silas 0.1.7 → 0.3.0

data/app/controllers/silas/inbox/sessions_controller.rb

@@ -1,9 +1,33 @@
 module Silas
   module Inbox
     class SessionsController < BaseController
+      before_action :authenticate_write!, only: :create
+
+      PER_PAGE = 50
+
       def index
-        @sessions = Silas::Session.order(created_at: :desc).limit(100)
-        @sessions = @sessions.where(agent_name: params[:agent]) if params[:agent].present?
+        # Keyset pagination on id (?before=<id> pages older), newest first.
+        scope = Silas::Session.order(id: :desc)
+        scope = scope.where(agent_name: params[:agent]) if params[:agent].present?
+        if params[:pending].present? # the "N awaiting approval" badge drills into this
+          # Subquery, not joins+distinct: DISTINCT over silas_sessions.* trips
+          # on the json metadata column (PG json has no equality operator).
+          scope = scope.where(
+            id: Silas::Turn.joins(:tool_invocations)
+                           .where(silas_tool_invocations: { approval_state: "required" })
+                           .select(:session_id)
+          )
+        end
+        scope = scope.where(id: ...params[:before].to_i) if params[:before].present?
+
+        # One query for the rows + turns, one for the pending counts — the
+        # per-row active_turn/turns.last/counts pattern was ~4 queries a card.
+        @sessions = scope.limit(PER_PAGE).includes(:turns).to_a
+        @next_before = @sessions.last&.id if @sessions.size == PER_PAGE
+        @pending_counts = Silas::ToolInvocation.joins(:turn)
+                                               .where(approval_state: "required",
+                                                      silas_turns: { session_id: @sessions.map(&:id) })
+                                               .group("silas_turns.session_id").count
         @agent_names = Silas::Session.distinct.pluck(:agent_name).sort
         @pending_total = Silas::ToolInvocation.where(approval_state: "required").count
       end
@@ -13,6 +37,19 @@ module Silas
         @turns = @session.turns.includes(steps: :tool_invocations)
         @cost = Silas::Inbox::Cost.for_session(@session)
       end
+
+      # Start a session from the browser. channel stays nil ("direct") — web
+      # chat is read live on the session page, not delivered outbound.
+      def create
+        input = params[:input].to_s.strip
+        return redirect_to inbox_sessions_path, alert: "Type a message first." if input.empty?
+
+        handle = params[:agent].present? ? Silas.agent(params[:agent]) : Silas.agent
+        started = handle.start(input: input)
+        redirect_to inbox_session_path(started)
+      rescue Silas::Error => e
+        redirect_to inbox_sessions_path, alert: e.message
+      end
     end
   end
 end

data/app/controllers/silas/inbox/turns_controller.rb

@@ -0,0 +1,51 @@
+module Silas
+  module Inbox
+    # The web composer: append a turn to an existing session. Same write-auth
+    # gate as approve/decline. Deliberately thin — the turn runs on the durable
+    # loop and the model's after_commit broadcasts render it live, so this
+    # controller only enqueues and redirects.
+    class TurnsController < BaseController
+      before_action :authenticate_write!
+
+      def create
+        agent_session = Silas::Session.find(params[:session_id])
+        input = params[:input].to_s.strip
+        return redirect_to inbox_session_path(agent_session), alert: "Type a message first." if input.empty?
+
+        agent_session.continue(input: input)
+        redirect_to inbox_session_path(agent_session)
+      rescue Silas::TurnInProgressError
+        redirect_to inbox_session_path(agent_session), alert: "A turn is already running — wait for it to settle."
+      end
+
+      # Cancel from the trace. Running turns are flagged and honored at the
+      # next step boundary (the same safe point as budgets); parked/queued
+      # turns cancel immediately.
+      def cancel
+        turn = Silas::Turn.find(params[:id])
+        outcome = turn.cancel!(reason: "canceled from inbox by #{current_actor}")
+        notice = outcome == :cancel_requested ? "Cancel requested — honored at the next step boundary." : "Turn canceled."
+        redirect_to inbox_session_path(turn.session_id), notice: notice
+      end
+
+      # Top up a budget-parked turn and resume it — the CHANGELOG promised
+      # this card in 0.1.5; completed steps replay from rows, same as approvals.
+      def raise_budget
+        turn = Silas::Turn.find(params[:id])
+        unless turn.budget_parked?
+          return redirect_to inbox_session_path(turn.session_id),
+                             alert: "Turn ##{turn.index} is not budget-parked."
+        end
+
+        reason = turn.failure_reason.to_s
+        value = params[:value].to_s
+        numeric = reason == "max_cost" ? value.to_f : value.to_i
+
+        turn.raise_budget!(**{ reason.to_sym => numeric })
+        redirect_to inbox_session_path(turn.session_id), notice: "#{reason} raised — resuming."
+      rescue Silas::Error, ArgumentError => e
+        redirect_to inbox_session_path(turn.session_id), alert: e.message
+      end
+    end
+  end
+end

