samagotchi 0.100.0 → 0.100.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10cafc8e1deb147528195213bd69b946f428918a8c344c57022b2c905cd2f4fb
-  data.tar.gz: 6b6764b06a4effc61ac2edd1d2221d7afd232b2a8ce3470f0b14280d3ded432d
+  metadata.gz: 47dbac4f107af7d9c7d9d571b907a1e9e777326732614ed34986f2dce954168a
+  data.tar.gz: 4335f033596dc75f3db80b754a347e36862d0fd07f1d72bafcc7a5c50ed539ff
 SHA512:
-  metadata.gz: a4da078e7bb452a96fbc8d38f9565946fa12a3e3b8185e35f26032fcc2a3ae76249ec5ad7712dd12b74fec0f52db5fac7c03890f5074fca747985944b50f8e26
-  data.tar.gz: 3cc980b577869624c31a8c577b69612198569875d5c3b1e2f9070a4aebed2b5d4e6d4d29d44e25e56e2144b2346f4017352dca2e7a01b2898bc6fa5046b4459e
+  metadata.gz: a2454b93c9271b14ba0349c2991f6b0312dfdee76fd6a90005feb38726025dad71b6b4f1701bcbb2622c3db786d86fe2e58636668aa2f7d43d0ac289cae36e5a
+  data.tar.gz: 8fef8d270b58719f286b57c840f1a5fc3a53de10fec01fdcc08ea3de1315de17d267a834759b05ae09c05ca80b8f27009329eb38ff0aaf9a7b6ab59585b3e1d3

data/CHANGELOG.md

@@ -8,6 +8,21 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.100.1] - 2026-10-22
+
+### Fixed
+
+- The web's `continue →` no longer takes a draft left over from another session (or the start page) as the new
+  link's first message: the opener goes in, and the toast's **Restore draft** brings the draft back. A draft written
+  in the continued session still stays.
+- work-cap 0.1.1: a changed `bundles: work-cap:` setting reaches a running session (the caps are resolved again when the
+  settings change; the state file still wins per meter), and an empty key (`tool_calls:` with no value) falls through to
+  `child:` / `default:` instead of reading as "off"; `off`, `false` and `0` stay an explicit no cap.
+- Web: a closed step's text in the history renders as markdown (with `web.markdown` on) and keeps its source refs,
+  live and after a reload, as the answer does.
+- A hook entry in config.yml's `hooks:` that isn't a mapping, or has no `path:`, warns naming it
+  (`hooks.before_turn[0]`) instead of vanishing; the event's other entries still load.
+
 ## [0.100.0] - 2026-10-22
 
 ### Added
@@ -3792,7 +3807,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.100.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.100.1...HEAD
+[0.100.1]: https://github.com/dm1try/samagotchi/compare/v0.100.0...v0.100.1
 [0.100.0]: https://github.com/dm1try/samagotchi/compare/v0.99.0...v0.100.0
 [0.99.0]: https://github.com/dm1try/samagotchi/compare/v0.98.0...v0.99.0
 [0.98.0]: https://github.com/dm1try/samagotchi/compare/v0.97.0...v0.98.0

data/docs/architecture.md

