samagotchi 0.13.0 → 0.15.0

data/lib/samagotchi/kernel_loop.rb

@@ -271,7 +271,7 @@ module Samagotchi
     def prepare_request(turn)
       prompt, images = format_prompt(turn)
       image_tokens = images.empty? ? 0 : ImagePlan.estimated_tokens(turn.conversation)
-      window = ContextWindow.resolve(client: @client, model: turn.model_name)
+      window = ContextWindow.resolve(client: @client, model: turn.model_name, setting: @turn_settings.window_setting)
       emit_context_status_event(turn.on_stream_event, turn.context, prompt, iteration_index: turn.iteration - 1,
                                                                              window: window, image_tokens: image_tokens)
       if (line = turn.context.take_guidance)

data/lib/samagotchi/llm/chat_loop.rb

@@ -172,11 +172,13 @@ module Samagotchi
 
       # The window for +model+: the kernel's client probes the server it
       # points at (Engine keeps it on the effective model's host; a local
-      # llama.cpp answers /props), then the host's model list, config, env
-      # and the default. A remote provider has no /props to probe.
+      # llama.cpp answers /props), then the host's model list, the model's
+      # or host's window_tokens, config, env and the default. A remote
+      # provider has no /props to probe.
       def context_window(model)
         client = @adapter.remote? ? nil : @kernel.client
-        ContextWindow.resolve(client: client, model: model, adapter: @adapter)
+        ContextWindow.resolve(client: client, model: model, adapter: @adapter,
+                              setting: (@kernel.turn_settings&.window_setting if @kernel.respond_to?(:turn_settings)))
       rescue StandardError
         nil
       end
@@ -191,9 +193,10 @@ module Samagotchi
       # The shape the engine persists: role and content (parts stay an
       # Array), plus a model turn's tool_calls and thinking (the host's
       # reasoning, never sent back), a result's tool_call_id, the image
-      # refs of a user message or a tool result, and a plugin tool result's
-      # tool_params and tool_labels (the live row's params line and label,
-      # never sent back), and an edit/write result's tool_diffs (never sent).
+      # refs of a user message or a tool result, a prompt's turn_id (Engine,
+      # never sent), and a plugin tool result's tool_params and tool_labels
+      # (the live row's params line and label, never sent back), and an
+      # edit/write result's tool_diffs (never sent).
       def plain(conversation)
         conversation.map do |entry|
           content = entry[:content].is_a?(Array) ? entry[:content] : entry[:content].to_s
@@ -201,6 +204,7 @@ module Samagotchi
           message[:tool_calls] = entry[:tool_calls] if entry[:tool_calls].is_a?(Array) && !entry[:tool_calls].empty?
           message[:tool_call_id] = entry[:tool_call_id] if entry[:tool_call_id]
           message[:images] = entry[:images] if entry[:images].is_a?(Array) && !entry[:images].empty?
+          message[:turn_id] = entry[:turn_id] if entry[:turn_id]
           message[:thinking] = entry[:thinking] if entry[:thinking].is_a?(String) && !entry[:thinking].empty?
           ToolResponse::SAVED_KEYS.each { |key| message[key] = entry[key] if entry[key] }
           message[TurnNote::RETRY_NUDGE] = true if TurnNote.retry_nudge?(entry)

data/lib/samagotchi/llm/turn_settings.rb

@@ -8,12 +8,14 @@ module Samagotchi
     # ChatLoop) and ToolRunner: the turn's VisionContext (nil sends no
     # images, placeholders instead), its request parameters
     # (SamplingSettings.for; empty sends none), its thinking level
-    # (Thinking.resolve) and the bare model id the turn runs on (every
-    # debug dump is tagged with it). The Engine sets them once per turn,
-    # in Engine#generate, after the model's host is synced.
-    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name) do
+    # (Thinking.resolve), the bare model id the turn runs on (every debug
+    # dump is tagged with it) and the model's or host's configured context
+    # window (ContextWindow.setting, nil for none). The Engine sets them
+    # once per turn, in Engine#generate, after the model's host is synced.
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name, :window_setting) do
       # No vision, no sampling, the default thinking, no model name.
