samagotchi 0.38.0 → 0.40.0

data/lib/samagotchi/tool_activity.rb

@@ -22,6 +22,7 @@ require_relative "tools/send_note"
 require_relative "tools/context_read"
 require_relative "tools/delegate"
 require_relative "tools/delegate_result"
+require_relative "tools/forget_outputs"
 
 module Samagotchi
   # The one-line summary of a tool call that the UIs show ("reading file",
@@ -172,6 +173,7 @@ module Samagotchi
       when Tools::ContextRead::NAME then "reading attached context"
       when Tools::Delegate::NAME then "delegating"
       when Tools::DelegateResult::NAME then "waiting for a delegate"
+      when Tools::ForgetOutputs::NAME then forget_outputs_action(call)
       else registry_entry(registry, tool_name)&.label || "calling tool"
       end
     end
@@ -192,6 +194,14 @@ module Samagotchi
       "saving memory"
     end
 
+    # forget_outputs' label: a call with only restore brings outputs back.
+    def forget_outputs_action(call)
+      return "forgetting outputs" unless call.is_a?(Hash)
+
+      request = Tools::ForgetOutputs.parse(call)
+      request.ids.empty? && request.restore? ? "restoring outputs" : "forgetting outputs"
+    end
+
     def tool_activity_status(result, tool_name = nil)
       text = result.to_s
       return "stopped" if text == Tools::Execute::NOT_RUN_ON_STOP
@@ -285,6 +295,14 @@ module Samagotchi
         parts.join(" ")
       when Tools::DelegateResult::NAME
         call[:session].to_s.strip.empty? ? nil : "session=#{preview_tool_param(call[:session])}"
+      when Tools::ForgetOutputs::NAME
+        request = Tools::ForgetOutputs.parse(call)
+        parts = []
+        parts << "ids=#{preview_tool_param(request.ids.join(","))}" unless request.ids.empty?
+        parts << "keep=#{preview_tool_param(request.keep.keys.join(","))}" unless request.keep.empty?
+        parts << "restore=#{preview_tool_param(request.restore.join(","))}" if request.restore?
+        parts << "note=#{preview_tool_param(request.note)}" unless request.note.empty?
+        parts.empty? ? nil : parts.join(" ")
       when Tools::AskUserQuestion::NAME
         parts = ["question=#{preview_tool_param(call[:question] || call[:content])}"]
         opts = call[:options]

data/lib/samagotchi/tool_declarations.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require_relative "tools/args"
+require_relative "llm_context_strategy"
 
 module Samagotchi
   # Tool-declaration constants, protocol constants, and guidance text.
@@ -437,6 +438,62 @@ module Samagotchi
       }
     ].freeze
 
