samagotchi 0.62.0 → 0.63.0

data/lib/samagotchi/bundles/loop-guard/plugin.rb

@@ -297,7 +297,7 @@ class Plugin
   def register(chi)
     chi.on(:before_turn) { |_event| reset }
     chi.on(:before_tool_call) { |event, ctx| before(event, ctx) }
-    chi.on(:after_tool_call) { |event| after(event) }
+    chi.on(:after_tool_call) { |event, ctx| after(event, ctx) }
     return unless @thinking["watch"]
 
     chi.on(:before_generation) do |_event|
@@ -377,6 +377,7 @@ class Plugin
     @warned = {}       # key => true once notified this turn
     @denials = 0
     @pending = nil
+    @stop_card = nil   # the stop's card, posted after the denied call
     @thinking_loops = 0
     @good_steps = 0
     @watch = nil
@@ -412,7 +413,8 @@ class Plugin
   # A call's result, paired with the before_tool_call that keyed it. A call
   # that was denied (by us or another voter) ran nothing: no result, or the
   # deny text would become the key's result and the next call would pass.
-  def after(event)
+  def after(event, ctx)
+    post_stop_card(ctx)
     pending = @pending
     @pending = nil
     return unless pending && event[:tool].to_s == pending[:key].first
@@ -426,16 +428,25 @@ class Plugin
     @previews[key] = preview(output)
   end
 
+  # The turn stops now; its card waits for the denied call's
+  # after_tool_call (#post_stop_card), so a UI that prints events in order
+  # shows it under that call's row, not before it.
   def stop(ctx)
     ctx.stop_turn("the model kept repeating the same calls")
     repeated = @attempts.select { |key, n| n > 1 && @last_result[key] && @results[[key, @last_result[key]]] >= @deny_after }
     lines = repeated.map do |key, n|
       "- `#{short_key(key)}`: #{n} times, the same result each time (#{@previews[key]})"
     end
-    ctx.card(title: "loop-guard stopped the turn",
-             body: "The model kept repeating these calls:\n\n#{lines.join("\n")}\n\n" \
-                   "Tell it what to try instead, or where to look.",
-             level: :warn)
+    @stop_card = { title: "loop-guard stopped the turn",
+                   body: "The model kept repeating these calls:\n\n#{lines.join("\n")}\n\n" \
+                         "Tell it what to try instead, or where to look.",
+                   level: :warn }
+  end
+
+  def post_stop_card(ctx)
+    card = @stop_card
+    @stop_card = nil
+    ctx.card(**card) if card
   end
 
   def warn(ctx, key, what)

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.62.0
+version: 0.63.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
   config_modification_protocol.md: sha256:16403da5dd97a335e19d9d15bb1ba4390237bf9f4869e35d63c172a8828b5ae0
-  memory_guide.md: sha256:d16919387c42d229498f470fc4078245a15faee872480ffbeffe2e27897624e4
+  memory_guide.md: sha256:b0a1ba42c5334d4117b5733c8c26d7477364baca9169b0c0a711de6ac7fc7f3c
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

data/lib/samagotchi/bundles/system/memory_guide.md

@@ -94,7 +94,7 @@ Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and
 - Integrity: each file's sha256 is recorded at install; a hook/plugin/rule file changed afterwards is not loaded (rules: every call denied) until reinstalled. It is an integrity check, not proof of authorship.
 - Installing = trusting its Ruby code (hooks, plugin), like a gem. Install only copies; the code runs at the next session start (`Engine.new`), so a running worker needs a restart to pick it up.
 - A bundle without `*.md` (btw, mcp, loop-guard) adds no line to the prompt's memory index.
