samagotchi 0.12.0 → 0.14.0

data/lib/samagotchi/session_manager.rb

@@ -12,6 +12,7 @@ require_relative "config"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_metrics"
+require_relative "utf8_default"
 require_relative "turn_note"
 require_relative "owner_lock"
 require_relative "bridge_client"
@@ -162,7 +163,9 @@ module Samagotchi
     # child inherits this process's ENV and reads config.yml itself (as it
     # is when the worker starts); opts[:env] adds to it (merged, not
     # replaced) what it can't read there: this `chi`'s CLI settings
-    # (Config.cli_env), the hosts and the absolute log file.
+    # (Config.cli_env), the hosts and the absolute log file. It unsets
+    # SAMAGOTCHI_GUARDRAILS_*. XDG_CONFIG_HOME passes: whoever starts or
+    # wakes the worker picks which config.yml it reads (docs/guardrails.md).
     private_class_method def self.spawn_options(session)
       # Own process group: workers outlive `chi web`, and a Ctrl-C in its
       # terminal must not reach them.
@@ -195,10 +198,17 @@ module Samagotchi
       else
         child_env["SAMAGOTCHI_LOG_DISABLE"] = "true"
       end
+      # The spawner's environment must not reach the worker's guardrails (a
+      # parent agent starting or waking a session): Process.spawn unsets a
+      # key mapped to nil. config.yml no longer reads them; this keeps an
+      # older or future env-exposed one out as well.
+      ENV.each_key { |key| child_env[key] = nil if key.start_with?(GUARDRAILS_ENV_PREFIX) }
       opts[:env] = child_env unless child_env.empty?
       opts
     end
 
+    GUARDRAILS_ENV_PREFIX = "SAMAGOTCHI_GUARDRAILS_"
+
     # List all sessions, reading status from persisted session.json files.
     # +project_root+: only that project's sessions (nil: every session).
     # +include_archived+: archived sessions too (Session#archived says which).
@@ -226,9 +236,11 @@ module Samagotchi
     # @param include_archived [Boolean] archived sessions too
     # @return [Array<Hash>] {id:, short_id:, desc:, preview:, cwd:, project:,
     #   updated_at:, status:, live:, busy:, owner:, recap:, parent_id:,
-    #   parent_short_id:, archived:, scratch:, test_run:}; busy = live with
+    #   parent_short_id:, archived:, scratch:, test_run:, waiting:, waiting_id:}; busy = live with
     #   a turn running, recap = the saved recap's first sentence, project =
-    #   Session#project_root
+    #   Session#project_root, waiting = the kind of question it waits on
+    #   ("question", "approval", "hook"; Session#waiting_question) or nil,
+    #   waiting_id = that question's id or nil
     def self.session_summaries(live: false, cwd: nil, limit: nil, include_tests: true, exclude: nil, state_dir: nil,
                                project_root: nil, include_archived: false, sort: nil, order: nil)
       sd = state_dir || Session.default_state_dir
@@ -239,20 +251,27 @@ module Samagotchi
                          .reject { |s| (!include_tests && s.test_run) || s.id == exclude }
                          .select { |s| root.nil? || in_folder?(s.working_directory, root) }
                          .filter_map do |s|
-        owner = session_owner(s.id, state_dir: sd)&.kind
-        owned = owner == "worker"
+        owner = session_owner(s.id, state_dir: sd)
+        owned = !!owner&.worker?
         next if live && !owned
 
         { id: s.id, short_id: s.id[0, 8], desc: summary_desc(s), preview: summary_preview(s), cwd: s.working_directory,
           project: s.project_root(cache: roots), updated_at: s.updated_at, status: s.status, live: owned, busy: owned && s.status == Session::STATUS_RUNNING,
-          owner: owner, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
+          owner: owner&.kind, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
           ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd))&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), archived: s.archived,
-          scratch: s.scratch, test_run: s.test_run }
+          scratch: s.scratch, test_run: s.test_run }.merge(waiting_fields(s.waiting_question(live: owned)))
       end
       (limit ? summaries.first(limit) : summaries.to_a)
     end
 