+    # forget_outputs, the forget layer's tool (LLMContextForget): offered
+    # only in a turn whose LLM context strategy has forget
+    # (Tools::Registry's layer gate), so it is not in TOOL_SCHEMAS, which
+    # every turn declares. Its description carries llm_context.policy
+    # (#forget_outputs_schema); this one the default's.
+    FORGET_OUTPUTS_POLICY = LLMContextStrategy::DEFAULT_POLICY
+    FORGET_OUTPUTS_DESCRIPTION = "Forget tool outputs you no longer need, to free context. Every tool output starts " \
+                                 "with an id like [#t42]: list ids to forget, and each output is replaced in place by " \
+                                 "a stub with your note (the call stays). %<policy>s\n" \
+                                 "The note is required and is all that stays of them, so write it for your future " \
+                                 "self: the facts you carry forward, quoted (file:line; values marked VERIFIED or " \
+                                 "UNVERIFIED); what you ruled out, with the reason and \"do not retry\"; the exact " \
+                                 "commands you tried; a last line NEXT: what you do next. Never \"not needed\".\n" \
+                                 "Good candidates: settled exploration, dead ends, long logs and test runs whose " \
+                                 "result the note keeps, listings, reads of files you're done with. Keep what you'll " \
+                                 "still edit against (edit needs the exact text): leave it, or forget it but keep " \
+                                 "its lines with keep. Outputs from your last few steps can't be forgotten yet.\n" \
+                                 "Cost: a forget makes the server read again everything after the earliest output " \
+                                 "it touches, so forget in one batch at a natural break, prefer older outputs, and " \
+                                 "skip small ones. The result says whether the stubs go out at once or at the " \
+                                 "turn's end. restore brings a forgotten output back (for a read, read the file " \
+                                 "again)."
+
+    module_function
+
+    # The forget_outputs schema, its description with +policy+ (the
+    # llm_context.policy sentence; blank: none).
+    def forget_outputs_schema(policy: FORGET_OUTPUTS_POLICY)
+      policy = policy.to_s.strip
+      description = format(FORGET_OUTPUTS_DESCRIPTION, policy: policy.empty? ? "" : "Policy: #{policy}")
+      {
+        name: "forget_outputs",
+        description: description.gsub(/ +\n/, "\n"),
+        parameters: {
+          type: "object",
+          properties: {
+            ids: { type: "array", items: { type: "string" },
+                   description: "Output ids to forget, e.g. [\"t41\", \"t42\"]" },
+            note: { type: "string",
+                    description: "Required with ids: the facts carried forward (quoted; VERIFIED or UNVERIFIED), what " \
+                                 "is ruled out and why (do not retry), the commands tried, and NEXT: …" },
+            keep: { type: "array", items: { type: "string" },
+                    description: "Lines to keep from an output you are forgetting: \"t42:12-40\" forgets t42 except " \
+                                 "those lines (a read's are the file's line numbers; other outputs count from 1)" },
+            restore: { type: "array", items: { type: "string" },
+                       description: "Ids of forgotten outputs to bring back instead" }
+          }
+        }
+      }
+    end
+
+    FORGET_OUTPUTS_SCHEMA = forget_outputs_schema.freeze
+    # Every built-in's schema: the ones each turn declares, then the ones a
+    # layer adds (BuiltinCalls maps their calls).
+    BUILTIN_SCHEMAS = (TOOL_SCHEMAS + [FORGET_OUTPUTS_SCHEMA]).freeze
+
     # Where Gemma's declaration text says something the schema doesn't:
     # extra description text.
     GEMMA_PARAM_OVERRIDES = {
@@ -456,8 +513,6 @@ module Samagotchi
 
     GEMMA_QUOTE = '<|"|>'
 
-    module_function
-
     # +schema+ without execute's description property: what a session
     # with execute.description off declares (the parameter isn't offered
     # at all). Any other schema as given.
@@ -526,8 +581,9 @@ module Samagotchi
     # The schemas the native (Gemma, Qwen) prompts declare: the built-ins
     # as they are, and each plugin tool's flattened (.flat_schema).
     # @param registry [Tools::Registry]
-    def native_schemas(registry)
-      registry.entries.map { |entry| entry.core? ? entry.schema : flat_schema(entry.schema) }
+    # @param layers [Array<Symbol>] the turn's LLM context layers (Registry#entries)
+    def native_schemas(registry, layers: [])
+      registry.entries(layers: layers).map { |entry| entry.core? ? entry.schema : flat_schema(entry.schema) }
     end
 
     # A plugin tool's schema in the shape the built-ins have, which is all

data/lib/samagotchi/tool_ids.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "tool_response"
+require_relative "context_note"
+
+module Samagotchi
+  # chi's own ids for tool outputs, one per run ("t41"), saved on the
+  # tool_response entry as tool_ids (ToolResponse.joined: one per call of
+  # the batch; ToolResponse.single: its one call). A strategy's edits
+  # (LLMContextView) name the outputs they change by them; the prompt never
+  # shows them under none.
+  #
+  # The next id is one past the highest the conversation holds, read when
+  # the runs are added: the ids live on the entries, so they go wherever
+  # the entries go (a turn's result, a save and load, --resume, a plugin's
+  # sessions.fork) with no counter of their own to keep in step. A rollback
+  # drops the later entries and their ids with them; an id handed out
+  # again after it names an output nothing else refers to any more (an
+  # edit is saved on the entry it changes, so it went too).
+  #
+  # Copies of an entry share its tool_ids Array (a checkpoint, a fork and
+  # duplicate_conversation copy the top level only): set it, never change
+  # it in place.
+  #
+  # An entry saved before the ids has none: #refs derives them on read
+  # from its index and the run's position ("e12.1"), marked derived, so a
+  # later strategy can refuse to change what it can't name for sure.
+  # #refs_at counts that index as if the conversation had its system head:
+  # each request puts a head on the stored messages
+  # (ContextNote.with_system_head replaces a saved one, and adds one to a
+  # head-less fork or a session before its first save), so an entry's
+  # derived id is the same in the stored session, every request and the
+  # warm-up, and an edit saved under it still names its run.
+  module ToolIds
+    PATTERN = /\At(\d+)\z/
+    DERIVED_PREFIX = "e"
+
+    # One run's id in an entry: the id, the run's position (0-based) and
+    # whether it was derived.
+    Ref = Data.define(:id, :run, :derived) do
+      def derived? = derived
+    end
+
+    module_function
+
+    # +count+ ids for runs about to go on +conversation+.
+    # @return [Array<String>]
+    def next_ids(conversation, count)
+      first = highest(conversation) + 1
+      Array.new(count) { |offset| "t#{first + offset}" }
+    end
+
+    # The highest stored id's number in +conversation+, 0 for none.
+    def highest(conversation)
+      Array(conversation).reduce(0) do |max, entry|
+        next max unless entry.is_a?(Hash) && entry[:role].to_s == "tool_response"
+
+        Array(entry[:tool_ids]).reduce(max) do |acc, id|
+          (match = PATTERN.match(id.to_s)) ? [acc, match[1].to_i].max : acc
+        end
+      end
+    end
+
+    # The ids of +conversation+[+index+]'s runs: #refs, a derived id
+    # counted as if the conversation had its system head.
+    # @return [Array<Ref>]
+    def refs_at(conversation, index)
+      refs(conversation[index], ContextNote.system_head?(conversation.first) ? index : index + 1)
+    end
+
+    # The ids of +entry+'s runs (+index+ its place in the conversation):
+    # the stored tool_ids, else derived ones, one per run (a chat result
+    # paired by tool_call_id is one run; a native entry has a run per
+    # "[name]" part, ToolResponse.split).
+    # @return [Array<Ref>]
+    def refs(entry, index)
+      ids = Array(entry[:tool_ids])
+      return ids.each_with_index.map { |id, run| Ref.new(id: id.to_s, run: run, derived: false) } unless ids.empty?
+
+      count = entry[:tool_call_id] ? 1 : [ToolResponse.split(entry[:content]).size, 1].max
+      Array.new(count) { |run| Ref.new(id: "#{DERIVED_PREFIX}#{index}.#{run + 1}", run: run, derived: true) }
+    end
+  end
+end

data/lib/samagotchi/tool_response.rb

@@ -10,8 +10,19 @@ module Samagotchi
   module ToolResponse
     SEPARATOR = "\n\n---\n\n"
     # Saved with a result for the web's reload (a plugin tool's params line
-    # and label, an edit/write's diff); the prompt never reads them.
-    SAVED_KEYS = %i[tool_params tool_labels tool_diffs].freeze
+    # and label, an edit/write's diff) and for the LLMContextView (each
+    # run's chi-owned id, ToolIds, and a strategy's edits by id,
+    # LLMContextEdit); the prompt never renders them.
+    SAVED_KEYS = %i[tool_params tool_labels tool_diffs tool_ids edits].freeze
+    # A run's "[name]" lead: the name, then a newline, a space or the end.
+    LEAD = /\A\[([^\]\s]+)\](?:\n| |\z)/
+
+    # One run's text in a joined entry: its "[name]" lead (with what
+    # follows it) and the rest. A part without a lead has no name and an
+    # empty lead.
+    RunText = Data.define(:name, :lead, :body) do
+      def text = "#{lead}#{body}"
+    end
 
     module_function
 