data/app/helpers/silas/inbox/trace_helper.rb

@@ -18,6 +18,11 @@ module Silas
         Array(step.response_blocks).select { |b| b["type"] == "text" }.map { |b| b["text"] }.join.presence
       end
 
+      # The final_answer payload, when the agent declared a schema.
+      def step_structured(step)
+        Array(step.response_blocks).reverse.find { |b| b["type"] == "structured" }&.dig("data")
+      end
+
       def pretty_args(hash)
         JSON.pretty_generate(hash || {})
       end

data/app/jobs/silas/agent_loop_job.rb

@@ -12,10 +12,51 @@ module Silas
   class AgentLoopJob < ActiveJob::Base
     include ActiveJob::Continuable
 
+    # Errors must reach retry_on. By default Continuable swallows any
+    # StandardError raised after a checkpoint and silently self-resumes —
+    # unbounded invisible retries that bypass attempts/wait/jitter entirely
+    # (verified against activejob 8.1: the around_perform rescue runs before
+    # rescue_with_handler). Checkpoints still survive retry_on's re-enqueues —
+    # continuation state rides the job payload — so a retried execution skips
+    # completed steps. Isolation interrupts are rescued separately and are
+    # unaffected by this flag. Do NOT reach for max_resumptions as an error
+    # bound: with isolate_steps on, every isolated step consumes one
+    # resumption by design.
+    self.resume_errors_after_advancing = false
+
     self.resume_options = { wait: 0 } # spike: default 5s wait makes turns crawl
 
     queue_as { Silas.config.queue_name }
 
+    # Transient provider trouble: back off and retry; the continuation resumes
+    # from the last completed step. Exhaustion fails the turn LOUDLY — a turn
+    # must never strand in "running". (Never retry_on StandardError: it would
+    # catch Continuation::Error subclasses and retry a structurally broken job
+    # forever.)
+    retry_on ::RubyLLM::RateLimitError, ::RubyLLM::OverloadedError,
+             ::RubyLLM::ServiceUnavailableError, ::RubyLLM::ServerError,
+             ::Faraday::TimeoutError, ::Faraday::ConnectionFailed,
+             wait: :polynomially_longer, attempts: 5, jitter: 0.15 do |job, error|
+      fail_turn(job, error)
+    end
+
+    # Permanent provider rejections: retrying cannot help. Fail the turn now.
+    discard_on ::RubyLLM::UnauthorizedError, ::RubyLLM::PaymentRequiredError,
+               ::RubyLLM::ForbiddenError, ::RubyLLM::BadRequestError do |job, error|
+      fail_turn(job, error)
+    end
+
+    # The force-fail path: expire approvals FIRST so no stale card can
+    # zombie-resume the failed turn, then finish loudly.
+    def self.fail_turn(job, error)
+      turn = Turn.find_by(id: job.arguments.first)
+      return unless turn&.active?
+
+      turn.expire_pending_approvals!("turn failed: model error")
+      turn.finish!(:failed, reason: "model_error")
+      Rails.logger&.error("[silas] turn #{turn.id} failed on #{error.class}: #{error.message}")
+    end
+
     def perform(turn_id)
       turn = Turn.find(turn_id)
       return if turn.completed? || %w[failed canceled].include?(turn.status)
