samagotchi 0.59.0 → 0.61.0

data/lib/samagotchi/system_prompt.rb

@@ -11,6 +11,7 @@ require_relative "model_notes"
 require_relative "bundle_needs"
 require_relative "memory_bundle/index_size"
 require_relative "thinking"
+require_relative "prompt_files"
 
 module Samagotchi
   # The system prompt an Engine gives its model: the base prompt (tool
@@ -24,8 +25,6 @@ module Samagotchi
   # tools a plugin replaces, the attached session, the thinking level) is
   # read at build time through the lookups; the memory lists are fixed.
   class SystemPrompt
-    AGENT_DESCRIPTION_FILE = "AGENTS.md"
-
     # The model a session runs on, as the prompt names it: the resolved
     # ref, its host ("name, host:port" or url), the memory overlay key, and
     # what a llama.cpp server says it serves when that differs (else nil).
@@ -51,8 +50,10 @@ module Samagotchi
     #   model's (none: the section is left out)
     # @param memories [Array<String>] the --memory list
     # @param muted_memory_names [Array<String>] normalized (MutedMemories)
+    # @param appended_files [Array<String>] chi --append-system-prompt's
+    #   files (absolute paths), after config.yml's append_system_prompt:
     def initialize(profile:, tools:, session:, thinking:, model: -> {}, model_notes: -> { [] }, memories: [],
-                   muted_memory_names: [])
+                   muted_memory_names: [], appended_files: [])
       @profile_lookup = profile
       @model_lookup = model
       @model_notes_lookup = model_notes
@@ -61,6 +62,14 @@ module Samagotchi
       @thinking_lookup = thinking
       @muted_memory_names = muted_memory_names
       @requested_memories = effective_preload_list(preload_memory_list(memories))
+      # Read once, as the memories: list is: a config edit is picked up by
+      # a new process. The files' text is read at each build.
+      @config_appended = begin
+        ConfigFile.appended_prompt_files
+      rescue StandardError
+        []
+      end
+      @cli_appended = Array(appended_files).map { |path| File.expand_path(path.to_s) }
     end
 
     # @return [Array<String>] the names the session preloads, known before
@@ -81,16 +90,20 @@ module Samagotchi
       @built ||= {}
       @index_sizes ||= {}
       @notes_loaded ||= {}
+      @files_loaded ||= {}
       unless @built.key?(key)
         @section_notes = nil
+        @section_files = []
         @built[key] = system_prompt_with_index(
           assist_system_prompt(chat: chat, thinking: thinking, layers: layers), chat: chat, thinking: thinking, layers: layers
         )
         @index_sizes[key] = @measured_index
         @notes_loaded[key] = @section_notes || []
+        @files_loaded[key] = @section_files.freeze
       end
       @memory_index = @index_sizes[key]
       @prompt_notes = @notes_loaded[key]
+      @prompt_files = @files_loaded[key]
       @built[key]
     end
 
@@ -108,6 +121,14 @@ module Samagotchi
     # @return [Array<ModelNotes::Note>, nil]
     attr_reader :prompt_notes
 
+    # The files whose text the prompt #build returned last holds, as
+    # absolute paths in prompt order: the AGENTS.md chain, then the
+    # appended files (append_system_prompt:, --append-system-prompt). [] before a
+    # build and after #reset!. Read when the prompt is built, as the
+    # sections are.
+    # @return [Array<String>]
+    def prompt_files = @prompt_files || []
+
     # Drops the built prompts: the next #build reads the profile, tools,
     # indexes and memories again (a model or profile switch, changed tools).
     def reset!
@@ -115,6 +136,8 @@ module Samagotchi
       @index_sizes = nil
       @notes_loaded = nil
       @prompt_notes = nil
+      @files_loaded = nil
+      @prompt_files = nil
       @stable_lengths = nil
     end
 
@@ -295,7 +318,7 @@ module Samagotchi
         "System memories:\n#{indexes[:system]}"
       ].join("\n\n")
       stable = [thinking_token + base, rg_guidance, system_identity_section, model_notes_section, explicit_memory_section,
-                project_specific_description, memory_sections]
+                project_specific_description, appended_section, memory_sections]
       stable_text = stable.compact.join("\n")
       volatile = [current_model, project_location, current_session].compact
       return with_tail_declarations(stable_text, chat: chat, layers: layers) if volatile.empty?
