xeno 0.0.1 → 0.0.2

data/lib/xeno/tool.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module Xeno
-  # Base class for agent tools. Anyone who knows RubyLLM already knows how
-  # to write these; xeno adds discovery and (later) the approval macro and
-  # session context.
+  # = Tools
+  #
+  # A tool is something the agent can do besides talk: look up an order, charge a card, file a
+  # ticket. Each tool is a class under agent/tools/, and the model decides when to call it based
+  # on the description and parameters you declare:
   #
   #   # agent/tools/get_weather.rb
   #   class Xeno::Tools::GetWeather < Xeno::Tool
@@ -13,51 +17,50 @@ module Xeno
   #     end
   #   end
   #
+  # The file name is the tool's name on the wire — get_weather.rb is callable as get_weather — and
+  # whatever execute returns becomes the tool result the model reads next.
+  #
+  # Beyond a plain RubyLLM::Tool, a xeno tool runs inside a durable session: it can keep working
+  # state in #state, see the #session it runs in, and declare an ::approval policy so a human
+  # signs off before anything irreversible happens.
   class Tool < RubyLLM::Tool
     class << self
-      # The runtime name the model calls this tool by. The path supplies the
-      # name: Zeitwerk guarantees agent/tools/get_weather.rb
-      # defines Xeno::Tools::GetWeather, so the demodulized class name and
-      # the file basename are the same thing. No suffix-stripping: a
-      # `charge_card_tool.rb` must be callable as `charge_card_tool`, or the
-      # runtime's slug-keyed lookup misses and the approval gate is skipped.
+      # The runtime name the model calls this tool by, taken from the path:
+      # agent/tools/get_weather.rb defines Xeno::Tools::GetWeather, and the demodulized class name
+      # matches the file basename. No suffix stripping: a charge_card_tool.rb must stay callable as
+      # charge_card_tool or the slug-keyed approval lookup misses.
       def tool_name
         name.demodulize.underscore
       end
 
-      # The human-in-the-loop gate. Anything irreversible or externally
-      # visible should be gated — approvals are the guardrail in an
-      # in-app-tools trust model.
+      # The human-in-the-loop gate. Gate anything irreversible or externally visible.
       #
       #   approval :never    # default: runs without asking
       #   approval :once     # asks the first time in a session, then remembered
       #   approval :always   # asks on every call
       #   approval ->(ctx) { ctx.principal&.dig("role") != "admin" }
       #
-      # The lambda receives an ApprovalContext (session, turn, tool_name,
-      # arguments, principal); truthy means approval is required.
+      # The lambda receives an ApprovalContext (session, turn, tool_name, arguments, principal);
+      # truthy means approval is required.
       def approval(policy = nil)
         @approval = policy unless policy.nil?
         return @approval if defined?(@approval) && @approval
 
         superclass.respond_to?(:approval) ? superclass.approval : :never
       end
-    end
 
-    # RubyLLM derives the wire name from the full class name, which would
-    # leak the namespace (xeno/tools/get_weather). Use the path-derived name.
-    def name
-      self.class.tool_name
+      def approval_declared? # :nodoc:
+        (defined?(@approval) && !@approval.nil?) ||
+          (superclass.respond_to?(:approval_declared?) && superclass.approval_declared?)
+      end
     end
 
-    # The session this call is running in — set by the runner before
-    # `call`. nil when the tool is exercised outside a session (unit tests
-    # calling `Tool.new.call` directly).
+    # The session this call is running in — set by the runner before `call`. nil when the tool is
+    # exercised outside a session (unit tests calling `Tool.new.call` directly).
     attr_accessor :session
 
-    # The session-scoped KV store: JSON-typed values that survive restarts,
-    # never cross sessions, and are cleared by reset. Working state, not
-    # long-term memory.
+    # The session-scoped KV store: JSON-typed values that survive restarts, never cross sessions,
+    # and are cleared by reset. Working state, not long-term memory.
     #
     #   def execute(city:)
     #     searches = state.get("searches").to_i + 1

data/lib/xeno/turn_runner.rb

