samagotchi 0.126.0 → 0.127.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2704d1d3f6cb8fa560e7f903ac58ac12d468fcd006b2a8782dcea02aede223a8
-  data.tar.gz: 49f91663fa29e4f77b41dae067efe8bba85917eef2682f1911af7ed7225db8fd
+  metadata.gz: d35df5e2cd9639c1da812c221e1c256567df7e2f9986df32c6cbc49cc9d6d431
+  data.tar.gz: 7e98badd5615015b9841a9885404c130ff46fddefd05dc70bafd051ae37f92ef
 SHA512:
-  metadata.gz: 0f2ed298f6d733e3f90e926b2124348c40fc119c934106d9661aa3fdb0cfd060535263516d31789ee5be3a043abe3a4c3c844754323d6bdf9e44e527587739b4
-  data.tar.gz: e3d1196a4881d05ae6fcc9f94700cc4e180a024b9d725de02baa42de3d46ae1b78146a8493aa5b42c707919476f410d23e059e9df24e3d9c1fa955362921afe3
+  metadata.gz: 3f5eaf2d9dca71dd6951989506b64c67ce905396c3af824521aa6fcc8e974d7a4f7ca6843f307f9915b5b5986b3ab87e2707ca76a771e985fa095a99acf9cedf
+  data.tar.gz: 65b7f35bcd7372d6c51a438c3808937266b035e8e67ac6c48511734d00f78ac12b9de3536359c67ad8797a4dc542e16a04649ece8d0dc7e8e729e6b7f60dd0a2

data/CHANGELOG.md

@@ -7,6 +7,30 @@ and commands may change between minor versions. How releases are made:
 [docs/releasing.md](docs/releasing.md).
 ## [Unreleased]
 
+## [0.127.0] - 2026-10-28
+
+### Added
+
+- chi web's header project chip opens a picker to switch projects without starting chi web in each one.
+
+### Changed
+
+- A participant's comment box sits in the same glass card as the owner's composer: the key hint above the text field,
+  their usage as the card's footer and the grip on its top edge; folded, the card keeps the usage line.
+
+### Fixed
+
+- A new invite link opens in a browser that still holds an ended link's cookie (behind an auth proxy it showed
+  'revoked').
+- A Verify verdict push names an owner's verdict "You" when its author is empty or the owner's mark, not "A
+  participant", on the phone and in the tab alike.
+- A Verify fresh check's system prompt carries no participants line when the owner asked for it, and its
+  requester's own (review or pair) when a participant did, instead of the parent session's.
+- A Verify turn that fails fast and comes back into chi web's composer keeps its claim, so sending it again still
+  puts a verdict card on the claim.
+
+Update with `chi update`, then restart `chi web` and the session workers (`chi sessions restart`).
+
 ## [0.126.0] - 2026-10-27
 
 ### Added
@@ -4763,7 +4787,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.126.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.127.0...HEAD
+[0.127.0]: https://github.com/dm1try/samagotchi/compare/v0.126.0...v0.127.0
 [0.126.0]: https://github.com/dm1try/samagotchi/compare/v0.125.0...v0.126.0
 [0.125.0]: https://github.com/dm1try/samagotchi/compare/v0.124.0...v0.125.0
 [0.124.0]: https://github.com/dm1try/samagotchi/compare/v0.123.0...v0.124.0

data/docs/architecture.md

@@ -615,6 +615,7 @@ model: [internals/remote-sessions.md](internals/remote-sessions.md).
 |---|---|---|---|---|
 | `GET /api/sessions/resolve?id=` | owner | an id or a unique prefix | 200 `{id}` | 404 `not_found`; 400 `ambiguous_id` with `ids` |
 | `GET /api/sessions/summaries` | owner | `dir` (a folder: its project; none: every project), `cwd`, `live=1`, `archived=1`, `tests=0`, `sort`, `order`, `limit` | 200: the rows `chi sessions list` prints (`SessionManager.session_summaries`: `status`, `live`, `busy`, `owner`, `recap`, `ctx_pct`, `waiting`, `waiting_id`, `title`, `preview`, …) | 400 `invalid_dir`, `invalid_cwd` |