@@ -39,8 +50,9 @@ module Samagotchi
 
     # The native loop's entry for a batch: the capped outputs joined, every image
     # in call order with how many each call returned (the web's reload puts
-    # each on its own tool row), and the saved-only fields one per call.
-    def joined(runs)
+    # each on its own tool row), and the saved-only fields one per call:
+    # +ids+ (ToolIds.next_ids) as tool_ids.
+    def joined(runs, ids:)
       images = runs.flat_map { |run| Array(run[:images]) }
       entry = { role: "tool_response", content: runs.map { |run| run[:capped_output] }.join(SEPARATOR) }
       unless images.empty?
@@ -50,18 +62,67 @@ module Samagotchi
       saved = { tool_params: runs.map { |run| run[:shown_params] }, tool_labels: runs.map { |run| run[:shown_label] },
                 tool_diffs: runs.map { |run| run[:diff] } }
       saved.each { |key, values| entry[key] = values if values.any? }
+      entry[:tool_ids] = ids
       entry
     end
 
     # The chat loop's entry for one call: its capped output, paired with the
-    # call by +tool_call_id+.
-    def single(run, tool_call_id:)
+    # call by +tool_call_id+, and its chi-owned id (a one-id +ids+, as
+    # #joined's tool_ids).
+    def single(run, tool_call_id:, ids:)
       entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call_id }
       entry[:images] = run[:images] if run[:images]&.any?
       entry[:tool_params] = run[:shown_params] if run[:shown_params]
       entry[:tool_labels] = run[:shown_label] if run[:shown_label]
       entry[:tool_diffs] = run[:diff] if run[:diff]