@@ -464,26 +487,59 @@ module Samagotchi
 
     # ── Project / rg helpers ───────────────────────────────────────────────────
 
-    # AGENTS.md in the cwd, else at the top of its git work tree.
+    # The AGENTS.md chain from the top of the git work tree down to the cwd
+    # (PromptFiles.agents_sections), one section per file with text.
     def project_specific_description
       return nil if skip_agent_description?
 
-      path = agent_description_path
-      return nil unless path
-
-      content = File.read(path, encoding: "UTF-8").strip
-      return nil if content.empty?
+      sections = PromptFiles.agents_sections(Dir.pwd)
+      return nil if sections.empty?
 
-      "Project specific description:\n#{content}"
+      @section_files&.concat(sections.map(&:path))
+      sections.map(&:text).join("\n\n")
     rescue StandardError
       nil
     end
 
-    def agent_description_path
+    # The appended files' text, right after AGENTS.md (the stable, cached
+    # part): config.yml's append_system_prompt: entries first (a relative
+    # one against the cwd, as AGENTS.md is found; a missing one is skipped),
+    # then --append-system-prompt's. A file the AGENTS.md chain holds, a
+    # repeat and an empty or vanished file are left out.
+    def appended_section
       cwd = Dir.pwd
-      [cwd, MemoryPaths.work_tree_root(cwd)].compact.uniq
-        .map { |dir| File.join(dir, AGENT_DESCRIPTION_FILE) }
-        .find { |path| File.file?(path) }
+      top = MemoryPaths.work_tree_root(cwd)
+      seen = Set.new((skip_agent_description? ? [] : PromptFiles.agents_paths(cwd)).map { |path| canonical_path(path) })
+      sections = []
+      appended_candidates(cwd).each do |path, source|
+        next unless seen.add?(canonical_path(path))
+
+        unless File.file?(path)
+          Log.debug(:config, "appended_prompt_file_missing", path: path, source: source)
+          next
+        end
+        text = PromptFiles.section(path, "Appended from #{PromptFiles.display_path(path, top: top)}:")
+        next unless text
+
+        @section_files&.push(path)
+        sections << text
+      end
+      sections.empty? ? nil : sections.join("\n\n")
+    rescue StandardError
+      nil
+    end
+
+    # [absolute path, "config" | "cli"], in prompt order.
+    def appended_candidates(cwd)
+      @config_appended.map { |entry| [File.expand_path(entry, cwd), "config"] } +
+        @cli_appended.map { |path| [path, "cli"] }
+    end
+
+    # The same file however it's spelled (/tmp vs /private/tmp on macOS).
+    def canonical_path(path)
+      File.realpath(path)
+    rescue SystemCallError
+      File.expand_path(path)
     end
 
     # Where the session runs and which project memory folder it uses. Only

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -37,6 +37,8 @@ module Samagotchi
       # @param memories [Array<String>] --memory: a new session's worker
       #   preloads them (an existing session keeps its own list)
       # @param muted_memories [Array<String>] --mute: hidden from a new session
+      # @param appended_prompt_files [Array<String>] --append-system-prompt's
+      #   files (absolute): a new session's setup carries them
       # @param llm_context [Hash{Symbol => String}] --llm-context* as typed
       #   (LLMContextOverride.update): a new session starts with them; a
       #   resumed or attached one's worker gets a /llm-context, after the
@@ -48,9 +50,10 @@ module Samagotchi
       #   :failed when the --model switch didn't go through, or (input from a
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
-              memories: [], muted_memories: [], llm_context: {}, thinking: nil)
+              memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [])
         client = connect(attach: attach, shared: shared, resume: resume, model: model,
-                         memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking)
+                         memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
+                         appended_prompt_files: appended_prompt_files)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
@@ -117,9 +120,11 @@ module Samagotchi
       # @return [BridgeClient] a client for the live Bridge of the session
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
-                  memories: [], muted_memories: [], llm_context: {}, thinking: nil, err: $stderr)
+                  memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], err: $stderr)
         sd = state_dir || Session.default_state_dir
