samagotchi 0.100.0 → 0.101.0

data/lib/samagotchi/host_keys.rb

@@ -21,16 +21,22 @@ module Samagotchi
     # Reads one generic password through /usr/bin/security (by absolute
     # path: the helper's PATH isn't the shell's) in its own process group,
     # killed at the deadline: a locked keychain or an access dialog must not
-    # hang a turn. nil on a miss, a non-zero exit, a timeout, no binary, or
-    # off macOS.
+    # hang a turn. The deadline covers the spawn too (macOS can hold a first
+    # exec for minutes while it scans the binary): the run is a thread the
+    # caller gives up on, and a pid that turns up late is killed and reaped
+    # there. nil on a miss, a non-zero exit, a timeout, no binary, or off
+    # macOS.
     class Keychain
       SECURITY = "/usr/bin/security"
       TIMEOUT = 5
 
-      def initialize(security: SECURITY, timeout: TIMEOUT, host_os: RbConfig::CONFIG["host_os"])
+      # +spawner+: how the run starts (Process.spawn's arguments; specs stall it).
+      def initialize(security: SECURITY, timeout: TIMEOUT, host_os: RbConfig::CONFIG["host_os"],
+                     spawner: Process.method(:spawn))
         @security = security
         @timeout = timeout
         @macos = host_os.to_s.include?("darwin")
+        @spawner = spawner
       end
 
       # @return [String, nil]
@@ -45,33 +51,44 @@ module Samagotchi
       private
 
       def run(name)
-        reader, writer = IO.pipe
-        pid = Process.spawn(@security, "find-generic-password", "-s", SERVICE, "-a", name, "-w",
-                            in: File::NULL, out: writer, err: File::NULL, pgroup: true)
-        writer.close
-        waiter = Process.detach(pid)
-        unless waiter.join(@timeout)
-          stop(pid, waiter)
-          Log.warn(:config, "keychain_timeout", name: name, seconds: @timeout)
-          return nil
+        lock = Mutex.new
+        pid = nil
+        late = false
+        worker = Thread.new do
+          Thread.current.report_on_exception = false
+          security(name) { |spawned| lock.synchronize { late ? stop(spawned) : pid = spawned } }
         end
-        return nil unless waiter.value.success?
+        return worker.value if worker.join(@timeout)
 
-        key = reader.read.to_s.chomp
-        key.strip.empty? ? nil : key
+        lock.synchronize do
+          late = true
+          stop(pid) if pid
+        end
+        Log.warn(:config, "keychain_timeout", name: name, seconds: @timeout)
+        nil
       rescue SystemCallError
         nil
+      end
+
+      # One run, start to reap; yields the pid as soon as there is one.
+      def security(name)
+        reader, writer = IO.pipe
+        pid = @spawner.call(@security, "find-generic-password", "-s", SERVICE, "-a", name, "-w",
+                            in: File::NULL, out: writer, err: File::NULL, pgroup: true)
+        writer.close
+        yield pid
+        key = reader.read.to_s.chomp
+        _, status = Process.wait2(pid)
+        status.success? && !key.strip.empty? ? key : nil
       ensure
         writer&.close unless writer&.closed?
         reader&.close
       end
 
-      def stop(pid, waiter)
+      def stop(pid)
         Process.kill(:KILL, -pid)
       rescue SystemCallError
         nil
-      ensure
-        waiter.join(1)
       end
     end
 

data/lib/samagotchi/testing/fake_executable.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "tmpdir"
 
 module Samagotchi
   module Testing
     # Fake commands for a test's PATH (Sandbox#fake_executable), cheap to
     # exec: macOS checks a new executable file on its first exec (about
-    # 0.5–1 s, once per file). A fake is a symlink to one launcher, made
-    # once per process, that runs the fake's body (<name>.sh beside the
-    # link) with /bin/sh: writing a new body costs nothing.
+    # 0.5–1 s, once per file; minutes on a busy machine). A fake is a
+    # symlink to the checked-in launcher, which runs the fake's body
+    # (<name>.sh beside the link) with /bin/sh: writing a new body costs
+    # nothing.
     module FakeExecutable
-      LAUNCHER = "#!/bin/sh\nexec /bin/sh \"$0.sh\" \"$@\"\n"
+      LAUNCHER = File.expand_path("fake_executable_launcher", __dir__)
 
       module_function
 
@@ -26,17 +26,7 @@ module Samagotchi
         path
       end
 
