samagotchi 0.69.0 → 0.71.0

data/lib/samagotchi/tool_runner.rb

@@ -7,6 +7,9 @@ require_relative "guardrails"
 require_relative "vision_context"
 require_relative "log"
 require_relative "edit_preview"
+require_relative "tool_output_cut"
+require_relative "tool_output_files"
+require_relative "tools/output_guardrails"
 require_relative "tools/tool_path"
 require_relative "memory_bundle/index_sync"
 require_relative "memory_bundle/index_size"
@@ -16,8 +19,8 @@ module Samagotchi
   # tool_call_completed events, the guardrail gate (before_tool_call hooks
   # and their veto), dispatch through KernelLoop, the after_tool_call hook
   # and the output cap. Both loops feed the model `capped_output:` (cut to
-  # the cap with a "[cut: N of M chars …]" line), the text the event and
-  # the hook get too.
+  # the cap by the tool's ToolOutputCut policy, with a "[cut: …]" line),
+  # the text the event and the hook get too.
   class ToolRunner
     # More images in one result are left out, each with a line (a tool
     # that returns many screenshots can't flood the context).
@@ -38,6 +41,7 @@ module Samagotchi
 
     # @param call_index [Integer] 1-based position of the call in its batch
     # @return [Hash] output:, capped_output:, truncated:, activity:,
+    #   output_file: (the saved whole output of a cut execute result),
     #   images: (refs) when the tool returned images the model gets to see, and
     #   shown_params: the params line the live row showed, and shown_label:
     #   its label ("chrome: screenshot"), only for a tool that isn't built in
@@ -109,7 +113,8 @@ module Samagotchi
         output = "#{changed}\n#{output}"
       end
       truncated = !max_tool_output_chars.nil? && output.length > max_tool_output_chars
-      capped = truncated ? cut(output, max_tool_output_chars) : output
+      capped, saved = truncated ? cut(call, output, max_tool_output_chars, result) : output
+      output_file = saved.path if saved.is_a?(ToolOutputFiles::Saved)
 
       # The call's outcome as its activity line has it (worked out from the
       # full output: ok, error, blocked, stopped); a dispatcher that raised
@@ -120,6 +125,7 @@ module Samagotchi
       completed[:images] = images if images&.any?
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
+      completed[:output_file] = output_file if output_file
       # Also here: a UI that missed the start (a replay gap) builds its row
       # from this event (its title is in the activity).
       completed.merge!(fields.slice(*ToolRowFields::EVENT_KEYS))
@@ -135,22 +141,50 @@ module Samagotchi
       run[:shown_label] = label if label
       run[:refs] = refs unless refs.empty?
       run[:diff] = diff if diff
+      run[:output_file] = output_file if output_file
       run
     end
 
     private
 
-    # +output+ cut to +cap+ chars, the cut line included: the model knows
-    # what it didn't get. A cap smaller than the line keeps +cap+ chars and
-    # the line goes past it.
-    def cut(output, cap)
-      keep = cap - cut_line(cap, output.length).length
-      keep = cap unless keep.positive?
-      "#{output[0, keep]}#{cut_line(keep, output.length)}"
+    # +output+ cut to +cap+ by its tool's policy (ToolOutputCut); an
+    # execute result keeps its tail too, its whole output saved in the
+    # session's folder.
+    # @param result [Hash] the dispatch's: its ref_path is the file the
+    #   whole text is in (a task's log, a child's reply: Tools::RefText),
+    #   for task_wait and delegate; ref_stderr_path, a task's stderr log
+    # @return [Array(String, Object)] the text, and the saved file (or why
+    #   there is none) when it was cut that way
+    def cut(call, output, cap, result)
+      ToolOutputCut.apply(output, cap: cap, tool: call[:name], save: ->(text, dry: false) { save_output(call, text, dry: dry) },
+                                  ref: result[:ref_path], ref_stderr: result[:ref_stderr_path],
+                                  head_chars: Tools::OutputGuardrails.config_positive_int("execute.cut_head_chars",
+                                                                                          ToolOutputCut::HEAD_CHARS))
     end
 
