rubino-agent 0.5.2.1 → 0.5.2.2

data/lib/rubino/commands/handlers/agents.rb

@@ -32,7 +32,7 @@ module Rubino
         # they'd mistyped; this names the real reason so they don't hunt for a
         # typo. Surfaced from EVERY not-found path (/agents <id>, /stop <id>,
         # steer, probe).
-        RESET_HINT = "(subagents reset when rubino restarts)"
+        RESET_HINT = "(background tasks reset when rubino restarts)"
 
         def initialize(ui:)
           @ui = ui
@@ -55,7 +55,10 @@ module Rubino
         # decision through the same gate.
         def auto_resolve_pending # rubocop:disable Naming/PredicateMethod -- a prompt-presenting mutator that reports whether it surfaced a request, not a pure query
           registry = Tools::BackgroundTasks.instance
-          if (entry = registry.awaiting_approval.first)
+          # Oldest-first (FIFO), skipping any the user dismissed with "Decide
+          # later" (#586): those stay parked cards the user re-opens deliberately,
+          # so the auto-modal doesn't re-pop them at every idle tick.
+          if (entry = registry.awaiting_approval.find { |e| !e.approval_snoozed })
             resolve_agent_approval(entry)
             return true
           end
@@ -115,10 +118,10 @@ module Rubino
           end
 
           if Tools::BackgroundTasks.instance.steer(id, text)
-            @ui.info("steer ▸ #{id} ← #{truncate(text, 80)}  (parked · enters child context next turn)")
+            @ui.info("steer ▸ #{id} ← #{truncate(text, 80)}")
             @ui.set_subagent_cards if @ui.respond_to?(:set_subagent_cards)
           else
-            @ui.error("cannot steer #{id} — no such running subagent. #{RESET_HINT}")
+            @ui.error("cannot steer #{id} — no such running background task. #{RESET_HINT}")
           end
         end
 
@@ -136,26 +139,21 @@ module Rubino
 
           entry = Tools::BackgroundTasks.instance.find(id)
           unless entry
-            @ui.error("cannot probe #{id} — no such subagent. #{RESET_HINT}")
+            @ui.error("cannot probe #{id} — no such background task. #{RESET_HINT}")
             return
           end
 
-          @ui.info(pastel.dim("┄┄ probe → #{id} ┄┄  (ephemeral · not saved · child trajectory unchanged)"))
-          # A probe answers from the child's context AT THIS INSTANT; right after
-          # spawn that context is still empty and the child honestly says it isn't
-          # working on anything yet — hint so that doesn't read as broken (#112).
-          if entry.tool_count.to_i.zero?
-            @ui.info(pastel.dim("   (snapshot at this instant — the child just started and its " \
-                                "context is still empty; probe again in a moment)"))
-          end
+          @ui.info(pastel.dim("┄┄ probe → #{id} ┄┄  (ephemeral · not saved · trajectory unchanged)"))
+          hint = entry.peek_hint
+          @ui.info(pastel.dim("   #{hint}")) if hint
           @ui.info("?  #{question}")
-          # The peek is a synchronous side-inference (seconds of model wait) with
-          # nothing streaming — show the same thinking row /probe got in #58 so
-          # the gap before the ⟵ answer never looks frozen (#146). TTY only;
-          # Null/API adapters and pipes stay silent.
+          # The peek is polymorphic: a subagent runs a synchronous LLM side-inference
+          # (seconds of model wait — show the thinking row so the gap doesn't look
+          # frozen, #58/#146), while a shell returns an instant output snapshot with
+          # no model call. Either way #peek lives on the entry, not here.
           probe_thinking_started(@ui)
           answer = begin
-            Tools::SubagentProbe.new.peek(entry: entry, question: question)
+            entry.peek(question)
           ensure
             probe_thinking_finished(@ui)
           end
@@ -382,6 +380,17 @@ module Rubino
           choice = ask_budget_answer(entry)
           return if choice.nil?
 
+          if choice == :later
+            # "Decide later" (#586): don't decide the gate — leave the child parked
+            # and SNOOZE its auto-modal so it stops re-popping at idle. It stays a
+            # `wants +budget` card the user resolves deliberately via the picker /
+            # `/agents <id>`. This is the safe ↓-target that keeps a mis-aimed
+            # picker ↓+Enter from force-summarizing a child.
+            Tools::BackgroundTasks.instance.snooze_approval(entry.id)
+            @ui.info("#{entry.id} left waiting — /agents #{entry.id} to grant or summarize.")
+            return
+          end
+
           grant = choice == :grant
           gate.decide(entry.approval_id, grant)
           @ui.info(grant ? "Granted more budget to #{entry.id}." : "#{entry.id} will summarize now.")