-      def launcher
-        @launcher ||= begin
-          dir = Dir.mktmpdir("chi-fake-exec")
-          owner = Process.pid
-          at_exit { FileUtils.rm_rf(dir) if Process.pid == owner }
-          File.join(dir, "launcher").tap do |path|
-            File.write(path, LAUNCHER)
-            File.chmod(0o755, path)
-          end
-        end
-      end
+      def launcher = LAUNCHER
     end
   end
 end

data/lib/samagotchi/testing/fake_executable_launcher

@@ -0,0 +1,6 @@
+#!/bin/sh
+# What every FakeExecutable (and spec/support/fake_executables.rb) fake
+# links to: runs the fake's body, <link>.sh, with /bin/sh. Checked in, not
+# written per process: macOS scans a just-written executable at its first
+# exec, which under a busy run can stall for minutes.
+exec /bin/sh "$0.sh" "$@"

data/lib/samagotchi/tool_response.rb

@@ -10,10 +10,11 @@ module Samagotchi
   module ToolResponse
     SEPARATOR = "\n\n---\n\n"
     # Saved with a result for the web's reload (a plugin tool's params line,
-    # label and row refs, an edit/write's diff) and for the LLMContextView (each
+    # label and row refs, an edit/write's diff), for the LLMContextView (each
     # run's chi-owned id, ToolIds, and a strategy's edits by id,
-    # LLMContextEdit); the prompt never renders them.
-    SAVED_KEYS = %i[tool_params tool_labels tool_diffs tool_refs tool_ids edits].freeze
+    # LLMContextEdit) and for WorkingSet (a file run's stamp, ToolRun#stamp);
+    # the prompt never renders them.
+    SAVED_KEYS = %i[tool_params tool_labels tool_diffs tool_refs tool_ids tool_stamps edits].freeze
     # The tools a chat result loaded (#single), saved with it.
     LOADED = :loaded
     # A run's "[name]" lead: the name, then a newline, a space or the end.
@@ -84,7 +85,7 @@ module Samagotchi
         entry[:image_counts] = runs.map { |run| Array(run.images).size }
       end
       saved = { tool_params: runs.map(&:shown_params), tool_labels: runs.map(&:shown_label),
-                tool_diffs: runs.map(&:diff), tool_refs: runs.map(&:refs) }
+                tool_diffs: runs.map(&:diff), tool_refs: runs.map(&:refs), tool_stamps: runs.map(&:stamp) }
       saved.each { |key, values| entry[key] = values if values.any? }
       entry[:tool_ids] = ids
       entry
@@ -92,8 +93,10 @@ module Samagotchi
 
     # The chat loop's entry for one call: its capped output, paired with the
     # call by +tool_call_id+, and its chi-owned id (a one-id +ids+, as
-    # #joined's tool_ids); a find_tools hit's +loaded+ names (saved on every
-    # chat backend: a wire that loads tools renders them, LLM::AnthropicWire).
+    # #joined's tool_ids) and its stamp (a one-stamp tool_stamps, likewise:
+    # read by the run's place); a find_tools hit's +loaded+ names (saved on
+    # every chat backend: a wire that loads tools renders them,
+    # LLM::AnthropicWire).
     def single(run, tool_call_id:, ids:)
       entry = { role: "tool_response", content: run.capped_output, tool_call_id: tool_call_id }
       entry[:images] = run.images if run.images&.any?
@@ -102,6 +105,7 @@ module Samagotchi
       entry[:tool_diffs] = run.diff if run.diff
       entry[:tool_refs] = run.refs if run.refs
       entry[:tool_ids] = ids
+      entry[:tool_stamps] = [run.stamp] if run.stamp
       entry[LOADED] = run.loaded if run.loaded&.any?
       entry
     end

data/lib/samagotchi/tool_runner.rb

@@ -3,6 +3,7 @@
 require_relative "tool_activity"
 require_relative "tool_row_fields"
 require_relative "row_refs"
+require_relative "file_ref"
 require_relative "guardrails"
 require_relative "vision_context"
 require_relative "log"
@@ -18,12 +19,14 @@ module Samagotchi
   # One call's result from ToolRunner#run, read by ToolResponse (the loops'
   # tool_response entries) and the loops' activity list. Fields a call didn't
   # produce (images, shown_params, shown_label, refs, diff, output_file,
