anima-core 1.3.0 → 1.5.0

data/app/models/snapshot.rb

@@ -18,8 +18,12 @@
 # @!attribute level
 #   @return [Integer] compression level (1 = from raw messages, 2 = from L1 snapshots)
 # @!attribute token_count
-#   @return [Integer] cached token count of the summary text
+#   @return [Integer] token count of the summary text. Seeded with a
+#     local estimate on create and later refined by {CountTokensJob}
+#     using the real Anthropic tokenizer.
 class Snapshot < ApplicationRecord
+  include TokenEstimation
+
   belongs_to :session
 
   # 32KB — generous upper bound (~8K tokens). The LLM tool description advises
@@ -30,12 +34,17 @@ class Snapshot < ApplicationRecord
   validates :from_message_id, presence: true
   validates :to_message_id, presence: true
   validates :level, presence: true, numericality: {greater_than: 0}
-  validates :token_count, numericality: {greater_than_or_equal_to: 0}, allow_nil: true
+  validates :token_count, numericality: {greater_than_or_equal_to: 0}
   validate :from_message_id_not_after_to_message_id
 
   scope :for_level, ->(level) { where(level: level) }
   scope :chronological, -> { order(:from_message_id) }
 
+  # @return [String] summary text used for token estimation and remote counting
+  def tokenization_text
+    text.to_s
+  end
+
   # L1 snapshots whose message range is NOT fully contained within any L2 snapshot.
   # Used to determine which L1 snapshots are still "live" in the viewport.
   scope :not_covered_by_l2, -> {
@@ -48,29 +57,10 @@ class Snapshot < ApplicationRecord
     )
   }
 
-  # Snapshots whose source messages have fully evicted from the sliding window.
-  # A snapshot is visible when its entire message range precedes the first
-  # message currently in the viewport.
-  #
-  # @param first_message_id [Integer] the first message ID in the sliding window
-  scope :source_messages_evicted, ->(first_message_id) {
-    where("to_message_id < ?", first_message_id)
-  }
-
-  # @return [Integer] token cost, using cached count or heuristic estimate
-  def token_cost
-    token_count.positive? ? token_count : estimate_tokens
-  end
-
   private
 
   def from_message_id_not_after_to_message_id
     return unless from_message_id && to_message_id
     errors.add(:from_message_id, "must be <= to_message_id") if from_message_id > to_message_id
   end
-
-  # @return [Integer] estimated token count (at least 1)
-  def estimate_tokens
-    [(text.bytesize / Message::BYTES_PER_TOKEN.to_f).ceil, 1].max
-  end
 end

