omen 0.4.0 → 0.6.0

data/app/models/omen/instructions.rb

@@ -1,4 +1,4 @@
-# Everything Claude is told before a question: the prose, the schema, and the shape of a reply.
+# Everything Claude is told before a question: the prose, and the schema it may write against.
 class Omen::Instructions
   # The prose, kept beside this class so it reads as prose rather than as a string.
   PROSE = File.expand_path 'instructions.md', __dir__
@@ -13,28 +13,16 @@ class Omen::Instructions
   # The database function a distance in miles is measured with, created by the same task.
   MILES = 'omen_miles_between'
 
-  # The one shape a reply may take: both keys required, and no others admitted.
-  ANSWER = {
-    type: 'object', additionalProperties: false, required: %w[ sql note combine ],
-    properties: {
-      sql: { type: 'string',
-             description: 'The one PostgreSQL SELECT that answers the question, or ' \
-                          'empty to ask something first.', },
-      note: { type: 'string',
-              description: 'A sentence or two: what the query returns and any ' \
-                           'assumption made. If sql is empty, the question you ' \
-                           'need answered first.', },
-      combine: Omen::Combination::SCHEMA,
-    },
-  }
-
-  # @return [Hash] what a reply is constrained to, so that it always parses.
-  def self.output_config = { format_: { type: :json_schema, schema: ANSWER } }
-
   # Cached for an hour: the schema is thousands of tokens, and refining sends it again.
+  # @param reading [Omen::Reading] the one being answered, which says what it may read.
   # @return [Array<Hash>] the one system block of a request.
-  def self.block
-    [ { type: 'text', text: new.text, cache_control: { type: 'ephemeral', ttl: '1h' } } ]
+  def self.block(reading)
+    [ { type: 'text', text: new(reading).text, cache_control: { type: 'ephemeral', ttl: '1h' } } ]
+  end
+
+  # @param reading [Omen::Reading] the one being answered, which says what it may read.
+  def initialize(reading)
+    @reading = reading
   end
 
   # Today's date is said out loud because "last month" is Claude's to resolve, and it has no clock.
@@ -43,17 +31,20 @@ class Omen::Instructions
     format File.read(PROSE), today: Date.current.to_fs(:long), zone_fn: TIME_ZONE,
       today_fn: TODAY, miles_fn: MILES,
       schema: schema, types: types, readable: readable, refused: refused,
-      notes: Omen.config.notes
+      notes: @reading.notes
   end
 
 private
 
-  def schema = Omen::Schema.new.text
+  def schema = Omen::Schema.new(@reading.runs_as).text
 
+  # This gem's own tables are told apart by a type column too, and are hidden from the schema,
+  # so naming their subclasses here would say the one thing the schema is careful not to.
   def types
     Rails.application.eager_load!
     Omen.config.record.descendants.select(&:finder_needs_type_condition?)
-      .group_by(&:table_name).sort.map { |table, kinds| "- `#{table}`: #{named kinds}" }.join "\n"
+      .group_by(&:table_name).except(*Omen.tables).sort
+      .map { |table, kinds| "- `#{table}`: #{named kinds}" }.join "\n"
   end
 
   def named(kinds) = kinds.map(&:name).sort.map { |name| "`#{name}`" }.join ', '

data/app/models/omen/narrowed.rb

@@ -0,0 +1,35 @@
+# Extends Omen::Reading with the audience it is asked by: what that audience may read, and the
+# Postgres role that holds it there.
+module Omen::Narrowed extend ActiveSupport::Concern
+  included do
+    # What this kind of reading is held to, where a host declared one.
+    class_attribute :narrowing
+  end
+
+  class_methods do
+    # Declares what a reading of this kind may read, which db:omen:grant then writes.
+    # @param role [String] the Postgres role its statement runs as.
+    # @param by [Symbol] the column of the reading that says whose rows these are.
+    # @param own [Hash] every table it reads rows of, to what makes a row its own -- written
+    #   with `%{owner}`, which stands for whoever the reading names.
+    # @param whole [Array<String>] the tables it reads whole, nobody's in particular.
+    # @param except [Regexp, nil] the columns of those it may not read.
+    # @return [void]
+    def narrows(role, by:, own:, whole: [], except: nil)
+      self.narrowing = Omen::Narrowing.new role: role, by: by, own: own, whole: whole,
+        except: except
+    end
+
+    # @return [Array<Omen::Narrowing>] every one a host has declared, over every kind of reading.
+    def narrowings
+      Rails.application.eager_load!
+      descendants.filter_map(&:narrowing).uniq
+    end
+  end
+
+  # @return [String] Postgres role the statement runs as, which holds what it may read.
+  def runs_as = narrowing&.role || Omen.config.narrow_role
+
+  # @return [Hash] what is set before the statement, for a row policy of the host's to read.
+  def settings = narrowing ? { narrowing.setting => self[narrowing.by] } : {}
+end

