rubino-agent 0.5.1 → 0.5.2.2

data/lib/rubino/cli/commands.rb

@@ -601,6 +601,11 @@ module Rubino
             ui.warning("gem update failed. If this is a permission error, re-run the installer or try `gem update --user-install #{Rubino::UpdateCheck::GEM_NAME}`.")
             return
           end
+          # The subprocess installed the new gem into this process's gem paths,
+          # but our in-memory spec list predates it — refresh so the version
+          # query below sees what `gem update` just wrote (else we'd report the
+          # pre-update version and claim "already up to date").
+          Gem.refresh
           new_v = Rubino::UpdateCheck.installed_gem_version(Rubino::UpdateCheck::GEM_NAME)
           if new_v && Gem::Version.new(new_v) > Gem::Version.new(current)
             ui.info("rubino is now on v#{new_v} (was v#{current}).")

data/lib/rubino/commands/built_ins.rb

@@ -22,7 +22,6 @@ module Rubino
         "/agent" => "Switch the primary agent (/agent <name>; a bare /<name> or Tab cycles)",
         "/agents" => "List background subagents; ↓+Enter to attach & steer one live, or steer/probe/view by id",
         "/tasks" => "Alias for /agents",
-        "/reply" => "Answer a subagent that is blocked waiting on you (e.g. an approval)",
         "/stop" => "Stop a running subagent (/stop <id>; alias for /agents <id> --stop)",
         "/jobs" => "List the background job queue (status counts); /jobs <id> for detail",
         "/skills" => "List skills; activate one ('none' clears), or enable/disable NAME",

data/lib/rubino/commands/executor.rb

@@ -20,10 +20,7 @@ module Rubino
       # conversation / config / turn state, so they run on the composer's reader
       # thread concurrently with the turn thread without a race (output routes
       # through the SAME render-mutex-serialized UI). /stop reuses the cancel
-      # machinery Esc / `--stop` use (already concurrent-safe). /reply is kept
-      # BLOCKED: its interactive form `/reply <id>` (-> @ui.ask) can't be told
-      # apart by NAME from the safe inline form, and would steal the reader's
-      # stdin (default-to-blocked on a concurrency hazard). Single source of
+      # machinery Esc / `--stop` use (already concurrent-safe). Single source of
       # truth for the busy-time classification — #busy_disposition reads it.
       IMMEDIATE_WHILE_BUSY = %w[agents tasks stop status jobs help commands dirs].freeze
 
@@ -210,9 +207,6 @@ module Rubino
           result.is_a?(Hash) ? result : :handled
         when "stop" # `/stop <id>` → `/agents <id> --stop` alias (FRICTION-4)
           agents_handler.handle_stop_alias(arguments) # returns :handled
-        when "reply"
-          agents_handler.handle_reply(arguments)
-          :handled
         when "sessions"
           sessions_handler.handle_sessions(arguments)
         when "probe"

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

@@ -6,21 +6,19 @@ require "time"
 module Rubino
   module Commands
     module Handlers
-      # The `/agents` (alias `/tasks`) drill-in surface and the `/reply` answer
-      # path, extracted from Commands::Executor (batch B).
+      # The `/agents` (alias `/tasks`) drill-in surface, extracted from
+      # Commands::Executor (batch B).
       #
       # The "see what other agents do" surface. Lists background subagents from
       # the BackgroundTasks registry (the async `task` substrate), drills into a
-      # single one's result/error, steers/probes/stops a running one, and routes
-      # a human /reply back down to a blocked child.
+      # single one's result/error, and steers/probes/stops a running one.
       #
       #   /agents                 → list
       #   /agents <id>            → drill-in (result / error / status)
       #   /agents <id> --stop     → cancel a running subagent
       #   /agents <id> steer "…"  → fire-and-forget note into the child's context
       #   /agents <id> probe "…"  → ephemeral read-only peek
-      #   /reply <id> <answer>    → answer a child blocked on a human/parent ask
-      class Agents # rubocop:disable Metrics/ClassLength -- one cohesive /agents command surface (list/attach/steer/probe/reply/approval/budget); splitting would scatter the routing
+      class Agents
         include Rubino::UI::ProbeWaitIndicator
 
         # How many times the parked-child approval prompt re-renders after an
