silas 0.1.1

data/app/jobs/silas/schedule_job.rb

@@ -0,0 +1,22 @@
+module Silas
+  # The recurring entry Solid Queue fires enqueues this thin job, which resolves
+  # the schedule by name and triggers it. A tick is fire-and-forget: it never
+  # retry-loops (a failed tick shouldn't pile up), and the turn it starts is
+  # itself fully durable from :prepare onward.
+  class ScheduleJob < ActiveJob::Base
+    queue_as { Silas.config.queue_name }
+
+    discard_on(StandardError) do |job, error|
+      Rails.logger&.error("silas: schedule #{job.arguments.first} failed: #{error.class}: #{error.message}")
+    end
+
+    def perform(schedule_name)
+      schedule = Silas.schedules.find { |s| s.name == schedule_name }
+      unless schedule
+        Rails.logger&.warn("silas: no schedule #{schedule_name.inspect} (stale recurring entry? run `bin/rails silas:schedules`)")
+        return
+      end
+      schedule.trigger!
+    end
+  end
+end

data/app/mailboxes/silas/agent_mailbox.rb

@@ -0,0 +1,35 @@
+module Silas
+  # Action Mailbox reference inbound: maps an email thread to a Silas session.
+  # A new thread starts a session; a reply (same References/In-Reply-To root)
+  # continues it. Route inbound mail here from the host's ApplicationMailbox:
+  #   routing all: "Silas::AgentMailbox"
+  # Requires app/agent/channels/email.rb (Agent::Channels::Email) to exist.
+  class AgentMailbox < ActionMailbox::Base
+    def process
+      channel_class.dispatch(
+        thread_key: self.class.thread_key(mail),
+        input: body_text,
+        metadata: { "email" => { "from" => mail.from&.first, "subject" => mail.subject } }
+      )
+    rescue Silas::TurnInProgressError
+      # A reply arriving while a turn is active is dropped (v1 single-active-turn).
+    end
+
+    # The thread root: References head, else In-Reply-To, else this Message-ID.
+    def self.thread_key(mail)
+      (Array(mail.references).first || mail.in_reply_to || mail.message_id).to_s
+    end
+
+    private
+
+    def channel_class
+      Silas.config.channel_resolver&.call("email") or
+        raise Silas::Error, "no app/agent/channels/email.rb (Agent::Channels::Email) defined"
+    end
+
+    def body_text
+      part = mail.multipart? ? (mail.text_part || mail.parts.first) : mail
+      part&.decoded.to_s.strip
+    end
+  end
+end

data/app/mailers/silas/channel_mailer.rb

@@ -0,0 +1,17 @@
+module Silas
+  # Outbound email for the email channel: the agent's answer, and an approval
+  # request rendering two signed one-click links.
+  class ChannelMailer < ActionMailer::Base
+    def answer(to:, subject:, text:)
+      @text = text
+      mail(to: to, subject: subject) { |f| f.text { render plain: text } }
+    end
+
+    def approval(to:, subject:, invocation:)
+      @invocation = invocation
+      @approve_token = Silas::Channel.token_for(invocation, "approve")
+      @decline_token = Silas::Channel.token_for(invocation, "decline")
+      mail(to: to, subject: subject)
+    end
+  end
+end

data/app/models/concerns/silas/inbox/broadcastable.rb