+      entry[:tool_ids] = ids
       entry
     end
+
+    # An entry's +content+ as +count+ runs, the way the LLMContextView
+    # sends them: one run is the whole content (its lead when it opens
+    # with one), more are #split's. The count may not match (#runs_named
+    # checks the parts).
+    # @return [Array<RunText>]
+    def runs(content, count)
+      return split(content, -1) unless count == 1
+
+      run = split(content, -1).first
+      return [RunText.new(name: nil, lead: "", body: content.to_s)] unless run&.name
+
+      [RunText.new(name: run.name, lead: run.lead, body: content.to_s.delete_prefix(run.lead))]
+    end
+
+    # +content+'s runs (#runs) when they are a batch's whose calls are
+    # +names+, in order: as many parts as calls, each opening with its
+    # call's "[name]" lead; nil when not. The part count alone can be
+    # fooled: a "ran as:" line before a lead (ToolRunner, a corrected call)
+    # merges that run into the one before it, and an output holding
+    # SEPARATOR + "[x] " adds a part, and the two cancel out. So whatever
+    # changes a run of an entry (a strategy's edit, LLMContextView) checks
+    # the names first.
+    # @return [Array<RunText>, nil]
+    def runs_named(content, names)
+      parts = runs(content, names.size)
+      parts.map(&:name) == names.map(&:to_s) ? parts : nil
+    end
+
+    # A joined entry's +content+ split into its runs (RunText), by the
+    # SEPARATOR heuristic: a part that opens with a "[name]" lead starts a
+    # run, any other part is the previous run's own text (the first one a
+    # run without a name). +limit+ goes to String#split (-1 keeps trailing
+    # empty parts, so the texts join back to +content+).
+    # @return [Array<RunText>]
+    def split(content, limit = 0)
+      content.to_s.split(SEPARATOR, limit).each_with_object([]) do |part, runs|
+        if (match = part.match(LEAD))
+          runs << RunText.new(name: match[1], lead: match[0], body: match.post_match)
+        elsif runs.empty?
+          runs << RunText.new(name: nil, lead: "", body: part)
+        else
+          runs[-1] = runs.last.with(body: "#{runs.last.body}#{SEPARATOR}#{part}")
+        end
+      end
+    end
   end
 end

data/lib/samagotchi/tools/builtin_calls.rb

