rails-ai-context 5.35.1 → 5.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 534fe60bd5d8bcd7bc0e2df04cbaed12794c259bc663e969625dd6ccd2437237
-  data.tar.gz: 0a5d91ff87c7c960539e6e60f3fea7d238cf3fcd79dc56905fea7a248b9d912a
+  metadata.gz: 8ea836548c12d9e6a022ca0e9cb78f471c2144d5b16197ab9493808209c12f74
+  data.tar.gz: 1037665358df3ef107d83530dcec2371728b76df61852c51387b2797eb5bac51
 SHA512:
-  metadata.gz: e44f58f7a5728ab9cbb04429f49cfe4abd685ce37c6fa6cd2b59e30afdb27443a11db5e9a07733bc135572a5876993a1449ef04bfba206c15f6ff71b4b870baf
-  data.tar.gz: d689733a334294b5f22a9ca839ee6171f881b2bcd7fdf3818097166ce8a2989ef5ceefd702b357d436c4796e7a3f93c8a11ce4adb3de85f9a8fe7191193153c5
+  metadata.gz: 007d9bbd31542ad5caa6847ce83443fa3d793483cbb93aefcd37dc03c4f4cbf536e51dfd4735ddcf27e0f6dda46b052a95f7f6317d2685f2b2cb8769da349819
+  data.tar.gz: a4815b990a54d309fe3b5a4ce97ab8b7fca7a50841a70825d3aa02378915fe77f0f5465259e3484efb2a8268e959f4877bde376a4617ee461e36e94292eb4301

data/CHANGELOG.md