-      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil)
+      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil,
+                          window_setting: nil)
     end
   end
 end

data/lib/samagotchi/plugin_session_state.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "paths"
+require_relative "session"
+
+module Samagotchi
+  # A plugin's state for one session, by convention under its data dir
+  # (ctx.data_dir): sessions/<id>.json or sessions/<id>/. It goes when the
+  # session does (SessionManager.delete_session: the CLI, the web, a
+  # discarded empty session; SessionRetention's prune), so no bundle keeps
+  # state for sessions that are gone (check-in's /checkin settings).
+  module PluginSessionState
+    module_function
+
+    # @return [Array<String>] the paths removed
+    def remove(session_id, env: ENV)
+      id = session_id.to_s
+      # Only a plain id: anything else could name a path outside the dir.
+      return [] unless Session.valid_id?(id)
+
+      Dir.glob(File.join(Paths.state_dir(env: env), "plugins", "*", "sessions")).flat_map do |dir|
+        [File.join(dir, "#{id}.json"), File.join(dir, id)].select { |path| File.exist?(path) }
+                                                         .each { |path| FileUtils.rm_rf(path) }
+      end
+    rescue SystemCallError
+      []
+    end
+  end
+end

data/lib/samagotchi/self_report.rb

@@ -56,7 +56,7 @@ module Samagotchi
         ["profile", model ? profile_for(model, env) : "-"],
         ["thinking", model ? thinking_for(model, env) : "-"],
         ["served model", model ? served_model_for(model, env) : "-"],
-        ["context window", context_window(env)],
+        ["context window", context_window(env, model)],
         ["bundles", bundles_summary],
         ["desktop", desktop_summary(env)],
         ["chi web", web_summary]
@@ -100,9 +100,29 @@ module Samagotchi
     def hooks_dir(env) = Hooks::Loader.hooks_dir(env)
 
     # Offline, so only the fallback: the running server's n_ctx wins at runtime.
-    def context_window(env)
-      window = ContextWindow.configured(env: env)
-      "#{window.tokens} (#{window.source}; the server's n_ctx wins at runtime)"
+    # The window config gives the current model (ContextWindow: its
+    # models.<key>.window_tokens, its host's, then context.window_tokens or
+    # the default) and which of them, as a turn resolves it offline.
+    def context_window(env, model = nil)
+      tokens, where = model_window(env, model) || ContextWindow.configured(env: env).to_h.values_at(:tokens, :source)
+      "#{tokens} (#{where}; the server's n_ctx wins at runtime)"
+    end
+
+    # [tokens, "models: KEY" | "hosts.NAME"], or nil when neither is set.
+    def model_window(env, model)
+      return nil unless model
+
+      registry = HostRegistry.new(env: env)
+      target = registry.resolve(model)
+      names = registry.lookup_names(model, target: target)
+      models = ConfigFile.model_settings(env: env)
+      window = ContextWindow.setting(target, names: names, models: models)
+      return nil unless window
+      return [window.tokens, "hosts.#{target.entry.name}"] if window.source == :host_setting
+
+      [window.tokens, "models: #{ConfigFile.model_setting(names, :window_tokens, models: models).first}"]
+    rescue StandardError
+      nil
     end
 
     def model_name

data/lib/samagotchi/session_manager.rb

@@ -12,6 +12,7 @@ require_relative "config"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_metrics"
+require_relative "utf8_default"
 require_relative "turn_note"
 require_relative "owner_lock"
 require_relative "bridge_client"
@@ -22,6 +23,7 @@ require_relative "installed_gem"
 require_relative "recap_store"
 require_relative "archive_store"
 require_relative "image_store"
+require_relative "plugin_session_state"
 require_relative "terminal_ui"
 
 module Samagotchi
@@ -552,6 +554,9 @@ module Samagotchi
           File.directory?(path) && (!EMPTY_DIRS.include?(name) || Dir.children(path).empty?)
         elsif name == "analytics.json"
           Array(JSON.parse(File.read(path))["turn_records"]).empty?