@@ -26,26 +67,17 @@ module Silas
       # staff member never wakes up holding the root agent's tools.
       scope = Silas.scope_for_session(turn.session)
       if scope
-        Silas.with_agent_scope(scope) { drive(turn) }
+        Silas.with_agent_scope(scope) { run_turn(turn) }
       else
-        drive(turn)
+        run_turn(turn)
       end
     end
 
     private
 
-    def drive(turn)
-      if Silas.resolved_engine.class.loop_ownership == :engine
-        perform_engine_owned(turn)
-      else
-        perform_framework_owned(turn)
-      end
-    end
-
-
-    # :ruby_llm — the framework drives the loop, one model call per step, tools
-    # executed through the Ledger. The determinism constraints live here.
-    def perform_framework_owned(turn)
+    # The framework drives the loop: one model call per step, tools executed
+    # through the Ledger. The determinism constraints live here.
+    def run_turn(turn)
       step :prepare, isolated: isolate? do
         Ledger.assert_no_checkpoint!
         turn.update!(status: "running", job_id: job_id, started_at: turn.started_at || Time.current)
@@ -95,35 +127,6 @@ module Silas
       end
     end
 
-    # :agent_sdk — Claude Code owns the loop; one isolated :run step wraps the
-    # whole subprocess (one Continuation checkpoint per invocation). Same
-    # durable shell, same queue/rescuer/single-active-turn invariants.
-    def perform_engine_owned(turn)
-      step :prepare, isolated: isolate? do
-        Ledger.assert_no_checkpoint!
-        turn.update!(status: "running", job_id: job_id, started_at: turn.started_at || Time.current)
-        Instructions.snapshot!(turn)
-        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!
-        outcome = SubprocessRunner.call(turn)
-      end
-
-      step :finalize do
-        turn.finish!(:completed) if outcome == :terminal
-      end
-    end
-
     def isolate? = Silas.config.isolate_steps
   end
 end

data/app/jobs/silas/dead_job_rescuer_job.rb

@@ -20,12 +20,33 @@ module Silas
 
       rescued = 0
       SolidQueue::FailedExecution.includes(:job).find_each do |failed|
-        next unless DEAD_PROCESS_ERRORS.include?(failed.error&.dig("exception_class"))
-
-        failed.retry
-        rescued += 1
+        if DEAD_PROCESS_ERRORS.include?(failed.error&.dig("exception_class"))
+          failed.retry
+          rescued += 1
+        elsif failed.job&.class_name == "Silas::AgentLoopJob"
+          fail_stranded_turn(failed)
+        end
       end
       rescued
     end
+
+    private
+
+    # A loop job that failed with a NON-dead-process error (something outside
+    # AgentLoopJob's retry list — a NoMethodError in a tool, an AR blip) will
+    # never be retried by anyone. Without this sweep its turn sits in
+    # "running" forever: not failed, not parked, invisible as broken. The
+    # failed execution stays in Solid Queue for forensics; the TURN is failed
+    # loudly with its approvals expired.
+    def fail_stranded_turn(failed)
+      turn = Turn.find_by(id: failed.job.arguments&.dig("arguments", 0))
+      return unless turn&.active?
+
+      exception = failed.error&.dig("exception_class")
+      turn.expire_pending_approvals!("turn failed: #{exception}")
+      turn.finish!(:failed, reason: "job_failed")
+      Rails.logger&.error("[silas] turn #{turn.id} failed: its loop job died with " \
+                          "#{exception} — #{failed.error&.dig('message')}")
+    end
   end
 end

data/app/models/silas/session.rb

@@ -5,6 +5,12 @@ module Silas
     has_many :turns, -> { order(:index) }, class_name: "Silas::Turn", foreign_key: :session_id,
              inverse_of: :session, dependent: :destroy
 
+    # Delegations and handoffs stamp parent_session_id; without associations
+    # they surfaced as unexplained orphans.
+    belongs_to :parent_session, class_name: "Silas::Session", optional: true
+    has_many :child_sessions, class_name: "Silas::Session",
+             foreign_key: :parent_session_id, inverse_of: :parent_session
+
     validates :status, inclusion: { in: STATUSES }
     validates :agent_name, presence: true
 