@@ -52,7 +52,8 @@ module Samagotchi
         "context_read" => { content: "name", fallback: :prefix_or_raw },
         "delegate" => { content: "task", fallback: :prefix_or_raw },
         "ask_user_question" => { content: "question", also: %w[question], verbatim: %w[options], options: true,
-                                 fallback: :raw }
+                                 fallback: :raw },
+        "forget_outputs" => { content: "note", also: %w[note], verbatim: %w[ids keep restore] }
       }.freeze
 
       # One built-in's mapping, resolved from its schema and OVERRIDES.
@@ -73,7 +74,7 @@ module Samagotchi
 
       # @return [Hash{String => Row}]
       def rows
-        @rows ||= ToolDeclarations::TOOL_SCHEMAS.to_h { |schema| [schema[:name], row_for(schema)] }.freeze
+        @rows ||= ToolDeclarations::BUILTIN_SCHEMAS.to_h { |schema| [schema[:name], row_for(schema)] }.freeze
       end
 
       def row_for(schema)

data/lib/samagotchi/tools/builtins.rb

@@ -22,6 +22,7 @@ require_relative "context_read"
 require_relative "delegate"
 require_relative "delegate_result"
 require_relative "ask_user_question"
+require_relative "forget_outputs"
 require_relative "../guardrails/parent_approvals"
 require_relative "../model_profile"
 
@@ -56,6 +57,8 @@ module Samagotchi
         DelegateResult,
         AskUserQuestion
       ].freeze
+      # The built-ins an LLM context layer adds (offered only under it).
+      LAYER_CLASSES = [ForgetOutputs].freeze
 
       # The handlers that pass more than the call's content.
       HANDLERS = {
@@ -104,7 +107,8 @@ module Samagotchi
         DelegateResult::NAME => lambda do |call, kctx|
           DelegateResult.call(call[:content], session: call[:session], timeout: call[:timeout], peers: kctx.peers)
         end,
-        AskUserQuestion::NAME => ->(call, kctx) { kctx.ask_user_question(call) }
+        AskUserQuestion::NAME => ->(call, kctx) { kctx.ask_user_question(call) },
+        ForgetOutputs::NAME => ->(call, kctx) { kctx.forget_outputs(call) }
       }.freeze
 
       module_function
@@ -152,16 +156,22 @@ module Samagotchi
 
       # @param command_description [Boolean] false: execute declares no
       #   description parameter (execute.description off)
+      # @param policy [String, nil] llm_context.policy, the sentence
+      #   forget_outputs' description carries
       # @return [Registry] a new registry with the built-ins, in
-      #   TOOL_SCHEMAS order (an Engine's own, which bundles add to)
-      def registry(command_description: true)
+      #   TOOL_SCHEMAS order (an Engine's own, which bundles add to), then
+      #   forget_outputs, offered only under the forget layer
+      def registry(command_description: true, policy: ToolDeclarations::FORGET_OUTPUTS_POLICY)
         by_name = CLASSES.to_h { |klass| [klass::NAME, klass] }
-        ToolDeclarations::TOOL_SCHEMAS.each_with_object(Registry.new) do |schema, registry|
+        registry = ToolDeclarations::TOOL_SCHEMAS.each_with_object(Registry.new) do |schema, built|
           schema = ToolDeclarations.without_command_description(schema) unless command_description
           klass = by_name.fetch(schema[:name])
           handler = HANDLERS.fetch(klass::NAME) { ->(call, _kctx) { klass.call(call[:content]) } }
-          registry.register(klass::NAME, schema: schema, handler: handler)
+          built.register(klass::NAME, schema: schema, handler: handler)
         end
+        registry.register(ForgetOutputs::NAME, schema: ToolDeclarations.forget_outputs_schema(policy: policy),
+                                               handler: HANDLERS.fetch(ForgetOutputs::NAME), layer: :forget)
+        registry
       end
 
       # @return [Registry] the built-ins alone, frozen: a KernelLoop or a

data/lib/samagotchi/tools/context_read.rb

@@ -15,8 +15,17 @@ module Samagotchi
     class ContextRead
       NAME = "context_read"
       DEFAULT_MAX_CHARS = 10_000
