samagotchi 0.59.0 → 0.60.0

data/lib/samagotchi/kernel_loop.rb

@@ -204,12 +204,18 @@ module Samagotchi
     #   steering mid-stream); drained lines merge into ONE user message appended
     #   at the conversation tail (prefix KV cache preserved) and a
     #   :pending_input_merged stream event is emitted.
+    # @param reasoning_since [Integer, nil] a step-limit Continue's: where the
+    #   run it resumes started in +messages+; that run's model messages keep
+    #   their thought blocks (#prepare_conversation), as within one run. nil:
+    #   every earlier thought is stripped.
     # @return [LLM::ModelResult] final visible response with continuation metadata
-    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil,
+            reasoning_since: nil)
       @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
       @last_slot = nil
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
-                                  pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))
+                                  pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars),
+                                  reasoning_since: reasoning_since)
 
       max_iterations.times do |iteration_index|
         turn.iteration = iteration_index + 1
@@ -284,8 +290,8 @@ module Samagotchi
                             :buffer_mark, keyword_init: true)
     private_constant :Turn, :Request, :Generation
 
-    def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:)
-      conversation = prepare_conversation(messages)
+    def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:, reasoning_since: nil)
+      conversation = prepare_conversation(messages, keep_thought_from: thought_floor(messages, reasoning_since))
       context = ContextStatus.new(conversation: conversation, llm_context: @turn_settings.llm_context)
       emit = ->(event) { emit_stream_event(on_stream_event, event) }
       @llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: context, emit: emit)
@@ -992,9 +998,13 @@ module Samagotchi
       @profile.uses_role_prefixes? ? @profile.user_prefix : "#{@profile.turn_start}user\n"
     end
 
-    def sanitize_history(messages)
-      messages.map do |m|
-        if m[:role] == "model"
+    # +keep_thought_from+: model messages from this index on keep their
+    # thought blocks (a resumed run's); nil strips every one.
+    def sanitize_history(messages, keep_thought_from: nil)
+      messages.each_with_index.map do |m, index|
+        if m[:role] == "model" && keep_thought_from && index >= keep_thought_from
+          { role: m[:role], content: m[:content].to_s, display: m[:display] }.compact
+        elsif m[:role] == "model"
           # `display` rides along so the stored conversation keeps it; the
           # prompt formatter never reads it (AnswerDisplay).
           { role: m[:role], content: strip_thought_blocks(m[:content].to_s), display: m[:display] }.compact
@@ -1004,8 +1014,24 @@ module Samagotchi
       end
     end
 
-    # Standard multi-turn compliance: never pass prior raw thought blocks.
-    def prepare_conversation(messages) = sanitize_history(messages)
+    # Standard multi-turn compliance: never pass prior raw thought blocks,
+    # but a resumed run's (+keep_thought_from+, #thought_floor): the same
+    # run going on after a step-limit Continue.
+    def prepare_conversation(messages, keep_thought_from: nil) = sanitize_history(messages, keep_thought_from: keep_thought_from)
+
+    # Where a resumed run's thought blocks start: its start (+since+). Inside
+    # one native run nothing re-sanitizes, so a user entry the run merged (a
+    # steer, a delegate report, the Qwen recovery prompt) left the thoughts
+    # before it in the prompt: they stay. Only a user or turn_start entry
+    # added after the run ended (after its last model message: a !cmd's
+    # output) starts them again past itself. nil without +since+.
+    def thought_floor(messages, since)
+      return nil if since.nil?
+
+      last_reply = messages.rindex { |m| m[:role].to_s == "model" } || -1
+      query = messages.rindex { |m| m[:role].to_s == "user" || m[:turn_start] == true }
+      query && query > last_reply ? [query + 1, since].max : since
+    end
 
     def duplicate_conversation(messages)
       messages.map(&:dup)

data/lib/samagotchi/llm/backend.rb

@@ -14,9 +14,14 @@ module Samagotchi
     # extra surface lives on backend-specific subclasses, never on this interface.
     #
     # The raw-prompt KernelLoop is NativeBackend; the chat loop is ChatLoop.
+    #
+    # +reasoning_since+: where the run a step-limit Continue resumes started
+    # in +messages+ (Engine#run_turn resume_from:); the replies from there on
+    # keep the model's reasoning (thought blocks), as within one run. nil:
+    # the run starts here, as every other turn's does.
     class ModelBackend
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
-                   model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+                   model_name: nil, max_tool_output_chars: nil, pending_input: nil, reasoning_since: nil)
         raise NotImplementedError, "#{self.class}#complete must be implemented"
       end
     end