+        # Cards and notices from before any turn (Bridge::CardStore).
+        elsif name == "cards.json"
+          JSON.parse(File.read(path))["turns"].to_i.zero?
         else
           EMPTY_SKELETON_FILES.include?(name)
         end
@@ -594,6 +599,7 @@ module Samagotchi
         FileUtils.rm_rf(dir)
         removed << dir
       end
+      PluginSessionState.remove(id)
       { id: id, removed: removed, stopped: !owner.nil? }
     end
 
@@ -631,6 +637,8 @@ module Samagotchi
     # @return [Symbol] :idle_exit or :exit_requested
     def self.run_session_loop(session_id, state_dir: nil, owner_wait: OwnerLock::DEFAULT_WAIT,
                               idle_exit_minutes: nil, poll_interval: nil)
+      # A worker inherits chi's locale (LC_ALL=C too): read files as UTF-8.
+      Utf8Default.apply!
       sd = state_dir || Session.default_state_dir
       # The spawner passed the file and level through ENV; a worker's stderr
       # is /dev/null, so warnings only reach the file.

data/lib/samagotchi/session_metrics.rb

@@ -284,7 +284,7 @@ module Samagotchi
           token_sources: [],
           retries: 0,
           model: nil,
-          id: SecureRandom.uuid,
+          id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
           tool_calls_by_id: {}

data/lib/samagotchi/session_retention.rb

@@ -8,6 +8,7 @@ require_relative "config"
 require_relative "log"
 require_relative "model_profile"
 require_relative "session_manager"
+require_relative "plugin_session_state"
 
 module Samagotchi
   # Which sessions go: `chi sessions prune` / `clean` (.prune) and the lazy
@@ -79,7 +80,10 @@ module Samagotchi
         next unless Time.now - File.mtime(dir) > EMPTY_GRACE_SECONDS && SessionManager.empty_session_dir?(dir)
         next if SessionManager.session_owner(name, state_dir: state_dir)
 
-        FileUtils.rm_rf(dir) unless dry_run
+        unless dry_run
+          FileUtils.rm_rf(dir)
+          PluginSessionState.remove(name)
+        end
         name
       rescue SystemCallError
         nil
@@ -246,6 +250,7 @@ module Samagotchi
             FileUtils.rm_f(path)
             sidecar = File.join(state_dir, session.id)
             FileUtils.rm_rf(sidecar) if File.exist?(sidecar)
+            PluginSessionState.remove(session.id)
             deleted << session.id
           rescue StandardError
             skipped << session.id

data/lib/samagotchi/system_prompt.rb

@@ -335,7 +335,7 @@ module Samagotchi
       path = agent_description_path
       return nil unless path
 
-      content = File.read(path).strip
+      content = File.read(path, encoding: "UTF-8").strip
       return nil if content.empty?
 
       "Project specific description:\n#{content}"

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -21,6 +21,8 @@ require_relative "../output_formatter"
 require_relative "../session_commands"
 require_relative "../session_manager"
 require_relative "../guardrails/parent_approvals"
+require_relative "../tool_activity"
+require_relative "../web/message_parts"
 
 module Samagotchi
   class TerminalUI
@@ -105,6 +107,7 @@ module Samagotchi
         @running = false
         @joined_mid_turn = false
         @attached = false
+        @early_lines = []
         @question = nil
         @answered_ids = Set.new
         @reader = nil
@@ -162,16 +165,17 @@ module Samagotchi
           when :event
             ended = safely_handle(payload)
             return ended if %i[closed failed unanswered].include?(ended)
+
+            ended = take_early_lines
+            return ended if ended
             return end_of_input if @input_ended && !own_turns_pending?
           when :line
-            if payload.nil? && @wait_at_eof && own_turns_pending?
-              # The pipe's end: this run's turns first. An open question
-              # has nothing left to answer it.
-              return unanswered_question(@question_pending) if @question
-
-              next @input_ended = true
-            end
-            return end_of_input if submit(payload) == :detach
+            # A pipe is read at once: its lines wait for the joining
+            # snapshot, which may bring the question they answer.
+            next @early_lines << payload if @wait_at_eof && !@attached
+
+            ended = take_line(payload)
+            return ended if ended
           when :interrupt then return :detached if interrupt(payload) == :detach
           end
         end
