samagotchi 0.85.0 → 0.86.0

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.86.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,9 @@ 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) { @commands.run(command.line, confirm: confirm?(command), as_parent: as_parent?(command)) }
+      end
     end
 
     # Whether +command+ asks before a costly /thinking or /reasoning-history
@@ -795,6 +803,11 @@ 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
+
     # 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 +879,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.86.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
@@ -519,6 +527,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

data/lib/samagotchi/guardrails/parent_continue.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../config"
-
-module Samagotchi
-  module Guardrails
-    # Whether a parent agent may answer Continue to a session's step-limit
-    # question (kind "continue", ContinueOffer): turn.parent_continue,
-    # config.yml only, default true. Continue grants no permission (every
-    # tool call still meets the guardrails), it spends time and tokens;
-    # false makes parents stop-only. Checked by `chi answer` before it posts
-    # and by the worker's question desk for an answer marked as chi
-    # answer's, the way ParentApprovals is.
-    module ParentContinue
-      KEY = "turn.parent_continue"
-      KIND = "continue"
-      CONTINUE = "Continue"
-
-      module_function
-
-      # @return [Boolean] this process's setting
-      def allowed?
-        Config.get(KEY) != false
-      end
-
-      # Why a parent may not give this answer, or nil.
-      # @param pending [PendingQuestion] the pending question
-      # @param selected [Array<String>] the selected labels
-      # @return [Symbol, nil] :stop_only
-      def refusal(pending, selected, allowed: allowed?)
-        return nil if allowed
-        return nil unless pending.kind.to_s == KIND
-
-        Array(selected).map(&:to_s).include?(CONTINUE) ? :stop_only : nil
-      end
-
-      def message
-        "a parent agent may only stop this turn here (#{KEY}: false): answer Stop " \
-          "(--option Stop --text WHY), or tell your user it waits"
-      end
-    end
-  end
-end