@@ -1,19 +1,18 @@
+# frozen_string_literal: true
+
 module Xeno
-  # Drives one turn to completion (or to a park). This is the durable core:
-  # RubyLLM's decomposed v2 loop (`generate` + self-executed tools +
-  # `add_message` injection), checkpointed in the database at every move.
-  # We never call `run_tools` (not idempotent) or `complete` (unbounded).
+  # Drives one turn to completion or to a park, checkpointing every move in the database. Uses
+  # RubyLLM's decomposed loop — `generate`, self-executed tools, `add_message` injection — and never
+  # `run_tools` (no approval gate, no per-call checkpoint) or `complete` (a turn must bound its
+  # model calls).
   #
-  # Crash-safety invariants:
-  # - The user message and instructions were persisted when the turn was
-  #   staged; the runner only advances the transcript.
-  # - `generate` persists the assistant message via the acts_as callback path.
-  # - A tool execution and its transcript injection commit in ONE transaction
-  #   (the action row is the checkpoint) — recorded calls are never re-run.
-  # - Every write is fenced on the claim token; zombies affect zero rows.
-  # - Trailing blank assistant rows (the mid-generate crash window) are
-  #   removed before deciding anything (spike #2, hazard 1).
-  class TurnRunner
+  # Invariants:
+  # - A tool execution and its transcript injection commit in one
+  #   transaction; recorded calls are never re-run.
+  # - Every write is fenced on the claim token; a zombie affects zero rows.
+  # - Trailing blank assistant rows (mid-generate crash artifacts) are
+  #   removed before anything else.
+  class TurnRunner # :nodoc:
     include Compaction
 
     attr_reader :turn, :session, :definition, :token
@@ -38,9 +37,9 @@ module Xeno
     private
 
     def run_claimed
-      # A pristine record instance: a memoized to_llm built elsewhere (e.g.
-      # by stage_turn! in this same process) would ignore the runtime attrs
-      # prepare_chat sets (protocol, assume_model_exists).
+      # A pristine record instance: a memoized to_llm built elsewhere (e.g. by stage_turn! in this
+      # same process) would ignore the runtime attrs prepare_chat sets (protocol,
+      # assume_model_exists).
       @chat = Chat.find(session.chat_id)
       clear_stale_cancellation
 
@@ -72,8 +71,8 @@ module Xeno
       interrupt_turn
       :interrupted
     rescue Xeno::Parked => parked
-      # Schedules have no human to wait for: a gated tool (or ask_question)
-      # in a schedule run deterministically fails the turn.
+      # Schedules have no human to wait for: a gated tool (or ask_question) in a schedule run
+      # deterministically fails the turn.
       if session.channel == "schedule"
         fail_schedule_park
         :failed
@@ -100,27 +99,22 @@ module Xeno
       raise
     end
 
-    # assume_model_exists and protocol are not persisted on the chat record —
-    # every process re-applies them from the definition before the first
-    # to_llm build (which with_tools triggers).
+    # assume_model_exists and protocol are not persisted on the chat record — every process
+    # re-applies them from the definition before the first to_llm build (which with_tools triggers).
     def prepare_chat
       @chat.apply_runtime_options!(definition.config.model_options)
       @chat.with_tools(Xeno::AskQuestion, *definition.tool_classes)
     end
 
-    # A persisted cancellation flag set before this turn claimed is stale —
-    # it targeted work that no longer exists (the previous turn ended, or a
-    # cancel raced a completion) and would otherwise poison this turn's
-    # first generate. Cancellation is documented as cooperative/best-effort,
-    # so the tiny window where a cancel lands between our claim and this
-    # clear is an accepted trade-off.
+    # A cancellation flag set before this turn claimed targeted work that no longer exists; clear
+    # it. Cancellation is cooperative, so a cancel landing between the claim and this clear is an
+    # accepted loss.
     def clear_stale_cancellation
       Chat.where(id: @chat.id, cancelled: true).update_all(cancelled: false)
     end
 