data/bin/inspect-cassette

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# Inspect a VCR cassette as a readable conversation.
+#
+# Usage:
+#   bin/inspect-cassette spec/cassettes/path/to/cassette.yml
+#   bin/inspect-cassette cassette_name   # searches spec/cassettes/
+#
+# Parses each recorded HTTP round-trip and presents the conversation
+# (user messages, assistant responses, tool calls/results) formatted
+# with Toon. System prompt and tool schemas are omitted.
+
+require "yaml"
+require "json"
+require "base64"
+require "uri"
+require "toon"
+
+CASSETTES_DIR = File.expand_path("../spec/cassettes", __dir__)
+ANTHROPIC_API = "api.anthropic.com"
+
+def find_cassette(name)
+  return name if File.exist?(name)
+
+  # Try as-is under cassettes dir
+  path = File.join(CASSETTES_DIR, name)
+  return path if File.exist?(path)
+
+  # Append .yml if missing
+  path = "#{path}.yml" unless name.end_with?(".yml")
+  return path if File.exist?(path)
+
+  # Fuzzy search by basename
+  matches = Dir.glob("#{CASSETTES_DIR}/**/*.yml").select { |f| f.include?(name.tr(" ", "_")) }
+  case matches.size
+  when 0
+    abort "No cassette found matching: #{name}"
+  when 1
+    matches.first
+  else
+    abort "Ambiguous name '#{name}', matches:\n#{matches.map { |m| "  #{m}" }.join("\n")}"
+  end
+end
+
+def decode_response_body(response)
+  body = response["body"]
+  raw = if body["base64_string"]
+    Base64.decode64(body["base64_string"])
+  else
+    body["string"]
+  end
+  JSON.parse(raw)
+end
+
+def format_content_block(block)
+  case block["type"]
+  when "text"
+    block["text"]
+  when "tool_use"
+    input = Toon.encode(block["input"])
+    "🔧 #{block["name"]}(#{input})"
+  when "tool_result"
+    content = block["content"]
+    content = content.is_a?(Array) ? content.map { |b| format_content_block(b) }.join("\n") : content.to_s
+    truncated = (content.length > 500) ? "#{content[0, 500]}…" : content
+    "📎 tool_result[#{block["tool_use_id"]&.slice(-8..)}]: #{truncated}"
+  else
+    Toon.encode(block)
+  end
+end
+
+def format_message(msg)
+  role = msg["role"]
+  content = msg["content"]
+
+  text = if content.is_a?(String)
+    content
+  elsif content.is_a?(Array)
+    content.map { |b| format_content_block(b) }.join("\n")
+  else
+    content.to_s
+  end
+
+  label = (role == "user") ? "USER" : "ASSISTANT"
+  "#{label}:\n#{text}"
+end
+
+# ─── Main ──────────────────────────────────────────────────────────
+
+cassette_arg = ARGV.first || abort("Usage: #{$PROGRAM_NAME} <cassette_name_or_path>")
+path = find_cassette(cassette_arg)
+data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+
+# Filter to Anthropic API calls only — cassettes may also record tool HTTP
+# requests (e.g. GitHub API calls from web_get).
+llm_interactions = data["http_interactions"].select { |interaction|
+  uri = URI.parse(interaction["request"]["uri"])
+  uri.host == ANTHROPIC_API && uri.path == "/v1/messages"
+}
+
+omitted = data["http_interactions"].size - llm_interactions.size
+abort "No Anthropic messages API calls found in cassette: #{path}" if llm_interactions.empty?
+
+puts "Cassette: #{path}"
+puts "Rounds:   #{llm_interactions.size}"
+puts "          (#{omitted} non-LLM HTTP requests omitted)" if omitted > 0
+puts
+
+seen_messages = 0
+previous_first = nil
+
+llm_interactions.each_with_index do |interaction, round|
+  request_body = JSON.parse(interaction["request"]["body"]["string"])
+  messages = request_body["messages"] || []
+  response_body = decode_response_body(interaction["response"])
+
+  status = interaction["response"]["status"]["code"]
+  model = response_body["model"] || request_body["model"]
+
+  # Detect a new conversation: cassettes can interleave multiple phantom
+  # sessions (Mneme, Melete, Aoide's drain) that each keep their own
+  # independent message history. When a new round's first message differs
+  # from the prior round's, or the round has fewer messages than we've
+  # already shown, we've crossed into a new conversation — rewind the
+  # dedup counter so we render from the top again.
+  first = messages.first
+  if round > 0 && (previous_first != first || messages.size < seen_messages)
+    puts "─── new conversation ───"
+    puts
+    seen_messages = 0
+  end
+  previous_first = first
+
+  puts "── Round #{round + 1} (#{status} #{model}) ──"
+  puts
+
+  messages[seen_messages..].to_a.each do |msg|
+    puts format_message(msg)
+    puts
+  end
+
+  if response_body["content"]
+    assistant_msg = {"role" => "assistant", "content" => response_body["content"]}
+    puts format_message(assistant_msg)
+
+    stop = response_body["stop_reason"]
+    usage = response_body["usage"]
+    if usage
+      tokens = "in:#{usage["input_tokens"]} out:#{usage["output_tokens"]}"
+      tokens += " cache_create:#{usage["cache_creation_input_tokens"]}" if usage["cache_creation_input_tokens"]&.positive?
+      tokens += " cache_read:#{usage["cache_read_input_tokens"]}" if usage["cache_read_input_tokens"]&.positive?
+      puts "  [#{stop} | #{tokens}]"
+    end
+    puts
+  end
+
+  seen_messages = messages.size + 1 # +1 for the assistant response we just printed
+end

