samagotchi 0.30.0 → 0.31.0

data/lib/samagotchi/terminal_ui.rb

@@ -254,6 +254,7 @@ module Samagotchi
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
         # Retry lines and hook notices on stderr; stdout gets the answer below.
         sink = OneShotSink.new
+        save_before_first_turn(session)
         begin
           result = @engine.run_turn(
             session,
@@ -582,6 +583,7 @@ module Samagotchi
       refresh_status_row
       # A prompt the user typed brings an archived session back to the lists.
       ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir) if prompt && !continue
+      save_before_first_turn(session)
       with_steering do
         @engine.run_turn(
           session,
@@ -809,6 +811,13 @@ module Samagotchi
       session.save
     end
 
+    # A fresh session reaches the disk before its first turn: a tool in that
+    # turn reads it from there (delegate loads its parent to start a child,
+    # "Session not found" otherwise). Later turns find it saved already.
+    def save_before_first_turn(session)
+      session.save unless Session.exist?(session.id)
+    end
+
     # A !cmd shows its own output; everything else is the model> line.
     def show_command_result(result)
       if result.shell

data/lib/samagotchi/tool_call_parser.rb

@@ -40,6 +40,8 @@ module Samagotchi
       TOOL_CALL_BODY_RE = /\Acall:([a-z_][a-z0-9_]{0,49})\{/
       THOUGHT_CHANNEL_OPEN  = ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN
       THOUGHT_CHANNEL_CLOSE = ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE
+      # Any channel's header (a thought's is THOUGHT_CHANNEL_OPEN).
+      THOUGHT_CHANNEL_HEADER = "<|channel>"
       CONTROL_TOKEN_START = "<|"
 
       def initialize(profile)
@@ -120,8 +122,43 @@ module Samagotchi
         [parse(response.to_s), nil]
       end
 
+      # Why +text+ (one generation) is corrupt, or nil. A Gemma 4
+      # generation ends a tool call with its close (the stop then comes at
+      # <|tool_response>), and thinks once, before the answer. A poisoned
+      # llama.cpp prompt cache (ggml-org/llama.cpp#27148) broke both: a
+      # call left open, then a fresh thought header and another
+      # conversation's answer.
+      def malformed(text)
+        text = text.to_s
+        return "unclosed tool call" if unclosed_tool_call?(text)
+
+        "thought header after the answer" if thought_after_answer?(strip_tool_calls(text))
+      end
+
       private
 
+      def unclosed_tool_call?(text)
+        pos = 0
+        while (open_pos = text.index(@tool_call_open, pos))
+          close_pos = text.index(@tool_call_close, open_pos + @tool_call_open.length)
+          return true unless close_pos
+
+          pos = close_pos + @tool_call_close.length
+        end
+        false
+      end
+
+      # A <|channel> header with visible text before it.
+      def thought_after_answer?(text)
+        pos = 0
+        while (header = text.index(THOUGHT_CHANNEL_HEADER, pos))
+          return true unless strip_thought(text[0...header]).strip.empty?
+
+          pos = header + THOUGHT_CHANNEL_HEADER.length
+        end
+        false
+      end
+
       # Scan forward from +start+ for the next <| sequence that is NOT the Gemma
       # string delimiter <|"|>.  Returns the position of that <| or nil if none.
       def next_real_control_token(text, start)
@@ -307,6 +344,9 @@ module Samagotchi
         read(text).map { |call| Tools::BuiltinCalls.build(call[:name], call[:args]) }
       end
 
+      # An open <tool_call> has its own recovery (#parse_with_recovery).
+      def malformed(_text) = nil
+
       # Each <tool_call> block as {name:, args:}: its <parameter=…>
       # (or <arg_key>/<arg_value>) text by lowercased key, unbuilt.
       def read(text)

data/lib/samagotchi/tool_declarations.rb

@@ -179,13 +179,13 @@ module Samagotchi
       },
       {
         name: "task_get",
-        description: "Get full metadata for a task by id. Use read on output_path to inspect command output.",
+        description: "Get a background task's metadata by its task id (from task_create or task_list; not a session id). Use read on output_path to inspect command output.",
         parameters: {
           type: "object",
           properties: {
             id: {
               type: "string",
-              description: "Task id returned by task_create"
+              description: "Task id from task_create/task_list, e.g. 20261005093000-1a2b3c4d"
             }
           },
           required: ["id"]
@@ -201,13 +201,13 @@ module Samagotchi
       },
       {
         name: "task_stop",
-        description: "Stop a running background task by id.",
+        description: "Stop a running background task by its task id (from task_create or task_list). Session ids don't work here.",
         parameters: {
           type: "object",
           properties: {
             id: {
               type: "string",
-              description: "Task id to stop"
+              description: "Task id from task_create/task_list, e.g. 20261005093000-1a2b3c4d"
             }
           },
           required: ["id"]
@@ -221,7 +221,7 @@ module Samagotchi
           properties: {
             task_id: {
               type: "string",
-              description: "Task id returned by task_create"
+              description: "Task id from task_create/task_list, e.g. 20261005093000-1a2b3c4d"
             },
             timeout: {
               type: "integer",
@@ -330,7 +330,7 @@ module Samagotchi
       },
       {
         name: "delegate",
-        description: "Hand a task to a child chi session that runs in parallel in this folder and returns only its final reply (its trace stays out of this context). The child is a normal session: it shows in the lists as a child of this one and the user can attach to it. With session, send a follow-up to one of this session's children instead. A tool call the child needs approved goes to your user as one of your own approvals; you only see how it was answered, as a line in the result. Children keep running if this turn is canceled; delegate_result waits for them later. A child stays until stopped: once its work is done, stop it with execute `chi sessions stop ID` (a follow-up with session wakes it again).",
+        description: "Hand a task to a child chi session that runs in parallel in this folder and returns only its final reply (its trace stays out of this context). The child is a normal session: it shows in the lists as a child of this one and the user can attach to it. With session, send a follow-up to one of this session's children instead. A tool call the child needs approved goes to your user as one of your own approvals; you only see how it was answered, as a line in the result. Children keep running if this turn is canceled. With wait false, chi brings each child's reply to you by itself when the child ends its turn (a delegate report, also when you are idle): don't poll it with delegate_result. To retry or redirect a child, use delegate with its session (task_* tools are for background commands, not sessions). A child stays until stopped: once its work is done, stop it with execute `chi sessions stop ID` (a follow-up with session wakes it again).",
         parameters: {
           type: "object",
           properties: {
@@ -360,7 +360,7 @@ module Samagotchi
       },
       {
         name: "delegate_result",
-        description: "Wait for a delegated child session's next reply: the child named, or this session's newest running child. Returns early if the child waits for a question the user must answer. A tool call the child needs approved goes to your user while this waits; the result says how it was answered.",
+        description: "Wait for a delegated child session's next reply: the child named, or this session's newest running child (name the child when a delegate report is about it). A delegate report already carries the reply: don't call this for it. Returns early if the child waits for a question the user must answer. A tool call the child needs approved goes to your user while this waits; the result says how it was answered.",
         parameters: {
           type: "object",
           properties: {

data/lib/samagotchi/tools/delegate.rb

@@ -5,6 +5,7 @@ require_relative "../config"
 require_relative "../model_profile"
 require_relative "peers"
 require_relative "delegate_wait"
+require_relative "../child_reports"
 
 module Samagotchi
   # Loaded on first use: session_manager requires terminal_ui, which
@@ -30,7 +31,7 @@ module Samagotchi
       STARTING_GRACE_SECONDS = 15
       # The memory every child starts with, scoped so a project memory of
       # the same name cannot shadow it.
-      CHILD_MEMORIES = ["system/delegated"].freeze
+      CHILD_MEMORIES = [Session::DELEGATE_MEMORY].freeze
 
       def self.name = NAME
 
@@ -62,12 +63,20 @@ module Samagotchi
         return note + DelegateWait.call(child_id, peers: peers, timeout: timeout) if wait
 
         started = session.to_s.strip.empty? ? "Started a delegate session" : "Sent the follow-up to delegate #{child_id[0, 8]}"
-        "#{note}session: #{child_id}\nstatus: running\n#{started}; delegate_result waits for its reply. " \
+        "#{note}session: #{child_id}\nstatus: running\n#{started}; #{running_hint} " \
           "It shows in chi sessions list and the web as a child of this session; the user can attach to it."
       rescue ArgumentError => e
         "Error: #{e.message}"
       end
 
+      # How the reply of a child left running comes back.
+      def self.running_hint
+        return "delegate_result waits for its reply." if ChildRing.mode == "off"
+
+        "chi brings its reply to you by itself when it ends its turn (a delegate report); don't poll with delegate_result."
+      end
+      private_class_method :running_hint
+
       # @return [String] the new child's id, or an Error: line
       def self.start_child(task, parent:, model:, state_dir:)
         if parent.parent_id
@@ -84,8 +93,8 @@ module Samagotchi
 
         child = SessionManager.spawn_session(prompt: task, working_directory: parent.working_directory,
                                              model_name: child_model(model, parent), memories: CHILD_MEMORIES,
-                                             parent_id: parent.id, state_dir: state_dir)
-        DelegateWait.mark_started(parent.id, child)
+                                             parent_id: parent.id, delegate: true, state_dir: state_dir)
+        DelegateWait.mark_started(parent.id, child, state_dir: state_dir)
         [child.id, child.model_warning]
       end
       private_class_method :start_child

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "../atomic_file"
+require_relative "../session"
+
+module Samagotchi
+  module Tools
+    # What a parent was already told about one delegate child: the newest
+    # reply it was given (+reply_file+, ReplyWait's cursor) and the child as
+    # it was then (+messages+, +question_id+, +last_turn+: ReplyWait's
+    # baseline). nil +messages+ means no baseline.
+    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages) do
+      def self.empty = new(reply_file: nil, last_turn: nil, question_id: nil, messages: nil)
+
+      # @param baseline [Hash, nil] ReplyWait.baseline_of's
+      def with_baseline(baseline)
+        b = baseline || {}
+        with(messages: b[:messages], question_id: b[:question_id], last_turn: b[:last_turn])
+      end
+
+      # @return [Hash, nil] ReplyWait's baseline:, nil when none was taken
+      def baseline
+        return nil if messages.nil?
+
+        { messages: messages, question_id: question_id, last_turn: last_turn }
+      end
+
+      def to_json_hash = to_h.transform_keys(&:to_s).compact
+    end
+
+    # The parent's cursors, one per child, in <parent dir>/delegates.json, so
+    # a respawned worker (or a REPL resuming the session) doesn't hand the
+    # model a reply it already had. Written by whoever owns the parent (its
+    # worker, or the REPL its kernel runs in), so a Mutex is enough for its
+    # turn thread vs its loop thread; the file is replaced whole.
+    module DelegateCursors
+      FILE = "delegates.json"
+      LOCK = Mutex.new
+
+      module_function
+
+      # @return [DelegateCursor] the child's cursor, empty when none
+      def get(parent_id, child_id, state_dir:)
+        get_from(read(parent_id, state_dir: state_dir), child_id)
+      end
+
+      # Read, change and write one child's cursor under the lock.
+      # @yieldparam cursor [DelegateCursor]
+      # @yieldreturn [DelegateCursor]
+      # @return [DelegateCursor] the new cursor
+      def update(parent_id, child_id, state_dir:)
+        LOCK.synchronize do
+          all = read(parent_id, state_dir: state_dir)
+          cursor = yield get_from(all, child_id)
+          all[child_id] = cursor.to_json_hash
+          write(parent_id, all, state_dir: state_dir)
+          cursor
+        end
+      end
+
+      def get_from(all, child_id)
+        data = all[child_id]
+        return DelegateCursor.empty unless data.is_a?(Hash)
+
+        DelegateCursor.new(reply_file: data["reply_file"], last_turn: data["last_turn"],
+                           question_id: data["question_id"], messages: data["messages"])
+      end
+
+      def path(parent_id, state_dir:)
+        File.join(Session.session_dir(parent_id, state_dir: state_dir), FILE)
+      end
+
+      # @return [Hash{String => Hash}] child id → cursor fields; {} when none
+      #   or unreadable
+      def read(parent_id, state_dir:)
+        data = JSON.parse(File.read(path(parent_id, state_dir: state_dir)))
+        data.is_a?(Hash) ? data : {}
+      rescue Errno::ENOENT, JSON::ParserError
+        {}
+      end
+
+      def write(parent_id, all, state_dir:)
+        file = path(parent_id, state_dir: state_dir)
+        FileUtils.mkdir_p(File.dirname(file))
+        AtomicFile.write(file, JSON.generate(all))
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/delegate_wait.rb

@@ -6,18 +6,18 @@ require_relative "../parent_report"
 require_relative "output_guardrails"
 require_relative "peers"
 require_relative "delegate_relay"
+require_relative "delegate_cursor"
 
 module Samagotchi
   module Tools
     # Waiting for a delegated session's next reply, shared by delegate and
     # delegate_result: ReplyWait in the tools' words, with the status words
-    # `chi send --wait` and `chi answer` use (ParentReport.status), with a cursor per
-    # child (the newest reply this parent was already given) and the child
-    # as it was before the message went in (ReplyWait's baseline), so a turn
-    # that ends before the wait's first look (a fast failure) still ends it.
-    # Both live in this process (a worker runs one session), keyed by parent
-    # and child; a worker respawn loses them, which only repeats the newest
-    # reply once or waits for a later turn.
+    # `chi send --wait` and `chi answer` use (ParentReport.status), with a
+    # DelegateCursor per child: the newest reply this parent was already
+    # given, and the child as it was when the parent last heard from it or
+    # sent it a message (ReplyWait's baseline), so a turn that ends before
+    # the wait's first look (a fast failure) still ends it. The cursors are
+    # on disk (DelegateCursors), so a respawned worker doesn't repeat a reply.
     module DelegateWait
       TIMEOUT_DEFAULT = 600
       POLL_INTERVAL = 0.5
@@ -32,16 +32,6 @@ module Samagotchi
 
       module_function
 
-      # @return [Hash{Array(String, String) => String}] [parent id, child id] → newest reply filename given
-      def seen
-        @seen ||= {}
-      end
-
-      # @return [Hash{Array(String, String) => Hash}] [parent id, child id] → ReplyWait baseline taken before sending
-      def baselines
-        @baselines ||= {}
-      end
-
       # @return [Hash{Array(String, String) => Array<String>}] [parent id,
       #   child id] → outcome lines of that child's approvals relayed while
       #   the parent waited on another child, for its next result
@@ -69,18 +59,20 @@ module Samagotchi
         cancelled = -> { peers.cancelled? }
         relay = peers.respond_to?(:relay) ? peers.relay : nil
         others = relay && others_for(peers.session_id, child_id, relay, sd)
-        baseline = baselines[key]
+        cursor = DelegateCursors.get(peers.session_id, child_id, state_dir: sd)
+        baseline = cursor.baseline
         left = timeout.to_i
         outcomes = relayed_outcomes.delete(key) || []
         loop do
           started = monotonic
-          wait = ReplyWait.call(child_id, state_dir: sd, cursor: seen[key], timeout: [left, 0].max,
+          wait = ReplyWait.call(child_id, state_dir: sd, cursor: cursor.reply_file, timeout: [left, 0].max,
                                           poll_interval: poll_interval, cancelled: cancelled, baseline: baseline,
                                           owner_grace: owner_grace, interject: others && -> { others.poll })
           left -= monotonic - started
           unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
             outcomes.concat(relayed_outcomes.delete(key) || [])
-            return with_outcomes(finish(wait, child_id, key: key, timeout: timeout), outcomes)
+            advance(peers.session_id, child_id, wait, state_dir: sd)
+            return with_outcomes(finish(wait, child_id, timeout: timeout), outcomes)
           end
 
           outcome = DelegateRelay.call(child_id, wait.question, relay: relay, state_dir: sd, more: others&.count.to_i)
@@ -118,24 +110,43 @@ module Samagotchi
 
       def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      REPORT_NEXT_REPLY = "chi brings the child's next reply here by itself; don't wait for it with delegate_result."
+
+      # Outcomes that tell the parent something about the child's state.
+      REPORTED = %i[done no_reply error stopped waiting_for_answer worker_gone].freeze
+
+      # Move the parent's cursor past what +wait+ reported: the reply it
+      # gave, and the child as that same look loaded it (a fresh load could
+      # swallow a turn that ended in between), so a later wait looks for a
+      # later turn and a question already reported isn't reported again.
+      # Nothing moves on a timeout or a cancel.
+      # @param wait [ReplyWait::Result]
+      # @return [DelegateCursor, nil] the new cursor
+      def advance(parent_id, child_id, wait, state_dir:)
+        return nil unless REPORTED.include?(wait.status) && wait.session
+
+        DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |cursor|
+          cursor = cursor.with(reply_file: wait.file) if wait.status == :done
+          cursor.with_baseline(ReplyWait.baseline_of(wait.session))
+        end
+      end
+
       # The tool result for how the wait ended.
       # @param wait [ReplyWait::Result]
-      # @param key [Array(String, String)] [parent id, child id]
+      # @param report [Boolean] a delegate report's text (ChildReports), not
+      #   the tool's: a question's last line says chi brings the next reply
       # @return [String]
-      def finish(wait, child_id, key:, timeout:)
-        # The turn sent to is handed over: a later wait looks for a later one.
-        baselines.delete(key) if %i[done no_reply].include?(wait.status)
+      def finish(wait, child_id, timeout:, report: false)
         status = ParentReport.status(wait)
         case wait.status
         when :done
-          seen[key] = wait.file
           reply_result(child_id, status, wait.text)
         when :error
           result(child_id, status, "the child's worker failed: #{wait.text}; its session shows what happened")
         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))
+          result(child_id, status, waiting_text(child_id, wait.question, report: report))
         when :canceled
           canceled_result(child_id)
         when :no_reply
@@ -153,14 +164,18 @@ module Samagotchi
       # child's baseline before the follow-up goes in.
       # @param child [Session] the child as loaded before sending
       def mark_seen(parent_id, child, state_dir:)
-        seen[[parent_id, child.id]] = ReplyWait.newest_reply(child.id, state_dir: state_dir)
-        baselines[[parent_id, child.id]] = ReplyWait.baseline_of(child)
+        newest = ReplyWait.newest_reply(child.id, state_dir: state_dir)
+        DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
+          cursor.with(reply_file: newest).with_baseline(ReplyWait.baseline_of(child))
+        end
       end
 
       # A new child's baseline: as spawned, before its first turn ran.
       # @param child [Session] the session spawn_session returned
-      def mark_started(parent_id, child)
-        baselines[[parent_id, child.id]] = ReplyWait.baseline_of(child, question_id: nil)
+      def mark_started(parent_id, child, state_dir:)
+        DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
+          cursor.with_baseline(ReplyWait.baseline_of(child, question_id: nil))
+        end
       end
 
       def reply_result(child_id, status, text)
@@ -188,13 +203,17 @@ module Samagotchi
       # decide (it isn't relayed: Continue grants no permission): continue
       # it with chi answer through execute, send a follow-up instead, or
       # report back.
-      def waiting_text(child_id, pending)
+      # A report's last line differs (+report+): "waits again" made models
+      # call delegate_result right after answering Continue.
+      def waiting_text(child_id, pending, report: false)
         text = "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id)}"
         if ParentReport.continue?(pending)
           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"
         end
+        return "#{text}#{REPORT_NEXT_REPLY}" if report
+
         "#{text}delegate_result #{child_id} waits again once it is answered."
       end
 

data/lib/samagotchi/tools/task_runtime.rb

@@ -154,7 +154,7 @@ module Samagotchi
 
       def get_record(task_id)
         record = load_record(task_id)
-        return [nil, "Error: task not found: #{task_id}"] unless record
+        return [nil, not_found(task_id)] unless record
 
         [refresh_record(record), nil]
       rescue StandardError => e
@@ -180,7 +180,7 @@ module Samagotchi
       # @param by [String] "model" (task_stop) or "user" (the web's button)
       def stop_task(task_id, by:)
         record = load_record(task_id)
-        return [nil, "Error: task not found: #{task_id}"] unless record
+        return [nil, not_found(task_id)] unless record
 
         refreshed = refresh_record(record)
         return [refreshed, nil] unless refreshed["status"] == "running"
@@ -223,7 +223,26 @@ module Samagotchi
         record
       end
 
+      # A session id (a uuid) is never a task's: task ids are a timestamp
+      # and hex (20261005093000-1a2b3c4d).
+      SESSION_ID_SHAPE = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/
+
+      # A model mixing up ids (Qwen passes session ids to task_get and
+      # task_stop) is told which kind it passed and where task ids come from.
+      def not_found(task_id)
+        error = "Error: task not found: #{task_id}"
+        return error unless SESSION_ID_SHAPE.match?(task_id.to_s)
+
+        "#{error} (that is a session id; task ids come from task_create, and task_list lists them)"
+      end
+
+      # Exactly the shape generate_task_id makes. Anything else (../x, an
+      # absolute path) is no task, so a model's id never leaves tmp/tasks.
+      TASK_ID_SHAPE = /\A\d{14}-\h{8}\z/
+
       def load_record(task_id)
+        return nil unless TASK_ID_SHAPE.match?(task_id.to_s)
+
         path = metadata_path(task_id)
         return nil unless File.exist?(path)
 

data/lib/samagotchi/tools/task_wait.rb

@@ -34,7 +34,7 @@ module Samagotchi
 
         loop do
           record, error = TaskRuntime.get_record(task_id)
-          return "Error: #{error}" if error
+          return error if error
 
           status = record.fetch("status")
           return finished_response(record, tail_lines) unless status == "running"
@@ -64,7 +64,7 @@ module Samagotchi
       # normal finished result. Only a task still running says so.
       def self.cancelled_response(task_id, tail_lines, started)
         record, error = TaskRuntime.get_record(task_id)
-        return "Error: #{error}" if error
+        return error if error
         return finished_response(record, tail_lines) unless record.fetch("status") == "running"
 
         note = [

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -1522,8 +1522,14 @@ module Samagotchi
 
           message = { role: norm_role, content: stripped }
           # Merged into the running turn (Steer::INPUT_KIND): part of it,
-          # read by step +step+.
-          message.merge!(merged: true, step: steer_step(list, index)) if norm_role == "user" && Samagotchi::Steer.input?(m)
+          # read by step +step+; a wake turn's report starts its turn
+          # (Steer.turn_prompt?). Its sender (a delegate report, chi send):
+          # the page's label.
+          if norm_role == "user" && Samagotchi::Steer.input?(m)
+            message.merge!(merged: true, step: steer_step(list, index)) unless Samagotchi::Steer.turn_prompt?(m)
+            source = (m[:source] || m["source"]).to_s
+            message[:source] = source unless source.empty?
+          end
           # The turn it started (Engine): the page pairs it with that turn's
           # record by this, not by its place.
           turn_id = m[:turn_id] || m["turn_id"]

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

@@ -46,7 +46,7 @@ import {
   appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, mergeTiming, normalizeTiming, STOPPED_LINE_CLASS, turnTimingText,
 } from "./timing.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, displayWait, dropEarlyRestores, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -142,8 +142,11 @@ let selectSeq = null;
 // new turn has started on it yet: see followWokenWorker.
 let streamFromGuess = false;
 // The last input_merged had an origin with no bubble: its merged text
-// (pending_input_merged) gets one.
+// (pending_input_merged) gets one ("report": a delegate report's).
 let unmatchedMerge = false;
+// The running turn is one chi ran for delegate reports and its report
+// bubble isn't drawn yet: that bubble starts the turn.
+let wakeStart = false;
 // The enqueued_ids this page sent (from the /turn acks): only these come back
 // into the composer when their turn fails.
 const sentIds = new Set();
@@ -710,6 +713,7 @@ function resetTurnView() {
   questionCards.removeQuestion();
   questionCards.forgetContinue();
   unmatchedMerge = false;
+  wakeStart = false;
   setTurnRunning(false);
   releaseDisplayWait();
 }
@@ -1067,14 +1071,18 @@ function untaggedOwnBubble(prompt) {
 // Returns the bubble of the turn a turn_started starts (the stage takes it
 // into its prompt line), else null.
 function applyPromptOps(event) {
-  const ops = promptOps(event, { myId: clientId, known: (id) => !!bubbleById(id), unmatchedMerge });
+  if (event.type === "turn_started") wakeStart = !!event.continue && isReportClient(event.origin?.client_id);
+  const ops = promptOps(event, { myId: clientId, known: (id) => !!bubbleById(id), unmatchedMerge, wakeStart });
   if (event.type === "input_merged") unmatchedMerge = false;
   if (event.type === "pending_input_merged") unmatchedMerge = false;
   let started = null;
   for (const op of ops) {
-    if (op.op === "add") {
+    if (op.op === "report") {
+      unmatchedMerge = "report";
+    } else if (op.op === "add") {
       const bubble = makeUserBubble(op.prompt, { state: op.state, label: op.label, enqueuedId: op.enqueuedId, images: op.images });
       if (op.state === "started") started = bubble;
+      if (event.type === "pending_input_merged") wakeStart = false;
     } else if (op.op === "tag") {
       if (bubbleById(op.enqueuedId)) continue;
       const echo = untaggedOwnBubble(op.prompt);

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

@@ -26,12 +26,19 @@ export function noteHtml(note) {
 // Who a steer names as its sender: a plugin's own label, chi's sender ids
 // in words (the TUI's Formatting#steer_sender agrees;
 // spec/shared/labels_matrix.json). "": no one named.
-const STEER_SENDERS = { parent_agent: "parent agent", chi_send: "chi send", plugin_send: "plugin" };
+const STEER_SENDERS = { parent_agent: "parent agent", chi_send: "chi send", plugin_send: "plugin", delegate_report: "delegate report" };
 export function steerSender(source) {
   const id = String(source ?? "");
   return STEER_SENDERS[id] || id;
 }
 
+// The label a user-role line gets on reload for who sent it, by its saved
+// source: a delegate report (the live bubble's clientLabel of child:<id>);
+// null for the user's own (and anything else, as before).
+export function sourceLabel(source) {
+  return source === "delegate_report" ? steerSender(source) : null;
+}
+
 // A plugin's steer (a nudge put into the running turn): one line that
 // names who nudged the model, its text collapsed under it. +bubble+: on its
 // own between bubbles (no step holds it), not a row of a step.

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

@@ -12,7 +12,9 @@ export function notifyState({ hasNotification, secureContext, permission, wanted
   return wanted && permission === "granted" ? "on" : "off";
 }
 
-// A finished turn shorter than this was watched: no "done".
+// A finished turn shorter than this was watched: no "done". Not a turn
+// chi ran for a delegate child's report (last_turn origin delegate_report):
+// nobody started it, so nobody watched it.
 export const DONE_MIN_SECONDS = 10;
 
 // The step-limit question (kind "continue": a turn ran out of iterations
@@ -66,7 +68,7 @@ export function attentionFor(prev, next) {
   if (next.parent_id) return null;
   const key = `${next.id}:${turn.ended_at}`;
   if (turn.outcome === "failed") return { reason: "failed", sessionId: next.id, key };
-  if (turn.outcome === "completed" && Number(turn.seconds) >= DONE_MIN_SECONDS) {
+  if (turn.outcome === "completed" && (Number(turn.seconds) >= DONE_MIN_SECONDS || turn.origin === "delegate_report")) {
     return { reason: "done", sessionId: next.id, key };
   }
   return null;