samagotchi 0.29.0 → 0.31.0

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/execute.rb

@@ -21,6 +21,8 @@ module Samagotchi
       STOP_POLL_INTERVAL_SEC = 0.05
       WAIT_SLICE_SEC = 0.2
       NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
+      # The first words of a command the user's Stop killed.
+      STOPPED_BY_USER = "Error: command stopped by the user"
       TIMEOUT_HINT = "(killed at the limit; for a long command use task_create, then task_wait)"
       # How long the output may stay open once the shell has exited: a
       # `server &` child keeps the pipes, and the read would never end.
@@ -67,7 +69,7 @@ module Samagotchi
         # a long command, and return whatever it printed before it was killed.
         stopped_result("Error: command timed out after #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
       rescue CommandCancelled => e
-        stopped_result("Error: command stopped by the user after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
+        stopped_result("#{STOPPED_BY_USER} after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue StandardError => e
         "Error: #{e.message}"
       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.29.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/activity.js

@@ -10,7 +10,8 @@ export const ROW_STATUS = Object.freeze({
   RUNNING: "running",
   OK: "ok",
   ERROR: "error",
-  // A task_wait the user's Stop ended (the task itself runs on).
+  // A call the user's Stop cut: a task_wait (the task itself runs on), a
+  // killed or never-started command. Not a failure.
   STOPPED: "stopped",
   // A call a guardrail denied (a hook, the guardrails bundle, a parent's
   // or the user's Deny): it never ran, and it isn't a failed call either.

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

@@ -43,10 +43,10 @@ import { applySessionEvent, heldOrder, listedSessions, sortedByUpdated, stoppedB
 import { createNotifications } from "./notifications.js";
 import { restartConfirmText, versionNotice, workerBadge } from "./update_notice.js";
 import {
-  appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, mergeTiming, normalizeTiming, turnTimingText,
+  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();
 }
@@ -960,9 +964,11 @@ function appendChunk(text) {
   if (follow) historyEl.scrollTop = historyEl.scrollHeight;
 }
 
-function addEndBubble(text) {
+// +stopped+: a stop someone chose (a cancel, the session's stop), drawn in
+// the stopped style (timing.js STOPPED_LINE_CLASS); else a failure's line.
+function addEndBubble(text, { stopped = false } = {}) {
   const div = document.createElement("div");
-  div.className = "bubble cancel";
+  div.className = stopped ? STOPPED_LINE_CLASS : "bubble cancel";
   div.textContent = text;
   appendToHistory(div);
   if (!turnDom.holds?.()) historyEl.scrollTop = historyEl.scrollHeight;
@@ -980,7 +986,7 @@ function emptyAnswerEl(emptyAnswer) {
 // Everything a turn's end (completed, canceled, failed) closes: then its
 // end line (+endText+, the cancel or failed line), then the step cards that
 // left the collapsed block (card.js leavesBlock), where a reload puts them.
-function endTurnView(kind, endText = null, { emptyAnswer = null } = {}) {
+function endTurnView(kind, endText = null, { emptyAnswer = null, stopped = false } = {}) {
   setTurnRunning(false);
   // Every ended turn has a record (completed, canceled, failed); a worker
   // gone mid-turn is re-rendered (resync), which counts again.
@@ -991,7 +997,7 @@ function endTurnView(kind, endText = null, { emptyAnswer = null } = {}) {
   const kept = turnDom.turnEnded({ kind, endNote, emptyAnswer: !!emptyAnswer }) || [];
   if (endNote && !endNote.isConnected) appendToHistory(endNote);
   finishLiveTurnTiming(null, { canceled: kind === "canceled" });
-  if (endText) addEndBubble(endText);
+  if (endText) addEndBubble(endText, { stopped });
   if (kept.length) {
     kept.forEach((el) => appendToHistory(el));
     if (!turnDom.holds?.()) historyEl.scrollTop = historyEl.scrollHeight;
@@ -1065,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);
@@ -1653,7 +1663,7 @@ function workerGone(id, { opened = true } = {}) {
   const stopped = stoppingId === id;
   const endText = workerGoneText({ turnRunning, stopped });
   if (endText) {
-    endTurnView("gone", endText);
+    endTurnView("gone", endText, { stopped });
     if (!stopped) setLiveStatus("idle");
   }
   if (current.owner === "worker") current.owner = null;
@@ -1770,7 +1780,7 @@ const streamHandlers = {
     }
   },
   turn_canceled: (data) => {
-    endTurnView("canceled", cancelLineText(data.cancellation_reason || "", data.cancelled_by));
+    endTurnView("canceled", cancelLineText(data.cancellation_reason || "", data.cancelled_by), { stopped: true });
     setLiveStatus("idle");
     refreshTimingFromSession();
   },

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

@@ -82,6 +82,24 @@ export function stepTextHtml(text) {
   return out + escapeHtml(String(text).slice(at));
 }
 
+function heredocLabel({ tag, lines }) {
+  return `${tag} · ${Number(lines)} ${lines === 1 ? "line" : "lines"}`;
+}
+
+// A step's heredoc chip: the first heredoc's tag and size, and "+N" for
+// the others when the step has more (CommandSteps' heredocs:, as gh api
+// -f body="$(cat <<EOF …)" -f title="$(cat <<EOF …)"), as a title with
+// more steps reads "+N"; the hover lists them all. "" without one.
+export function heredocChip(step) {
+  if (!step?.heredoc) return "";
+  const all = Array.isArray(step.heredocs) && step.heredocs.length > 1 ? step.heredocs : [step.heredoc];
+  const more = all.length > 1 ? ` +${all.length - 1}` : "";
+  const title = all.length > 1
+    ? `${all.length} heredocs: ${all.map(heredocLabel).join(", ")}; their text in the raw command`
+    : "a heredoc: its text in the raw command";
+  return `<span class="step-chip heredoc" title="${escapeHtml(title)}">${escapeHtml(heredocLabel(all[0]))}${more}</span>`;
+}
+
 // The steps as a list: a label as a small heading above its step, the op
 // that links a step to the one before, its text, its limit and heredoc
 // as chips (beside the text, below it when the row is narrow).
@@ -89,11 +107,7 @@ export function stepsHtml(steps) {
   const items = steps.map((step) => {
     const label = step.label ? `<li class="step-label">${escapeHtml(step.label)}</li>` : "";
     const limit = step.limit ? `<span class="step-chip" title="output limited">${escapeHtml(step.limit)}</span>` : "";
-    const heredoc = step.heredoc
-      ? `<span class="step-chip heredoc" title="a heredoc: its text in the raw command">${escapeHtml(step.heredoc.tag)} · ` +
-        `${Number(step.heredoc.lines)} ${step.heredoc.lines === 1 ? "line" : "lines"}</span>`
-      : "";
-    return `${label}<li class="activity-step">${opHtml(step.op)}<span class="step-body"><code>${stepTextHtml(step.text)}</code>${limit}${heredoc}</span></li>`;
+    return `${label}<li class="activity-step">${opHtml(step.op)}<span class="step-body"><code>${stepTextHtml(step.text)}</code>${limit}${heredocChip(step)}</span></li>`;
   });
   return `<ol class="activity-steps">${items.join("")}</ol>`;
 }

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/index.html

@@ -122,6 +122,8 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .bubble.user blockquote:last-child{margin-bottom:0}
 .bubble.tool{border-left:3px solid var(--ok);background:var(--bg-panel);font-size:13px;color:var(--text-2)}
 .bubble.cancel{border-left:3px solid var(--danger);background:color-mix(in srgb,var(--danger) 8%,var(--bg-panel));color:var(--danger-text);font-size:13px}
+/* A stop someone chose (a cancel, the session's stop): the ■ STOPPED rows' colours, not an error's. */
+.bubble.cancel.stopped{border-left-color:var(--warn);background:color-mix(in srgb,var(--warn) 8%,var(--bg-panel));color:var(--warn-text)}
 .bubble.recap{border-left:3px solid var(--think-text);background:color-mix(in srgb,var(--think) 6%,var(--bg-panel));font-size:13px}
 .bubble.recap summary{cursor:pointer;color:var(--think-text);font-size:12px}
 .bubble.recap .recap-body{white-space:pre-wrap;margin-top:6px}
@@ -236,6 +238,8 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .gen>summary::-webkit-details-marker{display:none}
 .gen>summary::before{content:"▸ ";color:var(--text-faint)}
 .gen[open]>summary::before{content:"▾ "}
+/* Open, a step whose label starts with its body's first words (turn_view.js labelParts) says only its calls. */
+.gen[open]>summary.repeats>:is(.gen-head,.gen-sep){display:none}
 /* A step with a failed call (status error): its chevron in the danger colour. */
 .gen.has-failed>summary::before{color:var(--danger)}
 .gen.live{border-top-color:transparent;background:var(--accent-tint);border-radius:8px;padding:6px 9px 8px calc(9px + var(--step-indent));margin-left:-9px;margin-right:-9px}
@@ -545,6 +549,7 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .turn-stage[data-phase="no answer"] .ts-mark,.turn-stage[data-phase="no answer"] .ts-phase{color:var(--text-muted)}
 .turn-stage[data-phase="waiting for you"] .ts-mark{background:var(--warn)}
 .ts-phase{color:var(--accent);font-weight:600}
+.ts-step:empty{display:none}
 .ts-timing{min-width:0;overflow:hidden;text-overflow:ellipsis}
 .ts-timing .turn-timing{margin:0;font-size:12px;color:var(--text-muted);display:inline}
 .ts-mini{min-width:0;overflow:hidden;text-overflow:ellipsis;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-2)}
@@ -579,14 +584,13 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .ts-spin{flex:none;width:11px;height:11px;border:2px solid var(--warn);border-right-color:transparent;border-radius:50%;animation:init-spin .8s linear infinite}
 .ts-idle{flex:none;width:11px;height:11px;border:2px solid var(--border-strong);border-radius:50%}
 .ts-tool{flex:none;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;font-weight:600;color:var(--accent)}
-.ts-tool.exec{color:var(--think-text)}
-.ts-tool.edit{color:var(--ok-text)}
 .ts-title{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;color:var(--text-2)}
 .ts-title.quiet{font-family:inherit;font-style:italic;color:var(--text-faint)}
 .ts-trail{height:18px;display:flex;gap:10px;overflow:hidden;font-size:12px;line-height:18px;color:var(--text-faint);white-space:nowrap}
 .ts-trail-item{flex:none;max-width:36ch;overflow:hidden;text-overflow:ellipsis}
-.ts-trail-item.error{color:var(--danger-text)}
+.ts-trail-item:is(.error,.blocked){color:var(--danger-text)}
 .ts-trail-item.warn{color:var(--warn-text)}
+.ts-trail-item.stopped{color:var(--warn-text);opacity:.8}
 .ts-trail-item.info,.ts-trail-item.steer{color:var(--accent)}
 .ts-trail-item.none{font-style:italic}
 /* A card waits: the tool row and trail give it their room. */
@@ -617,10 +621,14 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .ts-ticks{display:flex;flex-wrap:nowrap;justify-content:flex-end;overflow:hidden;gap:2px;flex:0 1 auto;min-width:0}
 .ts-tick{flex:none}
 .ts-tick{width:5px;height:12px;border-radius:1.5px;background:var(--text-faint);opacity:.55;cursor:pointer}
-.ts-tick.exec{background:var(--think);opacity:.85}
-.ts-tick.edit{background:var(--ok);opacity:.85}
-.ts-tick.other{background:var(--accent);opacity:.7}
+/* exec and edit are the rows' tool blue (purple is thinking's, green a done ✓'s); other a quieter blue-grey. */
+.ts-tick:is(.exec,.edit){background:var(--accent);opacity:.85}
+.ts-tick.other{background:var(--narr);opacity:.7}
 .ts-tick.error{background:var(--danger);opacity:1}
+/* A call a guardrail blocked: its ✕ BLOCKED row's red. */
+.ts-tick.blocked{background:var(--danger-text);opacity:1}
+/* A call the user's Stop cut: the ■ STOPPED rows' amber, still (running blinks). */
+.ts-tick.stopped{background:var(--warn-text);opacity:.8}
 .ts-tick.running{background:var(--warn);opacity:1;animation:ts-blink 1s ease-in-out infinite}
 @keyframes ts-blink{50%{opacity:.35}}
 .ts-cloud-body{max-height:calc(var(--stage-max,60vh) * .62);overflow:auto;scrollbar-width:thin;border-left:1px solid var(--border);margin-left:6px;padding-left:10px}

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;

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

@@ -76,6 +76,20 @@ export function toolKind(name) {
   return "other";
 }
 
+// A finished call's mark in the trail, as its row's (index.html
+// .activity-status): error and blocked ✕, stopped (a Stop cut it) ■, else ✓.
+export function trailMark(status) {
+  if (status === "error" || status === "blocked") return "\u2715";
+  if (status === "stopped") return "\u25A0";
+  return "\u2713";
+}
+
+// A finished call's tone in the trail, its class as its row's colour:
+// error and blocked (a guardrail's deny) red, stopped amber, else none.
+export function trailTone(status) {
+  return status === "error" || status === "blocked" || status === "stopped" ? status : "";
+}
+
 function rowTitle(row) {
   return row.title || row.params || "";
 }
@@ -116,6 +130,9 @@ const NO_ANSWER = "no answer";
 //            else "…";
 //   tool     the running call ({name, title, kind}, and command: its full
 //            command when it has one; taskId and key: a task_wait's) or null;
+//   quiet    the now row's word while no call runs: "writing…" while the
+//            step's text streams, else "thinking…"; "" once the turn has
+//            ended (nothing happens now);
 //   trail    the last three finished calls, newest last (a file's title
 //            without its dir; command as for tool);
 //   ticks    one per call: {kind, status, step (the gen's index)}.
@@ -146,6 +163,7 @@ export function liveSlots(turn, { narration = "", thinking = "", pending = false
     phase,
     step: ended ? gens.filter((g) => !g.answer || g.thinking || g.tools.length).length : gens.length,
     headline,
+    quiet: ended ? "" : current?.text && !current.textDone ? "writing…" : "thinking…",
     tool: running ? withTask(withCommand({ name: toolName(running), title: rowTitle(running), kind: toolKind(running.tool) }, running), running) : null,
     trail,
     ticks: rows.map(({ row, step }) => ({ kind: toolKind(row.tool), status: row.status, step })),

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

@@ -11,7 +11,7 @@
 // reload. Slots are patched in place, never rebuilt from HTML: a selection
 // and annotate survive. The rules are pure in stage_model.js.
 import { createTurnView } from "./turn_view.js";
-import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
+import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor, trailMark, trailTone } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 
@@ -189,20 +189,26 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     stage.dataset.phase = slots.phase;
     mark.textContent = MARKS[slots.phase] || "";
     phaseEl.textContent = slots.phase;
-    stepEl.textContent = endKind ? `${slots.step} step${slots.step === 1 ? "" : "s"}` : `step ${slots.step}`;
+    const steps = `${slots.step} step${slots.step === 1 ? "" : "s"}`;
 
     drawHeadline(slots.headline);
-    drawNow(slots.tool, gen);
+    drawNow(slots.tool, slots.quiet);
     drawTrail(slots.trail);
     drawTicks(slots.ticks);
     const calls = slots.ticks.length;
-    const elapsed = endKind ? formatDuration(endedAt - startedAt) : "";
-    chipLabel.textContent = `${slots.step} step${slots.step === 1 ? "" : "s"} · ${calls} tool call${calls === 1 ? "" : "s"}${elapsed ? ` · ${elapsed}` : ""}`;
+    // An ended turn says each thing once: its steps in the chip (the label
+    // of what the cloud holds), its time in the status row's timing line
+    // (the one that moves into the history). The chip keeps the time when
+    // that line is elsewhere (a turn the stage didn't hold from its start).
+    const elapsed = endKind && !timingSlot.firstChild ? formatDuration(endedAt - startedAt) : "";
+    chipLabel.textContent = `${steps} · ${calls} tool call${calls === 1 ? "" : "s"}${elapsed ? ` · ${elapsed}` : ""}`;
     miniTool.textContent = collapsed && slots.tool ? `${slots.tool.name} ${slots.tool.title}` : "";
     miniTool.title = (collapsed && slots.tool?.command) || "";
 
     live.hidden = plain || !!endKind;
     cloud.hidden = !blockEl || blockEl.parentNode !== cloudBody;
+    // Running: the step it is on. Ended: the count, unless the chip says it.
+    stepEl.textContent = !endKind ? `step ${slots.step}` : cloud.hidden ? steps : "";
     promptSlot.hidden = !promptSlot.firstChild;
     extras.hidden = !extras.firstChild;
     answer.hidden = !answer.firstChild;
@@ -225,8 +231,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     headline.classList.add("fresh");
   }
 
-  function drawNow(tool, gen) {
-    const quiet = gen?.text && !gen.textDone ? "writing…" : "thinking…";
+  function drawNow(tool, quiet) {
     // A task_wait's stop button, as the row's (task_stop.js): in the key
     // with its in-flight state, so a redraw keeps a clicked one disabled.
     const stopId = tool?.taskId && taskStop?.target({ tool: "task_wait", status: "running", view: { task_id: tool.taskId } });
@@ -248,7 +253,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
         const command = () => taskCommand(view.current().turn?.gens, stopId);
         now.appendChild(taskStopButton(taskStop, stopId, { command, onChange: scheduleRefresh }));
       }
-    } else {
+    } else if (quiet) {
       const word = node("span", "ts-title quiet", now);
       word.textContent = quiet;
     }
@@ -262,9 +267,9 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     trail.replaceChildren();
     if (flashing) node("span", `ts-trail-item ${flashing.kind}`, trail).textContent = `${FLASH_MARKS[flashing.kind]} ${flashing.text}`;
     for (const item of items) {
-      const failed = item.status === "error";
-      const el = node("span", `ts-trail-item${failed ? " error" : ""}`, trail);
-      el.textContent = `${failed ? "✕" : "✓"} ${item.name} ${item.title}`.trim();
+      const tone = trailTone(item.status);
+      const el = node("span", `ts-trail-item${tone ? ` ${tone}` : ""}`, trail);
+      el.textContent = `${trailMark(item.status)} ${item.name} ${item.title}`.trim();
       if (item.command) el.title = item.command;
     }
     if (!flashing && !items.length) node("span", "ts-trail-item none", trail).textContent = "no tool calls yet";