data/app/models/omen/query.rb

@@ -4,8 +4,10 @@ class Omen::Query
   UTC = { oid: 1114, name: 'timestamp', format: 0 }
 
   # @param sql [String] the statement Claude answered with.
-  def initialize(sql)
+  # @param reading [Omen::Reading] the one it answers, which says what it may read.
+  def initialize(sql, reading)
     @sql = sql
+    @reading = reading
   end
 
   # A savepoint, so a statement Postgres rejects leaves the surrounding transaction usable.
@@ -23,10 +25,12 @@ private
   def record = Omen.config.record
 
   def run(connection)
-    answered = Omen::Role.new(connection).around { executed connection }
+    answered = role(connection).around { executed connection }
     { result: answered.to_a.first(cap), provenance: Omen::Column.of(answered, connection) }
   end
 
+  def role(connection) = Omen::Role.new connection, @reading.runs_as, @reading.settings
+
   def executed(connection)
     raw = connection.raw_connection
     result = raw.exec_params capped, []

data/app/models/omen/reading.rb

@@ -1,6 +1,6 @@
 # A thread of questions somebody asks Claude about the data this app holds.
 class Omen::Reading < Omen.config.record
-  include Omen::Asked, Omen::Executed, Omen::Stated
+  include Omen::Asked, Omen::Executed, Omen::Narrowed, Omen::Stated
 
   has_many :questions, -> { order :id }, dependent: :destroy
 
@@ -15,6 +15,9 @@ class Omen::Reading < Omen.config.record
 
   # @return [String] the default representation (used in views).
   def to_s = questions.first&.text.to_s.truncate 80
+
+  # @return [String] the host's notes about its data, as this reading's asker is told them.
+  def notes = Omen.config.notes
 end
 
 ActiveSupport.run_load_hooks :omen_reading, Omen::Reading

data/app/models/omen/refusal.rb

@@ -0,0 +1,43 @@
+# What a Postgres role may not read: the tables it holds no SELECT on, and the columns of the
+# rest that a column-level grant left out. Each is asked of a role the database has to have, so
+# a name it does not know refuses nothing here -- the statement is what says the app is
+# misconfigured, in the one message that case is owed.
+class Omen::Refusal
+  # Every column of the app the role is refused. Asked of the column rather than of the table,
+  # since a grant naming columns leaves the table itself ungranted and every one of these true.
+  COLUMNS = <<~SQL
+    SELECT c.relname, a.attname FROM pg_roles r, pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
+     WHERE r.rolname = ? AND n.nspname = 'public' AND c.relkind = 'r'
+       AND NOT has_column_privilege(r.oid, c.oid, a.attnum, 'SELECT')
+  SQL
+
+  # Every table of it none of whose columns the role may read, this gem's own included.
+  TABLES = <<~SQL
+    SELECT c.relname FROM pg_roles r, pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE r.rolname = ? AND n.nspname = 'public' AND c.relkind = 'r'
+       AND NOT EXISTS (SELECT 1 FROM pg_attribute a
+                        WHERE a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
+                          AND has_column_privilege(r.oid, c.oid, a.attnum, 'SELECT'))
+  SQL
+
+  # @param role [String] the Postgres role a statement will run as.
+  def initialize(role)
+    @role = role
+  end
+
+  # @return [Array<String>] the tables it may not read.
+  def tables = Omen.tables | asked(TABLES).flatten
+
+  # @return [Array<Array<String>>] the table and column of each one it may not read.
+  def columns = asked COLUMNS
+
+private
+
+  def asked(sql)
+    named = Omen.config.record.sanitize_sql_array [ sql, @role ]
+    Omen.config.record.with_connection { |connection| connection.select_rows named }
+  end
+end

