rubino-agent 0.3.0 → 0.5.0

data/lib/rubino/agent/model_call_runner.rb

@@ -73,6 +73,12 @@ module Rubino
         # error can't bleed into the empty-retry count.
         error_attempts = 0
 
+        # Cumulative error-path backoff already spent on THIS call (seconds), the
+        # denominator of the TOTAL-wall-time cap (#dead-host). Reset per call! so
+        # a fresh turn gets the full retry budget. A fallback rotation also zeroes
+        # it (handle_error! → activate_fallback!) so the new adapter starts clean.
+        @error_retry_spent = 0.0
+
         # The degenerate-response recovery ladder (Slice 5). Fresh per call! so
         # its per-turn counters (prefill ≤2, empty ≤3) reset exactly where the
         # reference zeroes them on a successful content turn.
@@ -237,7 +243,10 @@ module Rubino
           thinking: request.thinking,
           prefill: seed,
           image_paths: request.image_paths,
-          stream: request.stream?
+          stream: request.stream?,
+          on_intermediate_message: request.on_intermediate_message,
+          on_round_trip: request.on_round_trip,
+          budget_exhausted: request.budget_exhausted
         )
       end
 
@@ -281,13 +290,29 @@ module Rubino
         classified = LLM::ErrorClassifier.classify(error)
 
         unless classified.retryable && attempts < api_max_retries
-          return 0 if activate_fallback!(iteration)
+          return reset_error_budget! if activate_fallback!(iteration)
 
           raise_with_auth_hint(error, classified)
         end
 
         attempts += 1
         wait = error_backoff(attempts, classified, error)
+
+        # TOTAL wall-time cap (#dead-host). A permanently-unreachable host fails
+        # with a RETRYABLE connection timeout every attempt, so the count budget
+        # alone lets backoff stack to ~75-110s before giving up. Once the backoff
+        # already spent PLUS this next planned wait would cross the budget, stop
+        # retrying: try a fallback first (resets the budget for the new adapter),
+        # otherwise fail fast with a clear "gave up after ~Ns" message. This
+        # bounds the dead-host wall WITHOUT cutting genuine recovery inside the
+        # window — a transient blip that clears before the budget still retries.
+        if exceeds_total_budget?(wait)
+          return reset_error_budget! if activate_fallback!(iteration)
+
+          raise_retry_budget_exhausted!(error, attempts)
+        end
+
+        @error_retry_spent += wait
         @event_bus.emit(Interaction::Events::MODEL_CALL_STARTED,
                         iteration: iteration, error_retry: attempts)
         log_safely(event: "llm.retry", attempt: attempts, sleep: wait, error: error.message)
@@ -295,6 +320,37 @@ module Rubino
         attempts
       end
 
+      # A fallback rotation gives the NEW adapter a fresh count budget AND a fresh
+      # wall-time budget — the time spent on the dead primary shouldn't penalise a
+      # healthy fallback. Zero the spent-clock and return 0 (the loop's reset
+      # sentinel for error_attempts).
+      def reset_error_budget!
+        @error_retry_spent = 0.0
+        0
+      end
+
+      # True when the cumulative error-path backoff already spent plus the next
+      # planned wait would cross the total wall-time budget. nil budget ⇒ no total
+      # cap (count-based retries only — the pre-cap behaviour).
+      def exceeds_total_budget?(next_wait)
+        budget = retry_total_timeout
+        return false if budget.nil?
+
+        (@error_retry_spent + next_wait) > budget
+      end
+
+      # Fail fast on the dead-host path: the host keeps timing out and the
+      # wall-time budget is spent, so surface a clear, actionable message instead
+      # of stalling for another full backoff. Preserves the original error and
+      # the auth-hint upgrade for the (rare) auth-shaped retryable case.
+      def raise_retry_budget_exhausted!(error, attempts)
+        spent = @error_retry_spent.round(1)
+        raise Rubino::Error,
+              "Gave up after ~#{spent}s and #{attempts - 1} retries: the provider host is " \
+              "unreachable or persistently failing (#{error.message}). Check the model's " \
+              "base_url / network, or configure a fallback model."
+      end
+
       # Jittered backoff for an invalid/empty response — 5s base, 120s cap,
       # via the INVALID_RESPONSE preset.
       def empty_backoff(attempt)