-- Profiles are shipped bundles with only `includes:` (bundle names): `core` (loop-guard, check-in, guardrails, slow-commands; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links, github-pr, coordinator). `chi bundle install core` installs the ones not installed and records them; a bundle the user uninstalled stays out on a later install, upgrade or `chi update`, which install only bundles new to the profile. `chi bundle uninstall core` removes its recorded bundles, then core (`docs/memory.md` "Bundle profiles").
+- Profiles are shipped bundles with only `includes:` (bundle names): `core` (loop-guard, check-in, guardrails, slow-commands; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links, github-pr, coordinator, claude-peer). `chi bundle install core` installs the ones not installed and records them; a bundle the user uninstalled stays out on a later install, upgrade or `chi update`, which install only bundles new to the profile. `chi bundle uninstall core` removes its recorded bundles, then core (`docs/memory.md` "Bundle profiles").
 
 ### CLI — `chi bundle`
 

data/lib/samagotchi/context_absorber.rb

@@ -16,8 +16,9 @@ module Samagotchi
   class ContextAbsorber
     # +note+: Engine#add_context_note's hash; +subscription+: the session's
     # Subscription after it (nil: dropped); +wake_note+: the same note with
-    # the wake line, for an update whose source asked to wake (the worker
-    # may start a turn with it), else nil.
+    # the wake line, for an update whose source asked to wake or a session
+    # push source's first text that asked (the worker may start a turn with
+    # it), else nil.
     Delivery = Data.define(:name, :note, :subscription, :wake_note) do
       def initialize(name:, note:, subscription:, wake_note: nil) = super
     end
@@ -93,9 +94,12 @@ module Samagotchi
         "(third-party text, not your user's words):\n> #{quoted}\n#{last_line}"
     end
 
-    def self.attached_text(name:, hint:, why:, summary:)
+    # The attached note's text; a wake turn's (+wake+) ends with the wake
+    # line in place of the background line.
+    def self.attached_text(name:, hint:, why:, summary:, wake: false)
       why_part = why ? " Why: #{why}#{"." unless why.match?(/[.!?]\z/)}" : ""
-      "Attached: #{name}#{" (#{hint})" if hint}.#{why_part}\nSummary: #{summary}\n#{BACKGROUND_LINE} #{read_line(name)}"
+      last_line = wake ? WAKE_LAST_LINE : "#{BACKGROUND_LINE} #{read_line(name)}"
+      "Attached: #{name}#{" (#{hint})" if hint}.#{why_part}\nSummary: #{summary}\n#{last_line}"
     end
 
     def self.read_line(name) = "Read it with context_read(name: \"#{name}\") when your user's request is about it."
@@ -105,6 +109,8 @@ module Samagotchi
     # A source the session sees: attached when it has text and was never
     # noted; updated for a new revision; an error once per run of failures
     # after a success. A source with no text yet waits (nothing to read).
+    # An update that asked to wake carries a wake note, and so does a first
+    # text that asked when #first_text_wakes?.
     def delivery_for(attached, sub, now)
       snapshot = attached.snapshot
       return nil unless snapshot.text?
@@ -112,8 +118,11 @@ module Samagotchi
       name = attached.name
       hint = snapshot.hint || attached.source.hint
       if sub.seen.nil?
-        text = self.class.attached_text(name: name, hint: hint, why: attached.source.why, summary: snapshot.summary)
-        return delivery(name, text_note_id(name, snapshot), text, now, seen(sub, snapshot))
+        args = { name: name, hint: hint, why: attached.source.why, summary: snapshot.summary }
+        found = delivery(name, text_note_id(name, snapshot), self.class.attached_text(**args), now, seen(sub, snapshot))
+        return found unless first_text_wakes?(attached, sub)
+
+        return found.with(wake_note: found.note.merge(text: self.class.attached_text(**args, wake: true)))
       end
       if sub.seen != snapshot.revision
         args = { name: name, hint: hint, summary: snapshot.summary, changes: snapshot.serial - sub.seen_serial }
@@ -131,6 +140,16 @@ module Samagotchi
                sub.with(error_seen: snapshot.error_since))
     end
 
+    # A first text may wake only for a session's pushed source (`chi context
+    # add NAME --push`, attached empty) that asked. Not for a command source
+    # (a URL/provider source has a cmd too): its first fetch runs as it is
+    # attached, while the user is likely looking at the session. Not for a
+    # project source: its first text may predate this session. A blank
+    # Subscription has seen_serial 0, so any revision that asked counts.
+    def first_text_wakes?(attached, sub)
+      attached.source.push? && attached.location.session? && attached.snapshot.wake_serial.to_i > sub.seen_serial
+    end
+
     # A subscription whose source is gone: detached when the session was
     # told of it, dropped quietly otherwise.
     def detached(sub, now)

data/lib/samagotchi/idle_recap.rb

@@ -7,6 +7,7 @@ require "time"
 
 require_relative "idle_client"
 require_relative "idle_target"
+require_relative "image_store"
 require_relative "output_formatter"
 require_relative "steer"
 require_relative "recap_store"
@@ -53,8 +54,6 @@ module Samagotchi
       # separator, while the chat loop writes one message per call.
       TOOL_OUTPUT_SEPARATOR = "\n\n---\n\n"
       TOOL_OUTPUT_HEADER_RE = /\A\[([\w.:-]+)\]/
-      # The text the web sends for a turn of images alone (images.js turnText).
-      IMAGE_ONLY_RE = /\A\s*(?:\[image: [^\]\n]*\]\s*)+\z/
       DELEGATE_REPORT_LINE = "(a delegate session's report, delivered by chi; not the user's words)"
 
       module_function