data/lib/samagotchi/llm/chat_loop.rb

@@ -68,12 +68,14 @@ module Samagotchi
 
       def provider = :chat
 
+      # +reasoning_since+ (ModelBackend#complete): the resumed run's start,
+      # the Run's own start then (#reasoning_boundary).
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
-                   model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+                   model_name: nil, max_tool_output_chars: nil, pending_input: nil, reasoning_since: nil)
         raise ArgumentError, "ChatLoop has no adapter" unless @adapter
 
         conversation = Array(messages).map(&:dup)
-        Run.new(self, conversation, on_stream_event, cancel_controller, model_name, pending_input)
+        Run.new(self, conversation, on_stream_event, cancel_controller, model_name, pending_input, start: reasoning_since)
            .call(max_iterations: max_iterations || 1, cap: KernelLoop.resolve_output_char_cap(max_tool_output_chars))
       rescue StandardError => e
         FailedTurn.attach(e, conversation && plain(conversation))
@@ -195,7 +197,8 @@ module Samagotchi
       # user message: a prompt, a steer, merged input, the chat template's
       # last query; or an entry that starts a turn, turn_start) and +since+
       # (the Run's start, so a continue turn -- a reminder, a context wake,
-      # a continue after a stop -- sends none of the run before it).
+      # a delegate report's wake -- sends none of the run before it; a
+      # step-limit Continue's Run starts where the run it resumes did).
       # @return [Integer, nil]
       def reasoning_boundary(conversation, since: nil, level: reasoning_history)
         case level
@@ -402,7 +405,9 @@ module Samagotchi
       # One turn's state: the conversation, the stream sink and tool
       # activity.
       class Run
-        def initialize(loop, conversation, on_stream_event, cancel_controller, model_name, pending_input)
+        # +start+: where the run a step-limit Continue resumes started (nil:
+        # this run starts at the conversation's end).
+        def initialize(loop, conversation, on_stream_event, cancel_controller, model_name, pending_input, start: nil)
           @loop = loop
           @conversation = conversation
           @on_stream_event = on_stream_event
@@ -410,8 +415,8 @@ module Samagotchi
           @model_name = model_name
           @pending_input = pending_input
           # Where this run's entries start: the reasoning it sends back
-          # (ChatLoop#reasoning_boundary) is its own.
-          @start = conversation.length
+          # (ChatLoop#reasoning_boundary) is its own, a resumed run's too.
+          @start = start || conversation.length
           @tool_activity = []
           @empty_retry = EmptyAnswerRetry.new
           # The empty generations, never saved: the UIs draw the turn's

data/lib/samagotchi/llm/model_result.rb

@@ -14,9 +14,15 @@ module Samagotchi
     # generations as model messages, which the loops keep out of the
     # conversation) and .empty_retries (the retries spent): the Engine saves
     # them on the turn's note for the UIs (TurnNote.empty).
+    #
+    # .run_start is where the turn's run started in the conversation (the
+    # length of the messages the loop got), set by the Engine after the loop
+    # returns; nil from a loop called directly. A step-limit offer keeps it
+    # (TurnFlow), so a Continue resumes that run (Engine#run_turn resume_from:).
     class ModelResult
       attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
                   :tool_activity, :context_status, :pending_tool_calls, :empty_steps, :empty_retries
+      attr_accessor :run_start
 
       def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
                      tool_activity: [], context_status: nil, pending_tool_calls: false, empty_steps: [], empty_retries: 0)
@@ -57,8 +63,11 @@ module Samagotchi
         !!pending_tool_calls
       end
 
-      # KernelLoop only marks a run exhausted when it stopped on pending tool
-      # calls, so exhausted? alone already means "resumable".
+      # A run that ran out of iterations can be continued (the step-limit
+      # offer). KernelLoop marks one exhausted only when it stopped on pending
+      # tool calls; ChatLoop also leaves it exhausted when its last iteration
+      # ended in a retry (an empty answer's nudge, a cut) or merged input
+      # after an answer, which a Continue then picks up.
       def resumable?
         exhausted?
       end

data/lib/samagotchi/llm/native_backend.rb