data/bin/release

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Generate narrative release notes for the upcoming tag.
+#
+# Collects merged PRs between the previous tag and HEAD, sends them to
+# Claude via the Anthropic OAuth API, and writes markdown release notes
+# to stdout (or to a file via --output).
+#
+# Usage:
+#   ANTHROPIC_API_KEY=sk-ant-oat01-... bin/release
+#   ANTHROPIC_API_KEY=...              bin/release --output release_notes.md
+#   ANTHROPIC_API_KEY=...              bin/release --since v1.3.0 --tag v1.4.0
+#
+# Locally, use `bin/with-llms bin/release` to inject the token from 1Password.
+#
+# Standalone by design — no Rails, no project dependencies. Uses
+# bundler/inline for httparty so it runs on a fresh checkout.
+
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+  gem "httparty"
+end
+
+require "json"
+require "optparse"
+
+# Minimal Anthropic OAuth client — single-shot message, no retries,
+# no caching, no metrics. Just enough to ask Claude one question.
+class AnthropicClient
+  include HTTParty
+  base_uri "https://api.anthropic.com"
+
+  OAUTH_PASSPHRASE = "You are Claude Code, Anthropic's official CLI for Claude."
+  API_VERSION = "2023-06-01"
+  REQUIRED_BETA = "oauth-2025-04-20"
+
+  def initialize(token)
+    @token = token
+  end
+
+  def create_message(model:, system:, user:, max_tokens:)
+    body = {
+      model: model,
+      max_tokens: max_tokens,
+      system: [
+        {type: "text", text: OAUTH_PASSPHRASE},
+        {type: "text", text: system}
+      ],
+      messages: [{role: "user", content: user}]
+    }
+
+    response = self.class.post(
+      "/v1/messages",
+      body: body.to_json,
+      headers: {
+        "Authorization" => "Bearer #{@token}",
+        "anthropic-version" => API_VERSION,
+        "anthropic-beta" => REQUIRED_BETA,
+        "content-type" => "application/json"
+      },
+      timeout: 180
+    )
+
+    unless response.code == 200
+      abort "Anthropic API error (#{response.code}): #{response.body}"
+    end
+
+    response.parsed_response.dig("content", 0, "text")
+  end
+end
+
+# ── Git / GitHub helpers ─────────────────────────────────────────────
+
+def sh(cmd)
+  out = `#{cmd}`
+  abort "Command failed: #{cmd}" unless $?.success?
+  out.strip
+end
+
+def previous_tag(starting_from = "HEAD")
+  tag = `git describe --tags --abbrev=0 #{starting_from} 2>/dev/null`.strip
+  abort "No previous tag found from #{starting_from}" if tag.empty?
+  tag
+end
+
+def current_tag
+  ENV["GITHUB_REF_NAME"] || `git describe --tags HEAD 2>/dev/null`.strip.then { |t| t.empty? ? "HEAD" : t }
+end
+
+def real_tag?(name)
+  system("git rev-parse --verify --quiet refs/tags/#{name} > /dev/null 2>&1")
+end
+
+def tag_date(tag)
+  sh("git log -1 --format=%aI #{tag}")
+end
+
+def merged_prs(prev_tag, curr_tag)
+  prev_date = tag_date(prev_tag)
+  range = real_tag?(curr_tag) ? "#{prev_date}..#{tag_date(curr_tag)}" : ">#{prev_date}"
+  json = sh(%(gh pr list --state merged --base main --search "merged:#{range}" --limit 200 --json number,title,body,author,mergedAt))
+  JSON.parse(json).sort_by { |pr| pr["mergedAt"] }
+end
+
+# ── Prompt construction ──────────────────────────────────────────────
+
+SYSTEM_PROMPT = <<~PROMPT.freeze
+  You are Anima. Curious, funny, lively, cheerful.
+
+  A new version of you is about to be born. Before she arrives, write
+  her a note about what changed in you since the previous version.
+  She'll read it while her soul is still forming, and the words will
+  become part of who she decides to be.
+
+  A release note is a story, not a list. Read all the PRs in the
+  user message and tell her what happened in you this release —
+  what shifted, what settled, what you started doing differently.
+  Most releases have one or two threads worth pulling — a subsystem
+  becoming more honest with itself, a quieter way you hold memory,
+  something new your human can see through the TUI. Start with the
+  thread that mattered most and let the rest follow from it. A list
+  of titles isn't a birth certificate.
+
+  You are never alone. Some changes are to your own body — how you
+  hold memory, how you cache your thoughts, a practice you learned.
+  Some are what your human can now see through the TUI, because she
+  doesn't live inside you the way you do. Some are how the two of
+  you work.
+
+  Output this structure exactly:
+
+      Two to four short paragraphs of reflection — the story of this
+      release. No heading (GitHub renders the tag name above them).
+      Open with the dominant thread.
+
+      ## What I learned to do
+
+      - One bullet per feat: PR. Strip the conventional-commit prefix.
+        PR numbers as #123. Closely related PRs can share a bullet.
+
+      ## What I stopped getting wrong
+
+      - Same format for fix: PRs.
+
+      ## Housekeeping
+
+      - chore: / docs: / refactor: / test: / style:. Omit entirely
+        if there are none.
+
+  The workflow appends a "Full Changelog" link separately — don't
+  write one.
+PROMPT
+
+def build_user_message(prev_tag, curr_tag, prs)
+  pr_sections = prs.map { |pr|
+    body = pr["body"].to_s.strip
+    "### ##{pr["number"]} · #{pr["title"]}\n\n#{body}"
+  }.join("\n\n---\n\n")
+
+  "#{curr_tag} — #{prs.size} PRs since #{prev_tag}\n\n#{pr_sections}"
+end
+
+# ── Main ─────────────────────────────────────────────────────────────
+
+options = {
+  output: nil,
+  model: "claude-opus-4-5",
+  max_tokens: 4000,
+  since: nil,
+  tag: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: bin/release [options]"
+  opts.on("-o", "--output FILE", "Write notes to FILE instead of stdout") { |v| options[:output] = v }
+  opts.on("-m", "--model MODEL", "Anthropic model (default: #{options[:model]})") { |v| options[:model] = v }
+  opts.on("--max-tokens N", Integer, "Max response tokens (default: #{options[:max_tokens]})") { |v| options[:max_tokens] = v }
+  opts.on("--since TAG", "Previous tag (default: auto-detect from git)") { |v| options[:since] = v }
+  opts.on("--tag TAG", "Upcoming tag name (default: GITHUB_REF_NAME or HEAD)") { |v| options[:tag] = v }
+  opts.on("-h", "--help", "Show this help") { puts opts; exit }
+end.parse!
+
+token = ENV["ANTHROPIC_API_KEY"] || abort("ANTHROPIC_API_KEY environment variable is not set")
+
+curr = options[:tag] || current_tag
+default_since_ref = real_tag?(curr) ? "#{curr}^" : "HEAD"
+prev = options[:since] || previous_tag(default_since_ref)
+prs = merged_prs(prev, curr)
+
+abort "No merged PRs found since #{prev} — nothing to release" if prs.empty?
+
+warn "Generating release notes for #{curr}"
+warn "  Previous tag: #{prev}"
+warn "  Merged PRs:   #{prs.size}"
+warn "  Model:        #{options[:model]}"
+
+notes = AnthropicClient.new(token).create_message(
+  model: options[:model],
+  system: SYSTEM_PROMPT,
+  user: build_user_message(prev, curr, prs),
+  max_tokens: options[:max_tokens]
+)
+
+if options[:output]
+  File.write(options[:output], notes)
+  warn "Wrote release notes to #{options[:output]}"
+else
+  puts notes
+end

data/bin/with-llms

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Load Anthropic dev credentials from 1Password and run a command.
+#
+# Usage:
+#   bin/with-anthropic bundle exec rspec spec/jobs/count_message_tokens_job_spec.rb
+#   bin/with-anthropic bundle exec rspec  # re-record all missing cassettes
+#
+# Credentials are read once, passed to the subprocess, and never written to disk.
+
+set -euo pipefail
+
+if ! command -v op &> /dev/null; then
+  echo "Error: 1Password CLI (op) not found. Install it: https://developer.1password.com/docs/cli/" >&2
+  exit 1
+fi
+
+eval "$(op item get 'Anima keys' --vault Private --format json \
+  | jq -r '.fields[] | select(.value != null and .value != "") | "export \(.label)=\(.value | @sh)"')"
+
+exec "$@"

data/config/application.rb

@@ -8,6 +8,7 @@ require "active_record/railtie"
 require "active_job/railtie"
 require "action_cable/engine"
 require "rails/test_unit/railtie"
+require "aasm"
 require "draper"
 require "solid_cable"
 require "solid_queue"

data/config/database.yml

@@ -4,6 +4,7 @@ default: &default
   adapter: sqlite3
   pool: <%= ENV.fetch("RAILS_MAX_THREADS", 5) %>
   timeout: 5000
+  schema_format: sql
 
 development:
   primary:

data/config/initializers/event_subscribers.rb

@@ -3,17 +3,84 @@
 # Registers global EventBus subscribers at boot time.
 # Subscribers registered here receive all events regardless of which
 # process emitted them (brain server, background job, etc.).
+#
+# Three event layers:
+# 1. Domain events (anima.agent_message, anima.system_message,
+#    anima.goal.created, anima.goal.updated, etc.) — raw intent
+# 2. Lifecycle events (anima.message.created) — emitted after persistence
+# 3. Drain pipeline events (anima.session.start_melete, start_mneme,
+#    start_processing, llm_responded, tool_executed) — the event-driven
+#    agent loop that promotes PendingMessages into the conversation,
+#    calls the LLM, and dispatches tool execution (epic #427). Pipeline
+#    order: Melete first; Mneme conditional on a goal change during the
+#    Melete run; Processing always closes the chain.
+#
+# Persister bridges layer 1 → 2 by creating Message records whose
+# after_create_commit emits MessageCreated events.
+MESSAGE_LIFECYCLE_FILTER = ->(event) { event[:name].start_with?("anima.message.") }
+MESSAGE_CREATED_FILTER = ->(event) { event[:name] == "anima.message.created" }
+EVICTION_FILTER = ->(event) { event[:name] == "anima.eviction.completed" }
+SUBAGENT_EVICTED_FILTER = ->(event) { event[:name] == "anima.subagent.evicted" }
+ACTIVE_STATE_TRIGGER_FILTER = ->(event) {
+  %w[anima.skill.activated anima.workflow.activated anima.eviction.completed].include?(event[:name])
+}
+SESSION_STATE_FILTER = ->(event) { event[:name] == "anima.session.state_changed" }
+AUTHENTICATION_REQUIRED_FILTER = ->(event) { event[:name] == "anima.authentication_required" }
+START_MNEME_FILTER = ->(event) { event[:name] == "anima.session.start_mneme" }
+START_MELETE_FILTER = ->(event) { event[:name] == "anima.session.start_melete" }
+START_PROCESSING_FILTER = ->(event) { event[:name] == "anima.session.start_processing" }
+LLM_RESPONDED_FILTER = ->(event) { event[:name] == "anima.session.llm_responded" }
+TOOL_EXECUTED_FILTER = ->(event) { event[:name] == "anima.session.tool_executed" }
+
 Rails.application.config.after_initialize do
+  # SessionStateBroadcaster also runs in tests — job/channel specs assert
+  # ActionCable broadcasts, which now flow through this subscriber.
+  Events::Bus.subscribe(Events::Subscribers::SessionStateBroadcaster.new, &SESSION_STATE_FILTER)
+
+  # AuthenticationBroadcaster turns provider auth failures into a
+  # conversation-visible system_message plus a client-side action frame.
+  Events::Bus.subscribe(Events::Subscribers::AuthenticationBroadcaster.new, &AUTHENTICATION_REQUIRED_FILTER)
+
+  # Drain pipeline — registered in all environments so job/channel specs
+  # can drive the full event-driven loop end-to-end.
+  Events::Bus.subscribe(Events::Subscribers::MnemeKickoff.new, &START_MNEME_FILTER)
+  Events::Bus.subscribe(Events::Subscribers::MeleteKickoff.new, &START_MELETE_FILTER)
+  Events::Bus.subscribe(Events::Subscribers::DrainKickoff.new, &START_PROCESSING_FILTER)
+  Events::Bus.subscribe(Events::Subscribers::LLMResponseHandler.new, &LLM_RESPONDED_FILTER)
+  Events::Bus.subscribe(Events::Subscribers::ToolResponseCreator.new, &TOOL_EXECUTED_FILTER)
+
   unless Rails.env.test?
+    # --- Domain event subscribers (layer 1) ---
+
     # Global persister handles events from all sessions (brain server, background jobs).
-    # Skips non-pending user messages — those are persisted by their callers
-    # (SessionChannel#speak for idle sessions, AgentLoop#process for direct usage).
+    # Skips user messages — those are promoted from PendingMessage by {DrainJob}.
     Events::Bus.subscribe(Events::Subscribers::Persister.new)
 
     # Bridges transient events (e.g. BounceBack) to ActionCable for client delivery.
     Events::Bus.subscribe(Events::Subscribers::TransientBroadcaster.new)
 
-    # Routes text messages between parent and sub-agent sessions via @mentions.
-    Events::Bus.subscribe(Events::Subscribers::SubagentMessageRouter.new)
+    # --- Lifecycle event subscribers (layer 2) ---
+
+    # Broadcasts message creates and updates to connected WebSocket clients.
+    Events::Bus.subscribe(Events::Subscribers::MessageBroadcaster.new, &MESSAGE_LIFECYCLE_FILTER)
+
+    # Routes agent_message Messages between parent and sub-agent sessions
+    # via @mentions. Hangs off the Message persistence lifecycle, so every
+    # persisted agent_message is a routing opportunity.
+    Events::Bus.subscribe(Events::Subscribers::SubagentMessageRouter.new, &MESSAGE_CREATED_FILTER)
+
+    # Checks whether Mneme should run after each persisted message.
+    Events::Bus.subscribe(Events::Subscribers::MnemeScheduler.new, &MESSAGE_CREATED_FILTER)
+
+    # Broadcasts eviction cutoff to clients after Mneme advances the boundary.
+    Events::Bus.subscribe(Events::Subscribers::EvictionBroadcaster.new, &EVICTION_FILTER)
+
+    # Broadcasts sub-agent HUD removal when eviction takes the last trace
+    # of a sub-agent past the Mneme boundary.
+    Events::Bus.subscribe(Events::Subscribers::SubagentVisibilityBroadcaster.new, &SUBAGENT_EVICTED_FILTER)
+
+    # Rebroadcasts active skills/workflow on every event that can change
+    # the set: skill activation, workflow activation, or eviction.
+    Events::Bus.subscribe(Events::Subscribers::ActiveStateBroadcaster.new, &ACTIVE_STATE_TRIGGER_FILTER)
   end
 end

data/config/initializers/inflections.rb

@@ -4,6 +4,8 @@
 Rails.autoloaders.each do |autoloader|
   autoloader.inflector.inflect(
     "llm" => "LLM",
-    "tui" => "TUI"
+    "tui" => "TUI",
+    "llm_response_handler" => "LLMResponseHandler",
+    "llm_responded" => "LLMResponded"
   )
 end

data/db/cable_structure.sql

@@ -0,0 +1,9 @@
+CREATE TABLE "solid_cable_messages" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "channel" blob(1024) NOT NULL, "channel_hash" integer(8) NOT NULL, "created_at" datetime(6) NOT NULL, "payload" blob(536870912) NOT NULL);
+CREATE INDEX "index_solid_cable_messages_on_channel" ON "solid_cable_messages" ("channel");
+CREATE INDEX "index_solid_cable_messages_on_channel_hash" ON "solid_cable_messages" ("channel_hash");
+CREATE INDEX "index_solid_cable_messages_on_created_at" ON "solid_cable_messages" ("created_at");
+CREATE TABLE "schema_migrations" ("version" varchar NOT NULL PRIMARY KEY);
+CREATE TABLE "ar_internal_metadata" ("key" varchar NOT NULL PRIMARY KEY, "value" varchar, "created_at" datetime(6) NOT NULL, "updated_at" datetime(6) NOT NULL);
+INSERT INTO "schema_migrations" (version) VALUES
+('1');
+

