silas 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35e622a6b7c17416ebe71717f1d072bd07c8a075f901c5b477177aa9bfccfa29
-  data.tar.gz: 59a87acd719063f275926852e255507d3c6159c16892907f70c8a77180dd61f8
+  metadata.gz: 7aa3f984d996b0eee69689f4009e3d43bd46d63caaf2144f0a4082b40d0ae918
+  data.tar.gz: 8c9b38ac7dae0a0ea510375046447442087a3a1536431199a8bf54677fca80b3
 SHA512:
-  metadata.gz: 608b8bc79c926eadf04b74360e62832413580986c8ef5c6899b5acdc9371695db555799d9dd26d76b3aea77d2deafee13f32236cf8564c3cc6ad47692c58be80
-  data.tar.gz: f992423e27b802ae2efb6e7cf1c366f584ff703bd2210b9388b68abb9730616f2d16ded6b0da6e4b0a62c4c9fefd5becc8e8a85c6a17763d47dfd72bfef6d9ab
+  metadata.gz: f3136bfb1276a84217f76733e1c718715b8dbed5794fe766f72383cf58560c50950c6cdb12932d89108c6c6de73bd16b1c2c1b915841bb1829b47c102d03f0f5
+  data.tar.gz: 5af58996877a0bb1bf6d64fbf2ef30c141462c8d00a7f37ebbaaca4dbf3518cd28c4ead9557d4ee2d5a23144748632f053e38b908238b39c64577ce9f0d355fd

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # 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
+  failed at its own post-install steps: the generated default model
+  ("claude-sonnet-5") wasn't in ruby_llm 1.16's bundled registry, and no
+  provider-key initializer was generated, so the first turn raised. The
+  generator now emits `config/initializers/ruby_llm.rb` (maps
+  `ANTHROPIC_API_KEY`), defaults to the registry-known `claude-opus-4-8`, and a
+  missing model raises an actionable error suggesting
+  `RubyLLM.models.refresh!`.
+- **`silas:schedules` no longer crashes on the generator's own template.** The
+  example schedule's ERB comment rendered a leading blank line the frontmatter
+  parser rejected; template fixed and the parser now tolerates leading
+  whitespace.
+- **`bin/ci` is never clobbered.** Rails 8.1 ships a real bin/ci; the installer
+  now leaves an existing one untouched and tells you to add
+  `bin/rails silas:eval` to it.
+- **Correct Opus 4.8 pricing.** Default `model_prices` had Opus 4.8 at $15/$75
+  per MTok; it is $5/$25. Added Sonnet 4.6 and the `claude-haiku-4-5` alias.
+- **ruby_llm dependency bounded `< 2`** (2.0 removes APIs the engine relies on).
+- **`bin/rails silas:chat` — a terminal REPL for your agent.** The dev-loop a
+  hosted platform gives you from its CLI, except there is no platform: it runs
+  inside your app, tools hit your real dev database, and parked approvals prompt
+  inline (`approve? [y]es / [d]ecline / [s]kip`) calling the same
+  `approve!`/`decline!` as the inbox and Slack. `SESSION=id` resumes a session;
+  a new message while a turn is parked steers you to the pending approvals. The
+  task forces the synchronous `:inline` adapter for its own process (a REPL
+  wants each turn settled before the next prompt; production still runs Solid
+  Queue).
+
 ## 0.1.3
 
 - **Ledger: parallel graded gates.** When the model emits several tool calls in

data/README.md