-      # Room for the header and the paging line inside the cap.
-      HEADER_ROOM = 1_000
+      # The smallest cap it pages to (a smaller one is taken as this).
+      MIN_CHARS = 2_000
+      # What the kernel puts before the output ("[context_read]\n"), and
+      # ToolRunner counts in the same cap: a page that fits never gets the
+      # runner's cut on top of its own paging.
+      PREFIX_ROOM = "[#{NAME}]\n".length
+      # Between the header and the page.
+      SEPARATOR = "\n---\n"
+      # A page's text at least, whatever the header takes (a header over
+      # the cap is the runner's to cut).
+      MIN_PAGE_CHARS = 200
 
       def self.name = NAME
 
@@ -44,7 +53,7 @@ module Samagotchi
         # (specs, a bare kernel) has only its folder.
         root = peers.respond_to?(:project_root) ? peers.project_root : ProjectScope.root_for(peers.cwd)
         @attached = ContextSources.attached(peers.session_id, project_root: root, state_dir: @state_dir)
-        @max_chars = [max_chars.to_i, HEADER_ROOM * 2].max
+        @max_chars = [max_chars.to_i, MIN_CHARS].max
         @now = now
       end
 
@@ -97,7 +106,7 @@ module Samagotchi
 
         page = lines[(first - 1)..] || []
         page = page.first(positive(limit)) if positive(limit)
-        page = fit(page)
+        page = fit(page, room: room(header, lines.size))
         last = first + page.size - 1
         @own.update_subscription(attached.name) { |sub| sub.with(read: snapshot.revision) }
 
@@ -105,7 +114,7 @@ module Samagotchi
           more = last < lines.size ? " Pass offset: #{last + 1} for more." : ""
           header << "Lines #{first}-#{last} of #{lines.size}.#{more}"
         end
-        "#{header.join("\n")}\n---\n#{page.join}"
+        "#{header.join("\n")}#{SEPARATOR}#{page.join}"
       end
 
       def header_lines(attached, snapshot)
@@ -119,16 +128,24 @@ module Samagotchi
         header
       end
 
-      # The lines that fit in the cap (at least one, cut when that one is
-      # longer than the cap).
-      def fit(lines)
-        budget = @max_chars - HEADER_ROOM
+      # What the output takes besides the page: the kernel's prefix, the
+      # header, its paging line at its longest (every number +count+) and
+      # the separator.
+      def room(header, count)
+        paging = "\nLines #{count}-#{count} of #{count}. Pass offset: #{count} for more."
+        PREFIX_ROOM + header.join("\n").length + paging.length + SEPARATOR.length
+      end
+
+      # The lines that fit in the cap beside +room+ (at least one, cut,
+      # its "…\n" included, when that one is longer).
+      def fit(lines, room:)
+        budget = [@max_chars - room, MIN_PAGE_CHARS].max
         taken = []
         used = 0
         lines.each do |line|
           break if used + line.length > budget && taken.any?
 
-          taken << (line.length > budget ? "#{line[0, budget]}…\n" : line)
+          taken << (line.length > budget ? "#{line[0, budget - 2]}…\n" : line)
           used += line.length
         end
         taken

