anima-core 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1093dd7268e23c30a34d081b91ae453080aba47f5864ed285baf3a4d637ddabe
-  data.tar.gz: c75a06cca5222689a4b204846eca8843c1ac912608dec8a8b3898443f6219728
+  metadata.gz: 6f7039906ee15401ed13db1ceaa640b088540903b1f0b814463fe69d91f6fa02
+  data.tar.gz: dee3280a42efa74aa78b3499f8c6687a937287eda9099e2b7de09d4ccf761021
 SHA512:
-  metadata.gz: 2e5b40e05fdd0a193adf362d4eda84d83ddfe51f379b8ebb3cc17070af733371526632946ecd577756815d10bd410e919a3013a942821ccf1f4c9fea966bfbe8
-  data.tar.gz: b28b6f7e60478e06bedeb8a87a4ce682dd65a9111007626565af515518f614e682b18bd26adb59ba6aa3d9dd1bc5c468c605229c880b4da0ad3ccdd96257e76a
+  metadata.gz: 1ed4a8551e9ba05919e95a4879bf2366e9cd4986726ebe0ed5900007bd6d06a53639133be5a286d38e41a7f269db78b3575ff982c23d2b4096f804c3528b02a0
+  data.tar.gz: 65f6d5dbe475dd36af817a3f2eb88c6f6913604de6bfc9dd56775d18abf8e47e0269862e669a8f739ee57fa99a9aede77d343c692400a44a4e873d28ee482c7a

data/.reek.yml

@@ -0,0 +1,18 @@
+---
+detectors:
+  # YARD docs cover module/class documentation; no need for reek to duplicate
+  IrresponsibleModule:
+    enabled: false
+  # Constructor injection (provider: nil) triggers false positives
+  ControlParameter:
+    enabled: false
+  # Bang methods don't need safe counterparts in this codebase
+  MissingSafeMethod:
+    enabled: false
+  # Private helpers don't need instance state to be valid
+  UtilityFunction:
+    public_methods_only: true
+
+# TUI render methods receive (frame, tui) by design — RatatuiRuby convention
+exclude_paths:
+  - lib/tui

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+### Added
+- Session and event persistence to SQLite — conversations survive TUI restart
+- `Session` model — owns an ordered event stream
+- `Event` model — polymorphic type, JSON payload, auto-incrementing position
+- `Events::Subscribers::Persister` — writes all events to SQLite as they flow through the bus
+- TUI resumes last session on startup, `Ctrl+a > n` creates a new session
+- `anima tui` now runs pending migrations automatically on launch
+- Event system using Rails Structured Event Reporter (`Rails.event`)
+- Five event types: `system_message`, `user_message`, `agent_message`, `tool_call`, `tool_response`
+- `Events::Bus` — thin wrapper around `Rails.event` for emitting and subscribing to Anima events
+- `Events::Subscribers::MessageCollector` — in-memory subscriber that collects displayable messages
+- Chat screen refactored from raw array to event-driven architecture
+- TUI chat screen with LLM integration — in-memory message array, threaded API calls
+- Chat input with character validation, backspace, Enter to submit
+- Loading indicator — "Thinking" status bar mode, grayed-out input during LLM calls
+- New session command (`Ctrl+a > n`) clears conversation
+- Error handling — API failures displayed inline as chat messages
+- Anthropic API subscription token authentication
+- LLM client (raw HTTP to Anthropic API)
+- TUI scaffold with RatatuiRuby — tmux-style `Ctrl+a` command mode, sidebar, status bar
+- Headless Rails 8.1 app (API-only, no views/assets/Action Cable)
+- `anima install` command — creates ~/.anima/ tree, per-environment credentials, systemd user service
+- `anima start` command — runs db:prepare and boots Rails
+- SQLite databases, logs, tmp, and credentials stored in ~/.anima/
+- Environment validation (development, test, production)
+
 ## [0.0.1] - 2026-03-06
 
 - Initial gem scaffold with CI and RubyGems publishing

data/README.md

@@ -3,7 +3,7 @@
 **A soul engine for AI agents.**
 
 Ruby framework for building AI agents with desires, personality, and personal growth.
