silas 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36bc01dd259d8950ae57b75a3eb94f91065aed62d2b149d705959695bc8f323f
-  data.tar.gz: f2aa37ea2d83373d2252b594aaef87894f1da03adda08edfa746baa6e76c2dea
+  metadata.gz: 9abd9603ae899da9a789ded30f092f11f1881ddc9abd2f0edf2638421f469abb
+  data.tar.gz: 16a684a62b54346ee51d4e7b9f6cb92ec19c2d95e7027667b432044d9a1e7f71
 SHA512:
-  metadata.gz: 43ba5370306adecd0c53f818d655a367748e5b3162559abca5e8eb2a5687410c8d145f8f8b545f98ca265961344378e1c0a474826b46853357f2bce4192aa12b
-  data.tar.gz: 3cf07dea2adbe6eb33ec3bf65401c96127c1a066fbb104ea2e945d42f5526e8272aebbf9561a5777d1c6278674b3bc386036d1aa2b01bcb37d99366822ac431b
+  metadata.gz: 9518d703a421ed47d1c59e9cb74cdbd46686b8a783a1f5aea8f90f5911e0e27f5ccc5fc86da22c8ebe870a3d811b7de28e5abfc2ff837ab7dbc47722d13e3dcc
+  data.tar.gz: 954efe8fac65a18a0d936bafda946bcca96e8dda35201d06637d8f6ee5a8ca425ecd50ab322d2f137e7c0d03b2e97321db7d5cedfc5ac7d0a4b016ddf3184b63

data/CHANGELOG.md

@@ -1,5 +1,114 @@
 # Changelog
 