data/lib/rubino/commands/handlers/status.rb

@@ -232,9 +232,12 @@ module Rubino
 
         def status_background_line
           entries = Tools::BackgroundTasks.instance.list
-          running = entries.count { |e| e.status == :running }
-          ids     = entries.first(3).map(&:id).join(", ")
-          line    = "#{running} running · #{entries.size} total"
+          running = entries.select { |e| e.status == :running }
+          # The parenthetical names the RUNNING ids (capped), matching the count
+          # and the picker — not the first rows of the total table, which could
+          # name a finished task while hiding a running one (subagents + shells).
+          ids  = running.first(3).map(&:id).join(", ")
+          line = "#{running.size} running · #{entries.size} total"
           ids.empty? ? line : "#{line} (#{ids})"
         rescue StandardError
           "(unavailable)"

data/lib/rubino/config/configuration.rb

@@ -284,14 +284,6 @@ module Rubino
         dig("memory", "auto_extract") == true
       end
 
-      # Background session-summary aux-LLM job (SummarizeSessionJob). Default ON
-      # (absent ⇒ true), so existing behaviour is unchanged; an explicit false
-      # turns it off — letting the whole background aux-LLM surface
-      # (extract/distill/summarize) be disabled together.
-      def memory_auto_summarize?
-        dig("memory", "auto_summarize") != false
-      end
-
       # Throttle interval (in turns) for memory.auto_extract (#412). Returns a
       # positive Integer; nil/<=1 (or absent) ⇒ 1 = every turn. The lifecycle
       # only enqueues ExtractMemoryJob when turns-since-last >= this.
@@ -449,6 +441,31 @@ module Rubino
         dig("auxiliary", task.to_s) || {}
       end
 
+      # True when the auxiliary +task+ resolves to the SAME server ENDPOINT as the
+      # main model — i.e. its LLM calls land on the main model server's KV slot.
+      # Slot-sharing is about the endpoint (provider + base_url), NOT the model: a
+      # different model on the SAME server still shares the single slot. At the
+      # defaults (auxiliary.<task>.provider:"main", empty base_url) this is true.
+      #
+      # It matters for local single-slot servers: an aux call sharing the slot
+      # OVERWRITES the live conversation's KV-cache prefix, so the next user turn
+      # re-prefills the whole context (the "freeze after N turns"). The post-turn
+      # extraction/distill gates use this to stay OFF the interactive slot,
+      # mirroring how Hermes/Claude Code keep automatic memory work off the live
+      # conversation (extract at session end instead). A DISTINCT aux endpoint
+      # (its own server/slot) does not evict, so inter-turn extraction stays on.
+      def auxiliary_on_main_endpoint?(task)
+        cfg = auxiliary_config(task)
+        provider = cfg["provider"].to_s.strip
+        aux_provider = provider.empty? || provider == "main" ? dig("model", "provider").to_s : provider
+
+        aux_base = cfg["base_url"].to_s.strip
+        aux_base = provider_config(aux_provider)["base_url"].to_s.strip if aux_base.empty?
+        main_base = provider_config(dig("model", "provider").to_s)["base_url"].to_s.strip
+
+        aux_provider == dig("model", "provider").to_s && aux_base == main_base
+      end
+
       # Returns true when the primary model can ingest images directly. Honours
       # an explicit `model.supports_vision` override; otherwise falls back to
       # ContentBuilder's name-pattern heuristic. Used by VisionTool to decide

data/lib/rubino/config/defaults.rb

@@ -134,9 +134,10 @@ module Rubino
             "base_url" => nil,
             "timeout" => 120
           },