@@ -187,6 +191,30 @@ module Samagotchi
         stream&.close
       end
 
+      # One input line (nil: the input ended).
+      # @return [Symbol, nil] how the run ends, or nil to go on
+      def take_line(line)
+        if line.nil? && @wait_at_eof && own_turns_pending?
+          # The pipe's end: this run's turns first. An open question
+          # has nothing left to answer it.
+          return unanswered_question(@question_pending) if @question
+
+          @input_ended = true
+          return nil
+        end
+        end_of_input if submit(line) == :detach
+      end
+
+      # The lines read before the snapshot came, once it has.
+      # @return [Symbol, nil] how the run ends, or nil to go on
+      def take_early_lines
+        until !@attached || @early_lines.empty?
+          ended = take_line(@early_lines.shift)
+          return ended if ended
+        end
+        nil
+      end
+
       # Render one Bridge event (string keys).
       # @return [Symbol, nil] :closed when the stream ended, :failed when the
       #   launch's first command didn't go through
@@ -911,9 +939,7 @@ module Samagotchi
 
         @screen.commit(prompt_line(nil, exchange[last_user][:content]))
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
-        exchange[(last_user + 1)..].select { |m| Steer.steer?(m) }.each do |m|
-          @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
-        end
+        render_join_steps(messages, messages.index { |m| m.equal?(exchange[last_user]) })
         # The saved answer is raw: the latest keeps its thinking, and one may
         # be only a tool call.
         answer = exchange[(last_user + 1)..].reverse_each
@@ -923,6 +949,31 @@ module Samagotchi
         render_join_notes(messages, after_exchange: true)
       end
 
+      # What the last exchange did, as the live turn drew it: each saved
+      # call's tool row (action, params, status from its result; no
+      # duration, which the session doesn't keep) and a plugin's steer
+      # where it came. The step texts stay out, as live (the ticker's).
+      def render_join_steps(messages, from)
+        messages.each_with_index.drop(from + 1).each do |m, i|
+          if Steer.steer?(m)
+            @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
+          elsif %w[model assistant].include?(m[:role].to_s)
+            responses = messages.drop(i + 1).take_while { |r| r[:role].to_s == "tool_response" }
+            Array(Web::MessageParts.for_message(m, responses)&.dig(:tools)).each { |part| @screen.commit(join_tool_line(part)) }
+          end
+        end
+      end
+
+      # A saved call's row; "no result" for a call the turn never answered
+      # (it ended first).
+      def join_tool_line(part)
+        output = part[:output]
+        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool])
+        activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
+                     params: part[:params], status: status }
+        "#{format_tool_activity_line(activity)}#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+      end
+
       # The context notes that came since the last prompt (all of them in a
       # session with none), after the exchange the header shows.
       def render_join_notes(messages, after_exchange: false)
@@ -948,7 +999,8 @@ module Samagotchi
       # The snapshot's cards and between-turns notices (Bridge CardStore):
       # on join the ones since the last turn (and the running turn's), as
       # the join header shows the last exchange; on a resync only cards not
-      # shown here yet. A turn's own rows (notices, retries) are left out:
+      # shown here yet, and not the ones an earlier worker saved (a resync
+      # onto a new worker: earlier turns, not news). A turn's own rows (notices, retries) are left out:
       # the running turn's come with its parts, and the join shows no older
       # turn's steps.
       def render_snapshot_cards(entries, joining:)
@@ -959,7 +1011,7 @@ module Samagotchi
 
             @screen.commit(EventRenderer.hook_notice_line(entry)) if joining && entry[:turns_since].to_i.zero?
           when "card"
-            next unless joining ? entry[:turns_since].to_i.zero? : !@renderer.card_shown?(entry[:id])
+            next unless joining ? entry[:turns_since].to_i.zero? : !entry[:earlier] && !@renderer.card_shown?(entry[:id])
 
             @renderer.render_card(entry, updated: entry[:updated] == true)
           end

data/lib/samagotchi/terminal_ui.rb