+## 0.4.0
+
+The architecture-and-hardening release: one shipped feature that had never
+worked, the naming locked down before 1.0 freezes it, and the durable loop
+finally observable.
+
+### Fixed
+
+- **The email approval channel had never worked.** Both the approval email
+  template and the confirmation page called `approval_url`/`approval_path`,
+  but the route is declared inside `namespace :channels`, so the real helpers
+  are `channels_approval_url`/`_path`. Rendering raised — meaning
+  **`ChannelMailer#approval` blew up and the "your agent needs approval" email
+  was never delivered**, and the confirmation page 500'd. If you relied on
+  email approvals, you were silently never notified that a money-moving call
+  was parked. Found by writing the first specs for these surfaces.
+
+### Changed (breaking, pre-1.0)
+
+- **The inference seam is now `Adapters::`, not `Engines::`** — and
+  `config.adapter`, not `config.engine`. "Engine" meant two unrelated things
+  in one namespace: the Rails engine at `Silas::Engine`, and the pluggable
+  inference backend. Every comparable seam disambiguates — ActiveJob has
+  `QueueAdapters::`, ActiveStorage `Service::`, RubyLLM `Provider`. Done now
+  because 1.0 freezes the public API and host apps subclass this seam.
+  **Nothing breaks today**: `Silas::Engines::Base`, `config.engine`, and
+  `Silas.resolved_engine` all still resolve, warn through the new deprecator,
+  and are removed in 2.0.
+- **Notification names follow the Rails convention** `<event>.silas` (like
+  `sql.active_record`). The two pre-existing events were backwards:
+  `silas.step` → `step.silas`, `silas.delta` → `delta.silas`. Update any
+  subscriber; `subscribe(/\.silas\z/)` now catches everything.
+
+### Added
+
+- **Instrumentation for the durable loop.** It emitted almost nothing before:
+  a turn could start, park for a human, be rescued after a `kill -9`, breach a
+  budget and finish without a single line. Ten events now — `turn`, `step`,
+  `tool`, `park`, `resume`, `approval`, `budget`, `rescue`, `nondeterminism`,
+  `delta` — with documented payloads that always carry `turn_id`/`session_id`,
+  so a subscriber never has to join. **`tool.silas`** times the tool's own
+  execution and reports how it settled (the most useful span in the system);
+  **`resume.silas`** carries `parked_for` — how long the human actually took.
+  `Silas::LogSubscriber` (modelled on Solid Queue's) turns them into log lines
+  at operator-filterable levels: parks and rescues INFO, budget WARN, failed
+  turns and nondeterminism ERROR, per-token chatter DEBUG — and stays silent
+  when the rescuer did nothing.
+- **`Silas.deprecator`** — an `ActiveSupport::Deprecation` registered in
+  `app.deprecators[:silas]`, so hosts silence or raise on Silas deprecations
+  exactly as they do Rails'. Every message names the replacement *and* the
+  removal version.
+- **Coverage for the four money-path surfaces that had none** (36 specs):
+  `Channels::SlackController` (unsigned / wrong-secret / stale-timestamp
+  requests refused end to end; retries and bot messages ignored; buttons
+  settle through the same `approve!`/`decline!`),
+  `Channels::ApprovalsController` (tampered, garbage, expired and
+  wrong-purpose tokens refused; **GET never mutates**, so a link preview or
+  scanner cannot approve a refund; a replayed link on a settled invocation
+  422s), `AgentMailbox` (References → In-Reply-To → Message-ID threading, so
+  replies continue rather than restart), and `ChannelMailer` (renders, shows
+  the arguments, embeds two distinct absolute links whose tokens verify back).
+- **Quality tooling, enforced in CI**: `rubocop-rails-omakase` (Rails' own
+  style baseline, zero offenses), SimpleCov with a **90% line-coverage floor
+  that fails the build** (actual: 92.5%), Brakeman and bundler-audit (clean —
+  the single deliberate CSRF suppression is documented with its reasoning in
+  `config/brakeman.ignore`), and a `rake zeitwerk:check` job that eager-loads
+  every constant to catch naming violations lazy tests never see.
+- **Dependency contract specs.** Silas reaches into Solid Queue and RubyLLM
+  internals, where a rename breaks *recovery* silently. Ten specs pin them:
+  the dead-process error classes the rescuer allowlists,
+  `FailedExecution#retry`, the Solid Queue >= 1.2 continuations floor,
+  RubyLLM's `with_schema`/`before_message`/`Tool::Halt`/model registry and the
+  error classes `retry_on` names, and `resume_errors_after_advancing` staying
+  false. Plus an allowed-to-fail CI canary against ruby_llm edge, for early
+  warning on the 2.0 horizon.
+- **`docs/conventions.md`** — the naming and structure rules (why the seam is
+  `Adapters::`; the deliberate `class << self` vs `module_function` split) and
+  the audited posture: nothing mass-assigned, no `raw`/`html_safe` anywhere,
+  `Time.current` throughout, indexes on query paths rather than every foreign
+  key. Written down so nobody "fixes" something load-bearing.
+
+No migration. 336 specs green on SQLite and Postgres.
+
+## 0.3.2
+
+- **The `timeout` budget no longer counts time spent parked for approval.**
+  The wall clock restarts when an approval resumes a turn, because any
+  approval slower than `limits.timeout` previously made the approved resume
+  *instantly* re-park on "timeout" — pathological for a gate whose whole point
+  is waiting for a person (found live in the playground: a 3-minute approval
+  against a 120s timeout). Timeout now bounds **active** stretches — hung
+  providers, runaway loops; crash-rescue resumes keep the original clock (the
+  turn was genuinely live), and cost/token budgets stay cumulative because
+  they measure real spend.
+- **Broadcast-rendered trace partials work in host apps.** The inbox's live
+  trace renders through Turbo's broadcast jobs — i.e. the HOST's default
+  renderer — where the engine-scoped `TraceHelper` and bare engine route
+  helpers didn't exist, so **every broadcast render raised and the live trace
+  silently never streamed in real host apps** (the gem's specs stubbed the
+  dispatch seam and never rendered). The helper is now registered host-wide,
+  partials build routes context-free via `silas_engine_path` (engine route
+  set + discovered mount point), and four host-renderer regression specs pin
+  the real path. `relative_time` is renamed `silas_relative_time` (it is now
+  host-visible, and the bare name is exactly what a host app would define).
+  Also new: `examples/playground` gets a customer-facing chat page that
+  renders and live-streams the engine's own trace partials with zero custom
+  streaming code, plus a scripted keyless demo mode (`bin/setup && bin/dev`
+  with no API key).
+
 ## 0.3.1
 
 - **Fixed: only the first scenario in a `silas:eval` run was really tested.**

data/README.md

@@ -104,15 +104,15 @@ hundreds of times per release (results in `chaos_host/results/`):
   deploy that changes tools/skills mid-turn fails the turn loudly
   (`NondeterminismError`) instead of resuming into a different agent.
 
-## Engine
+## Adapter
 
-Inference is one pluggable seam (`config.engine`): `:ruby_llm` — API-key auth
+Inference is one pluggable seam (`config.adapter`): `:ruby_llm` — API-key auth
 via [RubyLLM](https://rubyllm.com), any provider it supports — is the default
 and the production path. Compose resilience via `config.around_model_call`, or
 swap in any object responding to `#execute_step` (the eval harness and the
 chaos tests do exactly that).
 
-> The experimental `:agent_sdk` engine (a `claude -p` subprocess) was removed
+> The experimental `:agent_sdk` adapter (a `claude -p` subprocess) was removed
 > in 0.2: its subscription-auth rationale was structurally unreachable, and it
 > carried weaker guarantees than `:ruby_llm` on every axis. Its in-process MCP
 > server survives and returns as a first-class *mount your tools as MCP*
@@ -200,13 +200,13 @@ An agent is reached by more than a method call:
 
 ## Streaming
 
-Turns stream. The `:ruby_llm` engine emits text deltas as the model responds:
+Turns stream. The `:ruby_llm` adapter emits text deltas as the model responds:
 `bin/rails silas:chat` prints tokens as they arrive, and the inbox trace
 renders them live over Turbo (coalesced to ~10Hz). Deltas are decoration over
 the durable rows — never persisted, never fed back to the model, and a
 replayed step renders from its row with no deltas at all, so streaming adds
 zero risk to the durability contract. Custom sinks subscribe to the
-`"silas.delta"` notification (`{ session_id:, turn_id:, step_id:, step_index:,
+`"delta.silas"` notification (`{ session_id:, turn_id:, step_id:, step_index:,
 text: }`, where `text` is the accumulated string so far — filter by ids;
 notifications are process-global).
 

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

@@ -37,11 +37,21 @@ module Silas
         end
       end
 
-      def relative_time(time)
+      # Prefixed: this helper is registered host-wide (broadcast renders need
+      # it), and "relative_time" is exactly the name a host app would define.
+      def silas_relative_time(time)
         return "" unless time
 
         "#{time_ago_in_words(time)} ago"
       end
+
+      # Engine paths that resolve in EVERY render context. The mounted proxy
+      # (`silas.`) leans on the rendering scope's url_options, which Turbo's
+      # bare broadcast renderer doesn't have — so broadcast-rendered partials
+      # build paths from the engine's own route set + the discovered mount.
+      def silas_engine_path(helper, *args)
+        Silas::Engine.routes.url_helpers.public_send(helper, *args, script_name: Silas::Inbox.mount_path)
+      end
     end
   end
 end

data/app/jobs/silas/agent_loop_job.rb

@@ -112,6 +112,8 @@ module Silas
         # replays completed steps from rows, resuming where it left off.
         if (reason = Budget.exceeded_reason(turn))
           turn.update!(status: "waiting", failure_reason: reason)
+          Silas.instrument(:budget, reason: reason, turn_id: turn.id)
+          Silas.instrument(:park, reason: "budget", turn_id: turn.id, detail: reason)
           return
         end
 

data/app/jobs/silas/dead_job_rescuer_job.rb

@@ -15,7 +15,13 @@ module Silas
     queue_as { Silas.config.queue_name }
 
     def perform
+      Silas.instrument(:rescue) { |payload| sweep(payload) }
+    end
+
+    def sweep(payload)
       ToolInvocation.expire_stale!
+      payload[:rescued] = 0
+      payload[:stranded] = 0
       return 0 unless defined?(SolidQueue)
 
       rescued = 0
@@ -24,9 +30,10 @@ module Silas
           failed.retry
           rescued += 1
         elsif failed.job&.class_name == "Silas::AgentLoopJob"
-          fail_stranded_turn(failed)
+          payload[:stranded] += 1 if fail_stranded_turn(failed)
         end
       end
+      payload[:rescued] = rescued
       rescued
     end
 
@@ -40,13 +47,14 @@ module Silas
     # 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?
+      return false 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')}")
+      true
     end
   end
 end

data/app/models/silas/tool_invocation.rb

@@ -37,6 +37,8 @@ module Silas
       assert_parked!
       assert_turn_resumable!
       update!(status: "pending", approval_state: "approved", approved_by: by)
+      Silas.instrument(:approval, action: "approved", tool: tool_name, by: by,
+                                  invocation_id: id, turn_id: turn_id)
       resume_turn!
     end
 
@@ -49,6 +51,8 @@ module Silas
       assert_turn_resumable!
       update!(status: "failed", approval_state: "declined", approved_by: by,
               decline_reason: reason, result: { "denied" => reason })
+      Silas.instrument(:approval, action: "declined", tool: tool_name, by: by,
+                                  invocation_id: id, turn_id: turn_id)
       resume_turn!
     end
 
@@ -58,6 +62,8 @@ module Silas
       where(approval_state: "required").where(approval_expires_at: ..now).find_each do |inv|
         inv.update!(approval_state: "expired", status: "failed",
                     result: { "denied" => "approval expired" })
+        Silas.instrument(:approval, action: "expired", tool: inv.tool_name,
+                                    invocation_id: inv.id, turn_id: inv.turn_id)
         inv.turn.finish!(:failed, reason: "approval_expired")
       end
     end
@@ -84,7 +90,15 @@ module Silas
       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")
+      # Restart the wall clock: `limits.timeout` bounds ACTIVE stretches (hung
+      # providers, runaway loops), not human deliberation. Without this, any
+      # approval that took longer than the timeout made the approved resume
+      # instantly re-park on "timeout" — pathological for a gate whose whole
+      # point is waiting for a person. Cost/token budgets stay cumulative;
+      # they measure real spend.
+      parked_for = turn.updated_at ? (Time.current - turn.updated_at).to_f : nil
+      turn.update!(status: "queued", started_at: Time.current)
+      Silas.instrument(:resume, turn_id: turn.id, parked_for: parked_for)
       AgentLoopJob.perform_later(turn.id)
     end
   end

data/app/models/silas/turn.rb

@@ -21,8 +21,14 @@ module Silas
     def active?    = ACTIVE_STATUSES.include?(status)
     def parked?    = status == "waiting" || status == "in_doubt"
 
+    # Duration on this event spans the WHOLE turn, parked time included — it
+    # answers "how long did the customer wait", not "how much compute".
     def finish!(new_status, reason: nil)
-      update!(status: new_status.to_s, failure_reason: reason, finished_at: Time.current)
+      Silas.instrument(:turn, status: new_status.to_s, reason: reason, turn_id: id,
+                              session_id: session_id, agent: session.agent_name,
+                              steps: steps.count) do
+        update!(status: new_status.to_s, failure_reason: reason, finished_at: Time.current)
+      end
     end
 
     def canceled? = status == "canceled"

data/app/views/silas/channel_mailer/approval.text.erb

@@ -3,7 +3,7 @@ Your agent needs approval to run: <%= @invocation.tool_name %>
 Arguments:
 <%= JSON.pretty_generate(@invocation.arguments) %>
 
-Approve: <%= silas.approval_url(token: @approve_token) %>
-Decline: <%= silas.approval_url(token: @decline_token) %>
+Approve: <%= silas.channels_approval_url(token: @approve_token) %>
+Decline: <%= silas.channels_approval_url(token: @decline_token) %>
 
 These links expire; do not forward them.

data/app/views/silas/channels/approvals/show.html.erb

@@ -1,7 +1,7 @@
 <% if @invocation&.awaiting_approval? %>
   <h1>Approval needed: <%= @invocation.tool_name %></h1>
   <pre><%= JSON.pretty_generate(@invocation.arguments) %></pre>
-  <%= form_with url: silas.approval_path(token: params[:token]), method: :post do %>
+  <%= form_with url: silas.channels_approval_path(token: params[:token]), method: :post do %>
     <button type="submit">Confirm <%= @action %></button>
   <% end %>
 <% else %>

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

@@ -1,10 +1,13 @@
 <div class="approval">
   <h3>Approval needed — <%= invocation.tool_name %></h3>
   <pre><%= pretty_args(invocation.arguments) %></pre>
-  <%= form_with url: approve_inbox_invocation_path(invocation), method: :post, class: "inline" do %>
+  <%# silas_engine_path, not bare helpers: this partial is broadcast-rendered
+      through the HOST's renderer, where engine route helpers don't exist and
+      the mounted proxy has no routing scope to lean on. %>
+  <%= form_with url: silas_engine_path(:approve_inbox_invocation_path, invocation), method: :post, class: "inline" do %>
     <button class="btn approve">Approve</button>
   <% end %>
-  <%= form_with url: decline_inbox_invocation_path(invocation), method: :post, class: "decline-form" do %>
+  <%= form_with url: silas_engine_path(:decline_inbox_invocation_path, invocation), method: :post, class: "decline-form" do %>
     <textarea name="reason" rows="2" placeholder="Reason (optional — sent back to the agent as the tool result)"></textarea>
     <button class="btn decline">Decline</button>
   <% end %>

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

@@ -45,7 +45,7 @@
       <div class="muted">
         <%= pluralize(session.turns.size, "turn") %> ·
         <%= session.channel.presence || "direct" %> ·
-        <%= relative_time(session.updated_at) %>
+        <%= silas_relative_time(session.updated_at) %>
       </div>
     <% end %>
   <% end %>

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

@@ -11,7 +11,7 @@
     <span class="name"><%= @session.agent_name %></span>
     <span class="muted">#<%= @session.id %></span>
   </div>
-  <div class="muted"><%= @session.channel.presence || "direct" %> · started <%= relative_time(@session.created_at) %></div>
+  <div class="muted"><%= @session.channel.presence || "direct" %> · started <%= silas_relative_time(@session.created_at) %></div>
   <div id="silas-session-<%= @session.id %>-cost"><%= render "silas/inbox/sessions/cost", session: @session %></div>
 </div>
 

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

@@ -2,7 +2,10 @@
   <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 %>
+    <%# silas_engine_path — this partial is broadcast-rendered through the
+        host renderer on every turn status change; bare engine helpers (and
+        the scope-dependent mounted proxy) 500 there. %>
+    <%= form_with url: silas_engine_path(: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? %>
@@ -14,7 +17,7 @@
     <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 %>
+    <%= form_with url: silas_engine_path(: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>

data/config/brakeman.ignore

@@ -0,0 +1,11 @@
+{
+  "ignored_warnings": [
+    {
+      "warning_type": "Cross-Site Request Forgery",
+      "warning_code": 7,
+      "fingerprint": "64dd0725204c2cd5d6b2dba2fac6c278d20cebd07aaed38493f229193f44ed79",
+      "file": "app/controllers/silas/channels/base_controller.rb",
+      "note": "Deliberate: Silas::Channels::BaseController serves inbound WEBHOOKS, which no browser session originates, so a CSRF token cannot exist. Each route authenticates the request itself instead: Slack routes verify an HMAC-SHA256 request signature with a 300s replay window (Silas::Slack.verify_signature, covered by spec/silas/channels/slack_controller_spec.rb), and the email approve/decline routes require a purpose-scoped, expiring MessageVerifier token whose possession IS the credential — CSRF would add nothing an attacker holding the token could not already do (covered by spec/silas/channels/approvals_controller_spec.rb, including tampered/expired/wrong-purpose/replayed tokens and the GET-never-mutates property). The inbox controllers keep protect_from_forgery; the JSON API is ActionController::API and is token-authenticated."
+    }
+  ]
+}

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

@@ -1,7 +1,7 @@
 Silas.configure do |config|
   # Inference engine: :ruby_llm (API key, any provider RubyLLM supports), or
   # any object responding to #execute_step. See silas/README.
-  config.engine = :ruby_llm
+  config.adapter = :ruby_llm
 
   # Any model your installed ruby_llm's registry resolves (newer models may
   # need `RubyLLM.models.refresh!` first). "claude-sonnet-4-5" is the balanced

data/lib/silas/{engines → adapters}/base.rb

@@ -3,11 +3,11 @@ module Silas
   # set — consumers must ignore unknown types. Emitted today by Engines::RubyLLM:
   #   :message_start — once per model call (before_message)
   #   :text_delta    — { text: } chunks as the response streams
-  # StepRunner coalesces :text_delta into "silas.delta" notifications (see
+  # StepRunner coalesces :text_delta into "delta.silas" notifications (see
   # DeltaBuffer); everything else is available to custom engines/hooks.
   Event = Data.define(:type, :payload)
 
-  module Engines
+  module Adapters
     # The inference seam. An engine executes exactly ONE model call for a step
     # and reports what came back; the framework owns the loop, the ledger owns
     # tool execution.
@@ -25,4 +25,14 @@ module Silas
 
     ToolCall = Data.define(:id, :name, :arguments)
   end
+
+  # Renamed Engines:: -> Adapters:: in 0.4, removed in 2.0. Host apps subclass
+  # Adapters::Base for custom inference backends, so the old constant keeps
+  # resolving (with a warning) rather than blowing up on upgrade.
+  module Engines
+    def self.const_missing(name)
+      Silas.deprecator.warn("Silas::Engines::#{name} is deprecated; use Silas::Adapters::#{name}")
+      Silas::Adapters.const_get(name)
+    end
+  end
 end

data/lib/silas/{engines → adapters}/ruby_llm.rb

@@ -1,5 +1,5 @@
 module Silas
-  module Engines
+  module Adapters
     # The :ruby_llm adapter: ONE model call per step, streamed, with tool
     # interception. Silas's Ledger owns tool execution, so tools are registered
     # as halt-proxies — RubyLLM sees the schemas, but the moment the model
@@ -11,7 +11,7 @@ module Silas
       def execute_step(context, &on_event)
         chat = build_chat(context, &on_event)
 
-        response = ActiveSupport::Notifications.instrument("silas.step",
+        response = Silas.instrument(:step,
                                                            turn_id: context[:turn]&.id,
                                                            index: context[:index],
                                                            model: context[:model]) do

data/lib/silas/budget.rb

@@ -7,9 +7,11 @@ module Silas
   #
   # 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). 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.
+  # is correct (the turn genuinely ran too long across the crash). The clock
+  # RESTARTS when an approval resumes the turn (resume_turn! resets
+  # started_at): timeout bounds active stretches, never the hours a human
+  # spends deciding. Crash-rescue resumes keep the original clock — the turn
+  # was live the whole time.
   module Budget
     REASONS = %w[max_input_tokens max_cost timeout].freeze
 

data/lib/silas/chat.rb

@@ -59,11 +59,11 @@ module Silas
     end
 
     # The REPL runs inline, in the same process as the loop — so it hears the
-    # "silas.delta" notifications and prints tokens as they arrive. Filtered by
+    # "delta.silas" notifications and prints tokens as they arrive. Filtered by
     # session id: notifications are process-global.
     def with_delta_stream
       @live = {}
-      subscription = ActiveSupport::Notifications.subscribe("silas.delta") do |*args|
+      subscription = ActiveSupport::Notifications.subscribe("delta.silas") do |*args|
         payload = args.last
         print_delta(payload) if @session && payload[:session_id] == @session.id
       end

data/lib/silas/configuration.rb

@@ -1,7 +1,9 @@
 module Silas
   class Configuration
-    # Inference engine seam: :ruby_llm, or any object responding to #execute_step.
-    attr_accessor :engine
+    # Inference adapter seam: :ruby_llm, or any object responding to
+    # #execute_step. (Named `engine` before 0.4 — see the deprecated alias
+    # below; "engine" already meant the Rails engine at Silas::Engine.)
+    attr_accessor :adapter
     # Default model when agent.yml doesn't specify one.
     attr_accessor :default_model
     # Active Job queue for agent turns.
@@ -39,8 +41,21 @@ module Silas
     # tools as MCP" seam).
     attr_accessor :mcp_server_host
 
+    # Renamed in 0.4, removed in 2.0. "engine" meant two unrelated things —
+    # the Rails engine (Silas::Engine) and the inference backend — the exact
+    # collision ActiveJob avoids by calling its seam QueueAdapters.
+    def engine
+      Silas.deprecator.warn("config.engine is deprecated; use config.adapter")
+      adapter
+    end
+
+    def engine=(value)
+      Silas.deprecator.warn("config.engine= is deprecated; use config.adapter=")
+      self.adapter = value
+    end
+
     # config.auth and the agent_sdk_* options were removed with the :agent_sdk
-    # engine in 0.2 (warning no-ops for one release) and hard-removed in 0.3 —
+    # adapter in 0.2 (warning no-ops for one release) and hard-removed in 0.3 —
     # a leftover write now raises NoMethodError. Delete them from your
     # initializer.
     # JSON API (mounted under /silas/api/v1).
@@ -83,7 +98,7 @@ module Silas
     end
 
     def initialize
-      @engine = :ruby_llm
+      @adapter = :ruby_llm
       # Must be resolvable by the installed ruby_llm's model registry — newer
       # Claude models may need `RubyLLM.models.refresh!` before they resolve.
       # (Sonnet 4.5 ships in every supported registry; never default a first
@@ -142,11 +157,11 @@ module Silas
 
     # Fail-loud misconfiguration checks, run from Silas.configure and at boot.
     def boot_guard!
-      if engine == :agent_sdk
+      if adapter == :agent_sdk
         raise BootGuardError,
-              "the :agent_sdk engine was removed in Silas 0.2 — the claude -p subprocess " \
+              "the :agent_sdk adapter was removed in Silas 0.2 — the claude -p subprocess " \
               "integration is gone (its subscription-auth rationale was unreachable). " \
-              "Use engine :ruby_llm, the production path."
+              "Use adapter :ruby_llm, the production path."
       end
 
       check_provider_credentials!
@@ -159,7 +174,7 @@ module Silas
     # always a misconfiguration); warns in development so a fresh app can
     # still boot and browse the inbox before a key exists.
     def check_provider_credentials!
-      return unless engine == :ruby_llm && defined?(::RubyLLM)
+      return unless adapter == :ruby_llm && defined?(::RubyLLM)
 
       providers = ::RubyLLM::Provider.providers.values
       configured = providers.any? do |provider|
@@ -168,7 +183,7 @@ module Silas
       end
       return if configured
 
-      message = "[Silas] engine :ruby_llm has no configured provider — no API key is set on " \
+      message = "[Silas] adapter :ruby_llm has no configured provider — no API key is set on " \
                 "RubyLLM.config. Set one in config/initializers/ruby_llm.rb, e.g. " \
                 "RubyLLM.configure { |c| c.anthropic_api_key = ENV[\"ANTHROPIC_API_KEY\"] } " \
                 "— the first agent turn will fail without it."

data/lib/silas/delta_buffer.rb

@@ -1,5 +1,5 @@
 module Silas
-  # Coalesces model text deltas into ~10Hz "silas.delta" notifications carrying
+  # Coalesces model text deltas into ~10Hz "delta.silas" notifications carrying
   # the ACCUMULATED text so far — subscribers replace rather than append, which
   # is idempotent under a crash-restream (same step id, fresh stream overwrites
   # itself) and ordering-safe under Turbo. Deltas are decoration over the
@@ -38,8 +38,8 @@ module Silas
 
       @published = @text.length
       @last_publish = clock
-      ActiveSupport::Notifications.instrument(
-        "silas.delta",
+      Silas.instrument(
+        :delta,
         session_id: @turn.session_id, turn_id: @turn.id,
         step_id: @step.id, step_index: @step.index, text: @text.dup
       )

data/lib/silas/deprecator.rb

@@ -0,0 +1,16 @@
+module Silas
+  # One deprecator for the whole gem, so hosts can control the noise the way
+  # they control Rails' own:
+  #
+  #   Silas.deprecator.behavior = :raise    # or :warn (default), :silence
+  #
+  # Rails registers it in application.deprecators (see Silas::Engine), which
+  # means `config.active_support.report_deprecations = false` silences Silas
+  # along with everything else, and a host can opt into raising in CI.
+  #
+  # Every deprecation message names BOTH the replacement and the version it
+  # disappears in — a warning you can't act on is just noise.
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("2.0", "Silas")
+  end
+end

data/lib/silas/engine.rb

@@ -1,6 +1,6 @@
 module Silas
   # The Rails engine (not to be confused with inference adapters under
-  # Silas::Engines::*). Full engine: Silas is Rails-native by thesis.
+  # Silas::Adapters::*). Full engine: Silas is Rails-native by thesis.
   class Engine < ::Rails::Engine
     isolate_namespace Silas
 
@@ -33,16 +33,40 @@ module Silas
       end
     end
 
+    # Register with Rails so hosts control Silas's deprecations exactly as they
+    # control everyone else's: config.active_support.report_deprecations,
+    # or `config.silas.deprecator.behavior = :raise` in CI.
+    initializer "silas.deprecator" do |app|
+      app.deprecators[:silas] = Silas.deprecator if app.respond_to?(:deprecators)
+    end
+
     initializer "silas.boot_guard", after: :load_config_initializers do
       Silas.config.boot_guard!
     end
 
+    # Turn the loop's notifications into log lines. Attaching here (rather than
+    # at require time) means a host that never boots Rails pays nothing.
+    initializer "silas.log_subscriber" do
+      Silas::LogSubscriber.attach_to :silas if defined?(Silas::LogSubscriber)
+    end
+
     # Live token streaming into the inbox trace: one process-wide subscriber on
-    # "silas.delta"; a no-op unless turbo-rails is present and streaming is on.
+    # "delta.silas"; a no-op unless turbo-rails is present and streaming is on.
     initializer "silas.delta_broadcaster" do
       Silas::Inbox::DeltaBroadcaster.subscribe!
     end
 
+    # The trace partials render in TWO contexts: the inbox controllers (which
+    # declare this helper) and Turbo's broadcast jobs, which render through the
+    # HOST's default renderer — where an engine-scoped helper doesn't exist and
+    # every broadcast died silently inside Turbo's job. Register it host-wide
+    # so broadcast renders — and host apps embedding the trace partials in
+    # their own pages — resolve it. (Routes inside those partials go through
+    # TraceHelper#silas_engine_path, which needs no routing scope at all.)
+    initializer "silas.trace_helper" do
+      ActiveSupport.on_load(:action_controller_base) { helper Silas::Inbox::TraceHelper }
+    end
+
     # Registry rebuilds on every code reload in development, once in production.
     initializer "silas.registry" do |app|
       next unless app.root.join("app/agent").exist? || app.root.join("app/agents").exist?

data/lib/silas/eval/driver.rb

@@ -34,7 +34,7 @@ module Silas
         engine = scenario.real? ? nil : ScriptedEngine.new(scenario.steps)
         base_resolver = Silas.config.tool_resolver
         Silas.configure do |c|
-          c.engine = engine if engine
+          c.adapter = engine if engine
           c.isolate_steps = false
           c.max_steps = scenario.max_steps if scenario.max_steps
           if scenario.stubs.any?

data/lib/silas/eval/dsl.rb

@@ -22,7 +22,7 @@ module Silas
       # on_step(0, text:, call: {name:, arguments:}, calls: [ {…}, … ])
       def on_step(index, text: nil, call: nil, calls: [])
         tcs = (calls + [ call ].compact).each_with_index.map do |c, n|
-          Silas::Engines::ToolCall.new(id: "eval_s#{index}_#{n}", name: c[:name].to_s,
+          Silas::Adapters::ToolCall.new(id: "eval_s#{index}_#{n}", name: c[:name].to_s,
                                        arguments: (c[:arguments] || {}).stringify_keys)
         end
         blocks = []

data/lib/silas/eval/scripted_engine.rb

@@ -3,7 +3,7 @@ module Silas
     # The productized FakeEngine: a pure function of context[:index] that lets an
     # eval script the MODEL's decisions while the REAL Ledger runs the REAL tools —
     # so assertions see a genuine transcript.
-    class ScriptedEngine < Silas::Engines::Base
+    class ScriptedEngine < Silas::Adapters::Base
       attr_reader :calls
 
       def initialize(steps)
@@ -17,7 +17,7 @@ module Silas
         spec = @steps[i]
         return terminal("OK.") unless spec
 
-        Silas::Engines::Result.new(
+        Silas::Adapters::Result.new(
           blocks: spec[:blocks],
           tool_calls: spec[:tool_calls],
           stop_reason: spec[:tool_calls].empty? ? "end_turn" : "tool_use",
@@ -28,7 +28,7 @@ module Silas
       private
 
       def terminal(text)
-        Silas::Engines::Result.new(blocks: [ { "type" => "text", "text" => text } ],
+        Silas::Adapters::Result.new(blocks: [ { "type" => "text", "text" => text } ],
                                    tool_calls: [], stop_reason: "end_turn",
                                    usage: { input_tokens: 1, output_tokens: 1 })
       end

data/lib/silas/inbox/delta_broadcaster.rb

@@ -12,7 +12,7 @@ module Silas
     # the whole step partial (dom_id target) and supersedes anything streamed
     # into the inner text container.
     module DeltaBroadcaster
-      EVENT = "silas.delta".freeze
+      EVENT = "delta.silas".freeze
 
       class << self
         def subscribe!

data/lib/silas/inbox.rb

@@ -19,5 +19,20 @@ module Silas
     def stream_name(session_id)
       "silas:inbox:session:#{session_id}"
     end
+
+    # Where the host mounted the engine ("/silas" by the installer's
+    # convention), discovered from the app's route set. Used to build paths
+    # that work in EVERY render context — including Turbo's bare broadcast
+    # renderer, which has no routing scope for the mounted proxy to lean on.
+    def mount_path
+      @mount_path ||= begin
+        route = Rails.application.routes.routes.find do |r|
+          r.app.respond_to?(:app) && r.app.app == Silas::Engine
+        end
+        route&.path&.spec.to_s.sub(/\(.*\z/, "").presence || "/silas"
+      end
+    end
+
+    def reset_mount_path! = (@mount_path = nil) # specs remount
   end
 end

data/lib/silas/instrumentation.rb

@@ -0,0 +1,55 @@
+module Silas
+  # ActiveSupport::Notifications for the durable loop.
+  #
+  # Until now the loop was silent: a turn could start, park for a human, get
+  # rescued after a kill -9, breach a budget, and finish — without emitting a
+  # single line. This is the seam for logs, APM spans, and metrics.
+  #
+  # Names follow the Rails convention `<event>.silas` (like `sql.active_record`),
+  # so `ActiveSupport::Notifications.subscribe(/\.silas\z/)` gets everything.
+  #
+  #   ActiveSupport::Notifications.subscribe("tool.silas") do |event|
+  #     StatsD.timing("agent.tool", event.duration, tags: ["tool:#{event.payload[:tool]}"])
+  #   end
+  #
+  # ## Events and payloads
+  #
+  # Every payload carries `turn_id` and `session_id` where they exist, so any
+  # subscriber can correlate without joining.
+  #
+  #   turn.silas       status:, reason:, steps:, session_id:, turn_id:, agent:
+  #                    Duration = the whole turn INCLUDING parked time.
+  #   step.silas       index:, model:, turn_id:  (one model call)
+  #   tool.silas       tool:, effect_mode:, status:, approval_state:,
+  #                    invocation_id:, turn_id:
+  #                    Duration = the tool's own execution. The single most
+  #                    useful span in the system.
+  #   delta.silas      session_id:, turn_id:, step_id:, step_index:, text:
+  #                    Streamed text so far (see DeltaBuffer). High frequency.
+  #   park.silas       reason: (approval | in_doubt | budget), turn_id:, detail:
+  #   resume.silas     turn_id:, parked_for: (seconds a human took)
+  #   approval.silas   action: (approved | declined | expired), tool:, by:,
+  #                    invocation_id:, turn_id:
+  #   budget.silas     reason: (max_cost | max_input_tokens | timeout), turn_id:
+  #   rescue.silas     rescued: (jobs retried), stranded: (turns failed)
+  #   nondeterminism.silas  turn_id:, was:, now:  (digest changed mid-turn)
+  module Instrumentation
+    module_function
+
+    def instrument(event, **payload, &block)
+      ActiveSupport::Notifications.instrument("#{event}.silas", **payload, &block)
+    end
+  end
+
+  # Silas.instrument(:tool, tool: "issue_refund") { ... }
+  def self.instrument(event, **payload, &block)
+    Instrumentation.instrument(event, **payload, &block)
+  end
+
+  # The logger Silas writes through; hosts can point it elsewhere.
+  mattr_accessor :logger, default: nil
+
+  def self.logger
+    @@logger ||= (defined?(Rails) && Rails.logger) || ActiveSupport::Logger.new($stdout)
+  end
+end

data/lib/silas/ledger.rb

@@ -88,6 +88,8 @@ module Silas
           when :user_approval
             invocation.update!(approval_state: "required",
                                approval_expires_at: Silas.config.approval_ttl.from_now)
+            Silas.instrument(:park, reason: "approval", turn_id: invocation.turn_id,
+                                    detail: invocation.tool_name)
             return :parked
           when Hash # {denied: "reason"} — eve's shape
             invocation.update!(status: "failed", result: { "denied" => verdict[:denied] })
@@ -107,6 +109,16 @@ module Silas
       end
 
       def execute!(invocation, tool)
+        Silas.instrument(:tool, tool: invocation.tool_name, effect_mode: invocation.effect_mode,
+                                invocation_id: invocation.id, turn_id: invocation.turn_id) do |payload|
+          run_tool!(invocation, tool).tap do
+            payload[:status] = invocation.reload.status
+            payload[:approval_state] = invocation.approval_state
+          end
+        end
+      end
+
+      def run_tool!(invocation, tool)
         tool.session = invocation.turn.session if tool.respond_to?(:session=)
         args = invocation.arguments.symbolize_keys
 
@@ -149,6 +161,8 @@ module Silas
           # decline! = "it ran / abandon", operator supplies the outcome.
           invocation.update!(status: "in_doubt", approval_state: "required",
                              approval_expires_at: Silas.config.approval_ttl.from_now)
+          Silas.instrument(:park, reason: "in_doubt", turn_id: invocation.turn_id,
+                                  detail: invocation.tool_name)
           :parked
         end
       end

data/lib/silas/log_subscriber.rb

@@ -0,0 +1,78 @@
+require "active_support/log_subscriber"
+
+# Turns the loop's notifications into log lines, at levels that match what an
+# operator actually wants paged about: parks and rescues are INFO (a human is
+# now in the loop, or a crash was recovered), budget breaches and
+# nondeterminism are WARN, failed turns are ERROR, and the per-step/per-token
+# chatter stays DEBUG.
+#
+# Attach is automatic (see Silas::Engine). To silence just Silas:
+#   Silas.logger = Logger.new(IO::NULL)
+class Silas::LogSubscriber < ActiveSupport::LogSubscriber
+  def turn(event)
+    status = event.payload[:status]
+    line = formatted_event(event, action: "Turn #{status}",
+                           **event.payload.slice(:turn_id, :session_id, :agent, :steps, :reason).compact)
+    status.to_s == "failed" ? error(line) : info(line)
+  end
+
+  def step(event)
+    debug formatted_event(event, action: "Model call",
+                          **event.payload.slice(:turn_id, :index, :model).compact)
+  end
+
+  def tool(event)
+    line = formatted_event(event, action: "Tool #{event.payload[:tool]}",
+                           **event.payload.slice(:effect_mode, :status, :approval_state, :turn_id).compact)
+    event.payload[:status].to_s == "failed" ? warn(line) : info(line)
+  end
+
+  def park(event)
+    info formatted_event(event, action: "Turn parked (#{event.payload[:reason]})",
+                         **event.payload.slice(:turn_id, :detail).compact)
+  end
+
+  def resume(event)
+    parked_for = event.payload[:parked_for]
+    info formatted_event(event, action: "Turn resumed after #{parked_for&.round(1)}s parked",
+                         **event.payload.slice(:turn_id).compact)
+  end
+
+  def approval(event)
+    info formatted_event(event, action: "Approval #{event.payload[:action]}",
+                         **event.payload.slice(:tool, :by, :turn_id).compact)
+  end
+
+  def budget(event)
+    warn formatted_event(event, action: "Budget reached (#{event.payload[:reason]})",
+                         **event.payload.slice(:turn_id).compact)
+  end
+
+  def nondeterminism(event)
+    error formatted_event(event, action: "Definitions changed mid-turn",
+                          **event.payload.slice(:turn_id, :was, :now).compact)
+  end
+
+  def rescue(event)
+    payload = event.payload
+    return if payload[:rescued].to_i.zero? && payload[:stranded].to_i.zero?
+
+    info formatted_event(event, action: "Rescuer", **payload.slice(:rescued, :stranded))
+  end
+
+  # delta.silas is deliberately NOT logged — it fires many times per second
+  # per running turn. Subscribe to it directly if you want the firehose.
+
+  private
+    def formatted_event(event, action:, **attributes)
+      "Silas-#{Silas::VERSION} #{action} (#{event.duration.round(1)}ms)  #{formatted_attributes(**attributes)}"
+    end
+
+    def formatted_attributes(**attributes)
+      attributes.map { |attr, value| "#{attr}: #{value.inspect}" }.join(", ")
+    end
+
+    def logger
+      Silas.logger
+    end
+end

data/lib/silas/slack.rb

@@ -43,7 +43,7 @@ module Silas
 
     # Slack signs each request (v0 scheme) — HMAC-SHA256 over "v0:ts:body" plus a
     # 5-minute replay window. Returns true only for a genuine, fresh request.
-    def verify_signature(signing_secret:, timestamp:, body:, signature:, now: Time.now.to_i)
+    def verify_signature(signing_secret:, timestamp:, body:, signature:, now: Time.current.to_i)
       return false if signing_secret.blank? || signature.blank? || timestamp.blank?
       return false if (now - timestamp.to_i).abs > REPLAY_WINDOW
 

data/lib/silas/step_runner.rb

@@ -51,7 +51,7 @@ module Silas
 
     def execute_model_call(turn, index, step)
       assert_definitions_unchanged!(turn)
-      engine = Silas.resolved_engine
+      engine = Silas.resolved_adapter
       context = {
         turn: turn,
         index: index,
@@ -64,7 +64,7 @@ module Silas
       }
 
       # Live deltas: the engine yields Events, the buffer coalesces them into
-      # "silas.delta" notifications. A replayed step never reaches this method
+      # "delta.silas" notifications. A replayed step never reaches this method
       # (the completed? guard above), so replay emits nothing. The emitter is
       # created HERE and closed over by the inner block, so around_model_call
       # hooks keep their existing one-argument contract and can't swallow it.
@@ -93,6 +93,9 @@ module Silas
       return if live == turn.definitions_digest
 
       turn.finish!(:failed, reason: "definitions_changed")
+      Silas.instrument(:nondeterminism, turn_id: turn.id,
+                                        was: turn.definitions_digest.to_s[0, 12],
+                                        now: live[0, 12])
       raise NondeterminismError,
             "Tool/skill definitions changed mid-turn (digest #{turn.definitions_digest[0, 12]}… → " \
             "#{live[0, 12]}…). The turn was failed rather than resumed against a different agent."

data/lib/silas/version.rb

@@ -1,3 +1,3 @@
 module Silas
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/silas.rb

@@ -4,6 +4,8 @@ require "active_job/railtie" if defined?(::Rails::Railtie)
 require "active_record/railtie" if defined?(::Rails::Railtie)
 
 require "silas/version"
+require "silas/deprecator"
+require "silas/instrumentation"
 require "silas/errors"
 require "silas/configuration"
 require "silas/ledger"
@@ -35,15 +37,16 @@ require "silas/tools/recall"
 require "silas/tools/handoff"
 require "silas/mcp/handler"
 require "silas/mcp/server"
-require "silas/engines/base"
+require "silas/adapters/base"
 require "ruby_llm"
-require "silas/engines/ruby_llm"
+require "silas/adapters/ruby_llm"
 require "silas/message_builder"
 require "silas/instructions"
 require "silas/step_runner"
-require "silas/eval" # after engines (ScriptedEngine < Engines::Base)
+require "silas/eval" # after adapters (ScriptedEngine < Adapters::Base)
 require "silas/chat"
 require "silas/doctor"
+require "silas/log_subscriber" if defined?(::ActiveSupport::LogSubscriber)
 
 module Silas
   class << self
@@ -60,14 +63,14 @@ module Silas
     def configure
       yield config
       config.validate!
-      @resolved_engine = nil
+      @resolved_adapter = nil
       @resolved_sandbox = nil
       config
     end
 
     def reset_configuration! # for specs
       @config = nil
-      @resolved_engine = nil
+      @resolved_adapter = nil
       @resolved_sandbox = nil
       @agent = nil
     end
@@ -103,21 +106,29 @@ module Silas
 
     def reset_agent_memo! = (@agent = nil) # after Registry.install! swaps dirs
 
-    # The inference adapter instance. config.engine may be :ruby_llm or any
+    # The inference adapter instance. config.adapter may be :ruby_llm or any
     # object responding to #execute_step (specs, custom).
-    def resolved_engine
-      @resolved_engine ||=
-        case config.engine
-        when :ruby_llm then Engines::RubyLLM.new
+    def resolved_adapter
+      @resolved_adapter ||=
+        case config.adapter
+        when :ruby_llm then Adapters::RubyLLM.new
         when :agent_sdk
-          raise Error, "the :agent_sdk engine was removed in Silas 0.2 — the claude -p " \
+          raise Error, "the :agent_sdk adapter was removed in Silas 0.2 — the claude -p " \
                        "subprocess integration is gone (its subscription-auth rationale was " \
-                       "unreachable). Use engine :ruby_llm, the production path."
-        when Symbol then raise Error, "unknown engine #{config.engine.inspect}"
-        else config.engine
+                       "unreachable). Use adapter :ruby_llm, the production path."
+        when Symbol then raise Error, "unknown adapter #{config.adapter.inspect}"
+        else config.adapter
         end
     end
 
+    # Renamed in 0.4: "engine" meant two unrelated things (the Rails engine at
+    # Silas::Engine, and the inference backend), which is exactly the collision
+    # ActiveJob avoids with QueueAdapters. Removed in 2.0.
+    def resolved_engine
+      Silas.deprecator.warn("Silas.resolved_engine is deprecated; use Silas.resolved_adapter")
+      resolved_adapter
+    end
+
     # ---- scope-aware readers -------------------------------------------------
     # Every reader consults the active AgentScope first (named agent or
     # subagent), falling back to the boot-time config the Registry installed.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silas
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel St Paul
@@ -151,6 +151,7 @@ files:
 - app/views/silas/inbox/steps/_step.html.erb
 - app/views/silas/inbox/turns/_header.html.erb
 - app/views/silas/inbox/turns/_turn.html.erb
+- config/brakeman.ignore
 - config/routes.rb
 - db/migrate/20260714000001_create_silas_tables.rb
 - db/migrate/20260715000001_add_channel_outbound_markers.rb
@@ -174,6 +175,8 @@ files:
 - lib/generators/silas/install/templates/instructions.md
 - lib/generators/silas/install/templates/ruby_llm.rb
 - lib/silas.rb
+- lib/silas/adapters/base.rb
+- lib/silas/adapters/ruby_llm.rb
 - lib/silas/agent.rb
 - lib/silas/agent_scope.rb
 - lib/silas/budget.rb
@@ -183,10 +186,9 @@ files:
 - lib/silas/connection.rb
 - lib/silas/connections.rb
 - lib/silas/delta_buffer.rb
+- lib/silas/deprecator.rb
 - lib/silas/doctor.rb
 - lib/silas/engine.rb
-- lib/silas/engines/base.rb
-- lib/silas/engines/ruby_llm.rb
 - lib/silas/errors.rb
 - lib/silas/eval.rb
 - lib/silas/eval/assertions.rb
@@ -201,7 +203,9 @@ files:
 - lib/silas/inbox/cost.rb
 - lib/silas/inbox/delta_broadcaster.rb
 - lib/silas/instructions.rb
+- lib/silas/instrumentation.rb
 - lib/silas/ledger.rb
+- lib/silas/log_subscriber.rb
 - lib/silas/mcp/client.rb
 - lib/silas/mcp/handler.rb
 - lib/silas/mcp/server.rb