@@ -0,0 +1,86 @@
+module Silas
+  module Inbox
+    # Live trace: after_commit callbacks broadcast the changed row (rendered as
+    # a partial) to the session's Turbo stream. Mirrors ChannelDeliveryJob's
+    # after_commit -> off-loop decouple: the `_later` broadcasts render in
+    # Turbo's own job, never on the durable loop, and every broadcast is wrapped
+    # so a cable/render failure can NEVER roll back or slow a turn.
+    #
+    # Included in Turn/Step/ToolInvocation always; every callback early-returns
+    # unless streaming is actually live, so headless hosts pay nothing.
+    module Broadcastable
+      extend ActiveSupport::Concern
+
+      included do
+        after_create_commit :silas_inbox_broadcast_create
+        after_update_commit :silas_inbox_broadcast_update
+      end
+
+      private
+
+      def silas_inbox_broadcast_create
+        return unless Silas::Inbox.streaming?
+
+        safe_broadcast do
+          case self
+          when Silas::Turn
+            silas_inbox_dispatch(:append, session_id, target: "silas-turns",
+                                 partial: "silas/inbox/turns/turn", locals: { turn: self })
+          when Silas::Step
+            silas_inbox_dispatch(:append, turn.session_id, target: "silas-turn-#{turn_id}-steps",
+                                 partial: "silas/inbox/steps/step", locals: { step: self })
+          when Silas::ToolInvocation
+            silas_inbox_dispatch(:append, turn.session_id, target: "silas-step-#{step_id}-tools",
+                                 partial: "silas/inbox/invocations/invocation", locals: { invocation: self })
+          end
+        end
+      end
+
+      def silas_inbox_broadcast_update
+        return unless Silas::Inbox.streaming?
+
+        safe_broadcast do
+          case self
+          when Silas::Turn
+            next unless saved_change_to_status?
+
+            silas_inbox_dispatch(:replace, session_id, target: "silas-turn-#{id}-header",
+                                 partial: "silas/inbox/turns/header", locals: { turn: self })
+          when Silas::Step
+            next unless saved_change_to_status?
+
+            silas_inbox_dispatch(:replace, turn.session_id, target: ActionView::RecordIdentifier.dom_id(self),
+                                 partial: "silas/inbox/steps/step", locals: { step: self })
+            silas_inbox_refresh_cost(turn.session)
+          when Silas::ToolInvocation
+            next unless saved_change_to_approval_state? || saved_change_to_status?
+
+            silas_inbox_dispatch(:replace, turn.session_id, target: ActionView::RecordIdentifier.dom_id(self),
+                                 partial: "silas/inbox/invocations/invocation", locals: { invocation: self })
+          end
+        end
+      end
+
+      def silas_inbox_refresh_cost(session)
+        silas_inbox_dispatch(:replace, session.id, target: "silas-session-#{session.id}-cost",
+                             partial: "silas/inbox/sessions/cost", locals: { session: session })
+      end
+
+      # The single seam over turbo-rails, so the dispatch logic above is
+      # testable without loading turbo (stub this method).
+      def silas_inbox_dispatch(action, session_id, target:, partial:, locals:)
+        stream = Silas::Inbox.stream_name(session_id)
+        case action
+        when :append  then broadcast_append_later_to(stream, target: target, partial: partial, locals: locals)
+        when :replace then broadcast_replace_later_to(stream, target: target, partial: partial, locals: locals)
+        end
+      end
+
+      def safe_broadcast
+        yield
+      rescue StandardError => e
+        Rails.logger&.warn("[silas.inbox] broadcast failed: #{e.class}: #{e.message}") # never re-raise into the loop
+      end
+    end
+  end
+end

data/app/models/silas/application_record.rb

@@ -0,0 +1,5 @@
+module Silas
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/silas/session.rb

@@ -0,0 +1,36 @@
+module Silas
+  class Session < ApplicationRecord
+    STATUSES = %w[active archived].freeze
+
+    has_many :turns, -> { order(:index) }, class_name: "Silas::Turn", foreign_key: :session_id,
+             inverse_of: :session, dependent: :destroy
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :agent_name, presence: true
+
+    def active_turn
+      # Fresh relation query, never the cached association — callers mix reads
+      # with turn creation in the same objects.
+      turns.where(status: Turn::ACTIVE_STATUSES).order(:index).first
+    end
+
+    def pending_approvals
+      ToolInvocation.joins(:turn).where(silas_turns: { session_id: id }, approval_state: "required")
+    end
+
+    # Enqueue the next turn. One active turn per session — the partial unique
+    # index is the backstop; this is the friendly front door.
+    def continue(input:)
+      if active_turn
+        raise TurnInProgressError, "session #{id} already has an active turn (##{active_turn.index})"
+      end
+
+      next_index = (turns.maximum(:index) || -1) + 1
+      turn = turns.create!(index: next_index, input: input)
+      AgentLoopJob.perform_later(turn.id)
+      turn
+    rescue ActiveRecord::RecordNotUnique
+      raise TurnInProgressError, "session #{id} already has an active turn"
+    end
+  end
+end