@@ -17,7 +17,7 @@ module Samagotchi
       def provider = :native
 
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
-                   model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+                   model_name: nil, max_tool_output_chars: nil, pending_input: nil, reasoning_since: nil)
         @kernel.run(
           messages,
           max_iterations: max_iterations,
@@ -25,7 +25,8 @@ module Samagotchi
           cancel_controller: cancel_controller,
           model_name: model_name,
           max_tool_output_chars: max_tool_output_chars,
-          pending_input: pending_input
+          pending_input: pending_input,
+          reasoning_since: reasoning_since
         )
       end
     end

data/lib/samagotchi/log_subscriber.rb

@@ -63,7 +63,8 @@ module Samagotchi
       @generation_started_at.clear
       @tool_started_at.clear
       log(:info, :turn_started, session: event[:session_id], prompt_chars: event[:prompt].to_s.length,
-                                continue: event[:continue] || nil, **items(event), **origin(event))
+                                continue: event[:continue] || nil, resumed: event[:resumed] || nil, **items(event),
+                                **origin(event))
     end
 
     def on_turn_completed(event)

data/lib/samagotchi/plugin/context.rb

@@ -19,7 +19,9 @@ module Samagotchi
     # (chat messages, timeout:, max_tokens:, cancel_controller:) and returns
     # the answer text.
     # +messages_partial+ says whether +messages+ leaves out a running turn;
-    # +model_name+ (the session's resolved model ref, live after /model) and
+    # +prompt_files+ returns the files whose text the built system prompt
+    # holds (SystemPrompt#prompt_files, [] before a build); +model_name+
+    # (the session's resolved model ref, live after /model) and
     # +state_dir+ are what ctx.sessions forks with, and +setup+ (the
     # session's own SessionSetup), which a fork copies; +model_key+ is the
     # model's memory overlay key (ctx.model, ctx.model_key).
@@ -28,8 +30,8 @@ module Samagotchi
     # +frontend+ returns the Engine's interface (:repl, :worker,
     # :non_interactive), which ctx.frontend names for plugins.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
-                      :ask_model, :model_name, :model_key, :state_dir, :scratch, :setup, :steer, :stop_turn, :stop_generation,
-                      :frontend, keyword_init: true)
+                      :ask_model, :model_name, :model_key, :state_dir, :scratch, :setup, :prompt_files,
+                      :steer, :stop_turn, :stop_generation, :frontend, keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -159,6 +161,17 @@ module Samagotchi
       # a plugin can say what its answer is about.
       def messages_partial? = !!@host.messages_partial&.call
 
+      # The files whose text the session's system prompt holds now, as
+      # absolute paths in prompt order (SystemPrompt#prompt_files): the
+      # AGENTS.md chain (the work tree top down to the cwd), then the
+      # appended files (append_system_prompt:, --append-system-prompt).
+      # [] before the first build and after one that drops them (a model
+      # or tools change). A Host without the member (a spec's) reads [].
+      # @return [Array<String>] frozen
+      def prompt_files
+        Array(@host.prompt_files&.call || []).freeze
+      end
+
       # Run +block+ as this plugin's handler for +event+: until it returns,
       # the helpers called on this thread act as the event's own. Nests (a
       # fire inside a handler gets its own event; the outer one is back