+    # waiting: the question's kind, waiting_id: its id (what chi answer
+    # --question takes); both nil with none.
+    def self.waiting_fields(waiting)
+      { waiting: waiting&.dig(:kind), waiting_id: waiting&.dig(:id) }
+    end
+    private_class_method :waiting_fields
+
     # The sessions delegated by +parent_id+ (the `delegate` tool), newest
     # first, as .session_summaries rows. A running one (busy) counts against
     # session.max_children. Archived ones too.
@@ -534,6 +553,9 @@ module Samagotchi
           File.directory?(path) && (!EMPTY_DIRS.include?(name) || Dir.children(path).empty?)
         elsif name == "analytics.json"
           Array(JSON.parse(File.read(path))["turn_records"]).empty?
+        # Cards and notices from before any turn (Bridge::CardStore).
+        elsif name == "cards.json"
+          JSON.parse(File.read(path))["turns"].to_i.zero?
         else
           EMPTY_SKELETON_FILES.include?(name)
         end
@@ -613,6 +635,8 @@ module Samagotchi
     # @return [Symbol] :idle_exit or :exit_requested
     def self.run_session_loop(session_id, state_dir: nil, owner_wait: OwnerLock::DEFAULT_WAIT,
                               idle_exit_minutes: nil, poll_interval: nil)
+      # A worker inherits chi's locale (LC_ALL=C too): read files as UTF-8.
+      Utf8Default.apply!
       sd = state_dir || Session.default_state_dir
       # The spawner passed the file and level through ENV; a worker's stderr
       # is /dev/null, so warnings only reach the file.
@@ -831,6 +855,15 @@ module Samagotchi
       OwnerLock.owner(Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir))
     end
 
+    # A worker owns the session now: the one rule for whether a saved
+    # pending question waits for anyone (Session#waiting_question's live:).
+    # A chi REPL's question is its own (nothing else can answer it), and one
+    # a dead worker saved waits for no one.
+    # @return [Boolean]
+    def self.worker_live?(session_id, state_dir: nil)
+      !!session_owner(session_id, state_dir: state_dir)&.worker?
+    end
+
     # The session's owner (#session_owner), unless it is the interactive
     # TUI, which nothing else may resume, stop or delete.
     # @return [OwnerLock::Owner, nil]

data/lib/samagotchi/sessions_command.rb

@@ -146,13 +146,20 @@ module Samagotchi
         # scratch: a `chi scratch` session (deleted when its REPL ends, a
         # leftover one at the next sweep)
         # ctx_pct: how full the context was after the last turn, or nil
-        keys = %i[id short_id desc cwd project updated_at live busy owner recap parent_id archived scratch ctx_pct]
+        # waiting: the kind of question it waits on (question, approval,
+        # hook: chi answer or the web answers it), or nil; waiting_id: its
+        # id, for chi answer --question
+        keys = %i[id short_id desc cwd project updated_at live busy owner recap parent_id archived scratch ctx_pct waiting
+                  waiting_id]
         @stdout.puts JSON.generate(summaries.map { |summary| summary.slice(*keys) })
       when "tsv"
         summaries.each { |summary| @stdout.puts "#{summary[:id]}\t#{summary[:desc]}" }
       else
         summaries.each do |summary|
-          state = summary[:busy] ? "running" : (summary[:live] ? "live" : summary[:status].to_s)
+          state = if summary[:waiting] then "waiting"
+                  elsif summary[:busy] then "running"
+                  else summary[:live] ? "live" : summary[:status].to_s
+                  end
           # The saved recap's first sentence says more than the last prompt
           # (text only: tsv and json keep desc for pickers).
           desc = summary[:desc]