data/app/models/silas/step.rb

@@ -0,0 +1,33 @@
+module Silas
+  class Step < ApplicationRecord
+    STATUSES = %w[started completed].freeze
+
+    include Silas::Inbox::Broadcastable
+
+    belongs_to :turn, class_name: "Silas::Turn", inverse_of: :steps
+    has_many :tool_invocations, class_name: "Silas::ToolInvocation", foreign_key: :step_id,
+             inverse_of: :step, dependent: :destroy
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :index, presence: true
+    validate :terminal_write_once, on: :update
+
+    def completed? = status == "completed"
+
+    # Any invocation awaiting a human: approval-gated or in-doubt.
+    def parked?
+      tool_invocations.any? { |i| i.approval_state == "required" || i.status == "in_doubt" }
+    end
+
+    private
+
+    # THE loop-control column (spike finding #3 generalized): a resumed
+    # continuation re-derives its step sequence from terminal, so it must be
+    # write-once. NULL -> value is the only legal transition.
+    def terminal_write_once
+      return unless terminal_changed? && !terminal_was.nil?
+
+      errors.add(:terminal, "is write-once")
+    end
+  end
+end

data/app/models/silas/tool_invocation.rb

@@ -0,0 +1,78 @@
+module Silas
+  class ToolInvocation < ApplicationRecord
+    STATUSES = %w[pending started completed failed in_doubt].freeze
+    EFFECT_MODES = %w[transactional at_most_once idempotent].freeze
+    APPROVAL_STATES = [ nil, "required", "approved", "declined", "expired" ].freeze
+
+    include Silas::Inbox::Broadcastable
+
+    belongs_to :step, class_name: "Silas::Step", inverse_of: :tool_invocations
+    belongs_to :turn, class_name: "Silas::Turn", inverse_of: :tool_invocations
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :effect_mode, inclusion: { in: EFFECT_MODES }
+    validates :approval_state, inclusion: { in: APPROVAL_STATES }
+    validates :tool_call_id, :tool_name, presence: true
+
+    def completed? = status == "completed"
+    def in_doubt?  = status == "in_doubt"
+    def awaiting_approval? = approval_state == "required"
+
+    # Outbound: when a channel-bound invocation parks for approval, ping the
+    # channel off-loop (covers both approval-gate and in-doubt parking).
+    after_update_commit :notify_channel_approval, if: :should_notify_approval?
+
+    def should_notify_approval?
+      saved_change_to_approval_state? && approval_state == "required" && turn.session.channel.present?
+    end
+
+    def notify_channel_approval
+      ChannelDeliveryJob.perform_later("approval", id)
+    end
+
+    # Approve a parked invocation and resume the turn with a FRESH job (the
+    # parked job exited normally; its continuation is consumed). For an
+    # in-doubt invocation, approval means "it did not run — re-execute".
+    def approve!(by: nil)
+      assert_parked!
+      update!(status: "pending", approval_state: "approved", approved_by: by)
+      resume_turn!
+    end
+
+    # Decline: for an approval gate, eve's shape — the tool is not executed
+    # and the model sees {denied: reason} as the result, then the loop
+    # continues. For an in-doubt invocation, decline means "assume it ran /
+    # abandon" — the operator-supplied reason becomes the recorded outcome.
+    def decline!(reason:, by: nil)
+      assert_parked!
+      update!(status: "failed", approval_state: "declined", approved_by: by,
+              decline_reason: reason, result: { "denied" => reason })
+      resume_turn!
+    end
+
+    # Sweep for the rescuer: expire parked invocations past their TTL and fail
+    # their turns (parked-forever ghosts are a bug, not a feature).
+    def self.expire_stale!(now: Time.current)
+      where(approval_state: "required").where(approval_expires_at: ..now).find_each do |inv|
+        inv.update!(approval_state: "expired", status: "failed",
+                    result: { "denied" => "approval expired" })
+        inv.turn.finish!(:failed, reason: "approval_expired")
+      end
+    end
+
+    private
+
+    def assert_parked!
+      return if awaiting_approval?
+
+      raise Error, "invocation #{id} is not awaiting approval (state: #{approval_state.inspect})"
+    end
+
+    def resume_turn!
+      return if turn.tool_invocations.where(approval_state: "required").exists?
+
+      turn.update!(status: "queued")
+      AgentLoopJob.perform_later(turn.id)
+    end
+  end
+end