+| `GET /api/projects?dir=` | owner | optional page-scope folder | 200: project rows with counts, roots, default/current marks; no `dir`: no current project | 400 `invalid_dir`; 503 `no_hub` |
 | `POST /api/sessions` (more fields) | owner | `toolkit`, `tools`, `no_tools`, `parent_answers`; `client_id` (`cli:send`/`cli:answer`: the first line is checked as chi send checks it); `check_vision: true` (images follow) | 201 adds `model_warning`, `parent_answers_warning` (a level looser than config.yml's, capped) and `first_turn_id` (the id the prompt it starts with gets for its turn; null for an `idle` create) | 400 `invalid_toolkit`, `invalid_parent_answers`, `invalid_continues` (beside `continues`); 403 `parent_answers_refused`, `parent_continue_refused`; 422 `no_vision` |
 | `POST /api/sessions/:id/turn` (more fields) | owner | `client_id` as above; `check_vision: true` with `images` | as before | 403 `parent_answers_refused`, `parent_continue_refused`; 422 `no_vision` |
 | `POST /api/sessions/:id/wait/prepare` | owner | `question_id` (absent: the pending one; `null`: none), `turn`, `created`, `busy` (+ `queue`) | 200 `{session_id, cursor, baseline: {messages, question_id, last_turn}, own_turn, known_turn, running, live, settled, last_turn_id}` (`WaitStart`) | 409 `busy`, `waiting` (`SendCommand::Busy`'s words, and its fields: `question`, `parent_strategy`) |

data/docs/cli.md

@@ -13,7 +13,7 @@
 - A session id can be shortened to any unique prefix (like git): `chi --attach 2ea8`. `--resume`, `--attach`, `sessions stop`, `sessions archive` and `sessions delete` take one; an ambiguous prefix lists the sessions it matches.
 - `chi web [--port 4567] [--open] [--scope=all] [--start-dir DIR]` — start the Web UI (single localhost port session control plane) on this git project's sessions (`--scope=all`, or a folder in no repo: `/?scope=all`, every session); if a chi web already runs on the port, print (with `--open`, open) its page for this folder and exit. Something else on the port (an older chi web too) exits 1 with "port N is in use"
 - `chi web --web-host lan` — the Web UI on your home network too, for your phone: a link with an access token and its QR code (see [chi web on your phone](#chi-web-on-your-phone)); `chi web --new-token` replaces the token
-- `chi web --start-dir DIR` (config `web.start_dir`) — the folder chi web starts in, in place of the one you run it in (`~` and a relative path work; chi web never changes its own folder): its page opens on that folder's project (the printed link, a bare `/`, the LAN link and its QR code, the Home Screen app), and a new session from the all view starts there; `/?scope=all` (the header's `all`) is every project. One that isn't a folder exits 1; `--start-dir` without `web` exits 2. A chi web already running in another folder keeps it (the second one says so: restart it to change it)
+- `chi web --start-dir DIR` (config `web.start_dir`) — the folder chi web starts in, in place of the one you run it in (`~` and a relative path work; chi web never changes its own folder): its page opens on that folder's project (the printed link, a bare `/`, the LAN link and its QR code, the Home Screen app), and a new session from the all view starts there; the header's project chip switches projects. One that isn't a folder exits 1; `--start-dir` without `web` exits 2. A chi web already running in another folder keeps it (the second one says so: restart it to change it)
 - `chi web --tunnel tailscale` — the Web UI over https on your tailnet, for your phone anywhere: Tailscale Serve (never Funnel) on this machine's `<machine>.<tailnet>.ts.net` name for this run, the owner your Tailscale login, turned off on exit (see [Tailscale Serve](configuration.md#tailscale-serve-your-tailnet)); `--tunnel` without `web` exits 2
 - `chi web push ls [--format json]`, `chi web push rm ID`, `chi web push test [ID]` — the phones chi web pushes to (see [Phone notifications](configuration.md#phone-notifications-web-push)): list them (short id, label, origin, added, last delivery, done turns, last error; `stale` for one made on another public URL than chi web's now: never sent to), remove one, or send a test notification to ID or to every device not stale. chi web need not run; nothing printed holds a device's push address or keys. A usage error exits 2; a store others can read, a corrupt one, an unknown device or a failed test push exit 1. This machine only: `chi --remote X web push` exits 2
 - `chi web --web-markdown` — opt in to sanitized Markdown rendering for completed assistant messages, the stage's asking text and a resolved question card's reply

data/docs/configuration.md

@@ -1893,7 +1893,7 @@ What it needs:
 
 Turning it on, on the phone: open the `Proxied:` link in Safari → Share → **Add to Home Screen** → open the **Chi**
 app → tap the **bell** at the top → turn on **This device** in the sheet → Allow. A test notification arrives at once.
-The app opens on the project chi web starts in (`web.start_dir`; the header's `all` shows every project), but its
+The app opens on the project chi web starts in (`web.start_dir`; the header's project picker switches projects), but its
 notifications are every project's: opening it closes the ones whose question or card is no longer open and sets its
 badge for every project, whichever project the page shows.
 In a browser tab the bell stays the tab's own notifications (while the tab is in the background), as before.
@@ -2077,7 +2077,7 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `web.working_set` | `true` | yes | The stage view's working set: the files, memories and URLs a turn brought into the model's context, in a rail in the stage, a footprint line under each finished turn and a `set N` chip in place of the mem chip; `false` brings the mem chip back. `?working_set=1` or `?working_set=0` on the page URL overrides it for that page load; the turn view ignores it. See [CLI: the working set](cli.md#the-working-set). |
 | `web.annotate_presets` | `Agreed\|Could you please elaborate?` | yes | Quick replies next to Annotate in `chi web`, `\|`-separated (a YAML list works too); `""` in the file or on the CLI leaves only Annotate (an empty env value means the default). See [CLI](cli.md#web-annotate-presets). |
 | `web.editor` | `vscode` | yes | What a file ref in `chi web` (a file tool row's title, a diff line) opens, for a viewer on this machine: a preset (`vscode`, `vscode-insiders`, `cursor`, `zed`) or a URL template with `{path}` and an optional `{line}`; `none` turns refs off. See [Opening files from chi web](#opening-files-from-chi-web). |
-| `web.start_dir` | the folder `chi web` runs in | | The folder `chi web` starts in (`chi web --start-dir DIR` for one run): its page (the printed link, a bare `/`, the LAN link and QR code, the Home Screen app) opens on that folder's project, outside a repo on every session, and a new session from the all view starts there; `/?scope=all` is every project. `~` and a relative path (resolved from your home folder) work; one that isn't a folder stops `chi web` from starting. `chi web` never changes its own folder. See [CLI](cli.md). |
+| `web.start_dir` | the folder `chi web` runs in | | The folder `chi web` starts in (`chi web --start-dir DIR` for one run): its page (the printed link, a bare `/`, the LAN link and QR code, the Home Screen app) opens on that folder's project, outside a repo on every session, and a new session from the all view starts there; the header's project picker switches projects. `~` and a relative path (resolved from your home folder) work; one that isn't a folder stops `chi web` from starting. `chi web` never changes its own folder. See [CLI](cli.md). |
 | `web.participants.expires` | `7d` | | How long a participant's link lasts unless `chi share --expires` says otherwise: `Nh` or `Nd`, 1h to 30d. See [participants](internals/participants.md). |
 | `web.participants.cap` | `2.0` | | What a participant's turns, and the side calls they cause, may cost you in dollars unless `chi share --cap` says otherwise ($0 to $1000); at the cap their next comment is refused (429 `cap_reached`) and you get a notice. `chi share cap ID P DOLLARS` changes one grant's. |
 | `web.participants.queue` | `3` | | How many of a participant's turns may wait behind their running one (0 to 20); one more is refused (429 `too_many_turns`). |

data/docs/internals/participants.md

@@ -35,7 +35,8 @@ participant** and **one role**, until it expires or is revoked.
   retention, or archived or deleted by a process that didn't revoke, is caught by the gate: a live grant whose session
   file is gone or archived is revoked on sight (`revoked_by: gone | archive`). Unarchiving doesn't restore a grant.
   An ended grant stays in the store for 30 days, so its token answers `token_revoked` / `token_expired` rather than a
-  bare 401; then it goes.
+  bare 401; then it goes. The ended and bound pages also trade a link's `#code=`, so a new invite opens even in a
+  browser still holding an ended grant's cookie.
 - **Store.** `$XDG_STATE_HOME/samagotchi/web-grants/grants.json`, next to `web-token`: the file 0600, in its own 0700
   folder, written whole (`AtomicFile`) under a lock file (`grants.lock`) since chi web and a local `chi share` both
   write it. Its `version` is 1, and 2 once a grant is bound (never lowered); a store above `Grants::MAX_VERSION` is a
@@ -358,10 +359,11 @@ fields: a field added to an event later reaches nobody until it is named there.
   reads. `queued` counts their own queued turns on the worker; `model` is the session's model as its host is sent it
   (the alias applied, no host name), live else saved, redacted. Every source reads the grant's own author: another
   participant's spend, the owner's and the session's totals never reach them (the red-team spec checks the body). The
-  owner's participant view has none. The page draws it as one line under the comment box (`usageItems`): "$0.42 of
+  owner's participant view has none. The page draws it as one line in the comment box card's footer
+  (`.composer-card-foot`, `usageItems`): "$0.42 of
   $2.00 cap · 1/3 queued · link: 6 d left · model", each with a title in words; warn colours from 80% of the cap, a
-  full queue and a link's last day, "over" at the cap. On a phone it is the only line under the box (the hint is
-  hidden there), cut at the end (the model first); folded, it goes with the hint. It is redrawn at each re-read (a
+  full queue and a link's last day, "over" at the cap. The key hint is the line above the text field (hidden on a
+  phone). The usage is cut at the end (the model first); folded, it stays as the card's footer under the grip. It is redrawn at each re-read (a
   turn's end, a queued or taken-back comment), not while a turn streams.
 - **A fork's note.** A review fork (`chi review --from`, `/coordinate review`) starts with a note holding the source's
   recap and, from the coordinator, its handoff's body: a participant's review turn reads it like the rest of the
@@ -416,7 +418,9 @@ fields: a field added to an event later reaches nobody until it is named there.
   participant's invite link** in their own browser swaps their owner cookie for that grant (the page asks first). A
   continue archives the session and revokes its grants: re-share, and links to the old session stay on it.
 - **Verify verdict cards** (`verdict_card.js`). The built-in Verify preset carries the selected source turn id and quote
-  with the submitted turn, without changing its prompt text. A completed Verify reply whose final non-empty line has
+  with the submitted turn, without changing its prompt text. A Verify turn that fails fast and is rolled back hands
+  the claim back with its prompt (`prompt_restored`'s `verify`), so the owner's resend from the composer is a Verify
+  turn again. A completed Verify reply whose final non-empty line has
   a valid `Verdict: confirmed|refuted|unclear — <reason>` appends a verdict to the session. Both pages place its card
   after the source turn, name its author, show the reason and quote, and link to the checking turn; a live completion
   adds the card without a reload. The participant view receives only the card fields through its allowlist, with the
@@ -483,7 +487,7 @@ fields: a field added to an event later reaches nobody until it is named there.
     for a fresh verdict yet (`Attention` pushes a verdict at a turn's end).
 - **The comment box** is the owner's composer (`composer_mount.js`, styled by the shared `composer.css`), mounted by
   `participant.js` with a subset on. It has: the height that grows with the text, the grip (drag to resize,
-  double-click resets, click or drag down folds it; folded, the grip is the handle on the dock's edge and typing on the
+  double-click resets, click or drag down folds it; folded, the grip is the handle on the card's top edge and typing on the
   page opens it; Annotate opens it for the visit), the one-row layout of the owner's session composer (Send at its
   bottom right; a phone keeps it one row), and ↑/↓ over the participant's own comments: the ones the server took from
   this browser, in localStorage under `chi_review_history:<grant id>` (`review_history.js`; the grant id is the review
@@ -630,7 +634,9 @@ fixture loads and saves unchanged, `spec/turn_author_record_spec.rb`).
   worker's Engine at each turn's start), the system prompt's volatile tail opens with "Participants: people other
   than the owner review this session. …" (`SystemPrompt::PARTICIPANTS_LINE`), or in a working session with
   `PAIR_PARTICIPANTS_LINE`, which names the pair header (and the review one, for turns stamped before). It comes
-  when the first joins and goes when the last leaves or expires.
+  when the first joins and goes when the last leaves or expires. A Verify fresh child reads its parent's
+  `participants.json` but has one participant at most: its requester, under their saved mode while their grant is
+  active; the owner's child has no line (`SessionParticipants#prompt_mode`).
 - **Records.** `last_turn.author`, the analytics turn record's `author`, `turn_enqueued`'s `author`, and the
   Bridge's queued rows. `turn_started` carries `author`, `author_name` and `participant_mode` on a participant's turn
   (the owner's carries none), and so does the Bridge's turn snapshot and its replay. The owner's history

data/docs/sessions.md

@@ -91,10 +91,12 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 
 **Ordering:**
 
+- The web header's project chip opens a picker. The start project is the default row (including its start folder); other rows show their root, session and waiting counts. **All projects** opens every session, and choosing a project drops the open-session hash while keeping `?view=`.
+
 - `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 sessions start in that folder; the header chip says `<project> · all`, and `all` opens the same place as `?scope=all` (every session; a new session there starts in chi web's start folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the start folder's project). A bare `/` (the LAN link, the Home Screen app) is the start folder's project too: the folder chi web runs in, or `web.start_dir` / `chi web --start-dir DIR`; outside a repo it shows every session. A pushed notification opens its session in that session's own project (`/?dir=<its project>#/s/<id>`; `?scope=all` outside a repo). 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, and the grip on the chat's top edge — the same thin handle as the composer's, its twin — puts them away and brings them back: a drag up (or a click, or Enter/Space on it) hides them, a drag down (or a click) shows them again, and the choice is remembered. A hidden strip leaves its status in the top bar (`N sessions · ● 1 live · ● 1 waiting`, from the cards), and a click on that pill opens All sessions, without showing the strip first. In a window under 900 px wide, where the strip scrolls sideways, the grip stays under it, outside the scroller; a window under 700 px tall hides the strip by itself, so a question or approval card in the stage keeps room, and the grip shows it 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 session. 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 plugin's refs on an answer (an `after_turn` hook's, see [Refs on the answer](hooks.md#refs-on-the-answer-display-only)) are paired with its links and text whatever the rows touched: they can link a file the session didn't touch, or an issue or a commit, and add their own actions to the ref's menu. A plugin tool's row carries the refs its `refs:` gives (see [Refs on a tool's row](plugins.md#refs-on-a-tools-row)): its title opens the first, and its `▾` menu adds the others as `<ref> · <action>` (the URL on hover); their URL actions work on a phone too. 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)`); after a `/model` switch the info bar's tooltip adds a `per model:` row per run of turns on one model above those totals (`splash:qwen3-35b · 6 turns · 96.0k in / 9.0k out · ~$0.02`, a switch's prefill under its row: `└ switch prefill 58.0k uncached prompt ≈$0.01`; the timing's `model_segments`, replaced by each `generation_completed`'s; the session cards stay as they were), and right after the switch its ctx % is the new model's window's; 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 session starts on, and a fresh chain link's (see [Session chains](#session-chains); there a pick shows as a `/model` command bubble in the link); 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 session 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; the chip and rows as lit-html templates), `keep_focus.js` (lit reuses a list's nodes by position: a redraw keeps the focus on the same item by its `data-id` / `data-name`), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `#N` chip and rows as lit-html templates, the info bar's ← → links, a refused continue, and the fresh-link rule), `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), `bubbles.js` (the history's bubbles between the turns' rows: output chunks, end lines, every client's prompt bubbles by `enqueued_id` with their queued/steered badges, the idle recap, guardrail warnings, hooks' notices, plugins' steers, command and note bubbles; lit-html templates, put in the history with the sticky follow by `createBubbles`), `cards_place.js` (where plugin cards and a snapshot's notices go in the history: a card added or updated in place by its id, a running turn's into its step, a snapshot's each above the first turn after it, a finished turn's notice in its step's rows and its question resolved where it was asked; a card's action buttons), `format.js` (pure formatters such as `previewOf`), `plain_line.js` (markdown out of the plain one-line places: the stage headline, a closed step's title, an answered question card's kept-reply line), `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), `delivery_line.js` (the composer's row above the text field in a session, always there so the composer keeps its height: the key hint while idle, and the delivery line while a turn runs: where a message typed now goes in, from the step's phase, clock and size, whether "cut in now" can land, and the queue link for a worker with the `delivery` feature, as a pure `deliveryLine`, its lit-html template and `createDeliveryControl`, which ticks it and keeps a choice armed from a link; see docs/cli.md, "Typing during a turn"), `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), `stage_view.js` (the stage view: the running turn pinned above the composer, then handed off into the history; its pure rules and texts in `stage_model.js`, its live slots (headline, now row, trail, ticks) in `stage_slots.js`, its cap and held height in `stage_frame.js`, the in-use watch that times the hand-off in `stage_watch.js`), `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), `info_bar_model.js` (that model and the bar's buttons' states, built from the page's session state, its list and its in-flight continues and restarts as pure functions; `app.js`'s `updateInfoBar` applies them every second while a turn runs), `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, a plugin's ref data (label, http(s) URL actions) bound in a WeakMap by `bindRef`, 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), `ref_scan.js` (the `path:line` refs in an answer's or a step's text that name a file the session's rows touched), `answer_refs.js` (the refs a plugin attached to an answer, its `display_refs`: bound to the answer's bubble, paired with its links and text, bound with `bindRef`), `markdown_place.js` (where rendered markdown and its refs go: a text as markdown HTML, its `path:line` refs, a final answer's rendering), `images.js` (image chips in the composer: paste, drop and the image button, the upload before a turn, the thumbnails and the lightbox), `composer_grip.js` (the composer's grip and fold: the drag, tap and keys, the fold per visit), `composer_mount.js` (the composer mounted on a page's markup: the message box and its height, the image chips from a paste, a drop or the image button, the grip and fold, ↑/↓ over the prompt history and the keys; the page's own parts come in as hooks: what Enter and Send do, keys taken first, Esc, where the history comes from, the info bar's Stop turn and drop while folded, typing anywhere to open it; its styles are the shared `composer.css`, linked after `tokens.css` by `index.html` and `participant.html`), `strip_grip.js` (the latest-sessions strip's grip, the composer grip's twin: hides and shows the strip), `review_history.js` (a participant's ↑/↓ list on the participant page: their own comments, in localStorage per grant, never the owner's `/api/history`; `participant.js` mounts `composer_mount.js` with it, no `/` list, no delivery choices, images off), `storage.js` (the page's per-browser choices in localStorage, guarded: a choice that can't be read or written is not remembered), `unqueue.js` (the × on a message queued for after the turn: takes it back, its text into an empty composer or a toast), `toasts.js` (the page's toast stack: a timer each, sticky ones until acted on, the same text reusing its item), `toast_place.js` (where the toast sits: above the composer card, the stage and an open model panel), `dock_reserve.js` (what floats over the history: the history's bottom reserve (`--dock-h`) at the composer card's and the showing stage's height, a reader at the end kept there, and the toast's place measured for `toast_place.js`), `notice_links.js` (a hook notice line's http(s) URLs as links), `start_page.js` (the start page's model picker and its LLM context and thinking chips, a choice for the next new session only; a fresh chain link's picker and its `/model`), `session_actions.js` (Continue, Archive and its Undo, Delete and Stop, and the start page when the open session is gone), `send_turn.js` (the composer's send: a new session first on the start page, the route, the echo, the image upload, the `/turn` ack, a fast failure's restore and each error's place). Unit-tested via `npm 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; the chip and rows as lit-html templates), `keep_focus.js` (lit reuses a list's nodes by position: a redraw keeps the focus on the same item by its `data-id` / `data-name`), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `#N` chip and rows as lit-html templates, the info bar's ← → links, a refused continue, and the fresh-link rule), `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), `bubbles.js` (the history's bubbles between the turns' rows: output chunks, end lines, every client's prompt bubbles by `enqueued_id` with their queued/steered badges, the idle recap, guardrail warnings, hooks' notices, plugins' steers, command and note bubbles; lit-html templates, put in the history with the sticky follow by `createBubbles`), `cards_place.js` (where plugin cards and a snapshot's notices go in the history: a card added or updated in place by its id, a running turn's into its step, a snapshot's each above the first turn after it, a finished turn's notice in its step's rows and its question resolved where it was asked; a card's action buttons), `format.js` (pure formatters such as `previewOf`), `plain_line.js` (markdown out of the plain one-line places: the stage headline, a closed step's title, an answered question card's kept-reply line), `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), `delivery_line.js` (the composer's row above the text field in a session, always there so the composer keeps its height: the key hint while idle, and the delivery line while a turn runs: where a message typed now goes in, from the step's phase, clock and size, whether "cut in now" can land, and the queue link for a worker with the `delivery` feature, as a pure `deliveryLine`, its lit-html template and `createDeliveryControl`, which ticks it and keeps a choice armed from a link; see docs/cli.md, "Typing during a turn"), `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), `stage_view.js` (the stage view: the running turn pinned above the composer, then handed off into the history; its pure rules and texts in `stage_model.js`, its live slots (headline, now row, trail, ticks) in `stage_slots.js`, its cap and held height in `stage_frame.js`, the in-use watch that times the hand-off in `stage_watch.js`), `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), `info_bar_model.js` (that model and the bar's buttons' states, built from the page's session state, its list and its in-flight continues and restarts as pure functions; `app.js`'s `updateInfoBar` applies them every second while a turn runs), `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, a plugin's ref data (label, http(s) URL actions) bound in a WeakMap by `bindRef`, 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), `ref_scan.js` (the `path:line` refs in an answer's or a step's text that name a file the session's rows touched), `answer_refs.js` (the refs a plugin attached to an answer, its `display_refs`: bound to the answer's bubble, paired with its links and text, bound with `bindRef`), `markdown_place.js` (where rendered markdown and its refs go: a text as markdown HTML, its `path:line` refs, a final answer's rendering), `images.js` (image chips in the composer: paste, drop and the image button, the upload before a turn, the thumbnails and the lightbox), `composer_grip.js` (the composer's grip and fold: the drag, tap and keys, the fold per visit), `composer_mount.js` (the composer mounted on a page's markup: the message box and its height, the image chips from a paste, a drop or the image button, the grip and fold, ↑/↓ over the prompt history and the keys; the page's own parts come in as hooks: what Enter and Send do, keys taken first, Esc, where the history comes from, the info bar's Stop turn and drop while folded, typing anywhere to open it; its styles, the card it sits in (`.composer-card`, its footer and its line above the text field) included, are the shared `composer.css`, linked after `tokens.css` by `index.html` and `participant.html`), `strip_grip.js` (the latest-sessions strip's grip, the composer grip's twin: hides and shows the strip), `review_history.js` (a participant's ↑/↓ list on the participant page: their own comments, in localStorage per grant, never the owner's `/api/history`; `participant.js` mounts `composer_mount.js` with it, no `/` list, no delivery choices, images off), `storage.js` (the page's per-browser choices in localStorage, guarded: a choice that can't be read or written is not remembered), `unqueue.js` (the × on a message queued for after the turn: takes it back, its text into an empty composer or a toast), `toasts.js` (the page's toast stack: a timer each, sticky ones until acted on, the same text reusing its item), `toast_place.js` (where the toast sits: above the composer card, the stage and an open model panel), `dock_reserve.js` (what floats over the history: the history's bottom reserve (`--dock-h`) at the composer card's and the showing stage's height, a reader at the end kept there, and the toast's place measured for `toast_place.js`), `notice_links.js` (a hook notice line's http(s) URLs as links), `start_page.js` (the start page's model picker and its LLM context and thinking chips, a choice for the next new session only; a fresh chain link's picker and its `/model`), `session_actions.js` (Continue, Archive and its Undo, Delete and Stop, and the start page when the open session is gone), `send_turn.js` (the composer's send: a new session first on the start page, the route, the echo, the image upload, the `/turn` ack, a fast failure's restore and each error's place). Unit-tested via `npm 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).
 - The web session page's message box folds away for room to read. Drag the grip on its top edge (the pill that shows on hover; always on a phone) down, past the box by 32 px: the pill turns accent while releasing would hide it, and on release the box folds and the info bar stays as the page's bottom edge. The grip stays as a handle on the info bar's top edge, drawn always: pull it up (8 px opens it, and the box follows the pointer in the same gesture), click or tap it (opens it and focuses the box), or just type on the page (the key lands in the box) to bring it back; Enter or Space on the focused grip folds or opens too. A draft (text or images, which folding never clears) colours the handle with the accent, a session waiting on you with the attention colour; its tooltip says so. Stop turn moves into the info bar while it is folded. The fold is remembered per browser (`chi_composer_collapsed`), an archived session opens folded for the visit, and opening it there, like the page opening it itself (a restored line, a quote, continue →'s opener), is for that visit only. The fold keeps the height the grip set (`chi_composer_floor`): the box opens again at the height it had, and only a double-click on the grip forgets it. That height never takes more than half of the window the box is drawn in: a floor saved in a bigger window is held to that half in a smaller one (a rotated phone, a resized window, another device on the same origin), and the saved floor itself stays, so the height comes back when the room does. A click on the expanded grip hides the box as well: it folds 250 ms after the press, so a second click inside that window is read as a double-click and resets the height instead (a drag, Enter or Space act at once, and a drag after a click takes the wait back). The start page's grip only resizes.
 

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

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

data/lib/samagotchi/session_participants.rb

@@ -54,16 +54,29 @@ module Samagotchi
     # The system prompt's participants line while anyone is in it (#active?
     # as of the last #refresh!): ParticipantMode::PAIR when +session+ is a
     # working session and an active participant was invited to act, else
-    # ParticipantMode::REVIEW; nil with nobody active.
+    # ParticipantMode::REVIEW; nil with nobody active. A Verify fresh
+    # child reads its parent's sidecar but has one participant at most, its
+    # requester: their saved mode while their grant is active, nil for the
+    # owner's child (no participant ever writes in it).
     def prompt_mode(session)
       active = @entries.select { |entry| entry.active?(@clock.call) }
       return nil if active.empty?
 
+      fresh = session.respond_to?(:verify_fresh) && session.verify_fresh
+      return fresh_prompt_mode(fresh, active) if fresh
+
       active.any? { |entry| ParticipantMode.for_turn(session, entry) == ParticipantMode::PAIR } ? ParticipantMode::PAIR : ParticipantMode::REVIEW
     end
 
     private
 
+    def fresh_prompt_mode(fresh, active)
+      return nil unless fresh.participant?
+
+      id = Steer.participant_id(fresh.author)
+      active.any? { |entry| entry.id == id } ? fresh.turn_mode : nil
+    end
+
     def source_id(session)
       return nil unless session
 

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -60,6 +60,7 @@ require_relative "editor"
 require_relative "../message_parts"
 require_relative "../launch_mode"
 require_relative "session_summary"
+require_relative "project_list"
 require_relative "session_access_routes"
 require_relative "principal"
 require_relative "participant_access"
@@ -240,6 +241,7 @@ module Samagotchi
       ROUTES = [
         ["GET", %r{\A/(?:index\.html)?\z}, :serve_index, :participant],
         ["GET", %r{\A/api/sessions\z}, :handle_list, :owner],
+        ["GET", %r{\A/api/projects\z}, :handle_projects, :owner],
         ["POST", %r{\A/api/sessions\z}, :handle_create, :owner],
         ["GET", %r{\A/api/sessions/resolve\z}, :handle_resolve, :participant],
         ["GET", %r{\A/api/sessions/summaries\z}, :handle_summaries, :owner],
@@ -1046,6 +1048,16 @@ module Samagotchi
         [200, headers, [body]]
       end
 
+      def handle_projects(req)
+        return error_response(503, "no_hub", "this chi web has no session hub") unless @hub
+
+        dir, error = scope_dir(req.params["dir"])
+        return error if error
+
+        current_root = dir && ProjectScope.root_for(dir)
+        json_response(200, ProjectList.build(@hub.snapshot, start_dir: start_dir, current_root: current_root))
+      end
+
       # A scope folder from the page: [dir, nil] (dir nil when none was
       # given), or [nil, a 400 response] when it isn't an existing absolute
       # folder (a bookmarked worktree deleted since, a typo).

data/lib/samagotchi/web/participant_access.rb

@@ -490,7 +490,22 @@ module Samagotchi
         <style>#{PAGE_STYLE}</style></head>
         <body>
         <h1>chi</h1>
-        <p>{sentence}</p>
+        <p id="ended">{sentence}</p>
+        <script>
+          if (/[#&]code=/.test(location.hash)) document.getElementById("ended").hidden = true;
+        </script>
+        <p id="trade" hidden></p>
+        <script type="module">
+          const ended = document.getElementById("ended");
+          import("/token_fragment.js").then(({ tradeFragmentCode }) => tradeFragmentCode({
+            onRefused: (words) => {
+              const line = document.getElementById("trade");
+              line.textContent = words;
+              line.hidden = false;
+              ended.hidden = false;
+            }
+          })).catch(() => { ended.hidden = false; });
+        </script>
         </body></html>
       HTML
       BOUND_PAGE = ENDED_PAGE.sub("<title>chi: review link ended</title>", "<title>chi: review link for another account</title>")

data/lib/samagotchi/web/project_list.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../paths"
+require_relative "../project_scope"
+require_relative "push/attention"
+
+module Samagotchi
+  module Web
+    # Projects represented by the session hub, plus the start project even
+    # when it has no sessions.
+    module ProjectList
+      module_function
+
+      def build(summaries, start_dir:, current_root:)
+        start_dir = File.expand_path(start_dir.to_s)
+        default_root = ProjectScope.root_for(start_dir)
+        groups = {}
+        summaries.each do |summary|
+          next unless summary.is_a?(Hash) && !summary[:archived]
+
+          root = summary[:project_root]
+          next unless valid_root?(root)
+
+          (groups[root] ||= []) << summary
+        end
+        groups[default_root] ||= [] if valid_root?(default_root)
+
+        rows = groups.map do |root, sessions|
+          default = root == default_root
+          {
+            name: File.basename(root),
+            root: root,
+            root_label: Paths.tilde(root),
+            dir: default ? start_dir : root,
+            sessions: sessions.size,
+            waiting: sessions.count { |summary| Push::Attention.waits?(summary) },
+            updated_at: sessions.map { |summary| summary[:updated_at] }.compact.max_by(&:to_s),
+            default: default,
+            current: root == current_root
+          }
+        end
+        defaults, others = rows.partition { |row| row[:default] }
+        defaults + others.sort_by { |row| [row[:updated_at].to_s, row[:root]] }.reverse
+      end
+
+      def valid_root?(root)
+        root && File.directory?(root) && ProjectScope.root_for(root) == root
+      end
+      private_class_method :valid_root?
+    end
+  end
+end

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

@@ -78,6 +78,7 @@ import {
   claimFromHash, ownerClaimHash, participantClaimLink, selectionClaim, showClaim, turnIdOf,
 } from "./claim_link.js";
 import { scopeDir, scopeTemplate } from "./scope.js";
+import { createProjectPicker } from "./project_picker.js";
 import { html, render } from "./vendor/lit-html.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { SHORT_WINDOW_QUERY, stripAutoHidden } from "./strip.js";
@@ -609,6 +610,11 @@ function renderScope() {
   updateSessionTitle();
 }
 
+createProjectPicker({
+  el: $("#scope"), scope, scopeError: () => scopeError, api,
+  where: () => ({ search: location.search }),
+});
+
 // The session lists (lists_view.js): the strip, all sessions, their cards,
 // select mode, the family and chain popovers.
 const lists = createListsView({
@@ -1604,6 +1610,7 @@ const streamHandlers = createStreamHandlers({
   participantsControl,
   placeApply,
   placeVerdict,
+  restoreVerify: (anchor) => { pendingVerifyAnchor = anchor; },
   sentIds,
   earlyRestores,
   stream: {
@@ -1711,6 +1718,7 @@ const sendTurnControl = createSendTurn({
   api: { createIdleSession, uploadImage, sendTurn },
   verify: () => pendingVerifyAnchor,
   clearVerify: (anchor) => { if (pendingVerifyAnchor === anchor) pendingVerifyAnchor = null; },
+  restoreVerify: (anchor) => { pendingVerifyAnchor = anchor; },
   dir: scope.dir,
   startPage,
   takeDelivery: () => deliveryControl.take(),

data/lib/samagotchi/web/public/composer.css

@@ -1,11 +1,22 @@
 /* The composer (composer_mount.js): the message box, its image chips, grip and fold, its key hint and its toolbar row
    (the image button, Send). Shared by the owner's page (index.html) and the participant page (participant.html);
    linked after tokens.css and before a page's own <style>, so a page's rules of the same weight win. The owner's
-   own parts stay in index.html: the card (#dock), the delivery line, Stop turn, the start page's picker and chips,
+   own parts stay in index.html: the card's placing (#dock), the delivery line's links, Stop turn, the start page's picker and chips,
    the / list, and the 16px text fields for iOS. */
 /* The image button's icon mask (the stroke only shapes the mask; the icon takes currentColor); index.html's phone info
    bar and all view's cards use it too. */
 :root{--icon-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='none' stroke='black' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Crect x='2' y='2.75' width='12' height='10.5' rx='1.5'/%3E%3Ccircle cx='5.75' cy='6.25' r='1.1'/%3E%3Cpath d='m2.5 12.5 3.75-3.75 2.5 2.5 1.75-1.75 3 3'/%3E%3C/svg%3E")}
+/* The composer card: the glass card both pages' composers sit in (the owner's #dock, the stage view's .dock-card, the
+   participant page's .p-card), with its focus ring; its footer (the owner's info bar, the participant's usage) under
+   a hairline; and the composer's line, the quiet row above the text field (the owner's delivery line, the
+   participant's key hint). A page's own rules only place the card. */
+.composer-card{display:flex;flex-direction:column;border-radius:16px;position:relative;background:var(--glass-bg);-webkit-backdrop-filter:blur(18px) saturate(1.35);backdrop-filter:blur(18px) saturate(1.35);border:1px solid var(--glass-border);box-shadow:inset 0 1px 0 var(--glass-highlight),var(--glass-shadow);transition:border-color .12s ease,box-shadow .12s ease}
+.composer-card:focus-within{border-color:color-mix(in srgb,var(--accent) 70%,transparent);box-shadow:0 0 0 3px var(--accent-ring),var(--glass-shadow)}
+@supports not ((backdrop-filter:blur(1px)) or (-webkit-backdrop-filter:blur(1px))){.composer-card{background:var(--bg-panel)}}
+@media (prefers-reduced-transparency:reduce){.composer-card{background:var(--bg-panel);-webkit-backdrop-filter:none;backdrop-filter:none}}
+body.no-glass .composer-card{background:var(--bg-panel);-webkit-backdrop-filter:none;backdrop-filter:none}
+.composer-card-foot{padding:8px 14px 10px;border-top:1px solid var(--glass-border)}
+.composer-line{flex:1 0 100%;min-width:0;height:20px;padding:0 2px;overflow:hidden;font-size:12px;line-height:18px;color:var(--text-muted);user-select:none}
 #composer{display:flex;flex-direction:column;gap:8px;padding:14px 14px 10px}
 #composer .compose-col{flex:1;display:flex;flex-direction:column;gap:6px;min-width:0}
 #composer.dropping{outline:2px dashed var(--accent);outline-offset:-4px}

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

@@ -22,7 +22,7 @@
 html{-webkit-text-size-adjust:100%;text-size-adjust:100%}
 body{font-family: ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;background:radial-gradient(1100px 700px at 8% 0%,color-mix(in srgb,var(--accent) 13%,transparent),transparent 70%),var(--bg);background-attachment:fixed;color:var(--text);height:100vh;display:flex;flex-direction:column}
 /* Glass: the composer card, the strip cards, the all-sessions cards and the question cards (by selector, so app.js is untouched). */
-#dock,.turn-stage,.dock-card,#topStrip .card,#allList .card,.bubble.question,.bubble.plugin-card{background:var(--glass-bg);-webkit-backdrop-filter:blur(18px) saturate(1.35);backdrop-filter:blur(18px) saturate(1.35);border:1px solid var(--glass-border);box-shadow:inset 0 1px 0 var(--glass-highlight),var(--glass-shadow)}
+.turn-stage,#topStrip .card,#allList .card,.bubble.question,.bubble.plugin-card{background:var(--glass-bg);-webkit-backdrop-filter:blur(18px) saturate(1.35);backdrop-filter:blur(18px) saturate(1.35);border:1px solid var(--glass-border);box-shadow:inset 0 1px 0 var(--glass-highlight),var(--glass-shadow)}
 #topStrip .card:hover,#allList .card:hover{background:color-mix(in srgb,var(--bg-hover) 75%,transparent);border-color:var(--card-hover-border)}
 #topStrip .card.active,#allList .card.active{background:color-mix(in srgb,var(--accent-bg) 75%,transparent);border-color:color-mix(in srgb,var(--accent) 35%,transparent)}
 /* A parent whose folded family holds the open session: a quieter mark than .active. */
@@ -30,9 +30,9 @@ body{font-family: ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetic
 /* A session that waits on the user (a question, an approval, a card with actions): the warning colour of its question card, also when active or hovered. */
 #topStrip .card.waiting,#allList .card.waiting{border-color:color-mix(in srgb,var(--warn) 75%,transparent)}
 #topStrip .card.waiting:hover,#allList .card.waiting:hover{border-color:var(--warn)}
-@supports not ((backdrop-filter:blur(1px)) or (-webkit-backdrop-filter:blur(1px))){#dock,.turn-stage,.dock-card,#topStrip .card,#allList .card,#allHead input{background:var(--bg-panel)}.bubble.question{background:color-mix(in srgb,var(--warn) 7%,var(--bg-panel))}.bubble.plugin-card{background:color-mix(in srgb,var(--accent) 6%,var(--bg-panel))}}
-@media (prefers-reduced-transparency:reduce){#dock,.turn-stage,.dock-card,#topStrip .card,#allList .card,#allHead input{background:var(--bg-panel);-webkit-backdrop-filter:none;backdrop-filter:none}.bubble.question{background:color-mix(in srgb,var(--warn) 7%,var(--bg-panel));-webkit-backdrop-filter:none;backdrop-filter:none}.bubble.plugin-card{background:color-mix(in srgb,var(--accent) 6%,var(--bg-panel));-webkit-backdrop-filter:none;backdrop-filter:none}}
-body.no-glass #dock,body.no-glass .turn-stage,body.no-glass .dock-card,body.no-glass #topStrip .card,body.no-glass #allList .card,body.no-glass #allHead input{background:var(--bg-panel);-webkit-backdrop-filter:none;backdrop-filter:none}
+@supports not ((backdrop-filter:blur(1px)) or (-webkit-backdrop-filter:blur(1px))){.turn-stage,#topStrip .card,#allList .card,#allHead input{background:var(--bg-panel)}.bubble.question{background:color-mix(in srgb,var(--warn) 7%,var(--bg-panel))}.bubble.plugin-card{background:color-mix(in srgb,var(--accent) 6%,var(--bg-panel))}}
+@media (prefers-reduced-transparency:reduce){.turn-stage,#topStrip .card,#allList .card,#allHead input{background:var(--bg-panel);-webkit-backdrop-filter:none;backdrop-filter:none}.bubble.question{background:color-mix(in srgb,var(--warn) 7%,var(--bg-panel));-webkit-backdrop-filter:none;backdrop-filter:none}.bubble.plugin-card{background:color-mix(in srgb,var(--accent) 6%,var(--bg-panel));-webkit-backdrop-filter:none;backdrop-filter:none}}
+body.no-glass .turn-stage,body.no-glass #topStrip .card,body.no-glass #allList .card,body.no-glass #allHead input{background:var(--bg-panel);-webkit-backdrop-filter:none;backdrop-filter:none}
 body.no-glass .bubble.question{background:color-mix(in srgb,var(--warn) 7%,var(--bg-panel));-webkit-backdrop-filter:none;backdrop-filter:none}
 body.no-glass .bubble.plugin-card{background:color-mix(in srgb,var(--accent) 6%,var(--bg-panel));-webkit-backdrop-filter:none;backdrop-filter:none}
 button,input,textarea,select{font:inherit}
@@ -566,8 +566,8 @@ button.system-one-wrong:hover:not(:disabled){background:var(--bg-hover);color:va
 .bubble.output.markdown .code-wrap>pre{margin:0}
 .code-wrap>.copy-btn{top:5px;right:5px}
 @media (hover:none){.copy-btn{opacity:.55}}
-/* The dock is the composer card: the text field, a toolbar row, the info bar as its footer. */
-#dock{display:flex;flex-direction:column;flex-shrink:0;margin:0 12px 12px;border-radius:16px;position:relative;transition:border-color .12s ease,box-shadow .12s ease}
+/* The dock is the composer card (composer.css .composer-card): the text field, a toolbar row, the info bar as its footer. */
+#dock{flex-shrink:0;margin:0 12px 12px}
 /* In a session the card floats over the history, so the glass blurs it; the history's bottom padding follows the card (--dock-h, set from dock_reserve.js). */
 /* The session panel lets the page's glow through (the history's own layers go clear), so the card and its footer read as glass over it, not as a flat box on black. */
 body.has-session #center{background:color-mix(in srgb,var(--bg) 35%,transparent);border-color:var(--glass-border);position:relative}
@@ -576,9 +576,8 @@ body.has-session #stage,body.has-session #history{background:transparent}
 body.no-glass.has-session #center{background:var(--bg);border-color:var(--border)}
 body.has-session #dock{position:absolute;left:16px;right:16px;bottom:16px;margin:0;z-index:3}
 body.has-session #history{padding-bottom:calc(var(--dock-h,160px) + 32px)}
-#dock:focus-within{border-color:color-mix(in srgb,var(--accent) 70%,transparent);box-shadow:0 0 0 3px var(--accent-ring),var(--glass-shadow)}
 /* The delivery line (delivery_line.js): a session's row above the text field, always there so the composer never changes height: the key hint while idle; while a turn runs, where a message typed now goes in, then the cut and queue links. One quiet row, ellipsised; a phone gets the short text and chips. */
-#deliveryLine{display:flex;align-items:center;gap:10px;min-width:0;flex:1 0 100%;height:20px;padding:0 2px;overflow:hidden;font-size:12px;line-height:18px;color:var(--text-muted);user-select:none}
+#deliveryLine{display:flex;align-items:center;gap:10px}
 #deliveryLine[hidden]{display:none}
 #deliveryLine .delivery-where{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 #deliveryLine .delivery-where.idle{color:var(--text-faint)}
@@ -672,8 +671,6 @@ body.has-session.fresh-link #composer .actions-col .model-pick:not([hidden]){dis
 /* D2: its own glass card above the composer card (as a section of one card the composer's focus ring wrapped the turn too):
    in the stage view #dock is a clear column holding the stage and .dock-card (the composer and its footer, stage_view.js). */
 body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;border:0;box-shadow:none;-webkit-backdrop-filter:none;backdrop-filter:none;gap:10px}
-.dock-card{display:flex;flex-direction:column;border-radius:16px;position:relative;transition:border-color .12s ease,box-shadow .12s ease}
-.dock-card:focus-within{border-color:color-mix(in srgb,var(--accent) 70%,transparent);box-shadow:0 0 0 3px var(--accent-ring),var(--glass-shadow)}
 /* The live slots' heights (headline, tool row, trail); --ts-live-h is their running height with the two 8 px gaps. */
 .turn-stage{--ts-head-h:42px;--ts-now-h:32px;--ts-trail-h:18px;--ts-live-h:calc(var(--ts-head-h) + var(--ts-now-h) + var(--ts-trail-h) + 16px)}
 .turn-stage{display:flex;flex-direction:column;min-height:0;max-height:var(--stage-max,60vh);border-left:3px solid var(--accent);border-radius:14px;overflow:hidden}
@@ -995,7 +992,7 @@ button.ws-row:hover:not(:disabled){filter:none;background:var(--bg-hover)}
   .ts-trail-item{max-width:24ch}
 }
 @media (prefers-reduced-motion:reduce){.turn-stage.enter,.ts-arrive,.ts-headline.fresh,.ts-tick.running,.ts-mark,.turn-work:not(.done) .activity-status.running::before{animation:none}.turn-stage.leaving,#center.reserve-easing #history{transition:none}}
-#infoBar{display:flex;padding:8px 14px 10px;border-top:1px solid var(--glass-border);background:transparent;border-radius:0 0 16px 16px;color:var(--text-2);gap:10px;align-items:flex-start;flex-wrap:wrap;flex-shrink:0;transition:opacity 280ms ease}
+#infoBar{display:flex;background:transparent;border-radius:0 0 16px 16px;color:var(--text-2);gap:10px;align-items:flex-start;flex-wrap:wrap;flex-shrink:0;transition:opacity 280ms ease}
 #infoBar.visible{display:flex}
 /* The meta row keeps its room: with a plain flex:1 the bar's own buttons (continue, archive, stop session, delete)
    shrink it to a narrow column in a small window and its items wrap into five lines. With a 640px basis they share
@@ -1268,13 +1265,35 @@ body.has-session #newBtn .brand-new{display:inline}
 /* The scope chip: "<project> · all", or "all projects" and where a new session starts (start page only). */
 #scope{display:inline-flex;align-items:center;gap:8px;min-width:0;font-size:12px;color:var(--text-muted)}
 #scope[hidden]{display:none}
-#scope .scope-name{flex-shrink:0;padding:2px 9px;border:1px solid var(--border-strong);border-radius:999px;color:var(--text-2);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:40vw}
+#scope .scope-name{display:inline-flex;align-items:center;flex-shrink:0;padding:2px 9px;border:1px solid var(--border-strong);border-radius:999px;background:transparent;color:var(--text-2);font:inherit;line-height:inherit;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:40vw;cursor:pointer;transition:none}
+#scope .scope-name:hover:not(:disabled){filter:none}
 #scope .scope-name.error{color:var(--warn-text);border-color:var(--warn-border)}
 #scope .scope-all{color:var(--text-muted);text-decoration:none}
 #scope .scope-all:hover{color:var(--accent);text-decoration:underline}
 #scope .scope-where{display:inline-flex;gap:5px;min-width:0;white-space:nowrap;font-size:11px}
 /* The path cuts on the left, so its last folders stay in view. */
 #scope .scope-where .path{overflow:hidden;text-overflow:ellipsis;direction:rtl;min-width:0;font-family:ui-monospace,monospace}
+#projectPicker{width:min(380px,calc(100vw - 32px))}
+.project-picker.sheet{border-radius:14px;padding:14px 16px}
+.project-picker .ctx-pop-head{display:flex;align-items:center;justify-content:space-between;gap:12px}
+.project-picker .ctx-pop-head strong{font-family:inherit}
+.project-list{display:flex;flex-direction:column;gap:6px;margin:2px 0;padding:0}
+.project-row{display:flex;align-items:center;gap:12px;padding:8px 10px;border:1px solid transparent;border-radius:9px;background:var(--bg-inset);color:var(--text);text-decoration:none}
+.project-row:hover{background:var(--bg-hover);color:var(--text-hover)}
+.project-row:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.project-row[aria-current="page"]{border-color:var(--accent-border);background:var(--accent-bg)}
+.project-main{display:flex;flex:1;align-items:center;gap:7px;min-width:0;flex-wrap:wrap}
+.project-name{font-weight:600;overflow-wrap:anywhere}
+.project-root{flex-basis:100%;min-width:0;color:var(--text-muted);font:11px ui-monospace,monospace;overflow-wrap:anywhere}
+.project-meta{display:flex;flex-shrink:0;align-items:center;gap:7px;color:var(--text-muted);font-size:11px;white-space:nowrap}
+.project-default{padding:1px 6px;border-radius:999px;background:var(--bg-raised);color:var(--text-muted);font-size:10px}
+.project-check{color:var(--accent);font-weight:700}
+.project-hint{flex-basis:100%;color:var(--text-muted);font-size:12px}
+/* The divider is its own hairline above the row: a border-top on the rounded row curved up at both ends. */
+.project-all{position:relative;margin-top:12px;background:transparent}
+.project-all::before{content:"";position:absolute;left:-1px;right:-1px;top:-9px;height:1px;background:var(--border);pointer-events:none}
+.project-note{padding:5px 2px;color:var(--text-muted);font-size:12px}
+.project-error{color:var(--warn-text)}
 body.has-session #scope .scope-where{display:none}
 /* A phone has no room for both; the hidden strip's pill (count, live) wins. */
 @media(max-width:600px){body.strip-hidden #scope .scope-where{display:none}}
@@ -1525,7 +1544,7 @@ body.all-view #center, body.all-view #topStrip{display:none}
 .card .dot.waiting,.family-row .dot.waiting{background:var(--warn);animation:attn-pulse 1.6s ease-in-out var(--pulse-delay,0s) infinite}
 @keyframes attn-pulse{0%,100%{box-shadow:0 0 0 0 color-mix(in srgb,var(--warn) 60%,transparent)}50%{box-shadow:0 0 0 4px color-mix(in srgb,var(--warn) 0%,transparent)}}
 @media (prefers-reduced-motion:reduce){.card .dot.running,.card .dot.waiting,.family-row .dot.running,.family-row .dot.waiting{animation:none}}
-.card .attn,.family-row .attn{font-size:11px;font-weight:600;padding:1px 7px;border-radius:999px;white-space:nowrap;flex-shrink:0;background:var(--warn-bg);color:var(--warn-text);border:1px solid var(--warn-border)}
+.card .attn,.family-row .attn,.project-picker .attn{font-size:11px;font-weight:600;padding:1px 7px;border-radius:999px;white-space:nowrap;flex-shrink:0;background:var(--warn-bg);color:var(--warn-text);border:1px solid var(--warn-border)}
 .card .stopped-badge,.family-row .stopped-badge{font-size:11px;font-weight:600;padding:1px 7px;border-radius:999px;white-space:nowrap;flex-shrink:0;background:var(--warn);color:var(--bg)}
 .status.running{background:var(--ok-bg);color:var(--ok-text)}
 .status.idle{background:var(--bg-raised)}
@@ -1569,7 +1588,7 @@ a{color:var(--accent)}
       <div id="notice" role="status" hidden></div>
     </div>
     <div id="lightbox" hidden><img alt=""></div>
-    <div id="dock">
+    <div id="dock" class="composer-card">
       <div id="initRow" role="status" aria-live="polite" hidden></div>
       <div id="composeGrip" class="edge-grip" tabindex="0" aria-label="Message box" title="Drag to make the message box taller (double-click resets)"></div>
       <div id="composer" style="position:relative">
@@ -1578,7 +1597,7 @@ a{color:var(--accent)}
           <label class="model-search"><svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><circle cx="7" cy="7" r="4.5"/><path d="M10.5 10.5 14 14" stroke-linecap="round"/></svg><input id="modelSearch" type="text" placeholder="Search models" autocomplete="off" spellcheck="false" role="combobox" aria-label="Search models" aria-autocomplete="list" aria-controls="modelList" aria-expanded="false"></label>
           <div id="modelList" role="listbox" aria-label="Models"></div>
         </div>
-        <div id="deliveryLine" aria-live="off" hidden></div>
+        <div id="deliveryLine" class="composer-line" aria-live="off" hidden></div>
         <div class="compose-col">
           <div id="chips" hidden></div>
           <textarea id="prompt" placeholder="Ask chi anything…" aria-controls="commandList" aria-autocomplete="list" aria-expanded="false"></textarea>
@@ -1597,7 +1616,7 @@ a{color:var(--accent)}
           </div>
         </div>
       </div>
-      <div id="infoBar">
+      <div id="infoBar" class="composer-card-foot">
         <div class="info" id="infoText"></div>
         <div id="contextChips" aria-label="Attached context" hidden></div>
         <button class="ghost" id="infoCancelBtn" title="Cancel the running turn, whoever sent it" style="display:none">Stop turn</button>

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

@@ -163,7 +163,9 @@ export function attentionText(session, attention) {
   const title = clip(name, 61);
   const seconds = Math.round(Number(session?.last_turn?.seconds) || 0);
   const verdict = session?.last_verdict;
-  const who = verdict?.by_name || (verdict?.by ? "A participant" : "You");
+  // An owner's verdict has no participant author (none, "" or "owner").
+  const byParticipant = !!verdict?.by && verdict.by !== "owner";
+  const who = verdict?.by_name || (byParticipant ? "A participant" : "You");
   const verdictReason = clip(String(verdict?.reason || ""), VERDICT_REASON_MAX);
   const verdictIcon = { confirmed: "✅", refuted: "❌", unclear: "❓" }[verdict?.verdict] || "";
   const verdictBody = `${who}: ${verdictIcon} ${verdict?.verdict || ""} — ${verdictReason}`;

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

@@ -105,42 +105,42 @@ main{flex:1;min-height:0;overflow-y:auto;padding:16px 16px 8px}
 .p-tool-one.error{color:var(--danger-text)}
 .p-tag{font-size:11px;padding:0 6px;border-radius:999px;background:var(--bg-raised);color:var(--text-3)}
 .p-waiting{align-self:flex-start;font-size:13px;color:var(--warn-text);background:var(--warn-bg);border:1px solid var(--warn-border);border-radius:999px;padding:3px 12px}
-.p-dock{border-top:1px solid var(--border);background:var(--bg-panel);padding:10px 16px calc(10px + env(safe-area-inset-bottom))}
+/* The dock is the owner's composer card (index.html's #dock): a glass card over the page's bottom edge, holding the
+   comment box (key hint, text field, usage footer); the queue and errors sit above it. */
+.p-dock{padding:6px 16px calc(16px + env(safe-area-inset-bottom))}
 .p-dock-in{max-width:760px;margin:0 auto;display:flex;flex-direction:column;gap:8px}
 .p-queue{display:flex;flex-direction:column;gap:4px;font-size:13px}
 .p-queued{display:flex;align-items:center;gap:8px;color:var(--text-3)}
 .p-queued span{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .p-queue-note{font-size:12.5px;color:var(--text-muted)}
 .p-error{font-size:13px;color:var(--danger-text);background:var(--danger-bg-dim);border-radius:8px;padding:6px 10px}
-/* The comment box: the shared composer (composer.css, composer_mount.js), as the owner's session composer lays it out
-   (participant.js sets body.has-session for a participant: one row, the text field and Send at its bottom right). Its
-   grip straddles the dock's top border; folded, the dock keeps the queue and the grip as the handle. No `/` list,
-   delivery line or model picker here. */
-#composer{background:var(--bg-inset);border:1px solid var(--border-strong);border-radius:12px}
-#composer:focus-within{border-color:var(--accent);box-shadow:0 0 0 3px var(--accent-ring)}
-body.has-session #composer{padding:6px 6px 6px 10px}
+/* The comment box: the shared composer in the shared card (composer.css, composer_mount.js), as the owner's session
+   composer lays it out (participant.js sets body.has-session for a participant): the key hint as the composer's line,
+   the text field and Send, the usage as the card's footer. Its grip sits on the card's top edge, as the owner's does;
+   folded, the card keeps its footer under the grip, the owner's info bar's way. No `/` list, delivery choices or model
+   picker here. */
 #composer textarea{font:inherit;line-height:1.45;padding:2px 0}
 #composer textarea:disabled{cursor:not-allowed}
 #composer .actions-col #send{height:30px;min-height:30px;line-height:30px;padding:0 16px;font-weight:600}
-.p-dock #composeGrip{margin:-15px 0 5px}
-body.composer-folded .p-hint{display:none}
-/* The participant's own usage (participant_model.js usageItems: the fields their grant's exposure shows), one line
-   beside the hint; a phone shows it alone, one line, the end cut. Folded, it goes with the hint. */
-.p-foot{display:flex;flex-wrap:wrap;align-items:baseline;gap:2px 14px;min-width:0}
-.p-foot .p-hint{flex:1 1 320px;min-width:0}
+/* The participant's own usage (participant_model.js usageItems: the fields their grant's exposure shows), one line in
+   the card's footer, the end cut. Folded, it stays under the grip. */
+.p-hint.composer-line{color:var(--text-faint);white-space:nowrap;text-overflow:ellipsis}
+.p-foot{min-width:0}
+.p-foot:has(> .p-usage[hidden]){display:none}
+/* Folded before the usage loads, the card keeps a footer's height under its grip, not a 2 px sliver. */
+body.composer-folded .p-foot:has(> .p-usage[hidden]){display:block;min-height:18px}
 .p-usage{display:flex;align-items:baseline;min-width:0;max-width:100%;font-size:12px;color:var(--text-muted);font-variant-numeric:tabular-nums;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 .p-usage span{flex:0 0 auto}
 .p-usage span+span::before{content:"·";padding:0 6px;color:var(--text-faint)}
 .p-usage span.model{flex:0 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis}
 .p-usage .warn{color:var(--warn-text)}
 .p-usage .over{color:var(--danger-text);font-weight:600}
-body.composer-folded .p-foot{display:none}
+body.composer-folded .p-foot{border-top-color:transparent}
 button{font:inherit;cursor:pointer;border-radius:8px;border:1px solid var(--border-strong);background:var(--bg-raised);color:var(--text);padding:6px 12px}
 button:hover{background:var(--bg-hover)}
 button.primary{background:var(--primary);border-color:var(--primary);color:var(--on-solid);height:42px;padding:0 18px}
 button.primary:disabled{opacity:.5;cursor:default}
 button.small{font-size:12px;padding:2px 8px}
-.p-hint{font-size:12px;color:var(--text-faint)}
 .p-ended{max-width:30rem;margin:18vh auto 0;padding:0 16px;text-align:center;display:flex;flex-direction:column;gap:10px}
 .p-ended h1{font-size:20px;color:var(--text-bright)}
 .p-ended p{color:var(--text-3)}
@@ -155,8 +155,6 @@ button.small{font-size:12px;padding:2px 8px}
 }
 /* Under 16px iOS Safari zooms the page on focus (and a Home Screen app never zooms back). */
 @media (max-width:600px),(pointer:coarse){#composer textarea{font-size:16px}}
-/* A phone's grip (composer.css: 26 px tall, the pill at 17 px): the pill on the dock's top border. */
-@media (max-width:600px){.p-dock #composeGrip{margin:-29px auto 3px}}
 </style>
 </head>
 <body>
@@ -185,25 +183,27 @@ button.small{font-size:12px;padding:2px 8px}
   <div class="p-thread" id="thread"></div>
 </main>
 <footer class="p-dock" id="dock" hidden>
-  <div id="composeGrip" class="edge-grip" tabindex="0" aria-label="Comment box" title="Drag to make the comment box taller (double-click resets)"></div>
   <div class="p-dock-in">
     <div class="p-queue" id="queue"></div>
     <div class="p-error" id="error" role="alert" hidden></div>
-    <div id="composer">
-      <div class="compose-col">
-        <div id="chips" hidden></div>
-        <textarea id="comment" rows="1" placeholder="Comment or ask" aria-label="Comment or ask"></textarea>
+    <div class="p-card composer-card">
+      <div id="composeGrip" class="edge-grip" tabindex="0" aria-label="Comment box" title="Drag to make the comment box taller (double-click resets)"></div>
+      <div id="composer">
+        <div class="p-hint composer-line" id="hint">⏎ sends, ⇧⏎ a new line, ↑ an earlier comment. The model answers in a read-only turn; the owner sees everything.</div>
+        <div class="compose-col">
+          <div id="chips" hidden></div>
+          <textarea id="comment" rows="1" placeholder="Comment or ask" aria-label="Comment or ask"></textarea>
+        </div>
+        <div class="actions-col">
+          <button type="button" id="attachBtn" class="attach-btn" title="Add images" aria-label="Add images" hidden></button>
+          <input type="file" id="attachInput" accept="image/*" multiple hidden>
+          <div class="split"><button type="button" class="primary" id="send">Send</button></div>
+        </div>
       </div>
-      <div class="actions-col">
-        <button type="button" id="attachBtn" class="attach-btn" title="Add images" aria-label="Add images" hidden></button>
-        <input type="file" id="attachInput" accept="image/*" multiple hidden>
-        <div class="split"><button type="button" class="primary" id="send">Send</button></div>
+      <div class="p-foot composer-card-foot">
+        <div class="p-usage" id="usage" aria-label="Your usage" hidden></div>
       </div>
     </div>
-    <div class="p-foot">
-      <div class="p-usage" id="usage" aria-label="Your usage" hidden></div>
-      <div class="p-hint" id="hint">⏎ sends, ⇧⏎ a new line, ↑ an earlier comment. The model answers in a read-only turn; the owner sees everything.</div>
-    </div>
   </div>
 </footer>
 </div>

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

@@ -234,6 +234,7 @@ function render() {
   const copy = modeCopy(viewer.mode);
   $("note").textContent = ownerView ? "" : copy.note;
   $("hint").textContent = `⏎ sends, ⇧⏎ a new line, ↑ an earlier comment. ${copy.hint}`;
+  $("hint").title = $("hint").textContent; // one line in the card: the whole text on hover
   $("head").hidden = false;
   $("main").hidden = false;
   renderPlan();

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

@@ -0,0 +1,115 @@
+// The project picker opened by the top-bar scope chip. The server supplies
+// the project roots and their current/default marks; links carry the view
+// without carrying a session hash into another project's list.
+
+import { html, nothing, render } from "./vendor/lit-html.js";
+import { allScopeHref, projectScopeHref } from "./scope.js";
+import { createChipPopover } from "./chip_popover.js";
+
+function homeHref(search) {
+  const view = new URLSearchParams(search || "").get("view");
+  return view ? `/?view=${encodeURIComponent(view)}` : "/";
+}
+
+function sessionCount(count) {
+  const n = Number(count) || 0;
+  return `${n} session${n === 1 ? "" : "s"}`;
+}
+
+function projectRow(row, search) {
+  return html`<a class=${`project-row${row.default ? " default" : ""}${row.current ? " current" : ""}`}
+    href=${row.default ? homeHref(search) : projectScopeHref(row.dir, "", search)}
+    aria-current=${row.current ? "page" : nothing}>
+    <span class="project-main"><span class="project-name">${row.name}</span
+      >${row.default ? html`<span class="project-default">default</span>` : nothing
+      }<span class="project-root">${row.root_label}</span></span>
+    <span class="project-meta">${Number(row.waiting) > 0 ? html`<span class="attn">${Number(row.waiting)} waiting</span>` : nothing
+      }<span class="project-count">${sessionCount(row.sessions)}</span>${row.current ? html`<span class="project-check" aria-hidden="true">✓</span>` : nothing}</span>
+  </a>`;
+}
+
+// +rows+ is the API's ordered list. When there is no project scope, the
+// all-projects row is current; a bad ?dir= has no current project to mark.
+export function pickerTemplate({ rows = [], loading = false, error = "", search = "", currentDir = null,
+                                 allCurrent = false } = {}) {
+  const allHref = allScopeHref("", currentDir, search);
+  return html`<div class="ctx-pop-head"><strong>Projects</strong><button type="button" class="ctx-pop-close"
+      data-act="close" aria-label="Close">×</button></div>
+    ${loading ? html`<div class="project-note" role="status">Loading projects…</div>` : nothing}
+    ${error ? html`<div class="project-note project-error" role="alert">${error}</div>` : nothing}
+    <nav class="project-list" aria-label="Projects">${rows.map((row) => projectRow(row, search))}
+      <a id="projectAll" class=${`project-row project-all${allCurrent ? " current" : ""}`}
+        href=${allHref} aria-current=${allCurrent ? "page" : nothing}>
+        <span class="project-main"><span class="project-name">All projects</span
+          ><span class="project-hint">Every session</span></span>
+        ${allCurrent ? html`<span class="project-check" aria-hidden="true">✓</span>` : nothing}
+      </a>
+    </nav>`;
+}
+
+// +scopeError+ returns the page's current folder error, if any. +where+
+// supplies the live query string so links retain ?view= without a hash.
+export function createProjectPicker({ el, scope, scopeError = () => null, api, where = () => ({ search: "" }),
+                                      doc = globalThis.document, win = globalThis.window }) {
+  let rows = [];
+  let loading = false;
+  let error = "";
+  let loads = 0;
+
+  const currentDir = () => scopeError() ? null : scope.dir || null;
+  const paint = (focus = false) => {
+    const failedScope = !!scopeError();
+    render(pickerTemplate({
+      rows, loading, error, search: where().search, currentDir: currentDir(),
+      allCurrent: !scope.dir && !failedScope,
+    }), shell.pop);
+    if (focus) {
+      const target = shell.pop.querySelector('.project-row[aria-current="page"]') ||
+        shell.pop.querySelector(".project-row");
+      target?.focus();
+    }
+  };
+
+  async function load(focus = false) {
+    const turn = ++loads;
+    loading = true;
+    error = "";
+    if (shell.isOpen()) {
+      paint();
+      shell.replace();
+    }
+    try {
+      // A dead ?dir (the folder-not-found chip) is left out: the list is the way out of it.
+      const dir = currentDir();
+      const answer = await api(`/api/projects${dir ? `?dir=${encodeURIComponent(dir)}` : ""}`);
+      if (!Array.isArray(answer)) throw new Error("the server returned an invalid project list");
+      if (turn !== loads) return;
+      rows = answer;
+    } catch (e) {
+      if (turn !== loads) return;
+      error = `Can't read projects: ${e?.message || e}`;
+      rows = [];
+    }
+    if (turn !== loads) return;
+    loading = false;
+    if (shell.isOpen()) {
+      paint(focus);
+      shell.replace();
+    }
+  }
+
+  const shell = createChipPopover({
+    id: "projectPicker", className: "ctx-popover project-picker", width: 380, el, anchor: "#scopePick",
+    summary: () => ({}), sheet: true, label: "Projects", doc, win,
+    show: () => {
+      rows = [];
+      loading = true;
+      error = "";
+      paint();
+      void load(true);
+    },
+    onClose: () => { loads += 1; },
+  });
+
+  return { pop: shell.pop, isOpen: shell.isOpen, load };
+}

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

@@ -7,18 +7,21 @@ import { clientLabel, isOwn, withImages } from "./turn_events.js";
 // What a prompt_restored (the worker rolled a failed turn back and handed its
 // prompt back) does in this tab: `refill` is the text for an empty composer,
 // only for a prompt this page sent (`sentIds`, its acks' enqueued_ids), so a
-// replay after a reload never refills stale text; `own`/`label` mark the
+// replay after a reload never refills stale text, with a Verify turn's claim
+// (`verify`) so a resend still records a verdict; `own`/`label` mark the
 // failed bubble shown again after the resync.
 export function restoreAction(event, { myId, sentIds, composerEmpty }) {
   const origin = event?.origin || {};
   const own = isOwn(origin.client_id, myId);
   const sent = own && !!origin.enqueued_id && sentIds.has(origin.enqueued_id);
-  // The images go back as chips with the text.
+  // The images go back as chips with the text, and its Verify claim.
+  const back = sent && composerEmpty;
   return withImages({
-    refill: sent && composerEmpty ? event.prompt : null,
+    refill: back ? event.prompt : null,
     own,
     label: own ? null : clientLabel(origin.client_id),
-  }, sent && composerEmpty ? event.images : null);
+    ...(back && event.verify ? { verify: event.verify } : {}),
+  }, back ? event.images : null);
 }
 
 // A turn that fails fast can have its prompt_restored come over the stream

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

@@ -49,24 +49,22 @@ export function cardFolder(workingDirectory, projectName) {
   return folder === projectName ? "" : folder;
 }
 
-// The header's scope chip: "<project> · all" in a project view (all links
-// to the same place without ?dir); "all projects" otherwise, with a link
-// back to the project it came from and where a new session starts on the
-// start page. +scope+: { dir, projectName, projectDir, serverDir, backDir,
-// backName }; +error+: why the ?dir= folder can't be shown; +where+:
-// () => { hash, search } (the page's location, read again at a click: the
-// links follow an open session or the all-sessions view).
+// The header's project chip opens the picker. The "all" link remains the
+// direct way to every session from a project view. +scope+: { dir,
+// projectName, projectDir, serverDir, backDir, backName }; +error+: why
+// the ?dir= folder can't be shown; +where+: () => { hash, search } (the
+// page's location, read again at a click).
 export function scopeTemplate(scope, { error = null, where = () => ({ hash: "", search: "" }) } = {}) {
   const at = where();
   const allHref = () => allScopeHref(where().hash, scope.dir, where().search);
   const all = html`<a class="scope-all" href=${allScopeHref(at.hash, scope.dir, at.search)} title=${"Sessions of every project"} @click=${(e) => { e.currentTarget.href = allHref(); }}>all</a>`;
-  if (error) return html`<span class="scope-name error" title=${error}>folder not found</span>${all}`;
-  if (scope.projectName) return html`<span class="scope-name" title=${`Sessions of ${scope.projectDir}`}>${scope.projectName}</span>${all}`;
+  if (error) return html`<button id="scopePick" class="scope-name error" type="button" aria-haspopup="dialog" title=${error}>folder not found</button>${all}`;
+  if (scope.projectName) return html`<button id="scopePick" class="scope-name" type="button" aria-haspopup="dialog" title=${`Sessions of ${scope.projectDir}`}>${scope.projectName}</button>${all}`;
   const dir = scope.dir || scope.serverDir;
   const backHref = () => projectScopeHref(scope.backDir, where().hash, where().search);
   const back = scope.backName
     ? html`<a class="scope-all scope-back" href=${projectScopeHref(scope.backDir, at.hash, at.search)} title=${`Sessions of ${scope.backName} only`} @click=${(e) => { e.currentTarget.href = backHref(); }}>← ${scope.backName}</a>`
     : nothing;
   const newSession = dir ? html`<span class="scope-where" title=${`New sessions start in ${dir}`}>new session in<span class="path"><bdi>${dir}</bdi></span></span>` : nothing;
-  return html`<span class="scope-name" title="Sessions of every project">all projects</span>${back}${newSession}`;
+  return html`<button id="scopePick" class="scope-name" type="button" aria-haspopup="dialog" title="Sessions of every project">all projects</button>${back}${newSession}`;
 }

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

@@ -29,7 +29,7 @@ import { composerAfterAck, dropEarlyRestores, restoreOnAck } from "./restore.js"
 // +alert+: the browser's.
 export function createSendTurn({
   session, state, running, clientId, sentIds, earlyRestores, api, dir, startPage, takeDelivery, composer,
-  verify = () => null, clearVerify = () => {},
+  verify = () => null, clearVerify = () => {}, restoreVerify = () => {},
   historyEl, turnDom, makeUserBubble, bubbleById, addCommandBubble,
   addCreatedSession, select, showNotice, updateInfoBar, updateComposerMode, followWokenWorker, refreshHistory,
   leaveGoneSession, runCommand, toast, alert = (text) => globalThis.alert(text),
@@ -158,6 +158,8 @@ export function createSendTurn({
       const restored = restoreOnAck(ack?.enqueued_id, earlyRestores, { myId: clientId, sentIds });
       // A restored line must be seen: the composer opens for this visit.
       if (restored?.refill && sentTo === session()) composer.openForVisit();
+      // Its Verify claim too, so the resend still records a verdict.
+      if (restored?.refill && restored.verify && sentTo === session()) restoreVerify(restored.verify);
       const before = promptEl.value;
       promptEl.value = composerAfterAck({ sent: line, current: before, refill: restored?.refill || "" });
       // A line back from sentTo is a draft of that session, wherever the page is now.

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

@@ -66,7 +66,7 @@ export function createStageView({
   // The dock becomes a clear column: the stage's card, then the composer's
   // (its rows moved into .dock-card, which wears the glass and the focus ring).
   document.body.classList.add("stage-view");
-  const card = node("div", "dock-card");
+  const card = node("div", "dock-card composer-card");
   card.append(...dockEl.children);
   dockEl.appendChild(card);
   const stage = node("section", "turn-stage");

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

@@ -26,6 +26,7 @@
 //                         guess (takeGuess: whether, and forget it); restart:
 //                         close the stream and resync
 //   composer: {empty(), refill(text), setChips(chips)}
+//   restoreVerify(anchor) a restored Verify turn's claim, armed again for its resend
 //   getSession(id, opts)  data.js
 //   resync(), updateInfoBar(), applyPromptOps(data), showSteers(steers),
 //   markRecapStale(), setTurnRunning(running), setLiveStatus(status),
@@ -244,8 +245,9 @@ export function createStreamHandlers(deps) {
     prompt_restored: async (data) => {
       const id = selected();
       keepEarlyRestore(data, earlyRestores, { myId: clientId, sentIds });
-      const { refill, label, images: restoredImages } = restoreAction(data, { myId: clientId, sentIds, composerEmpty: composer.empty() });
+      const { refill, label, images: restoredImages, verify } = restoreAction(data, { myId: clientId, sentIds, composerEmpty: composer.empty() });
       if (refill) composer.refill(refill);
+      if (refill && verify) deps.restoreVerify?.(verify);
       if (restoredImages?.length) composer.setChips(restoredChips(selected(), restoredImages));
       const failedText = liveTurn.failedText;
       liveTurn.failedText = null;

data/lib/samagotchi/web/push/attention.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../steer"
+
 module Samagotchi
   module Web
     module Push
@@ -118,15 +120,31 @@ module Samagotchi
         # @return [Array<String>]
         def open_keys(by_id)
           by_id.each_value.flat_map do |summary|
-            question = summary[:pending_question]
-            card = summary[:pending_card]
+            question = open_question(summary)
+            card = open_card(summary)
             keys = []
-            keys << key(summary[:id], question[:id]) if question.is_a?(Hash) && question[:id] && !question[:relayed_to]
-            keys << card_key(summary[:id], card[:id]) if card.is_a?(Hash) && card[:id]
+            keys << key(summary[:id], question[:id]) if question
+            keys << card_key(summary[:id], card[:id]) if card
             keys
           end
         end
 
+        # Whether this summary contributes to the project's waiting count:
+        # the same open question or card #open_keys badges.
+        def waits?(summary) = !!(open_question(summary) || open_card(summary))
+
+        # The summary's unanswered question not relayed elsewhere, or nil.
+        def open_question(summary)
+          question = summary[:pending_question]
+          question if question.is_a?(Hash) && question[:id] && !question[:relayed_to]
+        end
+
+        # The summary's pending card, or nil.
+        def open_card(summary)
+          card = summary[:pending_card]
+          card if card.is_a?(Hash) && card[:id]
+        end
+
         def key(session_id, id) = "#{session_id}:#{id}"
         def card_key(session_id, card_id) = "#{session_id}:card:#{card_id}"
 
@@ -151,7 +169,8 @@ module Samagotchi
           result = verdict[:verdict].to_s
           icon = { "confirmed" => "✅", "refuted" => "❌", "unclear" => "❓" }.fetch(result, "")
           by = verdict[:by_name]
-          by = verdict[:by].nil? ? "You" : "A participant" unless present?(by)
+          # An owner's verdict has no participant author (nil, "" or "owner").
+          by = Steer.participant_author?(verdict[:by]) ? "A participant" : "You" unless present?(by)
           reason = clip(verdict[:reason].to_s, 120)
           "#{by}: #{icon} #{result} — #{reason}"
         end

data/lib/samagotchi/worker.rb

@@ -697,7 +697,7 @@ module Samagotchi
                                    images: prompt.images, **(prompt.verify ? { verify: prompt.verify } : {})) do |result, error|
         if error
           # The Engine announced :turn_failed (with the error's one line).
-          restore_failed_turn([[prompt.text, origin, prompt.images], *@merged_this_turn], error: error)
+          restore_failed_turn([[prompt.text, origin, prompt.images, prompt.verify], *@merged_this_turn], error: error)
         else
           @continue_offer.after_turn(result, no_interrupt: prompt.no_interrupt)
         end
@@ -1383,8 +1383,10 @@ module Samagotchi
     # or the restored ones, never the one without the other. A turn that
     # got somewhere stays instead (TurnFlow#prompt_turn_failed), with the
     # prompts it took: nothing goes back.
-    # @param prompts [Array<Array(String, TurnOrigin|nil, Array|nil)>] [prompt,
-    #   origin, images] (a web client gets its image chips back)
+    # @param prompts [Array<Array(String, TurnOrigin|nil, Array|nil, VerifyAnchor|nil)>]
+    #   [prompt, origin, images, verify] (a web client gets its image chips
+    #   back, and a Verify turn's claim, so sending it again still records
+    #   a verdict)
     # @param error [Exception, nil] what failed: its one line stays in the
     #   conversation as a turn note
     # Not saved here: run_engine_turn saves after its block.
@@ -1392,9 +1394,10 @@ module Samagotchi
       @engine.synchronize_events do
         next if @turn_flow.prompt_turn_failed(error: error) == :kept
 
-        prompts.each do |prompt, origin, images|
+        prompts.each do |prompt, origin, images, verify|
           restored = { type: :prompt_restored, prompt: prompt, origin: origin.wire }
           restored[:images] = images unless Array(images).empty?
+          restored[:verify] = verify.to_h if verify
           @engine.announce(restored)
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.126.0
+  version: 0.127.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -752,6 +752,7 @@ files:
 - lib/samagotchi/web/participants_admin.rb
 - lib/samagotchi/web/principal.rb
 - lib/samagotchi/web/private_files.rb
+- lib/samagotchi/web/project_list.rb
 - lib/samagotchi/web/proxy_gate.rb
 - lib/samagotchi/web/public/activity.js
 - lib/samagotchi/web/public/annotate_actions.js
@@ -822,6 +823,7 @@ files:
 - lib/samagotchi/web/public/participant_names.js
 - lib/samagotchi/web/public/participants_panel.js
 - lib/samagotchi/web/public/plain_line.js
+- lib/samagotchi/web/public/project_picker.js
 - lib/samagotchi/web/public/prompt_history.js
 - lib/samagotchi/web/public/push.js
 - lib/samagotchi/web/public/push_devices.js