@@ -32,34 +30,23 @@ module Rubino
         # is in-memory, never persisted — so a prior session's id is genuinely
         # gone after a REPL restart. The bare "no such id" left the user thinking
         # they'd mistyped; this names the real reason so they don't hunt for a
-        # typo. Surfaced from EVERY not-found path (/agents <id>, /reply <id>,
-        # /stop <id>, steer, probe).
-        RESET_HINT = "(subagents reset when rubino restarts)"
+        # typo. Surfaced from EVERY not-found path (/agents <id>, /stop <id>,
+        # steer, probe).
+        RESET_HINT = "(background tasks reset when rubino restarts)"
 
         def initialize(ui:)
           @ui = ui
         end
 
-        # Auto-open the EXISTING interactive prompt for ONE pending subagent
-        # request the human must act on — the REPL idle loop calls this at every
-        # idle tick so the affordance presents ITSELF instead of forcing the user
-        # to guess `/agents <id>` or `/reply <id>` (the maintainer's "auto-open
-        # the existing dropdown" ask). A request that arrives mid-turn, or
-        # survives a turn that is interrupted/aborted, is re-detected here the
-        # next time the REPL returns to idle, so it is never lost.
-        #
-        # Reuses the SAME primitives the manual slash paths use:
-        #   :needs_approval   → #resolve_agent_approval  (the approve/deny/always
-        #                       prompt, identical to /agents <id>)
-        #   :blocked_on_human → #prompt_reply_answer + #deliver_reply (the ◆ ask
-        #                       takeover, identical to /reply <id> with no inline
-        #                       answer)
-        # The manual slash commands stay as a fallback; this is just the primary,
-        # zero-typing surface. Approval is offered FIRST (a parked tool holds a
-        # concurrency slot and a possibly dangerous side effect, so it is the more
-        # urgent gate). Resolves at most ONE request per call so the loop repaints
-        # and re-checks between each. Returns true when it presented a request
-        # (the caller re-polls), false when nothing was pending.
+        # Auto-open the EXISTING interactive approval prompt for ONE pending
+        # subagent request the human must act on — the REPL idle loop calls this at
+        # every idle tick so the affordance presents ITSELF instead of forcing the
+        # user to guess `/agents <id>`. A request that arrives mid-turn, or
+        # survives a turn that is interrupted/aborted, is re-detected here the next
+        # time the REPL returns to idle, so it is never lost. Resolves at most ONE
+        # request per call so the loop repaints and re-checks between each. Returns
+        # true when it presented a request (the caller re-polls), false when
+        # nothing was pending.
         #
         # SECURITY: this changes WHEN the existing approval prompt appears (now it
         # auto-presents), never WHAT requires approval — the gate semantics, the
@@ -68,64 +55,16 @@ 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
-          if (entry = registry.awaiting_human.first)
-            answer_one_human(entry)
-            return true
-          end
           false
         end
 