data/app/models/silas/turn.rb

@@ -0,0 +1,58 @@
+module Silas
+  class Turn < ApplicationRecord
+    STATUSES = %w[queued running waiting in_doubt completed failed canceled].freeze
+    ACTIVE_STATUSES = %w[queued running waiting in_doubt].freeze
+
+    include Silas::Inbox::Broadcastable
+
+    belongs_to :session, class_name: "Silas::Session", inverse_of: :turns
+    has_many :steps, -> { order(:index) }, class_name: "Silas::Step", foreign_key: :turn_id,
+             inverse_of: :turn, dependent: :destroy
+    has_many :tool_invocations, class_name: "Silas::ToolInvocation", foreign_key: :turn_id,
+             inverse_of: :turn, dependent: :destroy
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :index, presence: true
+    validate :instructions_snapshot_immutable, on: :update
+
+    ACTIVE_STATUSES.each { |s| define_method(:"#{s}?") { status == s } }
+    def completed? = status == "completed"
+    def active?    = ACTIVE_STATUSES.include?(status)
+    def parked?    = status == "waiting" || status == "in_doubt"
+
+    def finish!(new_status, reason: nil)
+      update!(status: new_status.to_s, failure_reason: reason, finished_at: Time.current)
+    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
+      return "" unless step
+
+      Array(step.response_blocks).select { |b| b["type"] == "text" }.map { |b| b["text"] }.join
+    end
+
+    # Outbound: when a channel-bound turn reaches an answer, deliver it off-loop.
+    after_update_commit :notify_channel_answer, if: :should_notify_answer?
+
+    private
+
+    def should_notify_answer?
+      saved_change_to_status? && (completed? || status == "failed") && session.channel.present?
+    end
+
+    def notify_channel_answer
+      ChannelDeliveryJob.perform_later("answer", id)
+    end
+
+    private
+
+    # The snapshot is the determinism anchor for the whole turn: once rendered
+    # at :prepare it must never change (a resumed job re-reads it).
+    def instructions_snapshot_immutable
+      return unless instructions_snapshot_changed? && instructions_snapshot_was.present?
+
+      errors.add(:instructions_snapshot, "is immutable once set")
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title><%= content_for?(:title) ? yield(:title) : "Silas Inbox" %></title>
+  <% if Silas::Inbox.streaming_available? %><%= turbo_include_tags rescue nil %><% end %>
+  <style>
+    :root {
+      --bg: #f7f7f8; --panel: #ffffff; --ink: #16181d; --muted: #6b7280;
+      --line: #e5e7eb; --accent: #4f46e5; --amber: #b45309; --amber-bg: #fef3c7;
+      --green: #047857; --green-bg: #d1fae5; --red: #b91c1c; --red-bg: #fee2e2;
+      --blue: #1d4ed8; --blue-bg: #dbeafe; --grey-bg: #eef0f3;
+      --radius: 14px; --mono: ui-monospace, SFMono-Regular, Menlo, monospace;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --bg: #0d0f14; --panel: #161a22; --ink: #e6e8ec; --muted: #9aa2af;
+        --line: #262b36; --accent: #818cf8; --amber: #fbbf24; --amber-bg: #3a2e12;
+        --green: #34d399; --green-bg: #10291f; --red: #f87171; --red-bg: #35191a;
+        --blue: #60a5fa; --blue-bg: #14233d; --grey-bg: #1e232d;
+      }
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0; background: var(--bg); color: var(--ink);
+      font: 15px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      -webkit-font-smoothing: antialiased;
+    }
+    .wrap { max-width: 640px; margin: 0 auto; padding: 20px 16px 64px; }
+    header.top { display: flex; align-items: center; gap: 10px; margin-bottom: 18px; }
+    header.top .logo { font-weight: 700; letter-spacing: -0.02em; font-size: 20px; }
+    header.top .logo a { color: var(--ink); text-decoration: none; }
+    header.top .spacer { flex: 1; }
+    .badge { background: var(--amber-bg); color: var(--amber); font-weight: 600;
+      font-size: 12px; padding: 3px 9px; border-radius: 999px; }
+    a { color: var(--accent); }
+    .card { background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius);
+      padding: 14px 16px; margin-bottom: 12px; }
+    .session-row { display: block; text-decoration: none; color: inherit; }
+    .session-row:hover { border-color: var(--accent); }
+    .row-top { display: flex; align-items: center; gap: 8px; margin-bottom: 4px; }
+    .row-top .name { font-weight: 600; }
+    .muted { color: var(--muted); font-size: 13px; }
+    .pill { display: inline-block; font-size: 11px; font-weight: 600; text-transform: uppercase;
+      letter-spacing: 0.03em; padding: 2px 8px; border-radius: 999px; }
+    .pill-grey { background: var(--grey-bg); color: var(--muted); }
+    .pill-blue { background: var(--blue-bg); color: var(--blue); }
+    .pill-amber { background: var(--amber-bg); color: var(--amber); }
+    .pill-green { background: var(--green-bg); color: var(--green); }
+    .pill-red { background: var(--red-bg); color: var(--red); }
+    .pill-pulse { animation: pulse 1.4s ease-in-out infinite; }
+    @keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.5; } }
+    .turn { border-left: 2px solid var(--line); padding-left: 14px; margin: 16px 0; }
+    .turn-head { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; }
+    .turn-input { font-weight: 600; }
+    .step { position: relative; margin: 10px 0; padding-left: 14px; }
+    .step::before { content: ""; position: absolute; left: -5px; top: 6px; width: 8px; height: 8px;
+      border-radius: 50%; background: var(--accent); }
+    .step-text { margin: 2px 0; }
+    .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;
+      padding: 8px 10px; overflow-x: auto; margin: 6px 0; }
+    .approval { border: 1.5px solid var(--amber); background: var(--amber-bg); border-radius: 12px;
+      padding: 12px 14px; margin: 10px 0; }
+    .approval h3 { margin: 0 0 8px; font-size: 14px; color: var(--amber); }
+    .btn { display: inline-block; border: 0; border-radius: 10px; padding: 11px 18px; min-height: 44px;
+      font-size: 15px; font-weight: 600; cursor: pointer; }
+    .btn.approve { background: var(--green); color: #fff; }
+    .btn.decline { background: var(--panel); color: var(--red); border: 1px solid var(--red); }
+    .decline-form textarea { width: 100%; border: 1px solid var(--line); border-radius: 8px;
+      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); }
+    .flash { background: var(--red-bg); color: var(--red); padding: 10px 12px; border-radius: 10px; margin-bottom: 12px; }
+    .empty { text-align: center; color: var(--muted); padding: 48px 0; }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <header class="top">
+      <span class="logo"><%= link_to "Silas", inbox_sessions_path %></span>
+      <span class="spacer"></span>
+      <% if content_for?(:header_extra) %><%= yield :header_extra %><% end %>
+    </header>
+    <% if flash[:alert] %><div class="flash"><%= flash[:alert] %></div><% end %>
+    <%= yield %>
+  </div>
+</body>
+</html>

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