-    def cut_line(kept, total)
-      "\n[cut: #{kept} of #{total} chars; read it in parts]"
+    # The whole output in the session's tool_output folder
+    # (ToolOutputFiles), or why it isn't saved: no session (a bare kernel)
+    # or the error's class. Never fails the call. +dry+: where it would go,
+    # nothing written (ToolOutputFiles.planned).
+    # @return [ToolOutputFiles::Saved, String]
+    def save_output(call, text, dry: false)
+      dir = session_dir
+      return "no session" if dir.to_s.empty?
+      return ToolOutputFiles.planned(dir, text, tool: call[:name]) if dry
+
+      ToolOutputFiles.save(dir, text, tool: call[:name])
+    rescue SystemCallError => e
+      Log.warn(:turn, "tool_output_save_failed", tool: call[:name], error: e.class.name)
+      e.class.name
+    end
+
+    # The session's folder (KernelLoop#session_dir), nil for a bare kernel
+    # or a lookup that failed.
+    def session_dir
+      @kernel.respond_to?(:session_dir) ? @kernel.session_dir&.call : nil
+    rescue StandardError => e
+      Log.warn(:turn, "tool_output_save_failed", error: e.class.name)
+      nil
     end
 
     # edit/write only: the file just before the call runs. The row diffs it

data/lib/samagotchi/toolkit.rb

@@ -230,13 +230,17 @@ module Samagotchi
       base.changed(add: kit.add, remove: kit.remove).with(name: name)
     end
 
+    # The keys a config kit entry takes.
+    KIT_KEYS = %w[base add remove].freeze
+
     # The kits known: the built-ins, then config's toolkit.kits, then the
     # plugins' (chi.toolkit). A config kit with a built-in's name is left
     # out (one it can't redefine) with a line in +errors+, and so is one
-    # that isn't a {base:, add:, remove:} map.
+    # that isn't a {base:, add:, remove:} map. One with another key (a
+    # typo, a tools: list) still loads, with a line naming the key.
     # @param config [Hash, nil] toolkit.kits
     # @param plugins [Array<Kit>]
-    # @param errors [Array<String>] gets a line per kit left out
+    # @param errors [Array<String>] gets a line per kit left out or unknown key
     # @return [Hash{String => Kit}]
     def self.kits(config: nil, plugins: [], errors: [])
       kits = BUILTIN_KITS.dup
@@ -248,6 +252,9 @@ module Samagotchi
           errors << "toolkit.kits.#{name}: expected {base:, add:, remove:}"
         else
           spec = spec.transform_keys(&:to_s)
+          (spec.keys - KIT_KEYS).each do |key|
+            errors << "toolkit.kits.#{name}: unknown key #{key} (a kit takes base:, add:, remove:)"
+          end
           kits[name] = Kit.new(name: name, base: spec["base"] || FULL, add: spec["add"], remove: spec["remove"],
                                source: "config")
         end

data/lib/samagotchi/tools/delegate.rb

@@ -66,7 +66,10 @@ module Samagotchi
         return child_id if child_id.start_with?("Error:")
 
         note = warning ? "Warning: #{warning}\n" : ""
-        return note + DelegateWait.call(child_id, peers: peers, timeout: timeout) if wait
+        if wait
+          result = DelegateWait.call(child_id, peers: peers, timeout: timeout)
+          return RefText.wrap(note + result, result.respond_to?(:ref_path) ? result.ref_path : nil)
+        end
 
         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}; #{running_hint(peers)} " \

data/lib/samagotchi/tools/delegate_wait.rb

@@ -7,6 +7,7 @@ require_relative "output_guardrails"
 require_relative "peers"
 require_relative "delegate_relay"
 require_relative "delegate_cursor"
+require_relative "ref_text"
 
 module Samagotchi
   # Loaded on first use: child_reports requires this file (a circular
@@ -78,7 +79,8 @@ module Samagotchi
           unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
             outcomes.concat(relayed_outcomes.delete(key) || [])
             advance(peers.session_id, child_id, wait, state_dir: sd)
-            return with_outcomes(finish(wait, child_id, timeout: timeout, reports: reports), outcomes)
+            text = with_outcomes(finish(wait, child_id, timeout: timeout, reports: reports), outcomes)
+            return RefText.wrap(text, reply_path(child_id, wait, state_dir: sd))
           end
 
           outcome = DelegateRelay.call(child_id, wait.question, relay: relay, state_dir: sd, more: others&.count.to_i)
@@ -104,6 +106,15 @@ module Samagotchi
                                   })
       end
 