@@ -14,6 +14,7 @@ require_relative "llm/errors"
 require_relative "host_registry"
 require_relative "session"
 require_relative "owner_lock"
+require_relative "bridge/card_store"
 require_relative "engine"
 require_relative "guardrails/parent_approvals"
 require_relative "tools/memory"
@@ -223,6 +224,7 @@ module Samagotchi
         scratch: @scratch
       ))
       claim_session!(session.id) unless @owner_lock
+      keep_cards(session)
       # Saved at once, so a process killed before its first turn leaves a
       # file the sweep knows to delete.
       session.save if @scratch
@@ -345,6 +347,15 @@ module Samagotchi
       @surface.commit("Session #{session.id} was not archived (#{e.message}): chi sessions archive #{session.id}")
     end
 
+    # The session's cards.json, kept as a worker's Bridge keeps it (it owns
+    # the session as a worker would): this REPL's kept turns count on from
+    # the saved count, so a card an earlier worker showed stays that many
+    # turns back, and its own cards and notices are saved for the next.
+    def keep_cards(session)
+      path = File.join(Session.session_dir(session.id), Bridge::CardStore::FILE)
+      @cards_handle ||= @engine.subscribe(observer: Bridge::CardStore.new(path: path))
+    end
+
     # Take the session's OwnerLock for this process's lifetime: the TUI runs
     # its own Engine, so no worker may run the session meanwhile.
     # @raise [SessionBusy] when a worker or another TUI owns it
@@ -1112,6 +1123,7 @@ module Samagotchi
     # was cancelled).
     def answer_question_widget(prompt)
       loop do
+        @choice_echoed = false
         raw = begin
           yield
         rescue Interrupt
@@ -1133,7 +1145,7 @@ module Samagotchi
         @surface.commit(answer.note) if answer.note
         unless answer.ok?
           # The read left no echo: the line shows above its error.
-          @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{raw}")
+          echo_choice(raw)
           @surface.commit(answer.error)
           next
         end
@@ -1146,7 +1158,7 @@ module Samagotchi
         rescue QuestionDesk::Refused => e
           # A parent's allow guardrails.parent_approvals doesn't let through:
           # the question stays open for a deny (or the end of the input).
-          @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{raw}")
+          echo_choice(raw)
           @surface.commit(Guardrails::ParentApprovals.message(e.reason, typed: true))
           next
         rescue ArgumentError => e
@@ -1173,7 +1185,19 @@ module Samagotchi
     # A ? read of its own, off a terminal (specs, pipes): $stdin.gets.
     def read_choice_line(question_prompt)
       @surface.set_slot(:editor, [question_prompt])
-      $stdin.gets
+      line = $stdin.gets
+      # A pipe doesn't echo: the line completes the ? prompt here, once,
+      # and the widget doesn't echo it again (#echo_choice).
+      unless $stdin.tty?
+        @surface.commit(line.to_s.chomp)
+        @choice_echoed = true
+      end
+      line
+    end
+
+    # The answer line above its error, unless its read echoed it already.
+    def echo_choice(raw)
+      @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{raw}") unless @choice_echoed
     end
 
     # The next line submitted at the open prompt (?), nil for Ctrl-D

data/lib/samagotchi/tools/delegate_wait.rb

@@ -9,7 +9,8 @@ require_relative "peers"
 module Samagotchi
   module Tools
     # Waiting for a delegated session's next reply, shared by delegate and
-    # delegate_result: ReplyWait in the tools' words, with a cursor per
+    # delegate_result: ReplyWait in the tools' words, with the status words
+    # `chi send --wait` and `chi answer` use (ParentReport.status), with a cursor per
     # child (the newest reply this parent was already given) and the child
     # as it was before the message went in (ReplyWait's baseline), so a turn
     # that ends before the wait's first look (a fast failure) still ends it.
@@ -56,22 +57,23 @@ module Samagotchi
                                         owner_grace: owner_grace)
         # The turn sent to is handed over: a later wait looks for a later one.
         baselines.delete(key) if %i[done no_reply].include?(wait.status)
+        status = ParentReport.status(wait)
         case wait.status
         when :done
           seen[key] = wait.file