-Powered by [Rage](https://rage-rb.dev/).
+Headless Rails 8.1 app distributed as a gem, with a TUI-first interface via RatatuiRuby.
 
 ## The Problem
 
@@ -61,26 +61,110 @@ Existing RL techniques apply at the starting point, then we gradually expand int
 ## Architecture
 
 ```
-Anima Framework (Ruby, Rage-based)
+Anima Framework (Ruby, Rails 8.1 headless)
 ├── Thymos    — hormonal/desire system (stimulus → hormone vector)
 ├── Mneme     — semantic memory (QMD-style, emotional recall)
 ├── Psyche    — soul matrix (coefficient table, evolving through experience)
 └── Nous      — LLM integration (cortex, thinking, decision-making)
 ```
 
+### Tech Stack
+
+| Component | Technology |
+|-----------|-----------|
+| Framework | Rails 8.1 (headless — no web views, no asset pipeline) |
+| Database | SQLite (per environment, stored in `~/.anima/db/`) |
+| Event system | Rails Structured Event Reporter |
+| LLM integration | Raw HTTP to Anthropic API |
+| Interface | TUI via RatatuiRuby |
+| Distribution | RubyGems (`gem install anima-core`) |
+
+### Distribution Model
+
+Anima is a Rails app distributed as a gem, following Unix philosophy: immutable program separate from mutable data.
+
+```bash
+gem install anima-core       # Install the Rails app as a gem
+anima install                # Create ~/.anima/ directory structure
+anima start                  # Launch — code from gem, state from ~/.anima/
+```
+
+State directory (`~/.anima/`):
+```
+~/.anima/
+├── db/              # SQLite databases (production, development, test)
+├── config/
+│   ├── credentials/ # Rails encrypted credentials per environment
+│   └── anima.yml    # User configuration
+├── log/
+└── tmp/
+```
+
+Updates: `gem update anima-core` — next launch runs pending migrations automatically.
+
+### Authentication Setup
+
+Anima uses your Claude Pro/Max subscription for API access. You need a setup-token from Claude Code CLI.
+
+**1. Get a setup-token:**
+
+```bash
+claude setup-token
+```
+
+This requires [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and a Claude Pro or Max subscription.
+
+**2. Store the token in Anima credentials:**
+
+```bash
+cd $(gem contents anima-core | head -1 | xargs dirname | xargs dirname)
+bin/rails credentials:edit
+```
+
+Add your token:
+
+```yaml
+anthropic:
+  subscription_token: sk-ant-oat01-YOUR_TOKEN_HERE
+```
+
+**3. Verify the token works:**
+
+```bash
+bin/rails runner "Providers::Anthropic.validate!"
+```
+
+If the token expires or is revoked, repeat steps 1-2 with a new token.
+
 ### Three Layers (mirroring biology)
 
 1. **Endocrine system (Thymos)** — a lightweight background process. Reads recent events. Doesn't respond. Just updates hormone levels. Pure stimulus→response, like a biological gland.
 
-2. **Homeostasis** — persistent state (JSON/SQLite). Current hormone levels with decay functions. No intelligence, just state that changes over time.
+2. **Homeostasis** — persistent state (SQLite). Current hormone levels with decay functions. No intelligence, just state that changes over time.
 
 3. **Cortex (Nous)** — the main LLM. Reads hormone state transformed into **desire descriptions**. Not "longing: 87" but "you want to see them". The LLM should NOT see raw numbers — humans don't see cortisol levels, they feel anxiety.
 
 ### Event-Driven Design
 
-Built on [Rage](https://rage-rb.dev/) — a Ruby framework with fiber-based concurrency, native WebSockets, and a built-in event bus. The event bus maps directly to a nervous system: stimuli fire events, Thymos subscribers update hormone levels, Nous reacts to the resulting desires.
+Built on Rails Structured Event Reporter — a native Rails 8.1 feature for structured event emission with typed payloads, subscriber patterns, and block-scoped context tagging.
+
+Five event types form the agent's nervous system:
+
+| Event | Purpose |
+|-------|---------|
+| `system_message` | Internal notifications |
+| `user_message` | User input |
+| `agent_message` | LLM response |
+| `tool_call` | Tool invocation |
+| `tool_response` | Tool result |
+
+Events fire, subscribers react, state updates, the cortex (LLM) reads the resulting desire landscape. The system prompt is assembled separately for each LLM call — it is not an event.
+
+### Context as Viewport, Not Tape
 
-Single-process architecture: web server, background hormone ticks, WebSocket monitoring — all in one process, no Redis, no external workers.
+There is no linear chat history. There are only events attached to a session. The context window is a **viewport** — a sliding window over the event stream, assembled on demand for each LLM call within a configured token budget.
+
+POC uses a simple sliding window (newest events first, walk backwards until budget exhausted). Future versions will add multi-resolution compression with Draper decorators and associative recall from Mneme.
 
 ### Brain as Microservices on a Shared Event Bus
 
@@ -95,7 +179,7 @@ Event: "tool_call_failed"
   ├── Mneme subscriber: log failure context for future recall
   └── Psyche subscriber: update coefficient (this agent handles errors calmly → low frustration_gain)
 
-Event: "user_sent_message"  
+Event: "user_sent_message"
   │
   ├── Thymos subscriber: oxytocin += 5 (bonding signal)
   ├── Thymos subscriber: dopamine += 3 (engagement signal)
@@ -104,7 +188,17 @@ Event: "user_sent_message"
 
 Each subscriber is a microservice — independent, stateless, reacting to the same event bus. No orchestrator decides "now update frustration." The architecture IS the nervous system.
 
-This is why Rage's built-in event bus maps so naturally: `Rage.event_bus` IS the nervous system. Events fire, subscribers react, state updates, the cortex (LLM) reads the resulting desire landscape.
+### Plugin Architecture
+
+Both tools and feelings are distributed as gems on the event bus:
+
+```bash
+anima add anima-tools-filesystem
+anima add anima-tools-shell
+anima add anima-feelings-frustration
+```
+
+Tools provide MCP capabilities. Feelings are event subscribers that update hormonal state. Same mechanism, different namespace. In POC, tools are built-in; plugin extraction comes later.
 
 ### Semantic Memory (Mneme)
 
@@ -207,17 +301,38 @@ This single example demonstrates every core principle:
 
 ## Status
 
-Idea stage → early design. Architecture research underway (OpenClaw agent loop documented).
-First practical hormone (frustration) designed, ready for prototyping.
+POC stage. Gem scaffold with CI and RubyGems publishing exists. Building toward a working conversational agent with event-driven architecture.
+
+The hormonal system (Thymos, feelings, desires), semantic memory (Mneme), and soul matrix (Psyche) are designed but deferred — POC focuses on getting the core agent loop working first.
+
+## Development
+
+```bash
+git clone https://github.com/hoblin/anima.git
+cd anima
+bundle install
+bundle exec rspec
+```
+
+### Running the TUI
+
+The TUI requires a background job worker for async token counting (used by the sliding viewport). Start both in separate terminals:
+
+```bash
+# Terminal 1: Start Solid Queue worker
+RAILS_ENV=development bundle exec rake solid_queue:start
+
+# Terminal 2: Launch the TUI
+bundle exec anima tui
+```
+
+On first run, initialize the databases:
+
+```bash
+RAILS_ENV=development bundle exec rails db:migrate
+RAILS_ENV=development bundle exec rails db:schema:load:queue
+```
 
-## Next Steps
+## License
 
-- [ ] **MVP: Frustration hormone** — monitor tool calls, adjust thinking budget + inner voice injection
-- [ ] Research prior art in depth (affective computing, BDI architecture, virtual creature motivation)
-- [ ] Design initial coefficient matrix schema (Psyche)
-- [ ] Prototype Thymos: Rage event bus + JSON state + context injection into LLM thinking step
-- [ ] Experiment: hormone names vs abstract parameter names in LLM prompts
-- [ ] Set up Rage project skeleton with event bus
-- [ ] Design full event taxonomy (what events does the agent's "nervous system" react to?)
-- [ ] Build Mneme: semantic memory with emotional associations
-- [ ] Write blog post introducing the concept
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/Rakefile

@@ -7,4 +7,7 @@ RSpec::Core::RakeTask.new(:spec)
 
 require "standard/rake"
 
+require_relative "config/application"
+Rails.application.load_tasks
+
 task default: %i[spec standard]

data/app/jobs/application_job.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ApplicationJob < ActiveJob::Base
+end

data/app/jobs/count_event_tokens_job.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Counts tokens in an event's payload via the Anthropic API and
+# caches the result on the event record. Enqueued automatically
+# after each LLM event is created.
+class CountEventTokensJob < ApplicationJob
+  queue_as :default
+
+  retry_on Providers::Anthropic::Error, wait: :exponentially_longer, attempts: 3
+  discard_on ActiveRecord::RecordNotFound
+
+  # @param event_id [Integer] the Event record to count tokens for
+  def perform(event_id)
+    event = Event.find(event_id)
+    return if event.token_count > 0
+
+    provider = Providers::Anthropic.new
+    messages = [{role: event.api_role, content: event.payload["content"].to_s}]
+
+    token_count = provider.count_tokens(
+      model: LLM::Client::DEFAULT_MODEL,
+      messages: messages
+    )
+
+    # Atomic update: only write if still uncounted (avoids race with parallel jobs).
+    Event.where(id: event.id, token_count: 0).update_all(token_count: token_count)
+  end
+end

data/app/models/application_record.rb

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

data/app/models/event.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# A persisted record of something that happened during a session.
+# Events are the single source of truth for conversation history —
+# there is no separate chat log, only events attached to a session.
+#
+# @!attribute event_type
+#   @return [String] one of {TYPES}: system_message, user_message,
+#     agent_message, tool_call, tool_response
+# @!attribute payload
+#   @return [Hash] event-specific data (content, tool_name, tool_input, etc.)
+# @!attribute timestamp
+#   @return [Integer] nanoseconds since epoch (Process::CLOCK_REALTIME)
+# @!attribute token_count
+#   @return [Integer] cached token count for this event's payload (0 until counted)
+# @!attribute tool_use_id
+#   @return [String, nil] Anthropic-assigned ID correlating tool_call and tool_response
+class Event < ApplicationRecord
+  TYPES = %w[system_message user_message agent_message tool_call tool_response].freeze
+  LLM_TYPES = %w[user_message agent_message].freeze
+  CONTEXT_TYPES = %w[user_message agent_message tool_call tool_response].freeze
+
+  ROLE_MAP = {"user_message" => "user", "agent_message" => "assistant"}.freeze
+
+  belongs_to :session
+
+  validates :event_type, presence: true, inclusion: {in: TYPES}
+  validates :payload, presence: true
+  validates :timestamp, presence: true
+
+  after_create :schedule_token_count, if: :llm_message?
+
+  # @!method self.llm_messages
+  #   Events that represent conversation turns sent to the LLM API.
+  #   @return [ActiveRecord::Relation]
+  scope :llm_messages, -> { where(event_type: LLM_TYPES) }
+
+  # @!method self.context_events
+  #   Events included in the LLM context window (messages + tool interactions).
+  #   @return [ActiveRecord::Relation]
+  scope :context_events, -> { where(event_type: CONTEXT_TYPES) }
+
+  # Maps event_type to the Anthropic Messages API role.
+  # @return [String] "user" or "assistant"
+  def api_role
+    ROLE_MAP.fetch(event_type)
+  end
+
+  # @return [Boolean] true if this event represents an LLM conversation turn
+  def llm_message?
+    event_type.in?(LLM_TYPES)
+  end
+
+  # @return [Boolean] true if this event is part of the LLM context window
+  def context_event?
+    event_type.in?(CONTEXT_TYPES)
+  end
+
+  private
+
+  def schedule_token_count
+    CountEventTokensJob.perform_later(id)
+  end
+end

data/app/models/session.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# A conversation session — the fundamental unit of agent interaction.
+# Owns an ordered stream of {Event} records representing everything
+# that happened: user messages, agent responses, tool calls, etc.
+class Session < ApplicationRecord
+  # Claude Sonnet 4 context window minus system prompt reserve.
+  DEFAULT_TOKEN_BUDGET = 190_000
+
+  # Heuristic: average bytes per token for English prose.
+  BYTES_PER_TOKEN = 4
+
+  has_many :events, -> { order(:id) }, dependent: :destroy
+
+  # Builds the message array expected by the Anthropic Messages API.
+  # Includes user/agent messages and tool call/response events in
+  # Anthropic's wire format. Consecutive tool_call events are grouped
+  # into a single assistant message; consecutive tool_response events
+  # are grouped into a single user message with tool_result blocks.
+  #
+  # Walks events newest-first and includes them until the token budget
+  # is exhausted. Events are full-size or excluded entirely.
+  #
+  # @param token_budget [Integer] maximum tokens to include (positive)
+  # @return [Array<Hash>] Anthropic Messages API format
+  def messages_for_llm(token_budget: DEFAULT_TOKEN_BUDGET)
+    selected = []
+    remaining = token_budget
+
+    events.context_events.reorder(id: :desc).each do |event|
+      cost = (event.token_count > 0) ? event.token_count : estimate_tokens(event)
+      break if cost > remaining && selected.any?
+
+      selected << event
+      remaining -= cost
+    end
+
+    assemble_messages(selected.reverse)
+  end
+
+  private
+
+  # Converts a chronological list of events into Anthropic wire-format messages.
+  # Groups consecutive tool_call events into one assistant message and
+  # consecutive tool_response events into one user message.
+  #
+  # @param events [Array<Event>]
+  # @return [Array<Hash>]
+  def assemble_messages(events)
+    events.each_with_object([]) do |event, messages|
+      case event.event_type
+      when "user_message"
+        messages << {role: "user", content: event.payload["content"].to_s}
+      when "agent_message"
+        messages << {role: "assistant", content: event.payload["content"].to_s}
+      when "tool_call"
+        append_grouped_block(messages, "assistant", tool_use_block(event.payload))
+      when "tool_response"
+        append_grouped_block(messages, "user", tool_result_block(event.payload))
+      end
+    end
+  end
+
+  # Groups consecutive tool blocks into a single message of the given role.
+  def append_grouped_block(messages, role, block)
+    prev = messages.last
+    if prev&.dig(:role) == role && prev[:content].is_a?(Array)
+      prev[:content] << block
+    else
+      messages << {role: role, content: [block]}
+    end
+  end
+
+  def tool_use_block(payload)
+    {
+      type: "tool_use",
+      id: payload["tool_use_id"],
+      name: payload["tool_name"],
+      input: payload["tool_input"] || {}
+    }
+  end
+
+  def tool_result_block(payload)
+    {
+      type: "tool_result",
+      tool_use_id: payload["tool_use_id"],
+      content: payload["content"].to_s
+    }
+  end
+
+  # Rough estimate for events not yet counted by the background job.
+  # For tool events, estimates from the full payload since tool_input
+  # and tool metadata contribute to token count.
+  #
+  # @param event [Event]
+  # @return [Integer] at least 1
+  def estimate_tokens(event)
+    text = if event.event_type.in?(%w[tool_call tool_response])
+      event.payload.to_json
+    else
+      event.payload["content"].to_s
+    end
+    [(text.bytesize / BYTES_PER_TOKEN.to_f).ceil, 1].max
+  end
+end

data/config/application.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "boot"
+
+require "rails"
+require "active_model/railtie"
+require "active_record/railtie"
+require "active_job/railtie"
+require "rails/test_unit/railtie"
+require "solid_queue"
+
+Bundler.require(*Rails.groups) if ENV.key?("BUNDLE_GEMFILE")
+
+module Anima
+  class Application < Rails::Application
+    config.load_defaults 8.1
+    config.api_only = true
+
+    config.autoload_lib(ignore: %w[anima])
+    config.active_job.queue_adapter = :solid_queue
+    config.solid_queue.connects_to = {database: {writing: :queue}}
+
+    anima_home = Pathname.new(File.expand_path("~/.anima"))
+
+    config.paths["log"] = [anima_home.join("log", "#{Rails.env}.log").to_s]
+    config.paths["tmp"] = [anima_home.join("tmp").to_s]
+
+    config.credentials.content_path = anima_home.join("config/credentials/#{Rails.env}.yml.enc")
+    config.credentials.key_path = anima_home.join("config/credentials/#{Rails.env}.key")
+  end
+end

data/config/boot.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+gemfile = File.expand_path("../Gemfile", __dir__)
+
+if File.exist?(gemfile)
+  ENV["BUNDLE_GEMFILE"] ||= gemfile
+  require "bundler/setup"
+end

data/config/database.yml

@@ -0,0 +1,33 @@
+<% anima_home = File.expand_path("~/.anima") %>
+
+default: &default
+  adapter: sqlite3
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS", 5) %>
+  timeout: 5000
+
+development:
+  primary:
+    <<: *default
+    database: <%= File.join(anima_home, "db", "development.sqlite3") %>
+  queue:
+    <<: *default
+    database: <%= File.join(anima_home, "db", "development_queue.sqlite3") %>
+    migrations_paths: db/queue_migrate
+
+test:
+  primary:
+    <<: *default
+    database: <%= File.join(anima_home, "db", "test.sqlite3") %>
+  queue:
+    <<: *default
+    database: <%= File.join(anima_home, "db", "test_queue.sqlite3") %>
+    migrations_paths: db/queue_migrate
+
+production:
+  primary:
+    <<: *default
+    database: <%= File.join(anima_home, "db", "production.sqlite3") %>
+  queue:
+    <<: *default
+    database: <%= File.join(anima_home, "db", "production_queue.sqlite3") %>
+    migrations_paths: db/queue_migrate

data/config/environment.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "application"
+
+Rails.application.initialize!

data/config/environments/development.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Rails.application.configure do
+  config.enable_reloading = true
+  config.eager_load = false
+  config.consider_all_requests_local = true
+  config.active_support.deprecation = :log
+end

data/config/environments/production.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Rails.application.configure do
+  config.enable_reloading = false
+  config.eager_load = true
+  config.log_level = :info
+  config.active_support.deprecation = :notify
+end

data/config/environments/test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Rails.application.configure do
+  config.enable_reloading = false
+  config.eager_load = false
+  config.consider_all_requests_local = true
+  config.active_support.deprecation = :stderr
+  config.active_job.queue_adapter = :test
+end

data/config/initializers/inflections.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Zeitwerk inflections for acronym directories (e.g. lib/llm/ → LLM::)
+Rails.autoloaders.each do |autoloader|
+  autoloader.inflector.inflect(
+    "llm" => "LLM",
+    "tui" => "TUI"
+  )
+end

data/config/queue.yml

@@ -0,0 +1,18 @@
+default: &default
+  dispatchers:
+    - polling_interval: 1
+      batch_size: 500
+  workers:
+    - queues: "*"
+      threads: 3
+      processes: <%= ENV.fetch("JOB_CONCURRENCY", 1) %>
+      polling_interval: 0.1
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  <<: *default

data/config/recurring.yml

@@ -0,0 +1,15 @@
+# examples:
+#   periodic_cleanup:
+#     class: CleanSoftDeletedRecordsJob
+#     queue: background
+#     args: [ 1000, { batch_size: 500 } ]
+#     schedule: every hour
+#   periodic_cleanup_with_command:
+#     command: "SoftDeletedRecord.due.delete_all"
+#     priority: 2
+#     schedule: at 5am every day
+
+production:
+  clear_solid_queue_finished_jobs:
+    command: "SolidQueue::Job.clear_finished_in_batches(sleep_between_batches: 0.3)"
+    schedule: every hour at minute 12

data/config/routes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+end

data/db/migrate/20260308124202_create_sessions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class CreateSessions < ActiveRecord::Migration[8.1]
+  def change
+    create_table :sessions do |t|
+      t.timestamps
+    end
+  end
+end