-    # Spike #2, hazard 1: a process killed mid-generate leaves a blank
-    # assistant row that reads as a completed turn. Trailing blank assistant
-    # rows (no content, no tool calls) are crash artifacts — delete them.
+    # A kill mid-generate leaves a blank assistant row. Trailing blank assistant rows are crash
+    # artifacts; delete them.
     def remove_crash_artifacts
       loop do
         last = @chat.messages_association.order(:id).last
@@ -136,19 +130,16 @@ module Xeno
       @chat.reload
     end
 
-    # A drained turn carries its user messages in the turn row until it is
-    # claimed (a mid-flight earlier transcript must not be appended to).
-    # Staged here, exactly once: the appends and the flag flip commit
-    # together, and the flip is fenced — a crash replays the whole thing,
-    # a zombie stages nothing. Instructions refresh here too, so a deploy
-    # between drain and claim behaves like any other new turn.
+    # A drained turn carries its user messages in the turn row until it is claimed; appending
+    # earlier would corrupt a mid-flight transcript. The appends and the flag flip commit together
+    # and the flip is fenced, so a crash replays and a zombie stages nothing. Instructions refresh
+    # here too.
     def stage_deferred_transcript!
       return unless turn.transcript_deferred?
 
       contents = Array(turn.user_message&.fetch("contents", nil))
       ActiveRecord::Base.transaction do
-        resolved = definition.instructions_for(session: session)
-        @chat.with_instructions(resolved) if resolved
+        @chat.with_instructions(definition.instructions_for(session: session))
         contents.each { |content| @chat.add_message(role: :user, content: content) }
         turn.fenced_update!(token, transcript_deferred: false)
       end
@@ -165,10 +156,9 @@ module Xeno
       last_assistant.tool_calls.values.reject { |call| answered.include?(call.id) }
     end
 
-    # Resolves the batch: replays recorded work, injects denials, executes
-    # what is allowed to run, and collects everything that needs a human.
-    # Ungated calls in a mixed batch still execute before the park (their
-    # results are recorded, so the resume replays them for free).
+    # Resolves the batch: replays recorded work, injects denials, executes what may run, and
+    # collects what needs a human. Ungated calls in a mixed batch execute before the park; the
+    # resume replays their recorded results.
     def resolve_tool_calls(calls)
       blocking = []
 
@@ -203,6 +193,13 @@ module Xeno
       tool_class = definition.tools[call.name]
       return false unless tool_class.respond_to?(:approval)
 
+      # A tool declaring RubyLLM's requires_approval without a xeno policy gets the gate. An
+      # explicit xeno policy, even :never, wins.
+      if tool_class.respond_to?(:approval_declared?) && !tool_class.approval_declared? &&
+         tool_class.respond_to?(:requires_approval?) && tool_class.requires_approval?
+        return true
+      end
+
       policy = tool_class.approval
       case policy
       when :never, nil then false
@@ -262,9 +259,8 @@ module Xeno
       @chat.to_llm.messages.any? { |m| m.role == :tool && m.tool_call_id == call.id }
     end
 
-    # A completed action whose result is not yet in the transcript: either an
-    # answered question (Inputs writes the answer to the action only) or a
-    # self-heal after replay. Inject the recorded output — never re-execute.
+    # A completed action whose result is not yet in the transcript — an answered question, or a
+    # self-heal after replay. Inject the recorded output; never re-execute.
     def replay_completed_action(action, call)
       return false unless action.completed?
 
@@ -277,12 +273,9 @@ module Xeno
       true
     end
 
-    # A raising tool must NOT bubble into the queue's retry ladder: the
-    # action row wouldn't exist as a checkpoint, so every retry would
-    # re-execute the tool (side effects!), and after retry_on exhausted the
-    # turn would wedge. The exception becomes an error tool result the
-    # model can recover from; the failed action row replays like any other
-    # checkpoint.
+    # A raising tool must not reach the queue's retry ladder — without the action-row checkpoint
+    # every retry would re-execute it. The exception becomes an error tool result the model can
+    # recover from, and the failed action replays like any other checkpoint.
     def execute_action(action, call)
       tool_class = definition.tools[call.name]
       failure = nil