data/app/models/omen/reply.rb

@@ -0,0 +1,20 @@
+# The one shape a reply may take, which is what makes every reply parse.
+class Omen::Reply
+  # Both keys required, and no others admitted.
+  SHAPE = {
+    type: 'object', additionalProperties: false, required: %w[ sql note combine ],
+    properties: {
+      sql: { type: 'string',
+             description: 'The one PostgreSQL SELECT that answers the question, or ' \
+                          'empty to ask something first.', },
+      note: { type: 'string',
+              description: 'A sentence or two: what the query returns and any ' \
+                           'assumption made. If sql is empty, the question you ' \
+                           'need answered first.', },
+      combine: Omen::Combination::SCHEMA,
+    },
+  }
+
+  # @return [Hash] what a reply is constrained to, so that it always parses.
+  def self.output_config = { format_: { type: :json_schema, schema: SHAPE } }
+end

data/app/models/omen/role.rb

@@ -8,8 +8,12 @@ class Omen::Role
                   'the read-only role a statement runs as.'
 
   # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] the one to switch.
-  def initialize(connection)
+  # @param name [String] the role to enter.
+  # @param settings [Hash] what to set first, which a row policy may read to scope the rows.
+  def initialize(connection, name, settings = {})
     @connection = connection
+    @name = name
+    @settings = settings
   end
 
   # Given up before anything of ours runs; a statement Postgres refused rolls it back instead.
@@ -21,9 +25,17 @@ class Omen::Role
 
 private
 
+  # Set before the role rather than after it, so a setting is written by the role that holds
+  # the rows rather than by the one that is about to be refused them.
   def enter
-    @connection.execute "SET LOCAL ROLE #{@connection.quote_table_name Omen.config.narrow_role}"
+    @settings.each { |name, value| set name, value }
+    @connection.execute "SET LOCAL ROLE #{@connection.quote_table_name @name}"
   rescue ActiveRecord::StatementInvalid
     raise Unavailable, MISCONFIGURED
   end
+
+  # Through set_config, since a name carrying a dot is not one SET LOCAL can be given quoted.
+  def set(name, value)
+    @connection.raw_connection.exec_params 'SELECT set_config($1, $2, true)', [ name, value.to_s ]
+  end
 end

data/app/models/omen/schema.rb

@@ -1,22 +1,43 @@
-# What Claude writes its SQL against: the app's own schema, less the tables a reading is kept in.
+# What Claude writes its SQL against: the app's own schema, less what the role may not read.
 class Omen::Schema
   # A plain index is a note about speed; a unique one is a fact about the rows, so it stays.
   HINT = /^\s*t\.index (?!.*unique: true).*\n/
 
-  # @return [String] the schema, without this feature's own tables, their keys or their enum.
-  def text = without_orphan_enums hidden.inject(source) { |left, name| without_table left, name }
+  # @param role [String] the Postgres role the statement will run as.
+  def initialize(role)
+    @role = role
+  end
+
+  # @return [String] the schema, without a table or a column the role is refused, and without
+  #   an enum or a foreign key left behind by one.
+  def text = without_orphan_enums without_columns without_tables source
 
 private
 
   def source = File.read(Omen.config.schema).gsub HINT, ''
 
-  def hidden = Omen.tables
+  def refusal = Omen::Refusal.new @role
+
+  def without_tables(text)
+    refusal.tables.inject(text) { |left, name| without_table left, name }
+  end
+
+  def without_columns(text)
+    refusal.columns.inject(text) { |left, (table, column)| without_column left, table, column }
+  end
 
   def without_table(text, name)
     text.gsub(/^  create_table "#{name}".*?\n  end\n\n?/m, '')
       .gsub(/^  add_foreign_key ("#{name}"|"\w+", "#{name}").*\n/, '')
   end
 
+  def without_column(text, table, column)
+    text.sub(/^  create_table "#{table}".*?\n  end\n/m) do |block|
+      block.gsub(/^    t\.\w+ "#{column}".*\n/, '')
+        .gsub(/^    t\.index \[[^\]]*"#{column}".*\n/, '')
+    end
+  end
+
   def without_orphan_enums(text)
     # Derived rather than named, so a type the cut tables shared with another survives
     text.gsub(/^  create_enum "(\w+)".*\n/) do |line|