-  # loaded) are nil. +loaded+: the tools a find_tools hit loads
-  # (Tools::ToolIndex::FoundText#loaded), by their wire names.
+  # loaded, stamp) are nil. +loaded+: the tools a find_tools hit loads
+  # (Tools::ToolIndex::FoundText#loaded), by their wire names. +stamp+: an
+  # ok read/edit/write's file right after it ran ({path:, mtime_ns:,
+  # size:}), what WorkingSet tells a file changed since by.
   ToolRun = Data.define(:output, :capped_output, :truncated, :activity, :images, :shown_params, :shown_label, :refs, :diff,
-                        :output_file, :loaded) do
+                        :output_file, :loaded, :stamp) do
     def initialize(output: nil, capped_output: nil, truncated: nil, activity: nil, images: nil, shown_params: nil,
-                   shown_label: nil, refs: nil, diff: nil, output_file: nil, loaded: nil)
+                   shown_label: nil, refs: nil, diff: nil, output_file: nil, loaded: nil, stamp: nil)
       super
     end
   end
@@ -153,11 +156,27 @@ module Samagotchi
                   images: images&.any? ? images : nil,
                   shown_params: params && plugin_tool?(call[:name]) ? params : nil,
                   shown_label: label, refs: refs.empty? ? nil : refs, diff: diff, output_file: output_file,
-                  loaded: result[:loaded])
+                  loaded: result[:loaded], stamp: status == "ok" ? file_stamp(call) : nil)
     end
 
     private
 
+    # An ok read/edit/write's file as it is now, right after the call:
+    # {path:, mtime_ns:, size:}, the path as FileRef has it (against the
+    # session's folder, no realpath). nil for any other tool, a path it
+    # can't place and a stat that fails or isn't a file's.
+    def file_stamp(call)
+      ref = FileRef.for(call[:name], call, cwd: session_cwd)
+      return nil unless ref
+
+      stat = File.stat(ref.path)
+      return nil unless stat.file?
+
+      { path: ref.path, mtime_ns: (stat.mtime.to_i * 1_000_000_000) + stat.mtime.nsec, size: stat.size }
+    rescue SystemCallError
+      nil
+    end
+
     # +output+ cut to +cap+ by its tool's policy (ToolOutputCut); an
     # execute result keeps its tail too, its whole output saved in the
     # session's folder.
@@ -310,7 +329,7 @@ module Samagotchi
     # The session's folder (the Engine's, KernelLoop#session_cwd), else the
     # process's: a bare kernel (specs) has none.
     def session_cwd
-      cwd = @kernel.respond_to?(:session_cwd) && @kernel.session_cwd&.call
+      cwd = @kernel.session_cwd&.call if @kernel.respond_to?(:session_cwd)
       cwd.to_s.empty? ? Dir.pwd : cwd
     end
 

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -25,6 +25,7 @@ require_relative "../session_commands"
 require_relative "../steer"
 require_relative "../host_registry"
 require_relative "../llm_context_override"
+require_relative "../working_set"
 require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../session_setting"
@@ -97,6 +98,8 @@ module Samagotchi
       #   freshly-spawned worker's bridge before answering POST /api/sessions.
       # @param view ["stage", "turn"] the page's view of a turn (web.view);
       #   ?view=stage|turn overrides it for one page load
+      # @param working_set [Boolean] the stage view's working set
+      #   (web.working_set); ?working_set=1|0 overrides it for one page load
       # @param annotate_presets [String, Array] the quick replies next to
       #   Annotate (web.annotate_presets, "|"-separated); "" shows none. The
       #   page parses them (annotate_presets.js).
@@ -119,7 +122,8 @@ module Samagotchi
                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
                      editor: Config::BY_KEY["web.editor"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
-                     registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil)
+                     registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil,
+                     working_set: Config::BY_KEY["web.working_set"].default)
         @manager = manager || SessionManager
         @registry = registry
         @registry_given = !registry.nil?
@@ -132,6 +136,7 @@ module Samagotchi
         @bridge_wait_timeout = bridge_wait_timeout
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @view = view
+        @working_set = working_set
         @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
         @editor_url = Editor.template(editor)
         @hub = hub
@@ -183,6 +188,7 @@ module Samagotchi
         ["GET", %r{\A/api/sessions/([^/]+)/context/([^/]+)\z}, :handle_context_show, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/context\z}, :handle_context_add, :session],
         ["DELETE", %r{\A/api/sessions/([^/]+)/context/([^/]+)\z}, :handle_context_delete, :session],
+        ["GET", %r{\A/api/sessions/([^/]+)/working_set\z}, :handle_working_set, :session],
         ["GET", %r{\A/api/sessions/([^/]+)\z}, :handle_show, :session],
         ["DELETE", %r{\A/api/sessions/([^/]+)\z}, :handle_delete, :session]
       ].freeze