@@ -76,7 +75,7 @@ module Samagotchi
             # A delegate child's report (ChildReports) is chi's news, not
             # what the user said.
             content = "#{DELEGATE_REPORT_LINE}\n#{content}" if message["source"].to_s == Steer::DELEGATE_REPORT
-            images = IMAGE_ONLY_RE.match?(content) ? [] : image_lines(message["images"])
+            images = ImageRef.placeholder_only?(content) ? [] : image_lines(message["images"])
             [content, *images].reject(&:empty?).join("\n")
           when "model", "assistant"
             strip_thought(message["content"].to_s.gsub(TOOL_CALL_RE, ""))

data/lib/samagotchi/image_store.rb

@@ -159,6 +159,14 @@ module Samagotchi
   # One-line texts about an image ref ({file:, mime:, width:, height:,
   # bytes:, name:, source:}).
   module ImageRef
+    # The text the web sends for a turn of images alone (images.js
+    # turnText): "[image: name]" per image, nothing else.
+    PLACEHOLDER_ONLY_RE = /\A\s*(?:\[image: [^\]\n]*\]\s*)+\z/
+
+    # Whether +text+ is only that placeholder: the images' own lines would
+    # name them a second time.
+    def self.placeholder_only?(text) = PLACEHOLDER_ONLY_RE.match?(text.to_s)
+
     # Claude's rule of thumb (28×28 px per token). About 30% over on the
     # local Qwen, close enough for a label and the context estimate.
     def self.estimated_tokens(ref)

data/lib/samagotchi/plugin/attached_context.rb

@@ -94,18 +94,21 @@ module Samagotchi
         nil
       end
 
-      # This session's sources (its own, then its project's).
-      # @return [Array<Hash>] {name:, scope:, why:, hint:, fetched_at:, error:, provider:}
+      # This session's sources (its own, then its project's); none before
+      # the session has an id or a saved file.
+      # +summary+ is the last text's summary (nil before any text).
+      # @return [Array<Hash>] {name:, scope:, why:, hint:, fetched_at:, error:, provider:, summary:}
       def list
         id = @host.session_id.call