@@ -197,7 +204,10 @@ module Samagotchi
         ctx = Samagotchi::SessionMetrics.context_label(
           Samagotchi::SessionMetrics.saved_context_pct(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
         )
-        "#{s.id}  #{s.status.ljust(8)}  #{ctx.ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
+        # A question waits for an answer (chi answer, the web, chi --attach).
+        live = s.pending_question && Samagotchi::SessionManager.worker_live?(s.id, state_dir: state_dir)
+        status = s.waiting_question(live: !!live) ? "waiting" : s.status
+        "#{s.id}  #{status.ljust(8)}  #{ctx.ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
       end
       if project
         sessions.each { |s| @stdout.puts row.call(s) }

data/lib/samagotchi/system_prompt.rb

@@ -328,13 +328,14 @@ module Samagotchi
 
     # ── Project / rg helpers ───────────────────────────────────────────────────
 
+    # AGENT.md in the cwd, else at the top of its git work tree.
     def project_specific_description
       return nil if skip_agent_description?
 
-      path = File.join(Dir.pwd, AGENT_DESCRIPTION_FILE)
-      return nil unless File.file?(path)
+      path = agent_description_path
+      return nil unless path
 
-      content = File.read(path).strip
+      content = File.read(path, encoding: "UTF-8").strip
       return nil if content.empty?
 
       "Project specific description:\n#{content}"
@@ -342,6 +343,13 @@ module Samagotchi
       nil
     end
 
+    def agent_description_path
+      cwd = Dir.pwd
+      [cwd, MemoryPaths.work_tree_root(cwd)].compact.uniq
+        .map { |dir| File.join(dir, AGENT_DESCRIPTION_FILE) }
+        .find { |path| File.file?(path) }
+    end
+
     # Where the session runs and which project memory folder it uses. The root
     # line appears only when it differs from the cwd (a worktree or subdir).
     # The home directory is spelled out once so the model copies the right

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -5,6 +5,8 @@ require_relative "../config"
 require_relative "../model_profile"
 require_relative "../session_manager"
 require_relative "../bridge_client"
+require_relative "../parent_report"
+require_relative "../cli/exit"
 require_relative "live_region"
 require_relative "plain_surface"
 require_relative "attached_loop"
@@ -43,14 +45,40 @@ module Samagotchi
                          memories: memories, muted_memories: muted_memories)
         first_command = model && (attach || resume) ? "/model #{model}" : nil
         surface = open_surface
-        begin
-          AttachedLoop.new(client: client, screen: surface, client_id: "tui:#{Process.pid}", first_prompt: prompt,
-                           first_command: first_command, no_interrupt: no_interrupt,
-                           default_input: default_input && !prompt && !attach && !resume,
-                           wait_at_eof: !$stdin.tty?).run
+        attached = AttachedLoop.new(client: client, screen: surface, client_id: "tui:#{Process.pid}", first_prompt: prompt,
+                                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?)
+        ended = begin
+          attached.run
         ensure
           close_surface(surface)
         end
+        report_unanswered(attached.unanswered, session_id: client.session_id) if ended == :unanswered && attached.unanswered
+        ended
+      end
+
+      # A question left waiting (exit 3), in full on stderr as `chi send
+      # --wait` prints it (ParentReport), so a script or a parent agent
+      # can answer it with chi answer.
+      # @param pending [Hash] the pending question (symbol keys)
+      def report_unanswered(pending, session_id:, err: $stderr)
+        err.print("chi: #{ParentReport.question_text(pending, session_id: session_id)}")
+        err.flush
+      end
+
+      # chi's exit status after #run: 0 detached, 3 a question left waiting
+      # for an answer (input from a pipe ran out; chi --attach or chi answer
+      # answers it), 1 anything else (a failed turn, the worker gone).
+      # @param ended [Symbol] what #run returned
+      # @return [Integer]
+      def exit_status(ended)
+        case ended
+        when :detached then CLI::Exit::OK
+        when :unanswered then CLI::Exit::QUESTION
+        else CLI::Exit::FAILED
+        end
       end
 
       # A live region (Screen, with Reline drawing into it) on a terminal

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -20,6 +20,7 @@ require_relative "../model_profile"
 require_relative "../output_formatter"
 require_relative "../session_commands"
 require_relative "../session_manager"