-        # The ONE shared "surface the answer affordance for a child blocked on the
-        # human, read the human's answer, deliver it down the SAME wire" step —
-        # used by BOTH the idle poll (#auto_resolve_pending) and the mid-turn
-        # auto-open (BottomComposer#request_takeover, triggered by the child's
-        # ask_parent the instant it blocks). Keeping it in one method means the
-        # delivery semantics (free-text or pick-an-option → #deliver_reply →
-        # BackgroundTasks#deliver_answer) are identical on both paths and the
-        # parent turn's state is NEVER touched (deliver_answer only decides the
-        # child's gate + pushes its steer note under the registry mutex).
-        #
-        # An empty answer (the human cancelled — Esc in the dropdown / blank
-        # free-text) leaves the child PARKED and reports it: the affordance/hint
-        # stays so it can re-open. Returns true once it surfaced the request
-        # (the caller re-polls / re-reads awaiting_human for the next head).
-        def answer_one_human(entry) # rubocop:disable Naming/PredicateMethod -- a prompt-presenting mutator that reports it surfaced a request
-          answer = prompt_reply_answer(entry)
-          if answer.to_s.strip.empty?
-            @ui.info("No answer given — #{entry.id} is still waiting.")
-          else
-            deliver_reply(entry, answer)
-          end
-          true
-        end
-
-        # FIFO drain of the children blocked on the human, used by the MID-TURN
-        # auto-open: deliver the head, then RE-READ awaiting_human (a 2nd child
-        # may have asked while the dropdown was open, or the head may have been
-        # delivered/timed-out) and surface the next head, until the queue is
-        # empty. Each #answer_one_human runs its own dropdown takeover; a child
-        # that arrives mid-open simply appends and is picked up on the re-read.
-        # Bounded by the live awaiting_human snapshot shrinking each pass, so it
-        # always terminates. Runs on the INPUT thread (it owns the keyboard).
-        def answer_all_human
-          loop do
-            entry = Tools::BackgroundTasks.instance.awaiting_human.first
-            break unless entry
-
-            answer_one_human(entry)
-            # A cancelled (still-blocked) head would otherwise re-surface forever:
-            # stop once the head is no longer awaiting an answer it just got, OR
-            # the human declined it. We break when the FIRST awaiting_human entry
-            # is unchanged after the attempt (cancelled), so an Esc doesn't loop.
-            still = Tools::BackgroundTasks.instance.awaiting_human.first
-            break if still && still.id == entry.id
-          end
-        end
-
         def handle_agents(arguments)
           args = arguments.to_s.strip
           return show_agents_list if args.empty?
@@ -165,45 +104,6 @@ module Rubino
           :handled
         end
 
-        # child->parent ASK_PARENT answer: /reply <id> <answer>. Resolves the
-        # child's ask gate (Run::ApprovalGate#decide) so a BLOCKING ask unwinds with
-        # the answer as its tool result, and ALSO pushes the answer onto the child's
-        # steer queue so a NON-BLOCKING ask folds it in at its next turn boundary.
-        # Either way the answer PERSISTS in the child's context. With no inline
-        # answer, falls back to an interactive prompt (the ◆ takeover, like the
-        # approval menu). Clears the blocked state and unblocks the tree.
-        def handle_reply(arguments)
-          tokens = arguments.to_s.strip.split(/\s+/)
-          id     = tokens.shift
-          if id.nil? || id.empty?
-            show_blocked_agents
-            return
-          end
-
-          # /reply is UNSCOPED: the human is the ultimate supervisor and may answer
-          # ANY blocked node — one waiting on the human (:blocked_on_human) OR one
-          # waiting on its agent-parent (:blocked_on_parent), if the human chooses
-          # to step in.
-          entry = Tools::BackgroundTasks.instance.find(id)
-          if entry.nil?
-            @ui.error("no background subagent with id #{id}. #{RESET_HINT}")
-            return
-          end
-          unless %i[blocked_on_human blocked_on_parent].include?(entry.status)
-            @ui.error("#{id} is not waiting on you.")
-            return
-          end
-
-          answer = dequote(tokens.join(" "))
-          answer = prompt_reply_answer(entry) if answer.to_s.strip.empty?
-          if answer.to_s.strip.empty?
-            @ui.info("No answer given — #{id} is still waiting.")
-            return
-          end
-
-          deliver_reply(entry, answer)
-        end
-
         private
 
         # parent->child STEER: a fire-and-forget note that enters the child's
@@ -218,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
 
@@ -239,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
@@ -266,118 +161,6 @@ module Rubino
           @ui.info(pastel.dim("┄┄ end probe (nothing was saved to #{id}) ┄┄"))
         end
 