data/lib/samagotchi/prompt_files.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "memory_paths"
+
+module Samagotchi
+  # The files whose text goes into the system prompt as they are
+  # (SystemPrompt): which AGENTS.md files a cwd loads, and how a file
+  # becomes a prompt section.
+  module PromptFiles
+    AGENTS_FILE = "AGENTS.md"
+
+    AGENTS_HEADER = "Project specific description:"
+
+    # A file's text as the prompt carries it: +path+ absolute, +text+ the
+    # section with its header.
+    Section = Data.define(:path, :text)
+
+    module_function
+
+    # The AGENTS.md files a session in +cwd+ loads, as absolute paths,
+    # outermost first: inside a git work tree every one from its top (a
+    # linked worktree's own checkout) down to the cwd; outside a repository
+    # only the cwd's ([] with none).
+    # @param cwd [String] where the prompt is built (Dir.pwd, not the
+    #   session's working directory: /tmp vs /private/tmp would change the
+    #   prompt bytes)
+    # @return [Array<String>]
+    def agents_paths(cwd)
+      chain_dirs(cwd).map { |dir| File.join(dir, AGENTS_FILE) }.select { |path| File.file?(path) }
+    end
+
+    # The sections of the AGENTS.md chain (#agents_paths) with text: the
+    # first keeps the plain header (a one-file session's prompt is as it
+    # always was), each further one names its directory relative to the
+    # work tree top ("Project specific description for pkg/:").
+    # @return [Array<Section>]
+    def agents_sections(cwd)
+      top = MemoryPaths.work_tree_root(cwd)
+      sections = []
+      agents_paths(cwd).each do |path|
+        dir = File.dirname(path)
+        header = sections.empty? ? AGENTS_HEADER : "Project specific description for #{relative_dir(dir, top) || dir}/:"
+        text = section(path, header)
+        sections << Section.new(path: path, text: text) if text
+      end
+      sections
+    end
+
+    # The directories whose AGENTS.md a session in +cwd+ reads, outermost first.
+    def chain_dirs(cwd)
+      cwd = File.expand_path(cwd)
+      top = MemoryPaths.work_tree_root(cwd)
+      return [cwd] unless top
+
+      rel = relative_dir(cwd, top)
+      return [top] if rel == "."
+      # A cwd the walk up didn't reach from (not expected): only its own and the top's.
+      return [top, cwd] if rel.nil?
+
+      parts = rel.split("/")
+      [top] + parts.each_index.map { |i| File.join(top, *parts[0..i]) }
+    end
+
+    # +dir+ relative to +top+ ("." for the top itself), nil when it isn't under it.
+    def relative_dir(dir, top)
+      return "." if dir == top
+
+      prefix = top.end_with?("/") ? top : "#{top}/"
+      dir.start_with?(prefix) ? dir.delete_prefix(prefix) : nil
+    end
+
+    # How a prompt file is named in the prompt and /stats: relative to the
+    # work tree +top+ when inside it, else with ~ for the home directory.
+    # @return [String]
+    def display_path(path, top:)
+      rel = top && relative_dir(path, top)
+      return rel if rel && rel != "."
+
+      home = Dir.home
+      path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
+    rescue ArgumentError
+      path
+    end
+
+    # A chi --append-system-prompt value: [absolute path, nil], or
+    # [absolute path, the reason it can't be used].
+    # @param cwd [String] the shell's cwd the value is relative to
+    # @return [Array(String, String)]
+    def check_cli_file(value, cwd: Dir.pwd)
+      begin
+        path = File.expand_path(value.to_s, cwd)
+      rescue ArgumentError
+        # A quoted "~nosuchuser/x" reaches chi unexpanded.
+        return [value.to_s, "no such user"]
+      end
+      reason = if !File.exist?(path) then "no such file"
+               elsif !File.file?(path) then "not a file"
+               elsif !File.readable?(path) then "can't be read"
+               end
+      [path, reason]
+    end
+
+    # Text this long goes into every request: chi warns once, at start.
+    LARGE_CHARS = 32_000
+
+    # The number of chars of +path+ when above LARGE_CHARS, else nil.
+    # @return [Integer, nil]
+    def large_size(path)
+      chars = File.read(path, encoding: "UTF-8").length
+      chars > LARGE_CHARS ? chars : nil
+    rescue StandardError
+      nil
+    end
+
+    # +path+'s text under +header+ ("<header>\n<text>", stripped); nil when
+    # the file is empty or can't be read.
+    # @return [String, nil]
+    def section(path, header)
+      content = File.read(path, encoding: "UTF-8").strip
+      return nil if content.empty?
+
+      "#{header}\n#{content}"
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/samagotchi/ref.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Samagotchi
+  # One thing a click on a ref can do besides the kind's own (the web keeps
+  # those per kind, refs.js REF_ACTIONS): open +url+ in a new tab, shown as
+  # +label+ in the ref's menu. A plugin names it ("PR diff", "Open in Jira").
+  # The URL is http(s) only, checked here and again in the page
+  # (refs.js httpUrl): the page opens it as is, so a javascript:, data: or
+  # editor URL never gets there.
+  RefAction = Data.define(:id, :label, :url) do
+    # @raise [ArgumentError] an empty id or label, or a URL that isn't an
+    #   http(s) one with a host, at most MAX_URL characters
+    def initialize(id:, label:, url:)
+      id = id.to_s.strip
+      label = label.to_s.strip
+      url = url.to_s.strip
+      raise ArgumentError, "a ref action needs an id" if id.empty?
+      raise ArgumentError, "a ref action needs a label" if label.empty?
+      raise ArgumentError, "a ref action's url must be http(s) with a host, at most #{RefAction::MAX_URL} characters" unless RefAction.http_url?(url)
+
+      super
+    end
+  end
+
+  class RefAction
+    MAX_URL = 2_000
+
+    # @return [Boolean] +url+ is an http or https URL with a host
+    def self.http_url?(url)
+      return false if url.length > MAX_URL
+
+      uri = URI.parse(url)
+      uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # @param value [RefAction, Hash] a plugin's {id:, label:, url:} (String
+    #   or Symbol keys)
+    # @raise [ArgumentError] anything else, or an invalid action
+    def self.from(value)
+      return value if value.is_a?(RefAction)
+      raise ArgumentError, "a ref action is a Hash {id:, label:, url:}" unless value.is_a?(Hash)
+
+      value = value.transform_keys(&:to_sym)
+      new(id: value[:id], label: value[:label], url: value[:url])
+    end
+  end
+
+  # A ref as data: a kind, a target, an optional label and the plugins'
+  # extra actions (RefAction), for a UI to trace it. The kind's own actions
+  # are the UI's (a file ref keeps the editor, show in turn and copy), so
+  # +actions+ only adds to them.
+  # - +kind+ "file": +target+ {path:, line:, end_line:}, the lines only when
+  #   positive, the end only past the start (FileRef's shape).
+  # - Any other kind ("issue", "commit", …): +target+ {id:}. The page shows
+  #   its +label+ (or the text it matched) and runs its first action.
+  # +to_h+ is the shape the page reads (refs.js bindRef). FileRef stays the
+  # rows' own ref; this is the one a plugin gives.
+  Ref = Data.define(:kind, :target, :label, :actions) do
+    # @raise [ArgumentError] a kind that isn't a short lowercase word, a
+    #   target without its kind's key, a non-list of actions or a bad action
+    def initialize(kind:, target:, label: nil, actions: [])
+      kind = kind.to_s
+      raise ArgumentError, "a ref's kind is a short lowercase word (#{kind.inspect})" unless Ref::KIND.match?(kind)
+      raise ArgumentError, "a ref's actions are a list" unless actions.nil? || actions.is_a?(Array)
+
+      label = label.to_s.strip
+      super(kind: kind, target: Ref.target_for(kind, target), label: label.empty? ? nil : label,
+            actions: Array(actions).map { |action| RefAction.from(action) }.freeze)
+    end
+
+    # @return [Hash] {kind:, target:, label:, actions: [{id:, label:, url:}]},
+    #   no label when there is none
+    def to_h = { kind: kind, target: target, label: label, actions: actions.map(&:to_h) }.compact
+  end
+
+  class Ref
+    KIND = /\A[a-z][a-z0-9_-]{0,31}\z/
+    # FileRef::KIND, not required here (it loads the file tools).
+    FILE = "file"
+
+    # A plugin's {kind:, target:, label:, actions:} (String or Symbol keys).
+    # @raise [ArgumentError] as +new+
+    def self.from(value)
+      raise ArgumentError, "a ref is a Hash {kind:, target:, label:, actions:}" unless value.is_a?(Hash)
+
+      value = value.transform_keys(&:to_sym)
+      new(kind: value[:kind], target: value[:target], label: value[:label], actions: value[:actions] || [])
+    end
+
+    # +kind+'s target from +raw+: a file's path and lines, any other kind's id.
+    # @raise [ArgumentError] not a Hash, or without the kind's key
+    def self.target_for(kind, raw)
+      raise ArgumentError, "a ref's target is a Hash" unless raw.is_a?(Hash)
+
+      raw = raw.transform_keys(&:to_sym)
+      kind == FILE ? file_target(raw) : { id: required(raw[:id], :id) }.freeze
+    end
+
+    def self.file_target(raw)
+      line = positive(raw[:line])
+      end_line = line && positive(raw[:end_line])
+      { path: required(raw[:path], :path), line: line, end_line: end_line && end_line > line ? end_line : nil }.compact.freeze
+    end
+    private_class_method :file_target
+
+    def self.required(value, key)
+      value = value.to_s.strip
+      raise ArgumentError, "a ref's target needs #{key}" if value.empty?
+
+      value
+    end
+    private_class_method :required
+
+    def self.positive(value)
+      number = Integer(value.to_s.strip, exception: false)
+      number&.positive? ? number : nil
+    end
+    private_class_method :positive
+  end
+end