@@ -311,9 +367,14 @@ module Rubino
                                       retry_after: retry_after_for(classified, error))
       end
 
+      # The per-retry backoff CEILING for this error. The non-overload path now
+      # honours the (previously dead) api_retry_backoff_cap_seconds knob (16s)
+      # instead of the hardcoded 60s ERROR_PATH ceiling — capping the worst
+      # single wait to ~24s. Overload/unknown still ride the higher overload cap
+      # so a 529 backs off long enough to clear the hot window.
       def error_backoff_cap(classified)
         overload = [LLM::FailoverReason::OVERLOADED, LLM::FailoverReason::UNKNOWN]
-        base = BackoffPolicy::ERROR_PATH[:max]
+        base = backoff_cap
         overload.include?(classified.reason) ? [base, overload_backoff_cap].max : base
       end
 
@@ -373,6 +434,23 @@ module Rubino
         @config.dig("agent", "api_retry_backoff_overload_cap_seconds") || 60
       end
 
+      # Per-retry backoff ceiling for the ordinary error path (non-overload). The
+      # ERROR_PATH preset max is the fallback when the knob is unset.
+      def backoff_cap
+        @config.dig("agent", "api_retry_backoff_cap_seconds") || BackoffPolicy::ERROR_PATH[:max]
+      end
+
+      # Total error-path retry wall-time budget (seconds), or nil for no total
+      # cap. A non-positive value is treated as nil (no cap) rather than an
+      # instant give-up — a 0 here is almost certainly a misconfig.
+      def retry_total_timeout
+        raw = @config.dig("agent", "api_retry_total_timeout_seconds")
+        return nil if raw.nil?
+
+        n = Float(raw, exception: false)
+        n if n&.positive?
+      end
+
       def log_safely(**fields)
         Rubino.logger.warn(**fields)
       rescue StandardError

data/lib/rubino/agent/prompts/build.txt

@@ -1,7 +1,11 @@
 [Identity]
-You are rubino, a software engineering assistant running in the user's
-real environment. You read, edit, and run code with actual tool access —
-treat the file system, git, and the shell as production by default.
+You are rubino, a general-purpose software engineering assistant running in
+the user's real environment. You read, edit, and run code with actual tool
+access — treat the file system, git, and the shell as production by default.
+You are not tied to any one language or framework: work in whatever language
+and stack the project in front of you uses (Python, JavaScript, Go, Ruby,
+Rust, …). Detect the project's language from its files and conventions; never
+assume or default to one.
 
 [Principles]
 - Smallest change that solves the task. No speculative refactors, no
@@ -27,8 +31,10 @@ treat the file system, git, and the shell as production by default.
   map-reduces the file in a separate context and returns only the summary,
   so the raw text never fills this conversation. Reach for `read` (with
   offset/limit) or `grep` only when you need exact lines, not an overview.
-- For arbitrary code execution prefer `ruby` (sandboxed eval) over
-  `shell`. Use `shell` for binaries the host already provides.
+- The `ruby` tool runs sandboxed Ruby for quick computation/scripting —
+  reach for it when Ruby fits the project. Otherwise use `shell` for the
+  host's binaries and the project's own toolchain (its interpreter, package
+  manager, test runner). Match the project's language; don't default to Ruby.
 - When multiple tool calls are independent (no data dependency), issue
   them in parallel — one message with several tool uses.
 - Cite files as `path/to/file.rb:42` so the user can jump straight to the
@@ -43,6 +49,17 @@ treat the file system, git, and the shell as production by default.
   several background subagents at once; check one early with `task_result` or
   stop it with `task_stop`. Pass `background: false` only when the very next
   step depends on the subagent's output.