+      # The child's reply file a :done wait read (its output/ file), which
+      # ToolRunner's cut of a long reply names (ToolOutputCut's
+      # :head_tail_ref); nil for any other outcome.
+      def reply_path(child_id, wait, state_dir:)
+        return nil unless wait.status == :done && wait.file
+
+        File.join(ReplyWait.reply_dir(child_id, state_dir: state_dir), wait.file)
+      end
+
       # The relayed approvals' outcome lines, after the status line.
       def with_outcomes(text, outcomes)
         return text if outcomes.empty?

data/lib/samagotchi/tools/ref_text.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Tools
+    # A tool's text that shows part of a file kept elsewhere in whole: a
+    # task's log (task_wait's output tail), a child's reply file (delegate,
+    # delegate_result). It is the text itself (a String), like
+    # Plugin::ToolResult; #ref_path is the file, which ToolRunner's cut
+    # names when the text is longer than max_tool_output_chars
+    # (ToolOutputCut's :head_tail_ref), instead of saving a copy;
+    # #stderr_path, a handed-over execute's stderr log, the cut names too.
+    class RefText < String
+      attr_reader :ref_path, :stderr_path
+
+      def initialize(text, ref_path, stderr_path: nil)
+        @ref_path = ref_path
+        @stderr_path = stderr_path.to_s.empty? ? nil : stderr_path
+        super(text.to_s)
+      end
+
+      # +text+ as a RefText of +ref_path+; +text+ as it is with no path.
+      def self.wrap(text, ref_path, stderr_path: nil)
+        ref_path.to_s.empty? ? text : new(text, ref_path, stderr_path: stderr_path)
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/registry.rb

@@ -179,13 +179,24 @@ module Samagotchi
         return true if @index.sourced
         return false if toolkit&.removed&.include?(@index.call_name)
 
-        @entries.each_value.any? { |entry| soft?(entry, [], toolkit) }
+        index_reaches?(toolkit)
       end
 
+      # Whether the index's tools would reach something under +toolkit+,
+      # removed or not: a source registered at load, or a built-in the
+      # toolkit leaves out without removing it.
+      def index_reaches?(toolkit)
+        @index.sourced || @entries.each_value.any? { |entry| soft?(entry, [], toolkit) }
+      end
+
+      # Not declared by +toolkit+ under +layers+. An index tool counts only
+      # when the toolkit removes it and it would reach something (full with
+      # --no-tool call_tool and no MCP server leaves nothing out).
       def left_out?(entry, layers, toolkit)
         return false unless entry.offered?(layers) && !declared?(entry, toolkit)
+        return true unless index_entry?(entry)
 
-        !index_entry?(entry) || toolkit&.removed&.include?(entry.name) == true
+        toolkit&.removed&.include?(entry.name) == true && index_reaches?(toolkit)
       end
 
       # A built-in +toolkit+ leaves out of a turn under +layers+ without

data/lib/samagotchi/tools/task_wait.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "task_runtime"
+require_relative "ref_text"
 
 module Samagotchi
   module Tools
@@ -79,13 +80,11 @@ module Samagotchi
       end
       private_class_method :cancelled_response
 
-      # A task the user stopped also says so, with the tail of its output:
-      # the model sees where the job was cut off.
+      # Always give the log's last lines: a test run's summary, an error. A
+      # task the user stopped also says so.
       def self.finished_response(record, tail_lines)
-        return format_response(record) unless record.stopped_by_user?
-
-        format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines,
-                               extra: [TaskRuntime::USER_STOP_NOTE])
+        extra = record.stopped_by_user? ? [TaskRuntime::USER_STOP_NOTE] : []
+        format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines, extra: extra)
       end
       private_class_method :finished_response
 
@@ -121,7 +120,9 @@ module Samagotchi
         lines << output_tail.rstrip unless output_tail.empty?
         stderr_tail = stderr_tail(record, tail_lines)
         lines.concat(["stderr_tail:", stderr_tail.rstrip]) unless stderr_tail.empty?
-        lines.join("\n")
+        # The whole log is at output_path (stderr at stderr_path): a cut of
+        # this text names them.
+        RefText.wrap(lines.join("\n"), record.output_path, stderr_path: record.stderr_path)
       end
       private_class_method :format_response
 

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -896,9 +896,9 @@ module Samagotchi
       # session part is what the page reads of it (id, status, used memory
       # names, the model notes its prompt carried: the first turn's build or
       # a /model records them). ?turn_id=: that turn's answer (a queued