-        # The interactive ◆ takeover for /reply with no inline answer — mirrors the
-        # approval menu (composer-suspend, ◆ glyph) so answering an ask_parent feels
-        # exactly like answering an approval, a pattern the user already knows.
-        #
-        # Content of the affordance (LOCKED "options if present, else free text"):
-        #   * the asking child supplied `options:` → an arrow-SELECT of those
-        #     concrete options PLUS a trailing "✎ Answer (type)…" entry that opens
-        #     the free-text field. Reuses @ui.select (the same TTY::Prompt picker
-        #     /sessions resume uses) under run_in_terminal.
-        #   * no options → the original free-text @ui.ask, but offered as a
-        #     [Answer / Dismiss] choice first so Esc/Dismiss cleanly CANCELS this
-        #     answer (the child stays blocked) instead of forcing a blank line.
-        # Returns the chosen/typed answer, or "" when the human cancels (Esc /
-        # Dismiss / blank) — answer_one_human then leaves the child parked.
-        def prompt_reply_answer(entry)
-          @ui.info("")
-          @ui.info("◆ #{entry.id} (#{entry.subagent}) asks — everything is waiting on this")
-          @ui.info("   ❓ #{entry.ask_question}")
-          options = Array(entry.ask_options)
-          options.empty? ? prompt_free_or_dismiss : prompt_pick_option(options)
-        end
-
-        # No options: [Answer / Dismiss]. "Answer" opens the free-text field;
-        # "Dismiss" (or Esc, which #select returns as nil) cancels — child stays
-        # blocked. A UI without #select (scripted/legacy) falls straight through
-        # to the free-text @ui.ask so the existing behaviour is preserved.
-        def prompt_free_or_dismiss
-          return @ui.ask("✎ your answer › ").to_s unless @ui.respond_to?(:select)
-
-          choice = @ui.select("Answer this subagent?",
-                              [["✎ Answer (type)…", :answer], ["Dismiss (leave blocked)", :dismiss]])
-          return "" unless choice == :answer
-
-          @ui.ask("✎ your answer › ").to_s
-        end
-
-        # Options present: arrow-select one of them, or the trailing free-text
-        # entry. Esc (nil from #select) cancels. Reuses @ui.select; a UI without
-        # it answers free-text so scripted callers keep working.
-        def prompt_pick_option(options)
-          return @ui.ask("✎ your answer › ").to_s unless @ui.respond_to?(:select)
-
-          # An option is either a plain string (label==value) or a
-          # {label, description} map. Show the clean LABEL (with the description
-          # as a dim hint when present) and deliver the label STRING as the
-          # answer — never a raw hash literal (#475-3).
-          choices = options.map { |o| [option_label(o), option_value(o)] }
-          choices << ["✎ Answer (type)…", :__free__]
-          choice = @ui.select("Pick an answer for the subagent:", choices)
-          return "" if choice.nil? # Esc / cancelled
-          return @ui.ask("✎ your answer › ").to_s if choice == :__free__
-
-          choice
-        end
-
-        # The display label for a picker option: the bare label for a string,
-        # or "label — description" (description dimmed) for a {label, description}
-        # map. The description rides the label since @ui.select takes only
-        # [label, value] pairs (no separate hint slot).
-        def option_label(opt)
-          return opt.to_s unless opt.is_a?(Hash)
-
-          label = opt["label"].to_s
-          desc  = opt["description"].to_s
-          desc.empty? ? label : "#{label} #{pastel.dim("— #{desc}")}"
-        end
-
-        # The value DELIVERED to the child for a picker option: always the label
-        # STRING (the description is presentational only), so the child's answer
-        # is clean text, never a hash literal.
-        def option_value(opt)
-          opt.is_a?(Hash) ? opt["label"].to_s : opt.to_s
-        end
-
-        # Routes the answer back DOWN to the child: decide the gate (unblocks a
-        # blocking ask with the answer as its tool result) and push it onto the
-        # steer queue (a non-blocking ask folds it in next turn). Then clear the
-        # blocked state and repaint so the ⛔ marker clears.
-        def deliver_reply(entry, answer)
-          # The ONE shared answer wire (also used by the model-callable
-          # answer_child tool): decide the gate + push the steer note + clear the
-          # blocked state, all in BackgroundTasks#deliver_answer.
-          # H5 — deliver_answer reports HONESTLY now: false when the child has
-          # already finished and neither delivery path landed. Say so instead of
-          # the false "resumes at its next turn" — there is no next turn.
-          delivered = Tools::BackgroundTasks.instance.deliver_answer(entry.id, answer)
-          if delivered
-            @ui.info("↳ answered #{entry.id}: #{truncate(answer, 80)}")
-            @ui.info("✓ tree unblocked · #{entry.id} resumes at its next turn")
-          else
-            @ui.info("↳ answer to #{entry.id}: #{truncate(answer, 80)}")
-            @ui.error("⚠ not delivered — #{entry.id} already finished; it never saw your answer.")
-          end
-          @ui.set_subagent_cards if @ui.respond_to?(:set_subagent_cards)
-        end
-
-        # Lists the children currently blocked on the human (the /reply with no id
-        # case) so the user can see who is waiting and on what.
-        def show_blocked_agents
-          blocked = Tools::BackgroundTasks.instance.awaiting_human
-          if blocked.empty?
-            @ui.info("No subagent is waiting on you.")
-            return
-          end
-
-          @ui.info(pastel.red("⛔ #{blocked.size} subagent waiting on you:"))
-          blocked.each do |e|
-            @ui.info("  #{e.id} · #{e.subagent}: #{truncate(e.ask_question, 80)}")
-          end
-          @ui.info("/reply <id> <answer> to answer")
-        end
-
         # Strips a single pair of wrapping double/single quotes from a steer/probe
         # argument so `steer "be terse"` lands as `be terse`, not `"be terse"`.
         def dequote(text)