@@ -431,7 +431,10 @@ The page's frequent reads of `GET /api/sessions/:id` stay light too:
   `drawAsking(text, refs)`) pairs them on its raw draw and again after its markdown swap; the card pairs its
   question text and its kept reply (`question_cards.js`); the step's closed `.gen-text` takes them
   (`turn_view.js`; on a reload its `data-answer-at`, the message's `display_refs`) and `linkTextRefs` pairs it at
-  the turn's end and after a reload. A file ref outside the
+  the turn's end and after a reload. A closed step's text is markdown too with `web.markdown` on: a reload's
+  from its message's `html` (`turn_view.js` `textTemplate`), a live turn's from `POST /api/render` on its step's
+  first open after the turn's end (`markdown_place.js` `renderStepTexts`, which pairs its refs again after the
+  swap); the text as written stays on it as `data-copy-source` (`stepText`, a reloaded card's kept reply). A file ref outside the
   session's folder is dropped, as a reload drops it: the folder `/tail` names, else (an older worker) the hub's
   session list entry's, else (refs to check, no hub entry) the session file's; with no folder known at all, every
   file ref is dropped rather than shown unchecked.

data/docs/hooks.md

@@ -28,6 +28,8 @@ hooks:
 
 Each event key holds a list of entries. A `hooks:` that isn't a mapping, or an event key that isn't a list
 (`before_turn: guard.rb`), warns at each start and loads nothing for it; an empty key loads nothing, silently.
+An entry that isn't a mapping (`- guard.rb`) or has no `path:` warns the same way, naming it
+(`hooks.before_turn[0]`, counted from 0), and is skipped alone: the key's other entries load.
 
 ## Plugin Format
 

data/docs/sessions.md

@@ -237,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 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.
+- **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 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.100.0
+version: 0.100.1
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/bundles/work-cap/manifest.yml

@@ -1,12 +1,12 @@
 ---
 name: work-cap
-version: 0.1.0
+version: 0.1.1
 scope: system
 description: "A per-session work cap (tool calls, active minutes) across turns: at a cap the turn pauses on Continue (another cap's worth) / Stop with the session's totals, a warning at 80% goes to the user only; /workcap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:d4de4b835d1657223517f3d6a5d8a9b089b7c8fad08ed077f72748369323bd65
+  sha256: sha256:f4ce7ea7f5801490a29e232c41c7bca2007c140d21f1a78bbfb60e6b6fd4f64b
 # ask_user's effects: are in chi 0.92.0; ctx.usage is new in the next chi
 requires_chi: ">= 0.100.0"
 # chi --set work-cap.tool_calls=400 / work-cap.minutes=60: the session's own caps, a number or off

data/lib/samagotchi/bundles/work-cap/plugin.rb

@@ -12,9 +12,10 @@
 # prompt text. cost-cap (the $ cap) is its sibling; the wordings follow it.
 #
 # Settings (config.yml, bundles: work-cap:), from ctx.settings, never at
-# load: the caps are resolved once per session (see State below), so a
-# config change reaches a running session through /workcap or a new
-# session; warn_at and ignore_tools are read at each check.
+# load: the caps are resolved once per session and settings (see State
+# below), again when ctx.settings changes, so a config change reaches a
+# running session (the state file still wins per meter); warn_at and
+# ignore_tools are read at each check.
 #   tool_calls: 400   this session's own tool-call cap (session_settings:,
 #                     chi --set work-cap.tool_calls=400); 0/off: none
 #   minutes: 60       this session's own cap on active minutes, same rules
@@ -26,8 +27,10 @@
 #                     tools whose calls and time aren't counted (waiting:
 #                     delegate blocks on its child by default)
 # Each meter resolves on its own: its own value, else child:'s for a
-# delegate, else default:'s. A value that doesn't read (tool_calls: many)
-# warns the user once and the next one is used, never a silent "no cap".
+# delegate, else default:'s. An empty key (YAML nil) is unset and falls
+# through; off, false and 0 are an explicit "no cap". A value that doesn't
+# read (tool_calls: many) warns the user once and the next one is used,
+# never a silent "no cap".
 #
 # What counts: ctx.usage's tool calls and active time (generations plus
 # finished tool calls, never a question's wait), less ignore_tools'.
@@ -36,8 +39,8 @@
 # "step": 400}, "minutes": {"cap": null}}, written by /workcap and by
 # Continue; a meter's "cap": null is off for the session, over the config;
 # a meter missing from the file comes from the settings. Resolved once per
-# session id (ctx.delegate? parses the session file) and kept until
-# /workcap or Continue writes a new one.
+# session id and settings (ctx.delegate? parses the session file) and kept
+# until /workcap or Continue writes a new file, or the settings change.
 require "json"
 require "fileutils"
 
@@ -57,7 +60,7 @@ class Plugin
 
   def initialize(_settings)
     @mutex = Mutex.new
-    @resolved = nil        # {session:, meters: {meter => {cap:, step:, key:}}, unreadable: {name => value}}
+    @resolved = nil        # {session:, settings:, meters: {meter => {cap:, step:, key:}}, unreadable: {name => value}}
     @warned = {}           # meter => [session id, cap] the share warning was given for
     @unread_warned = nil   # the session id the "isn't a number" notice was given for
   end
@@ -101,7 +104,8 @@ class Plugin
   def self.float_text(text) = text.sub(/\.(?=e|\z)/i, ".0")
 
   # Whether +value+ reads as a cap or as none: a number (text too), off,
-  # false or nil; not "many", true or a list.
+  # false or nil (nil is unset, not none: #first_readable skips it); not
+  # "many", true or a list.
   def self.readable?(value, meter)
     case value
     when false, nil then true
@@ -269,16 +273,17 @@ class Plugin
 
   # The session's caps now: per meter the state file's, else the session's
   # own value (--set), else child:'s for a delegate, else default:'s.
-  # Cached per session id.
+  # Cached per session id and settings (a config change resolves again).
   def resolve(ctx)
     session = ctx.session_id
+    settings = ctx.settings
     cached = @mutex.synchronize { @resolved }
-    return cached if cached && cached[:session] == session
+    return cached if cached && cached[:session] == session && cached[:settings] == settings
 
     saved = state(ctx, session)
     configured = configured(ctx)
     meters = METERS.to_h { |meter| [meter, saved[meter] || configured[:meters][meter]] }
-    resolved = { session: session, meters: meters, unreadable: configured[:unreadable] }
+    resolved = { session: session, settings: settings, meters: meters, unreadable: configured[:unreadable] }
     @mutex.synchronize { @resolved = resolved }
   end
 
@@ -301,9 +306,9 @@ class Plugin
   end
 
   # Per meter the first of its own value, child:'s (a delegate's) and
-  # default:'s that is set and reads (.readable?); the ones set that don't
-  # read (and a child:/default: that isn't a mapping) are kept for the
-  # notice (#unreadable).
+  # default:'s that is set (an empty key, nil, isn't) and reads
+  # (.readable?); the ones set that don't read (and a child:/default: that
+  # isn't a mapping) are kept for the notice (#unreadable).
   def configured(ctx)
     settings = ctx.settings
     unreadable = {}
@@ -327,6 +332,8 @@ class Plugin
       next unless values.key?(meter)
 
       value = values[meter]
+      next if value.nil?
+
       unless self.class.readable?(value, meter)
         unreadable[name] = value
         next
@@ -360,12 +367,15 @@ class Plugin
       {}
     end
     saved = {} unless saved.is_a?(Hash)
-    saved[meter] = data
+    saved[meter] = data.transform_values { |value| whole(value) }
     Samagotchi::AtomicFile.write(path, "#{JSON.generate(saved)}\n")
     # Resolved again at the next use, from the file now holding the meter.
     @mutex.synchronize { @resolved = nil }
   end
 
+  # 800.0 as 800 (a whole cap is saved as an Integer), 2.5 as it is.
+  def whole(value) = value.is_a?(Float) && value.finite? && value == value.to_i ? value.to_i : value
+
   def state_path(ctx, session) = File.join(ctx.data_dir, "sessions", "#{session.gsub(/[^A-Za-z0-9_.-]/, "_")}.json")
 
   def count(value) = self.class.count(value)

data/lib/samagotchi/hooks/loader.rb

@@ -110,8 +110,8 @@ module Samagotchi
             next
           end
 
-          configs.each do |cfg|
-            next unless cfg.is_a?(Hash) && cfg["path"]
+          configs.each_with_index do |cfg, index|
+            next unless valid_entry?(event_type, cfg, index)
 
             definitions << {
               event_type: event_type.to_s,
@@ -125,6 +125,21 @@ module Samagotchi
         definitions
       end
 
+      # A hook entry is a mapping with a path:; anything else warns, naming
+      # the entry (hooks.EVENT[N], from 0), and is skipped alone.
+      def self.valid_entry?(event_type, cfg, index)
+        where = "hooks.#{event_type}[#{index}]"
+        unless cfg.is_a?(Hash)
+          Log.warn(:hooks, "hooks_entry_invalid", echo: "[samagotchi:hooks] config.yml #{where}: must be a mapping with a path:; ignored", event: event_type.to_s, index: index)
+          return false
+        end
+        return true if cfg["path"].is_a?(String) && !cfg["path"].strip.empty?
+
+        Log.warn(:hooks, "hooks_entry_no_path", echo: "[samagotchi:hooks] config.yml #{where}: has no path:; ignored", event: event_type.to_s, index: index)
+        false
+      end
+      private_class_method :valid_entry?
+
       # Load a plugin from the hooks directory.
       # Returns an instance of the plugin class. Instances are cached per
       # [path, settings] across Engines: two entries with different

data/lib/samagotchi/version.rb

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

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

@@ -38,7 +38,7 @@ import { createBubbles, hintEl, outputBubbleTemplate } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView } from "./stage_view.js";
 import { createMarkdownPlace } from "./markdown_place.js";
-import { openerText, openTitle } from "./chains.js";
+import { openerFill, openTitle, restoredComposer } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
 import { appendQuote } from "./annotations.js";
 import { parsePresets } from "./annotate_presets.js";
@@ -67,7 +67,7 @@ import {
   appendAboveLiveTiming, mergeTiming, normalizeTiming,
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
-import { applyFinalAnswer, pairAnswerRefs, setAnswerRefs } from "./answer_refs.js";
+import { answerRefsOf, applyFinalAnswer, pairAnswerRefs, setAnswerRefs } from "./answer_refs.js";
 import { installRefClicks } from "./refs.js";
 import { linkRefs, touchedFiles } from "./ref_scan.js";
 import { DONE_MS, applyInitEvent, dropDone, fadeDone, initRowTemplate, newInitTasks, seedInitTasks } from "./init_row.js";
@@ -174,6 +174,15 @@ const infoCancelBtn = $("#infoCancelBtn");
 const composeHintEl = $("#composeHint");
 
 let selected = null;
+// The session the composer's text was last written in ("" the start page,
+// undefined unknown): the composer is one for every session, and continue →
+// keeps only a draft of its own (fillOpener).
+let draftFrom;
+// Record that the composer's text was written now, in session +id+ (default
+// the open one). Every write of text into the composer comes through here.
+function noteDraft(id) {
+  draftFrom = id ?? selected ?? "";
+}
 let streamControl = null;
 // The session list's stream (GET /api/events); null while the page falls
 // back to fetching (a chi web without a hub).
@@ -213,6 +222,7 @@ const markdownPlace = createMarkdownPlace({
   normalize,
   pairAnswerRefs,
   setAnswerRefs,
+  answerRefsOf,
 });
 const { renderMarkdown, pairRefsIn, linkRefsIn, applyFinalMarkdown, linkTextRefs } = markdownPlace;
 const turnDom = view === "stage"
@@ -500,6 +510,7 @@ const sessionActions = createSessionActions({
   toast: showToast,
   addCreatedSession,
   fillOpener,
+  restoreDraft,
   closeLiveStream: () => streamControl?.close(),
   workerGone,
 });
@@ -759,6 +770,7 @@ function clearNotice() {
   noticeEl.textContent = "";
 }
 promptEl.addEventListener("input", clearNotice);
+promptEl.addEventListener("input", () => noteDraft());
 
 async function select(id) {
   clearNotice();
@@ -1277,6 +1289,7 @@ const streamHandlers = createStreamHandlers({
       // A failed turn's line back: seen, so the composer opens (this visit).
       openForVisit();
       promptEl.value = text;
+      noteDraft();
       fitPrompt();
     },
     setChips,
@@ -1372,6 +1385,7 @@ const sendTurnControl = createSendTurn({
     clear: clearComposer,
     openForVisit: () => openForVisit(),
     focus: () => focusPrompt(),
+    noteDraft,
   },
   historyEl,
   turnDom,
@@ -1525,6 +1539,7 @@ const unqueue = createUnqueue({
     if (promptEl.value.trim() || chips.length) return false;
     openForVisit();
     promptEl.value = text;
+    noteDraft();
     fitPrompt();
     promptEl.focus();
     return true;
@@ -1571,7 +1586,10 @@ const commandList = createCommandList({
   list: $("#commandList"),
   prompt: promptEl,
   commands: () => (selected && current.owner !== "tui" ? current.commands : []),
-  afterPick: () => fitPrompt(),
+  afterPick: () => {
+    noteDraft();
+    fitPrompt();
+  },
 });
 
 // ↑/↓: the prompt history shared with the TUI (prompt_history.js), from a
@@ -1588,6 +1606,7 @@ function historyKey(e) {
   if (!recalled) return false;
   e.preventDefault();
   promptEl.value = recalled.value;
+  noteDraft();
   promptEl.setSelectionRange(recalled.caret, recalled.caret);
   fitPrompt();
   return true;
@@ -1620,15 +1639,31 @@ $("#infoContinueBtn").addEventListener("click", () => continueSelected());
 $("#infoArchiveBtn").addEventListener("click", () => sessionActions.toggleArchiveSelected());
 
 // The new link's composer: the opener (openerText: the previous link's own,
-// else the constant), unless a draft is there (it stays). +created+: the
-// continue's 201.
-function fillOpener(created) {
-  if (promptEl.value.trim() || chips.length) return;
+// else the constant). A draft written in this session (or the new link, or
+// of unknown origin) stays instead; one carried over from another session or
+// the start page gives way to the opener and is returned, for the toast's
+// Restore draft (chains.js openerFill). +created+: the continue's 201;
+// +continuedId+: the session continued.
+// @return the displaced draft's text, or null
+function fillOpener(created, continuedId) {
+  const { value, displaced } = openerFill({
+    text: promptEl.value, hasChips: chips.length > 0, draftFrom, continuedId, linkId: created.id, created,
+  });
+  if (value === null) return null;
   openForVisit();
-  promptEl.value = openerText(created);
+  promptEl.value = value;
+  noteDraft(created.id);
   fitPrompt();
   focusPrompt();
   promptEl.setSelectionRange(promptEl.value.length, promptEl.value.length);
+  return displaced;
+}
+
+// Restore draft (the continue toast's): +draft+ back into the composer,
+// over the untouched +opener+ or an empty one, else after what is there
+// (chains.js restoredComposer); in whatever session is open now.
+function restoreDraft(draft, opener) {
+  fillComposer(restoredComposer({ current: promptEl.value, opener, draft }));
 }
 
 const toasts = createToasts({ el: $("#toast"), onChange: placeToast });
@@ -1642,6 +1677,7 @@ function showToast(text, action = null, options = {}) { toasts.show(text, action
 function fillComposer(text) {
   openForVisit();
   promptEl.value = text;
+  noteDraft();
   fitPrompt();
   focusPrompt();
   promptEl.setSelectionRange(promptEl.value.length, promptEl.value.length);

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

@@ -25,6 +25,30 @@ export function openerText(created) {
   return typeof own === "string" && own.trim() ? own : CONTINUE_OPENER;
 }
 
+// What continue → does with the composer as the new link opens (app.js
+// fillOpener): +text+ / +hasChips+ the composer now; +draftFrom+ the session
+// the text was last written in ("" the start page, undefined unknown);
+// +continuedId+ the session continued, +linkId+ the new link. An empty
+// composer gets the opener. A draft written in either session, or of unknown
+// origin, stays (+value+ null). One carried over from another session or the
+// start page gives way to the opener and comes back as +displaced+ (the
+// toast's Restore draft). Its image chips stay either way: only text is
+// replaced.
+export function openerFill({ text, hasChips, draftFrom, continuedId, linkId, created }) {
+  const hasText = !!text?.trim();
+  if (!hasText && !hasChips) return { value: openerText(created), displaced: null };
+  if (draftFrom === undefined || draftFrom === continuedId || draftFrom === linkId) return { value: null, displaced: null };
+  return { value: openerText(created), displaced: hasText ? text : null };
+}
+
+// The composer after Restore draft: +draft+ (a displaced draft) replaces
+// +current+ when that is empty or still exactly +opener+; else it goes after
+// it, past a blank line. Never loses text typed since.
+export function restoredComposer({ current, opener, draft }) {
+  if (!current.trim() || current === opener) return draft;
+  return `${current.replace(/\s+$/, "")}\n\n${draft}`;
+}
+
 // Whether +text+ (a title or a first message) is the opener and nothing
 // else, trimmed: "Continue where we left off. Then fix X" is a title of its own.
 export function isOpener(text) {

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

@@ -345,7 +345,13 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
   --md-strong-color:var(--text-bright);--md-blockquote-color:var(--text-muted);--md-code-color:var(--text);
   --md-pre-size:12.5px;--md-cell-size:13px
 }
-.md-compact:is(.ts-asking,.question-said-full){white-space:normal}
+.gen-text.md-compact{
+  --md-heading-size:14.5px;--md-heading-color:var(--text);
+  --md-subheading-size:14px;--md-subheading-color:var(--text-2);
+  --md-strong-color:var(--text);--md-blockquote-color:var(--text-muted);--md-code-color:var(--text);
+  --md-pre-size:12.5px;--md-cell-size:13px
+}
+.md-compact:is(.ts-asking,.question-said-full,.gen-text){white-space:normal}
 .md-compact :is(h1,h2,h3,h4,h5,h6){font-size:var(--md-heading-size);font-weight:600;line-height:1.4;margin:8px 0 2px;color:var(--md-heading-color)}
 .md-compact :is(h4,h5,h6){font-size:var(--md-subheading-size);color:var(--md-subheading-color)}
 .md-compact :is(p,ul,ol,blockquote,table,pre){margin:0 0 6px}

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

@@ -7,11 +7,17 @@
 // The texts whose refs linkTextRefs links: the answers and the closed
 // steps' texts.
 const TEXTS = ".bubble.output, .gen:not(.live) > .gen-text";
+// The closed steps' texts still shown raw: a live turn's (a reload's come
+// rendered, turn_view.js textTemplate).
+const RAW_STEPS = ".gen:not(.live) > .gen-text:not(.markdown)";
 
 export function createMarkdownPlace({
   capabilities, renderText, roots, touchedFiles, currentDir, linkRefs, applyFinalAnswer, findInTurnRoots, normalize,
-  pairAnswerRefs, setAnswerRefs = () => {},
+  pairAnswerRefs, setAnswerRefs = () => {}, answerRefsOf = () => null,
 }) {
+  // The raw step texts already waiting for their step's open.
+  const waiting = new WeakSet();
+
   // A text the page already shows as its markdown HTML (POST /api/render,
   // sanitised there), or null: markdown off here (no request), or a failed
   // read (the raw text stays).
@@ -55,6 +61,7 @@ export function createMarkdownPlace({
   // turn's end and after a reload's render. A ref already made stays as it
   // is.
   function linkTextRefs() {
+    renderStepTexts();
     const pageRoots = roots();
     const touched = touchedFiles(pageRoots);
     for (const root of pageRoots) {
@@ -66,5 +73,44 @@ export function createMarkdownPlace({
     }
   }
 
+  // The closed steps' raw texts as markdown, as the answers' (markdown on
+  // only): each from its step's first open (a turn's end would ask once per
+  // step, folded or not), as a resolved question card's kept reply. The
+  // text stays as its source (stepText); its refs, a question's, pair again
+  // on the swap, then the `path:line` ones (linkRefsIn). A null render
+  // keeps the text, and the next open asks again.
+  function renderStepTexts() {
+    if (capabilities().display !== true) return;
+    for (const root of roots()) {
+      for (const el of root.querySelectorAll(RAW_STEPS)) {
+        const step = el.parentElement;
+        if (waiting.has(el) || !step?.addEventListener) continue;
+        waiting.add(el);
+        renderOnOpen(step, el, el.textContent);
+      }
+    }
+  }
+
+  function renderOnOpen(step, el, text) {
+    let state = "raw";
+    const draw = () => {
+      if (!step.open || state !== "raw") return;
+      state = "asking";
+      renderMarkdown(text).then((html) => {
+        if (!html || el.textContent !== text) { state = html ? "done" : "raw"; return; }
+        state = "done";
+        step.removeEventListener("toggle", draw);
+        const refs = answerRefsOf(el);
+        el.setAttribute("data-copy-source", text);
+        // Sanitised on the server (POST /api/render).
+        el.innerHTML = html;
+        el.classList.add("markdown", "md-compact");
+        linkRefsIn(el, refs);
+      });
+    };
+    step.addEventListener("toggle", draw);
+    draw();
+  }
+
   return { renderMarkdown, pairRefsIn, linkRefsIn, applyFinalMarkdown, linkTextRefs };
 }

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

@@ -19,7 +19,8 @@ import { composerAfterAck, dropEarlyRestores, restoreOnAck } from "./restore.js"
 // (start_page.js: pendingPick(), chosenModel(), newChoices(),
 // clearChoices()); +takeDelivery()+ the delivery line's armed choice;
 // +composer+: {el (the text box), button (Send/Start), chips(),
-// setChips(list), fit(), clear(), openForVisit(), focus()}; +historyEl+,
+// setChips(list), fit(), clear(), openForVisit(), focus(), noteDraft(id) (the
+// text was written in session id)}; +historyEl+,
 // +turnDom+; +makeUserBubble(prompt, opts)+, +bubbleById(id)+,
 // +addCommandBubble(view)+; +addCreatedSession(created)+, +select(id)+,
 // +showNotice(text)+, +updateInfoBar()+, +updateComposerMode()+,
@@ -128,7 +129,10 @@ export function createSendTurn({
       const restored = restoreOnAck(ack?.enqueued_id, earlyRestores, { myId: clientId, sentIds });
       // A restored line must be seen: the composer opens for this visit.
       if (restored?.refill && sentTo === session()) composer.openForVisit();
-      promptEl.value = composerAfterAck({ sent: line, current: promptEl.value, refill: restored?.refill || "" });
+      const before = promptEl.value;
+      promptEl.value = composerAfterAck({ sent: line, current: before, refill: restored?.refill || "" });
+      // A line back from sentTo is a draft of that session, wherever the page is now.
+      if (promptEl.value.trim() && promptEl.value !== before) composer.noteDraft(sentTo);
       composer.fit();
       // Only the sent chips go: images added since stay (they go up at their own send).
       const kept = chipsAfterSend(composer.chips(), sending);

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

@@ -1,4 +1,4 @@
-import { continueRefusal, continuedText, openChildrenTemplate } from "./chains.js";
+import { continueRefusal, continuedText, openChildrenTemplate, openerText } from "./chains.js";
 import { cantText, deleteConfirmText, goneSessionNotice } from "./format.js";
 import { sessionHash } from "./route.js";
 import { inTree } from "./sessions_list.js";
@@ -14,12 +14,14 @@ import { inTree } from "./sessions_list.js";
 // +refresh()+ fetches the list); +lists+ (lists_view.js: render);
 // +select(id)+, +clearSelection()+, +showNotice(text)+, +updateInfoBar()+,
 // +toast(text, action, options)+, +addCreatedSession(created)+,
-// +fillOpener(created)+ (the new link's composer), +closeLiveStream()+ (the live
+// +fillOpener(created, continuedId)+ (the new link's composer; returns a draft
+// from another session it displaced, or null), +restoreDraft(draft, opener)+
+// (that draft back, never over newer text), +closeLiveStream()+ (the live
 // stream's close, the stream left as it is) and +workerGone(id)+ the page's.
 // +alert+ / +confirm+: the browser's.
 export function createSessionActions({
   selected, state, sessions, setSessions, api, eventsLive, refresh, lists,
-  select, clearSelection, showNotice, updateInfoBar, toast, addCreatedSession, fillOpener, closeLiveStream, workerGone,
+  select, clearSelection, showNotice, updateInfoBar, toast, addCreatedSession, fillOpener, restoreDraft, closeLiveStream, workerGone,
   alert = (text) => globalThis.alert(text), confirm = (text) => globalThis.confirm(text),
 }) {
   // The session this tab is stopping: its stream may close before the stop
@@ -105,8 +107,11 @@ export function createSessionActions({
         return;
       }
       await select(next);
-      if (selected() === next) fillOpener(created);
-      toast(continuedText(id, created), null, { sticky });
+      // A draft carried over from elsewhere gave way to the opener: the
+      // toast brings it back, and stays until closed so it can't be lost.
+      const displaced = selected() === next ? fillOpener(created, id) : null;
+      const restore = displaced ? { label: "Restore draft", run: () => restoreDraft(displaced, openerText(created)) } : null;
+      toast(continuedText(id, created), restore, { sticky: sticky || !!displaced });
     } catch (e) {
       const refusal = continueRefusal(e, sessions());
       if (refusal.kind === "open") {

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

@@ -71,13 +71,21 @@ function thinkingTemplate({ body, wrapped = true, line = null, cls = "thinking",
 // full text. None when there is nothing to say. A closed step's text is
 // set whole (.textContent): its refs (ref_scan.js) split it into spans
 // that a text part's update would leave behind. +at+: a reloaded step's
-// message index, for its refs (data-answer-at, as an answer's).
-function textTemplate(text, { live, sentences, placeholder, at = null }) {
+// message index, for its refs (data-answer-at, as an answer's). A
+// reloaded step's +rendered+ markdown (its message's html, sanitised on the
+// server, as an answer's) shows in place of the text, which it keeps as
+// its source (stepText); a live step's renders once it closed
+// (markdown_place.js renderStepTexts).
+function textTemplate(text, { live, sentences, placeholder, at = null, rendered = null }) {
   if (live && sentences?.length) {
     return html`<div class="gen-text streaming"><div class="narration">${sentences.map((s) => html`<div class="sentence">${s}</div>`)}</div></div>`;
   }
   if (live) return placeholder ? html`<div class="gen-text streaming">…</div>` : nothing;
-  return text ? html`<div class="gen-text" data-answer-at=${at ?? nothing} .textContent=${text}></div>` : nothing;
+  if (!text) return nothing;
+  if (typeof rendered === "string" && rendered) {
+    return html`<div class="gen-text markdown md-compact" data-answer-at=${at ?? nothing} data-copy-source=${text} .innerHTML=${rendered}></div>`;
+  }
+  return html`<div class="gen-text" data-answer-at=${at ?? nothing} .textContent=${text}></div>`;
 }
 
 // One step, live or reloaded. +gen+: { text, thinking, tools, answer } (a
@@ -97,7 +105,7 @@ export function stepTemplate(gen, st = {}) {
   const failed = !live && model.failedCount(gen.tools) > 0;
   // A step left with its thinking only reads "thinking" once.
   const wrapped = live || !!text || gen.tools.length > 0;
-  return html`<details class=${`gen${live ? " live" : ""}${failed ? " has-failed" : ""}`} .open=${open}><summary class=${label.repeats ? "repeats" : nothing} @click=${on.stepClick ?? nothing}>${label.content}</summary>${steers}${gen.thinking ? thinkingTemplate({ body, wrapped, line, on }) : nothing}${textTemplate(text, { live, sentences, placeholder, at })}${items.length ? html`<div class="activity-body">${items}</div>` : nothing}</details>`;
+  return html`<details class=${`gen${live ? " live" : ""}${failed ? " has-failed" : ""}`} .open=${open}><summary class=${label.repeats ? "repeats" : nothing} @click=${on.stepClick ?? nothing}>${label.content}</summary>${steers}${gen.thinking ? thinkingTemplate({ body, wrapped, line, on }) : nothing}${textTemplate(text, { live, sentences, placeholder, at, rendered: gen.html })}${items.length ? html`<div class="activity-body">${items}</div>` : nothing}</details>`;
 }
 
 // A hook's line (hook_notice) as a step's row. data.line is a whole row of
@@ -807,10 +815,11 @@ function defaultPlaceAnswer(appendToHistory) {
 
 // The text of a reloaded block's step +iteration+ (1-based, as the snapshot's
 // cards count), "" when it has none: a reloaded question card's asking
-// reply.
+// reply, as written (a rendered step keeps it as data-copy-source).
 export function stepText(block, iteration) {
   const step = block?.querySelectorAll(":scope > .gen")[Number(iteration) - 1];
-  return step?.querySelector(":scope > .gen-text")?.textContent || "";
+  const text = step?.querySelector(":scope > .gen-text");
+  return text?.getAttribute("data-copy-source") ?? text?.textContent ?? "";
 }
 
 // A re-rendered failed turn's line (a .bubble.cancel, as live's
@@ -885,7 +894,12 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
     if (plainThinking) {
       parts.push(thinkingTemplate({ body: only.thinking, cls: "bubble thinking" }));
     } else if (group.steps.length) {
-      const gens = group.steps.map((step) => ({ text: step.i === null ? "" : String(items[step.i].content ?? ""), thinking: step.thinking || "", tools: step.tools }));
+      // A step's text with its message's rendered markdown (html: web.markdown on).
+      const gens = group.steps.map((step) => ({
+        text: step.i === null ? "" : String(items[step.i].content ?? ""),
+        html: step.i === null ? null : items[step.i].html ?? null,
+        thinking: step.thinking || "", tools: step.tools,
+      }));
       const steps = gens.map((gen, k) => stepTemplate(gen, {
         // The steers the step answered first, where the live rows went.
         steers: (group.steps[k].steers || []).map((i) => steerTemplate(i, false)),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.100.0
+  version: 0.100.1
 platform: ruby
 authors:
 - Dmitry Dedov