+require_relative "../guardrails/parent_approvals"
 
 module Samagotchi
   class TerminalUI
@@ -62,6 +63,10 @@ module Samagotchi
       # @return [QuestionPrompt, nil] the question waiting for an answer
       attr_reader :question
 
+      # @return [Hash, nil] the pending question (symbol keys) #run left
+      #   waiting when it ended :unanswered
+      attr_reader :unanswered
+
       # @param client [BridgeClient]
       # @param screen [Surface] with #synchronize and #columns (a Screen, or a
       #   PlainSurface when the terminal can't show a live region)
@@ -81,7 +86,7 @@ module Samagotchi
       #   X </dev/null`): at their end, detach only once this run's prompts
       #   (the -p one too) have had their turns; if one failed, #run says so
       def initialize(client:, screen:, client_id:, first_prompt: nil, first_command: nil, no_interrupt: false,
-                     default_input: false, wait_at_eof: 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) })
@@ -90,12 +95,17 @@ module Samagotchi
         @archive_session = archive_session
         @screen = screen
         @client_id = client_id
+        # A parent agent drives this attach (AttachLauncher:
+        # ParentApprovals.parent_process?): its answers go as chi answer's,
+        # so the worker holds them to guardrails.parent_approvals.
+        @parent_answers = parent_answers
         @view = AttachedView.new(screen)
         @renderer = EventRenderer.new(@view)
         @shown_enqueued = Set.new
         @running = false
         @joined_mid_turn = false
         @attached = false
+        @early_lines = []
         @question = nil
         @answered_ids = Set.new
         @reader = nil
@@ -153,16 +163,17 @@ module Samagotchi
           when :event
             ended = safely_handle(payload)
             return ended if %i[closed failed unanswered].include?(ended)
+
+            ended = take_early_lines
+            return ended if ended
             return end_of_input if @input_ended && !own_turns_pending?
           when :line
-            if payload.nil? && @wait_at_eof && own_turns_pending?
-              # The pipe's end: this run's turns first. An open question
-              # has nothing left to answer it.
-              return unanswered_question if @question
-
-              next @input_ended = true
-            end
-            return end_of_input if submit(payload) == :detach
+            # A pipe is read at once: its lines wait for the joining
+            # snapshot, which may bring the question they answer.
+            next @early_lines << payload if @wait_at_eof && !@attached
+
+            ended = take_line(payload)
+            return ended if ended
           when :interrupt then return :detached if interrupt(payload) == :detach
           end
         end
@@ -178,6 +189,30 @@ module Samagotchi
         stream&.close
       end
 
+      # One input line (nil: the input ended).
+      # @return [Symbol, nil] how the run ends, or nil to go on
+      def take_line(line)
+        if line.nil? && @wait_at_eof && own_turns_pending?
+          # The pipe's end: this run's turns first. An open question
+          # has nothing left to answer it.
+          return unanswered_question(@question_pending) if @question
+
+          @input_ended = true
+          return nil
+        end
+        end_of_input if submit(line) == :detach
+      end
+
+      # The lines read before the snapshot came, once it has.
+      # @return [Symbol, nil] how the run ends, or nil to go on
+      def take_early_lines
+        until !@attached || @early_lines.empty?
+          ended = take_line(@early_lines.shift)
+          return ended if ended
+        end
+        nil
+      end
+
       # Render one Bridge event (string keys).
       # @return [Symbol, nil] :closed when the stream ended, :failed when the
       #   launch's first command didn't go through
@@ -217,7 +252,7 @@ module Samagotchi
         when :input_merged then merged_own_prompts(event)
         when :question_requested
           # Nothing is left to answer it with.
-          return unanswered_question if @input_ended
+          return unanswered_question(event[:pending_question]) if @input_ended
 
           ask(event[:pending_question])
         when :question_answered then question_answered(event)
