xeno 0.0.1

data/app/models/xeno/turn.rb

@@ -0,0 +1,125 @@
+module Xeno
+  # One user message and all work until the agent responds. Runs as one
+  # ActiveJob. Correctness lives here, in the database, not in the queue:
+  #
+  # 1. Atomic claim (CAS on claim_token) — one worker owns the turn.
+  # 2. Heartbeat — the owner touches heartbeat_at at step boundaries; a
+  #    stale heartbeat lets the next attempt reclaim (checkpoint replay
+  #    makes takeover safe).
+  # 3. Fencing token — every write is conditioned on claim_token = mine, so
+  #    a zombie that wakes up after being reaped affects zero rows.
+  # 4. Max attempts — poison turns become turn.failed, not infinite retries.
+  class Turn < ApplicationRecord
+    STATUSES = %w[pending running waiting completed failed cancelled].freeze
+    KINDS = %w[message compaction].freeze
+
+    belongs_to :session, class_name: "Xeno::Session"
+    has_many :actions, class_name: "Xeno::Action", dependent: :destroy
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :kind, inclusion: { in: KINDS }
+
+    # Appends the next turn to the session, sequence assigned race-safely.
+    # The INSERT runs in its own savepoint (requires_new): stage_turn! calls
+    # this inside a transaction, and on Postgres a failed INSERT otherwise
+    # aborts the whole transaction — the retry would raise
+    # PG::InFailedSqlTransaction instead of recovering.
+    def self.append!(session, user_message:, transcript_deferred: false, kind: "message")
+      attempts = 0
+      begin
+        sequence = (where(session_id: session.id).maximum(:sequence) || 0) + 1
+        transaction(requires_new: true) do
+          create!(session: session, sequence: sequence, user_message: user_message,
+                  transcript_deferred: transcript_deferred, kind: kind)
+        end
+      rescue ActiveRecord::RecordNotUnique
+        attempts += 1
+        retry if attempts < 5
+        raise
+      end
+    end
+
+    def enqueue!
+      TurnJob.perform_later(id)
+    end
+
+    # The atomic claim. Returns the fencing token on success, nil when
+    # another worker owns the turn (exit quietly) or it isn't claimable.
+    # Claimable: pending, or running with a stale heartbeat (dead owner).
+    # Poison turns are failed here instead of retrying forever.
+    #
+    # `attempts` counts FAILURES, not claims: a stale-running reclaim is
+    # crash evidence and counts here; a transient error counts in
+    # release_for_retry!; an approval/question resume counts in `resumes`
+    # and never against the poison ladder (H2).
+    def claim!
+      current = self.class.find(id)
+
+      if current.attempts >= Xeno.config.max_turn_attempts
+        poisoned = self.class.where(id: id, claim_token: current.claim_token)
+                       .where.not(status: %w[completed failed cancelled])
+                       .update_all(status: "failed", error: { "message" => "max attempts (#{current.attempts}) exhausted" })
+        if poisoned == 1
+          # A poisoned TURN leaves the SESSION running (idle, can take the
+          # next message); settle any dangling tool calls so it stays usable.
+          session.settle_unanswered_tool_calls!(self, reason: "turn failed (max attempts exhausted)")
+          session.emit("turn.failed", { turn_id: id, error: "max attempts exhausted" })
+        end
+        return nil
+      end
+
+      stale_before = Xeno.config.turn_stale_after.ago
+      earlier_active = self.class
+        .where(session_id: session_id)
+        .where("sequence < ?", sequence)
+        .where(status: %w[pending running waiting])
+
+      claimed = self.class
+        .where(id: id, claim_token: current.claim_token)
+        .where("status = 'pending' OR (status = 'running' AND (heartbeat_at IS NULL OR heartbeat_at < ?))", stale_before)
+        .where.not(earlier_active.arel.exists) # turns run in session order
+        .update_all([
+          "status = 'running', claim_token = ?, " \
+          "attempts = attempts + (CASE WHEN status = 'running' THEN 1 ELSE 0 END), " \
+          "heartbeat_at = ?",
+          current.claim_token + 1, Time.current
+        ])
+
+      claimed == 1 ? current.claim_token + 1 : nil
+    end
+
+    # Transient failure: record the error, count the failure against the
+    # poison ladder, and hand the claim back (status pending) so the queue
+    # retry can claim immediately.
+    def release_for_retry!(token, error)
+      current = self.class.find(id)
+      fenced_update!(token,
+        status: "pending",
+        attempts: current.attempts + 1,
+        error: { "class" => error.class.name, "message" => error.message })
+    end
+
+    # Fenced write: touches the heartbeat iff we still own the claim.
+    # Raises Xeno::Fenced when a zombie discovers it was reaped.
+    def heartbeat!(token)
+      fenced_update!(token, heartbeat_at: Time.current)
+    end
+
+    def fenced_update!(token, attributes)
+      rows = self.class.where(id: id, claim_token: token).update_all(attributes)
+      raise Xeno::Fenced, "turn #{id}: claim #{token} was fenced out" unless rows == 1
+
+      true
+    end
+
+    def record_step!(token)
+      current = self.class.find(id)
+      if current.steps_count >= Xeno.config.max_steps
+        raise Xeno::MaxStepsExceeded, "turn #{id}: exceeded #{Xeno.config.max_steps} steps"
+      end
+
+      fenced_update!(token, steps_count: current.steps_count + 1, heartbeat_at: Time.current)
+      current.steps_count + 1
+    end
+  end
+end