-        warn_memory_flags_ignored(attach || resume, memories, muted_memories, err) if attach || resume
+        if attach || resume
+          warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files)
+        end
         if attach
           live = connect_existing(attach, sd)
           return live if live
@@ -134,7 +139,8 @@ module Samagotchi
                     SessionManager.spawn_session(prompt: nil, model_name: model && model_ref(model), state_dir: sd,
                                                  memories: memories, muted_memories: muted_memories,
                                                  setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
-                                                                         thinking: Thinking.session_level(thinking)))
+                                                                         thinking: Thinking.session_level(thinking),
+                                                                         appended_prompt_files: appended_prompt_files))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)
         client || raise(Error, "the worker for session #{session.id} did not start its Bridge in time")
@@ -150,16 +156,19 @@ module Samagotchi
       end
 
       # An existing session's prompt is built from its own session fields:
-      # --memory/--mute given with --attach or --resume are ignored, with a
-      # line saying so (printed before the live region opens).
-      def warn_memory_flags_ignored(session_id, memories, muted_memories, err)
+      # --memory/--mute/--append-system-prompt given with --attach or
+      # --resume are ignored, with a line saying so (printed before the live
+      # region opens).
+      def warn_memory_flags_ignored(session_id, memories, muted_memories, err, appended_prompt_files: [])
         flags = []
         flags << "--memory" unless Array(memories).empty?
         flags << "--mute" unless Array(muted_memories).empty?
+        flags << "--append-system-prompt" unless Array(appended_prompt_files).empty?
         return if flags.empty?
 
         verb = flags.size == 1 ? "applies" : "apply"
-        err.puts "(#{flags.join(" and ")} #{verb} to a new session; #{session_id}'s prompt is already built)"
+        names = flags.size > 2 ? "#{flags[0..-2].join(", ")} and #{flags.last}" : flags.join(" and ")
+        err.puts "(#{names} #{verb} to a new session; #{session_id}'s prompt is already built)"
       end
 
       # @return [BridgeClient, nil] the running worker's, or nil when none runs

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -8,6 +8,7 @@ require_relative "../steer"
 require_relative "../steer_cut"
 require_relative "../memory_bundle/index_size"
 require_relative "../prompt_note"
+require_relative "../prompt_files"
 
 module Samagotchi
   class TerminalUI
@@ -404,6 +405,16 @@ module Samagotchi
         "#{"~" if source.to_s == "estimate"}#{number} tok/s"
       end
 
+      # The prompt files (absolute paths) named as the prompt names them:
+      # relative to this checkout's top, else with ~; nil with none.
+      def prompt_files_text(paths)
+        list = Array(paths).map(&:to_s).reject(&:empty?)
+        return nil if list.empty?
+
+        top = MemoryPaths.work_tree_root(Dir.pwd)
+        list.map { |path| PromptFiles.display_path(path, top: top) }.join(", ")
+      end
+
       # "~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)":
       # the memory indexes the session's prompt holds (the snapshot's
       # memory_index, symbol or string keys); "" without one. As ctx.js
@@ -600,6 +611,9 @@ module Samagotchi
         # The model notes the session's prompt carried (Engine#prompt_notes).
         notes = PromptNote.text(snapshot[:prompt_notes])
         lines << "model notes:      #{notes}" unless notes.empty?
+        # The files whose text is in the prompt (SystemPrompt#prompt_files).
+        files = prompt_files_text(snapshot[:prompt_files])
+        lines << "prompt files:     #{files}" if files
         llm_context = llm_context_stats_text(snapshot[:llm_context])
         lines << "llm context:      #{llm_context}" if llm_context
         thinking = setting_stats_text(snapshot[:thinking])

data/lib/samagotchi/terminal_ui.rb

@@ -9,6 +9,7 @@ require_relative "client_id"
 require_relative "iteration_limit"
 require_relative "model_profile"
 require_relative "turn_note"