@@ -0,0 +1,9 @@
+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) %>
+
+These links expire; do not forward them.

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

@@ -0,0 +1,2 @@
+<h1><%= @action == "approve" ? "Approved" : "Declined" %>.</h1>
+<p>You can close this window.</p>

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

@@ -0,0 +1,2 @@
+<h1>This link is invalid or has expired.</h1>
+<% if @message %><p><%= @message %></p><% end %>

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

@@ -0,0 +1,9 @@
+<% 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 %>
+    <button type="submit">Confirm <%= @action %></button>
+  <% end %>
+<% else %>
+  <h1>This approval is no longer pending.</h1>
+<% end %>

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

@@ -0,0 +1,11 @@
+<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 %>
+    <button class="btn approve">Approve</button>
+  <% end %>
+  <%= form_with url: 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 %>
+</div>

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

@@ -0,0 +1,11 @@
+<div class="tool" id="<%= dom_id(invocation) %>">
+  <div>
+    <code><%= invocation.tool_name %></code>
+    <%= status_pill(invocation.awaiting_approval? ? "required" : invocation.status) %>
+  </div>
+  <% if invocation.awaiting_approval? %>
+    <%= render "silas/inbox/invocations/approval_card", invocation: invocation %>
+  <% elsif invocation.result.present? %>
+    <pre><%= pretty_args(invocation.result) %></pre>
+  <% end %>
+</div>

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