data/app/views/layouts/xeno/application.html.erb

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Xeno</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%# The dev UI inlines its styles (_styles partial) — no asset-pipeline
+      link: standalone/mounted apps without propshaft would 404 on
+      /stylesheets/xeno/application.css on every page load. %>
+  <%= yield :head %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/xeno/dev_ui/_styles.html.erb

@@ -0,0 +1,24 @@
+<style>
+  .xeno-dev { max-width: 960px; margin: 2rem auto; font-family: ui-sans-serif, system-ui, sans-serif; color: #1a1a1a; padding: 0 1rem; }
+  .xeno-dev h1 { font-size: 1.4rem; } .xeno-dev h2 { font-size: 1.05rem; margin-top: 1.5rem; }
+  .xeno-dev .muted { color: #888; }
+  .xeno-dev table { border-collapse: collapse; width: 100%; }
+  .xeno-dev th, .xeno-dev td { text-align: left; padding: .35rem .6rem; border-bottom: 1px solid #eee; font-size: .9rem; }
+  .xeno-dev .badge { font-size: .75rem; padding: .1rem .5rem; border-radius: 99px; background: #eee; vertical-align: middle; }
+  .xeno-dev .badge-running { background: #d9f0ff; } .xeno-dev .badge-waiting { background: #fff3cd; }
+  .xeno-dev .badge-completed { background: #d9f7dc; } .xeno-dev .badge-failed { background: #ffd9d9; }
+  .xeno-dev .columns { display: grid; grid-template-columns: 3fr 2fr; gap: 2rem; align-items: start; }
+  .xeno-dev .msg { margin: .6rem 0; padding: .5rem .8rem; border-radius: 8px; background: #f6f6f6; }
+  .xeno-dev .msg-user { background: #eef4ff; } .xeno-dev .msg-tool { background: #f2fbf2; }
+  .xeno-dev .msg .role { font-size: .7rem; text-transform: uppercase; color: #999; margin-bottom: .15rem; }
+  .xeno-dev .msg code { font-size: .82rem; display: block; margin: .15rem 0; }
+  .xeno-dev .pending { border: 2px solid #f0c36d; border-radius: 8px; padding: .6rem .9rem; margin-top: 1rem; background: #fffaf0; }
+  .xeno-dev .pending h3 { margin: .2rem 0 .5rem; font-size: .95rem; }
+  .xeno-dev form.inline { display: inline-block; margin-right: .4rem; }
+  .xeno-dev form input[type="text"] { width: 60%; padding: .45rem .6rem; border: 1px solid #ccc; border-radius: 6px; }
+  .xeno-dev form input[type="submit"] { padding: .45rem .9rem; border: 0; border-radius: 6px; background: #1a1a1a; color: #fff; cursor: pointer; }
+  .xeno-dev form input.deny { background: #b33; }
+  .xeno-dev .events ol { font-size: .82rem; line-height: 1.5; padding-left: 2.4rem; }
+  .xeno-dev .live { color: #2b2; font-size: .8rem; }
+  .xeno-dev .reply { margin-top: 1rem; }
+</style>

data/app/views/xeno/dev_ui/index.html.erb

@@ -0,0 +1,28 @@
+<div class="xeno-dev">
+  <h1>xeno · dev chat</h1>
+
+  <%= form_with url: dev_sessions_path, method: :post, local: true, class: "new-chat" do |f| %>
+    <%= f.text_field :message, placeholder: "Start a conversation…", required: true, autofocus: true %>
+    <%= f.submit "Send" %>
+  <% end %>
+
+  <h2>Sessions</h2>
+  <% if @sessions.any? %>
+    <table>
+      <tr><th>#</th><th>status</th><th>channel</th><th>started</th><th></th></tr>
+      <% @sessions.each do |session| %>
+        <tr>
+          <td>#<%= session.id %></td>
+          <td><span class="badge badge-<%= session.status %>"><%= session.status %></span></td>
+          <td><%= session.channel %></td>
+          <td><%= session.created_at.strftime("%b %-d %H:%M") %></td>
+          <td><%= link_to "open", dev_session_path(session) %></td>
+        </tr>
+      <% end %>
+    </table>
+  <% else %>
+    <p class="muted">No sessions yet — send a message above.</p>
+  <% end %>
+</div>
+
+<%= render "xeno/dev_ui/styles" %>

data/app/views/xeno/dev_ui/show.html.erb

@@ -0,0 +1,115 @@
+<div class="xeno-dev">
+  <p><%= link_to "← sessions", dev_ui_path %></p>
+  <h1>
+    session #<%= @session.id %>
+    <span class="badge badge-<%= @session.status %>"><%= @session.status %></span>
+  </h1>
+
+  <div class="columns">
+    <section class="chat">
+      <h2>Conversation</h2>
+      <% @messages.each do |message| %>
+        <% next if message.role == "system" %>
+        <div class="msg msg-<%= message.role %>">
+          <div class="role"><%= message.role %></div>
+          <% if message.tool_call? %>
+            <% message.ruby_llm_tool_calls.each do |call| %>
+              <code>→ <%= call.name %>(<%= call.arguments.to_json %>)</code>
+            <% end %>
+          <% end %>
+          <% if message.content.present? %>
+            <div class="content"><%= simple_format(message.content) %></div>
+          <% end %>
+        </div>
+      <% end %>
+
+      <% if @pending_actions.any? %>
+        <div class="pending">
+          <h3>⏸ waiting on you</h3>
+          <% @pending_actions.each do |action| %>
+            <div class="action">
+              <% if action.kind == "question" %>
+                <p><strong><%= action.input&.dig("question") %></strong></p>
+                <%= form_with url: dev_session_input_path(@session), method: :post, local: true do |f| %>
+                  <%= f.hidden_field :action_id, value: action.id %>
+                  <%= f.text_field :answer, placeholder: "Your answer…", required: true %>
+                  <%= f.submit "Answer" %>
+                <% end %>
+              <% else %>
+                <p><code><%= action.tool_name %>(<%= action.input.to_json %>)</code></p>
+                <%= form_with url: dev_session_input_path(@session), method: :post, local: true, class: "inline" do |f| %>
+                  <%= f.hidden_field :action_id, value: action.id %>
+                  <%= f.hidden_field :decision, value: "approve" %>
+                  <%= f.submit "Approve" %>
+                <% end %>
+                <%= form_with url: dev_session_input_path(@session), method: :post, local: true, class: "inline" do |f| %>
+                  <%= f.hidden_field :action_id, value: action.id %>
+                  <%= f.hidden_field :decision, value: "deny" %>
+                  <%= f.submit "Deny", class: "deny" %>
+                <% end %>
+              <% end %>
+            </div>
+          <% end %>
+        </div>
+      <% end %>
+
+      <% if @session.active? %>
+        <%= form_with url: dev_session_message_path(@session), method: :post, local: true, class: "reply" do |f| %>
+          <%= f.text_field :message, placeholder: "Reply…", required: true %>
+          <%= f.submit "Send" %>
+          <label title="Stop the active turn and make this message the next one">
+            <%= f.check_box :steer %> steer
+          </label>
+        <% end %>
+        <%= form_with url: dev_session_compact_path(@session), method: :post, local: true, class: "inline" do |f| %>
+          <%= f.submit "Compact transcript", title: "Summarize-and-replace everything but the recent turns" %>
+        <% end %>
+      <% else %>
+        <p class="muted">Session is <%= @session.status %>.</p>
+      <% end %>
+    </section>
+
+    <section class="events">
+      <h2>Event stream <span class="live" id="live-dot">●</span></h2>
+      <ol id="event-list" start="0">
+        <% @events.each do |event| %>
+          <li value="<%= event.index %>"><code><%= event.event_type %></code></li>
+        <% end %>
+      </ol>
+    </section>
+  </div>
+</div>
+
+<%= render "xeno/dev_ui/styles" %>
+
+<script>
+  // Live updates ride xeno's own SSE endpoint — the dev UI dogfoods the API.
+  (function () {
+    var nextIndex = <%= (@events.last&.index || -1) + 1 %>;
+    var source = new EventSource("<%= session_stream_path(@session, start_index: (@events.last&.index || -1) + 1) %>");
+    var list = document.getElementById("event-list");
+    var reloadTypes = ["turn.completed", "turn.failed", "turn.cancelled", "session.waiting", "message.completed"];
+
+    ["session.started", "message.received", "turn.started", "step.started", "step.completed",
+     "actions.requested", "action.result", "input.requested", "reasoning.completed",
+     "message.completed", "compaction.requested", "compaction.completed",
+     "budget.exceeded", "turn.completed", "turn.failed", "turn.cancelled",
+     "session.waiting", "session.completed", "session.failed"].forEach(function (type) {
+      source.addEventListener(type, function (event) {
+        var li = document.createElement("li");
+        var envelope = JSON.parse(event.data);
+        li.value = envelope.meta.index;
+        li.innerHTML = "<code>" + type + "</code>";
+        list.appendChild(li);
+        if (reloadTypes.indexOf(type) !== -1) {
+          source.close();
+          setTimeout(function () { location.reload(); }, 300);
+        }
+      });
+    });
+
+    source.onerror = function () {
+      document.getElementById("live-dot").style.color = "#999";
+    };
+  })();
+</script>

data/config/routes.rb

@@ -0,0 +1,25 @@
+Xeno::Engine.routes.draw do
+  scope "v1" do
+    get "health", to: "health#show"
+
+    post "sessions", to: "sessions#create"
+    post "sessions/:id/messages", to: "sessions#message", as: :session_messages
+    post "sessions/:id/inputs", to: "sessions#input", as: :session_inputs
+    post "sessions/:id/cancel", to: "sessions#cancel", as: :session_cancel
+    post "sessions/:id/compact", to: "sessions#compact", as: :session_compact
+    post "sessions/:id/reset", to: "sessions#reset", as: :session_reset
+    get "sessions/:id/stream", to: "streams#show", as: :session_stream
+
+    post "dev/schedules/:name", to: "dev#dispatch_schedule", as: :dev_schedule_dispatch
+
+    post "channels/slack/events", to: "slack#events", as: :slack_events
+  end
+
+  # The dev chat UI (development only; the controller 404s elsewhere).
+  get "dev", to: "dev_ui#index", as: :dev_ui
+  post "dev/sessions", to: "dev_ui#create", as: :dev_sessions
+  get "dev/sessions/:id", to: "dev_ui#show", as: :dev_session
+  post "dev/sessions/:id/messages", to: "dev_ui#message", as: :dev_session_message
+  post "dev/sessions/:id/inputs", to: "dev_ui#input", as: :dev_session_input
+  post "dev/sessions/:id/compact", to: "dev_ui#compact", as: :dev_session_compact
+end

data/db/migrate/20260804000001_create_xeno_llm_tables.rb

@@ -0,0 +1,70 @@
+# The transcript layer: xeno-owned copies of RubyLLM's acts_as tables
+# (chats, messages, tool_calls, models). Column set mirrors RubyLLM's
+# install generator templates so the acts_as persistence paths keep
+# every column they know how to write (thinking, tokens, costs).
+class CreateXenoLlmTables < ActiveRecord::Migration[8.1]
+  def change
+    create_table :xeno_models do |t|
+      t.string :model_id, null: false
+      t.string :name, null: false
+      t.string :provider, null: false
+      t.string :family
+      t.datetime :model_created_at
+      t.integer :context_window
+      t.integer :max_output_tokens
+      t.date :knowledge_cutoff
+      t.json :modalities, default: {}
+      t.json :capabilities, default: []
+      t.json :pricing, default: {}
+      t.json :metadata, default: {}
+      t.timestamps
+
+      t.index [ :provider, :model_id ], unique: true
+      t.index :provider
+      t.index :family
+    end
+
+    create_table :xeno_chats do |t|
+      t.boolean :cancelled, null: false, default: false
+      t.references :model, foreign_key: { to_table: :xeno_models }
+      t.timestamps
+    end
+
+    create_table :xeno_messages do |t|
+      t.string :role, null: false
+      t.text :content
+      t.boolean :cache_until_here, null: false, default: false
+      t.text :thinking_text
+      t.text :thinking_signature
+      t.integer :thinking_tokens
+      t.json :citations
+      t.integer :input_tokens
+      t.integer :output_tokens
+      t.integer :cache_read_tokens
+      t.integer :cache_write_tokens
+      t.decimal :total_cost, precision: 16, scale: 10
+      t.json :cost_details
+      t.string :finish_reason
+      t.references :chat, null: false, foreign_key: { to_table: :xeno_chats }
+      t.references :model, foreign_key: { to_table: :xeno_models }
+      t.timestamps
+
+      t.index :role
+    end
+
+    create_table :xeno_tool_calls do |t|
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.text :thought_signature
+      t.json :arguments, default: {}
+      t.references :message, null: false, foreign_key: { to_table: :xeno_messages }
+      t.timestamps
+
+      t.index :tool_call_id, unique: true
+      t.index :name
+    end
+
+    # Tool-result messages point back at the tool call they answer.
+    add_reference :xeno_messages, :tool_call, foreign_key: { to_table: :xeno_tool_calls }
+  end
+end

data/db/migrate/20260804000002_create_xeno_orchestration_tables.rb

@@ -0,0 +1,70 @@
+# The orchestration layer above the transcript: sessions, turns (claim/
+# heartbeat/fencing), actions (tool-call checkpoint + approval state),
+# events (the append-only session stream), pending messages (drained into
+# the next turn). Per spike #2 there is no steps table — a step's output
+# lives in xeno_messages/xeno_tool_calls.
+class CreateXenoOrchestrationTables < ActiveRecord::Migration[8.1]
+  def change
+    create_table :xeno_sessions do |t|
+      t.string :agent, null: false
+      t.string :status, null: false, default: "running" # running|waiting|completed|failed
+      t.string :channel
+      t.string :continuation_token
+      t.string :title
+      t.json :principal
+      t.json :metadata, default: {}
+      t.references :chat, null: false, foreign_key: { to_table: :xeno_chats }
+      t.timestamps
+
+      t.index :continuation_token, unique: true
+      t.index :status
+    end
+
+    create_table :xeno_turns do |t|
+      t.references :session, null: false, foreign_key: { to_table: :xeno_sessions }
+      t.integer :sequence, null: false
+      t.string :status, null: false, default: "pending" # pending|running|waiting|completed|failed|cancelled
+      t.integer :claim_token, null: false, default: 0
+      t.datetime :heartbeat_at
+      t.integer :attempts, null: false, default: 0
+      t.integer :steps_count, null: false, default: 0
+      t.json :user_message
+      t.json :error
+      t.timestamps
+
+      t.index [ :session_id, :sequence ], unique: true
+      t.index :status
+    end
+
+    create_table :xeno_actions do |t|
+      t.references :turn, null: false, foreign_key: { to_table: :xeno_turns }
+      t.string :tool_call_id, null: false # the provider call id (xeno_tool_calls.tool_call_id)
+      t.string :tool_name, null: false
+      t.string :kind, null: false, default: "tool" # tool|question
+      t.string :status, null: false, default: "pending" # pending|pending_approval|approved|denied|completed|failed
+      t.json :input
+      t.json :output
+      t.datetime :resolved_at # when a human approved/denied/answered
+      t.json :resolved_by     # the resolving principal
+      t.timestamps
+
+      t.index [ :turn_id, :tool_call_id ], unique: true
+    end
+
+    create_table :xeno_events do |t|
+      t.references :session, null: false, foreign_key: { to_table: :xeno_sessions }
+      t.integer :index, null: false # per-session cursor (SSE start_index)
+      t.string :event_type, null: false
+      t.json :data
+      t.datetime :created_at, null: false
+
+      t.index [ :session_id, :index ], unique: true
+    end
+
+    create_table :xeno_pending_messages do |t|
+      t.references :session, null: false, foreign_key: { to_table: :xeno_sessions }
+      t.json :payload, null: false
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260805000001_add_resumes_to_xeno_turns.rb

@@ -0,0 +1,8 @@
+# H2: `attempts` is the failure ladder (transient errors, crash reclaims) —
+# approval/question resumes are human-driven and unbounded, counted apart so
+# a much-approved turn can never trip the poison branch.
+class AddResumesToXenoTurns < ActiveRecord::Migration[8.1]
+  def change
+    add_column :xeno_turns, :resumes, :integer, null: false, default: 0
+  end
+end

data/db/migrate/20260805000002_add_transcript_deferred_to_xeno_turns.rb

@@ -0,0 +1,8 @@
+class AddTranscriptDeferredToXenoTurns < ActiveRecord::Migration[8.1]
+  def change
+    # A deferred turn's user messages live in turns.user_message until the
+    # runner claims it and writes them into the transcript (drained turns
+    # must not mutate a parked turn's mid-flight transcript).
+    add_column :xeno_turns, :transcript_deferred, :boolean, null: false, default: false
+  end
+end

data/db/migrate/20260805000003_create_xeno_dedups.rb

@@ -0,0 +1,14 @@
+class CreateXenoDedups < ActiveRecord::Migration[8.1]
+  def change
+    # At-least-once delivery dedup ledger: schedule ticks, Slack event ids.
+    # One row per (scope, key); the unique index is the arbiter.
+    create_table :xeno_dedups do |t|
+      t.string :scope, null: false
+      t.string :key, null: false
+      t.json :metadata
+      t.datetime :created_at, null: false
+
+      t.index [ :scope, :key ], unique: true
+    end
+  end
+end

data/db/migrate/20260805000004_add_kind_to_xeno_turns.rb

@@ -0,0 +1,9 @@
+class AddKindToXenoTurns < ActiveRecord::Migration[8.1]
+  def change
+    # "message" turns drive the model loop; "compaction" turns
+    # summarize-and-replace the transcript. Compaction rides the turn
+    # machinery so it inherits the claim CAS, session ordering (it queues
+    # behind an active or parked turn), heartbeat, and crash-safe replay.
+    add_column :xeno_turns, :kind, :string, null: false, default: "message"
+  end
+end

data/db/migrate/20260805000005_add_state_to_xeno_sessions.rb

@@ -0,0 +1,8 @@
+class AddStateToXenoSessions < ActiveRecord::Migration[8.1]
+  def change
+    # The session-scoped KV store (Session#state / Tool#state): JSON-typed
+    # values, survives restarts, never crosses sessions, cleared by reset.
+    # Working state for one conversation — NOT long-term memory.
+    add_column :xeno_sessions, :state, :json, null: false, default: {}
+  end
+end

data/db/migrate/20260806000001_move_transcript_support_tables_to_ruby_llm.rb

@@ -0,0 +1,133 @@
+# ruby_llm 2aaddf96: models, tool calls, usage, and batches become library
+# records on RubyLLM-owned ruby_llm_* tables (polymorphic toward the app's
+# chat/message classes); message rows stop carrying token/cost accounting
+# (the per-attempt ruby_llm_usage_entries ledger replaces it). Table shapes
+# mirror upstream's install templates.
+#
+# DESTRUCTIVE (pre-release, no installs to migrate): xeno_tool_calls and
+# xeno_models are dropped without moving their rows, and the accounting
+# columns on xeno_messages are removed with their data. Existing chats keep
+# their transcript text but lose tool-call linkage and usage history.
+class MoveTranscriptSupportTablesToRubyLlm < ActiveRecord::Migration[8.1]
+  def change
+    create_table :ruby_llm_models do |t|
+      t.string :model_id, null: false
+      t.string :name, null: false
+      t.string :provider, null: false
+      t.string :family
+      t.datetime :model_created_at
+      t.integer :context_window
+      t.integer :max_output_tokens
+      t.date :knowledge_cutoff
+      t.json :modalities, default: {}
+      t.json :capabilities, default: []
+      t.json :pricing, default: {}
+      t.json :metadata, default: {}
+      t.timestamps
+
+      t.index [ :provider, :model_id ], unique: true
+      t.index :provider
+      t.index :family
+    end
+
+    create_table :ruby_llm_tool_calls do |t|
+      t.references :message, polymorphic: true, null: false, index: false
+      t.references :result, polymorphic: true, index: false
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.text :thought_signature
+      t.json :arguments, default: {}
+      t.timestamps
+
+      t.index [ :message_type, :message_id ]
+      t.index [ :result_type, :result_id ]
+      t.index :tool_call_id, unique: true
+      t.index :name
+    end
+
+    create_table :ruby_llm_usage_entries do |t|
+      t.references :chat, polymorphic: true, null: false, index: false
+      t.references :message, polymorphic: true, index: false
+      t.string :operation, null: false
+      t.string :provider, null: false
+      t.string :model, null: false
+      t.string :status, null: false
+      t.integer :input_tokens
+      t.integer :output_tokens
+      t.integer :cache_read_tokens
+      t.integer :cache_write_tokens
+      t.integer :thinking_tokens
+      t.decimal :input_cost, precision: 16, scale: 10
+      t.decimal :output_cost, precision: 16, scale: 10
+      t.decimal :cache_read_cost, precision: 16, scale: 10
+      t.decimal :cache_write_cost, precision: 16, scale: 10
+      t.decimal :thinking_cost, precision: 16, scale: 10
+      t.decimal :total_cost, precision: 16, scale: 10
+      t.timestamps
+
+      t.index [ :chat_type, :chat_id ]
+      t.index [ :message_type, :message_id ]
+      t.index :status
+      t.check_constraint "operation IN ('chat', 'embedding', 'moderation', 'image', 'speech', 'transcription')"
+      t.check_constraint "status IN ('pending', 'succeeded', 'failed', 'cancelled')"
+    end
+
+    create_table :ruby_llm_batches do |t|
+      t.string :provider_batch_id, null: false
+      t.string :provider, null: false
+      t.string :status
+      t.boolean :completed, null: false, default: false
+      t.string :chat_type
+      t.string :batch_protocol
+      t.json :chat_ids, default: []
+      t.json :request_counts
+      t.timestamps
+
+      t.index [ :provider, :provider_batch_id ], unique: true
+      t.index :status
+    end
+
+    # acts_as_chat hard-wires belongs_to :model with this foreign key.
+    # Upstream's fresh-install template makes it null: false; here it stays
+    # nullable because pre-existing xeno_chats rows have nothing to point at
+    # (the association is optional and resolve_model fills it on save).
+    add_reference :xeno_chats, :ruby_llm_model, foreign_key: { to_table: :ruby_llm_models }
+
+    remove_reference :xeno_messages, :tool_call, foreign_key: { to_table: :xeno_tool_calls }
+    remove_reference :xeno_messages, :model, foreign_key: { to_table: :xeno_models }
+    remove_reference :xeno_chats, :model, foreign_key: { to_table: :xeno_models }
+
+    remove_column :xeno_messages, :thinking_tokens, :integer
+    remove_column :xeno_messages, :input_tokens, :integer
+    remove_column :xeno_messages, :output_tokens, :integer
+    remove_column :xeno_messages, :cache_read_tokens, :integer
+    remove_column :xeno_messages, :cache_write_tokens, :integer
+    remove_column :xeno_messages, :total_cost, :decimal, precision: 16, scale: 10
+    remove_column :xeno_messages, :cost_details, :json
+
+    drop_table :xeno_tool_calls do |t|
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.text :thought_signature
+      t.json :arguments, default: {}
+      t.references :message, null: false
+      t.timestamps
+    end
+
+    drop_table :xeno_models do |t|
+      t.string :model_id, null: false
+      t.string :name, null: false
+      t.string :provider, null: false
+      t.string :family
+      t.datetime :model_created_at
+      t.integer :context_window
+      t.integer :max_output_tokens
+      t.date :knowledge_cutoff
+      t.json :modalities, default: {}
+      t.json :capabilities, default: []
+      t.json :pricing, default: {}
+      t.json :metadata, default: {}
+      t.timestamps
+    end
+  end
+end