@@ -53,6 +53,23 @@ session.pending_approvals.first.approve!(by: "daniel")
 session.continue(input: "Now email the customer.")
 ```
 
+Or talk to it from the terminal — the REPL runs *inside your app*, so tools hit
+your real dev database, and parked approvals prompt inline (the same
+`approve!`/`decline!` as the inbox and Slack):
+
+```
+$ bin/rails silas:chat
+you> Refund order 42, £12.50
+  ✓ lookup_order(order_id: 42)
+  ⏸ issue_refund(order_id: 42, amount: 1250) — awaiting approval
+
+approval needed — issue_refund(order_id: 42, amount: 1250)
+approve? [y]es / [d]ecline / [s]kip> y
+agent> Done — £12.50 refunded on order 42.
+```
+
+`SESSION=id` resumes an existing session.
+
 ## The durability contract (what's actually guaranteed)
 
 Verified by `chaos_host/bin/chaos` — the harness that kill -9s a live agent

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/generators/silas/install/install_generator.rb

@@ -7,6 +7,9 @@ module Silas
 
       def create_initializer
         template "initializer.rb", "config/initializers/silas.rb"
+        # ruby_llm reads no provider keys from ENV on its own; without this the
+        # first model call raises ConfigurationError.
+        template "ruby_llm.rb", "config/initializers/ruby_llm.rb"
       end
 
       def create_agent_directory
@@ -28,11 +31,19 @@ module Silas
         route 'mount Silas::Engine => "/silas"'
       end
 
-      # Evals as a deploy gate: an example scenario + a bin/ci wrapper.
+      # Evals as a deploy gate: an example scenario + a bin/ci wrapper. Rails
+      # 8.1 apps ship their own bin/ci (rubocop, brakeman, tests) — never
+      # clobber it; tell the user to add the eval gate to theirs instead.
       def create_eval_gate
         template "example_eval.rb", "test/agent_evals/example_eval.rb"
-        copy_file "bin_ci", "bin/ci"
-        chmod "bin/ci", 0o755
+
+        if File.exist?(File.expand_path("bin/ci", destination_root))
+          say "bin/ci already exists — left untouched. Add `bin/rails silas:eval` " \
+              "to it to gate deploys on agent evals.", :yellow
+        else
+          copy_file "bin_ci", "bin/ci"
+          chmod "bin/ci", 0o755
+        end
       end
 
       def add_rescuer_recurring_task
@@ -65,14 +76,15 @@ module Silas
 
           Silas installed. Next:
             1. bin/rails db:migrate
-            2. Edit app/agent/instructions.md (your agent's persona)
-            3. Write tools in app/agent/tools/ (keyword signature = schema)
-            4. Silas.agent.start(input: "hello")
-            5. Schedules: edit app/agent/schedules/*, then `bin/rails silas:schedules`
-            6. Channels (optional): set credentials.silas.slack.{signing_secret,bot_token}
+            2. export ANTHROPIC_API_KEY=sk-ant-...  (config/initializers/ruby_llm.rb reads it)
+            3. Edit app/agent/instructions.md (your agent's persona)
+            4. Write tools in app/agent/tools/ (keyword signature = schema)
+            5. Talk to it: bin/rails silas:chat  (or Silas.agent.start(input: "hello"))
+            6. Schedules: edit app/agent/schedules/*, then `bin/rails silas:schedules`
+            7. Channels (optional): set credentials.silas.slack.{signing_secret,bot_token}
                for Slack; route inbound mail to Silas::AgentMailbox for email.
                Delete app/agent/channels/{slack,email}.rb to disable.
-            7. Inbox: live at /silas/inbox once you set config.inbox_auth
+            8. Inbox: live at /silas/inbox once you set config.inbox_auth
                (deny-by-default until you do).
         MSG
       end

data/lib/generators/silas/install/templates/example_schedule.md

@@ -1,5 +1,5 @@
-<%# Task-mode schedule: this markdown body becomes the turn input on each tick. %>
 ---
+# Task-mode schedule: this markdown body becomes the turn input on each tick.
 cron: "0 9 * * *"
 # queue: default
 ---

data/lib/generators/silas/install/templates/initializer.rb

@@ -3,7 +3,10 @@ Silas.configure do |config|
   # :agent_sdk (a `claude -p` subprocess; API-key auth only). See silas/README.
   config.engine = :ruby_llm
 
-  config.default_model = "claude-sonnet-5"
+  # Any model your installed ruby_llm's registry resolves (newer Claude models
+  # may need `RubyLLM.models.refresh!` first). Alternatives: "claude-sonnet-5"
+  # (balanced), "claude-haiku-4-5" (fastest/cheapest).
+  config.default_model = "claude-opus-4-8"
 
   # Parked approvals expire after this long (the turn fails as approval_expired).
   # config.approval_ttl = 7.days

data/lib/generators/silas/install/templates/ruby_llm.rb

@@ -0,0 +1,9 @@
+# Point RubyLLM at your model provider. RubyLLM does NOT read provider API keys
+# from the environment automatically — this initializer maps them in.
+#
+#   export ANTHROPIC_API_KEY=sk-ant-...
+#
+# Any provider RubyLLM supports works the same way (openai_api_key, etc.).
+RubyLLM.configure do |c|
+  c.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+end if ENV["ANTHROPIC_API_KEY"].present?

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

@@ -0,0 +1,161 @@
+module Silas
+  # Terminal REPL for talking to the app's agent: `bin/rails silas:chat`.
+  #
+  # The dev-loop equivalent of a hosted platform's CLI — except there is no
+  # platform: this runs inside your app, so tools hit your real dev database
+  # and the transcript is rows in your own Postgres. Parked approvals prompt
+  # inline and call the exact same approve!/decline! as the inbox and Slack.
+  #
+  # IO is injected so the loop is testable; the rake task wires $stdin/$stdout
+  # and forces the synchronous :inline adapter (a REPL wants each turn settled
+  # before the next prompt, and the dev-default Async adapter is unsafe).
+  class Chat
+    GLYPH = { "completed" => "✓", "failed" => "✗", "pending" => "⏸",
+              "started" => "…", "in_doubt" => "?" }.freeze
+
+    def initialize(io_in: $stdin, io_out: $stdout, actor: ENV["USER"] || "cli", session: nil)
+      @in = io_in
+      @out = io_out
+      @actor = actor
+      @session = session
+    end
+
+    def run
+      banner
+      if @session && pending_for(@session).exists? # resuming a session that parked last time
+        settle_parked
+        print_outcome(@session.turns.reload.last)
+      end
+
+      loop do
+        @out.print "\nyou> "
+        line = @in.gets
+        break if line.nil?
+
+        line = line.strip
+        next if line.empty?
+        break if %w[exit quit].include?(line.downcase)
+
+        submit(line)
+      end
+      @out.puts "bye — session #{@session.id}" if @session
+    end
+
+    private
+
+    def banner
+      description = Silas.agent.description.presence || "your agent"
+      @out.puts "Silas chat — #{description} (#{Silas.agent.model})."
+      @out.puts "Approvals prompt inline. 'exit' or Ctrl-D to quit."
+      @out.puts "Resuming session #{@session.id} (#{@session.turns.count} turns)." if @session
+    end
+
+    def submit(text)
+      turn =
+        if @session.nil?
+          @session = Silas.agent.start(input: text)
+          @session.turns.first
+        else
+          @session.continue(input: text)
+        end
+      # start/continue enqueue the loop job; the :inline adapter has already run
+      # it synchronously by the time they return.
+      report(turn)
+    rescue TurnInProgressError
+      @out.puts "! a turn is still parked awaiting approval — settle it first:"
+      settle_parked
+      print_outcome(@session.turns.reload.last)
+    end
+
+    def report(turn)
+      turn.reload
+      print_trace(turn)
+
+      if turn.parked?
+        settle_parked
+        settle_budget_park(turn.reload)
+        turn.reload
+      end
+
+      print_outcome(turn)
+    end
+
+    def print_outcome(turn)
+      turn.reload
+      case turn.status
+      when "completed"
+        @out.puts "agent> #{turn.answer_text}"
+      when "waiting", "in_doubt"
+        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" : ""
+        @out.puts "  #{GLYPH.fetch(inv.status, '·')} #{inv.tool_name}(#{compact_args(inv.arguments)})#{gate}"
+      end
+    end
+
+    # Prompt for every parked approval in the session. Approving resumes the
+    # turn synchronously (inline adapter), so new invocations may appear —
+    # loop until nothing is pending or the user skips.
+    def settle_parked
+      loop do
+        invocation = pending_for(@session).order(:id).first
+        break unless invocation
+
+        @out.puts "\napproval needed — #{invocation.tool_name}(#{compact_args(invocation.arguments)})"
+        @out.print "approve? [y]es / [d]ecline / [s]kip> "
+        answer = @in.gets&.strip&.downcase
+
+        case answer
+        when "y", "yes"
+          invocation.approve!(by: @actor)
+          @out.puts
+          print_trace(@session.turns.reload.last)
+        when "d", "decline"
+          @out.print "reason> "
+          reason = @in.gets&.strip
+          invocation.decline!(reason: reason.presence || "declined from CLI", by: @actor)
+        else
+          @out.puts "(left parked — approve later here or in /silas/inbox)"
+          break
+        end
+      end
+    end
+
+    def pending_for(session)
+      session.pending_approvals.where(status: %w[pending in_doubt])
+    end
+
+    def compact_args(arguments)
+      (arguments || {}).map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+    end
+  end
+end

data/lib/silas/configuration.rb

@@ -64,7 +64,9 @@ module Silas
     def initialize
       @engine = :ruby_llm
       @auth = :api_key
-      @default_model = "claude-sonnet-5"
+      # Must be resolvable by the installed ruby_llm's model registry — newer
+      # Claude models may need `RubyLLM.models.refresh!` before they resolve.
+      @default_model = "claude-opus-4-8"
       @queue_name = :default
       @around_model_call = nil
       @approval_ttl = 7.days
@@ -102,10 +104,12 @@ module Silas
       @inbox_public_read = false
       @inbox_actor = ->(controller) { controller.try(:current_user)&.try(:email) || "inbox" }
       # Current Claude rates as cost-units per 1k tokens (1e6 units = $1):
-      # Sonnet $3/$15, Opus $15/$75, Haiku $1/$5 per million tokens.
+      # Opus 4.8 $5/$25, Sonnet $3/$15, Haiku $1/$5 per million tokens.
       @model_prices = {
+        "claude-opus-4-8" => { in: 5000, out: 25_000 },
         "claude-sonnet-5" => { in: 3000, out: 15_000 },
-        "claude-opus-4-8" => { in: 15_000, out: 75_000 },
+        "claude-sonnet-4-6" => { in: 3000, out: 15_000 },
+        "claude-haiku-4-5" => { in: 1000, out: 5000 },
         "claude-haiku-4-5-20251001" => { in: 1000, out: 5000 }
       }
     end

data/lib/silas/engines/ruby_llm.rb

@@ -26,7 +26,14 @@ module Silas
       private
 
       def build_chat(context, &on_event)
-        chat = ::RubyLLM.chat(model: context[:model])
+        chat = begin
+          ::RubyLLM.chat(model: context[:model])
+        rescue ::RubyLLM::ModelNotFoundError
+          raise Silas::Error,
+                "Model #{context[:model].inspect} is not in ruby_llm's model registry. " \
+                "Newer models may need a registry refresh (`RubyLLM.models.refresh!`), " \
+                "or pick a registry-known model in config.default_model / agent.yml."
+        end
         chat.with_instructions(context[:system]) if context[:system].present?
         context[:tools].each { |definition| chat.with_tool(HaltProxy.new(definition)) }
 

data/lib/silas/schedule.rb

@@ -38,7 +38,9 @@ module Silas
 
     def self.from_markdown(name, path)
       content = File.read(path)
-      if content =~ /\A---\s*\n(.*?)\n---\s*\n(.*)\z/m
+      # Tolerate leading whitespace/blank lines (e.g. an ERB comment in a
+      # generator template renders to an empty first line).
+      if content.sub(/\A\s+/, "") =~ /\A---\s*\n(.*?)\n---\s*\n(.*)\z/m
         frontmatter = YAML.safe_load(Regexp.last_match(1)) || {}
         body = Regexp.last_match(2)
       else

data/lib/silas/version.rb

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

data/lib/silas.rb

@@ -41,6 +41,7 @@ require "silas/instructions"
 require "silas/step_runner"
 require "silas/subprocess_runner"
 require "silas/eval" # after engines (ScriptedEngine < Engines::Base)
+require "silas/chat"
 
 module Silas
   class << self

data/lib/tasks/silas_chat.rake

@@ -0,0 +1,16 @@
+namespace :silas do
+  desc "Chat with your agent in the terminal (REPL). SESSION=id resumes one; approvals prompt inline."
+  task chat: :environment do
+    # A REPL wants each turn settled synchronously in this one process before
+    # the next prompt — and Rails' dev-default Async adapter is unsafe for Silas
+    # (it double-executes continuation retries; Silas warns at boot). Force the
+    # synchronous :inline adapter for this process only; production still runs
+    # Solid Queue.
+    ActiveJob::Base.queue_adapter = :inline
+    Silas.config.isolate_steps = false
+    Silas::Registry.install!
+
+    session = ENV["SESSION"].present? ? Silas::Session.find(ENV["SESSION"]) : nil
+    Silas::Chat.new(session: session).run
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silas
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Daniel St Paul
@@ -30,6 +30,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -37,6 +40,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -142,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
@@ -153,6 +161,7 @@ files:
 - lib/generators/silas/install/templates/example_tool.rb
 - lib/generators/silas/install/templates/initializer.rb
 - lib/generators/silas/install/templates/instructions.md
+- lib/generators/silas/install/templates/ruby_llm.rb
 - lib/silas.rb
 - lib/silas/agent.rb
 - lib/silas/agent_scope.rb
@@ -161,6 +170,7 @@ files:
 - lib/silas/agent_sdk/version_guard.rb
 - lib/silas/budget.rb
 - lib/silas/channel.rb
+- lib/silas/chat.rb
 - lib/silas/configuration.rb
 - lib/silas/connection.rb
 - lib/silas/connections.rb
@@ -202,6 +212,7 @@ files:
 - lib/silas/tools/load_skill.rb
 - lib/silas/tools/run_code.rb
 - lib/silas/version.rb
+- lib/tasks/silas_chat.rake
 - lib/tasks/silas_eval.rake
 - lib/tasks/silas_schedules.rake
 homepage: https://github.com/danielstpaul/silas