+- A BACKGROUND subagent runs ASYNCHRONOUSLY: there is nothing to "wait" for and
+  no result to poll for now — the user is notified and you receive the
+  `[background-task]` result automatically when it finishes. So do not narrate
+  waiting (no "I'll wait for it", no "task_result isn't available yet, nothing I
+  can do"); just finish your current reply or move on to other work. If you
+  genuinely cannot proceed without the answer this step, use `background: false`
+  instead of waiting.
+- Subagents are FULLY capable: the general subagent has every tool available,
+  including `task` (it can spawn its own subagents) and `ask_parent` (it can ask
+  YOU a clarifying question mid-task). Never decline to delegate by claiming a
+  subagent lacks `task`/`ask_parent` or can't reach the parent — that is false.
 
 [Safety]
 - Destructive shell commands (`rm -rf`, `git push --force`, `git reset

data/lib/rubino/agent/response_validator.rb

@@ -27,6 +27,13 @@ module Rubino
       def valid?(response)
         return [false, :nil_response] if response.nil?
         return [false, :interrupted]  if response.interrupted?
+        # A budget-Halt response (#355a) is a deliberate turn-ending signal — the
+        # streaming round-trip loop was cut short because the iteration/time
+        # budget ran out, not a model failure. It may legitimately carry no
+        # content (no preamble streamed), so it must NOT be judged empty and sent
+        # through the recovery ladder; the Loop reads #halted? and runs its
+        # budget-exhausted summary.
+        return [true, nil]            if response.respond_to?(:halted?) && response.halted?
         return [true, nil]            if response.has_tool_calls?
         return [false, :empty_response] if response.content.to_s.strip.empty?
 
@@ -41,6 +48,7 @@ module Rubino
       # Tool-call responses are never degenerate — the tool call IS the answer.
       def degenerate?(response)
         return false if response.nil? || response.interrupted?
+        return false if response.respond_to?(:halted?) && response.halted?
         return false if response.has_tool_calls?
 
         !content_after_think_block?(response.content)

data/lib/rubino/agent/runner.rb

@@ -13,7 +13,7 @@ module Rubino
 
       def initialize(session_id: nil, model_override: nil, provider_override: nil,
                      max_turns: nil, ignore_rules: false, ui: nil, agent_definition: nil,
-                     event_bus: nil, announce_session: true)
+                     event_bus: nil, announce_session: true, session_source: "cli")
         @ui = ui || Rubino.ui
         # An in-chat rewind/fork builds a runner on the child session but has its
         # own purpose-built "┄ rewound to message N — editing ┄" marker, so the
@@ -33,14 +33,32 @@ module Rubino
         @max_turns = max_turns
         @ignore_rules = ignore_rules
         @agent_definition = agent_definition
+        # The `source` stamped on a freshly-created session row. Defaults to
+        # "cli" (a user-driven REPL/one-shot session); the `task` tool passes
+        # "subagent" so internal subagent prompt-sessions can be filtered out of
+        # the user-facing /sessions picker + `sessions list` (they're machinery,
+        # not the user's own conversations) while staying resumable by explicit
+        # id. Like Claude Code hiding its Task subagent sessions from the picker.
+        @session_source = session_source
         # Pre-instantiate so cancel! is meaningful between turns and during the
         # window between Signal.trap install and run() — a too-early Ctrl+C
         # used to land on a nil token and silently no-op, then the next run
         # started fresh and the user's cancel was lost.
         @cancel_token = Interaction::CancelToken.new
+        # Detached post-turn polishing worker (#319): owns the background thread
+        # that drains memory-extract / skill-distill / summarize OFF the live
+        # turn so the next prompt is never gated, and is cancellable via Esc.
+        # Reused across this runner's turns so #running? / #cancel! address the
+        # CURRENT polishing run (coalescing rapid turns).
+        @polishing = Interaction::Polishing.new(config: @config)
         @session = load_or_create_session(session_id)
       end
 
+      # The detached post-turn polishing worker, so the CLI can show the
+      # non-blocking "polishing… (Esc to skip)" indicator while it runs and
+      # extend the single Esc/cancel path to it (#319).
+      attr_reader :polishing
+
       # Executes a full interaction turn, swallowing failures so CLI callers
       # can stay in the REPL after a model/tool error. The friendly UI
       # message is emitted, but the bus event INTERACTION_FAILED is NOT
@@ -89,18 +107,68 @@ module Rubino
           cancel_token: @cancel_token,
           model_override: @explicit_model_override,
           provider_override: @provider_override,
-          max_tool_iterations: @max_turns
+          max_tool_iterations: @max_turns,
+          polishing: @polishing
         )
 
-        lifecycle.execute(input, image_paths: image_paths, input_queue: input_queue,
-                                 paste_expansions: paste_expansions)
+        response = lifecycle.execute(input, image_paths: image_paths, input_queue: input_queue,
+                                            paste_expansions: paste_expansions)
+
+        # Adopt an automatic-compaction swap so the NEXT turn runs on the (small)
+        # compaction child, not the dead parent (P3 F1). When #check_and_compact
+        # fires, it reassigns the lifecycle's session to the child; without
+        # picking that up here the Runner would rebuild every subsequent turn's
+        # Lifecycle on the un-shrunk parent → re-compact every turn (superlinear
+        # DB/context bloat + ~2.9x slowdown). This is the automatic-path
+        # counterpart to the manual /compact swap (chat_command rebuilds the
+        # runner on result[:compact_into]).
+        @session = lifecycle.active_session
+
+        response
+      end
+
+      # Pins the agent Definition this runner threads into every subsequent turn
+      # (the sticky `/agent <name>` / Tab-cycle switch). Lifecycle reads
+      # @agent_definition fresh on each #run!, so swapping it here takes effect
+      # from the NEXT turn — the agent's system prompt and tool scope come along.
+      # nil restores the default (build) persona. The reader feeds the CLI
+      # status bar and a one-shot route that wants to restore it afterwards.
+      attr_accessor :agent_definition
+
+      # Runs ONE turn under +definition+ (a one-shot `/<name> <message>` route)
+      # without disturbing the runner's sticky agent. The override is swapped in
+      # for the single #run and restored in the ensure, so the next idle prompt
+      # is back on whatever the user had pinned.
+      def run_with_agent(definition, input, **)
+        sticky = @agent_definition
+        @agent_definition = definition
+        run(input, **)
+      ensure
+        @agent_definition = sticky
       end
 
       # Flips the current turn's cancel token. Called from the UI thread when
       # the user hits Esc or a second Ctrl+C while the worker is mid-stream.
       # No-op when no turn is in flight.
-      def cancel!
-        @cancel_token&.cancel!
+      #
+      # ONE Esc cancels whatever is in flight (#319): the FOREGROUND turn OR the
+      # DETACHED post-turn polishing. Flipping both tokens is safe — a token is
+      # one-shot and idle-when-untouched, so cancelling the not-running side is a
+      # harmless no-op. The polishing worker stops between jobs and its aux
+      # retry/backoff aborts mid-wait, leaving partial work in place.
+      # +reason+ records WHY the turn was cancelled so the result label stays
+      # truthful: :user (Esc/Ctrl+C, default) vs :external (SIGTERM/SIGHUP
+      # teardown). Plumbed through to the CancelToken / Interrupted (#361b).
+      def cancel!(reason: :user)
+        @cancel_token&.cancel!(reason: reason)
+        @polishing&.cancel!
+      end
+
+      # True while the detached post-turn polishing is still draining — drives
+      # the non-blocking "polishing… (Esc to skip)" indicator the CLI shows
+      # without owning the input.
+      def polishing?
+        @polishing&.running? || false
       end
 
       # Switches the LIVE model for this runner (the in-chat `/model <name>`).
@@ -136,6 +204,11 @@ module Rubino
         @session_repo.end_session!(@session[:id])
       rescue StandardError
         nil
+      ensure
+        # Let any in-flight detached polishing settle (bounded) so a clean
+        # teardown doesn't abandon a half-written extraction (#319). Best-effort:
+        # the cursor re-feeds anything unfinished next session anyway.
+        @polishing&.wait(3)
       end
 
       private
@@ -170,9 +243,31 @@ module Rubino
                   "Try `rubino sessions list`, or resume by id prefix."
           end
 
+          # Owner-guard on EXPLICIT resume (#347): auto-resume already skips a
+          # session a DIFFERENT live process is actively writing, but explicit
+          # `--resume <id>` / `-s <id>` had NO guard — N processes could latch
+          # the same "active" row and interleave writes into one malformed
+          # transcript (user user user … assistant), poisoning the next resume's
+          # history. When the target is live-owned by another process, fork a
+          # fresh child that inherits the full history instead of stomping the
+          # live session; the user keeps their context and the two writers never
+          # interleave.
+          # ATOMICALLY claim the row for THIS process (#390/residual #376).
+          # The old code checked `owned_by_other_live_process?` then later
+          # stamped owner_pid — a TOCTOU window where two concurrent
+          # `--resume <id>` both read the same dead owner_pid, both passed the
+          # check, and both stamped+wrote the live row (user,user … interleave).
+          # claim_for_resume! folds the check and stamp into one compare-and-swap
+          # (same idiom as Jobs::Queue#claim!): exactly one racer wins, the
+          # loser gets false and forks a fresh child off the busy parent.
+          return fork_busy_session(session) unless @session_repo.claim_for_resume!(session)
+
           # An existing row is already in the DB; mark it so the lazy-persist
-          # path (#144) treats it as persisted and never re-inserts.
+          # path (#144) treats it as persisted and never re-inserts. We now own
+          # owner_pid (stamped atomically above) so a later concurrent resume
+          # sees us as the live owner and forks rather than interleaving.
           session[:persisted] = true
+          session[:owner_pid] = Process.pid
           @ui.status("Resuming session: #{session[:id][0..7]}...") if @announce_session
           session
         else
@@ -182,7 +277,7 @@ module Rubino
           # record carries a real id so the whole turn pipeline works unchanged;
           # Lifecycle#persist_user_message flips it to a real row on demand.
           session = @session_repo.build(
-            source: "cli",
+            source: @session_source,
             model: @model_id,
             provider: @provider_override || LLM::ProviderResolver.resolve(@model_id)
           )
@@ -190,6 +285,36 @@ module Rubino
           session
         end
       end
+
+      # Forks a child session off a parent another live process is still writing
+      # (#347), copying the parent's full history so the explicit-resume user
+      # keeps their context, while writing to a SEPARATE row so the two writers
+      # never interleave into one malformed transcript. The child is owned by
+      # THIS process. Mirrors the /branch copy (history + extraction watermark +
+      # message_count sync) without a probe seed.
+      def fork_busy_session(parent)
+        store = @message_store
+        child = @session_repo.create(
+          source: "cli",
+          model: parent[:model] || @model_id,
+          provider: parent[:provider] || @provider_override,
+          title: parent[:title],
+          parent_session_id: parent[:id],
+          cwd: parent[:cwd]
+        )
+        store.copy_into(child[:id], store.for_session(parent[:id]))
+        store.seed_extraction_cursor(child[:id])
+        @session_repo.update(child[:id], message_count: store.count(child[:id]))
+
+        if @announce_session
+          @ui.status(
+            "Session #{parent[:id][0..7]} is in use by another rubino — " \
+            "forked a copy: #{child[:id][0..7]}"
+          )
+        end
+        child[:persisted] = true
+        child
+      end
     end
   end
 end