-          reply_result(child_id, wait.text)
+          reply_result(child_id, status, wait.text)
         when :error
-          result(child_id, "error", "the child's worker failed: #{wait.text}; its session shows what happened")
+          result(child_id, status, "the child's worker failed: #{wait.text}; its session shows what happened")
         when :stopped
-          result(child_id, "stopped", "the child was stopped (chi sessions stop); delegate with session: #{child_id} starts it again with a message")
+          result(child_id, status, "the child was stopped (chi sessions stop); delegate with session: #{child_id} starts it again with a message")
         when :waiting_for_answer
-          result(child_id, "waiting_for_answer", waiting_text(child_id, wait.question))
+          result(child_id, status, waiting_text(child_id, wait.question))
         when :canceled
-          result(child_id, "canceled", "wait canceled; the child keeps running; delegate_result #{child_id} waits again")
+          result(child_id, status, "wait canceled; the child keeps running; delegate_result #{child_id} waits again")
         when :no_reply
-          result(child_id, "no_reply", "the child's turn ended without a reply (canceled, failed or empty); its session shows what happened")
+          result(child_id, status, "#{no_reply_text(wait)}; its session shows what happened")
         when :worker_gone
-          result(child_id, "worker_gone",
+          result(child_id, status,
                  "the child's worker is gone (it stopped or crashed); delegate with session: #{child_id} starts it again with a message")
         else
           timeout_result(child_id, timeout)
@@ -95,8 +97,13 @@ module Samagotchi
         baselines[[parent_id, child.id]] = ReplyWait.baseline_of(child, question_id: nil)
       end
 
-      def reply_result(child_id, text)
-        "session: #{child_id}\nstatus: done\n---\n#{cut(text)}"
+      def reply_result(child_id, status, text)
+        "session: #{child_id}\nstatus: #{status}\n---\n#{cut(text)}"
+      end
+
+      # ParentReport's line for a turn that left no reply, about the child.
+      def no_reply_text(wait)
+        ParentReport.no_reply_line(wait).sub(/\Athe turn/, "the child's turn")
       end
 
       def result(child_id, status, text)

data/lib/samagotchi/tools/memory.rb

@@ -59,13 +59,13 @@ module Samagotchi
           resolved_scopes.each do |resolved_scope|
             path = memory_path(name, resolved_scope)
             if File.exist?(path)
-              body = File.read(path)
+              body = File.read(path, encoding: "UTF-8")
               # Append model-specific overlay if key is provided and overlay exists.
               [model_key, fallback_model_key].compact.each do |key|
                 overlay_path = ModelOverlay.overlay_path_for(name, key, resolved_scope)
                 next unless overlay_path && File.exist?(overlay_path)
 
-                body += SEPARATOR + "Model-specific guidance (#{key}):\n" + File.read(overlay_path)
+                body += SEPARATOR + "Model-specific guidance (#{key}):\n" + File.read(overlay_path, encoding: "UTF-8")
                 break
               end
               results << body
@@ -114,7 +114,7 @@ module Samagotchi
       def self.scoped_index(scope)
         dir = memories_dir(scope)
         index_path = File.join(dir, "#{MEMORY_INDEX}.md")
-        return File.read(index_path) if File.exist?(index_path)
+        return File.read(index_path, encoding: "UTF-8") if File.exist?(index_path)
 
         files = Dir.glob(File.join(dir, "*.md")).sort
         return "No memories stored yet." if files.empty?

data/lib/samagotchi/utf8_default.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # chi's files (memories, AGENT.md, sessions, config.yml) are UTF-8,
+  # whatever the locale. Under LC_ALL=C (or with no locale at all: an app
+  # started from Finder or launchd, `env -i`) Ruby reads files as US-ASCII,
+  # and a UTF-8 memory index then breaks the system prompt
+  # (Encoding::CompatibilityError). bin/chi and every worker call #apply!
+  # first.
+  module Utf8Default
+    LOCALE_KEYS = %w[LC_ALL LC_CTYPE LANG].freeze
+
+    # Files read as UTF-8 when the locale says US-ASCII. With no locale set
+    # at all, LANG too, so the workers and tools chi spawns get one; a
+    # locale the user set (LC_ALL=C) is left to them.
+    def self.apply!(env = ENV)
+      return unless Encoding.default_external == Encoding::US_ASCII
+
+      env["LANG"] = "en_US.UTF-8" if LOCALE_KEYS.none? { |key| env[key] }
+      verbose = $VERBOSE
+      begin
+        $VERBOSE = nil # Encoding.default_external= warns
+        Encoding.default_external = Encoding::UTF_8
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+  end
+end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -11,6 +11,7 @@ require "rack/request"
 
 require_relative "../bridge_client"
 require_relative "../bridge/bounded_queue"
+require_relative "../bridge/card_store"
 require_relative "../session"
 require_relative "../session_manager"
 require_relative "../session_commands"
@@ -533,7 +534,7 @@ module Samagotchi
         # ?cards=1: the page's re-read when a card arrives, for its rendered
         # body (the stream carries the card's plain text only).
         if req.params["cards"] == "1"
-          return json_response(200, { cards: cards_for_display(turn_snapshot) })
+          return json_response(200, { cards: cards_for_display(turn_snapshot, id) })
         end
         snapshot = live && live["session_state_snapshot"]
         last_event_seq = snapshot ? snapshot["event_seq"] : bridge_event_seq(id)
@@ -584,7 +585,7 @@ module Samagotchi
           plugin_warning: turn_snapshot && turn_snapshot["plugin_warning"],
           # Plugins' slow setup still running (chi.init): the page's init row.
           init_tasks: turn_snapshot ? Array(turn_snapshot["init_tasks"]) : [],
-          cards: cards_for_display(turn_snapshot),
+          cards: cards_for_display(turn_snapshot, id),
           # The composer's / autocomplete; the built-ins until a worker
           # names its plugins' too.
           commands: turn_snapshot&.fetch("commands", nil) || SessionCommands.builtin_registry.listing,
@@ -601,11 +602,14 @@ module Samagotchi
       end
 
       # The worker's last cards and between-turns notices (Bridge
-      # snapshot[:cards]), a card's body as body_html: rendered markdown
-      # when the renderer is on, else the escaped text in a <pre>.
-      # @return [Array<Hash>] [] without a live worker
-      def cards_for_display(turn_snapshot)
-        Array(turn_snapshot && turn_snapshot["cards"]).filter_map do |card|
+      # snapshot[:cards]), else (no live worker) the ones the last worker
+      # saved in the session's folder (CardStore.saved), a card's body as
+      # body_html: rendered markdown when the renderer is on, else the
+      # escaped text in a <pre>.
+      # @return [Array<Hash>]
+      def cards_for_display(turn_snapshot, id)
+        cards = turn_snapshot ? turn_snapshot["cards"] : saved_cards(id)
+        Array(cards).filter_map do |card|
           next unless card.is_a?(Hash)
           next card unless card["type"].to_s == "card"
 
@@ -613,6 +617,13 @@ module Samagotchi
         end
       end
 
+      # As JSON has them (string keys and values), like a snapshot's.
+      def saved_cards(id)
+        JSON.parse(JSON.generate(Samagotchi::Bridge::CardStore.saved(Session.session_dir(id, state_dir: default_state_dir))))
+      rescue StandardError
+        []
+      end
+
       def card_body_html(body)
         return "" if body.strip.empty?
 
@@ -1258,6 +1269,10 @@ module Samagotchi
           # Merged into the running turn (Steer::INPUT_KIND): part of it,
           # read by step +step+.
           message.merge!(merged: true, step: steer_step(list, index)) if norm_role == "user" && Samagotchi::Steer.input?(m)
+          # The turn it started (Engine): the page pairs it with that turn's
+          # record by this, not by its place.
+          turn_id = m[:turn_id] || m["turn_id"]
+          message[:turn_id] = turn_id.to_s if norm_role == "user" && turn_id
           images = m[:images] || m["images"]
           message[:images] = Array(images).map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } if norm_role == "user" && images.is_a?(Array) && !images.empty?
           if norm_role == "assistant"