data/app/models/silas/tool_invocation.rb

@@ -35,6 +35,7 @@ module Silas
     # in-doubt invocation, approval means "it did not run — re-execute".
     def approve!(by: nil)
       assert_parked!
+      assert_turn_resumable!
       update!(status: "pending", approval_state: "approved", approved_by: by)
       resume_turn!
     end
@@ -45,6 +46,7 @@ module Silas
     # abandon" — the operator-supplied reason becomes the recorded outcome.
     def decline!(reason:, by: nil)
       assert_parked!
+      assert_turn_resumable!
       update!(status: "failed", approval_state: "declined", approved_by: by,
               decline_reason: reason, result: { "denied" => reason })
       resume_turn!
@@ -68,8 +70,18 @@ module Silas
       raise Error, "invocation #{id} is not awaiting approval (state: #{approval_state.inspect})"
     end
 
+    # A failed turn must never be zombie-resumed by a stale approval card:
+    # force-fail paths expire approvals first, but a card already rendered in
+    # someone's browser can still POST — the verdict must land on a live turn.
+    def assert_turn_resumable!
+      return unless turn.reload.failed?
+
+      raise Error, "turn #{turn.id} already failed (#{turn.failure_reason}) — " \
+                   "this approval can no longer resume it"
+    end
+
     def resume_turn!
-      return if turn.reload.canceled? # a canceled turn never zombie-resumes
+      return if turn.reload.canceled? || turn.failed? # settled turns never zombie-resume
       return if turn.tool_invocations.where(approval_state: "required").exists?
 
       turn.update!(status: "queued")

data/app/models/silas/turn.rb

@@ -17,6 +17,7 @@ module Silas
 
     ACTIVE_STATUSES.each { |s| define_method(:"#{s}?") { status == s } }
     def completed? = status == "completed"
+    def failed?    = status == "failed"
     def active?    = ACTIVE_STATUSES.include?(status)
     def parked?    = status == "waiting" || status == "in_doubt"
 
@@ -83,6 +84,15 @@ module Silas
       Array(step.response_blocks).select { |b| b["type"] == "text" }.map { |b| b["text"] }.join
     end
 
+    # The structured payload when the agent declares a final_answer schema in
+    # agent.yml (nil otherwise) — the parsed Hash, not a string to re-parse.
+    def answer_data
+      step = steps.where(status: "completed").order(:index).last
+      return nil unless step
+
+      Array(step.response_blocks).reverse.find { |b| b["type"] == "structured" }&.dig("data")
+    end
+
     # Outbound: when a channel-bound turn reaches an answer, deliver it off-loop.
     after_update_commit :notify_channel_answer, if: :should_notify_answer?
 

data/app/views/layouts/silas/inbox.html.erb

@@ -58,6 +58,7 @@
     .step::before { content: ""; position: absolute; left: -5px; top: 6px; width: 8px; height: 8px;
       border-radius: 50%; background: var(--accent); }
     .step-text { margin: 2px 0; }
+    .step-live { white-space: pre-wrap; }
     .tool { background: var(--grey-bg); border-radius: 10px; padding: 8px 10px; margin: 6px 0; font-size: 13px; }
     .tool code { font-family: var(--mono); }
     pre { font-family: var(--mono); font-size: 12px; background: var(--grey-bg); border-radius: 8px;
@@ -73,12 +74,30 @@
       padding: 8px; margin: 8px 0; font: inherit; background: var(--panel); color: var(--ink); resize: vertical; }
     form.inline { display: inline; }
     .cost { font-family: var(--mono); font-size: 12px; color: var(--muted); }