@@ -557,7 +592,8 @@ module Samagotchi
         @own_failed ? :turn_failed : :detached
       end
 
-      def unanswered_question
+      def unanswered_question(pending)
+        @unanswered = pending
         detach("A question waits for an answer: chi --attach #{@client.session_id}")
         :unanswered
       end
@@ -634,6 +670,7 @@ module Samagotchi
         # What was typed at the prompt waits for the question to close.
         @set_aside = @reader&.typed_text unless @question
         @question = QuestionPrompt.new(pending)
+        @question_pending = pending
         # An edit's diff goes above, into the scrollback, once per question
         # (a join gets it from the snapshot and may get the event too).
         unless @previewed_id == @question.id
@@ -656,7 +693,8 @@ module Samagotchi
           return @screen.commit(answer.error)
         end
 
-        reply = @client.answer(id: @question.id, selected: answer.selected, freeform: answer.freeform)
+        parent = @parent_answers ? { client_id: Guardrails::ParentApprovals::CLIENT_ID } : {}
+        reply = @client.answer(id: @question.id, selected: answer.selected, freeform: answer.freeform, **parent)
         case reply.status
         when 200
           @answered_ids << @question.id
@@ -936,7 +974,8 @@ module Samagotchi
       # The snapshot's cards and between-turns notices (Bridge CardStore):
       # on join the ones since the last turn (and the running turn's), as
       # the join header shows the last exchange; on a resync only cards not
-      # shown here yet. A turn's own rows (notices, retries) are left out:
+      # shown here yet, and not the ones an earlier worker saved (a resync
+      # onto a new worker: earlier turns, not news). A turn's own rows (notices, retries) are left out:
       # the running turn's come with its parts, and the join shows no older
       # turn's steps.
       def render_snapshot_cards(entries, joining:)
@@ -947,7 +986,7 @@ module Samagotchi
 
             @screen.commit(EventRenderer.hook_notice_line(entry)) if joining && entry[:turns_since].to_i.zero?
           when "card"
-            next unless joining ? entry[:turns_since].to_i.zero? : !@renderer.card_shown?(entry[:id])
+            next unless joining ? entry[:turns_since].to_i.zero? : !entry[:earlier] && !@renderer.card_shown?(entry[:id])
 
             @renderer.render_card(entry, updated: entry[:updated] == true)
           end

data/lib/samagotchi/terminal_ui.rb

@@ -15,6 +15,7 @@ require_relative "host_registry"
 require_relative "session"
 require_relative "owner_lock"
 require_relative "engine"
+require_relative "guardrails/parent_approvals"
 require_relative "tools/memory"
 require_relative "output_formatter"
 require_relative "turn_flow"
@@ -1111,6 +1112,7 @@ module Samagotchi
     # was cancelled).
     def answer_question_widget(prompt)
       loop do
+        @choice_echoed = false
         raw = begin
           yield
         rescue Interrupt
@@ -1132,15 +1134,22 @@ module Samagotchi
         @surface.commit(answer.note) if answer.note
         unless answer.ok?
           # The read left no echo: the line shows above its error.
-          @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{raw}")
+          echo_choice(raw)
           @surface.commit(answer.error)
           next
         end
 
         begin
-          @engine.answer_question(id: prompt.id, selected: answer.selected, freeform: answer.freeform)
+          parent = parent_answers? ? { client_id: Guardrails::ParentApprovals::CLIENT_ID } : {}
+          @engine.answer_question(id: prompt.id, selected: answer.selected, freeform: answer.freeform, **parent)
           close_question_widget(prompt, prompt.answer_text(answer))
           return true
+        rescue QuestionDesk::Refused => e
+          # A parent's allow guardrails.parent_approvals doesn't let through:
+          # the question stays open for a deny (or the end of the input).
+          echo_choice(raw)
+          @surface.commit(Guardrails::ParentApprovals.message(e.reason, typed: true))
+          next
         rescue ArgumentError => e
           @surface.commit("Invalid: #{e.message}. Try again.")
           next