data/lib/samagotchi/tools/forget_outputs.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Samagotchi
+  module Tools
+    # forget_outputs, the forget layer's tool (LLMContextStrategy :forget):
+    # the model forgets its own tool outputs by id, with a note that keeps
+    # what it learned, or restores ones it forgot. Its schema is
+    # ToolDeclarations.forget_outputs_schema; the work is LLMContextForget's,
+    # on the running turn's conversation (KernelLoop#forget_outputs, through
+    # the handler's kctx). This reads the call: models write lists as JSON,
+    # as a JSON string, or as words, so every id form is taken.
+    class ForgetOutputs
+      NAME = "forget_outputs"
+
+      def self.name = NAME
+
+      # A call, read: the ids to forget, the note, the lines to keep
+      # ({id => [[first, last], …]}), and the ids to restore.
+      Request = Data.define(:ids, :note, :keep, :restore) do
+        def restore? = !restore.empty?
+      end
+
+      ID = /#?\b(t\d+)\b/
+      RANGE = /#?\b(t\d+)\s*[:=]\s*(?:lines?\s*)?(\d+)\s*(?:[-–]\s*(\d+))?/
+
+      # @param call [Hash] the internal call (BuiltinCalls: ids:, note: as
+      #   content:, keep:, restore:)
+      # @return [Request]
+      def self.parse(call)
+        keep = ranges(call[:keep])
+        Request.new(ids: (ids(call[:ids]) + keep.keys).uniq, note: (call[:note] || call[:content]).to_s.strip,
+                    keep: keep, restore: ids(call[:restore]))
+      end
+
+      # The ids in +raw+: "t41", "#t41", a list, a JSON list, or words.
+      def self.ids(raw)
+        text(raw).scan(ID).flatten.uniq
+      end
+
+      # "t42:12-40" (or "t42: lines 12-40", "t42=7") entries, by id.
+      def self.ranges(raw)
+        text(raw).scan(RANGE).each_with_object({}) do |(id, first, last), keep|
+          first = first.to_i
+          last = last ? last.to_i : first
+          (keep[id] ||= []) << [first, last] if first.positive? && last >= first
+        end
+      end
+
+      def self.text(raw)
+        case raw
+        when nil then ""
+        when Array then raw.map { |item| text(item) }.join(" ")
+        when Hash then raw.map { |key, value| "#{key}:#{text(value)}" }.join(" ")
+        else raw.to_s
+        end
+      end
+      private_class_method :text
+    end
+  end
+end

data/lib/samagotchi/tools/registry.rb

@@ -21,8 +21,14 @@ module Samagotchi
       # @!attribute preview [#call, nil] call → the activity line's params
       # @!attribute targets [#call, nil] call → what guardrail rules match
       # @!attribute source [String] "core", or the bundle that added it
-      Entry = Struct.new(:name, :schema, :handler, :label, :preview, :targets, :source, keyword_init: true) do
+      # @!attribute layer [Symbol, nil] the LLM context layer the tool
+      #   belongs to (LLMContextStrategy): offered only in a turn running
+      #   under it (forget_outputs, :forget); nil: always
+      Entry = Struct.new(:name, :schema, :handler, :label, :preview, :targets, :source, :layer, keyword_init: true) do
         def core? = source == "core"
+
+        # Offered in a turn under +layers+ (the turn's LLM context layers).
+        def offered?(layers) = layer.nil? || Array(layers).include?(layer)
       end
 
       def initialize
@@ -30,33 +36,44 @@ module Samagotchi
       end
 
       # @return [Entry]
-      def register(name, schema:, handler:, label: nil, preview: nil, targets: nil, source: "core")
+      def register(name, schema:, handler:, label: nil, preview: nil, targets: nil, source: "core", layer: nil)
         raise ArgumentError, "tool #{name} is already registered" if @entries.key?(name)
 
         @entries[name] = Entry.new(name: name, schema: schema, handler: handler, label: label, preview: preview,
-                                   targets: targets, source: source)
+                                   targets: targets, source: source, layer: layer)
       end
 
       # Remove a tool (a plugin's tool set changed after load).
       # @return [Entry, nil] the removed entry
       def unregister(name) = @entries.delete(name.to_s)
 
-      # @return [Entry, nil]
+      # @return [Entry, nil] whatever the turn offers
       def [](name) = @entries[name.to_s]
 
       def key?(name) = @entries.key?(name.to_s)
 
+      # The entry +name+ names when a turn under +layers+ offers it (the
+      # one a call dispatches to).
+      # @return [Entry, nil]
+      def offered(name, layers: [])
+        entry = self[name]
+        entry if entry&.offered?(layers)
+      end
+
+      # The tools a turn offers is per turn: +layers+, the turn's LLM
+      # context layers (LLMContextStrategy), adds the tools gated by them.
+      # Without layers (none, the default) the list is what it always was.
       # @return [Array<String>] in declaration order