-          # Document summarization. The `summarize_file` tool delegates here so
-          # the raw bytes of a huge file are map-reduced in these aux calls and
-          # never enter the main agent context (only the final summary returns).
+          # Summarization aux task. Used by skill distillation
+          # (jobs/handlers/distill_skill_job.rb, task: "summarize") to condense
+          # captured transcripts into a reusable skill; routed through this aux
+          # backend so it never blocks the live turn.
           # `provider: "main"` reuses the primary's provider/model.
           "summarize" => {
             "provider" => "main",
@@ -186,9 +187,16 @@ module Rubino
           # Pure SAFETY-NET wall clock on a single turn, NOT a working-time cap
           # (#408). Hermes' IterationBudget has no clock at all; the old 120s
           # KILLED slow-but-legitimate test/build turns mid-work (and was the
-          # root that made the #403 budget-extension loop possible). Raised to a
-          # backstop only a genuinely runaway turn should ever hit. nil disables.
-          "max_turn_seconds" => 600,
+          # root that made the #403 budget-extension loop possible). Even the
+          # raised 600s still guillotines legitimate work: a genuine multi-file
+          # "compare docs vs code" audit on a LOCAL model runs ~40 tool calls in
+          # ~13 min, blowing 600s and force-summarizing the turn into a confused
+          # non-answer — the exact failure #408 warned about. So the wall clock
+          # is DISABLED by default (nil): the tool-iteration budget
+          # (max_tool_iterations, 90) is the real runaway guard, and individual
+          # hung tools are bounded by their own per-tool timeouts. Hermes parity.
+          # Set a positive number to re-arm the clock as an explicit backstop.
+          "max_turn_seconds" => nil,
           # 5 retries with exponential backoff = 1+2+4+8+16 = 31s total wait.
           # Sized to absorb common provider blips (MiniMax intl in particular
           # has been observed returning "API server error - please try again"
@@ -377,12 +385,6 @@ module Rubino
           "enabled" => true,
           "backend" => "sqlite",
           "auto_extract" => true,
-          # Background session-summary aux-LLM job (SummarizeSessionJob), enqueued
-          # once a session passes the message threshold. Gateable like
-          # auto_extract / skills.auto_distill so the whole background aux-LLM
-          # surface can be turned off together (e.g. an engine-vs-engine
-          # benchmark that wants ONLY the task, no side-work). Default on.
-          "auto_summarize" => true,
           # Throttle the background aux-LLM memory extraction to ~every N turns
           # instead of EVERY turn (#412), mirroring Hermes' nudge_interval (10):
           # extraction enqueues only when turns-since-last-extract >= this. 10x
@@ -743,7 +745,7 @@ module Rubino
           # passwords, JWTs…) from tool output before it enters context, the
           # transcript, or the aux model. ON by default (secure default,
           # Hermes #17691). Applied to read / grep / shell / shell_output /
-          # shell_tail / summarize_file content via Security::Redactor. Set
+          # shell_tail / read_attachment content via Security::Redactor. Set
           # false ONLY when you need raw credential values in tool output
           # (e.g. working on the redactor itself). NOT a security boundary —
           # the shell runs as the same OS user; this is defense-in-depth.

data/lib/rubino/context/prompt_assembler.rb

@@ -43,6 +43,14 @@ module Rubino
         end
       end
 
+      # Model-name substrings that trigger tool-use-enforcement steering under the
+      # "auto" default. Ported from Hermes' TOOL_USE_ENFORCEMENT_MODELS, plus
+      # "minimax" — rubino's default targets it and its field notes document the
+      # same text-leaked-tool-call / narrate-instead-of-act failures.
+      TOOL_USE_ENFORCEMENT_MODELS = %w[
+        gpt codex gemini gemma grok glm qwen deepseek minimax
+      ].freeze
+
       def initialize(session:, memory_context:, config:, agent_definition: nil,
                      ignore_rules: false)
         @session = session
@@ -77,7 +85,21 @@ module Rubino
         # compaction/fork (those rows exist in prod). Mirrors Claude Code's
         # pre-call sanitization: never emit an orphan tool block that 400s a
         # strict provider. Conservative by design — when in doubt, keep.
-        history = repair_tool_pairs(@message_store.for_session(@session[:id]))
+        #
+        # Drop `[harness control]` messages FIRST: they are ephemeral within-turn
+        # runtime control (Loop's iteration-cap summary nudge, the resume /
+        # truncation / blocked-tool reminders, #75), written on the user's behalf
+        # for ONE model call — not durable conversation. They stay in the DB for
+        # audit/scrollback (and are already excluded from the rewind picker,
+        # chat_command#rewindable_message?), but must never re-enter the model's
+        # context on a LATER turn. Re-feeding the synthetic "you've reached the
+        # maximum tool-calling iterations" user turn made the model believe it
+        # was perpetually capped and parrot a "start a new session" refusal on
+        # every subsequent turn instead of acting. This is the single chokepoint
+        # every surface (CLI + web/API) rebuilds context through, so filtering
+        # here fixes them all.
+        durable = @message_store.for_session(@session[:id]).reject { |m| harness_control?(m) }
+        history = repair_tool_pairs(durable)
         history.each do |msg|
           messages << msg.to_context
         end
@@ -87,6 +109,17 @@ module Rubino
 
       private
 
+      # A `[harness control]`-marked message is runtime control the agent wrote
+      # on the user's behalf for a single model call (#75), never durable
+      # conversation — see #build for why re-feeding it poisons later turns. The
+      # marker only ever rides the user role (the iteration-cap nudge, resume /
+      # truncation / blocked-tool reminders), so scope the check to user rows to
+      # avoid dropping a genuine assistant message that merely quotes the marker.
+      def harness_control?(msg)
+        msg.role == "user" &&
+          msg.content.to_s.start_with?(Agent::Loop::HARNESS_CONTROL_MARKER)
+      end
+
       # Final pairing repair over the full history (a list of Message objects).
       # Two orphan shapes 400 strict providers; we fix both, conservatively:
       #
@@ -209,6 +242,15 @@ module Rubino
 
         parts = []
         parts << agent_identity
+        # Behavioral steering grouped with identity (and inside the cached stable
+        # prefix — model-stable). Ported from Hermes (prompt_builder.py): the
+        # open-weight models rubino targets (MiniMax/Qwen/GLM/DeepSeek) narrate-
+        # instead-of-act and leak tool-calls as text without this — the config
+        # key existed but its injection was dropped in the port (#588 dead key).
+        enforcement = tool_use_enforcement_block
+        parts << enforcement if enforcement
+        memory_guide = memory_guidance_block
+        parts << memory_guide if memory_guide
         product = product_preamble
         parts << "[Product]\n#{product}" if product
         env = environment_block
@@ -394,6 +436,52 @@ module Rubino
         FALLBACK
       end
 
+      # The tool-use-enforcement block (+ per-family operational guidance), or nil
+      # when not applicable. Gated by `agent.tool_use_enforcement`:
+      #   "auto" (default) — inject when the model id matches a known weak-FC family
+      #   true / false     — always / never
+      #   Array of substrings — custom match list
+      # Hermes-aligned (system_prompt.py): the open-weight models rubino runs need
+      # explicit steering to call tools instead of describing intended actions.
+      def tool_use_enforcement_block
+        return nil unless inject_tool_use_enforcement?
+
+        parts = [load_builtin_prompt("tool_use_enforcement")].compact
+        model = model_id_lower
+        if model.include?("gemini") || model.include?("gemma")
+          parts << load_builtin_prompt("tool_use_enforcement_google")
+        end
+        if model.include?("gpt") || model.include?("codex") || model.include?("grok")
+          parts << load_builtin_prompt("tool_use_enforcement_openai")
+        end
+        parts.compact!
+        parts.empty? ? nil : parts.join("\n\n")
+      end
+
+      def inject_tool_use_enforcement?
+        setting = @config.dig("agent", "tool_use_enforcement")
+        case setting
+        when true then true
+        when false then false
+        when Array then setting.any? { |p| model_id_lower.include?(p.to_s.downcase) }
+        else # "auto" or any unrecognised value — the default model-family list
+          TOOL_USE_ENFORCEMENT_MODELS.any? { |p| model_id_lower.include?(p) }
+        end
+      end
+
+      # The memory-write discipline block (HOW to curate memory), or nil when the
+      # memory subsystem is off. Hermes injects this when the memory tool is
+      # present; rubino gates on `memory.enabled` (default on), the same signal.
+      def memory_guidance_block
+        return nil if @config.dig("memory", "enabled") == false
+
+        load_builtin_prompt("memory_guidance")
+      end
+
+      def model_id_lower
+        @config.dig("model", "default").to_s.downcase
+      end
+
       def product_preamble
         return nil unless @config.respond_to?(:prompts_preamble)
 

data/lib/rubino/context/summary_builder.rb

@@ -116,16 +116,6 @@ module Rubino
         text
       end
 
-      # Builds and saves the summary to the database
-      def build_and_save!
-        message_store = Session::Store.new
-        messages = message_store.for_session(@session_id)
-        return if messages.size < 10
-
-        summary = build(messages: messages, previous_summary: load_previous_summary)
-        save!(summary)
-      end
-
       private
 
       def summary_system_prompt
@@ -172,18 +162,6 @@ module Rubino
         end.join("\n\n")
       end
 
-      def summary_store
-        @summary_store ||= Session::SummaryStore.new
-      end
-
-      def load_previous_summary
-        summary_store.latest_content(@session_id)
-      end
-
-      def save!(content)
-        summary_store.insert(session_id: @session_id, content: content)
-      end
-
       def fallback_summary(messages, previous_summary)
         parts = []
         parts << "## Previous Context\n#{previous_summary}" if previous_summary

data/lib/rubino/interaction/events.rb

@@ -51,8 +51,8 @@ module Rubino
 
       # Tool events
       TOOL_STARTED = :tool_started
-      # Incremental progress from a long-running tool (e.g. summarize_file's
-      # per-chunk "summarizing chunk N/M" or shell stdout lines). Emitted from
+      # Incremental progress from a long-running tool (e.g. shell stdout lines
+      # streamed as they arrive). Emitted from
       # the tool's stream_chunk callback so a tool that runs for minutes
       # without finishing keeps the API event stream alive — the SSE idle
       # watchdog only fires when NOTHING flows, so a genuinely hung run is

data/lib/rubino/interaction/lifecycle.rb

@@ -12,8 +12,8 @@ module Rubino
 
       # Queue priority for the user-visible memory save (#79). Lower = drained
       # first (the queue orders by `priority, run_at`). Below the default 100 the
-      # other post-turn jobs use, so an ExtractMemoryJob jumps ahead of the
-      # SummarizeSessionJob backlog and the "remember X" → recall is prompt.
+      # other post-turn jobs use, so an ExtractMemoryJob jumps ahead of any
+      # default-priority backlog and the "remember X" → recall is prompt.
       PRIORITY_EXTRACT_MEMORY = 50
       # The session this lifecycle is currently bound to. Starts as the session
       # passed in, but an automatic budget-triggered compaction swaps it to the
@@ -25,10 +25,16 @@ module Rubino
         @session
       end
 
+      # How the turn just run by #execute terminated (Agent::Loop#stop_reason),
+      # read back by the owning Runner so the subagent-completion path can report
+      # a force-summarized/truncated run as PARTIAL rather than "completed".
+      # nil until a turn has run.
+      attr_reader :last_stop_reason
+
       def initialize(session:, event_bus:, ui:, config:, ignore_rules: false,
                      agent_definition: nil, cancel_token: nil,
                      model_override: nil, provider_override: nil,
-                     max_tool_iterations: nil, polishing: nil)
+                     max_tool_iterations: nil, polishing: nil, interactive: false)
         @session = session
         @event_bus = event_bus
         @ui = ui