@@ -426,7 +209,7 @@ module Rubino
 
         def show_agent_snapshot(entry)
           return render_agent_watch(entry) if %i[
-            running stopping blocked_on_human blocked_on_parent needs_approval
+            running stopping needs_approval
           ].include?(entry.status)
 
           show_agent_result(entry)
@@ -597,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.")
@@ -700,20 +494,18 @@ module Rubino
             return
           end
 
-          unless %i[running needs_approval blocked_on_human blocked_on_parent].include?(entry.status)
+          unless %i[running needs_approval stopping].include?(entry.status)
             @ui.info("#{id} already #{entry.status} — nothing to stop.")
             return
           end
 
-          # A child parked on a human approval or an ask_parent is blocked in its
-          # gate's wait; the shared #stop_entry cancels the gates so it wakes
-          # (Interrupted → deny/cancel) and unwinds instead of holding its thread
-          # until the bound, runs the stop-cascade so every DESCENDANT parked on a
-          # blocking ask unwinds too (S5a — no orphaned blocked grandchild), marks
-          # the stop FIRST so the very next /agents list shows ◌ stopping instead
-          # of a stale ● running (#108) and the worker's terminal write records the
-          # unwind as :stopped, not ✗ failed (#13), then flips the runner token. The
-          # SAME body the parent-teardown #cancel_all uses — one implementation.
+          # A child parked on a human approval is blocked in its gate's wait; the
+          # shared #stop_entry cancels the gate so it wakes (Interrupted →
+          # deny/cancel) and unwinds instead of holding its thread, marks the stop
+          # FIRST so the very next /agents list shows ◌ stopping instead of a stale
+          # ● running (#108) and the worker's terminal write records the unwind as
+          # :stopped, not ✗ failed (#13), then flips the runner token. The SAME
+          # body the parent-teardown #cancel_all uses — one implementation.
           registry.stop_entry(entry)
           @ui.success("Stop requested for #{id} (#{entry.subagent}); it unwinds at its next checkpoint.")
         end
@@ -728,8 +520,6 @@ module Rubino
             when :stopping         then ["◌", "stopping", :yellow]
             when :stopped          then ["⊘", "stopped", :yellow]
             when :needs_approval   then ["●", "approval", :yellow]
-            when :blocked_on_human then ["⛔", "waiting on you", :red]
-            when :blocked_on_parent then ["◷", "waiting on parent", :cyan]
             when :failed then ["✗", "failed", :red]
             else ["✓", "done", :green]
             end
@@ -784,10 +574,10 @@ module Rubino
         end
 
         # Direct entry points for the REPL's agent-attach view: it calls these with
-        # the user's RAW text, so a steer/probe/reply note keeps embedded quotes
-        # intact instead of being serialized into a "steer \"…\"" command string
-        # and mangled by the executor's whitespace-split + single-pair dequote.
-        public :steer_agent, :probe_agent, :deliver_reply
+        # the user's RAW text, so a steer/probe note keeps embedded quotes intact
+        # instead of being serialized into a "steer \"…\"" command string and
+        # mangled by the executor's whitespace-split + single-pair dequote.
+        public :steer_agent, :probe_agent
       end
     end
   end

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/compression/line_skeleton.rb

