samagotchi 0.113.0 → 0.114.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc980123c32fef67a2b47defad94735286ba983537b227ba79961cf6b15f1f1a
-  data.tar.gz: 5768a7d054c2a36abd746b6a19b7126fa6e992915bbae6040d2990b1903754bf
+  metadata.gz: a59aa63d1ccf6a6114afcaf5b1cf19088cb482989c08acb3aa5bfede3a67358d
+  data.tar.gz: 3fe5245e7c864ca0b814d9b187b402d5658ffd88aa5d895881482f4b40e9391f
 SHA512:
-  metadata.gz: 906dcb1ea43aeb750b201f75ef585648c609c89e77b0a8ff2bc06e11aa06ece5bec4b7734a1ecff888099952c90e7898c1dc91d64fbe52b4ddbbf102ddefff3a
-  data.tar.gz: 05a0edaf338b7a33bb3ffa73a4b590bff8498d789004c12c3f85a7e52ccb2516c4a58c332ae7fb203b9e04131fb36d1b5bb8c1f0f2fc2373e03ef6ded9ccd366
+  metadata.gz: 412b5e6a15d73f4817729879e71aa3f2813ae73705039a8db561cbafffa0e246f6cf0f37760ebf346144c88369174a42cd902f36d31f3c02703345c99d18505f
+  data.tar.gz: 25d265a240a37194b5670afeb6d4784b55b43ddb33a857039da16ffc1a1184d79a6a4b30e7111a8c0698f538c130cd2c930545c03e3474a9bbf814bd22dbb48f

data/CHANGELOG.md

@@ -8,6 +8,28 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.114.0] - 2026-10-25
+
+### Added
+
+- Auto titles: the idle recap also writes a 2-6 word title for the session, in the same request, and a session
+  without a `/title` is named by it on the web's cards, top bar, tab and notifications and in `chi sessions list`
+  (json: `auto_title`). Later recaps keep it unless the focus moved; a hand title always wins.
+- chi web tells you Markdown rendering exists: while `web.markdown` is off, a session shows a one-line tip (restart
+  chi web with `--web-markdown`, or `web.markdown: true` in config.yml; plus `gem install commonmarker` when the gem
+  is missing). Its × hides it for that browser.
+- `chi bootstrap` on a terminal asks "Render answers as Markdown in chi web? [Y/n]": yes installs the commonmarker
+  gem when it is missing and writes `web: markdown: true` into config.yml, its comments kept; a failed install says
+  why in one line and writes nothing. Without a terminal, a new config's next steps name `chi web --web-markdown`.
+
+### Fixed
+
+- chi web's all sessions list: once it held more cards than fit, every card was cut to 72px whatever it held, so a
+  two-line title's meta row ran over the card's border and a parent's "▸ N delegates" chip was drawn under the next
+  card, out of reach.
+
+Update with `chi update` (the system bundle 0.114.0), then restart `chi web`.
+
 ## [0.113.0] - 2026-10-25
 
 ### Added
@@ -4314,7 +4336,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.113.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.114.0...HEAD
+[0.114.0]: https://github.com/dm1try/samagotchi/compare/v0.113.0...v0.114.0
 [0.113.0]: https://github.com/dm1try/samagotchi/compare/v0.112.0...v0.113.0
 [0.112.0]: https://github.com/dm1try/samagotchi/compare/v0.111.1...v0.112.0
 [0.111.1]: https://github.com/dm1try/samagotchi/compare/v0.111.0...v0.111.1

data/docs/cli.md

