silas 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be0574c8a9c71366220b9be69d9f3d679a6c0a469d907bec1fb2a7d53436f6b3
-  data.tar.gz: 5ac2adcf62f854ec3a4b8206c0d9a19bd33bb3b631615e36bffed425757126ca
+  metadata.gz: 7aa3f984d996b0eee69689f4009e3d43bd46d63caaf2144f0a4082b40d0ae918
+  data.tar.gz: 8c9b38ac7dae0a0ea510375046447442087a3a1536431199a8bf54677fca80b3
 SHA512:
-  metadata.gz: 3a0be6b63aec608abe5cf2c72f0533c79b7150f8d389344a36e68c90122055fb1f304a4a251ade503467c875c21d99ddd9d136fa37f4d4734d1d5bda9c158bd6
-  data.tar.gz: 1340782f9cb00620e4e1ed5e9c5b9dc9fc8d96a9310d3d9e67e55004363352e4d17e98f62d1cb6054738b2fed1052c0c7e92f576f5afe587a33770db5294cc48
+  metadata.gz: f3136bfb1276a84217f76733e1c718715b8dbed5794fe766f72383cf58560c50950c6cdb12932d89108c6c6de73bd16b1c2c1b915841bb1829b47c102d03f0f5
+  data.tar.gz: 5af58996877a0bb1bf6d64fbf2ef30c141462c8d00a7f37ebbaaca4dbf3518cd28c4ead9557d4ee2d5a23144748632f053e38b908238b39c64577ce9f0d355fd

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.1.5
+
+- **Turn cancellation.** `turn.cancel!` — a parked or queued turn settles to
+  `canceled` immediately (pending approvals expire, so a late `approve!` can
+  never zombie-resume it); a running turn is flagged and honored at the next
+  step boundary, keeping the in-flight step's paid work. Engine-owned
+  (`:agent_sdk`) turns cancel only before the subprocess starts (v1). New
+  migration adds `silas_turns.cancel_requested_at`.
+- **Resumable budget parks.** A turn that hits `max_cost` / `max_input_tokens` /
+  `timeout` now PARKS at zero compute (state intact) instead of failing
+  terminally. A human resumes it with `turn.raise_budget!(max_cost: 1.50)` —
+  the top-up is recorded as a per-turn override and a fresh job replays
+  completed steps from rows (no model re-calls, no re-effects), continuing
+  where it left off. `bin/rails silas:chat` prompts for the top-up inline.
+  New migration adds `silas_turns.budget_overrides` (run
+  `bin/rails silas:install:migrations db:migrate` on upgrade). Notes: the
+  timeout clock includes time spent parked — size a timeout top-up from
+  elapsed wall-clock; budget parks have no TTL yet (visible in the inbox as
+  waiting); an inbox top-up card is planned.
+
 ## 0.1.4
 
 - **Fresh-app quickstart actually works.** A from-scratch install previously

data/app/jobs/silas/agent_loop_job.rb

@@ -40,6 +40,16 @@ module Silas
 
       index = 0
       loop do
+        # Cancellation is honored at step boundaries only — the same safe point
+        # as budgets. (Mutable-state read between steps: benign, like the
+        # budget wall-clock check — a cancel landing later on resume is still
+        # a correct cancel.)
+        if turn.reload.cancel_requested_at
+          turn.expire_pending_approvals!("turn canceled")
+          turn.finish!(:canceled, reason: "canceled")
+          return
+        end
+
         step :"step_#{index}", isolated: isolate? do
           Ledger.assert_no_checkpoint!
           StepRunner.call(turn, index)
@@ -50,9 +60,12 @@ module Silas
         return if row.parked?
         break if row.terminal?
 
-        # Budget caps (cost/tokens/time) — checked between steps, never inside one.
+        # Budget caps (cost/tokens/time) — checked between steps, never inside
+        # one. A breach PARKS the turn (state intact, zero compute) rather than
+        # failing it: a human tops up with turn.raise_budget! and the fresh job
+        # replays completed steps from rows, resuming where it left off.
         if (reason = Budget.exceeded_reason(turn))
-          turn.finish!(:failed, reason: reason)
+          turn.update!(status: "waiting", failure_reason: reason)
           return
         end
 
@@ -79,6 +92,13 @@ module Silas
         Step.find_or_create_by!(turn: turn, index: 0) # anchor step exists before the MCP thread needs it
       end
 
+      # Cancellation for engine-owned turns is honored only BEFORE the
+      # subprocess starts — a running claude -p is not aborted mid-flight (v1).
+      if turn.reload.cancel_requested_at
+        turn.finish!(:canceled, reason: "canceled")
+        return
+      end
+
       outcome = nil
       step :run, isolated: isolate? do
         Ledger.assert_no_checkpoint!

