samagotchi 0.85.0 → 0.87.0

data/lib/samagotchi/testing.rb

@@ -22,5 +22,6 @@ require_relative "testing/recording_api"
 require_relative "testing/waiting"
 require_relative "testing/fake_executable"
 require_relative "testing/bundle"
+require_relative "testing/install"
 require_relative "testing/helpers"
 require_relative "testing/boundary"

data/lib/samagotchi/tools/builtins.rb

@@ -118,7 +118,8 @@ module Samagotchi
 
       # What execute and task_create export into the commands they run: a
       # chi started there answers as a parent agent
-      # (Guardrails::ParentApprovals.parent_process?), even under a PTY
+      # (Guardrails::ParentApprovals.parent_process?, held to
+      # Guardrails::ParentPolicy), even under a PTY
       # wrapper. The session's id, "chi" without one. And the model the
       # session runs on (SAMAGOTCHI_SESSION_MODEL, read live, so right after
       # /model), which chi self reports; unset when unknown, so a value

data/lib/samagotchi/tools/delegate.rb

@@ -134,7 +134,10 @@ module Samagotchi
                  "(the most is #{max}, #{MAX_CHILDREN_KEY}): #{ids}. #{full_hint(peers)}"
         end
 
-        setup = toolkit.empty? ? SessionSetup.new : SessionSetup.new(toolkit: Toolkit.new(name: toolkit))
+        # The parent's own parent_answers, as it is now (a snapshot): the
+        # child's answers are held at least as tight.
+        setup = SessionSetup.new(toolkit: toolkit.empty? ? nil : Toolkit.new(name: toolkit),
+                                 parent_answers: parent.parent_answers)
         child = SessionManager.spawn_session(prompt: task, working_directory: folder,
                                              model_name: child_model(model, parent), memories: CHILD_MEMORIES,
                                              parent_id: parent.id, delegate: true, setup: setup, state_dir: state_dir)

data/lib/samagotchi/tools/delegate_wait.rb

@@ -213,6 +213,10 @@ module Samagotchi
       # @return [String]
       def finish(wait, child_id, timeout:, report: false, reports: "off")
         status = ParentReport.status(wait)
+        # What the parent may pick on the child's question: config.yml
+        # tightened by the child session's own parent_answers (the session
+        # the wait read; none: config.yml's).
+        strategy = Guardrails::ParentPolicy.for_session(wait.session)
         case wait.status
         when :done
           reply_result(child_id, status, wait.text)
@@ -221,11 +225,11 @@ module Samagotchi
         when :stopped
           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, status, waiting_text(child_id, wait.question, report: report, reports: reports))
+          result(child_id, status, waiting_text(child_id, wait.question, report: report, reports: reports, strategy: strategy))
         when :canceled
           canceled_result(child_id, reports: reports)
         when :no_reply
-          result(child_id, status, "#{no_reply_text(wait, child_id)}; its session shows what happened")
+          result(child_id, status, "#{no_reply_text(wait, child_id, strategy: strategy)}; its session shows what happened")
         when :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")
@@ -266,8 +270,8 @@ module Samagotchi
       end
 
       # ParentReport's line for a turn that left no reply, about the child.
-      def no_reply_text(wait, child_id)
-        ParentReport.no_reply_line(wait, child_id).sub(/\Athe turn/, "the child's turn")
+      def no_reply_text(wait, child_id, strategy: nil)
+        ParentReport.no_reply_line(wait, child_id, strategy: strategy).sub(/\Athe turn/, "the child's turn")
       end
 
       def result(child_id, status, text)
@@ -303,12 +307,17 @@ module Samagotchi
       # A report's last line differs (+report+): "waits again" made models
       # call delegate_result right after answering Continue.
       # The tool's last line follows #reports_mode.