@@ -5,6 +5,380 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.36.0] - 2026-10-14
+
+### Security
+
+- **On PostgreSQL a name on the read-only VOLATILE list vouches for the server's
+  own function and an extension's C function alone.** The list trusted a name in
+  any schema, so a VOLATILE function the app defined under one of those names
+  ran. While the database holds a VOLATILE function of a listed name in another
+  language outside `pg_catalog`, every call of the name is now refused, and the
+  refusal says so. 5.35.2 and earlier versions had the gap.
+- **On PostgreSQL 18 a set operation over a secret column is refused, as it is
+  on older servers.** PostgreSQL 18 plans a set operation over the tables
+  themselves, and the plan check that refuses a secret column passed through a
+  set operation did not read that shape. A set operation now counts every column
+  its inputs hand up as a use of that column. 5.35.2 and earlier versions had
+  the gap on PostgreSQL 18.
+
+### Changed
+
+- **On SQLite a call of `changes()`, `total_changes()` or
+  `last_insert_rowid()` is refused also where the app has a table of the same
+  name.** The counter answers for the connection that runs the statement,
+  which is `rails_query`'s own. 5.35.1 and 5.35.2 ran such a call when a table
+  carried the counter's name. Read the counter on the app's own connection, in
+  `bin/rails runner` or the console.
+- **The packaged gem holds only what a user of the gem runs or reads.** That is
+  `lib/`, `exe/`, `app/`, `config/`, the README, the changelog, the license,
+  `SECURITY.md`, the user docs in `docs/`, and the files those docs link to
+  (`CONTRIBUTING.md` and three ADRs), so every link works in the unpacked gem.
+  5.35.2 also packed the files that serve the repository alone: `AGENTS.md`,
+  `CLAUDE.md`, `CONTEXT.md`, `CODE_OF_CONDUCT.md`, `docs/RELEASING.md`, the
+  other ADRs, `docs/agents/`, the docs site config, `.rspec`, `.rubocop.yml`,
+  `.ruby-version`, `Rakefile` and `server.json`. A tool that indexes an app's
+  bundle could read the two assistant files as instructions about the app.
+
+### Fixed
+
+- **On PostgreSQL a read with `TABLESAMPLE` runs.** The name of the sampling
+  method (`BERNOULLI`, `SYSTEM`) was read as a call of a VOLATILE function, and
+  the statement was refused. The statement never calls it, so it is no longer
+  read as a call. A VOLATILE function called anywhere in the statement, one
+  named like a sampling method included, is still refused. 5.35.2 refused the
+  read.
+- **On PostgreSQL an `EXISTS` inside an `EXISTS` over a table with a secret
+  column runs.** The plan puts a Result node over the inner scan, and the plan
+  check counted every column of that scan as passed through, so the statement
+  was refused with a sentence saying it passed the secret column on. A Result
+  node is now read like a join: a column counts only where the Result names
+  it. A plain read of a few columns under a condition that holds no column
+  (`WHERE EXISTS (...)`) runs for the same reason. 5.35.2 refused them.
+- **On PostgreSQL `EXPLAIN (GENERIC_PLAN)` answers the plan.** The plan check
+  planned the statement under it without the option, so a statement with `$1` in
+  it answered an SQL error. It is now planned with the option, read as the
+  server reads it: its last value counts, quoted or not. A server older than
+  PostgreSQL 16 has no such option and still answers its error. 5.35.2 answered
+  the error.
+- **On PostgreSQL the `pg_sequences` view can be read.** It reads each
+  sequence's value through `pg_sequence_last_value`, a VOLATILE function that
+  writes nothing, and the statement was refused. The function now joins the
+  list of read-only VOLATILE functions. `nextval`, `setval`, `currval` and
+  `lastval` are still refused. 5.35.2 refused the view.
+- **A query leaves a transaction the app opened with a raw `BEGIN` open, with
+  its writes.** Active Record does not count such a transaction, so on
+  PostgreSQL the query sent its own `BEGIN` and then `ROLLBACK`, which ended
+  the app's transaction and threw its writes away; the answer also missed the
+  rows the transaction had written. PostgreSQL now reads the server's own
+  transaction status and guards inside a savepoint there, under the same
+  read-only transaction and statement timeout. On MySQL and MariaDB the answer
+  is the refusal an open transaction gets ("MySQL cannot make a transaction
+  that is already open read-only"), where 5.35.2 answered the server's error
+  1568, and no `BEGIN`, which would commit the app's transaction, is sent. On
+  a SQLite file the statement runs on the app's own connection and reads the
+  transaction's rows, where 5.35.2 answered from the file without them.
+  5.35.2 and every earlier version ended the transaction on PostgreSQL.
+- **On PostgreSQL a statement another session cancels is answered as the SQL
+  error it is.** A `pg_cancel_backend` from another session raises the same
+  error class as the statement timeout, and 5.35.2 answered "Query exceeded <N>
+  second timeout". The server's message tells the two apart, so a cancel now
+  answers `SQL error: PG::QueryCanceled: ERROR:  canceling statement due to user
+  request`. A real timeout keeps its sentence. A server that writes its messages
+  in another language still answers a cancel as the timeout.
+- **A query that reads a setting `rails_query` sets for each statement says so,
+  and gives the session's own value.** `SHOW statement_timeout` answered the
+  bound the tool set for the statement (`2s`) with nothing to say it was not the
+  session's (`50s`), and so did `transaction_read_only` on PostgreSQL, and the
+  statement limit (`max_execution_time` or `max_statement_time`) and
+  `lock_wait_timeout` on MySQL and MariaDB, by `@@` (the name backquoted or
+  not), by `SHOW VARIABLES` or by MariaDB's
+  `information_schema.SESSION_VARIABLES`. The answer now ends with a note, for
+  example "statement_timeout here is the value rails_query sets for each
+  statement it runs. The session's own: statement_timeout 50s." A name used as
+  an alias or a column, one in a string or a comment, and a global value on
+  MySQL and MariaDB get no note. 5.35.2 and earlier gave no note.
+- **On PostgreSQL 13 and 14 a temporary table runs, with its secret column
+  filtered.** Before PostgreSQL 15 a plan names the session's temporary schema
+  by its number (`pg_temp_3`), where the column reads name it `pg_temp`, so
+  5.35.2 refused every statement over a temporary table there as one whose
+  columns could not be read. A whole row of a temporary table that holds a
+  secret column stays refused.
+- **On SQLite a column whose own name starts with `pragma_` runs.** A
+  `pragma_*` name is now refused where SQLite reads it as the pragma function:
+  called, or where a table stands (after `FROM`, `JOIN` or `IN`, after a comma
+  of a `FROM` list, inside a parenthesis that opens one, or after a schema and a
+  dot there), bare, quoted or as a string. Anywhere else it is a column's or an
+  alias's name, and the statement runs. 5.35.1 and 5.35.2 refused such a name
+  wherever it stood, so `SELECT id FROM t WHERE pragma_flag = 1` was refused.
+- **On SQLite a secret column name covers only the columns SQLite reads it as.**
+  SQLite folds ASCII letters alone, so `"é"` and `"É"` are two columns, and the
+  secret column rule now compares names that way there. With `"É"` in
+  `query_redacted_columns`, `SELECT "é" FROM t` runs and `SELECT *` filters `É`
+  alone; every earlier version refused `é` too and filtered both. A name is
+  still read with every letter folded for what it means, so a column that folds
+  to a built-in name or one the heuristic flags stays secret, and so does one a
+  configured name folds to when no column spells that name as SQLite folds it.
+  PostgreSQL, MySQL and MariaDB fold every letter as before.
+- **On SQLite a statement that names a view over a pragma function or a
+  counter that tells of the connection is refused, by the view and the
+  function.** The view's definition runs on `rails_query`'s own connection, so
+  `CREATE VIEW v AS SELECT name FROM pragma_database_list` answered without
+  the app's attached databases, and a view calling `changes()` answered for the
+  wrong connection, both as a success. 5.35.1 and 5.35.2 refused the function
+  written in the statement alone. A view over a pragma function that describes
+  the schema or the database file, such as `pragma_table_info`, runs.
+- **Every preset names each database's adapter and lists the databases.** On
+  `preset: standard`, which runs no `multi_database` introspector, the static
+  tier called the primary's adapter `unknown` in `rails_onboard` and in the
+  generated files, named no adapter beside a second database, and left the `-
+  Databases:` line out of CLAUDE.md and `.claude/rules/rails-context.md`. The
+  context now carries the app databases list on every preset, and where the
+  `multi_database` introspector failed, so these answer what `preset: full`
+  answers. 5.35.2 and earlier versions had the gap.
+- **A model whose class body raises is named with what it raised.** Ruby
+  registers a class before its body runs, so a model file that raised partway
+  down its class was listed as `[VERIFIED]` with only what ran before the
+  raise, and with no word that loading it failed. It is now named with the
+  error, as a file that raises before its class opens has been since 5.35.2.
+  5.35.2 and earlier versions listed it.
+- **A booted model keeps its STI hierarchy while nothing has queried its
+  database.** A model whose table is in a second database, and so not in
+  `db/schema.rb`, lost its STI parent, children and type column until a first
+  query connected that database. The table is now read as not known to lack the
+  type column, as the static tier reads it, and a model with no STI parent or
+  child still answers no STI. An abstract base, such as the class a second
+  database connects through, is no STI parent. 5.35.2 and earlier versions had
+  the gap.
+- **The static mailer list adds the actions a mailer inherits from the app's own
+  mailers.** A `ShopMailer < BaseMailer` listed only the actions in its own
+  file, where Rails delivers the parent's public methods too and the booted tier
+  lists them. Each name now takes the visibility the nearest class gives it, so
+  a method the child makes private, under `private` or with `private :name`,
+  stays out. The methods of `ApplicationMailer` itself stay out too, as the
+  booted tier leaves them out, and on both tiers a mailer with no action of its
+  own names where they come from only for a parent past the app's own mailers,
+  such as `Devise::Mailer`, and none past `ApplicationMailer`. 5.35.2 and
+  earlier versions had the gap.
+- **`rails_get_schema` says when two databases share `db/schema.rb`.** Rails
+  dumps both the first database and the one named `primary` to that file, so it
+  holds whichever was dumped last. A table of the other database was called
+  missing from the connected one, with advice to run `rails db:migrate`, which
+  changes nothing. The answer now says "_main and primary both dump to
+  db/schema.rb, so it may describe primary. Not in main: events._", and asked
+  for that table it says the same, with no word of a migration. 5.35.2 and
+  earlier versions had the gap.
+- **The conventions section says how many entries each of its lists of five
+  leaves out.** `rails_get_config(section: "conventions")` shows the first five
+  authorization checks, denials, flash notices, flash alerts and not-found
+  patterns, and now ends a longer list with `- _...and N more._`. Every earlier
+  version cut each list at five and said nothing about the rest.
+- **`rails_runtime_info` shows Sidekiq's queue counts as the app's only when
+  Sidekiq is the Active Job adapter.** Under another adapter the jobs section
+  says live queue stats are only read from Sidekiq and names that adapter. When
+  the app also has Sidekiq workers of its own, Sidekiq's counts follow under a
+  `### Sidekiq` heading that says they are those workers' counts. Since 4.3.1
+  any app with Sidekiq loaded got Sidekiq's counts under the adapter's name,
+  where they read as that adapter's queue.
+
+## [5.35.2] - 2026-10-14
+
+### Security
+
+- **On MySQL and MariaDB a quote character inside a string does not change
+  which databases a statement is read to name.** The secret column rule reads
+  the columns of every database a statement names. In 5.35.1, the first release
+  with that read, a quote character inside a string could keep the rule from
+  seeing that the statement named another database. A secret column of a table
+  or of a view in that database then came back. Each name before a dot is now
+  read backward from its dot, so nothing written before the name changes how it
+  is read. The refusals are the ones 5.35.1 gives. This gap is in 5.35.1
+  alone: earlier versions read no other database, which the 5.35.1 notes cover.
+- **On MySQL and MariaDB a `[` outside a string or a quoted name is refused.**
+  MariaDB reads `[name]` as a quoted name when the session's sql_mode holds
+  `MSSQL`, and the statement checks read a bracket as an ordinary character. In
+  a session with that mode the checks and the server could read one statement
+  two ways. `rails_query` does not read the session's mode, so it now refuses
+  the bracket on both servers. 5.35.1 and every earlier version had the gap,
+  on an app whose connection runs in that mode.
+- **On MySQL and MariaDB a query leaves no value behind on the app's
+  connection.** A user variable assignment (`:=`) and `LAST_INSERT_ID` called
+  with an argument each set a value that stayed on the pooled connection after
+  the query returned, which a read-only transaction does not stop. Both are now
+  refused. 5.35.1 and every earlier version ran them.
+- **On PostgreSQL what a foreign scan sends to the remote server is read like
+  what the plan runs itself.** A condition, a sort or a group on a secret
+  column of a `postgres_fdw` foreign table ran on the remote server, where the
+  plan checks did not read it. So a statement could test the column's value,
+  also through a view that renames the column and under a `column_name`
+  option. The remote statement the plan prints is now read, and such a
+  statement answers "Blocked: the query's plan uses the secret column
+  `<column>`". Fetching the column returns `[FILTERED]` as before. A statement
+  whose plan holds a foreign scan costs one more catalog read. Only the remote
+  statement of `postgres_fdw` is read: another foreign data wrapper prints
+  keys of its own. 5.35.1 and every earlier version had the gap.
+- **On PostgreSQL a join that the remote server runs is traced to its
+  tables.** When `postgres_fdw` sends a whole join to the remote server, the
+  plan names the tables with their aliases in one line of the scan, which the
+  plan checks did not read, so the secret column rule did not reach those
+  tables. The tables and aliases of that line are now read like any scan's: a
+  secret column is `[FILTERED]` in place and a whole row is refused, as for a
+  local table. 5.35.1 and every earlier version had the gap.
+- **On PostgreSQL the check for a secret column passed through a subquery
+  reads a name with two spaces in a row or a dotted capital I.** In 5.35.1
+  that check missed a secret column whose name holds either one. A statement
+  that passes such a column through a subquery, a CTE or a set operation is
+  now refused as for any other secret column. 5.35.0 refused it, so the gap is
+  in 5.35.1 alone.
+- **On SQLite a virtual table built on a relation that is not read is refused
+  however its definition is written.** 5.35.1 read a relation's name in the
+  `content=` option of a full-text table and in the table a vocabulary lists.
+  A virtual table that named the relation another way ran, and returned the
+  rows or words of a refused view, a shadow table or the page modules. The
+  module and every argument can now name a relation, except the columns a
+  full-text table (fts3, fts4, fts5) declares and the type an `fts5vocab`
+  table ends with (`row`, `col` or `instance`). An argument with `=` is read
+  whole, whatever its name, and comments are taken out first. The module is
+  read after the table's own name, so a name that spells a module changes
+  nothing: 5.35.1 read such a name as the module, and the rule for a virtual
+  table that holds a secret column did not reach that table. The answers are
+  the ones 5.35.1 gives. The gap needs a virtual table the app itself created.
+  5.35.0 and earlier returned such a table's rows too.
+- **On SQLite a relation whose name holds an apostrophe is matched where it
+  is written in single quotes.** SQLite reads a name in single quotes where a
+  table is expected, with the apostrophe doubled inside. The secret column
+  rule spelled a name in double quotes and in backticks and missed that
+  spelling, so a statement or a definition that used it was not held to the
+  rule for that relation. 5.35.1 and every earlier version had the gap, on an
+  app with a relation so named.
+
+### Changed
+
+The three refusals below go out under a patch number. Each closes a guard gap,
+and the maintainer chose 5.35.2 for them, outside step 1 of `docs/RELEASING.md`.
+
+- **On MySQL and MariaDB a statement with a user variable assignment (`:=`) is
+  refused.** The answer is "Blocked: a user variable assignment (`:=`) is not
+  run. It leaves a value on the pooled connection after the query returns,
+  which a read-only transaction does not stop." A statement that numbers its
+  rows with `@n := @n + 1` ran before and is refused now. Use a window
+  function, `ROW_NUMBER() OVER (...)`, which MySQL 8 and MariaDB 10.2 and
+  later have. A `:=` inside a string or a quoted name is data and runs, with
+  one case apart: a statement with a backslash before a quote inside a string.
+  The second reading of a backslash ends the string at that quote, and where
+  that leaves the `:=` outside a string the statement is refused. Write the
+  quote doubled.
+- **On MySQL and MariaDB `LAST_INSERT_ID` with an argument is refused.** The
+  answer is "Blocked: LAST_INSERT_ID with an argument is not run. It sets a
+  value that stays on the pooled connection after the query returns, which a
+  read-only transaction does not stop. LAST_INSERT_ID() with no argument
+  runs." The call is matched on the raw text, like the session functions, so
+  it is refused inside a string too.
+- **On MySQL and MariaDB a statement with a `[` outside a string or a quoted
+  name is refused.** The answer is "Blocked: a `[` outside a string or a
+  quoted name is not run. MariaDB reads it as the start of a quoted name when
+  the session's sql_mode holds MSSQL, and rails_query does not read the
+  session's mode. Quote a name in backticks." MySQL, and MariaDB outside that
+  mode, run no statement that holds one. In a session with that mode, write
+  `` `name` `` for `[name]`. A `[` inside a string or a backticked name runs,
+  with one case apart: a statement with a backslash before a quote inside a
+  string, as in `'O\'Brien'` beside `REGEXP '[a-z]'`. The second reading of a
+  backslash ends the string at that quote, and where that leaves the `[`
+  outside a string the statement is refused. Such a statement ran before.
+  Write the quote doubled.
+
+### Fixed
+
+- **A write that follows a `WITH` clause is refused as the write it is.**
+  `WITH ... INSERT INTO ...` answered "Blocked: SELECT INTO creates a table".
+  It now answers "Blocked: contains INSERT", and `REPLACE` and `MERGE` after a
+  `WITH` clause are named the same way. A real `SELECT ... INTO` keeps its
+  sentence.
+- **A refusal names a view, a table and a relation as the database spells
+  them.** It named them case folded, with a run of spaces as one space, so a
+  view called `Hq  Odd View` was named `hq odd view`, which no relation is
+  called. Two names that differ by a run of spaces alone are one name to the
+  rule, and the refusal names the first of them it read.
+- **A view refused over a table that is not read is said to name it.** The
+  answer ended "its definition reads `<table>`, which is not read", and the
+  rule tests whether the definition names the table. It now ends "its
+  definition names `<table>`, which is not read".
+- **The answer for a view that leads too deep drops its count.** It reads "The
+  view `<view>` leads through more databases than rails_query follows, so the
+  secret columns it could read cannot be told and no statement that names it
+  runs." The "(3 rounds)" after "follows" told a user nothing.
+- **The note for a row limit of one says "1 row shown".** It said "1 rows
+  shown; the query returned more".
+- **On PostgreSQL a sequence can be queried.** `SELECT last_value FROM
+  <sequence>` and `SELECT * FROM <sequence>` ran on 5.35.0, and 5.35.1 answered
+  that the sequence's columns could not be read. A sequence is now read like a
+  table that holds no secret column.
+- **On PostgreSQL a whole row of a table with no secret column runs when
+  another table shares its alias or its name with a number after it.** 5.35.1
+  refused such a statement when a subquery used the same alias for a table
+  that holds a secret column, or when a table named like `name_2` stood beside
+  it, and the refusal named the other table. 5.35.0 ran it. The number the
+  planner adds to an alias is now taken off for the members of an Append or a
+  Merge Append alone, and a refusal over a whole row names the relation whose
+  row the statement reads.
+- **On PostgreSQL a block comment inside a block comment is read as the server
+  reads it.** PostgreSQL nests block comments, and the gate ended one at the
+  first `*/`, so `SELECT 1 /* a /* b */ c */ AS n` answered PostgreSQL's
+  syntax error. It now runs.
+- **On SQLite a statement that runs past `query_timeout` answers the timeout
+  when a writer takes the lock while it runs.** It answered that the database
+  was locked and the query did not run. The query process now takes its read
+  lock before it prepares the statement, so no lock stops the statement from
+  there on. The locked answer is given for a lock the query process is still
+  waiting on when it gives up or when the deadline passes.
+- **On a SQLite file database a statement that names something the app's
+  connection alone holds runs on that connection.** While that connection
+  holds a temp object or an attachment, a statement runs there when it names a
+  temp object, `sqlite_temp_master` or `sqlite_temp_schema`, the `temp` schema
+  or an attached database, or calls a pragma function (`pragma_table_info(...)`,
+  `pragma_table_list` and the rest) or `dbstat`, since an argument can name any
+  of them.
+  The query process has none of them, so it answered an empty list, the rows of
+  a main table of the same name, or "unknown database". The answer now ends
+  with the note that the query ran without a time limit. A name is matched
+  anywhere in the statement, in any letter case and inside a string too.
+  Finding this out takes two more reads before a statement on a file database
+  where a query process can run: eight where there were six.
+- **The full generated file lists the first database's recent migrations
+  under its own name.** With a first database not named `primary` and another
+  one that is, the heading read `### Recent Migrations: primary`. It now names
+  the first database, as in `### Recent Migrations: animals`.
+- **The database marks and the first database's own name do not depend on the
+  preset.** On `preset: standard`, or any `introspectors` list without
+  `multi_database`, `rails_get_schema`, `rails_onboard`,
+  `rails_performance_check` and the generated files lost the mark of a
+  database another environment configures, such as `cache (production only)`,
+  and called a first database with another name `primary`. They now read the
+  app databases list there, as on `full`, and `rails_onboard` names a
+  secondary's adapter.
+- **The model, controller, job, mailer and channel lists hold a class only
+  while its own constant names it.** A class whose constant was removed stays
+  loaded until the garbage collector takes it, so a list could hold it in one
+  run and lose it in the next. Such a class is now left out. A constant still
+  waiting to autoload counts as naming its class. The lists of a class's
+  children follow the same rule: a model's STI children, the classes a base job
+  or mailer is inherited by, and the abstract bases.
+- **A model file that raises before its class opens costs that model alone.**
+  A failing `require` at the top of the file, or a raise above the class line,
+  made the whole models section answer an error. The file is now named with
+  what it raised, and the other models stay listed.
+- **The refusal over a secret column says where `query_allowed_columns` is
+  set on either install.** It said to add the name "in an initializer", which
+  does nothing on a standalone install. It now ends "add "x" to
+  query_allowed_columns in .rails-ai-context.yml (or in
+  config/initializers/rails_ai_context.rb where the app bundles the gem)."
+- **`rails_runtime_info` says when table sizes or index usage could not be
+  read.** A read that failed or ran out of time left its part of the database
+  section out with no word. The section now says "_Table sizes were not read:
+  the read failed or took longer than query_timeout._", and at `detail:
+  "full"` "_Index usage was not read: the read failed or took longer than
+  query_timeout._"
+
 ## [5.35.1] - 2026-10-13
 
 ### Security
@@ -8242,7 +8616,7 @@ Every introspector that scans `.rb` files has been migrated from regex-based pat
 
 ### Added - 8 new introspectors closing RAILS_NERVOUS_SYSTEM.md gaps
 
-An audit against [`RAILS_NERVOUS_SYSTEM.md`](RAILS_NERVOUS_SYSTEM.md) identified 9 framework sections where introspection was missing or partial. This release ships the 8 introspectors needed to close them (the 9th - §11 Query interface - was already covered by `:conventions` via `load_async` / `.async_*` scanning). All are wired into `PRESETS[:full]`. The gem now exposes **39 introspectors** (up from 31).
+An audit against `RAILS_NERVOUS_SYSTEM.md` identified 9 framework sections where introspection was missing or partial. This release ships the 8 introspectors needed to close them (the 9th - §11 Query interface - was already covered by `:conventions` via `load_async` / `.async_*` scanning). All are wired into `PRESETS[:full]`. The gem now exposes **39 introspectors** (up from 31).
 
 - **`InitializerIntrospector` (`:initializers`, §2).** Enumerates `Rails.application.initializers` - every initializer's name, owner, declared `before:` / `after:` ordering edges, and the `source_location` of its block. Also summarizes each `config/initializers/*.rb` file (initializer count + the top `config.*` setters it touches) so AI can jump straight to user-owned boot code.
 - **`AutoloadIntrospector` (`:autoload`, §3).** Zeitwerk presence, both `Rails.autoloaders.main` and `.once` with their collapsed dirs + ignored paths + root dirs, raw `autoload_paths` / `autoload_once_paths` / `eager_load_paths`, the resolved `eager_load` boolean, plus custom inflection rules extracted from `config/initializers/*.rb` (`inflect.acronym` / `.plural` / `.singular` / `.irregular` / `.uncountable` / `.human`). Paths are root-relative.

data/CONTRIBUTING.md

@@ -106,9 +106,10 @@ RAC_TEST_MYSQL_URL=trilogy://root:secret@127.0.0.1:3306/rac \
   BUNDLE_GEMFILE=gemfiles/database_servers.gemfile bundle exec rspec spec/lib/rails_ai_context/database_family/database_servers_spec.rb
 ```
 
-The specs create and drop tables and views whose names start with `rac_`, so point them at a scratch database.
+The specs create and drop tables and views whose names start with `rac_`, and leave the `postgres_fdw` extension installed on PostgreSQL, so point them at a scratch database.
 CI's `database_servers` job runs them on PostgreSQL 16 in every leg. Rails 8.0 runs two legs: MySQL 8.0 with MariaDB 10.6, and MySQL 8.4 with MariaDB 11.4. Rails 7.0 runs MySQL 8.0 with MariaDB 10.6, and Rails 8.1 runs MySQL 8.4 with MariaDB 11.4.
 Rails 7.0 has no Trilogy adapter, so its leg runs PostgreSQL and mysql2 only.
+The `postgresql_versions` job runs the PostgreSQL specs on PostgreSQL 13, 14, 15, 17 and 18 on Rails 8.0, since the plan checks read the plan the server prints.
 The job builds mysql2 against MariaDB's client library (`libmariadb-dev`, through `BUNDLE_BUILD__MYSQL2`), which signs in to MySQL and to MariaDB. A MySQL client from 9.0 on cannot sign in to MariaDB.
 
 ### Static fixture

data/docs/COMPATIBILITY.md

@@ -312,6 +312,17 @@ Proof sources:
    the tool's own checks timed on Ruby 3.4 for statements up to a megabyte
    and on Ruby 3.1 for statements of 50 kilobytes; and the unit suite and the
    E2E harness on Linux, macOS and Windows.
+   In the v5.35.2 closing review: the statement files of the v5.35.1 QA sent
+   through the tool again on PostgreSQL 16, MySQL 8.4, MariaDB 11.4 and SQLite,
+   on the v5.35.1 code and on the fixed code, with every changed answer traced
+   to its fix; and for each fix an example that fails on the v5.35.1 code, on a
+   real server where the fix is a server's.
+   In the v5.36.0 release QA: for each fix an example that fails on the v5.35.2
+   code, on a real server where the fix is a server's; `rails_query` through
+   its tool call in CI on PostgreSQL 16, MySQL 8.0 and 8.4 and MariaDB 10.6 and
+   11.4 on Rails 7.0 (mysql2), 8.0 and 8.1 (mysql2 and Trilogy), and on
+   PostgreSQL 13, 14, 15, 17 and 18 on Rails 8.0; and the unit suite and the
+   E2E harness on Linux, macOS and Windows.
 2. Non-crash coverage for every built-in tool including `get_view` in
    `spec/e2e/in_gemfile_install_spec.rb`'s full-tool sweep; output correctness
    (ivar cross-check, render-form detection, partial interfaces) verified
@@ -358,7 +369,10 @@ row estimates and index usage say they are not available there. CI's
 8.4 and MariaDB 10.6 and 11.4 on Rails 8.0, through mysql2 and Trilogy. It also
 runs PostgreSQL 16 with MySQL 8.0 and MariaDB 10.6 on Rails 7.0, which has no
 Trilogy adapter, and with MySQL 8.4 and MariaDB 11.4 on Rails 8.1; see
-[CONTRIBUTING.md](../CONTRIBUTING.md#real-database-servers).
+[CONTRIBUTING.md](../CONTRIBUTING.md#real-database-servers). The
+`postgresql_versions` job runs the PostgreSQL examples on PostgreSQL 13, 14,
+15, 17 and 18 as well, since the plan checks read the plan the server prints and
+its shape changes between major versions.
 
 Postgres itself - live query safety (read-only transactions, the
 `BLOCKED_FUNCTIONS` guard against `pg_read_file`/`dblink`/`COPY ... PROGRAM`,