@@ -297,7 +290,7 @@ module Xeno
               result = ActiveSupport::Notifications.instrument("xeno.action", turn_id: turn.id, tool: call.name) do
                 tool = tool_class.new
                 tool.session = session
-                with_heartbeat { tool.call(arguments) }
+                with_heartbeat { tool.call(arguments, tool_call: call) }
               end
               stringify_result(result)
             rescue StandardError => e
@@ -322,8 +315,8 @@ module Xeno
       })
     end
 
-    # A failed action is a checkpoint too: the recorded error result is
-    # injected on replay — the tool is never re-executed.
+    # A failed action is a checkpoint too: the recorded error result is injected on replay — the
+    # tool is never re-executed.
     def replay_failed_action(action, call)
       return false unless action.status == "failed"
 
@@ -340,16 +333,13 @@ module Xeno
       @chat.add_message(role: :tool, content: content, tool_call_id: call.id)
     end
 
-    # Keeps the claim visibly alive while this thread is buried in a model
-    # call or a tool body — the calls that can outlast turn_stale_after and
-    # would otherwise get reclaimed mid-flight by claim! or the reaper. A
-    # sibling thread (own DB connection) beats heartbeat_at until the block
-    # returns; a fenced beat means we were reclaimed anyway, so it stops and
-    # lets the next fenced write in this thread raise.
+    # Keeps the claim alive through model calls and tool bodies, the calls that can outlast
+    # turn_stale_after. A sibling thread with its own DB connection beats heartbeat_at until the
+    # block returns; a fenced beat means the turn was reclaimed, so it stops.
     def with_heartbeat
       interval = Xeno.config.heartbeat_interval.to_f
-      # A non-positive interval (turn_stale_after 0 in tests) means every
-      # heartbeat is already stale — a beater would just hammer the DB.
+      # A non-positive interval (turn_stale_after 0 in tests) means every heartbeat is already stale
+      # — a beater would just hammer the DB.
       return yield unless interval.positive?
 
       stop = Thread::Queue.new
@@ -386,8 +376,8 @@ module Xeno
       step_index = turn.record_step!(token)
       session.emit("step.started", { turn_id: turn.id, step: step_index })
 
-      # A channel that streams (Slack post-then-edit) gets the deltas; the
-      # sink is a failable nicety and never touches the turn's fate.
+      # A channel that streams (Slack post-then-edit) gets the deltas; the sink is a failable nicety
+      # and never touches the turn's fate.
       streamer = Channels.streamer_for(session)
       response = ActiveSupport::Notifications.instrument("xeno.step", turn_id: turn.id, step: step_index) do
         with_heartbeat do
@@ -411,20 +401,17 @@ module Xeno
         })
       else
         emit_completion_events(response)
-        # The streamer writes the durable final text into its message; when
-        # that lands, the completion post would be a duplicate.
+        # The streamer writes the durable final text into its message; when that lands, the
+        # completion post would be a duplicate.
         @stream_delivered = true if streamer&.finish(response.content)
       end
 
       response
     end
 
-    # Budgets, before EACH model call, from the per-attempt usage ledger
-    # (ruby_llm_usage_entries) — the provider's own counts, summed across
-    # every attempt of this session's chat, retries included. The call that
-    # crosses a cap is allowed to finish (usage is only known afterwards);
-    # the NEXT call trips. Checked here (not at claim) so a turn that needs
-    # no model call — pure replay — still settles cleanly.
+    # Budgets are checked before each model call, from the per-attempt usage ledger (retries
+    # included). The call that crosses a cap finishes — usage is only known afterwards — and the
+    # next call trips. Checked here rather than at claim so a pure-replay turn still settles.
     def enforce_budgets!
       check_budget_axis!("input", :input_tokens, Xeno.config.max_input_tokens_per_session)
       check_budget_axis!("output", :output_tokens, Xeno.config.max_output_tokens_per_session)
@@ -453,9 +440,9 @@ module Xeno
       advance_session
     end
 