+    .composer textarea { width: 100%; border: 1px solid var(--line); border-radius: 10px;
+      padding: 10px 12px; font: inherit; background: var(--panel); color: var(--ink); resize: vertical; }
+    .composer textarea:focus { outline: 2px solid var(--accent); outline-offset: -1px; }
+    .composer-row { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-top: 8px; }
+    .btn.send { background: var(--accent); color: #fff; }
+    select.composer-agent { border: 1px solid var(--line); border-radius: 8px; padding: 6px 8px;
+      font: inherit; background: var(--panel); color: var(--ink); margin-bottom: 8px; }
     .flash { background: var(--red-bg); color: var(--red); padding: 10px 12px; border-radius: 10px; margin-bottom: 12px; }
+    .flash-notice { background: var(--green-bg); color: var(--green); }
+    .btn-cancel { border: 1px solid var(--red); background: transparent; color: var(--red);
+      border-radius: 8px; padding: 2px 10px; font-size: 12px; font-weight: 600; cursor: pointer; margin-left: auto; }
+    pre.error { background: var(--red-bg); color: var(--red); }
+    pre.args { opacity: 0.85; }
     .empty { text-align: center; color: var(--muted); padding: 48px 0; }
     .agent-filter { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 14px; }
     .agent-filter .chip { font-size: 12px; padding: 3px 10px; border: 1px solid #d9dce1;
       border-radius: 999px; text-decoration: none; color: inherit; }
     .agent-filter .chip-on { background: #16181d; color: #fff; border-color: #16181d; }
+    .pager { text-align: center; margin: 16px 0; }
+    .pager .chip { font-size: 13px; padding: 6px 14px; border: 1px solid var(--line);
+      border-radius: 999px; text-decoration: none; color: inherit; }
+    .topup-form { display: flex; gap: 8px; margin-top: 8px; }
+    .topup-input { flex: 1; border: 1px solid var(--line); border-radius: 8px; padding: 8px 10px;
+      font: inherit; background: var(--panel); color: var(--ink); }
   </style>
 </head>
 <body>
@@ -89,6 +108,7 @@
       <% if content_for?(:header_extra) %><%= yield :header_extra %><% end %>
     </header>
     <% if flash[:alert] %><div class="flash"><%= flash[:alert] %></div><% end %>
+    <% if flash[:notice] %><div class="flash flash-notice"><%= flash[:notice] %></div><% end %>
     <%= yield %>
   </div>
 </body>

data/app/views/silas/inbox/invocations/_invocation.html.erb

@@ -2,10 +2,26 @@
   <div>
     <code><%= invocation.tool_name %></code>
     <%= status_pill(invocation.awaiting_approval? ? "required" : invocation.status) %>
+    <%# The audit line — who held the lever, and why it moved. %>
+    <% if invocation.approval_state == "approved" && invocation.approved_by.present? %>
+      <span class="muted">approved by <%= invocation.approved_by %></span>
+    <% elsif invocation.approval_state == "declined" %>
+      <span class="muted">declined<%= " by #{invocation.approved_by}" if invocation.approved_by.present? %><%= " — “#{invocation.decline_reason}”" if invocation.decline_reason.present? %></span>
+    <% elsif invocation.approval_state == "expired" %>
+      <span class="muted">approval expired unanswered</span>
+    <% end %>
   </div>
   <% if invocation.awaiting_approval? %>
     <%= render "silas/inbox/invocations/approval_card", invocation: invocation %>
-  <% elsif invocation.result.present? %>
-    <pre><%= pretty_args(invocation.result) %></pre>
+  <% else %>
+    <%# What the agent passed — the question an audit surface must answer. %>
+    <% if invocation.arguments.present? %>
+      <pre class="args"><%= pretty_args(invocation.arguments) %></pre>
+    <% end %>
+    <% if invocation.error.present? %>
+      <pre class="error"><%= invocation.error %></pre>
+    <% elsif invocation.result.present? %>
+      <pre><%= pretty_args(invocation.result) %></pre>
+    <% end %>
   <% end %>
 </div>

data/app/views/silas/inbox/sessions/index.html.erb

@@ -1,5 +1,7 @@
 <% content_for :header_extra do %>
-  <% if @pending_total.positive? %><span class="badge"><%= @pending_total %> awaiting approval</span><% end %>
+  <% if @pending_total.positive? %>
+    <%= link_to "#{@pending_total} awaiting approval", inbox_sessions_path(pending: 1), class: "badge" %>
+  <% end %>
 <% end %>
 
 <% if @agent_names && @agent_names.size > 1 %>
@@ -12,22 +14,46 @@
   </div>
 <% end %>
 
+<div class="card composer">
+  <%= form_with url: inbox_sessions_path do |f| %>
+    <% roster = Silas.named_agent_scopes.keys.sort %>
+    <% if roster.any? %>
+      <%= f.select :agent, [ [ "agent (root)", "" ] ] + roster.map { |a| [ a, a ] },
+            {}, class: "composer-agent" %>
+    <% end %>
+    <%= f.text_area :input, rows: 2, required: true, class: "composer-input",
+          placeholder: "Start a new session…" %>
+    <div class="composer-row">
+      <span></span>
+      <%= f.submit "Start session", class: "btn send" %>
+    </div>
+  <% end %>
+</div>
+
 <% if @sessions.empty? %>
-  <div class="empty">No agent sessions yet.</div>
+  <div class="empty">No agent sessions yet — start one above.</div>
 <% else %>
   <% @sessions.each do |session| %>
     <%= link_to inbox_session_path(session), class: "card session-row" do %>
       <div class="row-top">
         <span class="name"><%= session.agent_name %></span>
-        <% if (turn = session.active_turn || session.turns.last) %><%= status_pill(turn.status) %><% end %>
-        <% pending = session.pending_approvals.count %>
+        <%# Loaded association — no per-row queries. %>
+        <% if (turn = session.turns.detect(&:active?) || session.turns.last) %><%= status_pill(turn.status) %><% end %>
+        <% pending = @pending_counts.fetch(session.id, 0) %>
         <% if pending.positive? %><span class="badge"><%= pending %> to approve</span><% end %>
       </div>
       <div class="muted">
-        <%= pluralize(session.turns.count, "turn") %> ·
+        <%= pluralize(session.turns.size, "turn") %> ·
         <%= session.channel.presence || "direct" %> ·
         <%= relative_time(session.updated_at) %>
       </div>
     <% end %>
   <% end %>
+  <% if @next_before %>
+    <div class="pager">
+      <%= link_to "Older sessions →",
+            inbox_sessions_path(before: @next_before, agent: params[:agent].presence, pending: params[:pending].presence),
+            class: "chip" %>
+    </div>
+  <% end %>
 <% end %>

data/app/views/silas/inbox/sessions/show.html.erb

@@ -18,3 +18,14 @@
 <div id="silas-turns">
   <%= render partial: "silas/inbox/turns/turn", collection: @turns, as: :turn %>
 </div>
+
+<div class="card composer">
+  <%= form_with url: inbox_session_turns_path(@session) do |f| %>
+    <%= f.text_area :input, rows: 2, required: true, class: "composer-input",
+          placeholder: "Message #{@session.agent_name}…" %>
+    <div class="composer-row">
+      <span class="muted"><%= "a turn is running — sending will queue behind it" if @session.active_turn %></span>
+      <%= f.submit "Send", class: "btn send" %>
+    </div>
+  <% end %>
+</div>

data/app/views/silas/inbox/steps/_step.html.erb

@@ -1,6 +1,14 @@
 <div class="step" id="<%= dom_id(step) %>">
+  <%# The text container is unconditional: silas-step-<id>-text is the live
+      delta target. While the step runs, deltas replace its innerHTML; the
+      completed row render (this partial, re-broadcast) supersedes them. %>
   <% if (text = step_text(step)) %>
-    <div class="step-text"><%= simple_format(text) %></div>
+    <div class="step-text" id="silas-step-<%= step.id %>-text"><%= simple_format(text) %></div>
+  <% else %>
+    <div class="step-text step-live" id="silas-step-<%= step.id %>-text"></div>
+  <% end %>
+  <% if (data = step_structured(step)) %>
+    <pre class="args"><%= pretty_args(data) %></pre>
   <% end %>
   <div id="silas-step-<%= step.id %>-tools">
     <%= render partial: "silas/inbox/invocations/invocation", collection: step.tool_invocations, as: :invocation %>

data/app/views/silas/inbox/turns/_header.html.erb

@@ -1,7 +1,25 @@
 <div class="turn-head">
   <span class="turn-input"><%= truncate(turn.input, length: 90) %></span>
   <%= status_pill(turn.status) %>
+  <% if turn.active? && !turn.cancel_requested_at %>
+    <%= form_with url: cancel_inbox_turn_path(turn), method: :post, class: "inline" do %>
+      <button class="btn-cancel" title="Honored at the next step boundary">Cancel</button>
+    <% end %>
+  <% elsif turn.cancel_requested_at && turn.active? %>
+    <span class="muted">cancel requested…</span>
+  <% end %>
 </div>
-<% if turn.failure_reason.present? %>
+<% if turn.budget_parked? %>
+  <div class="approval">
+    <h3>Budget reached — <%= turn.failure_reason %></h3>
+    <div class="muted">Parked at zero compute. Raise the limit and the turn resumes
+      by replaying completed work from rows — no re-calls, no re-effects.</div>
+    <%= form_with url: raise_budget_inbox_turn_path(turn), method: :post, class: "topup-form" do %>
+      <input name="value" type="number" step="any" min="0" required class="topup-input"
+             placeholder="<%= turn.failure_reason == "max_cost" ? "new limit in dollars, e.g. 2.50" : "new limit, e.g. 200000" %>">
+      <button class="btn approve">Raise &amp; resume</button>
+    <% end %>
+  </div>
+<% elsif turn.failure_reason.present? %>
   <div class="muted">failed: <%= turn.failure_reason %></div>
 <% end %>

data/config/routes.rb

@@ -1,4 +1,23 @@
 Silas::Engine.routes.draw do
+  namespace :api do
+    namespace :v1 do
+      resources :sessions, only: %i[create show] do
+        resources :turns, only: :create
+        resources :approvals, only: :index
+        get :stream, on: :member, to: "streams#show"
+      end
+      resources :turns, only: [] do
+        member { post :cancel }
+      end
+      resources :approvals, only: [] do
+        member do
+          post :approve
+          post :decline
+        end
+      end
+    end
+  end
+
   namespace :channels do
     post "slack/events", to: "slack#events"
     post "slack/actions", to: "slack#actions"
@@ -8,7 +27,15 @@ Silas::Engine.routes.draw do
 
   namespace :inbox do
     root to: "sessions#index"
-    resources :sessions, only: %i[index show]
+    resources :sessions, only: %i[index show create] do
+      resources :turns, only: :create
+    end
+    resources :turns, only: [] do
+      member do
+        post :cancel
+        post :raise_budget
+      end
+    end
     resources :invocations, only: [] do
       member do
         post :approve

data/db/migrate/20260724000001_drop_agent_sdk_columns_from_silas_turns.rb

@@ -0,0 +1,9 @@
+class DropAgentSdkColumnsFromSilasTurns < ActiveRecord::Migration[8.1]
+  # The :agent_sdk engine was removed in 0.2. cli_session_id was its fail-closed
+  # resume marker; mcp_token was written by Mcp::Server but read by nothing (the
+  # token is minted and compared in memory).
+  def change
+    remove_column :silas_turns, :cli_session_id, :string
+    remove_column :silas_turns, :mcp_token, :string
+  end
+end

data/db/migrate/20260725000001_add_provider_to_silas_steps.rb

@@ -0,0 +1,13 @@
+class AddProviderToSilasSteps < ActiveRecord::Migration[8.1]
+  def change
+    # The provider RubyLLM's resolution picked for the step's model, stamped at
+    # persist time — cost lookups price against (model, provider) forever
+    # after, immune to registry tie-break changes (85/1081 registry ids exist
+    # under multiple providers at different prices).
+    add_column :silas_steps, :provider, :string
+
+    # Declared in 0.1.0, defaulted to 0, never written — a silent lie to
+    # anyone who queried it. Cost is derived at read time from step tokens.
+    remove_column :silas_turns, :cost_microcents, :integer, null: false, default: 0
+  end
+end