-        return [] unless id
+        # No id, or no saved file yet (a command before the first turn).
+        return [] unless id && Session.exist?(id, state_dir: state_dir)
 
         session = Session.load(id, state_dir: state_dir)
         ContextSources.attached(id, project_root: session.project_root, state_dir: state_dir).map do |attached|
           snapshot = attached.snapshot
           { name: attached.name, scope: attached.location.scope, why: attached.source.why,
             hint: snapshot.hint || attached.source.hint, fetched_at: snapshot.fetched_at, error: snapshot.error,
-            provider: attached.source.provider }
+            provider: attached.source.provider, summary: snapshot.summary }
         end
       end
 

data/lib/samagotchi/recap_setup.rb

@@ -31,12 +31,12 @@ module Samagotchi
     # @return [IdleRecap, nil]
     def self.build(recap, engine:, host_registry:, session_target:, session_id:, state_dir:)
       return nil if recap == false
-      # The TUI passes the config file's section; a worker passes nothing, so
-      # read it here too (a scalar `recap: false` is only seen this way).
+      # The REPL and a worker pass nothing: the config is read here alone
+      # (a scalar `recap: false` is only seen this way).
       return nil if recap.nil? && ConfigFile.recap_config == false
       return nil if Samagotchi::Config.get("recap.enabled") == false
 
-      # Normalize kwarg (TerminalUI passes recap: recap_config hash or nil)
+      # An explicit kwarg (a spec, an embedder) over the registry.
       kwarg_config = recap.is_a?(Hash) ? recap : {}
 
       base_url = string_config(kwarg_config, :base_url) || registry_string("recap.base_url")

data/lib/samagotchi/row_refs.rb

@@ -88,7 +88,7 @@ module Samagotchi
     # +cwd+ as [its spelling, its real path] (one when they are the same,
     # none without a +cwd+). absolute_path, not expand_path: a leading ~ is
     # a name, never a home. One realpath per row: the lambda's refs are
-    # checked together.
+    # checked together. The answer's refs (AnswerRef) check against it too.
     def roots(cwd)
       return [] if cwd.to_s.empty?
 
@@ -100,10 +100,10 @@ module Samagotchi
       end
       [given, real].uniq
     end
-    private_class_method :roots
 
     # +ref+ with a file's path absolute, resolved against the folder
-    # (+roots+, #roots), under its real spelling.
+    # (+roots+, #roots), under its real spelling: plan D7, for a plugin
+    # row's refs and an answer's (AnswerRef) alike.
     # @raise [ArgumentError] a relative path with no folder (or not
     #   +relative+), or a path outside the folder
     def inside(ref, roots, relative)
@@ -121,6 +121,5 @@ module Samagotchi
 
       ref.with(target: ref.target.merge(path: "#{roots.last}#{path.delete_prefix(root)}").freeze)
     end
-    private_class_method :inside
   end
 end

data/lib/samagotchi/session.rb

@@ -275,6 +275,18 @@ module Samagotchi
       { id: pending[:id], kind: %w[approval hook continue].include?(kind) ? kind : "question", relayed_to: relayed_to }.compact
     end
 
+    # A question saved by a process that no longer runs this session (the
+    # one that loads it now owns it): nobody waits on its answer, so it is
+    # dropped. Unsaved; the caller saves.
+    # @return [String, nil] the dropped question's id, nil with none
+    def drop_dead_question
+      pending = pending_question
+      return nil unless pending
+
+      @pending_question = nil
+      pending[:id].to_s
+    end
+
     # The stored project root, else (a file from before the field) the
     # project of the working directory now: nil when that is in no repo or
     # gone. +cache+ is ProjectScope.root_for's, shared across one listing.

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -46,12 +46,15 @@ module Samagotchi
       # @param thinking [String, nil] --thinking as typed: a new session
       #   starts with it as its own level; a resumed or attached one's
       #   worker gets a /thinking, after those
+      # @param state_dir [String, nil] where the sessions are (the default
+      #   state dir by default): the worker's, for the attached loop too
       # @return [Symbol] :detached, :closed when the worker went away,
       #   :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, appended_prompt_files: [])