@@ -1477,6 +1483,36 @@ module Samagotchi
         error_response(409, e.reason.to_s, "#{e.message}; try again in a moment")
       end
 
+      # ── The working set (web.working_set) ───────────────────────────────
+
+      # GET /api/sessions/:id/working_set: the working set as the model has
+      # it ({items:, at:}, WorkingSet), what the page overlays on its rows'
+      # set when it seeds a session's and when the expanded view opens (a
+      # file changed while the session sat idle). A live worker's snapshot
+      # messages are the truth, as #handle_show's, else the file's; the
+      # strategy is the session's llm ctx chip's, the folder its working
+      # directory.
+      def handle_working_set(_req, id)
+        session = @session_class.load(id, state_dir: default_state_dir)
+        live = bridge_get_json(id, "snapshot")
+        messages = live_or_saved(live && live["snapshot"], "messages") { session.messages }
+        # A snapshot's entries have string keys (paired_runs reads symbols).
+        messages = Array(messages).map { |message| message.is_a?(Hash) ? message.transform_keys(&:to_sym) : message }
+        llm_context = SessionSetting::LLM_CONTEXT.snapshot_value(live && live["session_state_snapshot"]) do
+          SessionSetting::LLM_CONTEXT.saved_summary(session, registry: host_registry)
+        end
+        snapshot = WorkingSet.build(messages, cwd: session.working_directory, strategy: working_set_strategy(llm_context))
+        json_response(200, snapshot.to_h)
+      end
+
+      # The strategy an llm ctx chip names ("none", "stale,forget"), as
+      # LLMContextView takes it; none when there is no chip.
+      def working_set_strategy(llm_context)
+        named = llm_context.is_a?(Hash) ? (llm_context[:strategy] || llm_context["strategy"]).to_s : ""
+        layers = named.split(",").map(&:strip).reject { |layer| layer.empty? || layer == "none" }
+        layers.empty? ? LLMContextView::NONE : layers.map(&:to_sym)
+      end
+
       # ── Attached context (ContextSources): the session bar's chips ───────
       # A source's command isn't shown (the page may be on a phone over the
       # LAN), and the web adds a URL only, through an installed bundle's
@@ -2126,6 +2162,8 @@ module Samagotchi
         # the one serving now (an upgraded chi web after a reconnect).
         attrs = { "sessions-dir" => sessions_dir_label, "server-dir" => home_label(Dir.pwd), "version" => Samagotchi::VERSION }
         attrs["view"] = view_name(req.params["view"])
+        # Only when on: the page reads its presence (the turn view ignores it).
+        attrs["working-set"] = "1" if working_set?(req.params["working_set"])
         # Always there: an empty one means no presets, not the default.
         attrs["annotate-presets"] = @annotate_presets
         dir, = scope_dir(req.params["dir"])
@@ -2154,6 +2192,16 @@ module Samagotchi
         VIEWS.include?(param) ? param : @view
       end
 
+      # The working set for this page load: ?working_set=1|0 wins, anything
+      # else leaves the config's choice (web.working_set).
+      def working_set?(param)
+        case param
+        when "1" then true
+        when "0" then false
+        else @working_set
+        end
+      end
+
       def json_response(status, payload)
         body = JSON.generate(payload)
         [status, { "Content-Type" => "application/json; charset=utf-8", "Content-Length" => body.bytesize.to_s, "Cache-Control" => "no-store" }, [body]]

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

@@ -21,6 +21,7 @@ import {
   detachContext,
   addContext,
   renderText,
+  getWorkingSet,
 } from "./data.js";
 import { createContextChips } from "./context_chips.js";
 import { createLlmContextControl } from "./llm_context_chip.js";
@@ -37,8 +38,10 @@ import { elementOf, emptyAnswerTemplate } from "./turn_html.js";
 import { createBubbles, hintEl, outputBubbleTemplate } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView } from "./stage_view.js";
+import { createWorkingSet, groupItems } from "./working_set_view.js";
+import { turnGroups } from "./timing.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 +70,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 +177,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,12 +225,24 @@ const markdownPlace = createMarkdownPlace({
   normalize,
   pairAnswerRefs,
   setAnswerRefs,
+  answerRefsOf,
 });
 const { renderMarkdown, pairRefsIn, linkRefsIn, applyFinalMarkdown, linkTextRefs } = markdownPlace;