data/lib/samagotchi/session.rb

@@ -53,6 +53,15 @@ module Samagotchi
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
     attr_accessor :preloaded_memory_names, :muted_memory_names
+    # The files chi --append-system-prompt put into the session's system
+    # prompt (absolute paths; config.yml's append_system_prompt: entries
+    # aren't stored): kept on respawns, copied by a fork and a continue
+    # (SessionSetup).
+    attr_reader :appended_prompt_files
+
+    def appended_prompt_files=(paths)
+      @appended_prompt_files = Array(paths).map(&:to_s).reject(&:empty?).uniq
+    end
     # The model notes the session's system prompt carried at its last build
     # (Array<PromptNote>: name, scope, chars, digest; ModelNotes), set by the
     # Engine at each build (a start, a resume's or a woken worker's first
@@ -182,7 +191,7 @@ module Samagotchi
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
-                   continues: nil, thinking: nil, reasoning_history: nil)
+                   continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [])
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -210,6 +219,7 @@ module Samagotchi
       self.llm_context = llm_context
       self.thinking = thinking
       self.reasoning_history = reasoning_history
+      self.appended_prompt_files = appended_prompt_files
       @archived = false
     end
 
@@ -289,6 +299,7 @@ module Samagotchi
         llm_context: setup.llm_context,
         thinking: setup.thinking,
         reasoning_history: setup.reasoning_history,