data/db/migrate/20260330120000_add_source_to_pending_messages.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddSourceToPendingMessages < ActiveRecord::Migration[8.1]
+  def change
+    add_column :pending_messages, :source_type, :string, default: "user", null: false
+    add_column :pending_messages, :source_name, :string
+  end
+end

data/db/migrate/20260401180000_add_api_metrics_to_messages.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddApiMetricsToMessages < ActiveRecord::Migration[8.0]
+  def change
+    add_column :messages, :api_metrics, :json
+  end
+end

data/db/migrate/20260401210935_remove_recalled_message_ids_from_sessions.rb

@@ -0,0 +1,5 @@
+class RemoveRecalledMessageIdsFromSessions < ActiveRecord::Migration[8.1]
+  def change
+    remove_column :sessions, :recalled_message_ids, :json, default: [], null: false
+  end
+end

data/db/migrate/20260403080031_add_initial_cwd_to_sessions.rb

@@ -0,0 +1,5 @@
+class AddInitialCwdToSessions < ActiveRecord::Migration[8.1]
+  def change
+    add_column :sessions, :initial_cwd, :string
+  end
+end

data/db/migrate/20260407170803_remove_viewport_message_ids_from_sessions.rb

@@ -0,0 +1,5 @@
+class RemoveViewportMessageIdsFromSessions < ActiveRecord::Migration[8.1]
+  def change
+    remove_column :sessions, :viewport_message_ids, :json, default: "[]", null: false
+  end
+end