+// The stage view's working set (web.working_set, or ?working_set=1|0):
+// what each turn brought into context, in a rail in the stage, a footprint
+// under each finished turn and a "set N" chip in the mem chip's place
+// (working_set_view.js). The turn view ignores it.
+const workingSet = view === "stage" && document.body.dataset.workingSet === "1"
+  ? createWorkingSet({
+    historyEl, stageRoot: () => turnDom.root, state: () => current, session: () => selected, infoEl: infoTextEl,
+    onChange: () => updateInfoBar(), getWorkingSet,
+  })
+  : null;
+document.body.classList.toggle("working-set", !!workingSet);
 const turnDom = view === "stage"
   ? createStageView({
     ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl,
-    renderMarkdown, linkRefs: linkRefsIn,
+    renderMarkdown, linkRefs: linkRefsIn, workingSet,
   })
   : createTurnView(viewArgs);
 // The history's bottom reserve and the toast's place follow the composer
@@ -500,6 +524,7 @@ const sessionActions = createSessionActions({
   toast: showToast,
   addCreatedSession,
   fillOpener,
+  restoreDraft,
   closeLiveStream: () => streamControl?.close(),
   workerGone,
 });
@@ -759,6 +784,7 @@ function clearNotice() {
   noticeEl.textContent = "";
 }
 promptEl.addEventListener("input", clearNotice);
+promptEl.addEventListener("input", () => noteDraft());
 
 async function select(id) {
   clearNotice();
@@ -850,6 +876,7 @@ function renderSessionView(data, { kept = [] } = {}) {
   reasoningHistoryControl.refresh();
   if (data.messages && data.messages.length) renderHistory(data.messages);
   else renderHistory(data.history || []);
+  seedWorkingSet(data);
   restoreCommandBubbles(historyEl, kept);
   // A failed turn's prompt went back to the user: shown after the
   // conversation, marked failed, as it was live (prompt_restored).
@@ -909,13 +936,27 @@ function renderSessionView(data, { kept = [] } = {}) {
   updateComposerMode();
 }
 
+// The working set's turns from a session's messages, as turnHistoryNodes
+// numbers them; the running turn (the replay draws it in the stage) isn't
+// one of them yet.
+function seedWorkingSet(data) {
+  if (!workingSet) return;
+  const items = data.messages || [];
+  const groups = typeof items[0] === "object" && items[0]?.role ? turnGroups(items, current.timing).filter((g) => g.kind === "turn") : [];
+  if (data.current_turn && groups.length) groups.pop();
+  workingSet.seed(groups.map((g, i) => {
+    const text = String(items[g.user]?.content ?? "").replace(/\s+/g, " ").trim();
+    return { items: groupItems(g, i), prompt: text.length > 60 ? `${text.slice(0, 59)}\u2026` : text };
+  }));
+}
+
 function renderHistory(items) {
   if (!items.length) {
     historyEl.replaceChildren(hintEl("No output yet. Send a message."));
     return;
   }
   if (typeof items[0] === "object" && items[0].role) {
-    historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsTemplate(selected, images) }));
+    historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsTemplate(selected, images), workingSet: !!workingSet }));
     linkTextRefs();
   } else {
     historyEl.replaceChildren(...items.map((c) => elementOf(outputBubbleTemplate(c))));
@@ -1076,7 +1117,7 @@ function updateInfoBar() {
   const { buttons, bar } = sessionBar({
     id: selected, state: current, sessions: allSessions, versions, cardTitle: (s) => lists.cardTitle(s),
     continuing: sessionActions.continuing, restarting: restartingIds, streaming: !!streamControl, running: liveTurn.running,
-    now: Date.now(),
+    now: Date.now(), workingSet: workingSet ? workingSet.chip() : undefined,
   });
   const stopBtn = document.getElementById("infoStopBtn");
   const deleteBtn = document.getElementById("infoDeleteBtn");
@@ -1257,6 +1298,7 @@ const streamHandlers = createStreamHandlers({
   llmContextControl,
   thinkingControl,
   reasoningHistoryControl,
+  workingSet,
   sentIds,
   earlyRestores,
   stream: {
@@ -1277,6 +1319,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 +1415,7 @@ const sendTurnControl = createSendTurn({
     clear: clearComposer,
     openForVisit: () => openForVisit(),
     focus: () => focusPrompt(),
+    noteDraft,
   },
   historyEl,
   turnDom,
@@ -1525,6 +1569,7 @@ const unqueue = createUnqueue({
     if (promptEl.value.trim() || chips.length) return false;
     openForVisit();
     promptEl.value = text;
+    noteDraft();
     fitPrompt();
     promptEl.focus();
     return true;
@@ -1571,7 +1616,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 +1636,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 +1669,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 +1707,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) {