samagotchi 0.72.0 → 0.73.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6421f740a2683f0dcf3d24b92fba7bba62bed9edb92ddfd532ce69c74e14e0e8
-  data.tar.gz: 23841684a58d0a3efedddcd0fb0caef4d1403c61a88268ad79f6b28a9d8f00ab
+  metadata.gz: 71fb1fa81145a92b955f7beaa2a9a1eabc37d29b9c8336dd65e27d5d616f23fa
+  data.tar.gz: b68963f09b363c1b03f8a32f14ebc41cf36297df3c290c594acef6735d0bb863
 SHA512:
-  metadata.gz: 91ccf28b2be3f0bfff968c5d0448b0c1748ef90c505f1195ec655ae93784e48975409e54a56e18d7f78605812770d4ec9eeae336208da1a95ddbab2aa057f3da
-  data.tar.gz: c5f8e40dfea68d7d6d706970106cbbdc5caf8e9571b92d771dc2928d6a3358704aafcd6b3a047f96ccfbe285b28ee2bc98de81505f10a342cc8b6efc228b0b9c
+  metadata.gz: 1752a44dd7c444534218f23c00ecc1746047875e4dac427b8395cd6cfb06169b38c456ff2bcbf4ca4000d68ce467454f52c2f4564547824ddb5c83dd586f5f2f
+  data.tar.gz: 66d5fcfd2b0a62957011653911edc44774843ac13837203cf1211e0523ae8d834025d0145324cd955d2f5c827f8b4a1e52c8b9c7db6a3735c6c24e4442eea7c0

data/CHANGELOG.md