data/db/migrate/20260912000000_add_type_to_omen_readings.rb

@@ -0,0 +1,6 @@
+class AddTypeToOmenReadings < ActiveRecord::Migration[8.1]
+  def change
+    add_column :omen_readings, :type, :string
+    add_index :omen_readings, :type
+  end
+end

data/lib/generators/omen/install/install_generator.rb

@@ -2,7 +2,7 @@ require 'rails/generators/active_record'
 
 module Omen
   module Generators
-    # Everything installing this gem writes into a host: three migrations and one initializer.
+    # Everything installing this gem writes into a host: its migrations and one initializer.
     # Not the roles or the database function, which are a rake task, because a copy of those
     # would drift from what the gem goes on to expect and nothing would detect it.
     class InstallGenerator < Rails::Generators::Base

data/lib/generators/omen/install/templates/omen.rb

@@ -23,6 +23,10 @@ Omen.configure do |config|
   # there are more without counting them.
   # config.maximum_rows = 100
 
+  # How many turns of a thread travel with the next question. A thread nobody clears would
+  # otherwise carry its whole history into each one, and be charged for it again each time.
+  # config.remembered = 20
+
   # Left unset, the Anthropic SDK resolves ANTHROPIC_API_KEY and its own wider chain.
   # config.api_key = Rails.application.credentials.dig :anthropic, :api_key
 

data/lib/generators/omen/pages/USAGE

@@ -0,0 +1,25 @@
+Description:
+    Writes the pages a reading is seen through, into this app: a name for one, a controller,
+    three views and a route. All of it is this app's from the moment it lands -- rename it,
+    restyle it, throw it away.
+
+    The controller descends from ApplicationController, so whatever guards the rest of this
+    app guards the one page that will run SQL across all of it.
+
+    Where Turbo is installed, the show page subscribes to the reading and an initializer
+    declaring broadcasts_refreshes is written beside it, so an answer arrives on its own
+    rather than waiting for a reload.
+
+Example:
+    bin/rails generate omen:pages
+
+        creates  app/models/inquiry.rb
+                 app/controllers/inquiries_controller.rb
+                 app/views/inquiries/index.html.erb
+                 app/views/inquiries/show.html.erb
+                 app/views/inquiries/_form.html.erb
+          route  resources :inquiries
+
+    bin/rails generate omen:pages Consultation
+
+        the same, under a name of this app's own choosing.

data/lib/generators/omen/pages/pages_generator.rb

@@ -0,0 +1,70 @@
+require 'rails/generators/named_base'
+
+module Omen
+  module Generators
+    # The least a host needs to see a reading at all: a name for one, a controller, three views
+    # and a route. All of it lands in the host and is the host's from then on -- Omen has no
+    # opinion about what a reading looks like. It has one about what it takes to draw one, and
+    # that is the part nobody should have to learn before their first question.
+    class PagesGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('templates', __dir__)
+
+      # One per action that renders, and the form the other two share.
+      VIEWS = %w[ index show _form ]
+
+      # Its own file rather than a line in the initializer, so that deleting these pages deletes
+      # everything they asked for. Declared on Omen::Reading and not on the name below it,
+      # because a question reaches its reading through the association: what a job is handed,
+      # and so what it broadcasts as, is always the gem's own class.
+      BROADCASTS = <<~RUBY
+        # Refreshes every page showing a reading when its answer lands, which is long after the
+        # response that asked for it went out. Written by `rails g omen:pages`, and safe to
+        # delete along with the pages it was written for.
+        ActiveSupport.on_load(:omen_reading) { broadcasts_refreshes }
+      RUBY
+
+      remove_argument :name
+      argument :name, type: :string, default: 'Inquiry',
+        desc: 'What this app calls a reading of its own'
+
+      # Raised on rather than written over: a host that already calls something Inquiry would
+      # otherwise find these pages standing where its own class used to, and quietly. The name
+      # is the argument, so `omen:pages Consultation` is the whole of the fix.
+      # @return [void]
+      def check_collisions = class_collisions class_name, "#{plural_name.camelize}Controller"
+
+      # @return [void]
+      def copy_model = template 'model.rb', "app/models/#{singular_name}.rb"
+
+      # @return [void]
+      def copy_controller
+        template 'controller.rb', "app/controllers/#{plural_name}_controller.rb"
+      end
+
+      # @return [void]
+      def copy_views
+        VIEWS.each do |view|
+          template "#{view}.html.erb", "app/views/#{plural_name}/#{view}.html.erb"
+        end
+      end
+
+      # @return [void]
+      def add_route = route "resources :#{plural_name}"
+
+      # @return [void]
+      def declare_broadcasts
+        return unless turbo?
+
+        create_file 'config/initializers/omen_broadcasts.rb', BROADCASTS
+      end
+
+    private
+
+      # Asked once, here, rather than by the pages at every render: a host either has it or has
+      # no use for the line. Without one the pages still work, they only stop arriving on their
+      # own, and a reload is what shows an answer.
+      # @return [Boolean] whether this app has a Turbo to broadcast a refresh over.
+      def turbo? = Object.const_defined? :Turbo
+    end
+  end
+end