@@ -99,6 +99,16 @@ chi bootstrap                            # try localhost 8080, 11434, 1234, 8000
   you uninstalled stays out ([Bundle profiles](memory.md#bundle-profiles-core-and-dev)).
   A bundle that fails to install makes the exit 1. `--dry-run` says what it
   would install.
+- **Markdown in chi web.** Then, on a terminal and unless config.yml has
+  `web: markdown: true` already, it asks `Render answers as Markdown in chi web? [Y/n]`
+  (a closed stdin is no). Yes installs the `commonmarker` gem when it is
+  missing (`gem install commonmarker` through the Ruby chi runs on; it can take
+  a while where no precompiled build exists) and writes `web: markdown: true`
+  into config.yml, its comments kept ("web: markdown on (config.yml)"). A failed
+  install says so in one line with gem's last output line, writes nothing and
+  leaves the exit code as it was. Without a terminal it doesn't ask; a new
+  config's next steps then name `chi web --web-markdown`. `--dry-run` says it
+  would ask.
 
 ### Writing a bundle: new, test, check
 
@@ -710,8 +720,9 @@ attach and `chi -p --non-interactive` are refused. `/parent-answers` alone answe
 mid-turn too; a change waits for the turn's end. No chip: its reply is where the
 web shows it. See [Guardrails](guardrails.md#answers-from-a-parent-agent).
 
-`/title` shows the session's title (`title: Coordinator`, or `title: none (shows
-the first message: …)`); `/title TEXT` names the session (whitespace collapsed,
+`/title` shows the session's title (`title: Coordinator`, or without one what names
+the session: `title: none (shows the auto title: …)`, the recap's, or `title: none
+(shows the first message: …)`); `/title TEXT` names the session (whitespace collapsed,
 cut at 80 characters), `/title --clear` drops the name (anything after `--clear`
 is refused with the usage line). It is saved at once,
 mid-turn too, and the lists, cards, top bar and tab show it in place of the first
@@ -897,7 +908,8 @@ Bundler, `gem install commonmarker`):
 chi web --web-markdown
 ```
 
-The setting also supports `SAMAGOTCHI_WEB_MARKDOWN=true` or the global config:
+`chi bootstrap` offers to turn it on (and install commonmarker) on a terminal
+(see [First setup](#first-setup)). The setting also supports `SAMAGOTCHI_WEB_MARKDOWN=true` or the global config:
 
 ```yaml
 web:
@@ -914,7 +926,11 @@ 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.
+warning explaining how to install the optional gem. While Markdown is off, the
+owner's session view shows a one-line tip saying how to turn it on (and, when
+commonmarker isn't installed, how to install it; the text is the server's,
+`markdown_tip` in the session payloads, never on a participant's page); its ×
+hides it for that browser (`chi_markdown_tip_dismissed` in localStorage).
 
 Every prompt and answer has a copy button (on hover; always shown, dimmed, on a
 touch screen), and so does each code block of a rendered answer. An answer

data/docs/configuration.md

@@ -50,7 +50,8 @@ hosts:
 # alias is applied, and its host:/the alias's host picks the host when host_ref
 # is left out; a model naming no host goes where a bare --model goes (the
 # default host). A model naming another host than host_ref turns recap off with
-# a warning. recap: false turns it off.
+# a warning. recap: false turns it off. Each recap also names the session with
+# a short auto title (shown when it has no /title), in the same request.
 recap:
   # host_ref: small-box
   # model: your-small-model-id

data/docs/internals/prompt-caching.md

@@ -124,7 +124,8 @@ right-hand column happens.
   only when the first participant joins and when the last leaves or expires: one history re-read each, then stable.
   Under D3(a) the declared tools stay the session's, so an author switch costs nothing: the review boundary is a
   gate on the calls, not a toolkit switch. The forged-header mark (`(quoted) `) is a pure function of the text too.
-- Side requests (idle recap, `/btw`) go through `IdleClient` with their own short system prompt. On a current
+- Side requests (idle recap, `/btw`) go through `IdleClient` with their own short system prompt (the recap's also
+  asks for its auto title line, `RecapPrompt::TITLE`: static text, still that one request). On a current
   llama.cpp they don't evict the session (see the server settings below); chi never pins them to a slot.
 
 ## The turn-end warm-up

data/docs/sessions.md

@@ -237,9 +237,9 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
 
 ## Session titles
 
-A session is named by its first message until you give it a title: `/title Coordinator` (in the REPL, an attached terminal, the web composer or `chi send -m "/title Coordinator" ID`; a parent agent may name its delegates the same way). The title is saved in the session file (`title`), whitespace collapsed and cut at 80 characters, and runs mid-turn too, at once. `/title` alone shows it (`title: none (shows the first message: hey chi …)` without one); `/title --clear` drops it, and the first message names the session again. A session whose first line was the command itself (`chi send --new -m "/title X"`) takes its preview from its first real message.
+A session is named by its first message until you give it a title: `/title Coordinator` (in the REPL, an attached terminal, the web composer or `chi send -m "/title Coordinator" ID`; a parent agent may name its delegates the same way). The title is saved in the session file (`title`), whitespace collapsed and cut at 80 characters, and runs mid-turn too, at once. `/title` alone shows it (`title: none (shows the auto title: Parser tab handling)` or `title: none (shows the first message: hey chi …)` without one); `/title --clear` drops it, and the first message names the session again. A session whose first line was the command itself (`chi send --new -m "/title X"`) takes its preview from its first real message.
 
-Without a title, the web names a session by its recap's first sentence once it has one (see [Session recap](cli.md#session-recap); its subject phrase stripped), else by its first message: on its card (which then leaves out its recap line, the same sentence), the families and chain rows, the top bar and the browser tab, the delete confirm and the search; `chi sessions list` already reads title, else recap, else the first message. The notifications keep the first message. A participant's page is unchanged (the title or the review's subjects).
+Without a title, a session is named by its **auto title** once its recap has one, else by its recap's first sentence (see [Session recap](cli.md#session-recap); its subject phrase stripped), else by its first message: on its card (which leaves out its recap line when the name is that same sentence), the families and chain rows, the top bar and the browser tab, the delete confirm and the search, the tab's and the phone's notifications, and `chi sessions list` (plain and `--live`; json has `auto_title`, tsv and json's `desc` keep the first message). The auto title is 2-6 words the recap's model writes on the line before the recap, in the same request (`Title: …`, split off by `RecapTitle`; the recap text never holds it). It is saved in the session's `recap.json` (`title`), so it goes when a stale recap is dropped; each later recap is shown the earlier title and keeps it unless the focus moved, and a reply without a usable one (not 2-6 words, or naming the user or the assistant) keeps the earlier title. A hand title always wins and is never overwritten. With the recap off no new auto title is written; a saved one still shows. The auto title is for display only: never in a model request (the `list_sessions` tool, `ctx.sessions`, a parent's children, `chi broadcast` keep the title, else the first message), nor on the terminal's status row, nor on a participant's page (the title or the review's subjects).
 
 The title names the session wherever its first message did: `chi sessions list` (plain, `--live`, tsv and json's `desc`, before the recap; json has `title` too), `chi sessions delete`'s line, the `list_sessions` tool, `chi broadcast`, the desktop helper, a parent's children (the coordinator bundle's `/children` card, `ctx.sessions.children`; `ctx.sessions.read` too), and in the web the cards, the families and chain rows, the top bar and the browser tab, the notifications and the search; the terminal's status row too (the REPL's and an attached one's, first, see [Status Line](cli.md#status-line)). In the web, `✎` (Rename this session) sits next to the session's title, on its active strip card or after the top bar's title: a small input over the title, prefilled with it; Enter or a click elsewhere sends `/title TEXT` when it changed (empty: `/title --clear`), Esc closes it unsent, and so does the title leaving the screen (All sessions opened, the card swiped out of a phone's strip). A session a chi REPL owns has no `✎`, nor one that shows no title yet (`/title` still works from the composer). A continue's new link keeps the title (see [Session chains](#session-chains)). An older `chi web` (or any chi from before the field) that saves a session drops its title: restart `chi web` after upgrading.
 
@@ -257,7 +257,7 @@ A session can **continue** an earlier one: "the next run of the same routine" (a
 - **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`, `thinking`, `settings`, `toolkit`, `tools`, `no_tools` or `parent_answers` (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 written in this session stays instead; one carried over from another session or the start page gives way to the opener, and the toast's **Restore draft** brings it back): 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 id, its full start (`2026-10-10 14:32`) and its preview in the tooltip; a neighbour that started on the open link's own day shows its time instead (`← 09:12`, `14:32 →`). A link made by `continue →` inherits the previous link's preview (and its title, if it has one) 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 with a recap of its own reads its recap's first sentence instead (a link without one reads its chain's name, and a first link's recap names its chain). 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 `↩ #N` chip (`#N of M` when later links aren't listed; its tooltip `Session chain: link N of M`) opens a popover of the other links, newest first (`#N`, its date, with its time (`2026-10-17 14:32`) when another link of the chain started the same day, its own title when it differs from the card's (a link inherits its chain's, so mostly it doesn't), else its recap's first sentence, else 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 `#N of M`, with its own delegates folded in, so a search finds an earlier link and its delegates.
+- **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 written in this session stays instead; one carried over from another session or the start page gives way to the opener, and the toast's **Restore draft** brings it back): 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 id, its full start (`2026-10-10 14:32`) and its preview in the tooltip; a neighbour that started on the open link's own day shows its time instead (`← 09:12`, `14:32 →`). A link made by `continue →` inherits the previous link's preview (and its title, if it has one) 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 with a recap of its own reads its auto title, else its recap's first sentence, instead (a link without one reads its chain's name, and a first link's recap names its chain). 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 `↩ #N` chip (`#N of M` when later links aren't listed; its tooltip `Session chain: link N of M`) opens a popover of the other links, newest first (`#N`, its date, with its time (`2026-10-17 14:32`) when another link of the chain started the same day, its own title when it differs from the card's (a link inherits its chain's, so mostly it doesn't), else its recap's first sentence, else 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 `#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/bootstrap_command.rb

@@ -5,6 +5,7 @@ require_relative "config"
 require_relative "model_profile"
 require_relative "host_registry"
 require_relative "host_keys"
+require_relative "gem_update"
 require_relative "bootstrap/probe"
 require_relative "bootstrap/config_writer"
 require_relative "bootstrap/bundles"
@@ -18,7 +19,8 @@ module Samagotchi
   # Anthropic's Messages API, Bootstrap::Probe), picks the model, sends one
   # test request and writes config.yml: a fresh file, or a hosts: entry
   # added to an existing one. Then it installs the
-  # system bundle and the core profile, and on a terminal asks about dev.
+  # system bundle and the core profile, and on a terminal asks about dev
+  # and Markdown in chi web (installing commonmarker when it is missing).
   # Prompts only on a terminal; a script gets the list and exit 2 instead.
   class BootstrapCommand
     include CLI::Command
@@ -53,7 +55,7 @@ module Samagotchi
         entry added (after a backup), and its other lines stay as they are.
         Then it installs the system bundle and the core bundles (loop-guard,
         check-in, guardrails, slow-commands, agents-md), and on a terminal
-        offers the dev bundles.
+        offers the dev bundles and Markdown in chi web.
     TEXT
 
     FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS) do |f|
@@ -75,13 +77,18 @@ module Samagotchi
     DEV = "dev"
     # The config outcomes after which the bundles are installed.
     INSTALLS_BUNDLES = %i[new appended exists snippet].freeze
+    # The optional gem chi web renders Markdown with (web.markdown).
+    MARKDOWN_GEM = "commonmarker"
+    MARKDOWN_HINT = "answers stay plain text — gem install #{MARKDOWN_GEM}, then chi web --web-markdown".freeze
 
     # @param argv [Array<String>] the arguments after "bootstrap"
     # @param probe [Bootstrap::Probe, nil] (specs)
     # @param bundles [Bootstrap::Bundles, nil] (specs: the bundles go where
     #   the process ENV points, not +env+)
+    # @param gem_runner [#run] runs `gem install commonmarker` (GemUpdate::Runner)
+    # @param gem_present [#call, nil] → whether commonmarker is installed
     def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, env: ENV, probe: nil, config_path: nil,
-                   platform: RbConfig::CONFIG["host_os"], bundles: nil)
+                   platform: RbConfig::CONFIG["host_os"], bundles: nil, gem_runner: GemUpdate::Runner.new, gem_present: nil)
       @argv = argv.dup
       @stdin = stdin
       @stdout = stdout
@@ -91,6 +98,9 @@ module Samagotchi
       @config_path = config_path || ConfigFile.global_path(env: env)
       @platform = platform
       @bundles = bundles || Bootstrap::Bundles.new
+      @gem_runner = gem_runner
+      # Installed, without loading its native extension into this process.
+      @gem_present = gem_present || -> { Gem::Specification.find_all_by_name(MARKDOWN_GEM).any? }
     end
 
     # @return [Integer] 0 written (or already there), 1 failed (a failed
@@ -358,7 +368,8 @@ module Samagotchi
     end
 
     # The system bundle, core, and dev when a terminal says yes: one line
-    # each. 1 when something failed.
+    # each. Then Markdown in chi web (#offer_markdown). 1 when a bundle
+    # failed; the Markdown step never changes it.
     def install_bundles(dry_run: false)
       ok = system_bundle_line(@bundles.sync_system(dry_run: dry_run), dry_run)
       ok = install_profile(CORE, dry_run) && ok
@@ -366,9 +377,61 @@ module Samagotchi
         @stdout.print("Also install #{DEV} (#{members.join(", ")})? [y/N] ")
         ok = install_profile(DEV, false) && ok if @stdin.gets.to_s.strip.downcase.start_with?("y")
       end
+      offer_markdown(dry_run)
       ok ? 0 : 1
     end
 
+    # On a terminal, unless config.yml has web.markdown on already: ask, and
+    # on yes install commonmarker when it is missing, then write
+    # web.markdown: true. A closed stdin is no, whatever the default.
+    # Sets @markdown_on for #next_steps.
+    def offer_markdown(dry_run)
+      @markdown_on = markdown_on?
+      return if @markdown_on || !tty?
+      return @stdout.puts("web: would ask about Markdown in chi web") if dry_run
+
+      @stdout.print("Render answers as Markdown in chi web? [Y/n] ")
+      answer = @stdin.gets
+      return if answer.nil?
+
+      answer = answer.strip.downcase
+      return unless answer.empty? || answer.start_with?("y")
+
+      @markdown_on = install_markdown_gem && write_markdown
+    end
+
+    # Whether @config_path (not the process's Config) has web.markdown on.
+    def markdown_on?
+      data = ConfigFile.read_yaml(path: @config_path)
+      raw = data["web"]["markdown"] if data.is_a?(Hash) && data["web"].is_a?(Hash)
+      Config.coerce!(Config.find_by_key("web.markdown"), raw) == true
+    rescue SessionConfig::Error
+      false
+    end
+
+    # true when commonmarker is there or `gem install` (this Ruby's own gem
+    # command) put it there; else one line with gem's last word on it.
+    def install_markdown_gem
+      return true if @gem_present.call
+
+      @stdout.puts("#{MARKDOWN_GEM}: installing…")
+      output, ok = @gem_runner.run([GemUpdate.gem_bin, "install", MARKDOWN_GEM, "--no-document"])
+      return true if ok
+
+      last = output.to_s.lines.map(&:strip).reject(&:empty?).last || "no output"
+      @stdout.puts("#{MARKDOWN_GEM}: install failed (#{last}); #{MARKDOWN_HINT}")
+      false
+    end
+
+    def write_markdown
+      ConfigFile.write_setting!("web.markdown", true, path: @config_path)
+      @stdout.puts("web: markdown on (config.yml)")
+      true
+    rescue StandardError => e
+      @stdout.puts("web: markdown not written (#{e.message.lines.first.to_s.strip}); #{MARKDOWN_HINT}")
+      false
+    end
+
     # One line for the profile; false when it (or a member) failed.
     def install_profile(name, dry_run)
       profile_line(@bundles.install(name, dry_run: dry_run), dry_run)
@@ -477,7 +540,9 @@ module Samagotchi
     def next_steps
       dev = dev_to_install
       bundles = dev.empty? ? ["chi bundle list", "the installed bundles"] : ["chi bundle install #{DEV}", "more bundles (#{dev.join(", ")})"]
-      lines = [["chi", "a session"], ["chi web --open", "the web UI"], bundles]
+      lines = [["chi", "a session"], ["chi web --open", "the web UI"]]
+      lines << ["chi web --web-markdown", "Markdown answers#{" (needs gem install #{MARKDOWN_GEM})" unless @gem_present.call}"] unless @markdown_on
+      lines << bundles
       lines << ["chi desktop install", "macOS \"Send to chi\" helper"] if @platform.to_s.include?("darwin")
       lines.each_with_index do |(command, what), i|
         @stdout.puts("#{i.zero? ? "next:" : "     "}  #{command.ljust(22)} # #{what}")

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

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

data/lib/samagotchi/config.rb

@@ -1245,6 +1245,30 @@ module Samagotchi
       true
     end
 
+    # Sets one registry key (a Config::Entry with a section.key yaml_path,
+    # e.g. "web.markdown") in config.yml, its value typed as the entry
+    # reads it (true is written bare); the rest of the file, comments
+    # included, stays as written (ConfigTextEdit). No Config.reload!: a
+    # caller reading Config.get afterwards reloads itself.
+    # @raise [ArgumentError] an unknown key, or one config.yml doesn't hold
+    #   as section.key
+    # @raise [SessionConfig::Error] a value the entry's type doesn't take
+    def write_setting!(key, value, env: ENV, path: global_path(env: env))
+      entry = Config.find_by_key(key)
+      raise ArgumentError, "unknown config key: #{key}" unless entry
+      raise ArgumentError, "#{key} isn't a section.key setting of config.yml" unless entry.config_exposed? && entry.yaml_path.size == 2
+
+      typed = Config.coerce!(entry, value)
+      raise ArgumentError, "#{key} needs a value" if typed.nil?
+
+      section, leaf = entry.yaml_path
+      expected = deep_copy(read_yaml(env: env, path: path) || {})
+      expected[section] = {} unless expected[section].is_a?(Hash)
+      expected[section][leaf] = typed
+      write_config_key(path, section, leaf, typed, expected)
+      typed
+    end
+
     def model_aliases(env: ENV, path: global_path(env: env))
       data = read_yaml(env: env, path: path)
       return {} unless data.is_a?(Hash)

data/lib/samagotchi/config_text_edit.rb

@@ -25,7 +25,8 @@ module Samagotchi
     # @param text [String, nil] the file's text (nil: no file)
     # @param section [String] a top-level key ("default")
     # @param key [String] the key under it; an existing key matches in any case
-    # @param value [String] the value, written as a quoted string
+    # @param value [String, Integer, Boolean] the value: a string quoted, an
+    #   Integer or true/false bare (as the file's types read them back)
     # @param expected [Hash] the whole file's data after the change
     # @return [String] the new text
     def set(text, section:, key:, value:, expected:)
@@ -77,7 +78,13 @@ module Samagotchi
       line[/\A\s*(["']?)([^"':#\s][^"':#]*?)\1:(?:\s|\z)/, 2]
     end
 
-    # JSON's quoting is valid YAML: model ids hold "/" and ":".
-    def scalar(value) = JSON.generate(value.to_s)
+    # JSON's quoting is valid YAML: model ids hold "/" and ":". true, false
+    # and Integers go bare, so they read back as themselves, not as text.
+    def scalar(value)
+      case value
+      when true, false, Integer then value.to_s
+      else JSON.generate(value.to_s)
+      end
+    end
   end
 end

data/lib/samagotchi/gem_update.rb

@@ -39,8 +39,12 @@ module Samagotchi
       end
     end
 
+    # This Ruby's own gem command (chi bootstrap installs commonmarker with
+    # it too).
+    def self.gem_bin = File.join(RbConfig::CONFIG["bindir"], "gem")
+
     # @param fetcher [#call, nil] → the latest.json body (specs)
-    def initialize(env: ENV, fetcher: nil, runner: Runner.new, gem_bin: File.join(RbConfig::CONFIG["bindir"], "gem"))
+    def initialize(env: ENV, fetcher: nil, runner: Runner.new, gem_bin: GemUpdate.gem_bin)
       @env = env
       @fetcher = fetcher || method(:fetch)
       @runner = runner

data/lib/samagotchi/idle_recap.rb

@@ -11,6 +11,7 @@ require_relative "image_store"
 require_relative "output_formatter"
 require_relative "steer"
 require_relative "recap_store"
+require_relative "recap_title"
 require_relative "log"
 
 module Samagotchi
@@ -143,8 +144,17 @@ module Samagotchi
       # user decisions) — tolerated. The "we" variant was 4/4 consistent.
       # %<plain>s is the range, e.g. "2-4 plain sentences"; %<shape>s is SHAPE
       # or ONE_SHAPE.
+      # Auto-title spike (eval 0004, 2026-10-25; local Qwen3.8-Flash-Next,
+      # the 4 recap-spike sessions, first recap + update, N=5): a first-line
+      # title parsed in 50/50, 2-6 words and no actor in all, no recap
+      # regression against "Reply with the recap only" (one reply echoed
+      # "Blank line follows title." before the recap: RecapTitle drops it).
+      # Asked last, it was there in 15/50 and 4 replies were the title alone.
+      # A quoted example title (probe p0) was copied as the title: none here.
+      TITLE = "Reply with a title line, a blank line, then the recap. The title line is \"#{RecapTitle::LABEL} \" " \
+              "followed by 2-6 words naming the task, no actors. The recap: "
       SYSTEM = "You write short recaps of a chat between a user and an assistant, for the user " \
-               "coming back to it later. Reply with the recap only: %<plain>s, no heading, " \
+               "coming back to it later. #{TITLE}%<plain>s, no heading, " \
                "no preamble, no notes about the task or the transcript. Do not mention what the " \
                "transcript lacks or does not say; leave it out. Centre it on outcomes, not on " \
                "the order of events. %<shape>s Keep project names " \
@@ -169,6 +179,10 @@ module Samagotchi
       UPDATE = " You are given the earlier recap and the conversation since the earlier recap: " \
                "write an updated recap of the whole session that also covers what happened since " \
                "(do not just repeat the earlier recap)."
+      # With an earlier title (the user message's "Earlier title:" line): the
+      # spike kept it in 14/15 updates on the same task and changed it on 4/5
+      # where the focus moved, so a card doesn't rename at every idle window.
+      UPDATE_TITLE = " Keep the earlier title unless the focus moved."
       # Holds the length once the recap covers more (S0: an updated recap ran
       # to 6 sentences for 2-4 without it, within range+1 in 95%+ with it).
       # The first-sentence line keeps the list preview on the task.
@@ -210,7 +224,9 @@ module Samagotchi
       #   transcript to summarize
       # @param sentences [Array(Integer, Integer)] the range, from #sentences_range
       # @param offer [Boolean] a continue offer is open: add OFFER_LINE
-      def build(transcript, tool_count: nil, tool_names: [], previous: nil, sentences: DEFAULT_SENTENCES, offer: false)
+      # @param previous_title [String, nil] the earlier recap's title (with +previous+)
+      def build(transcript, tool_count: nil, tool_names: [], previous: nil, previous_title: nil, sentences: DEFAULT_SENTENCES,
+                offer: false)
         body = cap(transcript.to_s.strip)
         return nil if body.empty?
 
@@ -227,8 +243,11 @@ module Samagotchi
         one = sentences.last == 1
         range = { plain: sentences_text(sentences, "plain "), sentences: sentences_text(sentences),
                   shape: one ? ONE_SHAPE : SHAPE, focus: one ? "it" : "the first sentence" }
-        system = format(SYSTEM, range) + (previous ? UPDATE + format(UPDATE_LENGTH, range) : "") + tools
+        earlier_title = previous && !previous_title.to_s.strip.empty? ? previous_title.to_s.strip : nil
+        update = "#{UPDATE}#{UPDATE_TITLE if earlier_title}#{format(UPDATE_LENGTH, range)}"
+        system = format(SYSTEM, range) + (previous ? update : "") + tools
         user = +""
+        user << "Earlier title: #{earlier_title}\n\n" if earlier_title
         user << "Earlier recap:\n#{previous}\n\n" if previous
         user << "Transcript#{" since the earlier recap" if previous} (the system prompt and tool " \
                 "internals were removed; only user turns and assistant prose remain):\n---\n#{body}\n---\n"
@@ -269,8 +288,9 @@ module Samagotchi
     #   answer (the Worker's or the REPL's TurnFlow); read at each attempt
     attr_writer :awaiting_continue
 
-    # @return [Hash, nil] the last recap written: {text:, covered:,
-    #   covered_digest:, model:, created_at:}, where covered counts the
+    # @return [Hash, nil] the last recap written: {text:, title:, covered:,
+    #   covered_digest:, model:, created_at:} (title: the auto title, absent
+    #   when no reply gave one), where covered counts the
     #   session messages it summarizes and covered_digest fingerprints the
     #   last of them. With a store, loaded from it for each new session.
     def state
@@ -467,12 +487,13 @@ module Samagotchi
       return :nothing_new if transcript.strip.empty?
 
       prompt = RecapPrompt.build(transcript, tool_names: TranscriptFilter.tool_names(fresh), previous: previous&.dig(:text),
-                                                     sentences: @sentences, offer: offer_open?)
+                                             previous_title: previous&.dig(:title), sentences: @sentences, offer: offer_open?)
       return :nothing_new if prompt.nil?
 
       asked = target
       @in_flight = { thread: spawn_summarize(client_for(asked), prompt), generation: gen, deadline: @clock.call + @timeout,
-                     covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked.label }
+                     covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked.label,
+                     previous_title: previous&.dig(:title) }
       :started
     rescue StandardError
       :failed
@@ -499,9 +520,16 @@ module Samagotchi
       # An IdleClient::Summary names the model that answered; a plain String
       # (a stubbed client) doesn't, and the asked label stands in.
       served = recap.model if recap.respond_to?(:model)
-      text = recap.to_s
-      saved = { text: text, covered: job[:covered], covered_digest: job[:covered_digest],
-                model: served || job[:model], created_at: Time.now.utc.iso8601 }
+      # The title line off the recap (RecapTitle): the text is the recap
+      # alone. A reply without a title that passes keeps the earlier one, so
+      # a broken line doesn't blank the card; a title alone is no recap.
+      split = RecapTitle.split(recap.to_s)
+      text = split.body
+      return if text.empty?
+
+      title = split.title || job[:previous_title]
+      saved = { text: text, title: title, covered: job[:covered], covered_digest: job[:covered_digest],
+                model: served || job[:model], created_at: Time.now.utc.iso8601 }.compact
       @mutex.synchronize { @state = saved }
       save(saved)
       @engine.emit_recap(recap: text, generation: job[:generation], covered: job[:covered], created_at: saved[:created_at])

data/lib/samagotchi/recap_store.rb

@@ -8,7 +8,9 @@ require_relative "session"
 
 module Samagotchi
   # The idle recap saved with its session, in <session dir>/recap.json:
-  #   {text, covered, covered_digest, model, created_at}
+  #   {text, title, covered, covered_digest, model, created_at}
+  # (title: the auto title the recap reply led with, RecapTitle; absent in
+  # a recap saved before it, or when no reply gave one).
   # A separate file, so it never races the session-file save at the end of a
   # turn. Follows the Engine's current session (the REPL can switch).
   class RecapStore
@@ -77,11 +79,26 @@ module Samagotchi
       nil
     end
 
+    # What a session card or list row reads from the saved recap.
+    # +preview+: #preview's sentence; +title+: the auto title, or nil.
+    Card = Data.define(:preview, :title)
+
+    # @return [Card] the saved recap's preview and auto title, from one
+    #   read (both nil when there is no recap)
+    def self.card(session_dir)
+      data = read(session_dir)
+      title = data&.dig(:title).to_s.gsub(/\s+/, " ").strip
+      Card.new(preview: preview_of(data), title: title.empty? ? nil : title)
+    end
+
     # @return [String, nil] the first sentence of the recap saved in
     #   +session_dir+, on one line, without the subject phrase (SUBJECT_RE)
     #   and cut to PREVIEW_CHARS. The full recap keeps its sentence.
-    def self.preview(session_dir)
-      text = read(session_dir)&.dig(:text).to_s.gsub(/\s+/, " ").strip
+    def self.preview(session_dir) = preview_of(read(session_dir))
+
+    # #preview of a recap already read (RecapStore.read's hash, or nil).
+    def self.preview_of(data)
+      text = data&.dig(:text).to_s.gsub(/\s+/, " ").strip
       return nil if text.empty?
 
       first = text[/\A.*?[.!?](?=\s|\z)/] || text

data/lib/samagotchi/recap_title.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The auto title the recap reply leads with (IdleRecap::RecapPrompt::TITLE):
+  # "Title: <2-6 words>", a blank line, then the recap. #split takes the
+  # title line off, so the recap text the bubble, /recap, a continue's carry
+  # note and the next "Earlier recap:" read never holds it. A title line
+  # last is taken too (the spike's last-line arm put it there; a model may
+  # drift). A title that isn't 2-6 words or names an actor is no title, but
+  # its line still goes. Never raises.
+  module RecapTitle
+    LABEL = "Title:"
+    # As long as a card's title shows on a phone without wrapping twice.
+    MAX_CHARS = 60
+    WORDS = (2..6)
+    # "Title: Foo", "**Title:** Foo", "## Title: Foo" (a colon only: a
+    # recap may open "Title-casing the headings…").
+    LINE_RE = /\A[\s*_#>]*title[\s*_]*:[\s*_]*(?<title>.*)\z/i
+    # An instruction echoed between the title and the recap (the spike's
+    # "Blank line follows title."), or "(blank line)": dropped.
+    ECHO_RE = /\A[\s*_(\[]*(?:a |the )?blank line\b[^\n]{0,40}\z/i
+    # A "Recap:" label before the recap's first sentence: dropped, the
+    # sentence kept.
+    RECAP_LABEL_RE = /\A[\s*_#]*recap[\s*_]*:[\s*_]*/i
+    # The recap prompt's actors (RecapPrompt::SYSTEM: no "the user", no "the
+    # assistant", no "I", no "we"). A bare "User" or "Chi" stays: "User
+    # settings page", "Chi web push devices" name things.
+    ACTOR_RE = /\A(?:the\s+(?:user|assistant)(?:'s)?|(?:user|assistant)'s|i|we|you)(?=\s|\z)/i
+    QUOTES = "\"'`“”‘’«»"
+
+    # A reply split in two: +title+ nil when it has none (or none that
+    # passes), +body+ the recap without the title line.
+    Split = Data.define(:title, :body)
+
+    module_function
+
+    # @param text [String] the recap model's reply
+    # @return [Split]
+    def split(text)
+      lines = text.to_s.strip.lines(chomp: true)
+      if lines.first && LINE_RE.match?(lines.first)
+        title = lines.shift[LINE_RE, :title]
+        lines = lead_cleaned(lines)
+      elsif lines.size > 1 && LINE_RE.match?(lines.last)
+        title = lines.pop[LINE_RE, :title]
+      else
+        return Split.new(title: nil, body: text.to_s.strip)
+      end
+      Split.new(title: clean(title), body: lines.join("\n").strip)
+    rescue StandardError
+      Split.new(title: nil, body: text.to_s.strip)
+    end
+
+    # The title as a card shows it: markup, quotes and a closing period
+    # gone, one line, cut at MAX_CHARS; nil when it isn't 2-6 words or
+    # starts with an actor.
+    def clean(raw)
+      title = raw.to_s.gsub(/[*_#]+/, " ").gsub(/\s+/, " ").strip
+      title = title.delete_prefix(title[0]).delete_suffix(title[-1]).strip while quoted?(title)
+      title = title.sub(/[.。]+\z/, "").strip
+      return nil unless WORDS.cover?(title.split.size)
+      return nil if ACTOR_RE.match?(title)
+
+      title.length > MAX_CHARS ? "#{title[0, MAX_CHARS - 1].rstrip}…" : title
+    end
+
+    def quoted?(title) = title.length > 1 && QUOTES.include?(title[0]) && QUOTES.include?(title[-1])
+
+    # Blank lines, echoed instructions and a "Recap:" label before the recap.
+    def lead_cleaned(lines)
+      lines = lines.drop_while { |line| line.strip.empty? || ECHO_RE.match?(line) }
+      return lines if lines.empty?
+
+      first = lines.first.sub(RECAP_LABEL_RE, "")
+      first.strip.empty? ? lead_cleaned(lines.drop(1)) : [first, *lines.drop(1)]
+    end
+  end
+end

data/lib/samagotchi/session_manager.rb

@@ -308,12 +308,13 @@ module Samagotchi
     # @param exclude [String, nil] a session id to leave out (the asker)
     # @param include_archived [Boolean] archived sessions too
     # @return [Array<Hash>] {id:, short_id:, desc:, preview:, cwd:, project:,
-    #   updated_at:, status:, live:, busy:, owner:, recap:, parent_id:,
+    #   updated_at:, status:, live:, busy:, owner:, recap:, auto_title:, parent_id:,
     #   parent_short_id:, continues:, continues_short_id:, delegate:, archived:, scratch:, test_run:, waiting:,
     #   waiting_id:, stopped_by:}; busy =
     #   live with a turn running, delegate = started by the delegate tool
     #   (Session#delegate?; a fork has a parent_id but isn't one), continues = the session it continues (the
-    #   previous link of its chain, Session#continues), recap = the saved recap's first sentence, project =
+    #   previous link of its chain, Session#continues), recap = the saved recap's first sentence, auto_title =
+    #   the auto title its reply led with (RecapTitle) or nil, project =
     #   Session#project_root, waiting = the kind of question it waits on
     #   ("question", "approval", "hook"; Session#waiting_question) or nil,
     #   waiting_id = that question's id or nil, relayed_to = the parent
@@ -339,7 +340,7 @@ module Samagotchi
 
         { id: s.id, short_id: s.id[0, 8], desc: summary_desc(s), preview: summary_preview(s), title: s.title, cwd: s.working_directory,
           project: s.project_root(cache: roots), updated_at: s.updated_at, status: s.status, live: owned, busy: owned && s.status == Session::STATUS_RUNNING,
-          owner: owner&.kind, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
+          owner: owner&.kind, **recap_fields(Session.session_dir(s.id, state_dir: sd)),
           ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd),
                                                     budget_tokens: -> { budgets.call(s) })&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), continues: s.continues,
@@ -478,6 +479,12 @@ module Samagotchi
       cut(desc, SUMMARY_DESC_LIMIT)
     end
 
+    # A session row's recap: and auto_title: (RecapStore.card, one read).
+    private_class_method def self.recap_fields(session_dir)
+      card = RecapStore.card(session_dir)
+      { recap: card.preview, auto_title: card.title }
+    end
+
     private_class_method def self.summary_preview(session)
       cut(summary_text(session), SUMMARY_PREVIEW_LIMIT)
     end

data/lib/samagotchi/sessions_command.rb

@@ -217,12 +217,13 @@ module Samagotchi
         # scratch: a `chi scratch` session (deleted when its REPL ends, a
         # leftover one at the next sweep)
         # ctx_pct: how full the context was after the last turn, or nil
-        # title: the session's own name (/title; desc shows it too), or nil
+        # title: the session's own name (/title; desc shows it too), or nil;
+        # auto_title: the one its recap gave it (RecapTitle), or nil
         # waiting: the kind of question it waits on (question, approval,
         # hook: chi answer or the web answers it), or nil; waiting_id: its
         # id, for chi answer --question; relayed_to: the parent session (short
         # id) whose card it also waits in (the approval relay), or nil
-        keys = %i[id short_id desc title cwd project updated_at live busy owner recap parent_id continues delegate archived scratch ctx_pct
+        keys = %i[id short_id desc title auto_title cwd project updated_at live busy owner recap parent_id continues delegate archived scratch ctx_pct
                   waiting waiting_id relayed_to stopped_by]
         @stdout.puts JSON.generate(summaries.map { |summary| summary.slice(*keys) })
       when "tsv"
@@ -234,12 +235,13 @@ module Samagotchi
                   elsif summary[:busy] then "running"
                   else summary[:live] ? "live" : summary[:status].to_s
                   end
-          # The saved recap's first sentence says more than the last prompt
-          # (text only: tsv and json keep desc for pickers); a title (in
-          # desc) says what the user named it.
+          # The recap's auto title, else its first sentence, says more than
+          # the last prompt (text only: tsv and json keep desc for pickers);
+          # a title (in desc) says what the user named it.
           desc = summary[:desc]
-          if summary[:recap] && !summary[:title]
-            desc = [File.basename(summary[:cwd].to_s), summary[:recap]].reject(&:empty?).join(" · ")
+          named = summary[:auto_title] || summary[:recap]
+          if named && !summary[:title]
+            desc = [File.basename(summary[:cwd].to_s), named].reject(&:empty?).join(" · ")
             desc = "#{desc[0, 59]}…" if desc.length > 60
           end
           # A delegated session points at its parent.
@@ -265,15 +267,16 @@ module Samagotchi
       sort ||= "updated_at"
       order ||= "desc"
       sessions = @access.list(sort: sort, order: order, limit: limit, project_root: project, include_archived: include_archived)
-      # The session's title, else the saved recap's first sentence, else the
-      # last prompt (or the first message, before any turn), cut as before.
+      # The session's title, else the recap's auto title, else its first
+      # sentence, else the last prompt (or the first message, before any
+      # turn), cut as before.
       # These rows read each session's folder here (its recap, saved
       # context, owner): machine-local, the server's rows remotely (P2's
       # list parity).
       state_dir = Samagotchi::Session.default_state_dir
       list_text = lambda do |s|
-        recap = s.title ? nil : Samagotchi::RecapStore.preview(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
-        (recap || Samagotchi::SessionManager.summary_text(s))[0, 60]
+        card = s.title ? nil : Samagotchi::RecapStore.card(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
+        (card&.title || card&.preview || Samagotchi::SessionManager.summary_text(s))[0, 60]
       end
       # How full the context was after the last turn: "ctx 12%", counted
       # against the session's llm_context budget when one is set and smaller

data/lib/samagotchi/title_command.rb

@@ -48,10 +48,15 @@ module Samagotchi
 
     private
 
-    # "title: Coordinator", or "title: none (shows the first message: hey chi …)"
+    # "title: Coordinator", "title: none (shows the auto title: Parser tab
+    # handling)" (the recap's, RecapTitle), or "title: none (shows the
+    # first message: hey chi …)"
     def listing(session)
       return "title: #{session.title}" if session.title
 
+      auto = @engine.recap&.state&.dig(:title)
+      return "title: none (shows the auto title: #{auto})" if auto
+
       preview = session.first_preview.to_s
       "title: none (shows #{preview.empty? ? "the first message" : "the first message: #{preview}"})"
     end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/markdown_renderer.rb

@@ -7,6 +7,11 @@ module Samagotchi
   module Web
     class MarkdownRenderer
       WARNING = "Markdown rendering is enabled, but the optional commonmarker gem is not installed. Install it with: gem install commonmarker"
+      # The session view's tip while rendering is off (#tip): how to turn it
+      # on, the gem first when it isn't installed. Each fits two lines on a
+      # phone (390px), hence the short lead and the gem one without config.yml.
+      TIP = "Markdown answers: restart chi web with --web-markdown (or web.markdown: true in config.yml)."
+      TIP_GEM = "Markdown answers: gem install commonmarker, then restart chi web with --web-markdown."
       # NOTE: `span` is allowed because the syntax highlighter (commonmarker/syntect)
       # emits classed <span>s; keeping it lets highlighting render.
       ALLOWED_ELEMENTS = %w[a blockquote br code del em h1 h2 h3 h4 h5 h6 hr li ol p pre s strong span table tbody td th thead tr ul].freeze
@@ -29,6 +34,15 @@ module Samagotchi
         WARNING if enabled? && !load_bundled_commonmarker!
       end
 
+      # The tip while rendering is off, nil when it is on. Whether the gem is
+      # installed is read from its gemspec, not by loading it: a server that
+      # won't render has no use for the native extension.
+      def tip
+        return nil if enabled?
+
+        commonmarker_installed? ? TIP : TIP_GEM
+      end
+
       def render(markdown)
         return nil unless available?
 
@@ -57,6 +71,12 @@ module Samagotchi
         @commonmarker_available = false
       end
 
+      def commonmarker_installed?
+        return @commonmarker_installed unless @commonmarker_installed.nil?
+
+        @commonmarker_installed = Gem::Specification.find_all_by_name("commonmarker").any?
+      end
+
       def sanitize(html)
         fragment = Nokogiri::HTML5.fragment(html)
         fragment.traverse do |node|

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

@@ -99,6 +99,7 @@ import { createStartPage } from "./start_page.js";
 import { createSessionActions } from "./session_actions.js";
 import { createRename } from "./session_rename.js";
 import { createSendTurn } from "./send_turn.js";
+import { createMarkdownTip } from "./markdown_tip.js";
 
 // A link's #code= (behind an auth proxy): traded for the cookie before
 // anything else runs; the page reloads without it.
@@ -193,6 +194,8 @@ const startPage = createStartPage({
   listModels,
 });
 const markdownWarningEl = $("#markdownWarning");
+// While web.markdown is off: how to turn it on, until dismissed here.
+const markdownTip = createMarkdownTip($("#markdownTip"));
 // What the page renders that a notice may stand in for (the server's
 // Web::Capabilities, next to markdown_warning); a notice it names isn't
 // drawn (shownElsewhere). An older server sends none: every notice shows.
@@ -817,6 +820,7 @@ function clearSelection() {
   setTurnRunning(false);
   closeStream();
   setMarkdownWarning(null);
+  markdownTip.show(null);
   setCapabilities(null, null);
   composerGrip.newVisit();
   updateComposerMode();
@@ -944,6 +948,7 @@ async function resync({ endText = null } = {}) {
 // then a pending question.
 function renderSessionView(data, { kept = [] } = {}) {
   setMarkdownWarning(data.markdown_warning);
+  markdownTip.show(data.markdown_tip);
   setCapabilities(data.capabilities, data.editor_url);
   // The saved fill (when there is one) goes in here too, so a reloaded or
   // stopped session shows it before its next turn (a running turn's replay
@@ -1092,6 +1097,7 @@ async function readTurnEnd() {
       if (!(await mergeTurnTiming(id, d.timing))) return;
       liveTurn.timing.finishLine(line);
       setMarkdownWarning(d.markdown_warning);
+      markdownTip.show(d.markdown_tip);
       setCapabilities(d.capabilities, d.editor_url);
       if (Array.isArray(d.messages)) applyFinalMarkdown(d.messages);
       updateInfoBar();

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

@@ -109,6 +109,11 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 @keyframes init-spin{to{transform:rotate(360deg)}}
 @media (prefers-reduced-motion:reduce){.init-spin{animation:none;border-top-color:var(--accent)}.init-task{transition:none}}
 .markdown-warning{margin:0 16px 4px;padding:8px 10px;border:1px solid var(--warn);border-radius:8px;background:var(--warn-bg);color:var(--warn-bright);font-size:12px;line-height:1.4}
+.markdown-tip{display:flex;align-items:flex-start;gap:8px;margin:0 16px 4px;padding:6px 6px 6px 10px;border:1px solid var(--accent-border);border-radius:8px;background:var(--accent-bg);color:var(--text-muted);font-size:12px;line-height:1.4}
+.markdown-tip[hidden]{display:none}
+.markdown-tip-text{flex:1;min-width:0}
+.markdown-tip-close{flex:none;width:18px;height:18px;padding:0;border:0;border-radius:4px;background:transparent;color:var(--text-muted);font-size:14px;line-height:1;cursor:pointer}
+.markdown-tip-close:hover{background:var(--bg-hover);color:var(--text)}
 .bubble.user{border-left:3px solid var(--accent);background:var(--accent-bg);align-self:flex-end;max-width:85%;margin-left:auto;display:flex;align-items:center;justify-content:space-between;gap:10px}
 .bubble.user.queued{border-left-style:dashed;opacity:.8}
 .bubble.user.steered{border-left-style:dashed;border-left-color:var(--accent);opacity:.9}
@@ -1271,7 +1276,7 @@ body.has-session.composer-folded #infoBar{border-top-color:transparent}
 /* Start page (no session): the composer alone, centered; no info bar. */
 body:not(.has-session) #center{justify-content:safe center;background:transparent}
 body:not(.has-session) #stage{flex:0 0 auto;min-height:0;background:transparent}
-body:not(.has-session) #history,body:not(.has-session) #markdownWarning{display:none}
+body:not(.has-session) #history,body:not(.has-session) #markdownWarning,body:not(.has-session) #markdownTip{display:none}
 body:not(.has-session) #empty{position:static;background:transparent;padding:0}
 body:not(.has-session) #dock{width:min(720px,calc(100% - 32px));margin:0 auto}
 body:not(.has-session) #infoBar{display:none}
@@ -1488,7 +1493,9 @@ body.all-view #center, body.all-view #topStrip{display:none}
 #toast .toast-action{background:transparent;border:0;color:var(--accent);font-weight:600;cursor:pointer;padding:2px 4px}
 #toast .toast-close{background:transparent;border:0;color:var(--text-muted);cursor:pointer;padding:2px 4px;margin-left:-6px}
 #toast .toast-close:hover{color:var(--text)}
-#allList{flex:1;min-height:0;overflow:auto;display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:12px;align-content:start;padding:2px}
+/* Each row is as tall as its tallest card. An `auto` row in a grid that overflows its
+   height has no free space to grow into, so it collapses to each card's min-height. */
+#allList{flex:1;min-height:0;overflow:auto;display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:12px;align-content:start;grid-auto-rows:max-content;padding:2px}
 .card.skeleton{pointer-events:none;border-style:dashed;opacity:.9;animation:skeleton-pulse 1.2s ease-in-out infinite}
 .card.skeleton .line{height:10px;background:var(--bg-raised);border-radius:6px}
 .card.skeleton .line.long{width:78%}
@@ -1502,8 +1509,8 @@ body.all-view #center, body.all-view #topStrip{display:none}
 .card{padding:12px;border-radius:10px;background:var(--bg-panel);border:1px solid var(--border);cursor:pointer;display:flex;flex-direction:column;gap:6px;min-height:72px}
 .card:hover{border-color:var(--border-strong);background:var(--bg-hover)}
 #allList .card{position:relative}
-/* Every row keeps its content's height: a card shorter than its rows (seen on iOS) cut the clamped preview and the
-   single-line title and recap through the middle. */
+/* A card's lines are never squeezed to fit a short card: the flex side of the same overflow the rule above fixes
+   (an overflowing grid collapsing its rows to min-height), seen on iOS as the title, recap and preview cut through. */
 #allList .card > *{flex-shrink:0}
 /* A card's tools in the all view: archive (or unarchive) and delete, shown on hover, always under hover:none. */
 #allList .card-tools{position:absolute;top:6px;right:6px;display:flex;gap:2px}
@@ -1578,6 +1585,7 @@ a{color:var(--accent)}
   <section id="center">
     <div id="stage">
       <div id="markdownWarning" class="markdown-warning" hidden></div>
+      <div id="markdownTip" class="markdown-tip" hidden><span class="markdown-tip-text"></span><button type="button" class="markdown-tip-close" aria-label="Dismiss tip" title="Dismiss tip">×</button></div>
       <div id="history"></div>
       <div id="empty"></div>
       <div id="notice" role="status" hidden></div>

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

@@ -0,0 +1,33 @@
+// The session view's Markdown tip (the server's Web::MarkdownRenderer#tip,
+// sent as markdown_tip while web.markdown is off): one calm line with a ×
+// that hides it for this browser. The text is the server's; an older server
+// sends none, so no tip.
+import { readStored, writeStored } from "./storage.js";
+
+export const TIP_DISMISSED_KEY = "chi_markdown_tip_dismissed";
+
+// +el+ holds a .markdown-tip-text span and a .markdown-tip-close button
+// (index.html's #markdownTip).
+export function createMarkdownTip(el) {
+  const textEl = el.querySelector(".markdown-tip-text");
+  const closeBtn = el.querySelector(".markdown-tip-close");
+
+  function hide() {
+    el.hidden = true;
+    textEl.textContent = "";
+  }
+
+  // The tip for this payload: shown unless there is none or it was dismissed.
+  function show(text) {
+    if (!text || readStored(TIP_DISMISSED_KEY) === "1") return hide();
+    textEl.textContent = text;
+    el.hidden = false;
+  }
+
+  closeBtn.addEventListener("click", () => {
+    writeStored(TIP_DISMISSED_KEY, "1");
+    hide();
+  });
+
+  return { show };
+}

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

@@ -128,7 +128,8 @@ module Samagotchi
         # reason, never the question or the command (a lock screen shows it).
         # @return [Array(String, String)] title, body
         def text(summary, reason)
-          name = (summary && [summary[:title], summary[:first_preview], summary[:last_prompt]].find { |v| present?(v) }) ||
+          name = (summary && [summary[:title], summary[:auto_title], summary[:first_preview], summary[:last_prompt]]
+                             .find { |v| present?(v) }) ||
                  "chi session"
           body = reason == "done" ? "done in #{seconds(summary&.dig(:last_turn) || {}).round} s" : BODIES.fetch(reason, "")
           [clip(name.to_s.strip, TITLE_MAX), body]

data/lib/samagotchi/web/session_show.rb

@@ -81,6 +81,7 @@ module Samagotchi
           # names its plugins' too.
           commands: turn_snapshot&.fetch("commands", nil) || SessionCommands.builtin_registry.listing,
           markdown_warning: @markdown_renderer.warning,
+          markdown_tip: @markdown_renderer.tip,
           **viewer_capabilities(req),
           pending_question: pending,
           last_event_seq: last_event_seq,
@@ -208,6 +209,7 @@ module Samagotchi
           session: session_json,
           messages: messages,
           markdown_warning: @markdown_renderer.warning,
+          markdown_tip: @markdown_renderer.tip,
           **viewer_capabilities(req),
           timing: timing
         })

data/lib/samagotchi/web/session_summary.rb

@@ -40,6 +40,7 @@ module Samagotchi
         up = bridge_up?(session_dir, owner)
         sidecar = up ? WorkerSidecar.read(session_dir) : nil
         saved = SessionMetrics.saved_summary(session_dir, budget_tokens: budget_resolver(session, registry))
+        recap_card = RecapStore.card(session_dir)
         {
           id: session.id,
           status: status,
@@ -74,8 +75,12 @@ module Samagotchi
           # place of the first message.
           title: session.title,
           owner: owner&.kind,
-          # The saved recap's first sentence, for the session card.
-          recap: RecapStore.preview(session_dir),
+          # The saved recap's first sentence, for the session card, and the
+          # auto title its reply led with (RecapTitle), else nil: an untitled
+          # session's name on the pages and its pushes (never in a model
+          # request).
+          recap: recap_card.preview,
+          auto_title: recap_card.title,
           # How full the context was after the last turn (%), or nil, and
           # the session's token sums and cost (the card's ctx tooltip), from
           # one read of analytics.json.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.113.0
+  version: 0.114.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -513,6 +513,7 @@ files:
 - lib/samagotchi/recap_command.rb
 - lib/samagotchi/recap_setup.rb
 - lib/samagotchi/recap_store.rb
+- lib/samagotchi/recap_title.rb
 - lib/samagotchi/redacted_inspect.rb
 - lib/samagotchi/ref.rb
 - lib/samagotchi/relay.rb
@@ -768,6 +769,7 @@ files:
 - lib/samagotchi/web/public/llm_context_chip.js
 - lib/samagotchi/web/public/manifest.webmanifest
 - lib/samagotchi/web/public/markdown_place.js
+- lib/samagotchi/web/public/markdown_tip.js
 - lib/samagotchi/web/public/model_pick.js
 - lib/samagotchi/web/public/model_picker.js
 - lib/samagotchi/web/public/notice_links.js