-      def names = entries.map(&:name)
+      def names(layers: []) = entries(layers: layers).map(&:name)
 
       # @return [Array<Entry>] in declaration order
-      def entries
-        core, added = @entries.values.partition(&:core?)
+      def entries(layers: [])
+        core, added = @entries.values.select { |entry| entry.offered?(layers) }.partition(&:core?)
         core + added.sort_by { |entry| [entry.source.to_s, entry.name] }
       end
 
       # @return [Array<Hash>] the schemas, in declaration order
-      def schemas = entries.map(&:schema)
+      def schemas(layers: []) = entries(layers: layers).map(&:schema)
 
       def freeze
         @entries.freeze

data/lib/samagotchi/version.rb

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

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

@@ -367,7 +367,7 @@ function cardHtml(s, { deletable = false, archivable = false, selectable = false
   const kidsHtml = fam ? familyChipHtml(fam, { open }) : "";
   const rowsHtml = fam && rows && open ? familyRowsHtml(fam, { activeId: selected, matchIds, archivable: !selectable }) : "";
   const membersAttr = fam ? ` data-members="${escapeHtml(fam.members.map((m) => m.session.id).join(" "))}"` : "";
-  return `<div class="card${s.archived ? " archived" : ""}${waiting || familyWaiting ? " waiting" : ""}${selectable && picked ? " picked" : ""}${fam && rows && open ? " family-open" : ""}" data-id="${s.id}"${membersAttr} title=""${escapeHtml(tip)}${memTitle ? ` · ${escapeHtml(memTitle)}` : ""}"><div class="preview">${preview}</div>${s.recap ? `<div class="recap" title="${escapeHtml(s.recap)}">${escapeHtml(s.recap)}</div>` : ""}<div class="meta"><span class="status dot ${escapeHtml(s.status)}${waiting ? " waiting" : ""}" title="${escapeHtml(dotWord)}" aria-label="${escapeHtml(dotWord)}"></span>${waitingHtml}${stoppedHtml}${timeHtml}${ctxHtml}${folderHtml}${parentChipHtml(s)}${kidsHtml}${ownerBadgeHtml(s)}${archivedHtml}${s.used_memory_names && s.used_memory_names.length ? `<span title="${escapeHtml(s.used_memory_names.join(", "))}">mem ${s.used_memory_names.length}</span>` : ""}</div>${rowsHtml}${skipHtml}${pickHtml}${selectable ? "" : cardToolsHtml(s, { deletable, archivable })}</div>`;
+  return `<div class="card${s.archived ? " archived" : ""}${waiting || familyWaiting ? " waiting" : ""}${selectable && picked ? " picked" : ""}${fam && rows && open ? " family-open" : ""}" data-id="${s.id}"${membersAttr} title="${escapeHtml(tip)}${memTitle ? ` · ${escapeHtml(memTitle)}` : ""}"><div class="preview">${preview}</div>${s.recap ? `<div class="recap" title="${escapeHtml(s.recap)}">${escapeHtml(s.recap)}</div>` : ""}<div class="meta"><span class="status dot ${escapeHtml(s.status)}${waiting ? " waiting" : ""}" title="${escapeHtml(dotWord)}" aria-label="${escapeHtml(dotWord)}"></span>${waitingHtml}${stoppedHtml}${timeHtml}${ctxHtml}${folderHtml}${parentChipHtml(s)}${kidsHtml}${ownerBadgeHtml(s)}${archivedHtml}</div>${rowsHtml}${skipHtml}${pickHtml}${selectable ? "" : cardToolsHtml(s, { deletable, archivable })}</div>`;
 }
 
 function cardToolsHtml(s, { deletable, archivable }) {

data/lib/samagotchi/worker.rb

@@ -279,6 +279,10 @@ module Samagotchi
 
       input_files = SessionInbox.find_new_input_files(@session_dir)
       return idle_pass if input_files.empty?
+      # A command queued since the look above, before these prompts were
+      # written (an answer's /continue yes, then a prompt), still runs
+      # first; the next pass takes the prompts.
+      return if run_queued_commands
 
       run_input_files(input_files)
     end