@@ -1151,6 +1160,12 @@ module Samagotchi
       end
     end
 
+    # Whether the answers typed here are a parent agent's (piped stdin, an
+    # agent marker): QuestionDesk holds them to guardrails.parent_approvals.
+    def parent_answers?
+      Guardrails::ParentApprovals.parent_process?
+    end
+
     def close_question_widget(prompt, outcome)
       @surface.clear_slot(:notes)
       @surface.commit(prompt.summary(outcome, paint: method(:paint)))
@@ -1159,7 +1174,19 @@ module Samagotchi
     # A ? read of its own, off a terminal (specs, pipes): $stdin.gets.
     def read_choice_line(question_prompt)
       @surface.set_slot(:editor, [question_prompt])
-      $stdin.gets
+      line = $stdin.gets
+      # A pipe doesn't echo: the line completes the ? prompt here, once,
+      # and the widget doesn't echo it again (#echo_choice).
+      unless $stdin.tty?
+        @surface.commit(line.to_s.chomp)
+        @choice_echoed = true
+      end
+      line
+    end
+
+    # The answer line above its error, unless its read echoed it already.
+    def echo_choice(raw)
+      @surface.commit("#{paint(QUESTION_PROMPT, 33)}#{raw}") unless @choice_echoed
     end
 
     # The next line submitted at the open prompt (?), nil for Ctrl-D

data/lib/samagotchi/thought_stream_splitter.rb

@@ -25,15 +25,15 @@ module Samagotchi
   # not a block and stays in `:text` (the model doesn't emit it; the system
   # prompt carries it).
   class ThoughtStreamSplitter
-    # Gemma 4's thought channel (ToolCallParser::Gemma strips the same pair).
-    GEMMA_THOUGHT_CHANNEL = { open: "<|channel>thought", close: "<channel|>" }.freeze
-
     # @return [Array<Hash>] each entry { open: String, close: String, lane: :thinking|:drop }
     def self.for_profile(profile)
       blocks = []
       # A thinking block needs a close marker to be bounded.
       blocks << { open: profile.thought_open, close: profile.thought_close, lane: :thinking } if profile.thought_close
-      blocks << GEMMA_THOUGHT_CHANNEL.merge(lane: :thinking) if profile.name == "gemma4"
+      # Gemma 4's thought channel (ToolCallParser::Gemma strips the same pair).
+      if profile.thought_channel_open
+        blocks << { open: profile.thought_channel_open, close: profile.thought_channel_close, lane: :thinking }
+      end
       blocks << { open: profile.tool_call_open, close: profile.tool_call_close, lane: :drop }
       new(blocks)
     end

data/lib/samagotchi/tool_call_parser.rb