+require_relative "turn_checkpoint"
 require_relative "config"
 require_relative "context_note"
 require_relative "cancellation_controller"
@@ -92,8 +93,12 @@ module Samagotchi
     #   (LLMContextOverride.update): set on the new or resumed session
     # @param thinking [String, nil] --thinking as typed: the new or resumed
     #   session's own level (default unsets it)
+    # @param appended_prompt_files [Array<String>] --append-system-prompt's
+    #   files (absolute): a new session saves them; a resumed one's own come
+    #   first, and the merge goes only to the Engine (as --memory's does)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
-                   spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil)
+                   spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
+                   appended_prompt_files: [])
       @scratch        = scratch
       @thinking_word  = thinking
       @prompt         = prompt
@@ -142,9 +147,11 @@ module Samagotchi
       # session started attached with mutes keeps them here.
       @requested_memories = Array(memories)
       @muted_memory_names = Array(muted_memories)
+      @appended_prompt_files = Array(appended_prompt_files)
       if @resume_session
         @requested_memories = (@resume_session.preloaded_memory_names + @requested_memories).uniq
         @muted_memory_names = (@resume_session.muted_memory_names + @muted_memory_names).uniq
+        @appended_prompt_files = (@resume_session.appended_prompt_files + @appended_prompt_files).uniq
       end
       # Every terminal write goes through the surface. The REPL swaps in a
       # live region when the terminal can show one (#assist_loop), unless it
@@ -178,6 +185,7 @@ module Samagotchi
         model_typed: no_default ? @resumed_model_typed : nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
+        appended_prompt_files: @appended_prompt_files,
         recap: scratch ? nil : recap_config,
         scratch: scratch,
         reminders: {
@@ -258,7 +266,8 @@ module Samagotchi
         working_directory: Dir.pwd,
         preloaded_memory_names: @requested_memories,
         muted_memory_names: @muted_memory_names,
-        scratch: @scratch
+        scratch: @scratch,
+        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.
@@ -269,6 +278,9 @@ module Samagotchi
         session.save if @resume_session
       end
       claim_session!(session.id) unless @owner_lock
+      # A turn a worker died in (TurnCheckpoint): ended as canceled, with its
+      # note, before this REPL's first turn appends after it.
+      session.save if @resume_session && TurnCheckpoint.settle(session)
       keep_cards(session)
       # Saved at once, so a process killed before its first turn leaves a
       # file the sweep knows to delete.
@@ -628,7 +640,7 @@ module Samagotchi
     # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
     # Engine#run_turn, rendering via @renderer.
     # @param images [Array<Hash>] the prompt's `@path` images ({path:})
-    def run_engine_turn(session, prompt, continue: false, max_iterations: IterationLimit.for, images: [])
+    def run_engine_turn(session, prompt, continue: false, max_iterations: IterationLimit.for, images: [], resumed: false, resume_from: nil)
       cancellation_controller = CancellationController.new
       @active_cancel_controller = cancellation_controller
       @renderer.begin_turn
@@ -646,7 +658,9 @@ module Samagotchi
           cancel_controller: cancellation_controller,
           pending_input: method(:drain_steering),
           continue: continue,
-          images: images
+          images: images,
+          resumed: resumed,
+          resume_from: resume_from
         )
       end
     rescue Interrupt
@@ -774,9 +788,11 @@ module Samagotchi
       end
       return show_command_result(answer) unless answer.resume
 
+      # The run the offer's turn started: the Continue keeps its reasoning.
+      resume_from = @turn_flow.resume_from
       @turn_flow.before_continue_turn
       begin
-        result = run_engine_turn(session, nil, continue: true)
+        result = run_engine_turn(session, nil, continue: true, resumed: true, resume_from: resume_from)
       rescue LLM::ProviderError
         # The renderer showed the failure (:turn_failed).
         @surface.commit(turn_end_hint("continue prompt preserved"))