@@ -44,6 +50,9 @@ module Rubino
         # API/server path and nested subagent runs, which keep the original
         # synchronous inline drain (no interactive prompt to free up).
         @polishing = polishing
+        # True only on the interactive REPL (more in-process turns follow). Gates
+        # automatic memory extraction OFF the live KV slot between turns (#608c).
+        @interactive = interactive
         # Explicit per-run cap from `--max-turns` (Runner → here → IterationBudget).
         # nil ⇒ use the configured agent_max_tool_iterations (#141).
         @max_tool_iterations = max_tool_iterations
@@ -393,7 +402,11 @@ module Rubino
         # (API/server) ⇒ no sink; the result stays reachable via `task_result`.
         Rubino.with_background_sink(input_queue) do
           Rubino.with_event_bus(@event_bus) do
-            loop_runner.run(messages: messages, tools: tools)
+            content = loop_runner.run(messages: messages, tools: tools)
+            # Post-turn state, captured like #active_session: the caller reads it
+            # off #last_stop_reason after #execute returns.
+            @last_stop_reason = loop_runner.stop_reason
+            content
           end
         end
       end
@@ -426,14 +439,36 @@ module Rubino
         # extract off the interactive path AND cuts its cadence ~10x.
         enqueued = false
 
-        if @config.memory_auto_extract? && interval_due?(turn_no, @config.memory_auto_extract_interval)
+        # KV-cache coherence (#608c): when the aux model shares the MAIN model's
+        # server slot (the default — see Configuration#auxiliary_on_main_endpoint?),
+        # an inter-turn extraction OVERWRITES the live conversation's prefix cache,
+        # so the NEXT user turn re-prefills the whole context (the "freeze after N
+        # turns"). On a single-slot local server there is no way to run a divergent
+        # aux prompt between turns without evicting — so we DON'T: extraction is
+        # deferred to the session-end flush (Memory::Flusher#flush_on_session_end!,
+        # runner.rb) and to compaction, exactly like Hermes/Claude Code keep
+        # automatic memory work off the live conversation. No recall is lost: the
+        # per-session memory snapshot is FROZEN at session start (PromptAssembler
+        # @snapshots), so a mid-session extract is never recalled THIS session
+        # anyway — only the next one, which the end-of-session flush already feeds.
+        #
+        # Scoped to the INTERACTIVE REPL (@interactive), where more in-process
+        # turns follow this one and would reuse the live KV prefix. A headless
+        # one-shot / API run exits after its single turn, so there is no live
+        # cache to protect and the extraction must still run there (it is how the
+        # fact gets stored before exit, #358). A DISTINCT aux endpoint (its own
+        # slot) never evicts, so it keeps the inter-turn cadence too.
+        extract_evicts_live_slot = @interactive && @config.auxiliary_on_main_endpoint?("compression")
+        distill_evicts_live_slot = @interactive && @config.auxiliary_on_main_endpoint?("summarize")
+
+        if @config.memory_auto_extract? && !extract_evicts_live_slot &&
+           interval_due?(turn_no, @config.memory_auto_extract_interval)
           # ExtractMemoryJob is the user-visible save ("remember X" → recall):