-    # Channel delivery (Slack thread reply, etc.) — a failable nicety; the
-    # durable truth is already in the transcript and events. Skipped when a
-    # streamer already delivered this reply (post-then-edit).
+    # Channel delivery (Slack thread reply, etc.) — a failable nicety; the durable truth is already
+    # in the transcript and events. Skipped when a streamer already delivered this reply
+    # (post-then-edit).
     def deliver_final_answer
       return if @stream_delivered
 
@@ -463,10 +450,8 @@ module Xeno
       Channels.deliver_completion(session, final.content) if final&.content.present?
     end
 
-    # After a terminal turn: fold queued messages into the next turn, and
-    # chain the next pending turn's job (later turns can't claim while an
-    # earlier one is non-terminal, so completion is what wakes them). A
-    # session retired mid-turn (reset) stops advancing.
+    # After a terminal turn: fold queued messages into the next turn and chain the next pending
+    # turn's job — completion is what wakes later turns. A session retired mid-turn stops advancing.
     def advance_session
       return unless session.reload.active?
 
@@ -474,10 +459,9 @@ module Xeno
       session.turns.where(status: "pending").order(:sequence).first&.enqueue!
     end
 
-    # Parking: the pending actions are recorded, the turn is waiting, and the
-    # job ENDS — no process waits. Input resolution enqueues the resume.
-    # Messages that queued behind this turn become visible NOW as a staged
-    # (deferred) next turn — mvp-design's drain-on-park delivery semantics.
+    # Parking: the pending actions are recorded, the turn waits, and the job ends — no process
+    # waits. Input resolution enqueues the resume; queued messages become a staged (deferred) next
+    # turn immediately.
     def park_turn(actions = [])
       turn.fenced_update!(token, status: "waiting")
       session.update!(status: "waiting")
@@ -504,19 +488,16 @@ module Xeno
       advance_session
     end
 
-    # Transient failure: count it, hand the claim back (status pending) so
-    # the retry can claim immediately, and let the error propagate to the
-    # queue's retry machinery.
+    # Transient failure: count it, hand the claim back (status pending) so the retry can claim
+    # immediately, and let the error propagate to the queue's retry machinery.
     def release_for_retry(error)
       turn.release_for_retry!(token, error)
     rescue Xeno::Fenced
       nil
     end
 
-    # The graceful-shutdown checkpoint (AJ Continuation's stopping? probe,
-    # adopted): between steps, a stopping worker hands the turn back instead
-    # of dying mid-step and waiting out stale-heartbeat reclaim. Every move
-    # so far is checkpointed, so the next worker fast-forwards for free.
+    # Between steps, a stopping worker hands the turn back instead of dying mid-step and waiting out
+    # stale-heartbeat reclaim. Every move so far is checkpointed, so the next worker fast-forwards.
     def checkpoint_shutdown!
       raise Xeno::Interrupted, "worker is shutting down" if stopping?
     end
@@ -530,11 +511,8 @@ module Xeno
       false # an adapter without the probe never interrupts
     end
 
-    # Not a failure and not crash evidence: the claim is released (status
-    # pending, ladder untouched) and the turn re-enqueues itself for the
-    # next worker. The re-enqueue is at-least-once like everything else —
-    # if it is lost with the worker, the reaper's stale-pending sweep is
-    # the backstop.
+    # Not a failure and not crash evidence: the claim is released with the ladder untouched and the
+    # turn re-enqueues itself. A lost re-enqueue is caught by the reaper's stale-pending sweep.
     def interrupt_turn
       turn.fenced_update!(token, status: "pending", heartbeat_at: Time.current)
       turn.enqueue!

data/lib/xeno/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Xeno
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/xeno.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "ruby_llm"
 
 require "xeno/version"
@@ -21,8 +23,8 @@ require "xeno/engine"
 
 module Xeno
   class << self
-    # The app's agent directory. Defaults to <Rails.root>/agent; overridable
-    # (standalone mode, tests).
+    # The app's agent directory. Defaults to <Rails.root>/agent; overridable (standalone mode,
+    # tests).
     attr_writer :agent_root
 
     def agent_root