data/lib/samagotchi/turn_checkpoint.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "interrupted_turn"
+require_relative "log"
+require_relative "session"
+require_relative "steer"
+require_relative "turn_note"
+
+module Samagotchi
+  # A worker's running turn, kept on disk at the loop's iteration
+  # boundaries, so a worker killed mid-turn (SIGKILL, a crash of the
+  # process) loses at most INTERVAL seconds of it instead of all of it.
+  #
+  # At each boundary (Worker#pending_input_drain, on the turn's thread) the
+  # turn's live conversation (Engine#live_conversation) is copied, with the
+  # lines that boundary merges (their input files are deleted as they are
+  # claimed), into the session's overlay (Session#turn_checkpoint), marked
+  # with an InterruptedTurn. Every save while the turn runs writes the
+  # overlay instead of the session's messages: this one's, written at the
+  # first boundary (the prompt reaches the disk) and then at most every
+  # INTERVAL (or when the boundary merged input), and any other save in the
+  # turn (a question asked). The session's in-memory messages never change
+  # (a Bridge snapshot shows the turn in progress or in the messages, never
+  # both). The turn's end saves the real messages without a marker.
+  #
+  # The copy is what a Stop at that boundary would keep, minus its note, so
+  # the history before the turn is never rewritten (prompt caching); later
+  # steps of the same turn may still edit their own entries in place.
+  class TurnCheckpoint
+    INTERVAL = 10.0
+
+    # A session loaded with an InterruptedTurn mark (its worker died in the
+    # turn): the turn ends now, as canceled. Its note goes at the tail
+    # (append-only: the model reads on its next turn that the previous one
+    # was cut, after how long), the status goes idle and the mark goes. The
+    # dead turn is not run again. The caller saves.
+    #
+    # last_turn is left as it was: a new last_turn saved idle here, before
+    # the turn a `chi send --wait` started this worker for, would end that
+    # wait at once as the sent turn's (ReplyWait compares last_turn), with
+    # the dead turn's outcome.
+    # @return [InterruptedTurn, nil] the mark settled, nil when there was none
+    def self.settle(session)
+      mark = session.interrupted_turn
+      return nil unless mark
+
+      messages = Array(session.messages)
+      # How long it ran up to its last checkpoint (it died later); none
+      # when that was its first boundary ("after 0s" would mislead).
+      seconds = mark.seconds
+      seconds = nil if seconds && seconds < 1
+      note = TurnNote.cancelled(:worker_stopped, seconds: seconds, shown: TurnNote.interrupted_tail?(messages))
+      session.messages = messages + [note]
+      session.status = Session::STATUS_IDLE if session.status == Session::STATUS_RUNNING
+      session.interrupted_turn = nil
+      mark
+    end
+
+    # @param session [Session] the worker's session (saved as a whole)
+    # @param clock [#call] monotonic seconds (specs)
+    def initialize(session:, state_dir:, interval: INTERVAL, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+      @session = session
+      @state_dir = state_dir
+      @interval = interval
+      @clock = clock
+      @boundaries = 0
+      @written_at = nil
+      @started_at = nil
+    end
+
+    # A turn begins (before Engine#run_turn and the worker's running save):
+    # the overlay starts as the history plus +prompt+ (text only: no
+    # images, no turn id), marked at iteration 0, so a worker killed before
+    # the loop's first boundary leaves the prompt and a mark the next one
+    # settles. A continue turn (no prompt) is the history, marked.
+    # @param prompt [String, nil]
+    def begin_turn(prompt: nil)
+      @boundaries = 0
+      @written_at = nil
+      @started_at = Time.now.iso8601(3)
+      messages = Array(@session.messages).dup
+      messages << { role: "user", content: prompt } unless prompt.to_s.empty?
+      @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0) }
+    end
+
+    # The turn ended (or never began): the session saves its own messages.
+    def end_turn
+      @session.turn_checkpoint = nil
+    end
+
+    # An iteration boundary of the running turn.
+    # @param conversation [Array<Hash>, nil] the loop's live conversation;
+    #   nil (no turn): nothing
+    # @param merging [Array<Steer::Line>] the lines this boundary merges
+    #   (appended after the conversation, as Steer.inject! will)
+    # @param turn_id [String, nil]
+    # @return [Boolean] whether the session file was written
+    def boundary(conversation, merging: [], turn_id: nil)
+      return false unless conversation
+
+      @boundaries += 1
+      merged = merging.empty? ? [] : Steer.merge(merging).messages
+      # One level deep: the loop may edit an entry in place later (a
+      # forget stub) while a save on another thread serializes this one.
+      messages = conversation.map { |message| message.is_a?(Hash) ? message.dup : message } + merged
+      marker = InterruptedTurn.new(id: turn_id, started_at: @started_at, at: Time.now.iso8601(3), iteration: @boundaries)
+      @session.turn_checkpoint = { messages: messages, marker: marker }
+      return false unless due? || !merged.empty?
+
+      write
+    end
+
+    private
+
+    def due? = @written_at.nil? || @clock.call - @written_at >= @interval
+
+    def write
+      @session.save(state_dir: @state_dir)
+      @written_at = @clock.call
+      true
+    rescue StandardError => e
+      # The turn goes on; the next boundary tries again.
+      Log.warn(:worker, "checkpoint_failed", error: e.class.name, msg: e.message)
+      false
+    end
+  end
+end