-          # it must drain AHEAD of the SummarizeSessionJobs that pile up one per
-          # turn once a session passes 20 messages (#79). The drain orders by
-          # `priority, run_at` (lower = first), so a higher-priority (smaller
-          # number) extract jumps the queue of slower, less time-sensitive
-          # summaries that were enqueued before it — otherwise the save the user
-          # is about to recall waits minutes behind a FIFO backlog of summaries.
+          # it must drain AHEAD of any default-priority post-turn jobs already in
+          # the queue (#79). The drain orders by `priority, run_at` (lower =
+          # first), so a higher-priority (smaller number) extract jumps slower,
+          # less time-sensitive jobs enqueued before it — otherwise the save the
+          # user is about to recall waits behind a FIFO backlog.
           queue.enqueue("ExtractMemoryJob", { session_id: @session[:id] },
                         priority: PRIORITY_EXTRACT_MEMORY, drain_inline: drain_inline)
           @event_bus.emit(Events::JOB_ENQUEUED, type: "ExtractMemoryJob")
@@ -448,20 +483,19 @@ module Rubino
         # already covered) before spending one aux-model call. Handler lookup
         # is load-order independent: Jobs::Registry resolves the class from
         # the Handlers namespace on demand (#81).
-        if @config.skills_auto_distill? && interval_due?(turn_no, @config.skills_auto_distill_interval)
+        if @config.skills_auto_distill? && !distill_evicts_live_slot &&
+           interval_due?(turn_no, @config.skills_auto_distill_interval)
           queue.enqueue("DistillSkillJob", { session_id: @session[:id] }, drain_inline: drain_inline)
           @event_bus.emit(Events::JOB_ENQUEUED, type: "DistillSkillJob")
           enqueued = true
         end
 
-        # Summarize if session is getting long (gateable like the extract/distill
-        # background jobs, so the whole aux-LLM surface can be turned off together).
-        message_count = @message_store.count(@session[:id])
-        if @config.memory_auto_summarize? && message_count > 20
-          queue.enqueue("SummarizeSessionJob", { session_id: @session[:id] }, drain_inline: drain_inline)
-          @event_bus.emit(Events::JOB_ENQUEUED, type: "SummarizeSessionJob")
-          enqueued = true
-        end
+        # NB: there is no per-turn session-summary job. The running summary that
+        # PromptAssembler injects is produced by the THRESHOLD-GATED compaction
+        # (Context::Compressor → SummaryStore), exactly as Hermes / Claude Code /
+        # Codex do it — summarize INLINE only when the context approaches its
+        # limit, never as a background job after every turn (which on a slow local
+        # gateway would pile up faster than it drains and starve the live turns).
 
         # Detach: kick the polishing worker so it drains the rows just enqueued
         # off this thread. Returns immediately — the next prompt is never gated.