@@ -8,6 +8,30 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.73.0] - 2026-10-16
+
+### Added
+
+- Web: the stage's asking text (a question's or approval's reply) renders as markdown with clickable links when
+  `web.markdown` is on, and so does a resolved question card's copy of it once the card is opened; their
+  `path:line` refs are links with markdown off too.
+
+### Changed
+
+- Web: `continue →` fills the new link's composer with the previous link's own first message when that link was a
+  continuation itself (else `Continue where we left off.`), so a chain's opener comes back on every link; a chain
+  link's top bar and tab show its card's title whatever opener it was sent.
+- Web: http(s) URLs in a hook's notice line (source-links' `sources:` line with markdown off) are links; they open
+  in a new tab.
+
+### Fixed
+
+- A `task_create` task given a `cwd`, or running `cd`, recorded `failed` / `process_ended_without_exit_code` even
+  when it succeeded (its exit code was written relative to the shell's directory); a task killed by a signal now
+  records 128 + the signal.
+
+Update with `chi update` (the system bundle 0.73.0), then restart `chi web`.
+
 ## [0.72.0] - 2026-10-16
 
 ### Added
@@ -3109,7 +3133,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.72.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.73.0...HEAD
+[0.73.0]: https://github.com/dm1try/samagotchi/compare/v0.72.0...v0.73.0
 [0.72.0]: https://github.com/dm1try/samagotchi/compare/v0.71.0...v0.72.0
 [0.71.0]: https://github.com/dm1try/samagotchi/compare/v0.70.0...v0.71.0
 [0.70.0]: https://github.com/dm1try/samagotchi/compare/v0.69.0...v0.70.0

data/docs/architecture.md

@@ -148,7 +148,7 @@ agent logic and can be used without any terminal rendering; the UI is a thin lay
 | UI | `Samagotchi::TerminalUI` | Interactive REPL (Reline), rendering (ANSI, spinner, status line), REPL commands. Delegates all core work to an `Engine`. |
 | Model loops and adapters | `KernelLoop`, `LLM::ChatLoop`, `Samagotchi::Client`, `LLM::OpenAIChat`, `LLM::AnthropicMessages`, `LLM::HTTP` | The model↔tool loops and the HTTP adapters they talk through (see "Model loops and adapters"). |
 | Bridge (SSE/HTTP) | `Samagotchi::Bridge`, `SessionManager` | The **single live client transport**: an SSE read stream + HTTP POST turn/cancel/answer surface that attaches to a worker's existing `Engine` via `Engine#subscribe`. Every session worker starts it (bound `127.0.0.1`, no auth, localhost-only). |
-| Web (Rack) | `Samagotchi::Web::App`, `SessionManager` | Single-port `127.0.0.1:4567` control plane via `rack`+`webrick` (serve `index.html` + `/api/*`). With `web.host: lan` (or one of this machine's IPv4 addresses) the server also listens on that address, where every request but this machine's needs the access token (`App#token_gate`: the `chi_token` cookie or `Authorization: Bearer`; [CLI](cli.md#chi-web-on-your-phone)). It talks to each worker's Bridge (`App#relay`, `bridge_get`; `/stream` proxies it) and reads the session files; no `Engine` of its own. `bin/chi web` entrypoint. |
+| Web (Rack) | `Samagotchi::Web::App`, `SessionManager` | Single-port `127.0.0.1:4567` control plane via `rack`+`webrick` (serve `index.html` + `/api/*`). With `web.host: lan` (or one of this machine's IPv4 addresses) the server also listens on that address, where every request but this machine's needs the access token (`App#token_gate`: the `chi_token` cookie or `Authorization: Bearer`; [CLI](cli.md#chi-web-on-your-phone)). It talks to each worker's Bridge (`App#relay`, `bridge_get`; `/stream` proxies it) and reads the session files; no `Engine` of its own. Markdown (`web.markdown`) is rendered here only (`Web::MarkdownRenderer`): the answers it serves, card bodies, and `POST /api/render` for a text the page already shows. `bin/chi web` entrypoint. |
 | Sessions | `Samagotchi::Session`, `SessionManager` | File-based `~/.local/state/samagotchi/sessions/<uuid>.json` + sidecar `input/`/`output/`; retention (14d/500) + ordering (`updated_at desc`). |
 
 - `bin/chi` in REPL mode (see `LaunchMode` above) builds `TerminalUI`. `TerminalUI#run` is the single

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 the Web UI (single localhost port session control plane) on this git project's sessions (`--scope=all`, or a folder in no repo: every session); if a chi web already runs on the port, print (with `--open`, open) its page for this folder and exit. Something else on the port (an older chi web too) exits 1 with "port N is in use"
 - `chi web --web-host lan` — the Web UI on your home network too, for your phone: a link with an access token and its QR code (see [chi web on your phone](#chi-web-on-your-phone)); `chi web --new-token` replaces the token
-- `chi web --web-markdown` — opt in to sanitized Markdown rendering for completed assistant messages
+- `chi web --web-markdown` — opt in to sanitized Markdown rendering for completed assistant messages, the stage's asking text and a resolved question card's reply
 - `chi web --web-view turn` — draw turns with the turn view (each turn as one block of steps, the running one at the bottom of the history) instead of the default stage view (the running turn pinned above the composer); `?view=stage|turn` on the page URL overrides it (see [Web views](#web-views))
 - `chi sessions list|stop|restart|archive|unarchive|delete|prune|clean|stats` — manage persisted sessions; `list` shows this git project's, `list --scope=all` every one, a delegated session with `↳ <parent>`, `list --archived` the archived ones too (see [Sessions](sessions.md)). `stats ID` prints a session's cost, tokens and progress (a live worker's `GET stats`, else its saved `analytics.json`; `--format json` one object) without running a model turn. A usage error (an unknown subcommand or flag, a flag missing its value, `stop`, `restart` or `delete` with no ids, a bad `list --format` or `--scope`, a `--days`, `--keep` or `--limit` that isn't a whole number) exits 2; an unknown or refused session exits 1
 - `chi note [--source NAME] [-m TEXT] (ID|PREFIX)... | --all` — add a context note (TEXT or stdin) to sessions: background the model sees on its next turn; it starts no turn (see [Sessions: Context notes](sessions.md#context-notes))
@@ -698,8 +698,14 @@ web:
 ```
 
 Only finalized assistant messages are rendered; user messages and live streaming
-chunks remain escaped text. Generated HTML is sanitized, raw HTML in model output
-is not trusted, and unsafe links are removed. If Markdown is enabled without
+chunks remain escaped text. The stage's asking text (the whole reply that asked
+a waiting question or approval) shows raw at once, then as markdown, its links
+opening in a new tab; a resolved question card's copy of that reply renders when
+the card is first opened (its summary line stays plain). A text the page already shows and renders later goes
+through `POST /api/render` (`{text}` → `{html}`, up to 64 KB; `html` is null
+with markdown off), the same renderer and sanitizer. Generated HTML is
+sanitized, raw HTML in model output is not trusted, and unsafe links are
+removed. If Markdown is enabled without
 commonmarker installed, Chi Web keeps the normal escaped-text display and shows a
 warning explaining how to install the optional gem.
 

data/docs/hooks.md

@@ -124,7 +124,8 @@ links), for a UI that doesn't render that display. The hook never names a UI;
 each decides by what it renders. The web with markdown on (`web.markdown` and
 the commonmarker gem) leaves such a line out, live and after a reload; with
 markdown off it shows, as it does in the REPL, the attached TUI and
-`chi -p`, which print the answer as text. The log keeps the line with
+`chi -p`, which print the answer as text (in the web its http(s) URLs are
+links, as in any hook's notice line). The log keeps the line with
 `fallback_for=display`. `:editor` marks a line that names a file the viewer
 could open from a ref in its editor: the web leaves it out for a viewer on
 this machine with `web.editor` set, and every other UI and viewer (a phone,
@@ -660,7 +661,8 @@ keeps the web links. With markdown on, the web leaves the line out when the
 answer links every URL it names, since it would only repeat them as plain
 text ([`fallback_for: :display`](#what-a-hook-can-do-the-runtime)); it shows
 when it names one the answer doesn't link (a ref only in code, two sources on
-one ref) and whenever markdown is off. Bundle 0.4.0 needs chi 0.35.0 for that.
+one ref) and whenever markdown is off (its URLs are links in the web). Bundle
+0.4.0 needs chi 0.35.0 for that.
 
 Each ref the answer links is also a [ref on the
 answer](#refs-on-the-answer-display-only): kind `issue` (or the source's

data/docs/internals/background-tasks.md

@@ -23,9 +23,9 @@ Behavior:
 - A stop (`task_stop`, the user's Stop of an `execute`, the execute limit in kill mode) TERMs the task's process group, then KILLs it after a grace. The groups its processes started are stopped too: a GNU `timeout N cmd` (without `--foreground`) moves itself and its command to a group of its own. `ProcessGroup.stop` finds them with one `ps -A -o pid=,ppid=,pgid=` (~40 ms on macOS) before the TERM and again before the KILL, walking down from the group's members. A process whose parent already exited (reparented to init, e.g. a setsid'd `cmd &`, or a backgrounded `timeout N cmd &` after its shell exited) is not found and runs on.
 - Task listing is workspace-scoped (current project only).
 - `execute` runs its command with stdout and stderr in two logs under `$XDG_STATE_HOME/samagotchi/execute/<id>/` (outside the workspace: `git status` and `rm -rf tmp` never see them), stdin `/dev/null` and the same `exit_code` wrapper as a task. Its own copies of the logs hold a shared `flock` across the spawn: while a fresh exclusive `flock` fails, some process the command started still has them open. When the shell exits, a background child still holding them (`server &`) gets 1.5 s, then its group is stopped; one holding none (`nohup server >log 2>&1 &`) is left alone. A holder that left the group (setsid) is out of the stop's reach: it runs on, the result ends with the "left running" hint, and its dir stays for it to write to (the sweep removes it once no one holds the logs). Otherwise a finished command's dir is removed. Known gap on Linux: a command that writes through `/dev/stdout` or `/dev/stderr` (`echo b >/dev/stdout`) reopens the log file itself with `O_TRUNC`, so the output before it is lost (macOS dups the descriptor; the fix would be a relay pipe). The check needs the state dir on a local file system: over NFS, `flock` is emulated with `fcntl` locks, which children don't inherit.
-- The exit code: the command runs after an EXIT trap that writes the shell's status to the `exit_code` file (`TaskRuntime.wrapped_shell_command`, shared with `task_create`), so `exit N`, a `set -e` failure and a trailing `\` or `|` in the command all record what the shell exited with. A command that sets its own EXIT trap replaces it: `execute` still reports the shell's status, and a handed-over one gets its code from chi's waiter while that chi runs; a `task_create` task ends failed with no exit code.
+- The exit code: the command runs after an EXIT trap that writes the shell's status to the `exit_code` file (`TaskRuntime.wrapped_shell_command`, shared with `task_create`), so `exit N`, a `set -e` failure and a trailing `\` or `|` in the command all record what the shell exited with. The trap runs wherever the shell is when it exits (a `task_create` `cwd`, or a `cd` in the command), so `task_create`'s `exit_code_path` is absolute; its `output_path` stays relative (`tmp/tasks/<id>/output.log`, opened by chi in the worker's cwd before the spawn). A command that sets its own EXIT trap replaces it, and a shell killed by a signal skips it (zsh's sh mode, on TERM, INT and KILL): `execute` still reports the shell's status, and a `task_create` task or a handed-over execute gets its code from chi's waiter while the chi that started it runs (`TaskRuntime.record_exit_status`): the exit status, or `128 + the signal` (TERM → 143), with no new `stop_reason`. A record a refresh already finished without a code in between (`failed`, `process_ended_without_exit_code` or the not-chi's-process reason) is corrected, its `finished_at` kept; a stopped task (its stop flag on disk) is never touched. `process_ended_without_exit_code` is left only when the shell wrote nothing and the chi that started it was gone too.
 - A stop of an `execute` (the user's Stop, the limit in kill mode) is done once the shell is reaped and nothing holds the logs: a child that ignores TERM after its shell died gets the KILL.
-- A command still running at `execute.timeout_sec` is handed over as a task (`execute.on_timeout: task`, the default; `kill` stops it instead, and the `!cmd` bang always kills): the result starts `Still running at the 120s limit: moved to a background task, not killed.`, then `task_id: …` and the tails of both logs so far. A timeout during the 1.5 s background grace is a kill (the shell is gone, nothing to hand over). If the record can't be written, the command is killed. `TaskRuntime.adopt` writes a record for the process execute already started, with `handed_over_by: "execute"`. Its logs stay where execute wrote them, so the record's paths are absolute: `output_path` (stdout), `stderr_path` (stderr, a log of its own) and `exit_code_path`. `started_at` (and `created_at`) is the spawn time, not the hand-over's; `pid_started` is read at the hand-over, while execute's detach waiter is still running. From there it is an ordinary task: `task_wait`, `task_get`, `task_list` and `task_stop` treat it as any other. Its dir gets a `task` back-pointer file holding the record's absolute path. Once per process, the first `execute` sweeps `…/execute/`: a dir whose logs no process holds is removed when it has no back-pointer and is a day old (chi died mid-command), when its record is gone, or when it is 14 days old. The records live in each project's `tmp/tasks`, which the state dir can't list: hence the back-pointer.
+- A command still running at `execute.timeout_sec` is handed over as a task (`execute.on_timeout: task`, the default; `kill` stops it instead, and the `!cmd` bang always kills): the result starts `Still running at the 120s limit: moved to a background task, not killed.`, then `task_id: …` and the tails of both logs so far. A timeout during the 1.5 s background grace is a kill (the shell is gone, nothing to hand over). If the record can't be written, the command is killed. `TaskRuntime.adopt` writes a record for the process execute already started, with `handed_over_by: "execute"`. Its logs stay where execute wrote them, so the record's paths are absolute: `output_path` (stdout), `stderr_path` (stderr, a log of its own) and `exit_code_path` (a `task_create` record's `exit_code_path` is absolute too; its `output_path` is relative). `started_at` (and `created_at`) is the spawn time, not the hand-over's; `pid_started` is read at the hand-over, while execute's detach waiter is still running. From there it is an ordinary task: `task_wait`, `task_get`, `task_list` and `task_stop` treat it as any other. Its dir gets a `task` back-pointer file holding the record's absolute path. Once per process, the first `execute` sweeps `…/execute/`: a dir whose logs no process holds is removed when it has no back-pointer and is a day old (chi died mid-command), when its record is gone, or when it is 14 days old. The records live in each project's `tmp/tasks`, which the state dir can't list: hence the back-pointer.
 - `task_wait` and `task_get` show `stderr_path` when the record has one; `task_wait`'s output tail is followed by a `stderr_tail:` of at most 10 lines when that log isn't empty. A `task_create` task has one log (stdout and stderr together) and no `stderr_path`. A `task_wait` result longer than `max_tool_output_chars` keeps its header and the tail's end, with a gap line naming `output_path`, where the whole log already is (and `stderr_path`, when the record has one) (`ToolOutputCut`'s `:head_tail_ref`; nothing is copied; see [Tool output guardrails](tool-guardrails.md#the-runners-cut-max_tool_output_chars)).
 - Which tasks are a session's own (a cancelled turn's note, the turn-end note, a worker's idle exit, the web's stop-task button): the ids its `task_create` results and its handed-over executes name (`TaskRuntime.created_ids_in`, `created_id`). An execute's id is read only after its first line (`Execute::HANDED_OVER`, through `TaskRuntime.handed_over_id`; the web has a JS twin in `task_stop.js`), not from a `task_id:` line inside a run, which the command can print. (A command that prints the `---` separator chi joins a turn's results with, then a hand-over line, still fakes one: a known gap.) Either result may start with the `ran as: …` line of a gate-corrected call.
 - `task_get` returns metadata and `output_path`; use `read` for output contents.

data/docs/sessions.md

@@ -215,8 +215,8 @@ A session can **continue** an earlier one: "the next day of the same routine" (a
 - **Its open delegates move to the new link** instead: each direct delegate that is running, waiting for an answer, has a live worker or a reply its parent wasn't given, or has such a delegate below it (checked again after the recap wait, so one delegated meanwhile moves too). It moves with its own delegates, stays unarchived, and from then on is the new link's: its card folds under the new link, its reports ring the new link (an idle one runs a wake turn for them, as for its own delegates), `delegate_result` and the `⑂` chip count it there, and what its parent was already told (`delegates.json`) and any report still waiting come along, so nothing is reported twice. A moved delegate gets a context note from `session chain`, `Your parent session is now 4b7e9a01 (…), the next link of its session chain: …`, as its system prompt keeps naming the parent it started with. The move writes `<child>/parent.json` (`{parent_id, from, at}`) beside the child's session file, never the file itself, so a live child worker saving its own copy changes nothing; every reader applies it (a later move overwrites it; it is never removed). A continue is **refused for an open delegate that can't move** (`SessionContinue::Refused`, naming it): one whose live worker runs an older chi (`older chi worker 0.46.1; restart it`: `chi sessions restart <id>`, or stop it) or that is open in a chi REPL (close it there). An older `chi web` or CLI still running shows a moved delegate under the archived link until it is restarted.
 - **If the continue fails part-way:** a new link that fails to start gives its moved delegates back before it is deleted (each gets a note saying so; its worker is stopped first, if one started, and a worker that won't stop is reported, the link left), with any report one of them rang it with meanwhile; the previous link, back in the lists, is woken for reports waiting. A continue that dies in the middle leaves a `move.json` in the new link's folder: the new link's next worker finishes that move (only the delegates it names, and without a second note to one already told) as it starts. Until the new link's own worker holds it, a ring from a moved delegate doesn't start another (a `starting` marker in its folder, which that worker removes; a stale one, over 60 s old or from a process that is gone, is ignored). An open delegate below an archived delegate refuses the continue (`under archived …`): unarchive that one, or archive this one.
 - **Refused too:** a link that is continued already (naming the link that continues it; continue that one, or `last:<id>`), a previous link whose folder is gone, and one whose model's host can't run it when no default model is configured to fall back to. A refusal starts nothing and archives nothing; a new link that fails to start puts back what was archived. Every refusal that can be known up front (the archive's ones included) comes before the recap wait. One continue of a session runs at a time (a lock in its folder; other chains don't wait), so a double click finds the first one's link and is refused, while a `last:<id>` continue that waited follows the chain to its new end.
-- **Web:** `POST /api/sessions` takes `continues: "<id, prefix or last:id>"`, with `idle: true` (a new link waiting for its first message, previewed by the previous link's, or `preview`) or a `prompt`, and `model` (or `model_name`) for the new link's model, but not `dir`, `llm_context` or `thinking` (400 `invalid_continues`: the previous link's are taken). 201 is the new session's summary, `continues` set, with `moved`: the ids of the delegates that moved to it (`[]` for none), and `model_warning`: the default-model fallback's warning, then any about the model id, joined by `; ` (`null` for none); 404 `not_found`; 400 `ambiguous_id` for a prefix of several sessions, `invalid_model` for a given model whose host config.yml doesn't have (or a fallback with no default model); 409 `continued` with `next_id` (the link that continues it already, which the page opens instead), `open_children` with `ids` (open delegates that can't move), `folder_gone`, `busy`, `scratch` or `owned_by_tui`. Every session summary carries `continues`.
-- **The page:** the info bar's `continue →` continues the open session (`continues: <id>, idle: true`; it reads `continuing…` through the recap wait) and opens the new link with `Continue where we left off.` in the composer, not sent (the same line for every chain; a draft already there stays instead); the previous link is archived, a toast says so (`Continued 3fa2c1d0 in 4b7e9a01; 3fa2c1d0 is archived; 1 open delegate moved`), and a moved delegate's card folds under the new link. When the previous link's model's host is gone the link starts on the default model and the toast carries the server's `model_warning` too, and then stays until closed. A fresh link (one with no turn yet, however it was made: `continue →`, `chi send --new --continues`, a reload) shows the model picker in its composer with the link's model, until its first turn starts (a failed or canceled first turn ends it too); a pick runs `/model <name>` in the link (a command bubble; the info bar follows) and changes neither the start page's remembered model nor its Recent list, and a Send right after it waits for the `/model` to be taken. A link a chi REPL owns, or one continued already, shows none. A link continued already has no `continue →`: its `→` link goes to the next link (a stale page's continue answered 409 `continued` opens `next_id`). A continue refused for open delegates that can't move shows a toast that names each one (its preview and what the server says to do: `older chi worker 0.46.1; restart it`, `open in a chi REPL; close it there`), each a link to its page; any other refusal shows the server's words. The info bar of a link carries `← 2026-10-08` (the previous link's day) and, on an earlier link, `2026-10-10 →`, each a link with its preview and id in the tooltip. A link whose title is the opener and nothing else (its first message once sent) shows its chain's first link's title instead, on its card, in the popover and in its info bar's title line, display only (its messages and data keep the opener; its own title when the first link is gone). The lists fold a chain into the card of its latest listed link, whatever the earlier links' archived state (typing in an archived link brings it back, folded there still), their delegates with them: the card's `↩ day N` chip (`day N of M` when later links aren't listed) opens a popover of the other links, newest first (`day N`, its date, its recap's first sentence or its preview, `archived`), a click opens one; the chip shows a live dot or `waiting` for a link that has a worker or waits on the user, and a waiting link puts its chain's card first. All sessions folds nothing while a search is typed or "include archived" is on: every link is a card of its own then, its chip `day N of M`, with its own delegates folded in, so a search finds an earlier link and its delegates.
+- **Web:** `POST /api/sessions` takes `continues: "<id, prefix or last:id>"`, with `idle: true` (a new link waiting for its first message, previewed by the previous link's, or `preview`) or a `prompt`, and `model` (or `model_name`) for the new link's model, but not `dir`, `llm_context` or `thinking` (400 `invalid_continues`: the previous link's are taken). 201 is the new session's summary, `continues` set, with `moved`: the ids of the delegates that moved to it (`[]` for none), and `model_warning`: the default-model fallback's warning, then any about the model id, joined by `; ` (`null` for none), and `opener`: the previous link's first typed message, in full, when that link continues one itself (`null` otherwise: a chain's first link's first message is its task); 404 `not_found`; 400 `ambiguous_id` for a prefix of several sessions, `invalid_model` for a given model whose host config.yml doesn't have (or a fallback with no default model); 409 `continued` with `next_id` (the link that continues it already, which the page opens instead), `open_children` with `ids` (open delegates that can't move), `folder_gone`, `busy`, `scratch` or `owned_by_tui`. Every session summary carries `continues`.
+- **The page:** the info bar's `continue →` continues the open session (`continues: <id>, idle: true`; it reads `continuing…` through the recap wait) and opens the new link with an opener in the composer, not sent (a draft already there stays instead): the previous link's own first typed message when that link continues one (the 201's `opener`; a `!shell` line isn't taken), else `Continue where we left off.`. So whatever you sent on the last link comes back on the next one, and editing it once changes it for every later link; the previous link is archived, a toast says so (`Continued 3fa2c1d0 in 4b7e9a01; 3fa2c1d0 is archived; 1 open delegate moved`), and a moved delegate's card folds under the new link. When the previous link's model's host is gone the link starts on the default model and the toast carries the server's `model_warning` too, and then stays until closed. A fresh link (one with no turn yet, however it was made: `continue →`, `chi send --new --continues`, a reload) shows the model picker in its composer with the link's model, until its first turn starts (a failed or canceled first turn ends it too); a pick runs `/model <name>` in the link (a command bubble; the info bar follows) and changes neither the start page's remembered model nor its Recent list, and a Send right after it waits for the `/model` to be taken. A link a chi REPL owns, or one continued already, shows none. A link continued already has no `continue →`: its `→` link goes to the next link (a stale page's continue answered 409 `continued` opens `next_id`). A continue refused for open delegates that can't move shows a toast that names each one (its preview and what the server says to do: `older chi worker 0.46.1; restart it`, `open in a chi REPL; close it there`), each a link to its page; any other refusal shows the server's words. The info bar of a link carries `← 2026-10-08` (the previous link's day) and, on an earlier link, `2026-10-10 →`, each a link with its preview and id in the tooltip. A link made by `continue →` inherits the previous link's title when it is created, so its card keeps its chain's title whatever opener it is sent, and its top bar and browser tab show its card's title. A link whose title is the opener and nothing else (a `chi send --new --continues` link whose first message is `Continue where we left off.`) shows its chain's first link's title instead, on its card, in the popover and in its info bar's title line, display only (its messages and data keep the opener; its own title when the first link is gone). The lists fold a chain into the card of its latest listed link, whatever the earlier links' archived state (typing in an archived link brings it back, folded there still), their delegates with them: the card's `↩ day N` chip (`day N of M` when later links aren't listed) opens a popover of the other links, newest first (`day N`, its date, its recap's first sentence or its preview, `archived`), a click opens one; the chip shows a live dot or `waiting` for a link that has a worker or waits on the user, and a waiting link puts its chain's card first. All sessions folds nothing while a search is typed or "include archived" is on: every link is a card of its own then, its chip `day N of M`, with its own delegates folded in, so a search finds an earlier link and its delegates.
 - **CLI:** `chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT]` (see *Starting a session*).
 - **Which link:** an id, a unique prefix, or `last:<id or prefix>`, the latest link of the chain that session is in. It walks the links that still exist: a deleted link in the middle (`chi sessions delete`, the retention sweep of an unarchived one) ends the walk before it, so `last:` of an earlier link then names that earlier link, and continuing it starts a second line beside the links after the gap; name a link after the gap instead. A trigger names the chain this way: `chi send` to an archived link would bring it back (a human's input), not continue the chain.
 

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.72.0
+version: 0.73.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.rb

@@ -220,6 +220,11 @@ module Samagotchi
     # SessionManager.continue_session sets it); not saved.
     attr_accessor :moved_children
 
+    # The text web `continue →` prefills in this new link
+    # (SessionChain.opener_for; SessionManager.continue_session sets it); not
+    # saved.
+    attr_accessor :opener
+
     def initialize(id:, mode:, model_name:, working_directory:, messages:, created_at:, updated_at:,
                    metadata_version: METADATA_VERSION, status: STATUS_IDLE, last_prompt: "",
                    first_preview: "", test_run: false, pending_question: nil,

data/lib/samagotchi/session_chain.rb

@@ -78,6 +78,30 @@ module Samagotchi
       "#{head} Its recap#{", as of #{as_of}" if as_of}:\n#{text}"
     end
 
+    # What web `continue →` prefills in +previous+'s next link: +previous+'s
+    # own first typed message when +previous+ is itself a continuation (so a
+    # chain's opener comes back on every link, edited once for all later
+    # ones), else nil (a chain's first link's first message is its task; the
+    # page falls back to its constant). Typed means a user message with text
+    # and no kind: Engine#turn_messages' (turn_id), or a checkpointed prompt
+    # (none); a stored `!shell` line ("!(cmd)\n<output>", no turn_id) is not.
+    # @param previous [Session]
+    # @return [String, nil]
+    def opener_for(previous)
+      return nil unless previous.continues
+
+      previous.messages.each do |msg|
+        next unless msg[:role] == "user" && msg[:kind].nil?
+
+        text = msg[:content]
+        next unless text.is_a?(String) && !text.strip.empty?
+        next if msg[:turn_id].nil? && text.start_with?("!(")
+
+        return text.strip
+      end
+      nil
+    end
+
     def day(iso)
       Time.iso8601(iso.to_s).localtime.strftime("%Y-%m-%d")
     rescue ArgumentError

data/lib/samagotchi/session_continue.rb

@@ -86,7 +86,8 @@ module Samagotchi
     # @param title [String, nil] what the lists show before the first turn;
     #   by default the prompt, else the previous link's preview
     # @return [Session] the new link (#model_warning as spawn_session's,
-    #   #moved_children: the delegates it took over)
+    #   #moved_children: the delegates it took over, #opener:
+    #   SessionChain.opener_for the previous link)
     # @raise [ArgumentError] no such session (Session::AmbiguousId for a prefix of several)
     # @raise [Refused] continued already, delegates open that can't
     #   move, or its folder is gone
@@ -208,6 +209,7 @@ module Samagotchi
         note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn
       )
       link.moved_children = move
+      link.opener = SessionChain.opener_for(previous)
       # The fallback's warning first: spawn_session set its own.
       warnings = [choice.warning, link.model_warning].compact
       link.model_warning = warnings.join("; ") unless warnings.empty?

data/lib/samagotchi/tools/execute.rb

@@ -350,7 +350,7 @@ module Samagotchi
         return nil if error
 
         File.write(File.join(dir, BACK_POINTER), File.expand_path(TaskRuntime.metadata_path(record.id)))
-        write_missing_exit_code(waiter, record.exit_code_path)
+        TaskRuntime.record_exit_status(waiter, record.exit_code_path, task_id: record.id)
         # Ended between the deadline and the adopt: the record says how.
         TaskRuntime.get_record(record.id) unless waiter.alive?
         lines = [handed_over_line(timeout_sec), "task_id: #{record.id}",
@@ -363,20 +363,6 @@ module Samagotchi
       end
       private_class_method :hand_over
 
-      # A command that set its own EXIT trap replaced the wrapper's, so it
-      # writes no exit_code: while this chi lives, the waiter's status fills
-      # it in (a refresh in between may still read "no exit code").
-      def self.write_missing_exit_code(waiter, path)
-        Thread.new do
-          Thread.current.report_on_exception = false
-          code = waiter.value&.exitstatus
-          File.write(path, code.to_s) if code && !File.exist?(path) && Dir.exist?(File.dirname(path))
-        rescue StandardError => e
-          Log.debug(:turn, "execute_exit_code_failed", error: e.class.name, msg: e.message)
-        end
-      end
-      private_class_method :write_missing_exit_code
-
       # <state dir>/execute: every command's dir (LOGS_DIRNAME).
       def self.logs_root = File.join(Paths.state_dir, LOGS_DIRNAME)
 

data/lib/samagotchi/tools/task_runtime.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "shellwords"
 require "time"
 require_relative "../atomic_file"
+require_relative "../log"
 require_relative "../process_group"
 require_relative "shell"
 require_relative "task_record"
@@ -55,7 +56,9 @@ module Samagotchi
         task_id = generate_task_id
         task_dir = task_dir_for(task_id)
         output_path = File.join(task_dir, OUTPUT_FILENAME)
-        exit_code_path = File.join(task_dir, EXIT_CODE_FILENAME)
+        # Absolute: the trap writes it wherever the shell is when it exits
+        # (a +cwd+, or a cd in the command). Ruby opens output_path here.
+        exit_code_path = File.expand_path(File.join(task_dir, EXIT_CODE_FILENAME))
 
         FileUtils.mkdir_p(task_dir)
 
@@ -72,7 +75,7 @@ module Samagotchi
           out: output_io,
           err: output_io
         )
-        Process.detach(pid)
+        waiter = Process.detach(pid)
         # Read now, compared before each signal: a pid reused later is not this task.
         pid_started = ProcessGroup.start_time(pid)
 
@@ -81,6 +84,7 @@ module Samagotchi
                                     output_path: output_path, exit_code_path: exit_code_path)
 
         write_record(record)
+        record_exit_status(waiter, exit_code_path, task_id: task_id)
         [record, nil]
       rescue StandardError => e
         [nil, "Error: #{e.message}"]
@@ -88,6 +92,60 @@ module Samagotchi
         output_io&.close
       end
 
+      # The shell's status from chi's waiter (+waiter+, a Process.detach
+      # thread), for a shell whose EXIT trap wrote nothing: one killed by a
+      # signal (zsh's sh mode skips the trap on TERM, INT and KILL) gets
+      # 128 + the signal, one whose command replaced the trap gets its exit
+      # status. Only while this chi runs. A record a refresh finished in
+      # between (failed, no exit code) is corrected; a stopped task (its
+      # stop flag on disk) is left as task_stop records it.
+      # @return [Thread]
+      def record_exit_status(waiter, path, task_id:)
+        # Absolute now: safe against a later chdir.
+        record_path = File.expand_path(metadata_path(task_id))
+        path = File.expand_path(path)
+        Thread.new do
+          Thread.current.report_on_exception = false
+          code = status_code(waiter.value)
+          next if code.nil? || record_at(record_path)&.stop_requested_by
+
+          File.write(path, code.to_s) if !File.exist?(path) && Dir.exist?(File.dirname(path))
+          correct_finished_record(record_path, read_exit_code(path))
+        rescue StandardError => e
+          Log.debug(:turn, "task_exit_code_failed", id: task_id, error: e.class.name, msg: e.message)
+        end
+      end
+
+      # A Process::Status as a shell reports one: its exit status, or
+      # 128 + the signal that killed it.
+      def status_code(status)
+        return nil unless status
+
+        status.exitstatus || (status.termsig && (128 + status.termsig))
+      end
+
+      # Reasons a refresh finishes a record with when it read no exit code.
+      MISSING_CODE_REASONS = ["process_ended_without_exit_code", NOT_CHIS_PROCESS].freeze
+
+      # A record a refresh finished before the exit code was there (failed,
+      # exit_code nil, no stop) gets +code+; finished_at is kept.
+      def correct_finished_record(record_path, code)
+        record = record_at(record_path)
+        return unless code && record && !record.running? && record.exit_code.nil? && !record.stop_requested_by
+        return unless MISSING_CODE_REASONS.include?(record.stop_reason)
+
+        status = code.zero? ? "completed" : "failed"
+        AtomicFile.write(record_path, record_json(record.with(status: status, exit_code: code, stop_reason: nil)))
+      end
+
+      def record_at(path)
+        return nil unless File.file?(path)
+
+        TaskRecord.from_file(JSON.parse(File.read(path)))
+      rescue JSON::ParserError
+        nil
+      end
+
       # A record for a command chi already runs: an execute still running at
       # its limit, handed over as a task (Execute::HANDED_OVER), given as a
       # TaskRecord.running whose +started_at+ is the spawn's. Its logs and
@@ -321,9 +379,11 @@ module Samagotchi
         FileUtils.mkdir_p(dir)
 
         path = File.join(dir, METADATA_FILENAME)
-        AtomicFile.write(path, JSON.pretty_generate(record.to_file) + "\n")
+        AtomicFile.write(path, record_json(record))
       end
 
+      def record_json(record) = JSON.pretty_generate(record.to_file) + "\n"
+
       def metadata_path(task_id)
         File.join(task_dir_for(task_id), METADATA_FILENAME)
       end
@@ -352,9 +412,12 @@ module Samagotchi
       # exit status to +exit_code_path+. A prefix, not lines after the
       # command: a trailing "\\" or "|" in the command would swallow those,
       # and an `exit N` or a `set -e` failure would skip them. A command that
-      # sets its own EXIT trap replaces this one: no exit_code file then
-      # (the task ends failed with process_ended_without_exit_code, unless
-      # its starter's waiter writes the code: Execute's hand-over).
+      # sets its own EXIT trap replaces this one, and a shell killed by a
+      # signal skips it (zsh's sh mode, on TERM, INT and KILL): no exit_code
+      # file from the shell then. The waiter of the chi that started it
+      # writes the code instead (record_exit_status: the status, or
+      # 128 + the signal); with that chi gone too, the task ends failed with
+      # process_ended_without_exit_code.
       def wrapped_shell_command(command, exit_code_path)
         write = %(printf "%s" "$?" > #{Shellwords.escape(exit_code_path)})
         "trap #{Shellwords.escape(write)} EXIT\n#{command}\n"

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -66,6 +66,9 @@ module Samagotchi
       BRIDGE_WAIT_TIMEOUT = 10.0
       # An uploaded image may be this big before it is downscaled.
       MAX_IMAGE_UPLOAD_BYTES = 20 * 1024 * 1024
+      # A POST /api/render body may be this big: a decision message is a few
+      # KB, and the cap bounds the work a page can ask for.
+      MAX_RENDER_BYTES = 64 * 1024
       SESSION_ID_RE = /\A[0-9A-Za-z-]{1,64}\z/
       IMAGE_NAME_RE = /\A[0-9a-f]{16}\.(png|jpe?g|gif|webp)\z/
       IMAGE_TYPES = { "png" => "image/png", "jpg" => "image/jpeg", "jpeg" => "image/jpeg", "gif" => "image/gif",
@@ -158,6 +161,7 @@ module Samagotchi
         ["GET", %r{\A/api/models\z}, :handle_models],
         ["GET", %r{\A/api/history\z}, :handle_history],
         ["GET", %r{\A/api/events\z}, :handle_events],
+        ["POST", %r{\A/api/render\z}, :handle_render],
         ["GET", %r{\A/api/sessions/([^/]+)/stream\z}, :handle_stream],
         ["GET", %r{\A/api/sessions/([^/]+)/output\z}, :handle_output],
         ["POST", %r{\A/api/sessions/([^/]+)/cancel\z}, :handle_cancel],
@@ -679,8 +683,9 @@ module Samagotchi
       # refused beside it (a create takes no reasoning_history). It runs on
       # model (or model_name) when given, else on the previous link's: one
       # whose host is gone falls back to the default, and the 201's
-      # model_warning (null when none) says so. A model it can't start on is
-      # 400 invalid_model, nothing archived.
+      # model_warning (null when none) says so. Its opener is the text the
+      # page prefills (SessionChain.opener_for; null: the page's constant).
+      # A model it can't start on is 400 invalid_model, nothing archived.
       # 409 continued (with next_id, the link that continues it already: the
       # page opens that one), open_children (ids), folder_gone, busy, scratch
       # or owned_by_tui.
@@ -707,7 +712,8 @@ module Samagotchi
         [session.continues, session.id, *moved].each { |sid| @hub&.touch(sid) }
         record_history(body, prompt) if !idle && PromptHistory.shell_line?(prompt.to_s.strip)
         json_response(201, session_to_json(session).merge(bridge_port: port, moved: moved,
-                                                          model_warning: session.model_warning))
+                                                          model_warning: session.model_warning,
+                                                          opener: session.opener))
       end
 
       # SessionManager.continue_session, its refusals as responses: [session,
@@ -1006,6 +1012,24 @@ module Samagotchi
         html || "<pre>#{CGI.escapeHTML(body)}</pre>"
       end
 
+      # POST /api/render {text}: the page's markdown read for a text it
+      # already shows (the stage's asking text, a resolved question card's
+      # reply), session-free. {html: nil} when markdown is off or
+      # commonmarker is missing: the page keeps the raw text.
+      def handle_render(req)
+        too_large = error_response(413, "too_large", "a text to render may be up to #{MAX_RENDER_BYTES / 1024} KB")
+        return too_large if req.content_length.to_i > MAX_RENDER_BYTES
+
+        raw = request_body(req, MAX_RENDER_BYTES + 1).to_s
+        return too_large if raw.bytesize > MAX_RENDER_BYTES
+
+        body = parse_json(raw)
+        return error_response(400, "invalid_json", "give {text}") unless body.is_a?(Hash) && body["text"].is_a?(String)
+
+        html = @markdown_renderer.render(body["text"]) if @markdown_renderer.available?
+        json_response(200, { html: html })
+      end
+
       def handle_question_answer(req, id)
         session = @session_class.load(id, state_dir: default_state_dir) rescue nil
         return error_response(404, "not_found", "Session not found: #{id}") unless session

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

@@ -20,6 +20,7 @@ import {
   getContext,
   detachContext,
   addContext,
+  renderText,
 } from "./data.js";
 import { createContextChips } from "./context_chips.js";
 import {
@@ -45,7 +46,7 @@ import { createBubbles, hintEl, outputBubbleTemplate, setBubbleDelivery } from "
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView, FOLD_MS } from "./stage_view.js";
 import { reducedMotion, STAGE_GAP } from "./stage_frame.js";
-import { CONTINUE_OPENER, chainNeighbours, isOpener, continueRefusal, continuedText, freshLink, openChildrenTemplate } from "./chains.js";
+import { chainNeighbours, continueRefusal, continuedText, freshLink, openChildrenTemplate, openerText, openTitle } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
 import { appendQuote } from "./annotations.js";
 import { parsePresets } from "./annotate_presets.js";
@@ -231,8 +232,25 @@ const viewArgs = {
   taskStop: createTaskStopper({ sessionId: () => selected, features: () => current.workerFeatures }),
 };
 const turnDom = view === "stage"
-  ? createStageView({ ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl })
+  ? createStageView({
+    ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl,
+    renderMarkdown, linkRefs: linkRefsIn,
+  })
   : createTurnView(viewArgs);
+// A text the page already shows as its markdown HTML (POST /api/render,
+// sanitised there), or null: markdown off here (no request), or a failed
+// read (the raw text stays).
+function renderMarkdown(text) {
+  if (pageCapabilities.display !== true) return Promise.resolve(null);
+  return renderText(text)
+    .then((d) => (typeof d?.html === "string" && d.html ? d.html : null))
+    .catch(() => null);
+}
+// The `path:line` refs in one rendered text (the stage's asking slot, a
+// kept reply), as linkTextRefs links the answers'.
+function linkRefsIn(el) {
+  linkRefs(el, touchedFiles(turnRoots()), current.dir);
+}
 // Where a running turn's rows can be: the history, and the stage while it
 // holds a turn (lookups by id, copy, annotate, card actions).
 function turnRoots() {
@@ -293,6 +311,8 @@ const questionCards = createQuestionCards({
   scrollToEnd: () => { historyEl.scrollTop = historyEl.scrollHeight; },
   removeHintIfEmpty: () => removeHintIfEmpty(),
   askingText: () => turnDom.askingText(),
+  renderMarkdown,
+  linkRefs: linkRefsIn,
 });
 // The history's bubbles (bubbles.js): output, end lines, every client's
 // prompts, the recap, warnings and notices, command and note bubbles.
@@ -1107,12 +1127,12 @@ function updateInfoBar() {
 
 // The open session's title, once on screen (session_title.js): its strip
 // card says it when the strip is shown and has one; else the top bar. The
-// browser tab names it too. It follows the card's: a chain link opened with
-// the opener reads its chain's first link's title (cardTitle).
+// browser tab names it too. It follows the card's (openTitle): a chain link
+// reads its card's title (cardTitle), whatever opener it was sent.
 function updateSessionTitle() {
   const shown = selected ? lists.sessionsById().get(selected) : null;
   const first = current.firstPreview || "";
-  const raw = !selected ? "" : (shown && isOpener(first) ? lists.cardTitle(shown) : first);
+  const raw = !selected ? "" : openTitle({ shown, first, cardTitle: (s) => lists.cardTitle(s) });
   const title = raw === "\u2014" ? "" : raw; // "—": no first message yet
   const text = topBarTitle({
     title,
@@ -1888,7 +1908,8 @@ $("#infoArchiveBtn").addEventListener("click", () => {
 // ── Continue (session chains) ───────────────────────────────────────────────
 // Continue → starts the next link of the open session's chain (the server
 // waits up to 30 s for its recap, archives it, starts the new one with the
-// recap as a note) and opens it with the opener in the composer, not sent.
+// recap as a note) and opens it with the opener in the composer, not sent
+// (fillOpener: the previous link's own first message when it continues one).
 // A link continued already opens that next link; its open delegates move
 // to the new link (the toast counts them); a refusal for open delegates
 // that can't move names them, each a link.
@@ -1914,7 +1935,7 @@ async function continueSelected() {
       return;
     }
     await select(next);
-    if (selected === next) fillOpener();
+    if (selected === next) fillOpener(created);
     showToast(continuedText(id, created), null, { sticky });
   } catch (e) {
     const refusal = continueRefusal(e, allSessions);
@@ -1932,10 +1953,12 @@ async function continueSelected() {
   }
 }
 
-// The new link's composer: the opener, unless a draft is there (it stays).
-function fillOpener() {
+// The new link's composer: the opener (openerText: the previous link's own,
+// else the constant), unless a draft is there (it stays). +created+: the
+// continue's 201.
+function fillOpener(created) {
   if (promptEl.value.trim() || chips.length) return;
-  promptEl.value = CONTINUE_OPENER;
+  promptEl.value = openerText(created);
   fitPrompt();
   promptEl.focus();
   promptEl.setSelectionRange(promptEl.value.length, promptEl.value.length);

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

@@ -9,6 +9,7 @@ import { BADGES, elementOf, noteBubbleTemplate, stateBadgeTemplate, steerRowTemp
 import { thumbsTemplate } from "./images.js";
 import { appendAboveLiveTiming, STOPPED_LINE_CLASS } from "./timing.js";
 import { keepFollowing } from "./scroll.js";
+import { linkedLine } from "./notice_links.js";
 import { hookNoticeLabel, isReportClient, promptOps } from "./turn_events.js";
 import { drawCommandBubble } from "./commands.js";
 
@@ -53,10 +54,11 @@ export function guardrailWarningTemplate(text, label = "guardrails") {
 
 // A hook's line to the user (event[:notify]), in the warning colour for
 // level warn; +cls+ adds a kind's class (llm_context_edited's). +bubble+:
-// one of the history's own, else a row of a turn's step.
+// one of the history's own, else a row of a turn's step. Its http(s) URLs
+// are links (notice_links.js).
 export function hookNoticeTemplate({ line, level = null, cls = null, title = null }, { bubble = true } = {}) {
   const klass = (bubble ? "bubble hook-notice" : "hook-notice") + (level === "warn" ? " warn" : "") + (cls ? ` ${cls}` : "");
-  return html`<div class=${klass} title=${title || nothing}>${line}</div>`;
+  return html`<div class=${klass} title=${title || nothing}>${linkedLine(line)}</div>`;
 }
 
 // A hook notice's line: its own (a snapshot's notice), else "<hook>: text".

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

@@ -13,9 +13,18 @@ import { archivedBadge, rowBadgesTemplate, rowDotTemplate } from "./families_vie
 import { html, nothing } from "./vendor/lit-html.js";
 
 // The opener a new link's composer is filled with (never sent: the user
-// edits or sends it). The same for every chain.
+// edits or sends it) when the continue brings none of its own.
 export const CONTINUE_OPENER = "Continue where we left off.";
 
+// What a new link's composer is filled with: the continue's own opener
+// (+created+, the 201: the previous link's first typed message, when that
+// link continues one), else CONTINUE_OPENER. So whatever the user sent on
+// the last link comes back on the next one.
+export function openerText(created) {
+  const own = created?.opener;
+  return typeof own === "string" && own.trim() ? own : CONTINUE_OPENER;
+}
+
 // Whether +text+ (a title or a first message) is the opener and nothing
 // else, trimmed: "Continue where we left off. Then fix X" is a title of its own.
 export function isOpener(text) {
@@ -41,6 +50,17 @@ export function chainTitle(s, byId) {
   return isOpener(at.first_preview || at.last_prompt) ? own : previewForCard(at);
 }
 
+// The open session's title (app.js updateSessionTitle: the top bar and the
+// tab) from +first+, its first message: it follows its card. A chain link
+// (+shown+, its summary, has continues) reads +cardTitle+(shown) whatever
+// its first message: a web link inherits its chain's title, and its first
+// message is an opener (the constant or the user's own). Else +first+,
+// unless it is the opener. +shown+ null: not listed yet, +first+.
+export function openTitle({ shown, first, cardTitle }) {
+  if (shown && (shown.continues || isOpener(first))) return cardTitle(shown);
+  return first;
+}
+
 const createdMs = (s) => {
   const ms = Date.parse(s?.created_at || "");
   return Number.isNaN(ms) ? 0 : ms;

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

@@ -120,6 +120,15 @@ export function sendCommand(id, line, { clientId, card = false, ...opts } = {})
   });
 }
 
+// A text's markdown as sanitised HTML ({ html }; null with markdown off).
+export function renderText(text, opts = {}) {
+  return api("/api/render", {
+    method: "POST",
+    body: JSON.stringify({ text }),
+    ...opts,
+  });
+}
+
 export function cancelTurn(id, opts = {}) {
   return api(`/api/sessions/${id}/cancel`, {
     method: "POST",

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

@@ -326,6 +326,22 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .bubble.question>summary .question-said{max-width:72ch;margin:2px 0 1px 1.05em;font-size:12.5px;font-weight:400;line-height:1.5;color:var(--text-muted);white-space:normal;overflow-wrap:anywhere;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;line-clamp:2;overflow:hidden}
 .bubble.question[open]>summary .question-said{display:none}
 .question-said-full{margin:4px 0 6px;font-size:13px;line-height:1.55;color:var(--text-muted);white-space:pre-wrap;overflow-wrap:anywhere}
+/* Its markdown once the card is first opened (question_cards.js renderSaidOnOpen), as compact as the stage's. */
+.question-said-full.markdown{white-space:normal}
+.question-said-full.markdown :is(h1,h2,h3,h4,h5,h6){font-size:13.5px;font-weight:600;line-height:1.4;margin:8px 0 2px;color:var(--text-2)}
+.question-said-full.markdown :is(p,ul,ol,blockquote,table,pre){margin:0 0 6px}
+.question-said-full.markdown>:first-child{margin-top:0}
+.question-said-full.markdown>:last-child{margin-bottom:0}
+.question-said-full.markdown :is(ul,ol){padding-left:1.3em}
+.question-said-full.markdown li>:is(ul,ol){margin:0}
+.question-said-full.markdown hr{border:0;border-top:1px solid var(--border);margin:8px 0}
+.question-said-full.markdown blockquote{border-left:3px solid var(--border-strong);padding-left:10px}
+.question-said-full.markdown code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:.88em}
+.question-said-full.markdown :not(pre)>code{background:var(--bg-inset);border:1px solid var(--border);border-radius:4px;padding:0 4px}
+.question-said-full.markdown pre{overflow:auto;padding:6px 8px;border-radius:6px;background:var(--bg-inset);border:1px solid var(--border);font-size:12px;line-height:1.45;white-space:pre}
+.question-said-full.markdown table{border-collapse:collapse;display:block;max-width:100%;overflow:auto}
+.question-said-full.markdown :is(th,td){border:1px solid var(--border-strong);padding:3px 7px;font-size:12.5px}
+.question-said-full.markdown th{background:var(--bg-inset);font-weight:600}
 .bubble.command{border-left:3px solid var(--text-faint);background:var(--bg-panel);font-size:13px}
 .bubble.note{border-left:3px dotted var(--text-faint);background:transparent;font-size:12px;color:var(--text-muted);opacity:.85}
 .note-line{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-faint);margin-bottom:2px}
@@ -438,6 +454,8 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .gen .activity-body>.hook-notice:first-child{border-top:none}
 .gen .hook-notice.warn{border-left-color:var(--warn);color:var(--warn-text)}
 .hook-notice.llm-context{border-left-style:dashed;cursor:help}
+.hook-notice a{color:inherit;text-decoration:underline;text-underline-offset:2px}
+.hook-notice a:hover{text-decoration-thickness:2px}
 /* A plugin's steer (a nudge into the running turn): a row of its step, or a bubble; its text collapsed. */
 .steer-row{font-size:13px;color:var(--text-3);border-left:2px solid var(--accent-border)}
 .steer-row>summary{cursor:pointer;list-style:none;font-style:italic}
@@ -708,9 +726,28 @@ body.stage-view .turn-stage{position:absolute;left:0;right:0;bottom:100%;margin-
 .ts-headline.thinking{font-size:13.5px;font-style:italic;color:var(--text-muted)}
 .ts-think-tag{font-style:normal;font-size:12.5px;color:var(--think-text);margin-right:6px}
 .ts-headline.fresh{animation:ts-fade .3s ease}
-/* While a question or approval waits: the whole reply that asked it, raw as a closed step's text, in the headline's
-   place; capped so the card keeps its room, read from the top (stage_view.js drawAsking). */
+/* While a question or approval waits: the whole reply that asked it, in the headline's place; raw as a closed step's
+   text, then its markdown when web.markdown is on (.markdown, stage_slots.js drawAsking); capped so the card keeps
+   its room, read from the top. */
 .ts-asking{max-height:calc(var(--stage-max,60vh) * .35);overflow:auto;scrollbar-width:thin;white-space:pre-wrap;overflow-wrap:anywhere;font-size:14px;line-height:1.55;color:var(--narr);border-left:2px solid var(--border-strong);padding-left:10px}
+/* Its markdown, compact: about the raw text's metrics, so the swap barely moves the slot. */
+.ts-asking.markdown{white-space:normal}
+.ts-asking.markdown :is(h1,h2,h3,h4,h5,h6){font-size:14.5px;font-weight:600;line-height:1.4;margin:8px 0 2px;color:var(--text-bright)}
+.ts-asking.markdown :is(h4,h5,h6){font-size:14px;color:var(--text-2)}
+.ts-asking.markdown :is(p,ul,ol,blockquote,table,pre){margin:0 0 6px}
+.ts-asking.markdown>:first-child{margin-top:0}
+.ts-asking.markdown>:last-child{margin-bottom:0}
+.ts-asking.markdown :is(ul,ol){padding-left:1.3em}
+.ts-asking.markdown li>:is(ul,ol){margin:0}
+.ts-asking.markdown strong{color:var(--text-bright)}
+.ts-asking.markdown hr{border:0;border-top:1px solid var(--border);margin:8px 0}
+.ts-asking.markdown blockquote{border-left:3px solid var(--border-strong);padding-left:10px;color:var(--text-muted)}
+.ts-asking.markdown code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:.88em}
+.ts-asking.markdown :not(pre)>code{background:var(--bg-inset);border:1px solid var(--border);border-radius:4px;padding:0 4px;color:var(--text)}
+.ts-asking.markdown pre{overflow:auto;padding:6px 8px;border-radius:6px;background:var(--bg-inset);border:1px solid var(--border);font-size:12.5px;line-height:1.45;white-space:pre}
+.ts-asking.markdown table{border-collapse:collapse;display:block;max-width:100%;overflow:auto}
+.ts-asking.markdown :is(th,td){border:1px solid var(--border-strong);padding:3px 7px;font-size:13px}
+.ts-asking.markdown th{background:var(--bg-inset);font-weight:600}
 .turn-stage.asking .ts-headline{display:none}
 @keyframes ts-fade{from{opacity:.35}}
 .ts-now{height:var(--ts-now-h);display:flex;align-items:center;gap:8px;min-width:0;padding:0 9px;border-radius:8px;background:var(--accent-tint);font-size:13px}

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

@@ -0,0 +1,55 @@
+// A hook notice line's http(s) URLs as links (a source-links `sources:`
+// line with markdown off): the terminals need the line as text, the web can
+// click it. Only http(s) URLs that refs.js httpUrl accepts (no userinfo, not
+// over-long) are linked; everything else stays text, escaped by lit (no
+// unsafeHTML). A link opens in a new tab: refs.js installRefClicks leaves a
+// plain <a> (no data-ref-kind) to the browser.
+import { html } from "./vendor/lit-html.js";
+import { httpUrl } from "./refs.js";
+
+// A candidate: the scheme, then anything up to a space or an angle bracket
+// (`<https://x/a>` links https://x/a).
+const CANDIDATE = /https?:\/\/[^\s<>]+/gi;
+const TRAILING = /[.,;:!?'"]+$/;
+
+// +url+ cut at its first ) that no ( inside it balances: `(https://x/a)`
+// ends before the ), `…/Foo_(bar)` keeps it (source_links.rb trim_url_end).
+function cutUnbalancedParen(url) {
+  let depth = 0;
+  for (let i = 0; i < url.length; i++) {
+    if (url[i] === "(") depth++;
+    else if (url[i] === ")") {
+      if (depth === 0) return url.slice(0, i);
+      depth--;
+    }
+  }
+  return url;
+}
+
+// A candidate without what ends the sentence around it: trailing
+// punctuation (the sources line's ", "), an unbalanced ), a ] no [ opens.
+function trimUrl(candidate) {
+  let url = cutUnbalancedParen(candidate.replace(TRAILING, ""));
+  if (url.endsWith("]") && !url.includes("[")) url = url.replace(/\]+$/, "");
+  return url.replace(TRAILING, "");
+}
+
+// +text+ with each http(s) URL a link (a lit template's array of strings
+// and <a> parts); +text+ itself when it links nothing, so a URL-less line
+// renders exactly as before.
+export function linkedLine(text) {
+  if (typeof text !== "string" || !text) return text;
+  const parts = [];
+  let last = 0;
+  for (const match of text.matchAll(CANDIDATE)) {
+    const shown = trimUrl(match[0]);
+    const href = httpUrl(shown);
+    if (!href) continue;
+    if (match.index > last) parts.push(text.slice(last, match.index));
+    parts.push(html`<a href=${href} target="_blank" rel="noopener noreferrer">${shown}</a>`);
+    last = match.index + shown.length;
+  }
+  if (!parts.length) return text;
+  if (last < text.length) parts.push(text.slice(last));
+  return parts;
+}

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

@@ -31,6 +31,9 @@ import { continueLine } from "./commands.js";
 // @param removeHintIfEmpty () drops the history's placeholder hint
 // @param askingText () => the running turn's asking reply (turn_model.js
 //   askingText via the page's view), kept by a question or own approval card
+// @param renderMarkdown (text) => Promise<html|null>: the kept reply's
+//   markdown (the page's POST /api/render; null keeps the raw text)
+// @param linkRefs (el) the page's path:line ref pass on it
 // @param api {sendAnswer, dismissQuestion, sendCommand} (data.js)
 // @param doc the page's document
 // @return {renderQuestion(pq, {said}), resolveQuestion(id, opts), removeQuestion(),
@@ -38,6 +41,7 @@ import { continueLine } from "./commands.js";
 //   renderContinue(offer), resolveContinue(data), forgetContinue()}
 export function createQuestionCards({
   sessionId, clientId, place, isNearBottom, scrollToEnd, removeHintIfEmpty, askingText = () => "",
+  renderMarkdown = () => Promise.resolve(null), linkRefs = () => {},
   api = { sendAnswer, dismissQuestion, sendCommand }, doc = globalThis.document,
 }) {
   // Live ask_user_question card, keyed by pending question id. Re-rendered from
@@ -403,13 +407,14 @@ export function createQuestionCards({
     // the toggle's label), and whole, selectable, at the top of the body
     // when it is open (a drag in the summary would toggle the card).
     const asked = saidOf.get(questionEl);
+    let full = null;
     if (summary && asked) {
       const line = doc.createElement("div");
       line.className = "question-said";
       line.setAttribute("aria-hidden", "true");
       line.textContent = asked;
       summary.appendChild(line);
-      const full = doc.createElement("div");
+      full = doc.createElement("div");
       full.className = "question-said-full";
       full.textContent = asked;
       questionEl.insertBefore(full, summary.nextSibling);
@@ -421,9 +426,36 @@ export function createQuestionCards({
     const keepNote = questionEl.dataset.toggled || (!cancelled && deniedReason(pending, answer));
     if (summary && !keepNote) note.classList.add("hidden");
     if (!questionEl.dataset.toggled) questionEl.open = false;
+    // After the collapse: a card left open by hand renders at once.
+    if (full) renderSaidOnOpen(questionEl, full, asked);
     pending = null;
   }
 
+  // The body's copy as markdown, from the card's first open on (a reload
+  // draws every card in the history: rendering them all would ask once per
+  // card). Raw until then, and when the render answers null (then the next
+  // open asks again).
+  function renderSaidOnOpen(card, full, asked) {
+    let state = "raw";
+    const draw = () => {
+      if (!card.open || state !== "raw") return;
+      state = "asking";
+      Promise.resolve()
+        .then(() => renderMarkdown(asked))
+        .catch(() => null)
+        .then((html) => {
+          if (!html) { state = "raw"; return; }
+          state = "done";
+          // Sanitised on the server (POST /api/render).
+          full.innerHTML = html;
+          full.classList.add("markdown");
+          linkRefs(full);
+        });
+    };
+    card.addEventListener("toggle", draw);
+    draw();
+  }
+
   function markQuestionSelection(sel) {
     if (!questionEl || !sel.length) return;
     questionEl.querySelectorAll(".question-choice").forEach((button) => {

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

@@ -19,10 +19,19 @@ export function node(tag, cls, parent = null) {
 // +taskStop+: the page's stopper (task_stop.js), for the stop-task button
 // on a running task_wait; +gens()+ the running turn's gens (the button's
 // command, read at its click); +onChange+ redraws (the stage's
-// scheduleRefresh).
-export function createStageSlots({ headline, asking, now, trail, ticks, taskStop = null, gens, onChange }) {
+// scheduleRefresh). +renderMarkdown(text)+: the asking text's HTML
+// (Promise<string|null>; null keeps the raw text: markdown off, a failed
+// read); +linkRefs(el)+: the page's path:line ref pass on the slot.
+export function createStageSlots({
+  headline, asking, now, trail, ticks, taskStop = null, gens, onChange,
+  renderMarkdown = () => Promise.resolve(null), linkRefs = () => {},
+}) {
   // What each slot shows, so an unchanged slot is left alone.
   const shown = { headline: null, now: null, trail: null, asking: null };
+  // The last asking text sent to render and its answer (in flight or
+  // done, HTML only): the same question drawn again (after a reset, a
+  // blank between) asks no second time.
+  let rendering = { text: null, html: null };
 
   function drawHeadline({ text, thinking }) {
     const key = `${thinking ? "t" : "n"}|${text}`;
@@ -42,13 +51,35 @@ export function createStageSlots({ headline, asking, now, trail, ticks, taskStop
 
   // Patched only when the text changes (a late chunk to the closed gen
   // rewrites the same text): a selection in it survives. A new text reads
-  // from its top.
+  // from its top: drawn raw at once, then swapped for its markdown when
+  // that comes back while the slot still shows the same text (the text is
+  // final: it shows only once the call that asks runs).
   function drawAsking(text) {
     asking.hidden = !text;
     if (shown.asking === text) return;
     shown.asking = text;
+    asking.classList.remove("markdown");
     asking.textContent = text;
     asking.scrollTop = 0;
+    if (!text) return;
+    linkRefs(asking);
+    if (rendering.text !== text) {
+      let html;
+      try { html = Promise.resolve(renderMarkdown(text)).catch(() => null); } catch (_) { html = Promise.resolve(null); }
+      rendering = { text, html };
+    }
+    const pending = rendering;
+    pending.html.then((html) => {
+      // A null isn't kept: the next draw of this text asks again.
+      if (!html && rendering === pending) rendering = { text: null, html: null };
+      // Swapped once: a blank-then-same draw while in flight waits twice.
+      if (!html || shown.asking !== text || asking.classList.contains("markdown")) return;
+      // Sanitised on the server (POST /api/render), as an answer's HTML is.
+      asking.innerHTML = html;
+      asking.classList.add("markdown");
+      asking.scrollTop = 0;
+      linkRefs(asking);
+    });
   }
 
   function drawNow(tool, quiet) {
@@ -123,6 +154,7 @@ export function createStageSlots({ headline, asking, now, trail, ticks, taskStop
   function reset() {
     for (const slot of [headline, asking, now, trail, ticks]) slot.replaceChildren();
     asking.hidden = true;
+    asking.classList.remove("markdown");
     shown.headline = shown.now = shown.trail = shown.asking = null;
   }
 

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

@@ -48,8 +48,12 @@ function readCollapsed() {
 // the history only for a reader at its end). +dockEl+, +centerEl+ and
 // +composerEl+ size the stage's cap.
 // +taskStop+: the page's stopper (task_stop.js), for the stop-task button
-// on a running task_wait.
-export function createStageView({ historyEl, appendToHistory, isNearBottom: historyNearBottom, sawText, sessionId, dockEl, centerEl, composerEl, taskStop = null }) {
+// on a running task_wait. +renderMarkdown+ and +linkRefs+: the asking
+// slot's markdown read and ref pass (stage_slots.js).
+export function createStageView({
+  historyEl, appendToHistory, isNearBottom: historyNearBottom, sawText, sessionId, dockEl, centerEl, composerEl, taskStop = null,
+  renderMarkdown, linkRefs,
+}) {
   // 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");
@@ -82,7 +86,8 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   headline.setAttribute("role", "button");
   headline.title = "Show this step's reasoning";
   // While a question or approval waits: the whole reply that asked it, in
-  // the headline's place (the card says what to answer, this says why).
+  // the headline's place (the card says what to answer, this says why),
+  // as markdown when web.markdown is on.
   const asking = node("div", "ts-asking", live);
   asking.hidden = true;
   const now = node("div", "ts-now", live);
@@ -111,7 +116,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   // "queued"), each to run as a turn of its own; they hand off last.
   const queuedSlot = node("div", "ts-queued", stage);
   const slotsView = createStageSlots({
-    headline, asking, now, trail, ticks, taskStop,
+    headline, asking, now, trail, ticks, taskStop, renderMarkdown, linkRefs,
     gens: () => view.current().turn?.gens,
     onChange: () => scheduleRefresh(),
   });

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

@@ -37,6 +37,7 @@ import { createSentenceFeed } from "./sentences.js";
 import { createTicker } from "./thinking_ticker.js";
 import * as model from "./turn_model.js";
 import { createHold } from "./hold.js";
+import { linkedLine } from "./notice_links.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 
 // ---- The templates: one step, its thinking, its label ----
@@ -99,10 +100,10 @@ export function stepTemplate(gen, st = {}) {
 
 // A hook's line (hook_notice) as a step's row. data.line is a whole row of
 // chi's own (an empty-answer retry), shown as is; data.cls a class of its
-// own and data.title its hover (a ✂ row's).
+// own and data.title its hover (a ✂ row's). Its http(s) URLs are links.
 function noticeTemplate(data) {
   const cls = "hook-notice" + (data.level === "warn" ? " warn" : "") + (data.cls ? ` ${data.cls}` : "");
-  return html`<div class=${cls} title=${data.title || nothing}>${data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}`}</div>`;
+  return html`<div class=${cls} title=${data.title || nothing}>${linkedLine(data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}`)}</div>`;
 }
 
 // +template+ rendered as detached nodes (a fragment).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.72.0
+  version: 0.73.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -614,6 +614,7 @@ files:
 - lib/samagotchi/web/public/llm_context_chip.js
 - lib/samagotchi/web/public/model_pick.js
 - lib/samagotchi/web/public/model_picker.js
+- lib/samagotchi/web/public/notice_links.js
 - lib/samagotchi/web/public/notifications.js
 - lib/samagotchi/web/public/notify.js
 - lib/samagotchi/web/public/prompt_history.js