data/lib/samagotchi/turn_flow.rb

@@ -42,8 +42,9 @@ module Samagotchi
       [:invalid, nil]
     end
 
-    # @return [Hash, nil] the pending continue offer: {context:, no_interrupt:}
-    #   (context summarizes the interrupted turn for a "no, <reason>")
+    # @return [Hash, nil] the pending continue offer: {context:, no_interrupt:,
+    #   run_start:, model:} (context summarizes the interrupted turn for a
+    #   "no, <reason>"; run_start and model are #resume_from's)
     attr_reader :offer
 
     # How many times the conversation went back to a checkpoint (a failed
@@ -94,7 +95,11 @@ module Samagotchi
       end
 
       if result.resumable?
-        @offer = { context: interrupted_turn_context(result), no_interrupt: no_interrupt }
+        # A Continue that ran out again goes on from the run the chain
+        # started; any other turn's offer (a prompt's, a wake's) from its own.
+        run_start = (continue && resume_from) || result.run_start
+        @offer = { context: interrupted_turn_context(result), no_interrupt: no_interrupt, run_start: run_start,
+                   model: @engine.effective_model_name }
         :continue_offered
       else
         @offer = nil
@@ -143,6 +148,20 @@ module Samagotchi
       :restored
     end
 
+    # Where a Continue of the pending offer resumes: the run its turn (or
+    # the first turn of a chain of Continues) started (ModelResult#run_start),
+    # so the Continue keeps that run's reasoning (Engine#run_turn
+    # resume_from:). nil with no offer, and after a model change while the
+    # offer stands: another model's reasoning isn't replayed, the Continue
+    # starts cold. A cancelled or failed Continue keeps the offer, and so
+    # this; every way the offer goes takes it along.
+    # @return [Integer, nil]
+    def resume_from
+      return nil unless @offer && @offer[:model] == @engine.effective_model_name
+
+      @offer[:run_start]
+    end
+
     # Answer the offer with no (Stop): the interrupted turn stays, as
     # after a Ctrl-C or a new prompt (!rollback still erases it), and the
     # model reads that it wasn't continued: a note, or the user's reason

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -13,6 +13,7 @@ require_relative "../analytics_file"
 require_relative "../client_id"
 require_relative "../delivery"
 require_relative "../answer_tail"
+require_relative "../answer_refs"
 require_relative "../bridge_client"
 require_relative "../bridge/bounded_queue"
 require_relative "../bridge/card_store"
@@ -1907,6 +1908,10 @@ module Samagotchi
             message[:display] = shown unless shown.strip.empty?
             rendered = message[:display] || stripped
             message[:html] = @markdown_renderer.render(rendered) if !rendered.empty? && @markdown_renderer.available?
+            # The refs after_turn hooks attached (AnswerRefs), checked again:
+            # a stored file is never trusted. Never raises.
+            refs = Samagotchi::AnswerRefs.for_display(m[:display_refs] || m["display_refs"])
+            message[:display_refs] = refs unless refs.empty?
           end
           message[:parts] = did if did
           filtered << message