@@ -50,15 +52,15 @@ module Xeno
       @captured_agent_config
     end
 
-    # The agent/instructions.rb entry point — dynamic instructions resolved
-    # at turn-stage time with the session context:
+    # The agent/instructions.rb entry point — dynamic instructions resolved at turn-stage time with
+    # the session context:
     #
     #   Xeno.instructions do |context|
     #     "You are helping #{context.principal&.dig("name") || "a guest"}."
     #   end
     #
-    # Composes with the static instructions.md: static first, the block's
-    # return appended. The block runs on EVERY turn stage — keep it fast.
+    # Composes with the static instructions.md: static first, the block's return appended. The block
+    # runs on EVERY turn stage — keep it fast.
     def instructions(&block)
       @captured_instructions = block
     end
@@ -72,15 +74,15 @@ module Xeno
       @captured_instructions
     end
 
-    # The agent/hooks/*.rb entry point — observe-only handlers for stream
-    # events (any type from the vocabulary, or "*"):
+    # The agent/hooks/*.rb entry point — observe-only handlers for stream events (any type from the
+    # vocabulary, or "*"):
     #
     #   Xeno.hook "turn.completed" do |event|
     #     Metrics.increment("agent.turns")
     #   end
     #
-    # Handlers fire after the event commits, at-least-once (replays
-    # re-emit). Raising never breaks the runtime.
+    # Handlers fire after the event commits, at-least-once (replays re-emit). Raising never breaks
+    # the runtime.
     def hook(event_type, &block)
       raise ArgumentError, "Xeno.hook requires a block" unless block
 
@@ -94,8 +96,8 @@ module Xeno
       @captured_hooks
     end
 
-    # The resolved agent definition, discovered on first use and cached.
-    # Rails reloading resets it (see engine's to_prepare).
+    # The resolved agent definition, discovered on first use and cached. Rails reloading resets it
+    # (see engine's to_prepare).
     def definition
       @definition ||= AgentDefinition.load(agent_root, name: default_agent_name)
     end
@@ -108,8 +110,8 @@ module Xeno
       Rails.application.class.module_parent_name.underscore
     end
 
-    # Dev routes exist in development, or when XENO_DEV_ROUTES is exactly
-    # "1"/"true" (a truthy-check would let "0" enable them — S5).
+    # Dev routes exist in development, or when XENO_DEV_ROUTES is exactly "1"/"true" (a truthy-check
+    # would let "0" enable them).
     def dev_routes_enabled?
       Rails.env.development? || %w[1 true].include?(ENV["XENO_DEV_ROUTES"].to_s)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xeno
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nicolas Erlichman
@@ -80,14 +80,9 @@ files:
 - app/views/xeno/dev_ui/index.html.erb
 - app/views/xeno/dev_ui/show.html.erb
 - config/routes.rb
-- db/migrate/20260804000001_create_xeno_llm_tables.rb
-- db/migrate/20260804000002_create_xeno_orchestration_tables.rb
-- db/migrate/20260805000001_add_resumes_to_xeno_turns.rb
-- db/migrate/20260805000002_add_transcript_deferred_to_xeno_turns.rb
-- db/migrate/20260805000003_create_xeno_dedups.rb
-- db/migrate/20260805000004_add_kind_to_xeno_turns.rb
-- db/migrate/20260805000005_add_state_to_xeno_sessions.rb
-- db/migrate/20260806000001_move_transcript_support_tables_to_ruby_llm.rb
+- db/migrate/20260808000001_create_ruby_llm_tables.rb
+- db/migrate/20260808000002_create_xeno_tables.rb
+- docs/configuration.md
 - docs/runtime.md
 - exe/xeno
 - lib/generators/xeno/install/install_generator.rb

data/db/migrate/20260804000001_create_xeno_llm_tables.rb

@@ -1,70 +0,0 @@
-# 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/20260805000001_add_resumes_to_xeno_turns.rb

@@ -1,8 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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