+        appended_prompt_files: setup.appended_prompt_files,
         continues: continues
       )
     end
@@ -351,7 +362,8 @@ module Samagotchi
       "llm_context" => nil,
       "continues" => nil,
       "thinking" => nil,
-      "reasoning_history" => nil
+      "reasoning_history" => nil,
+      "appended_prompt_files" => []
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -476,7 +488,7 @@ module Samagotchi
                 when "reasoning_history" then reasoning_history_file
                 when "prompt_notes" then @prompt_notes.map(&:to_file)
                 when "last_turn" then @last_turn&.to_file
-                when "used_memory_names", "preloaded_memory_names", "muted_memory_names"
+                when "used_memory_names", "preloaded_memory_names", "muted_memory_names", "appended_prompt_files"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")
                 end

data/lib/samagotchi/session_metrics.rb

@@ -142,9 +142,13 @@ module Samagotchi
       :cuts,
       :capped,
       :model,
-      # The turn the user started by answering the step-limit question with
-      # Continue (:turn_started's +continue+); its record carries it.
+      # A turn with no prompt of its own (:turn_started's +continue+): a
+      # step-limit Continue, a reminder's or a wake's turn; its record
+      # carries it.
       :continue,
+      # The turn the user started by answering the step-limit question with
+      # Continue (:turn_started's +resumed+): it resumed the run before it.
+      :resumed,
       :id,
       :started_at,
       :started_monotonic,
@@ -558,6 +562,7 @@ module Samagotchi
           capped: 0,
           model: nil,
           continue: event[:continue] ? true : false,
+          resumed: event[:resumed] ? true : false,
           id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
@@ -597,6 +602,7 @@ module Samagotchi
           # Every record says, so the report can tell a file with no Continue
           # from one written before the mark.
           record[:continue] = @turn.continue
+          record[:resumed] = @turn.resumed
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)

data/lib/samagotchi/session_setup.rb

@@ -10,15 +10,20 @@ module Samagotchi
   # (SessionManager.spawn_session, a continue, a plugin's fork, the web's
   # create, chi send --new): +llm_context+ is an LLMContextOverride or nil,
   # +thinking+ a level Symbol (Thinking.session_level) or nil,
-  # +reasoning_history+ a level Symbol (ReasoningHistory.session_level) or nil.
+  # +reasoning_history+ a level Symbol (ReasoningHistory.session_level) or nil,
+  # +appended_prompt_files+ the absolute paths chi --append-system-prompt
+  # named (their text goes into the system prompt; [] with none).
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
   # without one; a continue and a fork copy their session's (.of).
-  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history) do
-    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil) = super
+  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files) do
+    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [])
+      super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
+            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze)
+    end
 
-    def empty? = llm_context.nil? && thinking.nil? && reasoning_history.nil?
+    def empty? = llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty?
 
     # A session's own setup, for a session that starts from it.
     # @param session [Session, nil]
@@ -26,7 +31,8 @@ module Samagotchi
     def self.of(session)
       return new if session.nil?
 
-      new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history)
+      new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
+          appended_prompt_files: session.appended_prompt_files)
     end
   end
 end