-        client = connect(attach: attach, shared: shared, resume: resume, model: model,
+              memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], state_dir: nil)
+        state_dir ||= Session.default_state_dir
+        client = connect(attach: attach, shared: shared, resume: resume, model: model, state_dir: state_dir,
                          memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
                          appended_prompt_files: appended_prompt_files)
         commands = []
@@ -65,7 +68,7 @@ module Samagotchi
                                     first_command: first_command, no_interrupt: no_interrupt,
                                     default_input: default_input && !prompt && !attach && !resume,
                                     wait_at_eof: !$stdin.tty?,
-                                    parent_answers: Guardrails::ParentApprovals.parent_process?)
+                                    parent_answers: Guardrails::ParentApprovals.parent_process?, state_dir: state_dir)
         ended = begin
           attached.run
         ensure

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -100,14 +100,18 @@ module Samagotchi
       #   (the -p one too) have had their turns; if one failed, #run says so
       # @param children_counts [#call] session id -> its delegates'
       #   ChildrenStatus::Counts, the status row's children segment
+      # @param state_dir [String] the state dir the worker was found in: its
+      #   session folder (@path images, saved records) is under it
       def initialize(client:, screen:, client_id:, first_prompt: nil, first_command: nil, no_interrupt: false,
                      default_input: false, wait_at_eof: false, parent_answers: false,
                      clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                      delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) },
                      archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) },
                      installed_version: -> { InstalledVersions.new.newest },
-                     children_counts: ->(id) { ChildrenStatus.counts(id, state_dir: Session.default_state_dir) })
+                     state_dir: Session.default_state_dir,
+                     children_counts: ->(id) { ChildrenStatus.counts(id, state_dir: state_dir) })
         @client = client
+        @state_dir = state_dir
         @installed_version = installed_version
         @delete_session = delete_session
         @archive_session = archive_session
@@ -342,7 +346,7 @@ module Samagotchi
         id = @client.session_id
         return :gone if Session.stopped_marker?(id)
 
-        BridgeClient.discover(id, session_dir: Session.session_dir(id), host: @client.host)
+        BridgeClient.discover(id, session_dir: Session.session_dir(id, state_dir: @state_dir), host: @client.host)
       end
 
       # The stream moved to a new worker (a restart): requests go there too.
@@ -683,7 +687,11 @@ module Samagotchi
                   end
         @continue_answer = nil
         @screen.commit(QuestionSlot.continue_summary(outcome, paint: method(:paint))) if outcome && !asked
-        sync_prompt
+        # Back to the > prompt: with the text a question set aside meanwhile
+        # (#close_question), else what the ? read holds.
+        set_aside = @set_aside
+        @set_aside = nil
+        set_aside ? sync_prompt(keep_text: false, prefill: set_aside) : sync_prompt
       end
 
       # The notes slot shows the offer's choices while it waits (a question
@@ -802,7 +810,7 @@ module Samagotchi
         paths = ImageInput.extract(text)
         return [] if paths.empty?
 
-        session_dir = Session.session_dir(@client.session_id)
+        session_dir = Session.session_dir(@client.session_id, state_dir: @state_dir)
         paths.map do |image|
           ref = ImageStore.ingest(session_dir, path: image[:path])
           { file: ref[:file], name: ref[:name] }
@@ -865,7 +873,9 @@ module Samagotchi
 
         @view.finish_thinking_spinner
         # What was typed at the prompt waits for the question to close.
-        @set_aside = @reader&.typed_text unless @question
+        # Not over text already set aside (a question that closed while a
+        # continue offer waits): the ? read holds an answer then, if anything.
+        @set_aside = @reader&.typed_text.to_s.then { |typed| typed.empty? ? nil : typed } unless @question || @set_aside
         @question = QuestionPrompt.new(pending)
         @question_pending = pending
         # The step-limit question stands for the continue offer's own slot