data/lib/generators/omen/pages/templates/_form.html.erb.tt

@@ -0,0 +1,8 @@
+<%%= form_with model: <%= singular_name %> do |form| %>
+  <%% if <%= singular_name %>.errors.any? %>
+    <p style="color: red"><%%= <%= singular_name %>.errors.full_messages.to_sentence %></p>
+  <%% end %>
+
+  <div><%%= form.textarea :question, rows: 3, cols: 60 %></div>
+  <div><%%= form.submit 'Ask' %></div>
+<%% end %>

data/lib/generators/omen/pages/templates/controller.rb.tt

@@ -0,0 +1,54 @@
+# The pages of a reading. Written by `rails g omen:pages` and this app's from then on, which is
+# also why it descends from ApplicationController: whatever guards the rest of this app guards
+# the one page here that will run SQL across all of it.
+class <%= plural_name.camelize %>Controller < ApplicationController
+  before_action :set_<%= singular_name %>, only: %i[ show update destroy ]
+
+  # GET /<%= plural_name %>
+  def index
+    @<%= plural_name %> = <%= class_name %>.order id: :desc
+    @<%= singular_name %> = <%= class_name %>.new
+  end
+
+  # GET /<%= plural_name %>/1
+  def show
+  end
+
+  # POST /<%= plural_name %>
+  # Opening a reading is asking its first question, so there is no page for a blank one.
+  def create
+    @<%= singular_name %> = <%= class_name %>.new <%= singular_name %>_params
+
+    if @<%= singular_name %>.save
+      redirect_to @<%= singular_name %>
+    else
+      @<%= plural_name %> = <%= class_name %>.order id: :desc
+      render :index, status: :unprocessable_content
+    end
+  end
+
+  # PATCH/PUT /<%= plural_name %>/1
+  # A reading is never edited: what was asked is what it stays. Asking again adds to the thread,
+  # and Claude is shown the whole of it when it answers.
+  def update
+    question = <%= singular_name %>_params[:question]
+    @<%= singular_name %>.ask(question) if question.present?
+
+    redirect_to @<%= singular_name %>
+  end
+
+  # DELETE /<%= plural_name %>/1
+  def destroy
+    @<%= singular_name %>.destroy!
+
+    redirect_to <%= plural_name %>_path, status: :see_other
+  end
+
+private
+
+  def set_<%= singular_name %>
+    @<%= singular_name %> = <%= class_name %>.find params.expect(:id)
+  end
+
+  def <%= singular_name %>_params = params.expect <%= singular_name %>: [ :question ]
+end

data/lib/generators/omen/pages/templates/index.html.erb.tt

@@ -0,0 +1,12 @@
+<h1><%= plural_name.humanize %></h1>
+
+<%%= render 'form', <%= singular_name %>: @<%= singular_name %> %>
+
+<ul>
+  <%% @<%= plural_name %>.each do |<%= singular_name %>| %>
+    <li>
+      <%%= link_to <%= singular_name %>, <%= singular_name %> %>
+      <%% if <%= singular_name %>.answering? %><em>answering</em><%% end %>
+    </li>
+  <%% end %>
+</ul>

data/lib/generators/omen/pages/templates/model.rb.tt

