samagotchi 0.95.0 → 0.96.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a359a1fc0fd6f83c6676d21b651513596e6618652aa996087087fb4bdb432d03
-  data.tar.gz: 96a3421ca2dee43940f7591e32dd76764090b6ae1791cd5e91c13e6be575339a
+  metadata.gz: 919ca9857f9debe0c23587e3061cc7d7723966067a236054d06acc68bb811b35
+  data.tar.gz: 3b5588e7c7de075d1dc7a7d84d57a39222ddd63342931aef4764a5422cc1959b
 SHA512:
-  metadata.gz: 57f03d06345f6e2cd7f74411a6eca333cb08352eb1a2e48a39dfafe5ce5b7977b88d8b7fa327056f5aa6fc448b10ac7030661d149d61ce0823d66a104d5212fd
-  data.tar.gz: 2d0dae400a20ae0b023ccd613cb6dc871e34e86de7a6c3605d22eb21d5f1babbd3dc94d7f47a54ff31afcf36da4f71c9c667f80e5c6c90bb16e0a41c92892615
+  metadata.gz: 2928c6af604c2e9e33728949ae701d814ca61c510bec264004c56b00986c46ec6b2a23dfc449e832eed18246b33c57bc04b3d422e02dc3fe21667fd890b29fce
+  data.tar.gz: 4171544e495614b7f7ff23ef92b484d67dc9aa34c3624b2ac7459d8bf1e9fd93b36fc7ca329ca11e1dead80da44a032146c617900484b934fc11f2d3c4fbf159

data/CHANGELOG.md