data/app/models/silas/tool_invocation.rb

@@ -69,6 +69,7 @@ module Silas
     end
 
     def resume_turn!
+      return if turn.reload.canceled? # a canceled turn never zombie-resumes
       return if turn.tool_invocations.where(approval_state: "required").exists?
 
       turn.update!(status: "queued")

data/app/models/silas/turn.rb

@@ -24,6 +24,57 @@ module Silas
       update!(status: new_status.to_s, failure_reason: reason, finished_at: Time.current)
     end
 
+    def canceled? = status == "canceled"
+
+    # Cancel a turn. A PARKED or QUEUED turn (no live execution) settles to
+    # canceled immediately, expiring its pending approvals so a later approve!
+    # can't zombie-resume it. A RUNNING turn is flagged; the loop honors the
+    # flag at the next step boundary — the in-flight model call completes and
+    # its step commits (aborting mid-step would forfeit paid work and create
+    # an in-doubt tool window for nothing).
+    def cancel!(reason: "canceled")
+      raise Error, "turn #{id} is already terminal (#{status})" unless active?
+
+      if running?
+        update!(cancel_requested_at: Time.current)
+        :cancel_requested
+      else
+        expire_pending_approvals!(reason)
+        finish!(:canceled, reason: reason)
+        :canceled
+      end
+    end
+
+    def expire_pending_approvals!(reason)
+      tool_invocations.where(approval_state: "required").find_each do |inv|
+        inv.update!(approval_state: "expired", status: "failed",
+                    result: { "denied" => reason })
+      end
+    end
+
+    # Parked by a budget cap (failure_reason doubles as the park reason while
+    # the turn is waiting; it is cleared on resume).
+    def budget_parked?
+      waiting? && Budget::REASONS.include?(failure_reason)
+    end
+
+    # Human top-up for a budget-parked turn: record the raised limit(s) and
+    # resume with a fresh job — completed steps replay from rows, no model
+    # re-calls, no re-effects (the same resume path approvals use).
+    #   turn.raise_budget!(max_cost: 1.50)          # dollars
+    #   turn.raise_budget!(max_input_tokens: 200_000, timeout: 3600)
+    def raise_budget!(max_cost: nil, max_input_tokens: nil, timeout: nil)
+      raise Error, "turn #{id} is not budget-parked (#{status}/#{failure_reason})" unless budget_parked?
+
+      raises = { "max_cost" => max_cost, "max_input_tokens" => max_input_tokens,
+                 "timeout" => timeout }.compact
+      raise ArgumentError, "pass at least one limit to raise" if raises.empty?
+
+      update!(budget_overrides: (budget_overrides || {}).merge(raises),
+              failure_reason: nil, status: "queued")
+      AgentLoopJob.perform_later(id)
+    end
+
     # The agent's answer for this turn: the last completed step's text blocks.
     def answer_text
       step = steps.where(status: "completed").order(:index).last

data/db/migrate/20260716000001_add_budget_overrides_to_silas_turns.rb

@@ -0,0 +1,7 @@
+class AddBudgetOverridesToSilasTurns < ActiveRecord::Migration[8.1]
+  def change
+    # Per-turn budget raises (max_cost / max_input_tokens / timeout), set by a
+    # human topping up a budget-parked turn. Overrides agent.yml/config limits.
+    add_column :silas_turns, :budget_overrides, :json, null: false, default: {}
+  end
+end

data/db/migrate/20260716000002_add_cancel_requested_to_silas_turns.rb

@@ -0,0 +1,7 @@
+class AddCancelRequestedToSilasTurns < ActiveRecord::Migration[8.1]
+  def change
+    # Set by Turn#cancel! on a running turn; the loop honors it at the next
+    # step boundary (the same safe point budgets are checked at).
+    add_column :silas_turns, :cancel_requested_at, :datetime
+  end
+end

data/lib/silas/budget.rb

@@ -1,15 +1,21 @@
 module Silas
   # Per-turn budget caps beyond max_steps: cumulative input tokens, cost, and
   # wall-clock. Checked between steps in the framework-owned loop (never inside a
-  # continuation step), so a breach fails the turn cleanly with a limit reason.
+  # continuation step). A breach PARKS the turn at zero compute (like an
+  # approval); a human resumes it with Turn#raise_budget!, which records a
+  # per-turn override consulted here ahead of the agent's limits.
   #
   # Token/cost checks are deterministic (persisted step data). The timeout check
   # reads the wall clock — benign non-determinism: a cap firing later on resume