@@ -987,10 +997,14 @@ module Samagotchi
         @screen.clear_slot(:notes)
         @screen.commit(@question.summary(outcome, paint: method(:paint))) if outcome
         @question = nil
+        # A continue offer still waiting keeps the ? prompt (the step-limit
+        # question closes before its offer resolves): the text set aside
+        # waits for the > prompt (#continue_resolved).
+        return sync_continue_slot if @continue_offer
+
         set_aside = @set_aside
         @set_aside = nil
         sync_prompt(keep_text: false, prefill: set_aside)
-        sync_continue_slot if @continue_offer
       end
 
       # Restart the open read when its prompt no longer fits (a question or a
@@ -1195,7 +1209,10 @@ module Samagotchi
         return unless last_user
 
         @screen.commit(join_prompt_line(exchange[last_user]))
-        Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
+        # An image-only turn's text names its images already.
+        unless ImageRef.placeholder_only?(exchange[last_user][:content])
+          Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
+        end
         from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
         failed = join_failed_record(exchange[last_user])
@@ -1244,7 +1261,7 @@ module Samagotchi
       # machine's state dir, as #attach_images): none for a prompt with no
       # turn id (an older session) or a session with no analytics.
       def join_tool_records(prompt)
-        SessionMetrics.saved_tool_records(Session.session_dir(@client.session_id), prompt[:turn_id] || prompt["turn_id"])
+        SessionMetrics.saved_tool_records(Session.session_dir(@client.session_id, state_dir: @state_dir), prompt[:turn_id] || prompt["turn_id"])
       rescue Session::InvalidId
         []
       end
@@ -1254,7 +1271,7 @@ module Samagotchi
       # canceled or older turn — or one saved before the failure field —
       # draws its answer as before.
       def join_failed_record(prompt)
-        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id),
+        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id, state_dir: @state_dir),
                                                   prompt[:turn_id] || prompt["turn_id"])
         return nil unless record && record["status"] == "failed" && record["failure"].is_a?(Hash)
 

data/lib/samagotchi/terminal_ui.rb

@@ -121,6 +121,7 @@ module Samagotchi
 
       claim_session!(session_id) if session_id
       @resume_session = session_id ? Session.load(session_id) : nil
+      drop_dead_question(@resume_session) if @resume_session
       if @resume_session
         # --model overrides resumed session's model (runtime only, default unchanged)
         if flag_model_name