-      def waiting_text(child_id, pending, report: false, reports: "off")
-        text = "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id)}"
-        if ParentReport.continue?(pending)
+      def waiting_text(child_id, pending, report: false, reports: "off", strategy: nil)
+        text = "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id, strategy: strategy)}"
+        if ParentReport.continue?(pending) && ParentReport.may_continue?(pending, strategy: strategy)
           text += "The child ran out of steps before it answered. Decide: continue it (run the chi answer command " \
                   "above with execute) if it is getting somewhere; send it a narrower follow-up with delegate " \
                   "session: #{child_id} (that drops the question); or stop it and report back to your user.\n"
+        elsif ParentReport.continue?(pending)
+          # guardrails.parent_answers: hard: continuing is the user's.
+          text += "The child ran out of steps before it answered. Decide: send it a narrower follow-up with delegate " \
+                  "session: #{child_id} (that drops the question); or stop it (the chi answer Stop command above, " \
+                  "with execute) and report back to your user, who may continue it.\n"
         end
         return "#{text}#{REPORT_NEXT_REPLY}" if report
         return "#{text}delegate_result #{child_id} waits again once it is answered." if reports == "off"

data/lib/samagotchi/tools/task_runtime.rb

@@ -100,15 +100,15 @@ module Samagotchi
       # between (failed, no exit code) is corrected; a stopped task (its
       # stop flag on disk) is left as task_stop records it.
       # The thread is named EXIT_STATUS_THREAD (a spec joins them before it
-      # removes the tasks' folder).
+      # removes the tasks' folder) here, before it returns: named from
+      # inside, a thread not yet scheduled was missed by that join.
       # @return [Thread]
       def record_exit_status(waiter, path, task_id:)
         # Absolute now: safe against a later chdir.
         record_path = File.expand_path(metadata_path(task_id))
         path = File.expand_path(path)
-        Thread.new do
+        thread = Thread.new do
           Thread.current.report_on_exception = false
-          Thread.current.name = EXIT_STATUS_THREAD
           code = status_code(waiter.value)
           next if code.nil? || record_at(record_path)&.stop_requested_by
 
@@ -117,6 +117,8 @@ module Samagotchi
         rescue StandardError => e
           Log.debug(:turn, "task_exit_code_failed", id: task_id, error: e.class.name, msg: e.message)
         end
+        thread.name = EXIT_STATUS_THREAD
+        thread
       end
 
       # A Process::Status as a shell reports one: its exit status, or

data/lib/samagotchi/turn_checkpoint.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "json"
 require "time"
+require_relative "atomic_file"
 require_relative "interrupted_turn"
+require_relative "last_turn"
 require_relative "log"
 require_relative "session"
+require_relative "session_inbox"
 require_relative "steer"
 require_relative "turn_note"
 
@@ -39,9 +44,12 @@ module Samagotchi
     # last_turn is left as it was: a new last_turn saved idle here, before
     # the turn a `chi send --wait` started this worker for, would end that
     # wait at once as the sent turn's (ReplyWait compares last_turn), with
-    # the dead turn's outcome.
+    # the dead turn's outcome. A mark with an enqueued_id records the dead
+    # turn's end under that id instead (+session_dir+, #settled_turn): only
+    # a wait for that very turn (ReplyWait's turn:) reads it.
+    # @param session_dir [String, nil] where to record it; nil: nowhere
     # @return [InterruptedTurn, nil] the mark settled, nil when there was none
-    def self.settle(session)
+    def self.settle(session, session_dir: nil)
       mark = session.interrupted_turn
       return nil unless mark
 
@@ -54,9 +62,63 @@ module Samagotchi
       session.messages = messages + [note]
       session.status = Session::STATUS_IDLE if session.status == Session::STATUS_RUNNING
       session.interrupted_turn = nil
+      record_settled(session_dir, mark, seconds) if session_dir
       mark
     end
 