-      # turn's page re-reads after the next one started). ?recent=1 (the page since this
-      # release): the timing's records are the newest turn's (#recent_timing),
-      # which the page merges by id; without it, the whole timing as before.
+      # turn's page re-reads after the next one started). The timing's records
+      # are the newest turn's (#recent_timing), which the page merges by id
+      # (the page still sends ?recent=1, which is accepted and not needed).
       def handle_tail_read(req, id)
         return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
 
@@ -919,9 +919,7 @@ module Samagotchi
         end
         session_json = { id: id, status: status, used_memory_names: Array(used), prompt_notes: Array(notes) }
         live_metrics = state && state["metrics"]
-        # Without recent=1: a tab opened before this release (it replaces its
-        # timing with the reply's). Remove this branch after the next release.
-        timing = req.params["recent"] == "1" ? recent_timing(id, live_metrics) : timing_payload(id, live_metrics: live_metrics)
+        timing = recent_timing(id, live_metrics)
         json_response(200, {
           tail: true,
           session: session_json,
@@ -1703,7 +1701,7 @@ module Samagotchi
                                                                  turn_count: (live && turn_count(live_metrics)) || turns.size)
       end
 
-      # The timing a ?tail=1&recent=1 read sends: a live worker's recent
+      # The timing a ?tail=1 read sends: a live worker's recent
       # records as its metrics hold them (the newest finished turn's and
       # the unsaved ones, the running turn's finished calls), no
       # analytics.json read; with no worker the disk's, trimmed to the

data/lib/samagotchi/web/message_parts.rb

@@ -10,6 +10,7 @@ require_relative "../image_store"
 require_relative "../llm_context_edit"
 require_relative "../token_usage"
 require_relative "../row_refs"
+require_relative "../tool_output_cut"
 
 module Samagotchi
   module Web
@@ -50,8 +51,9 @@ module Samagotchi
       # so an output that holds the joiner itself stays whole.
       JOINER_BEFORE_TAG = /\n\n---\n\n(?=\[)/
       # The row shows 300 chars and the rest on hover; a read of a big file
-      # would otherwise ride along with every reload.
-      OUTPUT_MAX = 2000
+      # would otherwise ride along with every reload. A longer one keeps its
+      # head and tail (ToolOutputCut.preview).
+      OUTPUT_MAX = ToolOutputCut::WEB_PREVIEW_CHARS
 
       QWEN_THINK = %r{<think>(.*?)</think>}m
       QWEN_OPEN_THINK = %r{\A(.*?)</think>}m # the template opened the block
@@ -246,7 +248,7 @@ module Samagotchi
         part.merge!(ToolRowFields.for(name, call, cwd: cwd))
         part[:label] = label if label.is_a?(String) && !label.empty?
         unless output.nil?
-          part[:output] = output.length > OUTPUT_MAX ? output[0, OUTPUT_MAX] : output
+          part[:output] = ToolOutputCut.preview(output, cap: OUTPUT_MAX, tool: name)
           part[:output_truncated] = true if output.length > OUTPUT_MAX
         end
         shots = Array(images).select { |image| image.is_a?(Hash) }

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

@@ -67,6 +67,7 @@ export function applyFinalAnswer(messages, bubbles, normalize) {
   if (typeof message.html === "string") {
     bubble.classList.add("markdown");
     bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
+    // The server's rendered markdown, sanitized there (Web::MarkdownRenderer#sanitize): set as it is, not templated.
     bubble.innerHTML = message.html;
   }
   setAnswerRefs(bubble, message.display_refs);

data/lib/samagotchi/web/public/index.html

@@ -162,6 +162,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .activity-alias{color:var(--text-faint);white-space:nowrap}
 .activity-duration{color:var(--text-faint);font-size:11px;font-variant-numeric:tabular-nums;white-space:nowrap}
 .activity-output{margin:4px 0 2px var(--row-gutter);font-size:12px;color:var(--text-muted);white-space:pre-wrap;word-break:break-word;background:var(--bg);border-radius:6px;padding:6px 8px;max-height:160px;overflow:auto}
+.activity-output.tail{display:flex;flex-direction:column-reverse}
 /* A row's status and tool name never wrap (a phone broke them letter by
    letter); the params take what is left. The output goes on its own line
    under the call instead of a column beside it: on a desktop it lines up

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

@@ -11,6 +11,7 @@ import { activityDiffTemplate } from "./diff_view.js";
 import { clip, steerSender } from "./format.js";
 import { rowTitleRef } from "./refs.js";
 import { readLinesTemplate } from "./read_view.js";
+import { handedOverId } from "./task_stop.js";
 import { STOPPED_LINE_CLASS, cancelLineText, formatDuration } from "./timing.js";
 import { emptyAnswerLine } from "./turn_events.js";
 
@@ -73,12 +74,63 @@ function llmEditTemplate(row) {
   return html`<div class="activity-edit" title=${hover}>${line}</div>`;
 }
 
+// What a done row shows of its output inline: its first INLINE_CHARS, else
+// for an execute's result and a task_wait with its log's last lines its
+// last ones (a test run's summary, a failing exit line). An execute drops a
+// bare success "exit: 0" (the mark says it) and, with no stderr block, the
+// lone "stdout:" label. A guardrail deny, an approval refused or an
+// execute's error has its reason first, a hand-over its task_id: the head.
+// A gate-corrected call's `ran as:` line shows on hover only.
+const INLINE_CHARS = 300;
+// The JS twin of ToolOutputCut::EXIT_LINE (tool_output_cut.rb): an exit line, then maybe a hint; a
+// signal-killed command's has no number ("exit: ").
+const EXIT_LINE = /\nexit: (?:-?\d+)?[^\n]*(?:\n\([^\n]*\))?$/;
+// A bare success exit line; group 1 is the hint line after it, if any.
+const SUCCESS_EXIT_LINE = /\nexit: 0(\n\([^\n]*\))?$/;
+const EXECUTE_BLOCK = /(?:^|\n)(?:stdout|stderr):\n/;
+const OUTPUT_TAIL = /^output_tail:$/m;
+// A gate-corrected call's first line (ToolRunner#changed_call_line) and the "[tool]" lead after it, which
+// the row's lead strip misses (it isn't first). The inline text drops both; the hover keeps them.
+const RAN_AS_LEAD = /^ran as: [^\n]*\n(?:\[[^\]\s]+\](?:\n| ))?/;
+
+export function inlineOutput(tool, full) {
+  const text = String(full ?? "").replace(RAN_AS_LEAD, "");
+  if (!tailMode(tool, text)) return clip(text, INLINE_CHARS + 1);
+  let shown = text;
+  if (tool === "execute") {
+    shown = shown.replace(SUCCESS_EXIT_LINE, (_, hint) => hint || "");
+    if (!text.includes("\nstderr:\n") && shown.startsWith("stdout:\n")) shown = shown.slice("stdout:\n".length);
+  }
+  shown = shown.replace(/\n+$/, "");
+  return tailClip(shown.trim() ? shown : text);
+}
+
+// Whether a row's output shows its end (its div opens scrolled to the end).
+export function tailMode(tool, text) {
+  if (tool === "task_wait") return OUTPUT_TAIL.test(text);
+  if (tool !== "execute" || handedOverId(text)) return false;
+  return EXECUTE_BLOCK.test(text) || EXIT_LINE.test(text);
+}
+
+// The text's end, as clip keeps its start: whole when it fits, else "…" and
+// its last INLINE_CHARS, never from half an emoji, from a line's start when
+// that keeps at least half of them (ToolOutputCut.cut_block's tail rule).
+function tailClip(text) {
+  if (text.length <= INLINE_CHARS + 1) return text;
+  let kept = text.slice(-INLINE_CHARS);
+  const first = kept.charCodeAt(0);
+  if (first >= 0xdc00 && first <= 0xdfff) kept = kept.slice(1);
+  const nl = kept.indexOf("\n");
+  if (nl >= 0 && kept.length - nl - 1 >= INLINE_CHARS / 2) kept = kept.slice(nl + 1);
+  return `\u2026${kept}`;
+}
+
 // A tool row: its status mark, tool, title (else params; the full command,
 // else the full params line, on hover), the word an exception shows, the
 // call's duration, the full command (an execute/task_create's view, also
 // while it runs), the output once done (its "[tool]" tag dropped, 300 chars,
-// the rest on hover; a read of the file as-is also its numbered lines,
-// closed: read_view.js), its images (+thumbs+(images) draws them) and an
+// an execute/task_wait's last ones (inlineOutput), the rest on hover; a read
+// of the file as-is also its numbered lines, closed: read_view.js), its images (+thumbs+(images) draws them) and an
 // edit's collapsed diff, and a reloaded row's ✂ mark above its output. A
 // part with nothing to say is left out. A reload renders toolRowTemplate;
 // the live view renders toolRowInnerTemplate into its own row element
@@ -107,7 +159,7 @@ export function toolRowInnerTemplate(row, { thumbs = () => nothing, stop = nothi
   const duration = formatDuration(row.duration_ms);
   const full = row.status === "running" ? "" : String(row.output || "").replace(/^\[[^\]]*\]\s*/, "");
   const output = full
-    ? html`<div class="activity-output" title=${full}>${clip(full, 301)}</div>`
+    ? html`<div class=${tailMode(row.tool, full) ? "activity-output tail" : "activity-output"} title=${full}>${inlineOutput(row.tool, full)}</div>`
     : nothing;
   const status = statusParts(row.status, { noMatch: !!row.no_match });
   return html`${statusMarkTemplate(status)}<span class="activity-tool">${toolName(row)}</span>${params}${stop}${alias}${statusWordTemplate(status)}${duration ? html`<span class="activity-duration">${duration}</span>` : nothing}${commandBlockTemplate(row.view, row.title)}${llmEditTemplate(row)}${output}${full ? readLinesTemplate(row) : nothing}${row.images?.length ? thumbs(row.images) : nothing}${row.diff ? activityDiffTemplate(row.diff) : nothing}`;

data/lib/samagotchi/worker.rb

@@ -496,13 +496,13 @@ module Samagotchi
     # turn from context:<name> whose first message is the wake note already
     # in the conversation (named by +turn_id+), on the same rules as a
     # delegate report's wake turn: it counts toward session.max_wakes (a
-    # peer's answer toward context.peer_turns too), and a failure goes back
+    # peer's answer toward context.peer_turns too, unless it agrees), and a failure goes back
     # to before the turn (the note stays, as a plain one:
     # WorkerInbound#unmark_wake) and pauses wakes until a human's input.
     # +context_wake+: a WorkerInbound::ContextWake.
     def run_context_wake_turn(context_wake)
       name = context_wake.name
-      Log.info(:worker, "context_wake_turn", name: name, in_a_row: @wakes.count!(peer: context_wake.peer?))
+      Log.info(:worker, "context_wake_turn", name: name, in_a_row: @wakes.count!(peer: context_wake.peer_turn?))
       @turn_flow.before_prompt_turn
       run_engine_turn(nil, continue: true, origin: context_wake.origin,
                            id: context_wake.turn_id, max_iterations: IterationLimit.for) do |result, error|

data/lib/samagotchi/worker_inbound.rb

@@ -47,6 +47,9 @@ module Samagotchi
       def name = delivery.name
       # For a peer agent's answer (its own budget, WorkerWakes#peer_open?).
       def peer? = !delivery.peer.nil?
+      # Whether the wake counts toward context.peer_turns: a peer's answer
+      # that agrees closes the round and counts toward session.max_wakes only.
+      def peer_turn? = peer? && !delivery.agreed
       def origin = { client_id: "#{ClientId::CONTEXT_PREFIX}#{name}" }
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.69.0
+  version: 0.71.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -504,6 +504,8 @@ files:
 - lib/samagotchi/tool_call_parser.rb
 - lib/samagotchi/tool_declarations.rb
 - lib/samagotchi/tool_ids.rb
+- lib/samagotchi/tool_output_cut.rb
+- lib/samagotchi/tool_output_files.rb
 - lib/samagotchi/tool_response.rb
 - lib/samagotchi/tool_row_fields.rb
 - lib/samagotchi/tool_runner.rb
@@ -531,6 +533,7 @@ files:
 - lib/samagotchi/tools/output_guardrails.rb
 - lib/samagotchi/tools/peers.rb
 - lib/samagotchi/tools/read.rb
+- lib/samagotchi/tools/ref_text.rb
 - lib/samagotchi/tools/register_reminder.rb
 - lib/samagotchi/tools/registry.rb
 - lib/samagotchi/tools/send_note.rb