@@ -0,0 +1 @@
+<span class="cost"><%= cost_label(Silas::Inbox::Cost.for_session(session)) %></span>

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

@@ -0,0 +1,23 @@
+<% content_for :header_extra do %>
+  <% if @pending_total.positive? %><span class="badge"><%= @pending_total %> awaiting approval</span><% end %>
+<% end %>
+
+<% if @sessions.empty? %>
+  <div class="empty">No agent sessions yet.</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 %>
+        <% if pending.positive? %><span class="badge"><%= pending %> to approve</span><% end %>
+      </div>
+      <div class="muted">
+        <%= pluralize(session.turns.count, "turn") %> ·
+        <%= session.channel.presence || "direct" %> ·
+        <%= relative_time(session.updated_at) %>
+      </div>
+    <% end %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,20 @@
+<% content_for :title, "#{@session.agent_name} · Silas Inbox" %>
+
+<% if Silas::Inbox.streaming? %>
+  <%= turbo_stream_from Silas::Inbox.stream_name(@session.id) %>
+<% else %>
+  <meta http-equiv="refresh" content="4">
+<% end %>
+
+<div class="card">
+  <div class="row-top">
+    <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 id="silas-session-<%= @session.id %>-cost"><%= render "silas/inbox/sessions/cost", session: @session %></div>
+</div>
+
+<div id="silas-turns">
+  <%= render partial: "silas/inbox/turns/turn", collection: @turns, as: :turn %>
+</div>

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

@@ -0,0 +1,8 @@
+<div class="step" id="<%= dom_id(step) %>">
+  <% if (text = step_text(step)) %>
+    <div class="step-text"><%= simple_format(text) %></div>
+  <% end %>
+  <div id="silas-step-<%= step.id %>-tools">
+    <%= render partial: "silas/inbox/invocations/invocation", collection: step.tool_invocations, as: :invocation %>
+  </div>
+</div>

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

@@ -0,0 +1,7 @@
+<div class="turn-head">
+  <span class="turn-input"><%= truncate(turn.input, length: 90) %></span>
+  <%= status_pill(turn.status) %>
+</div>
+<% if turn.failure_reason.present? %>
+  <div class="muted">failed: <%= turn.failure_reason %></div>
+<% end %>

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

@@ -0,0 +1,8 @@
+<div class="turn" id="<%= dom_id(turn) %>">
+  <div id="silas-turn-<%= turn.id %>-header">
+    <%= render "silas/inbox/turns/header", turn: turn %>
+  </div>
+  <div id="silas-turn-<%= turn.id %>-steps">
+    <%= render partial: "silas/inbox/steps/step", collection: turn.steps, as: :step %>
+  </div>
+</div>

data/config/routes.rb

@@ -0,0 +1,19 @@
+Silas::Engine.routes.draw do
+  namespace :channels do
+    post "slack/events", to: "slack#events"
+    post "slack/actions", to: "slack#actions"
+    get "approvals/:token", to: "approvals#show", as: :approval
+    post "approvals/:token", to: "approvals#update"
+  end
+
+  namespace :inbox do
+    root to: "sessions#index"
+    resources :sessions, only: %i[index show]
+    resources :invocations, only: [] do
+      member do
+        post :approve
+        post :decline
+      end
+    end
+  end
+end