@@ -186,7 +187,6 @@ module Samagotchi
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         appended_prompt_files: @appended_prompt_files,
-        recap: scratch ? nil : recap_config,
         scratch: scratch,
         reminders: {
           callback: lambda { |due_names|
@@ -249,7 +249,8 @@ module Samagotchi
     # post-turn conversation.
     # @return [Symbol, nil] :turn_failed when lines came from a pipe and a
     #   turn failed, :empty_answer when a -p --non-interactive turn ended
-    #   with no answer (bin/chi exits 1 on both), :interrupted when Ctrl-C
+    #   with no answer, :iteration_limit when the iteration limit cut that
+    #   turn short (bin/chi exits 1 on all three), :interrupted when Ctrl-C
     #   cancelled that turn (bin/chi exits 130)
     def run
       # --non-interactive with no --prompt is a harmless no-op exit: build
@@ -309,12 +310,13 @@ module Samagotchi
         # Retry lines and hook notices on stderr; stdout gets the answer below.
         sink = OneShotSink.new
         save_before_first_turn(session)
+        max_iterations = IterationLimit.for(no_interrupt: true)
         begin
           result = @engine.run_turn(
             session,
             one_shot_prompt,
             on_event: sink,
-            max_iterations: IterationLimit.for(no_interrupt: true),
+            max_iterations: max_iterations,
             cancel_controller: nil,
             images: ImageInput.extract(one_shot_prompt)
           )
@@ -337,6 +339,11 @@ module Samagotchi
         session.save
         # The after_turn hooks' notices, after the answer as the REPL shows them.
         sink.flush
+        # The limit cut the turn short: what came so far is no answer, so say
+        # so and fail (bin/chi exits 1), as the REPL's "iteration limit
+        # reached" line does there.
+        return one_shot_exhausted(session, max_iterations) if result.resumable?
+
         return
       end
 
@@ -390,6 +397,16 @@ module Samagotchi
       :turn_failed
     end
 
+    # A -p --non-interactive turn the iteration limit cut short: a line on
+    # stderr, with how to go on unless the session goes with this run.
+    # @return [Symbol] :iteration_limit
+    def one_shot_exhausted(session, max_iterations)
+      line = "chi: the iteration limit (#{max_iterations}) was reached before the turn finished"
+      line += "; continue it with: chi --resume #{session.id}" unless @scratch
+      warn line
+      :iteration_limit
+    end
+
     # `chi -p "/models" --non-interactive`: the command's output; a refused
     # one fails the run (bin/chi exits 1). The session is saved only when
     # the command changed it. Nobody is there to answer a confirm: a
@@ -518,6 +535,17 @@ module Samagotchi
       @pending_card_handle = @engine.subscribe(observer: pending)
     end
 
+    # A question the session's last owner saved and died with (a worker's,
+    # or another REPL's): this TUI owns the session now, so nobody waits on
+    # it. Dropped and saved, as the worker does (Worker#drop_dead_question).
+    def drop_dead_question(session)
+      id = session.drop_dead_question
+      return unless id
+
+      Log.info(:repl, "dead_question_dropped", id: id)
+      session.save
+    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
@@ -1359,14 +1387,6 @@ module Samagotchi
       Log.debug(:repl, "children_counts_failed", error: e.class.name)
     end
 
-    # Resolve the recap config (on by default). Returns false when explicitly
-    # disabled, nil when nothing is configured, or a Hash when enabled so the
-    # Engine can build the detector. Single precedence path via the Config
-    # registry: CLI > ENV (SAMAGOTCHI_RECAP_*) > file (recap:) > default.
-    def recap_config
-      ConfigFile.recap_config
-    end
-
     # Reset the Engine's shared inactivity clock when a prompt opens (a
     # Reline.pre_input_hook) and on each key typed (RelineSeam.key_handler). This is the
     # single seam the Engine-owned idle recap detector reads, so the idle clock

data/lib/samagotchi/tools/execute.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require_relative "../config"
+require_relative "../log"
 require_relative "../paths"
 require_relative "../process_group"
 require_relative "output_guardrails"
@@ -169,10 +170,14 @@ module Samagotchi
         exit_code_path = File.join(dir, TaskRuntime::EXIT_CODE_FILENAME)
         begin
           pid = spawn_logged(command, env: env, cwd: cwd, logs: logs, exit_code_path: exit_code_path)
-        rescue StandardError
+        rescue StandardError => e
+          Log.info(:turn, "execute_spawn_failed", id: id, error: e.class.name)
           FileUtils.rm_rf(dir)
           raise
         end
+        # Never the command line or its output: a command may carry a
+        # secret, and its output is the tool result's.
+        Log.debug(:turn, "execute_started", id: id, pid: pid, timeout_sec: timeout_sec, on_timeout: on_timeout)
         wait_thr = Process.detach(pid)
         # A stop is done once the shell is reaped and nothing holds the logs:
         # a child that ignores TERM keeps them, so the stop goes on to KILL.
@@ -195,6 +200,7 @@ module Samagotchi
                              timeout_sec: timeout_sec, dir: dir, logs: logs, exit_code_path: exit_code_path)
             if text
               handed_over = true
+              Log.info(:turn, "execute_handed_over", id: id, after_sec: timeout_sec)
               raise HandedOver, text
             end
             # Not adopted because it ended meanwhile: finished too.
@@ -205,10 +211,11 @@ module Samagotchi
           status = wait_thr.value
         rescue HandedOver
           raise
-        rescue Exception # rubocop:disable Lint/RescueException -- kill the child, then re-raise
+        rescue Exception => e # rubocop:disable Lint/RescueException -- kill the child, then re-raise
           # An Interrupt (or anything else) mid-wait: the child is in its own
           # process group, so it never saw the SIGINT. Kill it.
           aborted = true
+          Log.info(:turn, "execute_aborted", id: id, error: e.class.name)
           terminate_process_tree(pid, stopped: stopped) if wait_thr.alive?
           raise
         ensure
@@ -230,9 +237,18 @@ module Samagotchi
           end
         end
 
-        raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
-        raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
+        elapsed_ms = ((monotonic_time - started) * 1000).round
+        if timed_out
+          Log.info(:turn, "execute_timed_out", id: id, after_sec: timeout_sec)
+          raise CommandTimedOut.new(stdout_text, stderr_text)
+        end
+        if was_cancelled
+          Log.info(:turn, "execute_stopped", id: id, ms: elapsed_ms)
+          raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started)
+        end
 