@@ -0,0 +1,7 @@
+# A reading of this app's own data: what somebody asked Claude, and what came back.
+#
+# Omen::Reading has a type column nowhere, so this is a second name for the same rows rather
+# than a kind of them. <%= class_name %>.all carries no condition, and a belongs_to declared here
+# is one that every reading has.
+class <%= class_name %> < Omen::Reading
+end

data/lib/generators/omen/pages/templates/show.html.erb.tt

@@ -0,0 +1,45 @@
+<%- if turbo? -%>
+<%%= turbo_stream_from @<%= singular_name %>.becomes(Omen::Reading) %>
+
+<%- end -%>
+<p><%%= link_to 'All <%= plural_name %>', <%= plural_name %>_path %></p>
+
+<%% @<%= singular_name %>.questions.each do |question| %>
+  <h2><%%= question.text %></h2>
+
+  <%% if (answer = question.answer) %>
+    <p><%%= answer.note %></p>
+
+    <%% if answer.error.present? %>
+      <p style="color: red"><%%= answer.error %></p>
+    <%% elsif answer.sql.present? %>
+      <details>
+        <summary>SQL</summary>
+        <pre><%%= answer.sql %></pre>
+      </details>
+
+      <table border="1" cellpadding="4">
+        <tr><%% answer.shown.first&.each_key do |header| %><th><%%= header %></th><%% end %></tr>
+        <%% answer.shown.each do |row| %>
+          <tr><%% row.each_value do |value| %><td><%%= value %></td><%% end %></tr>
+        <%% end %>
+      </table>
+
+      <%% if answer.truncated? %>
+        <p>The first <%%= Omen.config.maximum_rows %> rows, and there are more.</p>
+      <%% end %>
+    <%% end %>
+  <%% end %>
+<%% end %>
+
+<%% if @<%= singular_name %>.answering? %>
+  <p>Claude is working on it.</p>
+<%% else %>
+  <%% if @<%= singular_name %>.failed? %>
+    <p style="color: red">That one could not be answered. Asking again starts it over.</p>
+  <%% end %>
+
+  <%%= render 'form', <%= singular_name %>: @<%= singular_name %> %>
+<%% end %>
+
+<%%= button_to 'Delete', @<%= singular_name %>, method: :delete %>

data/lib/omen/bound.rb

@@ -0,0 +1,26 @@
+module Omen
+  # Which roles a restrictive policy really holds back. A role that inherits the privileges of
+  # a narrowed one is narrowed along with it, so a page can go empty for somebody nobody meant
+  # to narrow -- silently, since an empty answer raises nothing.
+  module Bound
+    # A policy is written for one role and named after it, so a binding anybody asked for is
+    # one whose policy name ends in the name of the role it turned up for.
+    ROLES = <<~SQL
+      SELECT p.tablename, p.policyname, r.rolname FROM pg_policies p
+        CROSS JOIN LATERAL unnest(p.roles) AS named(rolname)
+        JOIN pg_roles r ON pg_has_role(r.oid, named.rolname::regrole::oid, 'USAGE')
+       WHERE p.permissive = 'RESTRICTIVE' AND p.schemaname = 'public' AND NOT r.rolsuper
+       ORDER BY p.tablename, p.policyname, r.rolname
+    SQL
+
+    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] any one.
+    # @return [Array<Array<String>>] the table, the policy and the role it holds back.
+    def self.roles(connection) = connection.select_rows ROLES
+
+    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] any one.
+    # @return [Array<Array<String>>] the ones a host did not ask for.
+    def self.surprises(connection)
+      roles(connection).reject { |_table, policy, role| policy.end_with? role }
+    end
+  end
+end

data/lib/omen/config.rb

@@ -15,6 +15,9 @@ module Omen
     # How many rows of one answer a page will show.
     attr_accessor :maximum_rows
 
+    # How many turns of a thread travel with the next question.
+    attr_accessor :remembered
+
     # The key the Anthropic API is reached with. Left unset, the SDK resolves one of its own.
     attr_accessor :api_key
 
@@ -26,6 +29,7 @@ module Omen
       @narrow_role = 'omen_inquirer'
       @claude_model = 'claude-opus-5'
       @maximum_rows = 100
+      @remembered = 20
       @schema_path = 'db/schema.rb'
     end