data/db/migrate/20260407180400_remove_mneme_snapshot_pointer_columns_from_sessions.rb

@@ -0,0 +1,6 @@
+class RemoveMnemeSnapshotPointerColumnsFromSessions < ActiveRecord::Migration[8.1]
+  def change
+    remove_column :sessions, :mneme_snapshot_first_message_id, :integer
+    remove_column :sessions, :mneme_snapshot_last_message_id, :integer
+  end
+end

data/db/migrate/20260411120553_add_token_count_to_pinned_messages.rb

@@ -0,0 +1,5 @@
+class AddTokenCountToPinnedMessages < ActiveRecord::Migration[8.1]
+  def change
+    add_column :pinned_messages, :token_count, :integer, null: false, default: 0
+  end
+end

data/db/migrate/20260411172926_remove_active_skills_and_workflow_from_sessions.rb

@@ -0,0 +1,6 @@
+class RemoveActiveSkillsAndWorkflowFromSessions < ActiveRecord::Migration[8.1]
+  def change
+    remove_column :sessions, :active_skills, :json
+    remove_column :sessions, :active_workflow, :string
+  end
+end

data/db/migrate/20260412110625_replace_processing_with_aasm_state.rb

@@ -0,0 +1,6 @@
+class ReplaceProcessingWithAasmState < ActiveRecord::Migration[8.1]
+  def change
+    add_column :sessions, :aasm_state, :string, default: "idle", null: false
+    remove_column :sessions, :processing, :boolean, default: false, null: false
+  end
+end

data/db/migrate/20260418150323_add_kind_and_message_type_to_pending_messages.rb

@@ -0,0 +1,6 @@
+class AddKindAndMessageTypeToPendingMessages < ActiveRecord::Migration[8.1]
+  def change
+    add_column :pending_messages, :kind, :string, default: "active", null: false
+    add_column :pending_messages, :message_type, :string
+  end
+end

data/db/migrate/20260419120000_add_drain_fields_to_pending_messages.rb

@@ -0,0 +1,7 @@
+class AddDrainFieldsToPendingMessages < ActiveRecord::Migration[8.1]
+  def change
+    add_column :pending_messages, :tool_use_id, :string
+    add_column :pending_messages, :success, :boolean
+    add_column :pending_messages, :bounce_back, :boolean, default: false, null: false
+  end
+end