+        Log.debug(:turn, "execute_finished", id: id, exit: status&.exitstatus, ms: elapsed_ms,
+                                             background: held_open || nil)
         [stdout_text, stderr_text, status, held_open]
       end
       private_class_method :run_command
@@ -348,6 +364,8 @@ module Samagotchi
           Thread.current.report_on_exception = false
           code = waiter.value&.exitstatus
           File.write(path, code.to_s) if code && !File.exist?(path) && Dir.exist?(File.dirname(path))
+        rescue StandardError => e
+          Log.debug(:turn, "execute_exit_code_failed", error: e.class.name, msg: e.message)
         end
       end
       private_class_method :write_missing_exit_code

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -921,7 +921,7 @@ module Samagotchi
           state = nil
           session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names),
                            prompt_notes: session.prompt_notes.map(&:to_h) }
-          messages = last_assistant_for_display(session.messages, turn_id: turn_id)
+          messages = last_assistant_for_display(session.messages, turn_id: turn_id, cwd: session.working_directory)
         end
         live_metrics = state && state["metrics"]
         # Without recent=1: a tab opened before this release (it replaces its
@@ -1923,7 +1923,7 @@ module Samagotchi
             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"])
+            refs = Samagotchi::AnswerRefs.for_display(m[:display_refs] || m["display_refs"], cwd: cwd)
             message[:display_refs] = refs unless refs.empty?
           end
           message[:parts] = did if did
@@ -1968,8 +1968,10 @@ module Samagotchi
 
       # The last message messages_for_display shows as an answer
       # (AnswerTail), as a list of at most one: only that one is rendered.
-      def last_assistant_for_display(msgs, turn_id: nil)
-        messages_for_display([AnswerTail.find(msgs, turn_id: turn_id)].compact)
+      # +cwd+: the session's folder, for its file refs (nil from a live
+      # worker's tail: its refs were held to the folder when they were added).
+      def last_assistant_for_display(msgs, turn_id: nil, cwd: nil)
+        messages_for_display([AnswerTail.find(msgs, turn_id: turn_id)].compact, cwd: cwd)
       end
 
       def parse_json(str)

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

@@ -140,10 +140,10 @@ export function addCompleted(model, event = {}, now = null) {
   // A grep that found nothing (status ok): the row says "no match".
   if (event.activity?.no_match) row.no_match = true;
   // The images the tool returned (a reload in the turn view draws them from
-  // the saved parts, turn_html.js toolRowHtml).
+  // the saved parts, turn_html.js toolRowTemplate).
   if (event.images?.length) row.images = event.images;
   // What an edit/write changed in its file (a reload draws it from the
-  // saved parts, turn_html.js toolRowHtml).
+  // saved parts, turn_html.js toolRowTemplate).
   if (event.diff) row.diff = event.diff;
   const duration = callDuration(row, event, now);
   if (duration !== null) row.duration_ms = duration;