anima-core 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9517757f2c4fdb8b19d204a154d3badd3c3b8fb456dffaf03236b2d7c065378d
-  data.tar.gz: a0d26e0b27fd1d2df0c46c3a4bbad822ac3517d1d02b41a6bdd49195de64e71f
+  metadata.gz: e3b4a76568897bb6c9d465151e61f6dd889c42c33b71dcf0c019ae561143b2e4
+  data.tar.gz: 44acf306c750f33b3bb006c7be209ec80924521f61a89d2e863179672f33751b
 SHA512:
-  metadata.gz: d150e5f97a3a2055c66cfaa773c7bd1dd33354b869fe38d6fa25b2b47352c76cec0c222f44aa4eb7e7e65b61098b7531e61522a01e6dd1d722ee9224c7759aea
-  data.tar.gz: 0f9ef56323a4598ed8dc3dca79e6ec9cf1e63ea9dff8751612cd32691aa0968e629144b4f7c47150cd9c9861f3d74e323c852433e1aa066732bb10fc8db235fc
+  metadata.gz: bb66a71439efafa605eb7e6124269e82a0183c3d133d7e63658a1bdbe1c4f6adc9a4bf3303fb4bc724337319434eded5de40e9134c456ecbb3bb4508500b9370
+  data.tar.gz: b06ae76628e9abd1a76832703bc1769f24ea206c39c86b5fc1ef3bcfe9a59cfe87db222042aa7ea277714d18c3fb9c7c460769974fd75edd3b1f00923560e756

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+### Added
+- Real-time event broadcasting via `Event::Broadcasting` concern — `after_create_commit` and `after_update_commit` callbacks broadcast decorated payloads with database ID and action type to the session's ActionCable stream (#91)
+- TUI `MessageStore` ID-indexed updates — events with `action: "update"` replace existing entries in-place (O(1) lookup) without changing display order
+- `CountEventTokensJob` triggers broadcast — uses `update!` so token count updates push to connected clients in real time
+- Connection status constants in `CableClient` — replaces magic strings with named constants for protocol message types
+
+### Changed
+- Connection status indicator simplified — emoji-only `🟢` for normal state, descriptive text only for abnormal states (#80)
+- `STATUS_STYLES` structure simplified from `{label, fg, bg}` to `{label, color}` (#80)
+- `ActionCableBridge` removed — broadcasting moved from EventBus subscriber to AR callbacks, eliminating the timing gap where events were broadcast before persistence
+- `SessionChannel` history includes event IDs for client-side correlation
+
+### Fixed
+- TUI showed empty chat on reconnect — message store was cleared _after_ history arrived because `confirm_subscription` comes after `transmit` in Action Cable protocol; now clears on "subscribing" before history (#82)
+
 ## [0.2.1] - 2026-03-13
 
 ### Added

data/README.md

@@ -130,37 +130,13 @@ Updates: `gem update anima-core` — next launch runs pending migrations automat
 
 ### Authentication Setup
 
-Anima uses your Claude Pro/Max subscription for API access. You need a setup-token from Claude Code CLI.
+Anima uses your Claude Pro/Max subscription for API access. You need a setup-token from [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code).
 
-**1. Get a setup-token:**
+1. Run `claude setup-token` in a terminal to get your token
+2. In the TUI, press `Ctrl+a → a` to open the token setup popup
+3. Paste the token and press Enter — Anima validates it against the Anthropic API and saves it to encrypted credentials
 
-```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.
+The popup also activates automatically when Anima detects a missing or invalid token. If the token expires, repeat the process with a new one.
 
 ### Three Layers (mirroring biology)
 
@@ -186,7 +162,7 @@ Five event types form the agent's nervous system:
 
 Events flow through two channels:
 1. **In-process** — Rails Structured Event Reporter (local subscribers like Persister)
-2. **Over the wire** — Action Cable WebSocket (the ActionCableBridge subscriber forwards events to connected TUI clients)
+2. **Over the wire** — Action Cable WebSocket (`Event::Broadcasting` callbacks push to connected TUI clients)
 
 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.
 

data/app/channels/session_channel.rb

@@ -14,19 +14,25 @@ class SessionChannel < ApplicationCable::Channel
   MAX_LIST_LIMIT = 50
 
   # Subscribes the client to the session-specific stream.
-  # Rejects the subscription if no valid session_id is provided.
-  # Transmits the current view_mode and chat history to the subscribing client.
+  # When a valid session_id is provided, subscribes to that session.
+  # When omitted or zero, resolves to the most recent session (creating
+  # one if none exist) — this is the CQRS-compliant path where the
+  # server owns session resolution instead of a REST endpoint.
   #
-  # @param params [Hash] must include :session_id (positive integer)
+  # Always transmits a session_changed signal so the client learns
+  # the authoritative session ID, followed by view_mode and history.
+  #
+  # @param params [Hash] optional :session_id (positive integer)
   def subscribed
-    @current_session_id = params[:session_id].to_i
-    if @current_session_id > 0
-      stream_from stream_name
-      transmit_view_mode
-      transmit_history
-    else
-      reject
-    end
+    @current_session_id = resolve_session_id
+    stream_from stream_name
+
+    session = Session.find_by(id: @current_session_id)
+    return unless session
+
+    transmit_session_changed(session)
+    transmit_view_mode(session)
+    transmit_history(session)
   end
 
   # Receives messages from clients and broadcasts them to all session subscribers.
@@ -37,14 +43,43 @@ class SessionChannel < ApplicationCable::Channel
   end
 
   # Processes user input: persists the message and enqueues LLM processing.
+  # When the session is actively processing an agent request, the message
+  # is queued as "pending" and picked up after the current loop completes.
   #
   # @param data [Hash] must include "content" with the user's message text
   def speak(data)
     content = data["content"].to_s.strip
-    return if content.empty? || !Session.exists?(@current_session_id)
+    return if content.empty?
+
+    session = Session.find_by(id: @current_session_id)
+    return unless session
 
-    Events::Bus.emit(Events::UserMessage.new(content: content, session_id: @current_session_id))
-    AgentRequestJob.perform_later(@current_session_id)
+    if session.processing?
+      Events::Bus.emit(Events::UserMessage.new(content: content, session_id: @current_session_id, status: Event::PENDING_STATUS))
+    else
+      Events::Bus.emit(Events::UserMessage.new(content: content, session_id: @current_session_id))
+      AgentRequestJob.perform_later(@current_session_id)
+    end
+  end
+
+  # Recalls the most recent pending message for editing. Deletes the
+  # pending event and broadcasts the recall so all clients remove it.
+  #
+  # @param data [Hash] must include "event_id" (positive integer)
+  def recall_pending(data)
+    event_id = data["event_id"].to_i
+    return if event_id <= 0
+
+    event = Event.find_by(
+      id: event_id,
+      session_id: @current_session_id,
+      event_type: "user_message",
+      status: Event::PENDING_STATUS
+    )
+    return unless event
+
+    event.destroy!
+    ActionCable.server.broadcast(stream_name, {"action" => "user_message_recalled", "event_id" => event_id})
   end
 
   # Returns recent sessions with metadata for session picker UI.
@@ -86,6 +121,23 @@ class SessionChannel < ApplicationCable::Channel
     transmit_error("Session not found")
   end
 
+  # Validates and saves an Anthropic subscription token to encrypted credentials.
+  # Format-validated and API-validated before storage. The token never enters the
+  # LLM context window — it flows directly from WebSocket to encrypted credentials.
+  #
+  # @param data [Hash] must include "token" (Anthropic subscription token string)
+  def save_token(data)
+    token = data["token"].to_s.strip
+
+    Providers::Anthropic.validate_token_format!(token)
+    Providers::Anthropic.validate_token_api!(token)
+    write_anthropic_token(token)
+
+    transmit({"action" => "token_saved"})
+  rescue Providers::Anthropic::TokenFormatError, Providers::Anthropic::AuthenticationError => error
+    transmit({"action" => "token_error", "message" => error.message})
+  end
+
   # Changes the session's view mode and re-broadcasts the viewport.
   # All clients on the session receive the mode change and fresh history.
   #
@@ -109,6 +161,33 @@ class SessionChannel < ApplicationCable::Channel
     "session_#{@current_session_id}"
   end
 
+  # Resolves the session to subscribe to. Uses the client-provided ID
+  # when valid, otherwise falls back to the most recent session or
+  # creates a new one.
+  #
+  # @return [Integer] resolved session ID
+  def resolve_session_id
+    id = params[:session_id].to_i
+    return id if id > 0
+
+    (Session.recent(1).first || Session.create!).id
+  end
+
+  # Transmits session metadata as a session_changed signal.
+  # Used on initial subscription and after session switches so the
+  # client can handle both paths with a single code path.
+  #
+  # @param session [Session] the session to announce
+  # @return [void]
+  def transmit_session_changed(session)
+    transmit({
+      "action" => "session_changed",
+      "session_id" => session.id,
+      "message_count" => session.events.llm_messages.count,
+      "view_mode" => session.view_mode
+    })
+  end
+
   # Switches the channel to a different session: stops current stream,
   # updates the session reference, starts the new stream, and sends
   # a session_changed signal followed by chat history.
@@ -116,23 +195,18 @@ class SessionChannel < ApplicationCable::Channel
     stop_all_streams
     @current_session_id = new_id
     stream_from stream_name
+
     session = Session.find(new_id)
-    transmit({
-      "action" => "session_changed",
-      "session_id" => new_id,
-      "message_count" => session.events.llm_messages.count,
-      "view_mode" => session.view_mode
-    })
-    transmit_history
+    transmit_session_changed(session)
+    transmit_history(session)
   end
 
   # Transmits the current view_mode so the TUI initializes correctly.
   # Sends `{action: "view_mode", view_mode: <mode>}` to the subscribing client.
+  #
+  # @param session [Session] the session whose view_mode to transmit
   # @return [void]
-  def transmit_view_mode
-    session = Session.find_by(id: @current_session_id)
-    return unless session
-
+  def transmit_view_mode(session)
     transmit({"action" => "view_mode", "view_mode" => session.view_mode})
   end
 
@@ -142,10 +216,9 @@ class SessionChannel < ApplicationCable::Channel
   # the transmitted payload. Tool events are included so the TUI can
   # reconstruct tool call counters on reconnect.
   # In debug mode, prepends the assembled system prompt as a special block.
-  def transmit_history
-    session = Session.find_by(id: @current_session_id)
-    return unless session
-
+  #
+  # @param session [Session] the session whose history to transmit
+  def transmit_history(session)
     transmit_system_prompt(session) if session.view_mode == "debug"
 
     session.viewport_events.each do |event|
@@ -166,8 +239,16 @@ class SessionChannel < ApplicationCable::Channel
     end
   end
 
+  # Decorates an event for transmission to clients. Merges the event's
+  # database ID and structured decorator output into the payload.
+  # Used by {#transmit_history} and {#broadcast_viewport} for historical
+  # and viewport re-broadcast — live broadcasts use {Event::Broadcasting}.
+  #
+  # @param event [Event] persisted event record
+  # @param mode [String] view mode for decoration (default: "basic")
+  # @return [Hash] payload with "id" and optional "rendered" key
   def decorate_event_payload(event, mode = "basic")
-    payload = event.payload
+    payload = event.payload.merge("id" => event.id)
     decorator = EventDecorator.for(event)
     return payload unless decorator
 
@@ -212,6 +293,27 @@ class SessionChannel < ApplicationCable::Channel
     }
   end
 
+  # Merges the Anthropic subscription token into encrypted credentials,
+  # preserving existing keys (e.g. secret_key_base).
+  #
+  # @param token [String] validated Anthropic subscription token
+  # @return [void]
+  def write_anthropic_token(token)
+    creds = Rails.application.credentials
+    existing = begin
+      YAML.safe_load(creds.read) || {}
+    rescue ActiveSupport::EncryptedFile::MissingContentError
+      {}
+    end
+    existing["anthropic"] ||= {}
+    existing["anthropic"]["subscription_token"] = token
+    creds.write(existing.to_yaml)
+    # Rails memoizes the decrypted config in @config. Without clearing it,
+    # subsequent credential reads return stale data. No public API exists
+    # for cache invalidation as of Rails 8.1.
+    creds.instance_variable_set(:@config, nil)
+  end
+
   def transmit_error(message)
     transmit({"action" => "error", "message" => message})
   end

data/app/decorators/user_message_decorator.rb

@@ -3,22 +3,33 @@
 # Decorates user_message events for display in the TUI.
 # Basic mode returns role and content. Verbose mode adds a timestamp.
 # Debug mode adds token count (exact when counted, estimated when not).
+# Pending messages include `status: "pending"` so the TUI renders them
+# with a visual indicator (dimmed, clock icon).
 class UserMessageDecorator < EventDecorator
   # @return [Hash] structured user message data
-  #   `{role: :user, content: String}`
+  #   `{role: :user, content: String}` or with `status: "pending"` when queued
   def render_basic
-    {role: :user, content: content}
+    base = {role: :user, content: content}
+    base[:status] = "pending" if pending?
+    base
   end
 
   # @return [Hash] structured user message with nanosecond timestamp
-  #   `{role: :user, content: String, timestamp: Integer|nil}`
   def render_verbose
-    {role: :user, content: content, timestamp: timestamp}
+    base = {role: :user, content: content, timestamp: timestamp}
+    base[:status] = "pending" if pending?
+    base
   end
 
   # @return [Hash] verbose output plus token count for debugging
-  #   `{role: :user, content: String, timestamp: Integer|nil, tokens: Integer, estimated: Boolean}`
   def render_debug
     render_verbose.merge(token_info)
   end
+
+  private
+
+  # @return [Boolean] true when this message is queued but not yet sent to LLM
+  def pending?
+    payload["status"] == Event::PENDING_STATUS
+  end
 end

data/app/jobs/agent_request_job.rb

@@ -26,23 +26,52 @@ class AgentRequestJob < ApplicationJob
 
   discard_on ActiveRecord::RecordNotFound
   discard_on Providers::Anthropic::AuthenticationError do |job, error|
+    session_id = job.arguments.first
+    # Persistent system message for the event log
     Events::Bus.emit(Events::SystemMessage.new(
       content: "Authentication failed: #{error.message}",
-      session_id: job.arguments.first
+      session_id: session_id
     ))
+    # Transient signal to trigger TUI token setup popup (not persisted)
+    ActionCable.server.broadcast(
+      "session_#{session_id}",
+      {"action" => "authentication_required", "message" => error.message}
+    )
   end
 
   # @param session_id [Integer] ID of the session to process
   def perform(session_id)
     session = Session.find(session_id)
+
+    # Atomic: only one job processes a session at a time. If another job
+    # is already running, this one exits — the running job will pick up
+    # any pending messages after its current loop completes.
+    return unless claim_processing(session_id)
+
     agent_loop = AgentLoop.new(session: session)
-    agent_loop.run
+    loop do
+      agent_loop.run
+      promoted = session.promote_pending_messages!
+      break if promoted == 0
+    end
   ensure
+    release_processing(session_id)
     agent_loop&.finalize
   end
 
   private
 
+  # Sets the session's processing flag atomically. Returns true if this
+  # job claimed the lock, false if another job already holds it.
+  def claim_processing(session_id)
+    Session.where(id: session_id, processing: false).update_all(processing: true) == 1
+  end
+
+  # Clears the processing flag so the session can accept new jobs.
+  def release_processing(session_id)
+    Session.where(id: session_id).update_all(processing: false)
+  end
+
   # Emits a system message before each retry so the user sees
   # "retrying..." instead of nothing.
   def retry_job(options = {})

data/app/jobs/count_event_tokens_job.rb

@@ -12,7 +12,7 @@ class CountEventTokensJob < ApplicationJob
   # @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
+    return if already_counted?(event)
 
     provider = Providers::Anthropic.new
     messages = [{role: event.api_role, content: event.payload["content"].to_s}]
@@ -22,7 +22,18 @@ class CountEventTokensJob < ApplicationJob
       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)
+    # Guard against parallel jobs: reload and re-check before writing.
+    # Uses update! (not update_all) so {Event::Broadcasting} after_update_commit
+    # broadcasts the updated token count to connected clients.
+    event.reload
+    return if already_counted?(event)
+
+    event.update!(token_count: token_count)
+  end
+
+  private
+
+  def already_counted?(event)
+    event.token_count > 0
   end
 end

data/app/models/concerns/event/broadcasting.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Broadcasts Event records to connected WebSocket clients via ActionCable.
+# Follows the Turbo Streams pattern: events are broadcast on both create
+# and update, with an action type so clients can distinguish append from
+# replace operations.
+#
+# Each broadcast includes the Event's database ID, enabling clients to
+# maintain an ID-indexed store for efficient in-place updates (e.g. when
+# token counts arrive asynchronously from {CountEventTokensJob}).
+#
+# @example Create broadcast payload
+#   {
+#     "type" => "user_message", "content" => "hello", ...,
+#     "id" => 42, "action" => "create",
+#     "rendered" => { "basic" => { "role" => "user", "content" => "hello" } }
+#   }
+#
+# @example Update broadcast payload (e.g. token count arrives)
+#   {
+#     "type" => "user_message", "content" => "hello", ...,
+#     "id" => 42, "action" => "update",
+#     "rendered" => { "debug" => { "role" => "user", "content" => "hello", "tokens" => 15 } }
+#   }
+module Event::Broadcasting
+  extend ActiveSupport::Concern
+
+  ACTION_CREATE = "create"
+  ACTION_UPDATE = "update"
+
+  included do
+    after_create_commit :broadcast_create
+    after_update_commit :broadcast_update
+  end
+
+  private
+
+  def broadcast_create
+    broadcast_event(action: ACTION_CREATE)
+  end
+
+  def broadcast_update
+    broadcast_event(action: ACTION_UPDATE)
+  end
+
+  # Decorates the event for the session's current view mode and broadcasts
+  # the payload to the session's ActionCable stream.
+  #
+  # @param action [String] ACTION_CREATE or ACTION_UPDATE — tells clients how to handle the event
+  def broadcast_event(action:)
+    return unless session_id
+
+    mode = Session.where(id: session_id).pick(:view_mode) || "basic"
+    decorator = EventDecorator.for(self)
+    broadcast_payload = payload.merge("id" => id, "action" => action)
+
+    if decorator
+      broadcast_payload["rendered"] = {mode => decorator.render(mode)}
+    end
+
+    ActionCable.server.broadcast("session_#{session_id}", broadcast_payload)
+  end
+end

data/app/models/event.rb

@@ -16,9 +16,12 @@
 # @!attribute tool_use_id
 #   @return [String, nil] Anthropic-assigned ID correlating tool_call and tool_response
 class Event < ApplicationRecord
+  include Event::Broadcasting
+
   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
+  PENDING_STATUS = "pending"
 
   ROLE_MAP = {"user_message" => "user", "agent_message" => "assistant"}.freeze
 
@@ -43,6 +46,17 @@ class Event < ApplicationRecord
   #   @return [ActiveRecord::Relation]
   scope :context_events, -> { where(event_type: CONTEXT_TYPES) }
 
+  # @!method self.pending
+  #   User messages queued during active agent processing, not yet sent to LLM.
+  #   @return [ActiveRecord::Relation]
+  scope :pending, -> { where(status: PENDING_STATUS) }
+
+  # @!method self.deliverable
+  #   Events eligible for LLM context (excludes pending messages).
+  #   NULL status means delivered/processed — the only excluded value is "pending".
+  #   @return [ActiveRecord::Relation]
+  scope :deliverable, -> { where(status: nil) }
+
   # Maps event_type to the Anthropic Messages API role.
   # @return [String] "user" or "assistant"
   def api_role
@@ -59,6 +73,11 @@ class Event < ApplicationRecord
     event_type.in?(CONTEXT_TYPES)
   end
 
+  # @return [Boolean] true if this is a pending message not yet sent to the LLM
+  def pending?
+    status == PENDING_STATUS
+  end
+
   # Heuristic token estimate: ~4 bytes per token for English prose.
   # Tool events are estimated from the full payload JSON since tool_input
   # and tool metadata contribute to token count. Messages use content only.

data/app/models/session.rb

@@ -28,12 +28,17 @@ class Session < ApplicationRecord
   # is exhausted. Events are full-size or excluded entirely.
   #
   # @param token_budget [Integer] maximum tokens to include (positive)
+  # @param include_pending [Boolean] whether to include pending messages (true for
+  #   display, false for LLM context assembly)
   # @return [Array<Event>] chronologically ordered
-  def viewport_events(token_budget: DEFAULT_TOKEN_BUDGET)
+  def viewport_events(token_budget: DEFAULT_TOKEN_BUDGET, include_pending: true)
+    scope = events.context_events
+    scope = scope.deliverable unless include_pending
+
     selected = []
     remaining = token_budget
 
-    events.context_events.reorder(id: :desc).each do |event|
+    scope.reorder(id: :desc).each do |event|
       cost = (event.token_count > 0) ? event.token_count : estimate_tokens(event)
       break if cost > remaining && selected.any?
 
@@ -58,11 +63,26 @@ class Session < ApplicationRecord
   # 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.
+  # Pending messages are excluded — they haven't been delivered yet.
   #
   # @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)
-    assemble_messages(viewport_events(token_budget: token_budget))
+    assemble_messages(viewport_events(token_budget: token_budget, include_pending: false))
+  end
+
+  # Promotes all pending user messages to delivered status so they
+  # appear in the next LLM context. Triggers broadcast_update for
+  # each event so connected clients refresh the pending indicator.
+  #
+  # @return [Integer] number of promoted messages
+  def promote_pending_messages!
+    promoted = 0
+    events.where(event_type: "user_message", status: Event::PENDING_STATUS).find_each do |event|
+      event.update!(status: nil, payload: event.payload.except("status"))
+      promoted += 1
+    end
+    promoted
   end
 
   private

data/config/initializers/event_subscribers.rb

@@ -7,5 +7,4 @@ Rails.application.config.after_initialize do
   # Global persister handles events from all sessions (brain server, background jobs).
   # Skipped in test — specs manage their own persisters for isolation.
   Events::Bus.subscribe(Events::Subscribers::Persister.new) unless Rails.env.test?
-  Events::Bus.subscribe(Events::Subscribers::ActionCableBridge.instance)
 end

data/config/routes.rb

@@ -3,10 +3,4 @@
 Rails.application.routes.draw do
   mount ActionCable.server => "/cable"
   get "up", to: "rails/health#show", as: :rails_health_check
-
-  namespace :api do
-    resources :sessions, only: [:create] do
-      get :current, on: :collection
-    end
-  end
 end

data/db/migrate/20260313010000_add_status_to_events.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddStatusToEvents < ActiveRecord::Migration[8.1]
+  def change
+    add_column :events, :status, :string
+    add_index :events, [:session_id, :status], name: "index_events_on_session_id_and_status"
+  end
+end

data/db/migrate/20260313020000_add_processing_to_sessions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddProcessingToSessions < ActiveRecord::Migration[8.1]
+  def change
+    add_column :sessions, :processing, :boolean, default: false, null: false
+  end
+end

data/lib/agent_loop.rb

@@ -87,11 +87,14 @@ class AgentLoop
   private
 
   # Builds the default tool registry with all available tools.
-  # @return [Tools::Registry] registry with Bash and WebGet tools
+  # @return [Tools::Registry] registry with all available tools
   def build_tool_registry
     registry = Tools::Registry.new(context: {shell_session: @shell_session})
-    registry.register(Tools::WebGet)
     registry.register(Tools::Bash)
+    registry.register(Tools::Read)
+    registry.register(Tools::Write)
+    registry.register(Tools::Edit)
+    registry.register(Tools::WebGet)
     registry
   end
 end