@@ -23,7 +23,7 @@ module Rubino
       # leaves behind. `first_line`/`line_count` are the 1-based read window into
       # the ORIGINAL file (so a `read offset=first_line limit=line_count` returns
       # exactly these bytes — the drill-in invariant).
-      Elision = Struct.new(:first_line, :line_count, :indent, keyword_init: true)
+      Elision = Struct.new(:first_line, :line_count, keyword_init: true)
 
       def initialize(keep_method_body_max_lines:)
         @keep_max = keep_method_body_max_lines.to_i

data/lib/rubino/compression/python_code_skeleton.rb

@@ -87,7 +87,7 @@ module Rubino
         return nil if ranges.nil?
 
         ranges
-          .map { |first, count| Elision.new(first_line: first, line_count: count, indent: nil) }
+          .map { |first, count| Elision.new(first_line: first, line_count: count) }
           .sort_by(&:first_line)
       end
 

data/lib/rubino/compression/ruby_code_skeleton.rb

@@ -73,7 +73,7 @@ module Rubino
         line_count = last - first + 1
         return nil if line_count <= @keep_max
 
-        Elision.new(first_line: first, line_count: line_count, indent: nil)
+        Elision.new(first_line: first, line_count: line_count)
       end
     end
   end

data/lib/rubino/compression/tree_sitter_code_skeleton.rb

@@ -111,7 +111,7 @@ module Rubino
         line_count = inner_last - inner_first + 1
         return nil unless line_count > @keep_max
 
-        Elision.new(first_line: inner_first, line_count: line_count, indent: nil)
+        Elision.new(first_line: inner_first, line_count: line_count)
       end
     end
   end

data/lib/rubino/config/configuration.rb

@@ -60,6 +60,26 @@ module Rubino
         value.positive? ? value : UI::BottomComposer::MAX_INPUT_ROWS
       end
 
+      # Render the in-flight streamed block as formatted markdown in the live
+      # region (display.live_markdown). Default true; only an explicit false
+      # falls back to the legacy raw live tail.
+      def display_live_markdown?
+        dig("display", "live_markdown") != false
+      end
+
+      # Wrap each live-region frame in DEC-2026 synchronized output
+      # (display.synchronized_output). Default true; only an explicit false
+      # falls back to the legacy per-write frames.
+      def display_synchronized_output?
+        dig("display", "synchronized_output") != false
+      end
+
+      # Syntax-highlight committed code blocks (display.code_highlight). Default
+      # true; only an explicit false falls back to plain (uncoloured) code.
+      def display_code_highlight?
+        dig("display", "code_highlight") != false
+      end
+
       # -- Paste section (UI::PasteStore: the file-backed paste pipeline) --
       # A paste with MORE than this many lines collapses to a
       # "[Pasted text #N +M lines]" placeholder in the composer (expanded to
@@ -192,18 +212,10 @@ module Rubino
         dig("tasks", "max_live_probes_per_child") || Defaults.dig("tasks", "max_live_probes_per_child")
       end
 
-      # Bound (seconds) a BLOCKING ask_parent waits for an answer before the child
-      # self-heals and proceeds with its best judgement (S5a). Reuses the
-      # approval-gate timeout convention — a sane upper bound, never "forever" —
-      # so an abandoned ask never parks the child's thread indefinitely. Default 900.
-      def tasks_ask_parent_timeout
-        dig("tasks", "ask_parent_timeout") || Defaults.dig("tasks", "ask_parent_timeout")
-      end
-
       # Bound (seconds) an interactive `question`/clarify waits for the human to
       # answer before it EXPIRES CLEANLY and the agent proceeds with its best
-      # judgement (#552). Mirrors the ask_parent / Hermes clarify_timeout
-      # convention — a generous upper bound (default 600s = 10 min, well above
+      # judgement (#552). Mirrors the Hermes clarify_timeout convention — a
+      # generous upper bound (default 600s = 10 min, well above
       # human reading/deliberation time), never the 30s stale-chunk window and
       # never "forever". An abandoned clarify self-heals into the NO_ANSWER
       # outcome instead of hanging the run or being killed by the stale watchdog.
@@ -272,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.
@@ -437,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