-  # is correct (the turn genuinely ran too long across the crash).
+  # is correct (the turn genuinely ran too long across the crash). Note the
+  # timeout clock includes time spent parked, so a timeout top-up should be
+  # sized from Time.current - started_at, not from the original limit.
   module Budget
+    REASONS = %w[max_input_tokens max_cost timeout].freeze
+
     module_function
 
-    # Returns a failure reason string if a cap is exceeded, else nil.
+    # Returns a limit-reason string if a cap is exceeded, else nil.
     def exceeded_reason(turn, agent: Silas.agent)
       return "max_input_tokens" if over_tokens?(turn, agent)
       return "max_cost" if over_cost?(turn, agent)
@@ -18,14 +24,20 @@ module Silas
       nil
     end
 
+    # A human top-up (turn.budget_overrides) beats the agent's configured limit.
+    def limit_for(turn, agent, key)
+      override = turn.budget_overrides&.dig(key.to_s)
+      override.nil? ? agent.public_send(key) : override
+    end
+
     def over_tokens?(turn, agent)
-      limit = agent.max_input_tokens or return false
+      limit = limit_for(turn, agent, :max_input_tokens) or return false
 
       Silas::Step.where(turn_id: turn.id).sum(:input_tokens) > limit
     end
 
     def over_cost?(turn, agent)
-      limit = agent.max_cost or return false
+      limit = limit_for(turn, agent, :max_cost) or return false
 
       spent = Silas::Inbox::Cost.for_turn(turn)
       # Only enforce on priced tokens; unpriced models can't be cost-capped.
@@ -33,7 +45,7 @@ module Silas
     end
 
     def over_time?(turn, agent)
-      limit = agent.timeout or return false
+      limit = limit_for(turn, agent, :timeout) or return false
       return false unless turn.started_at
 
       (Time.current - turn.started_at) > limit

data/lib/silas/chat.rb

@@ -73,6 +73,7 @@ module Silas
 
       if turn.parked?
         settle_parked
+        settle_budget_park(turn.reload)
         turn.reload
       end
 
@@ -80,17 +81,40 @@ module Silas
     end
 
     def print_outcome(turn)
-      case turn.reload.status
+      turn.reload
+      case turn.status
       when "completed"
         @out.puts "agent> #{turn.answer_text}"
       when "waiting", "in_doubt"
-        @out.puts "(parked — #{pending_for(turn.session).count} approval(s) still pending; " \
-                  "they also render in /silas/inbox)"
+        if turn.budget_parked?
+          @out.puts "(parked: #{turn.failure_reason} budget reached — resume with " \
+                    "turn.raise_budget! or from a fresh silas:chat)"
+        else
+          @out.puts "(parked — #{pending_for(turn.session).count} approval(s) still pending; " \
+                    "they also render in /silas/inbox)"
+        end
       when "failed"
         @out.puts "(turn failed: #{turn.failure_reason})"
       end
     end
 
+    # A budget-parked turn prompts for a top-up right in the terminal. The
+    # resume runs synchronously on the :inline adapter, so new work (and
+    # possibly another park) follows immediately.
+    def settle_budget_park(turn)
+      return unless turn.budget_parked?
+
+      reason = turn.failure_reason
+      @out.puts "\nbudget reached — #{reason}"
+      @out.print "raise #{reason} to (blank to leave parked)> "
+      value = @in.gets&.strip
+      return if value.blank?
+
+      numeric = reason == "max_cost" ? value.to_f : value.to_i
+      turn.raise_budget!(**{ reason.to_sym => numeric })
+      print_trace(turn.reload)
+    end
+
     def print_trace(turn)
       ToolInvocation.where(turn_id: turn.id).order(:id).each do |inv|
         gate = inv.approval_state == "required" ? " — awaiting approval" : ""

data/lib/silas/version.rb

@@ -1,3 +1,3 @@
 module Silas
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silas
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Daniel St Paul
@@ -148,6 +148,8 @@ files:
 - db/migrate/20260715000001_add_channel_outbound_markers.rb
 - db/migrate/20260715000002_add_agent_sdk_columns_to_turns.rb
 - db/migrate/20260715000003_add_parent_session_to_silas_sessions.rb
+- db/migrate/20260716000001_add_budget_overrides_to_silas_turns.rb
+- db/migrate/20260716000002_add_cancel_requested_to_silas_turns.rb
 - lib/generators/silas/install/install_generator.rb
 - lib/generators/silas/install/templates/agent.yml
 - lib/generators/silas/install/templates/bin_ci