@@ -38,8 +38,8 @@ module Samagotchi
       # Digits after the first character: plugin tools may have them
       # (Plugin::Api::TOOL_NAME).
       TOOL_CALL_BODY_RE   = /\Acall:([a-z_][a-z0-9_]{0,49})\{/
-      THOUGHT_CHANNEL_OPEN  = "<|channel>thought"
-      THOUGHT_CHANNEL_CLOSE = "<channel|>"
+      THOUGHT_CHANNEL_OPEN  = ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN
+      THOUGHT_CHANNEL_CLOSE = ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE
       CONTROL_TOKEN_START = "<|"
 
       def initialize(profile)
@@ -305,10 +305,10 @@ module Samagotchi
       end
 
       def parse(text)
-        read(text).map { |call| Tools::BuiltinCalls.build(call[:name], call[:args], raw: call[:raw]) }
+        read(text).map { |call| Tools::BuiltinCalls.build(call[:name], call[:args]) }
       end
 
-      # Each <tool_call> block as {name:, args:, raw:}: its <parameter=…>
+      # Each <tool_call> block as {name:, args:}: its <parameter=…>
       # (or <arg_key>/<arg_value>) text by lowercased key, unbuilt.
       def read(text)
         results = []
@@ -324,8 +324,7 @@ module Samagotchi
 
           body = text[body_start...close_pos]
           if (name = qwen_function_name(body))
-            params = qwen_params(body)
-            results << { name: name, args: params, raw: params.to_s }
+            results << { name: name, args: qwen_params(body) }
           end
           pos = close_pos + tool_close.length
         end

data/lib/samagotchi/tools/builtin_calls.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "../tool_declarations"
 require_relative "ask_user_question"
 
@@ -18,7 +19,7 @@ module Samagotchi
     # and the handler reading it.
     #
     # A tool that is not built in keeps its arguments whole on args: (typed
-    # by its schema at dispatch, Tools::Args) with +raw+ as its content.
+    # by its schema at dispatch, Tools::Args) with their JSON as its content.
     module BuiltinCalls
       # Per tool, what the schema alone doesn't say:
       #   content:  the property (or ordered list of keys to try) that fills
@@ -103,7 +104,7 @@ module Samagotchi
       # @param name [String]
       # @param args [Hash] string keys, as the model gave them
       # @param raw [String, nil] the call's text, the content of a tool
-      #   that isn't built in
+      #   that isn't built in when no argument could be read from it
       # @return [Hash]
       def build(name, args, raw: nil)
         name = name.to_s
@@ -139,7 +140,17 @@ module Samagotchi
       end
 
       def passthrough(name, args, raw)
-        { name: name, content: raw.nil? ? args.values.join(" ") : raw.to_s, path: nil, scope: nil, args: args }
+        { name: name, content: passthrough_content(args, raw), path: nil, scope: nil, args: args }
+      end
+
+      # The arguments as JSON, one form for every model format and Ruby
+      # version; the raw text when none could be read from it.
+      def passthrough_content(args, raw)
+        return raw.to_s if args.empty? && !raw.to_s.empty?
+
+        JSON.generate(args)
+      rescue JSON::GeneratorError
+        args.values.join(" ")
       end
     end
   end

data/lib/samagotchi/tools/builtins.rb

@@ -21,6 +21,7 @@ require_relative "send_note"
 require_relative "delegate"
 require_relative "delegate_result"
 require_relative "ask_user_question"
+require_relative "../guardrails/parent_approvals"
 
 module Samagotchi
   module Tools
@@ -72,13 +73,15 @@ module Samagotchi
         TaskCreate::NAME => lambda do |call, kctx|
           next Execute::NOT_RUN_ON_STOP if cancelled_proc(kctx).call
 
-          TaskCreate.call(call[:content], cwd: call[:cwd], env: call[:env])
+          TaskCreate.call(call[:content], cwd: call[:cwd], env: call[:env], marker_env: parent_env(kctx))
         end,
         TaskWait::NAME => lambda do |call, kctx|
           TaskWait.call(call[:content], timeout: call[:timeout], tail_lines: call[:tail_lines],
                                         done_pattern: call[:done_pattern], cancelled: cancelled_proc(kctx))
         end,
-        Execute::NAME => ->(call, kctx) { Execute.call(call[:content], cwd: call[:cwd], cancelled: cancelled_proc(kctx)) },
+        Execute::NAME => lambda do |call, kctx|
+          Execute.call(call[:content], cwd: call[:cwd], cancelled: cancelled_proc(kctx), env: parent_env(kctx))
+        end,
         RegisterReminder::NAME => lambda do |call, kctx|
           RegisterReminder.call(call[:content], reminder_store: kctx.reminder_store, description: call[:description],
                                                 interval_minutes: call[:interval_minutes])
@@ -99,6 +102,15 @@ module Samagotchi
 
       module_function
 
+      # 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
+      # wrapper. The session's id, "chi" without one.
+      def parent_env(kctx)
+        id = kctx.peers.respond_to?(:session_id) ? kctx.peers.session_id.to_s : ""
+        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id }
+      end
+
       # Stop flips the turn's controller, seen through the Engine's PeerView
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)