@@ -8,6 +8,18 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.96.0] - 2026-10-21
+
+### Added
+
+- Session titles: `/title Coordinator` names a session (`/title` shows it, `/title --clear` drops it), from any UI or
+  `chi send`, mid-turn too. Every list, card, chain row, top bar, tab and notification shows it in place of the first
+  message, `chi sessions list` too (json has `title`), and a continue's next link keeps it. The web's info bar has `✎`
+  to rename the open session. See [docs/sessions.md](docs/sessions.md#session-titles).
+
+Update with `chi update` (the system bundle 0.96.0), then restart `chi web`: a `chi web` or session worker from
+before the update drops a session's title when it saves the session.
+
 ## [0.95.0] - 2026-10-21
 
 ### Removed
@@ -3691,7 +3703,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.95.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.96.0...HEAD
+[0.96.0]: https://github.com/dm1try/samagotchi/compare/v0.95.0...v0.96.0
 [0.95.0]: https://github.com/dm1try/samagotchi/compare/v0.94.0...v0.95.0
 [0.94.0]: https://github.com/dm1try/samagotchi/compare/v0.93.0...v0.94.0
 [0.93.0]: https://github.com/dm1try/samagotchi/compare/v0.92.0...v0.93.0

data/docs/cli.md

@@ -653,6 +653,14 @@ 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,
+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
+message; a continue's next link keeps it. The web's info bar has `✎` for it. See
+[Session titles](sessions.md#session-titles).
+
 A `/thinking`, `/reasoning-history` or `/toolkit` change that restarts the prompt cache
 asks first: the reply says what it costs, changes nothing, and names the line
 that applies it (`/thinking low --yes`). `--yes` (or `-y`) applies it at once.

data/docs/plugins.md

@@ -966,7 +966,7 @@ id = ctx.sessions.fork(messages: ctx.messages + [{ role: "user", content: q }, {
                        title: "btw: #{q}")
 ctx.sessions.send(id, "go on from here")
 ctx.sessions.send(id, "then the docs", delivery: :queue)  # after its running turn
-ctx.sessions.read(id)      # => {id:, title:, status:, parent_id:, running:, messages:}
+ctx.sessions.read(id)      # => {id:, title:, status:, parent_id:, running:, messages:}  (title: its /title, else its preview)
 ctx.sessions.children      # => [{id:, short_id:, state:, branch:, last_reply:, reported:, ...}]
 ctx.sessions.stop(id)      # one of this session's own children
 ```
@@ -977,8 +977,9 @@ ctx.sessions.stop(id)      # one of this session's own children
   attach to it. It returns the child's id.
   - Without `prompt:` the child waits idle. With one, it runs it as its first
     turn, and counts against `session.max_children` (like `delegate`).
-  - `title:` is what the lists show until its first turn (else the prompt, or
-    the first user message).
+  - `title:` is its preview: what the lists show for it (else the prompt, or
+    the first user message). It stays after the first turn; it is not a
+    `/title` of its own (see [Session titles](sessions.md#session-titles)).
   - An image a message names is copied into the child. One whose file is
     gone is dropped, with `[image x.png was not copied]` in its message.
 - `send(id, text)` sends a user message to a session (an id or a unique

data/docs/sessions.md

@@ -217,13 +217,19 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
 - The 16 KiB cap applies: `git diff | chi send --new …` on a big diff is refused; name the branch in the message instead and let the session read it.
 - A session nobody attaches to stalls at its first question or guardrail ask until someone answers it (`chi answer`, the web, `chi --attach`), and its worker stays up meanwhile: it doesn't idle-exit while a question waits (`chi sessions list` shows it as `waiting`; `chi sessions stop ID` frees it). Otherwise it idle-exits after `session.idle_exit_minutes` like any worker. These are ordinary sessions: delete them like any other.
 
+## 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 ID "/title Coordinator"`; 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 "/title X"`) takes its preview from its first real message.
+
+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 web's info bar has `✎` (Rename this session): a small input prefilled with the title; Enter or a click elsewhere sends `/title TEXT` when it changed (empty: `/title --clear`), Esc closes it unsent. A session a chi REPL owns has no `✎`. 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.
+
 ## Session chains
 
 A session can **continue** an earlier one: "the next run of the same routine" (a daily coordinator, say, continued once a day or several times). The new session's `continues` field names the previous link; the chain is derived from it, never stored: follow `continues` back for the earlier links, forward for the later ones. It is not a parent: archiving one link leaves the next alone, and lists fold delegates, not links. A link is continued at most once, so a chain has no forks and its latest link is the one nobody continues.
 
 `SessionManager.continue_session` makes the next link:
 
-- **What it copies:** the previous link's folder, its model (the name it was typed as, so an alias holds) unless the continue names one (`--model`, the web's `model`), and its own LLM context values. A model given is checked like a new session's (a host config.yml doesn't have refuses the continue, nothing archived). An inherited model whose host can't run it any more (gone from config.yml, `enabled: false`, an alias naming another host) **falls back to the default model** with a warning, `gone:org/model can't run (unknown host 'gone' in model …); started on <default>`, decided before the archive; with no default model configured the continue is refused. The carry note doesn't mention the model. The new link carries no transcript, so a different model, or another provider, starts clean there. Its preview is the previous link's (until its first message is saved), unless it starts with a message.
+- **What it copies:** the previous link's folder, its model (the name it was typed as, so an alias holds) unless the continue names one (`--model`, the web's `model`), and its own LLM context values. A model given is checked like a new session's (a host config.yml doesn't have refuses the continue, nothing archived). An inherited model whose host can't run it any more (gone from config.yml, `enabled: false`, an alias naming another host) **falls back to the default model** with a warning, `gone:org/model can't run (unknown host 'gone' in model …); started on <default>`, decided before the archive; with no default model configured the continue is refused. The carry note doesn't mention the model. The new link carries no transcript, so a different model, or another provider, starts clean there. Its preview is the previous link's (until its first message is saved), unless it starts with a message. Its title (`/title`) is the previous link's, with or without a first message.
 - **The carry note:** the new link starts with a context note from `session chain` (shown in its transcript as `note from session chain`), queued before its worker spawns, so its first turn sees it: `This session continues 3fa2c1d0 (2026-10-08 09:12), the previous link of its chain. Its recap, as of 2026-10-08 18:02:` and the previous link's recap (`recap.json`; cut at 8000 characters). No recap (fewer user turns than a recap needs, recaps off, none written in time): `… It left no recap.` Never more than the recap: no transcript. An idle new link holding only the note is kept, not discarded as empty.
 - **The recap first:** a previous link with a live worker is asked for a recap (the Bridge's `POST /recap`) and given up to 30 s to write it; one with none wrote its recap when its worker left.
 - **The previous link is archived** before the new one starts, by the archive's own rules (see *Archiving a session*): a turn running, a prompt queued or the step-limit question refuse it, a live idle worker is stopped, a plain REPL's session is refused. Its finished delegates are archived with it, as any archive does.
@@ -231,7 +237,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` 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 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 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 `↩ #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 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 `#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 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 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 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/bundles/system/manifest.yml

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

data/lib/samagotchi/children_status.rb

@@ -81,7 +81,7 @@ module Samagotchi
     def child(session, row, cursors, state_dir:)
       reply = ReplyWait.newest_reply(session.id, state_dir: state_dir)
       cursor = Tools::DelegateCursors.get_from(cursors, session.id)
-      Child.new(id: session.id, short_id: session.id[0, 8], title: row[:preview].to_s,
+      Child.new(id: session.id, short_id: session.id[0, 8], title: (session.title || row[:preview]).to_s,
                 state: state_of(session, row, reply), waiting: row[:waiting], live: !!row[:live],
                 delegate: session.delegate?, cwd: session.working_directory, branch: GitHead.branch(session.working_directory),
                 last_reply: reply && first_line(session.id, reply, state_dir: state_dir),

data/lib/samagotchi/plugin/sessions.rb

@@ -53,7 +53,7 @@ module Samagotchi
 
         child = SessionManager.spawn_session(
           prompt: prompt, working_directory: @host.cwd.call || Dir.pwd, model_name: @host.model_name&.call,
-          parent_id: parent_id, messages: Array(messages).map { |message| unfrozen(message) }, title: title,
+          parent_id: parent_id, messages: Array(messages).map { |message| unfrozen(message) }, preview: title,
           images_from: Session.session_dir(parent_id, state_dir: state_dir), state_dir: state_dir,
           setup: @host.setup&.call || SessionSetup.new
         )
@@ -105,7 +105,8 @@ module Samagotchi
       # Session +id+ now: from its worker when one runs (with a running turn
       # so far), else as saved.
       # @return [Hash] {id:, title:, status:, parent_id:, running:, messages:}
-      #   (messages without the system prompt, symbol keys)
+      #   (title: its own name, /title, else its first message's preview;
+      #   messages without the system prompt, symbol keys)
       # @raise [Error] no such session
       def read(id)
         state_dir = self.state_dir
@@ -120,7 +121,7 @@ module Samagotchi
             messages += Bridge::TurnAccumulator.messages_of(deep_symbolize(turn))
           end
         end
-        { id: sid, title: session.first_preview.to_s, status: session.status.to_s, parent_id: session.parent_id,
+        { id: sid, title: session.display_title, status: session.status.to_s, parent_id: session.parent_id,
           running: running, messages: without_system_head(messages) }
       end
 

data/lib/samagotchi/send_command.rb

@@ -416,7 +416,7 @@ module Samagotchi
       # says whether it ran as one.
       through_worker = images || command_like?(prompt)
       begin
-        start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
+        start = through_worker ? { prompt: nil, preview: prompt } : { prompt: prompt }
         session = if options[:continues]
                     SessionManager.continue_session(options[:continues], **start, model: options[:model],
                                                                              state_dir: @state_dir)

data/lib/samagotchi/session.rb

@@ -56,6 +56,10 @@ module Samagotchi
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
     attr_accessor :preloaded_memory_names, :muted_memory_names
+    # The name the user gave the session (/title, TitleCommand), else nil:
+    # every list, card and tab shows it in place of #first_preview (see
+    # #display_title). A continue's new link inherits it.
+    attr_accessor :title
     # The files chi --append-system-prompt put into the session's system
     # prompt (absolute paths; config.yml's append_system_prompt: entries
     # aren't stored): kept on respawns, copied by a fork and a continue
@@ -276,7 +280,7 @@ module Samagotchi
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
                    continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [],
-                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil, parent_answers: nil)
+                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil, parent_answers: nil, title: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -289,6 +293,7 @@ module Samagotchi
       @status = status
       @last_prompt = last_prompt
       @first_preview = first_preview
+      @title = title
       @test_run = !!test_run
       self.pending_question = pending_question
       @used_memory_names = self.class.name_list(used_memory_names)
@@ -455,6 +460,7 @@ module Samagotchi
       "status" => STATUS_IDLE,
       "last_prompt" => "",
       "first_preview" => "",
+      "title" => nil,
       "test_run" => false,
       "pending_question" => nil,
       "used_memory_names" => [],
@@ -719,6 +725,12 @@ module Samagotchi
       File.join(Paths.state_home(env: env), STATE_SUBDIR)
     end
 
+    # What names the session: its #title when it has one, else its
+    # #first_preview.
+    def display_title
+      title.to_s.strip.empty? ? first_preview.to_s : title
+    end
+
     # Derive and cache the first user-message preview in the session record.
     # Returns true if the cached value was set or updated.
     # A session with only context notes so far previews by its first note

data/lib/samagotchi/session_commands.rb

@@ -14,6 +14,7 @@ require_relative "llm_context_command"
 require_relative "thinking_command"
 require_relative "toolkit_command"
 require_relative "parent_answers_command"
+require_relative "title_command"
 require_relative "reasoning_history_command"
 require_relative "guardrails/parent_policy"
 
@@ -37,6 +38,7 @@ module Samagotchi
     THINKING_COMMAND = ThinkingCommand::NAME
     TOOLKIT_COMMAND = ToolkitCommand::NAME
     PARENT_ANSWERS_COMMAND = ParentAnswersCommand::NAME
+    TITLE_COMMAND = TitleCommand::NAME
     REASONING_HISTORY_COMMAND = ReasoningHistoryCommand::NAME
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
@@ -112,6 +114,9 @@ module Samagotchi
                                                 "never looser than config.yml's)",
                         id: :parent_answers, mid_turn: show_mid_turn(PARENT_ANSWERS_COMMAND),
                         match: ->(text) { text.match?(%r{\A/parent-answers(?:\s+.*)?\z}) }) { |text| parent_answers(text) }
+      # Only a name: renaming a running session doesn't wait for its turn.
+      registry.register(TITLE_COMMAND, "show or set this session's title (--clear: back to its first message)",
+                        id: :title, anytime: true, match: ->(text) { text.match?(%r{\A/title(?:\s+.*)?\z}) }) { |text| title(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -522,6 +527,14 @@ module Samagotchi
       reply(output, status: status, changed: changed ? [:parent_answers] : [])
     end
 
+    # /title (TitleCommand); :title in changed when it named the session or
+    # cleared its name. A plain save: no setting moved, and it may run on
+    # an anytime thread beside a turn.
+    def title(text)
+      output, changed, status = TitleCommand.new(engine: @engine, save: @save).run(text.delete_prefix(TITLE_COMMAND))
+      reply(output, status: status, changed: changed ? [:title] : [])
+    end
+
     # A session setting changed (/llm-context, /thinking, /reasoning-history):
     # saved with its model.
     def save_setup(session)

data/lib/samagotchi/session_continue.rb

@@ -83,7 +83,7 @@ module Samagotchi
     # follows the chain to its new end instead.
     # @param id_or_ref [String] an id, a prefix, or last:<id> (SessionChain.resolve)
     # @param prompt [String, nil] its first message (nil: it starts idle)
-    # @param title [String, nil] what the lists show before the first turn;
+    # @param preview [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, #opener:
@@ -92,7 +92,7 @@ module Samagotchi
     # @raise [Refused] continued already, delegates open that can't
     #   move, or its folder is gone
     # @raise [ArchiveRefused, OwnedByTUI] as archive_session
-    def self.run(id_or_ref, prompt: nil, title: nil, model: nil, state_dir: nil, recap_wait: RECAP_WAIT, archive_wait: 5)
+    def self.run(id_or_ref, prompt: nil, preview: nil, model: nil, state_dir: nil, recap_wait: RECAP_WAIT, archive_wait: 5)
       sd = state_dir || Session.default_state_dir
       TRIES.times do |try|
         id = SessionChain.resolve(id_or_ref, state_dir: sd)
@@ -100,7 +100,7 @@ module Samagotchi
           follow = id_or_ref.to_s.strip.start_with?(SessionChain::LAST_PREFIX) && try < TRIES - 1
           next :moved if follow && SessionChain.next_of(id, state_dir: sd)
 
-          run_locked(id, prompt: prompt, title: title, model: model, state_dir: sd, recap_wait: recap_wait,
+          run_locked(id, prompt: prompt, preview: preview, model: model, state_dir: sd, recap_wait: recap_wait,
                          archive_wait: archive_wait)
         end
         return result unless result == :moved
@@ -116,7 +116,7 @@ module Samagotchi
       end
     end
 
-    private_class_method def self.run_locked(id, prompt:, title:, model:, state_dir:, recap_wait:, archive_wait:)
+    private_class_method def self.run_locked(id, prompt:, preview:, model:, state_dir:, recap_wait:, archive_wait:)
       previous = Session.load(id, state_dir: state_dir)
       checked = check!(previous, state_dir, model: model)
       plan = checked.plan
@@ -132,7 +132,7 @@ module Samagotchi
       archive = SessionManager.archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)
       archived = archive[:archived] - already
       begin
-        spawn_continuation(previous, prompt: prompt, title: title, choice: checked.choice, state_dir: state_dir,
+        spawn_continuation(previous, prompt: prompt, preview: preview, choice: checked.choice, state_dir: state_dir,
                                      move: plan.move)
       rescue StandardError
         # Nothing started: the delegates go back, what this archived goes
@@ -194,16 +194,16 @@ module Samagotchi
 
     # The new link, holding off any worker but its own (ChildMove.starting?)
     # while +move+ goes to it.
-    private_class_method def self.spawn_continuation(previous, prompt:, title:, choice:, state_dir:, move:)
+    private_class_method def self.spawn_continuation(previous, prompt:, preview:, choice:, state_dir:, move:)
       recap = RecapStore.read(Session.session_dir(previous.id, state_dir: state_dir))
       start = prompt.to_s.strip.empty? ? nil : prompt
-      title = previous.first_preview if title.to_s.strip.empty? && start.nil?
+      preview = previous.first_preview if preview.to_s.strip.empty? && start.nil?
       before_spawn = lambda do |link|
         ChildMove.mark_starting(link.id, state_dir: state_dir)
         ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
       end
       link = SessionManager.spawn_session(
-        prompt: start, title: title, working_directory: previous.working_directory,
+        prompt: start, preview: preview, title: previous.title, working_directory: previous.working_directory,
         model_name: choice.model, setup: SessionSetup.of(previous),
         continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
         note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn

data/lib/samagotchi/session_delete_command.rb

@@ -80,7 +80,7 @@ module Samagotchi
     end
 
     def preview_of(id)
-      text = Session.load(id, state_dir: @state_dir).first_preview.to_s.gsub(/\s+/, " ").strip
+      text = Session.load(id, state_dir: @state_dir).display_title.gsub(/\s+/, " ").strip
       return nil if text.empty?
 
       text.length > PREVIEW_LIMIT ? "#{text[0, PREVIEW_LIMIT - 1]}…" : text

data/lib/samagotchi/session_manager.rb

@@ -138,8 +138,11 @@ module Samagotchi
     # @param messages [Array<Hash>] a conversation to start from (a plugin's
     #   ctx.sessions.fork); its image refs are copied from +images_from+
     # @param images_from [String, nil] the session dir the seed's images are in
-    # @param title [String, nil] what the lists show before the first turn
+    # @param preview [String, nil] what the lists show before the first turn
     #   (the prompt's preview by default, else the seed's first user message)
+    # @param title [String, nil] the session's own name (Session#title; a
+    #   continue's link inherits its previous link's), saved before the
+    #   worker starts: the worker owns the file from then on
     # @param setup [SessionSetup] the session's own settings (chi
     #   --llm-context; a fork and a continue copy their session's; a delegate
     #   child the toolkit its delegate call named); without a toolkit the
@@ -156,7 +159,7 @@ module Samagotchi
     #   and #model_warning: an id its host's saved list doesn't have
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
-                           title: nil, delegate: false, setup: SessionSetup.new, continues: nil, note: nil,
+                           preview: nil, title: nil, delegate: false, setup: SessionSetup.new, continues: nil, note: nil,
                            note_source: "chi", before_spawn: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
@@ -189,7 +192,8 @@ module Samagotchi
       session.last_prompt = prompt
       # The worker takes last_prompt and clears it, and messages are saved at
       # the turn's end: until then this is the only preview a list has.
-      session.first_preview = Session.preview_of(title.to_s.strip.empty? ? prompt : title)
+      session.first_preview = Session.preview_of(preview.to_s.strip.empty? ? prompt : preview)
+      session.title = title
       session_dir = Session.session_dir(session.id, state_dir: sd)
       unless session.messages.empty?
         session.messages, dropped = ImageStore.copy_refs(session.messages, from: images_from, to: session_dir)
@@ -321,7 +325,7 @@ module Samagotchi
         owned = !!owner&.worker?
         next if live && !owned
 
-        { id: s.id, short_id: s.id[0, 8], desc: summary_desc(s), preview: summary_preview(s), cwd: s.working_directory,
+        { 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)),
           ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd),
@@ -464,10 +468,12 @@ module Samagotchi
       cut(summary_text(session), SUMMARY_PREVIEW_LIMIT)
     end
 
-    # A session as one line of text for the lists: its last prompt, else the
-    # first message it was started with (a session command like `/model x`,
-    # or a first turn not saved yet).
+    # A session as one line of text for the lists: its title (/title), else
+    # its last prompt, else the first message it was started with (a session
+    # command like `/model x`, or a first turn not saved yet).
     def self.summary_text(session)
+      return one_line(session.title) unless session.title.to_s.strip.empty?
+
       one_line(session.last_prompt.to_s.strip.empty? ? session.first_preview.to_s : session.last_prompt.to_s)
     end
 

data/lib/samagotchi/sessions_command.rb

@@ -198,11 +198,12 @@ 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
         # 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 cwd project updated_at live busy owner recap parent_id continues delegate archived scratch ctx_pct
+        keys = %i[id short_id desc 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"
@@ -215,9 +216,10 @@ module Samagotchi
                   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).
+          # (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]
+          if summary[:recap] && !summary[:title]
             desc = [File.basename(summary[:cwd].to_s), summary[:recap]].reject(&:empty?).join(" · ")
             desc = "#{desc[0, 59]}…" if desc.length > 60
           end
@@ -245,11 +247,11 @@ module Samagotchi
       order ||= "desc"
       sessions = Samagotchi::SessionManager.list_sessions(sort: sort, order: order, limit: limit, project_root: project,
                                                           include_archived: include_archived)
-      # 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 saved recap's first sentence, else the
+      # last prompt (or the first message, before any turn), cut as before.
       state_dir = Samagotchi::Session.default_state_dir
       list_text = lambda do |s|
-        recap = Samagotchi::RecapStore.preview(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
+        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]
       end
       # How full the context was after the last turn: "ctx 12%", counted

data/lib/samagotchi/title_command.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # /title, the session's own name (Session#title): with no argument, the
+  # title and what shows without one; `/title TEXT` names the session
+  # (whitespace collapsed, cut at 80 characters as a preview is), saved at
+  # once; `/title --clear` drops it, and the lists show the first message
+  # again. Anyone who may send the session a command may name it (a parent
+  # agent its delegates too). It runs mid-turn as well (anytime): the save
+  # takes the session's lock and writes a running turn's checkpoint, as a
+  # turn's own saves do.
+  class TitleCommand
+    NAME = "/title"
+    CLEAR = "--clear"
+    USAGE = "usage: #{NAME} [TEXT|#{CLEAR}]".freeze
+    # As long as a preview (Session.preview_of) may be.
+    LIMIT = 80
+
+    # @param engine [Engine] #session
+    # @param save [#call] saves the session after a change
+    def initialize(engine:, save:)
+      @engine = engine
+      @save = save
+    end
+
+    # @param args [String] what follows /title
+    # @return [Array(String, Boolean, Symbol)] the reply, whether the
+    #   title changed, and :ok or :error
+    def run(args)
+      session = @engine.session or return ["no session yet", false, :error]
+      text = args.to_s.gsub(/\s+/, " ").strip
+      return [listing(session), false, :ok] if text.empty?
+      # "--clear and more" is a slip, not a title.
+      return [USAGE, false, :error] if text.start_with?("#{CLEAR} ")
+
+      title = if text == CLEAR then nil
+              elsif text.length > LIMIT then "#{text[0, LIMIT]}…"
+              else text
+              end
+      return ["#{listing(session)}\n(no change)", false, :ok] if title == session.title
+
+      session.title = title
+      # The command itself as the session's first line (chi send --new
+      # "/title X", a web first message) became its preview: it goes, and
+      # the save derives the preview from the first user message again.
+      session.first_preview = "" if session.first_preview.to_s.start_with?(NAME)
+      @save.call(session)
+      [listing(session), true, :ok]
+    end
+
+    private
+
+    # "title: Coordinator", or "title: none (shows the first message: hey chi …)"
+    def listing(session)
+      return "title: #{session.title}" if session.title
+
+      preview = session.first_preview.to_s
+      "title: none (shows #{preview.empty? ? "the first message" : "the first message: #{preview}"})"
+    end
+  end
+end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -681,7 +681,7 @@ module Samagotchi
         # next; the list and the notifications name the session by it
         # until that turn is saved.
         preview = idle ? body["preview"].to_s.strip : ""
-        folder[:title] = preview unless preview.empty?
+        folder[:preview] = preview unless preview.empty?
         setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, bundle_settings: bundle_settings)
         folder[:setup] = setup unless setup.empty?
         begin
@@ -725,7 +725,7 @@ module Samagotchi
 
         preview = idle ? body["preview"].to_s.strip : ""
         model = (body["model"] || body["model_name"]).to_s.strip
-        session, error = continue_from(given, prompt: idle ? nil : prompt.to_s, title: preview.empty? ? nil : preview,
+        session, error = continue_from(given, prompt: idle ? nil : prompt.to_s, preview: preview.empty? ? nil : preview,
                                               model: model.empty? ? nil : model)
         return error if error
 
@@ -742,8 +742,8 @@ module Samagotchi
       # SessionManager.continue_session, its refusals as responses: [session,
       # nil] or [nil, the response]. Only its own errors: what fails after
       # the new link started is not a refusal of it.
-      def continue_from(given, prompt:, title:, model:)
-        [@manager.continue_session(given, prompt: prompt, title: title, model: model, state_dir: @state_dir), nil]
+      def continue_from(given, prompt:, preview:, model:)
+        [@manager.continue_session(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir), nil]
       rescue SessionContinue::Refused => e
         extra = e.reason == :continued ? { next_id: e.ids.first } : { ids: e.ids }
         [nil, json_response(409, { error: e.reason.to_s, detail: e.message, **extra })]

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

@@ -85,6 +85,7 @@ import { createToasts } from "./toasts.js";
 import { createUnqueue } from "./unqueue.js";
 import { createStartPage } from "./start_page.js";
 import { createSessionActions } from "./session_actions.js";
+import { createRename } from "./session_rename.js";
 import { createSendTurn } from "./send_turn.js";
 
 const $ = (s) => document.querySelector(s);
@@ -495,6 +496,14 @@ const sessionActions = createSessionActions({
   closeLiveStream: () => streamControl?.close(),
   workerGone,
 });
+// ✎: /title through the chips' path (session_rename.js).
+const rename = createRename({
+  button: $("#infoRenameBtn"),
+  session: () => selected,
+  titleOf: (id) => lists.sessionsById().get(id)?.title || null,
+  run: (line) => runSessionCommand(line),
+});
+
 const { confirmDelete, leaveGoneSession, continueSelected, archiveOne, setArchived } = sessionActions;
 
 // All sessions: its own view at #/sessions, so the browser's back button
@@ -1046,6 +1055,9 @@ function updateInfoBar() {
   const deleteBtn = document.getElementById("infoDeleteBtn");
   const archiveBtn = document.getElementById("infoArchiveBtn");
   const continueBtn = document.getElementById("infoContinueBtn");
+  const renameBtn = document.getElementById("infoRenameBtn");
+  if (renameBtn) renameBtn.style.display = buttons.rename.shown ? "" : "none";
+  rename.follow(buttons.rename.shown ? selected : null);
   if (continueBtn) {
     continueBtn.style.display = buttons.continue.shown ? "" : "none";
     continueBtn.disabled = buttons.continue.disabled;

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

@@ -36,9 +36,11 @@ export function isOpener(text) {
 // reads its chain's first link's title instead, so the links of a chain
 // keep its name. Its own title when the first link isn't in +byId+ (id →
 // session; deleted, or a walk a missing link cut short) or is the opener too.
+// A link with a title of its own (/title; a new link inherits it) reads it,
+// and a titled first link names its chain.
 export function chainTitle(s, byId) {
   const own = previewForCard(s);
-  if (!s?.continues || !isOpener(s.first_preview || s.last_prompt)) return own;
+  if (s?.title || !s?.continues || !isOpener(s.first_preview || s.last_prompt)) return own;
   const seen = new Set([s.id]);
   let at = s;
   while (at.continues) {
@@ -47,7 +49,7 @@ export function chainTitle(s, byId) {
     seen.add(prev.id);
     at = prev;
   }
-  return isOpener(at.first_preview || at.last_prompt) ? own : previewForCard(at);
+  return !at.title && isOpener(at.first_preview || at.last_prompt) ? own : previewForCard(at);
 }
 
 // The open session's title (app.js updateSessionTitle: the top bar and the
@@ -55,9 +57,10 @@ export function chainTitle(s, byId) {
 // (+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+.
+// unless it is the opener. A titled session (/title) reads its card's too.
+// +shown+ null: not listed yet, +first+.
 export function openTitle({ shown, first, cardTitle }) {
-  if (shown && (shown.continues || isOpener(first))) return cardTitle(shown);
+  if (shown && (shown.title || shown.continues || isOpener(first))) return cardTitle(shown);
   return first;
 }
 
@@ -213,13 +216,23 @@ export function chainChipTemplate(f, { open = false } = {}) {
 
 // The chain's list (the chip's popover): one row per other link, newest
 // first: status dot, "#N", its date (with its HH:MM when another link of
-// the chain, the head too, started the same day: chainStamp), its recap's first sentence (else
-// its preview), the waiting / stopped badge, archived. A row's click opens
+// the chain, the head too, started the same day: chainStamp), its own title (/title) when it
+// differs from the head's (a link inherits its chain's: the card says it), else its recap's
+// first sentence, else its preview, the waiting / stopped badge, archived. A row's click opens
 // that link (families_view.js's popover binds .family-row[data-id]).
 // @param activeId the open session's id (its row is .active)
+// A chain row's words: a name of its own (not the one it shares with the
+// head), else what tells the link apart: its recap, else its preview (an
+// opener's read as the chain's, chainTitle, with its own title left out).
+function rowTitle(s, headTitle, byId) {
+  if (s.title && s.title !== headTitle) return s.title;
+  return s.recap || chainTitle({ ...s, title: null }, byId);
+}
+
 export function chainRowsTemplate(f, { activeId = null, now = Date.now() } = {}) {
-  const byId = new Map((f?.chain?.links || []).map((s) => [s.id, s]));
   const links = f?.chain?.links || [];
+  const byId = new Map(links.map((s) => [s.id, s]));
+  const headTitle = (byId.get(f?.head?.id) || f?.head)?.title || null;
   const rows = chainOthers(f).map(({ session: s, n }) => {
     const cls = ["family-row", "chain-row"];
     if (activeId && s.id === activeId) cls.push("active");
@@ -231,7 +244,7 @@ export function chainRowsTemplate(f, { activeId = null, now = Date.now() } = {})
     const tip = `${s.id} · ${s.status || ""}${ago ? ` · updated ${ago}` : ""}`;
     return html`<div class=${cls.join(" ")} data-id=${s.id} style=${"--depth:1"} role=${"listitem"}><button type="button" class="fr-open"
       title=${tip}>${rowDotTemplate(s, waiting)}<span class="cr-n">#${n}</span>${
-      date ? html`<span class=${date.length > 10 ? "cr-date timed" : "cr-date"}>${date}</span>` : nothing}<span class="fr-preview">${s.recap || chainTitle(s, byId)}</span>${
+      date ? html`<span class=${date.length > 10 ? "cr-date timed" : "cr-date"}>${date}</span>` : nothing}<span class="fr-preview">${rowTitle(s, headTitle, byId)}</span>${
       rowBadgesTemplate(waiting, stopped)}${s.archived ? archivedBadge : nothing}</button></div>`;
   });
   return html`<div class="family-rows chain-rows" role="list">${rows}</div>`;

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

@@ -58,8 +58,9 @@ export function firstPreview(text) {
 }
 
 export function previewForCard(session) {
-  // Unified card preview: first message (80) else previewOf(last_prompt)
-  const raw = session.first_preview || session.last_prompt || "";
+  // Unified card preview: its title (/title), else its first message (80),
+  // else its last prompt.
+  const raw = session.title || session.first_preview || session.last_prompt || "";
   return firstPreview(raw) || "\u2014";
 }
 
@@ -69,7 +70,7 @@ const DELETE_PREVIEW_CHARS = 40;
 // list's owner can be stale (a worker idle-exits), so a worker is only
 // "stopped if it's still running", never promised.
 export function deleteConfirmText(session) {
-  const n = normalize(session.first_preview || session.last_prompt || "");
+  const n = normalize(session.title || session.first_preview || session.last_prompt || "");
   const preview = clip(n, DELETE_PREVIEW_CHARS + 1);
   const shortId = session.short_id || String(session.id).slice(0, 8);
   const lines = [

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

@@ -887,6 +887,10 @@ body.stage-view .turn-stage{position:absolute;left:0;right:0;bottom:100%;margin-
 #infoBar #infoStopBtn{background:var(--bg-raised);color:var(--warn-text);border:1px solid var(--border-strong)}
 #infoBar #infoStopBtn:hover{background:var(--warn-bg);border-color:var(--warn-border)}
 #infoBar #infoArchiveBtn{background:transparent;color:var(--text-muted);border:1px solid var(--border-strong)}
+#infoBar #infoRenameBtn{background:transparent;color:var(--text-muted);border:1px solid transparent}
+#infoBar #infoRenameBtn:hover{color:var(--text);background:var(--bg-hover)}
+/* ✎'s input (session_rename.js), in the button's place. */
+#infoBar .rename-input{flex:0 1 18em;min-width:6em;font:inherit;font-size:12px;padding:3px 8px;border-radius:8px;border:1px solid var(--accent-border);background:var(--bg-raised);color:var(--text);outline:none}
 #infoBar #infoArchiveBtn:hover{color:var(--text);background:var(--bg-hover)}
 #infoBar #infoDeleteBtn{background:transparent;color:var(--text-muted);border:1px solid transparent}
 #infoBar #infoDeleteBtn:hover{color:var(--on-solid);background:var(--danger-bg);border-color:var(--danger-bg)}
@@ -976,6 +980,8 @@ body.has-session.composer-folded #infoBar{border-top-color:transparent}
   #infoBar>button{font-size:0;line-height:0;padding:5px 7px}
   #infoBar>button::before{content:"";display:block;width:14px;height:14px;background:currentColor;-webkit-mask:var(--icon) center/contain no-repeat;mask:var(--icon) center/contain no-repeat}
   #infoBar #infoArchiveBtn{--icon:var(--icon-archive)}
+  #infoBar #infoRenameBtn{--icon:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='none' stroke='black' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M10.5 2.5l3 3L5.5 13.5H2.5v-3z'/%3E%3C/svg%3E")}
+  #infoBar .rename-input{flex:1 1 8em;font-size:16px}
   #infoBar #infoArchiveBtn.archived{--icon:var(--icon-unarchive)}
   #infoBar #infoContinueBtn{--icon:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='none' stroke='black' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M3 8h9M8.5 4.5 12 8l-3.5 3.5'/%3E%3C/svg%3E")}
   #infoBar #infoCancelBtn{--icon:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='none' stroke='black' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Crect x='4' y='4' width='8' height='8' rx='1.5'/%3E%3C/svg%3E")}
@@ -1300,6 +1306,7 @@ a{color:var(--accent)}
         <div class="info" id="infoText"></div>
         <div id="contextChips" aria-label="Attached context" hidden></div>
         <button class="ghost" id="infoCancelBtn" title="Cancel the running turn, whoever sent it" style="display:none">Stop turn</button>
+        <button class="ghost" id="infoRenameBtn" title="Rename this session" aria-label="Rename this session" style="display:none">✎</button>
         <button class="ghost" id="infoContinueBtn" title="Continue: start the next link of this session's chain from its recap (this one is archived)" style="display:none">continue →</button>
         <button class="ghost" id="infoArchiveBtn" title="Archive: hide from the lists, keep for good" style="display:none">archive</button>
         <button class="ghost" id="infoStopBtn" title="Stop session (terminate worker)" style="display:none">stop session</button>

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

@@ -42,6 +42,8 @@ export function infoButtons({ id, state, chain, archived, continuing, streaming
   const busy = !!id && continuing;
   return {
     continue: { shown: !!id && !chain.next && state.owner !== "tui", disabled: busy, text: busy ? "continuing…" : "continue →" },
+    // ✎: /title from the web (a plain terminal's session takes no commands).
+    rename: { shown: !!id && state.owner !== "tui" },
     delete: { shown: !!id },
     archive: {
       shown: !!id,

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

@@ -0,0 +1,86 @@
+// The info bar's ✎ (Rename this session): a small input in its place,
+// prefilled with the session's title ("" for none). Enter sends
+// `/title TEXT` (blank: `/title --clear`) through the chips' command path
+// (composer.js run: the reply shows as a command bubble, a refusal in the
+// failed bubble, the composer untouched); leaving the field saves the same
+// way (a phone's keyboard dismissed keeps what was typed). Esc, or opening
+// another session, closes it unsent. The cards follow from the saved file
+// (the hub's scan), as for any title.
+import { normalize } from "./format.js";
+
+// As long as a title may be (TitleCommand::LIMIT).
+const TITLE_CHARS = 80;
+
+// The line the input's +text+ sends.
+export function titleLine(text) {
+  const title = normalize(text);
+  return title ? `/title ${title}` : "/title --clear";
+}
+
+// @param button the ✎ button (it hides while the input shows)
+// @param session () => the open session's id, or null
+// @param titleOf (id) => that session's title, or null
+// @param run (line) => composer.js run's promise
+export function createRename({ button, session, titleOf, run }) {
+  let input = null;
+  let openFor = null;
+
+  function close() {
+    if (!input) return;
+    const el = input;
+    input = null;
+    openFor = null;
+    el.remove();
+    button.hidden = false;
+  }
+
+  // Enter's and blur's: once (closing it blurs it again), and only to the
+  // session it was opened for.
+  function submit() {
+    if (!input) return null;
+    const id = openFor;
+    const before = normalize(input.dataset.before);
+    const text = input.value;
+    close();
+    if (!id || session() !== id || normalize(text) === before) return null;
+    return run(titleLine(text));
+  }
+
+  function open() {
+    const id = session();
+    if (input || !id) return;
+    const el = document.createElement("input");
+    el.type = "text";
+    el.className = "rename-input";
+    el.maxLength = TITLE_CHARS;
+    el.placeholder = "Session title";
+    el.setAttribute("aria-label", "Session title (Enter saves, empty clears, Esc cancels)");
+    el.value = titleOf(id) || "";
+    el.dataset.before = el.value;
+    el.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        submit();
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        close();
+      }
+    });
+    el.addEventListener("blur", () => submit());
+    input = el;
+    openFor = id;
+    button.hidden = true;
+    button.after(el);
+    el.focus();
+    el.select();
+  }
+
+  // The info bar redrew for +id+ (app.js updateInfoBar): an input opened
+  // for another session closes.
+  function follow(id) {
+    if (input && openFor !== id) close();
+  }
+
+  button.addEventListener("click", () => open());
+  return { open, close, follow, isOpen: () => !!input };
+}

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

@@ -118,10 +118,12 @@ export function sessionStateFrom(data) {
   return state;
 }
 
-// The info bar's title: the first user message when the payload has
-// messages, else the card's preview, else the first prompt of its history.
+// The info bar's title: the session's own title (/title), else the first
+// user message when the payload has messages, else the card's preview, else
+// the first prompt of its history.
 function sessionFirstPreview(data) {
   const s = data.session;
+  if (s.title) return firstPreview(s.title);
   let preview = s.first_preview || previewForCard(s);
   if (data.messages && data.messages.length) {
     const first = data.messages.find((m) => m.role === "user");

data/lib/samagotchi/web/session_summary.rb

@@ -67,6 +67,9 @@ module Samagotchi
           # chain), else nil: the lists draw chains from it.
           continues: session.continues,
           first_preview: first_preview_for(session),
+          # The session's own name (/title), else nil: the pages show it in
+          # 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),

data/lib/samagotchi/worker.rb

@@ -933,8 +933,11 @@ module Samagotchi
     # finishes) comes after its command_queued. The cards it shows go out at
     # once (btw's "thinking…" card), after its command_queued, which the
     # UIs draw its line at (Engine#running_anytime). Its handler reads
-    # copies (ctx.messages) and shows things through ctx only; nothing is
-    # saved.
+    # copies (ctx.messages) and shows things through ctx only. One saves:
+    # /title, a field no turn writes, through Session#save, which takes the
+    # session's lock and writes a running turn's checkpoint (as
+    # WorkerSignals' save off the turn thread does), so the turn's own saves
+    # keep it.
     def start_anytime_command(command)
       @engine.spawn_anytime do
         result = command_result(command) { @engine.running_anytime { @commands.run(command.line, confirm: confirm?(command)) } }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.95.0
+  version: 0.96.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -582,6 +582,7 @@ files:
 - lib/samagotchi/thinking_tails.rb
 - lib/samagotchi/thinking_ticker.rb
 - lib/samagotchi/thought_stream_splitter.rb
+- lib/samagotchi/title_command.rb
 - lib/samagotchi/token_usage.rb
 - lib/samagotchi/tool_activity.rb
 - lib/samagotchi/tool_call_parser.rb
@@ -717,6 +718,7 @@ files:
 - lib/samagotchi/web/public/send_turn.js
 - lib/samagotchi/web/public/sentences.js
 - lib/samagotchi/web/public/session_actions.js
+- lib/samagotchi/web/public/session_rename.js
 - lib/samagotchi/web/public/session_state.js
 - lib/samagotchi/web/public/session_title.js
 - lib/samagotchi/web/public/sessions_list.js