+    # Where a per-input terminal outcome is kept: input/settled/<enqueued_id>,
+    # outside the *.json glob like SessionInbox's removed tombstones.
+    SETTLED_DIR = "settled"
+    WORKER_STOPPED = "worker_stopped"
+
+    # The terminal outcome recorded for +enqueued_id+.
+    # @return [LastTurn, nil] nil when no settle recorded one
+    def self.settled_turn(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      return nil unless SessionInbox::ENQUEUED_ID_NAME.match?(id)
+
+      raw = File.read(File.join(session_dir, SessionInbox::INPUT_DIR, SETTLED_DIR, id))
+      LastTurn.from_file(JSON.parse(raw)) || settled_record(id)
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      nil
+    rescue JSON::ParserError, SystemCallError
+      # The file says the turn was settled even when it can't be read.
+      settled_record(id)
+    end
+
+    def self.settled_record(id, ended_at: nil, seconds: nil)
+      LastTurn.new(outcome: "canceled", cancel_reason: WORKER_STOPPED, ended_at: ended_at, seconds: seconds, enqueued_id: id)
+    end
+    private_class_method :settled_record
+
+    # A file-delivered command ends its sender's wait without running a
+    # turn. Keep a terminal outcome under the same per-input settled path.
+    def self.record_command_outcome(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      return if id.empty? || !SessionInbox::ENQUEUED_ID_NAME.match?(id)
+
+      dir = File.join(session_dir, SessionInbox::INPUT_DIR, SETTLED_DIR)
+      FileUtils.mkdir_p(dir)
+      record = LastTurn.new(outcome: "completed", ended_at: Time.now.iso8601(3), enqueued_id: id)
+      AtomicFile.write(File.join(dir, id), JSON.generate(record.to_file))
+    rescue SystemCallError, IOError => e
+      Log.warn(:worker, "command_outcome_write_failed", error: e.class.name, msg: e.message, enqueued_id: id)
+    end
+
+    def self.record_settled(session_dir, mark, seconds)
+      id = mark.enqueued_id.to_s
+      return unless SessionInbox::ENQUEUED_ID_NAME.match?(id)
+
+      dir = File.join(session_dir, SessionInbox::INPUT_DIR, SETTLED_DIR)
+      FileUtils.mkdir_p(dir)
+      record = settled_record(id, ended_at: Time.now.iso8601(3), seconds: seconds)
+      AtomicFile.write(File.join(dir, id), JSON.generate(record.to_file))
+    rescue SystemCallError => e
+      # The settle goes on; a wait for that turn runs to its timeout.
+      Log.warn(:worker, "settled_turn_write_failed", error: e.class.name, msg: e.message)
+    end
+    private_class_method :record_settled
+
     # @param session [Session] the worker's session (saved as a whole)
     # @param clock [#call] monotonic seconds (specs)
     def initialize(session:, state_dir:, interval: INTERVAL, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })

data/lib/samagotchi/turn_flow.rb

@@ -23,6 +23,16 @@ module Samagotchi
 
     # Read an answer to the continue offer.
     # @return [Array(Symbol, String|nil)] [:resume | :abort | :abort_with_reason | :invalid, reason]
+    # Whether +line+ is a /continue that continues the turn (/continue,
+    # /continue yes): what a parent agent's must be checked for.
+    def self.continue_yes?(line)
+      text = line.to_s.strip
+      return false unless text.match?(/\A#{Regexp.escape(CONTINUE_COMMAND)}(\s|\z)/)
+
+      answer = text.delete_prefix(CONTINUE_COMMAND).strip
+      continue_decision(answer.empty? ? CONTINUE_COMMAND : answer).first == :resume
+    end
+
     def self.continue_decision(input)
       normalized = input.to_s.strip
       return [:resume, nil] if normalized.empty?

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -926,14 +926,10 @@ module Samagotchi
         state = nil unless state.is_a?(Hash)
         if state
           status, used, notes = state.values_at("status", "used_memory_names", "prompt_notes")
-          # No session file read here: the folder the answer's file refs must
-          # stay under is the worker's (its tail's working_directory), else the
-          # hub's session list entry's (a worker from before the field, or read
-          # through its snapshot); nil then without a hub or before it saw the
-          # session: refs aren't checked.
-          cwd = tail["working_directory"]
-          cwd = @hub&.working_directory(id) unless cwd.is_a?(String) && !cwd.empty?
-          messages = last_assistant_for_display([tail["answer"]].compact, cwd: cwd)
+          answer = tail["answer"]
+          cwd = tail_working_directory(id, tail, answer)
+          answer = without_file_refs(answer) unless cwd
+          messages = last_assistant_for_display([answer].compact, cwd: cwd)
         else
           session = @session_class.load(id, state_dir: default_state_dir)
           status = displayed_status(session)
@@ -956,6 +952,35 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # The folder the live tail's answer's file refs must stay under: the
+      # worker's (its tail's working_directory), else the hub's session list
+      # entry's (a worker from before the field, or read through its
+      # snapshot), else, only when the answer has refs to check, the session
+      # file's, as the full read takes it. nil when none is known: the
+      # caller drops the file refs rather than show them unchecked.
+      # @return [String, nil]
+      def tail_working_directory(id, tail, answer)
+        known = ->(dir) { dir.is_a?(String) && !dir.empty? }
+        cwd = tail["working_directory"]
+        cwd = @hub&.working_directory(id) unless known.call(cwd)
+        return cwd if known.call(cwd)
+        return nil unless answer.is_a?(Hash) && (answer[AnswerRefs::KEY.to_s] || answer[AnswerRefs::KEY])
+
+        cwd = @session_class.load(id, state_dir: default_state_dir).working_directory
+        known.call(cwd) ? cwd : nil
+      rescue ArgumentError, KeyError, SystemCallError
+        nil
+      end
+
+      # +answer+ without its file refs (the rest kept), for a read that
+      # knows no folder to check them against.
+      def without_file_refs(answer)
+        return answer unless answer.is_a?(Hash)
+
+        key = [AnswerRefs::KEY.to_s, AnswerRefs::KEY].find { |name| answer[name].is_a?(Array) } or return answer
+        answer.merge(key => answer[key].reject { |ref| ref.is_a?(Hash) && (ref["kind"] || ref[:kind]).to_s == Ref::FILE })
+      end
+
       # ?timing=1: the whole timing (every record, analytics.json merged with
       # the live ones) and turn_count, when the page's merge comes up short.
       # The worker's GET state, never its messages.
@@ -1572,7 +1597,7 @@ module Samagotchi
           return [200, headers.merge("rack.hijack" => hijack), []]
         end
 
-        query = req.query_string.to_s.empty? ? "" : "?#{req.query_string}"
+        query = stream_query(req)
         [200, headers, ProxyStreamBody.new(host: DEFAULT_HOST, port: bridge_port, session_id: id, query: query, headers: req.env,
                                            server_running: @server_running)]
       end
@@ -1616,13 +1641,26 @@ module Samagotchi
         [200, headers, body]
       end
 
+      # The stream's query as the worker's Bridge gets it ("?..." or ""):
+      # every parameter but `raw`. `?raw=1` is the worker port's debugging view
+      # (a chunk's provider payload); a browser never gets it through here.
+      # Keys are compared decoded, as the Bridge reads them.
+      def stream_query(req)
+        pairs = req.query_string.to_s.split("&").reject do |pair|
+          URI.decode_www_form_component(pair.split("=", 2).first.to_s) == "raw"
+        rescue ArgumentError
+          false
+        end
+        pairs.empty? ? "" : "?#{pairs.join("&")}"
+      end
+
       # Rack hijack lambda (env["rack.hijack?"] truthy): pipes the bridge's SSE
       # frames directly to the client socket until it disconnects. The handler
       # (WEBrick via rackup) has already sent the status line + headers, so
       # only body bytes go to the socket here.
       def sse_hijack(id, req, port)
         lambda do |io|
-          query = req.query_string.to_s.empty? ? "" : "?#{req.query_string}"
+          query = stream_query(req)
           body = ProxyStreamBody.new(host: DEFAULT_HOST, port: port, session_id: id, query: query, headers: req.env,
                                      server_running: @server_running)
           body.each { |chunk| io.write(chunk) }

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

@@ -1,26 +1,15 @@
 // Pure routing for one :generation_chunk event into the two render lanes.
 //
-// Every :generation_chunk the server sends carries additive `text` (visible
-// prose, thinking + tool_call blocks removed) and `thinking` (thinking-only)
-// fields beside the raw `content`: the native loop splits its stream per
-// generation for every profile (Gemma's thought channel included), the chat
-// loop gets reasoning apart from the answer. We use those fields and ignore raw
-// `content`; a chunk without them (an older server) falls back to raw
-// `content` as text.
-//
-// Presence is checked with `typeof === "string"` (not truthiness) so an empty
-// `text` (e.g. a chunk that is entirely a tool_call body) still selects the new
-// wire instead of accidentally falling back to raw `content`.
+// Every :generation_chunk the server sends carries `text` (visible prose,
+// thinking + tool_call blocks removed) and `thinking` (thinking-only): the
+// native loop splits its stream per generation for every profile (Gemma's
+// thought channel included), the chat loop gets reasoning apart from the
+// answer. The raw stream text and the provider's payload stay in the worker
+// (Bridge::ClientEvent); a missing or non-string field is an empty lane.
 export function routeChunk(data) {
   data = data || {};
-  if (typeof data.text === "string" || typeof data.thinking === "string") {
-    return {
-      text: typeof data.text === "string" ? data.text : "",
-      thinking: typeof data.thinking === "string" ? data.thinking : "",
-    };
-  }
   return {
-    text: typeof data.content === "string" ? data.content : "",
-    thinking: "",
+    text: typeof data.text === "string" ? data.text : "",
+    thinking: typeof data.thinking === "string" ? data.thinking : "",
   };
 }

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

@@ -1,7 +1,10 @@
-// Context-window usage (%) from a stream event. `windowTokens` is the window
-// the kernel resolved for this generation (:generation_started carries it as
-// context_window_tokens); llama.cpp's stream payloads report token counts
-// but no n_ctx, so without it only a precomputed pct or an n_ctx works.
+// Context-window usage (%) from a stream event: a :context_status's
+// estimated_pct, or a :generation_chunk's `counts` (chi's own counts, which
+// the worker's Bridge works out from the provider's payload; the payload
+// itself never reaches a client). `windowTokens` is the window the kernel
+// resolved for this generation (:generation_started carries it as
+// context_window_tokens); a chunk's counts carry a window only when the server
+// reported one (llama.cpp's /completion doesn't), and that one wins.
 // `budgetTokens` is the session's LLM context budget (llm_context's
 // budget_tokens): a percentage this file computes counts against it when it
 // is smaller than the window, as the kernel's :context_status does
@@ -20,32 +23,15 @@ function countedTokens(windowTokens, budgetTokens = null) {
   return budget && budget > 0 ? Math.min(budget, window) : window;
 }
 
-// Tokens in context after this chunk: prompt + generated so far.
-function usedTokens(p) {
-  if (!p || typeof p !== "object") return null;
-  if (num(p.n_past)) return p.n_past;
-  if (num(p.usage?.total_tokens)) return p.usage.total_tokens;
-  const prompt = num(p.usage?.prompt_tokens) ?? num(p.tokens_evaluated) ?? num(p.timings?.prompt_n);
-  const completion = num(p.usage?.completion_tokens) ?? num(p.tokens_predicted) ?? num(p.timings?.predicted_n);
-  if (prompt === null && completion === null) return null;
-  return (prompt ?? 0) + (completion ?? 0);
-}
-
 export function extractCtxPct(data, windowTokens = null, budgetTokens = null) {
   if (!data || typeof data !== "object") return null;
-  if (num(data.ctx_pct) !== null) return data.ctx_pct;
-  if (num(data.est_pct) !== null) return data.est_pct;
-  if (num(data.ctxPct) !== null) return data.ctxPct;
   // The kernel's :context_status event: { usage: { estimated_pct, ... }, bucket }.
   if (num(data.usage?.estimated_pct) !== null) return data.usage.estimated_pct;
-  if (data.context_window_tokens && data.total_tokens) {
-    const against = countedTokens(data.context_window_tokens, budgetTokens);
-    if (against) return (data.total_tokens / against) * 100;
-  }
-  const p = data.payload || data;
-  if (num(p.ctx_pct) !== null) return p.ctx_pct;
-  const against = countedTokens(num(p.n_ctx) || num(windowTokens), budgetTokens);
-  const used = usedTokens(p);
+  // A chunk's counts: tokens in context after it (prompt + generated so far).
+  const counts = data.counts;
+  if (!counts || typeof counts !== "object") return null;
+  const used = num(counts.total_tokens);
+  const against = countedTokens(num(counts.context_window_tokens) || num(windowTokens), budgetTokens);
   if (!against || used === null) return null;
   return (used / against) * 100;
 }

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

@@ -61,7 +61,7 @@ export function createStreamHandlers(deps) {
   return {
     generation_chunk: (data) => {
       // Route the chunk's bytes to the text bubble and the thinking block (see
-      // chunk_router.js). Raw `content` is only a fallback for an older server.
+      // chunk_router.js).
       const { text, thinking } = routeChunk(data);
       liveTurn.timing.setNote("");
       turnDom.chunk({ text, thinking, iteration: data.iteration ?? null, now: data.replayed ? null : Date.now() });

data/lib/samagotchi/web/server.rb

@@ -120,6 +120,9 @@ module Samagotchi
       def self.start(port: nil, host: nil, url: nil, open_browser: false, state_dir: nil, manager: nil, markdown: false,
                      view: Config::BY_KEY["web.view"].default, annotate_presets: Config::BY_KEY["web.annotate_presets"].default, hub: nil, lan: nil,
                      editor: Config::BY_KEY["web.editor"].default, token_path: Token.path)
+        config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :web) do |message|
+          Samagotchi::Log.warn(:config, "restart_required", echo: "Warning: config: #{message}")
+        end
         port = resolve_port(port)
         host = resolve_host(host)
         url ||= "http://#{url_host(host)}:#{port}/"
@@ -166,6 +169,7 @@ module Samagotchi
         warn "Error: can't listen on #{lan.ip}:#{port} (#{e.message}); did the address change? Run chi web again"
         false
       ensure
+        config_restart_unsubscribe&.call
         hub&.stop
         Samagotchi::Log.info(:web, "stop") if app
       end

data/lib/samagotchi/worker.rb

@@ -229,6 +229,9 @@ module Samagotchi
       # The running turn, on disk at its iteration boundaries.
       @checkpoint = TurnCheckpoint.new(session: @session, state_dir: @state_dir)
       @engine = build_engine
+      @config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :worker) do |message|
+        @engine.announce(type: :hook_notice, hook: "config", text: message, level: :warn, between_turns: true)
+      end
       settle_interrupted_turn
       # Before the Bridge serves anything: a UI joining a resumed worker's
       # stream gets the session's history and status in its snapshot, not
@@ -278,8 +281,9 @@ module Samagotchi
                                    context_absorber: @context_absorber, wakes: @wakes,
                                    awaiting_continue: -> { @turn_flow.awaiting_continue? },
                                    stopped: -> { stopped_on_disk? },
-                                   queue_command: lambda { |line, client_id, after_file|
-                                     @bridge.queue_command(line, client_id: client_id, after_file: after_file)
+                                   queue_command: lambda { |line, client_id, after_file, enqueued_id|
+                                     @bridge.queue_command(line, client_id: client_id, after_file: after_file,
+                                                                 enqueued_id: enqueued_id)
                                    })
       # /model's default is the config's, as in the REPL; the Engine started
       # on the session's model.  nil when there is no default.model.
@@ -414,6 +418,7 @@ module Samagotchi
     # The context poller first: a command it runs goes (its process
     # group) before the Engine does.
     def teardown
+      @config_restart_unsubscribe&.call
       @context_poller&.stop
       drop_queued_commands
       @engine&.shutdown
@@ -453,9 +458,10 @@ module Samagotchi
 
     # A turn an earlier worker died in (TurnCheckpoint's mark in the file):
     # ended now as canceled, with its note, and saved, before the Bridge
-    # serves the session (TurnCheckpoint.settle).
+    # serves the session (TurnCheckpoint.settle). Its queued id's wait
+    # (chi send --queue --wait) reads the end it records in the session dir.
     def settle_interrupted_turn
-      mark = TurnCheckpoint.settle(@session)
+      mark = TurnCheckpoint.settle(@session, session_dir: @session_dir)
       return unless mark
 
       Log.info(:worker, "interrupted_turn_settled", turn_id: mark.id, iteration: mark.iteration, at: mark.at)
@@ -787,7 +793,11 @@ module Samagotchi
     #   the cards and notices it showed, held: they follow its command_ran,
     #   as its output
     def run_command_line(command)
-      @engine.holding_announcements { command_result(command) { @commands.run(command.line, confirm: confirm?(command)) } }
+      @engine.holding_announcements do
+        command_result(command) do
+          @commands.run(command.line, confirm: confirm?(command), as_parent: as_parent?(command), user_ui: user_ui?(command))
+        end
+      end
     end
 
     # Whether +command+ asks before a costly /thinking or /reasoning-history
@@ -795,6 +805,17 @@ module Samagotchi
     # question; chi send, a delegate, a plugin and a card's action apply it.
     def confirm?(command) = ClientId.interactive?(command.client_id) && !command.card
 
+    # Whether +command+ is a parent agent's (chi answer's marker, which chi
+    # send and a parent's attach give a /continue yes too): held to
+    # guardrails.parent_answers (SessionCommands#continue_answer).
+    def as_parent?(command) = command.client_id.to_s == ClientId::CLI_ANSWER
+
+    # Whether +command+ is a user's at a UI (a web tab, a chi TUI, a card's
+    # click), not a parent agent's: only such a line loosens
+    # /parent-answers. chi send, a delegate's follow-up, a plugin and an
+    # input with no client never do (ParentAnswersCommand).
+    def user_ui?(command) = ClientId.interactive?(command.client_id) && !as_parent?(command)
+
     # The block's Result for +command+; one that raised, or found no
     # command for the line, is an error Result saying so.
     # @return [SessionCommands::Result]
@@ -866,6 +887,7 @@ module Samagotchi
     # @param confirm [CacheConfirm::Confirm, nil] the change asks first: the
     #   line that applies it (the TUI's prefill, the web's Apply button)
     def announce_command(command, status:, output:, changed:, anytime: false, confirm: nil)
+      TurnCheckpoint.record_command_outcome(@session_dir, command.enqueued_id)
       text = output.to_s
       event = { type: :command_ran, **command.event_fields, status: status, output: text[0, COMMAND_OUTPUT_LIMIT],
                 changed: changed.map(&:to_s), model_name: @engine.effective_model_name }

data/lib/samagotchi/worker_inbound.rb

@@ -70,9 +70,9 @@ module Samagotchi
     # @param wakes [WorkerWakes] the wake budget a context wake asks
     # @param awaiting_continue [#call] whether a continue offer waits
     # @param stopped [#call] whether the session was stopped on disk
-    # @param queue_command [#call] (line, client_id, after_file) queues a
-    #   session command for the loop's next pass; after_file is the input
-    #   file it came in, or nil
+    # @param queue_command [#call] (line, client_id, after_file, enqueued_id)
+    #   queues a session command for the loop's next pass; after_file is the
+    #   input file it came in, or nil
     def initialize(session:, state_dir:, session_dir:, engine:, context_absorber:, wakes:, awaiting_continue:,
                    stopped:, queue_command:)
       @session = session
@@ -228,7 +228,7 @@ module Samagotchi
     def queue_as_command(text, origin, after_file = nil)
       return false unless @engine.command_registry.command?(text.to_s)
 
-      @queue_command.call(text, origin&.dig(:client_id), after_file)
+      @queue_command.call(text, origin&.dig(:client_id), after_file, origin&.dig(:enqueued_id))
       true
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.85.0
+  version: 0.87.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -124,6 +124,7 @@ files:
 - bin/chi
 - docs/architecture.md
 - docs/broadcast.md
+- docs/bundle-authoring.md
 - docs/cli.md
 - docs/configuration.md
 - docs/context.md
@@ -162,6 +163,7 @@ files:
 - lib/samagotchi/bridge.rb
 - lib/samagotchi/bridge/bounded_queue.rb
 - lib/samagotchi/bridge/card_store.rb
+- lib/samagotchi/bridge/client_event.rb
 - lib/samagotchi/bridge/event_id.rb
 - lib/samagotchi/bridge/pending_card.rb
 - lib/samagotchi/bridge/ring_buffer.rb
@@ -179,6 +181,9 @@ files:
 - lib/samagotchi/broadcast/triage_model.rb
 - lib/samagotchi/broadcast_command.rb
 - lib/samagotchi/bundle_command.rb
+- lib/samagotchi/bundle_command/check.rb
+- lib/samagotchi/bundle_command/scaffold.rb
+- lib/samagotchi/bundle_command/test_run.rb
 - lib/samagotchi/bundle_needs.rb
 - lib/samagotchi/bundle_session_settings.rb
 - lib/samagotchi/bundles/agents-md/manifest.yml
@@ -218,6 +223,8 @@ files:
 - lib/samagotchi/bundles/loop-guard/plugin.rb
 - lib/samagotchi/bundles/mcp/manifest.yml
 - lib/samagotchi/bundles/mcp/plugin.rb
+- lib/samagotchi/bundles/ruby/manifest.yml
+- lib/samagotchi/bundles/ruby/plugin.rb
 - lib/samagotchi/bundles/skills/manifest.yml
 - lib/samagotchi/bundles/skills/plugin.rb
 - lib/samagotchi/bundles/slow-commands/manifest.yml
@@ -301,7 +308,7 @@ files:
 - lib/samagotchi/guardrails/model_size.rb
 - lib/samagotchi/guardrails/outside.rb
 - lib/samagotchi/guardrails/parent_approvals.rb
-- lib/samagotchi/guardrails/parent_continue.rb
+- lib/samagotchi/guardrails/parent_policy.rb
 - lib/samagotchi/guardrails/protected_paths.rb
 - lib/samagotchi/guardrails/read_only_shell.rb
 - lib/samagotchi/guardrails/rm_targets.rb
@@ -391,6 +398,7 @@ files:
 - lib/samagotchi/memory_bundle/plugin_ref.rb
 - lib/samagotchi/memory_bundle/profile.rb
 - lib/samagotchi/memory_bundle/provenance.rb
+- lib/samagotchi/memory_bundle/shas.rb
 - lib/samagotchi/memory_bundle/shipped_update.rb
 - lib/samagotchi/memory_bundle/source.rb
 - lib/samagotchi/memory_bundle/status.rb
@@ -414,6 +422,7 @@ files:
 - lib/samagotchi/note_delivery.rb
 - lib/samagotchi/output_formatter.rb
 - lib/samagotchi/owner_lock.rb
+- lib/samagotchi/parent_answers_command.rb
 - lib/samagotchi/parent_report.rb
 - lib/samagotchi/paths.rb
 - lib/samagotchi/peer_sources.rb
@@ -519,6 +528,7 @@ files:
 - lib/samagotchi/testing/fake_http.rb
 - lib/samagotchi/testing/helpers.rb
 - lib/samagotchi/testing/host.rb
+- lib/samagotchi/testing/install.rb
 - lib/samagotchi/testing/minitest.rb
 - lib/samagotchi/testing/recorder.rb
 - lib/samagotchi/testing/recording_api.rb