@consiliency/agent-board-schema 1.51.0 → 1.53.0

package/tests/agent_board_claimpolicy_race.test.sql

@@ -83,7 +83,7 @@ set search_path = extensions, public, agent_board;
 
 begin;
 
-select plan(41);
+select plan(45);
 
 -- ---------------------------------------------------------------------------
 -- Fixture: one board, one thread on it, one thread with NO board (the constitutive-'inherit'
@@ -135,6 +135,1370 @@ begin
   insert into _cpr(board, thread, free_thread, board_b) values (v_board, v_thread, v_free, v_board_b);
 end $$;
 
+-- ===========================================================================
+-- THE MATCHERS FIRST. CPR-0..0b gate the regexes every population assertion below is built from,
+-- so they run BEFORE any production use: a matcher that no longer compiles is named here by its
+-- behaviour-table row (`raises: invalid regular expression …`), where the same defect met first by
+-- a bare `~` in CPR-6 or CPR-14a would only abort the file (#113) and name nothing. Measured under
+-- mutation m25 (a `(?c)` director spliced mid-pattern): with this block after the census, CPR-14a
+-- aborted at its first `write_re('claims')` and 16 of 45 assertions ran.
+-- ===========================================================================
+-- CPR-0 / CPR-0a. THE MATCHERS' BEHAVIOUR TABLE, AND A GATE ON THE TABLE ITSELF.
+--
+-- WHY BOTH. The identifier matchers drifted four times across three review rounds, and every
+-- version passed its accept cases. So a table was added. Then the SAME defect appeared INSIDE the
+-- table three times: rows that pass for a reason unrelated to the rule they are named for — first
+-- r06 (tested `$` through an adjacency that rejected it earlier), then a12/r13 (compiled a
+-- reconstruction rather than the production object), then a13/a14/a15 (keyword branches that the
+-- subject text could never exercise). Each was found by a different reviewer, after the previous
+-- fix, by the same procedure: revert a rule and see which rows move.
+--
+-- THREE OCCURRENCES IS ENOUGH EVIDENCE THAT A HAND-COMPILED REVERT MAP CANNOT BE TRUSTED, because
+-- compiling it is the same act as writing the rows. So the map is mechanical now: CPR-0a reverts
+-- each rule in turn, re-evaluates every row, and requires at least one row to flip. A rule with no
+-- flipping row FAILS AND NAMES ITSELF — which is what would have caught all three, and none of
+-- which a human reading the table did.
+--
+-- The rows are DATA rather than inline expressions so both assertions evaluate the same list: a
+-- row CPR-0 checks and CPR-0a cannot re-evaluate would be back to two lists that agree today.
+-- ---------------------------------------------------------------------------
+-- WANT IS TEXT, NOT BOOLEAN (Consiliency/message-board#416 PR 1): a row may now expect the matcher to
+-- RAISE (`writes_any_frag` on an empty list), and a raise must be asserted by its MESSAGE rather than
+-- by "it did not return true" — otherwise a typo in the expression would satisfy the row. `costly`
+-- marks the rows that run `lock_edges()`/`fn_call_closure()` (seconds each); CPR-0a re-evaluates
+-- them only when the rule being reverted belongs to one of those two functions.
+create temp table _mrow (label text primary key, expr text, want text, costly boolean not null default false) on commit drop;
+
+-- A fixture in agent_board for the two costly rows: a caller whose callee is spelled with a QUOTED
+-- identifier. Created inside this rolled-back transaction, so it never outlives the test.
+create function agent_board._probe416_quoted_callee(p_task uuid) returns void
+language plpgsql as $f$
+begin
+  perform agent_board."acquire_claim"(p_task);
+end $f$;
+
+insert into _mrow(label, expr, want) values
+  -- ACCEPTS: spellings PostgreSQL resolves to OUR object
+  ('a01-qualified',      $x$'update agent_board.claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
+  ('a02-unqualified',    $x$'update claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
+  ('a03-upper-unquoted', $x$'UPDATE AGENT_BOARD.CLAIMS SET x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
+  ('a04-quoted-lower',   $x$'update "agent_board"."claims" set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
+  ('a05-verb-newline',   $x$'insert' || chr(10) || 'into claims v' ~ agent_board_test.stmt_re('insert into','claims')$x$, true),
+  ('a06-verb-2spaces',   $x$'delete  from claims where x' ~ agent_board_test.stmt_re('delete from','claims')$x$, true),
+  ('a07-verb-tab',       $x$'merge' || chr(9) || 'into claims m' ~ agent_board_test.stmt_re('merge into','claims')$x$, true),
+  -- a08 gates ci_re's OWN space rule, which a05-a07 do NOT: they exercise whitespace inside a verb
+  -- through stmt_re, which would still work if ci_re emitted a literal space and stmt_re rewrote it.
+  ('a08-cire-phrase',    $x$'no' || chr(10) || 'key' ~ ('(?c)' || agent_board_test.ci_re('no key'))$x$, true),
+  ('a09-inheritance',    $x$'update agent_board.boards* set x' ~ agent_board_test.stmt_re('update','boards')$x$, true),
+  ('a10-call-space',     $x$'perform _claimgate_lock_board_policy (v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, true),
+  ('a11-call-quoted',    $x$'perform agent_board."_claimgate_lock_board_policy"(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, true),
+  ('a12-col-upper',      $x$'set CLAIM_POLICY = x' ~ agent_board_test.col_frag('claim_policy')$x$, true),
+  ('a13-ins-novals',     $x$'insert into agent_board.boards values (1,2)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
+  ('a14-ins-select',     $x$'insert into agent_board.boards select (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
+  -- a15/a16 cover two INSERT FORMS the rule must census. They do NOT gate a keyword exclusion, and
+  -- that is stated rather than implied: DEFAULT is only ever followed by VALUES and OVERRIDING by
+  -- SYSTEM/USER, so neither can be mistaken for an alias-before-`(`. The exclusions for them were
+  -- therefore DEAD CODE and have been removed rather than kept with rows that cannot gate them.
+  ('a15-ins-default',    $x$'insert into agent_board.boards default values' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
+  ('a16-ins-overriding', $x$'insert into agent_board.boards overriding user value values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
+  ('a17-ins-re-eq-frag', $x$agent_board_test.insert_all_columns_re('boards') = '(?c)' || agent_board_test.insert_all_columns_frag('boards')$x$, true),
+  -- REJECTS: spellings PostgreSQL resolves ELSEWHERE
+  ('a18-verb-rel-spaces', $x$'update  agent_board.claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
+  ('r01-other-schema',   $x$'update other.claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, false),
+  ('r02-dot-space',      $x$'perform other . _claimgate_lock_board_policy(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, false),
+  ('r03-quoted-upper',   $x$'update "AGENT_BOARD"."claims" set x' ~ agent_board_test.stmt_re('update','claims')$x$, false),
+  ('r04-prefix-word',    $x$'update dashboards set x' ~ agent_board_test.stmt_re('update','boards')$x$, false),
+  ('r05-dollar-lead',    $x$'perform x$_claimgate_lock_board_policy(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, false),
+  ('r06-dollar-rel',     $x$'from x$claims c' ~ agent_board_test.qname_re('claims')$x$, false),
+  ('r07-nonascii-lead',  $x$'perform ' || chr(233) || '_claimgate_lock_board_policy(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, false),
+  ('r08-nonascii-trail', $x$'from claims' || chr(233) || ' c' ~ agent_board_test.qname_re('claims')$x$, false),
+  ('r09-col-nonascii',   $x$'set claim_policy' || chr(233) || ' = x' ~ agent_board_test.col_frag('claim_policy')$x$, false),
+  ('r10-col-dollar',     $x$'set x$claim_policy = x' ~ agent_board_test.col_frag('claim_policy')$x$, false),
+  ('r11-i-flag',         $x$regexp_instr('x "AGENT_BOARD"."claims" y', agent_board_test.qname_re('claims'), 1, 1, 0, 'i') > 0$x$, false),
+  ('r12-ci-operator',    $x$'x "AGENT_BOARD"."claims" y' ~* agent_board_test.qname_re('claims')$x$, false),
+  ('r13-ins-collist',    $x$'insert into agent_board.boards (slug) values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, false),
+  ('r14-ins-alias',      $x$'insert into agent_board.boards as b(slug) values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, false),
+  ('r16-call-i-flag',    $x$regexp_instr('perform "AGENT_BOARD"."_claimgate_lock_board_policy"(v)', agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0, 'i') > 0$x$, false),
+  ('r15-ins-qalias',     $x$'insert into agent_board.boards as "b"(slug) values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, false),
+  -- #416/#417/#424 PR 1: the STATEMENT-SPAN, ASSIGNMENT-POSITION and WRITE-SHAPE rules. Every
+  -- row below was run against the family before it was written down.
+  ('a19-span-lit-semicolon',  $x$'update boards set note = ''a;b'', claim_policy = x' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r17-span-stmt-boundary',  $x$'update boards set x = 1; update other set claim_policy = 2' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('a20-merge-ins-novals',    $x$'merge into agent_board.boards b using s on b.id = s.id when not matched then insert values (1)' ~ ('(?c)' || agent_board_test.merge_insert_all_columns_frag('boards'))$x$, true),
+  ('a20b-merge-ins-novals-via-col-write', $x$'merge into agent_board.boards b using s on b.id = s.id when not matched then insert values (1)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r18-merge-ins-collist',   $x$'merge into agent_board.boards b using s on b.id = s.id when not matched then insert (slug) values (1)' ~ ('(?c)' || agent_board_test.merge_insert_all_columns_frag('boards'))$x$, false),
+  ('r19-merge-do-nothing',    $x$'merge into agent_board.boards b using s on b.id = s.id when not matched then do nothing' ~ ('(?c)' || agent_board_test.merge_insert_all_columns_frag('boards'))$x$, false),
+  ('r20-merge-matched-update', $x$'merge into agent_board.boards b using s on b.id = s.id when matched then update set x = 1' ~ ('(?c)' || agent_board_test.merge_insert_all_columns_frag('boards'))$x$, false),
+  ('a21-three-part-name',     $x$'update mb_db.agent_board.boards set x' ~ agent_board_test.stmt_re('update','boards')$x$, true),
+  ('a21b-three-part-quoted-db', $x$'update "mb db".agent_board.boards set x' ~ agent_board_test.stmt_re('update','boards')$x$, true),
+  ('r21-three-part-other-schema', $x$'update mb_db.other.boards set x' ~ agent_board_test.stmt_re('update','boards')$x$, false),
+  ('a22-copy-from',           $x$'copy agent_board.boards from stdin' ~ agent_board_test.write_re('boards')$x$, true),
+  ('a22b-copy-collist-from',  $x$'copy agent_board.boards (slug, claim_policy) from stdin' ~ agent_board_test.write_re('boards')$x$, true),
+  ('r22-copy-to',             $x$'copy agent_board.boards to stdout' ~ agent_board_test.write_re('boards')$x$, false),
+  ('a23-truncate-table-only', $x$'truncate table only agent_board.boards' ~ agent_board_test.write_re('boards')$x$, true),
+  ('a36-truncate-list-second', $x$'truncate agent_board.claims, agent_board.boards' ~ agent_board_test.write_re('boards')$x$, true),
+  ('r34-truncate-other-only', $x$'truncate agent_board.claims' ~ agent_board_test.write_re('boards')$x$, false),
+  ('r23-write-suffix-word',   $x$'update boards_archive set x' ~ agent_board_test.write_re('boards')$x$, false),
+  ('r24-bare-when-required',  $x$'update boards set x' ~ agent_board_test.stmt_re('update','boards', false)$x$, false),
+  ('a24-qualified-when-required', $x$'update agent_board.boards set x' ~ agent_board_test.stmt_re('update','boards', false)$x$, true),
+  ('a39-other-schema-explicit', $x$'update auth.users set x' ~ agent_board_test.stmt_re('update','auth.users')$x$, true),
+  ('r35-other-schema-wrong-schema', $x$'update agent_board.users set x' ~ agent_board_test.stmt_re('update','auth.users')$x$, false),
+  ('a25-set-row-form',        $x$'update boards set (slug, claim_policy) = (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a33-mixed-scalar-row-form', $x$'update agent_board.boards set updated_at = now(), (slug, claim_policy) = (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r25-col-in-where',        $x$'update agent_board.boards set slug = x where claim_policy = y' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r26-col-in-returning',    $x$'update agent_board.boards set slug = x returning claim_policy' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r27-merge-col-in-on-only', $x$'merge into agent_board.boards b using s on b.claim_policy = s.x when matched then update set slug = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r28-insert-select-col',   $x$'insert into agent_board.boards (slug) select claim_policy from x' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r29-set-rhs-read',        $x$'update agent_board.boards set slug = (select claim_policy from x)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('a26-set-subquery-then-col', $x$'update agent_board.boards set slug = (select 1 from t where q = 1), claim_policy = 2' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a27-set-where-in-literal', $x$'update agent_board.boards set note = ''where'', claim_policy = 2' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a28-span-estring',        $x$'update boards set note = E''a\'';b'', claim_policy = x' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r30-estring-guard',       $x$'update boards set line = ''x\''; update other set claim_policy = ''z''' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('a29-quoted-callee',       $x$'perform agent_board."acquire_claim"(1)' ~ agent_board_test.call_re('acquire_claim')$x$, true),
+  ('r31-bare-callee-when-required', $x$'perform acquire_claim(1)' ~ agent_board_test.call_re('acquire_claim', false)$x$, false),
+  ('a30-case-when-then-col',  $x$'update agent_board.boards set slug = case when x then y else z end, claim_policy = p' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a31-merge-when-matched-and-pred', $x$'merge into agent_board.boards b using s on b.id = s.id when matched and b.x > 1 then update set claim_policy = s.p' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a32-merge-not-matched-by-source-update', $x$'merge into agent_board.boards b using s on b.id = s.id when not matched by source then update set claim_policy = s.p' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a34-merge-case-when-then-col', $x$'merge into agent_board.boards b using s on b.id = s.id when matched then update set slug = case when s.x then 1 else 2 end, claim_policy = s.p' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r33-merge-col-in-later-clause', $x$'merge into agent_board.boards b using s on b.id = s.id when matched then update set slug = 1 when not matched then do nothing' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r32-copy-other-cols-from', $x$'copy agent_board.boards (slug) from stdin' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('a38-copy-collist-col-from', $x$'copy agent_board.boards (slug, claim_policy) from stdin' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a37-insert-collist-overriding', $x$'insert into agent_board.boards (slug, claim_policy) overriding system value values (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a40-insert-alias-collist', $x$'insert into agent_board.boards as b (slug, claim_policy) values (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a41-merge-ins-collist-col', $x$'merge into agent_board.boards b using s on b.id = s.id when not matched then insert (slug, claim_policy) values (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a42-select-into-table',   $x$'select 1 into temp table agent_board.boards from x' ~ agent_board_test.write_re('boards')$x$, true),
+  ('r36-select-into-var-from', $x$'select claim_policy into v_policy from agent_board.boards' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('a35-union-compiles',      $x$'update agent_board.boards set x = 1' ~ agent_board_test.re(agent_board_test.call_frag('a') || '|' || agent_board_test.write_frag('boards'))$x$, true),
+  ('a43-writes-any',          $x$'delete from agent_board.claims where x' ~ agent_board_test.writes_any_re(array['boards','claims'])$x$, true),
+  ('r37-writes-any-empty-refused', $x$'x' ~ agent_board_test.writes_any_re(array[]::text[])$x$, 'raises: writes_any_frag: the relation list is empty'),
+  ('a44-re-eq-frag',          $x$agent_board_test.write_re('boards') = '(?c)' || agent_board_test.write_frag('boards')$x$, true),
+  ('a45-col-write-re-eq-frag', $x$agent_board_test.col_write_re('boards','claim_policy') = '(?c)' || agent_board_test.col_write_frag('boards','claim_policy')$x$, true),
+  ('a46-stmt-re-eq-frag',     $x$agent_board_test.stmt_re('update','boards') = '(?c)' || agent_board_test.stmt_frag('update','boards')$x$, true),
+  ('a47-writes-any-re-eq-frag', $x$agent_board_test.writes_any_re(array['boards']) = '(?c)' || agent_board_test.writes_any_frag(array['boards'])$x$, true),
+  ('a48-call-re-two-eq-frag', $x$agent_board_test.call_re('acquire_claim', false) = '(?c)' || agent_board_test.call_frag('acquire_claim', false)$x$, true),
+  ('a49-set-run-fold-escape', $x$'update agent_board.boards set slug = 1, claim_policy = 2 WHERE x' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r38-set-run-upper-terminator', $x$'update agent_board.boards set slug = x WHERE claim_policy = y' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r39-set-run-from-terminator', $x$'update agent_board.boards set slug = x from other o where o.claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('k1-three-level-paren-KNOWN-MISS', $x$'update agent_board.boards set slug = (select (select (select 1 from a where b) from c) from d), claim_policy = 2' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('a50-qname-re-bare',       $x$'from claims c' ~ agent_board_test.qname_re('claims')$x$, true),
+  ('a51-ins-novals-bare',     $x$'insert into boards values (1)' ~ ('(?c)' || agent_board_test.insert_all_columns_frag('boards'))$x$, true),
+  ('a52-merge-span-lit-semicolon', $x$'merge into agent_board.boards b using (select ''a;b'' as x) s on b.id = s.id when matched then update set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a53-merge-span-estring',  $x$'merge into agent_board.boards b using (select E''a\'';b'' as x) s on b.id = s.id when matched then update set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a54-estring-guard-ident-prefix', $x$'update boards set note = line''x\'', claim_policy = 1; update other set y = ''z''' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a55-set-two-level-paren', $x$'update agent_board.boards set slug = (select (select 1 from a where b) from c), claim_policy = 2' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a56-same-stmt-estring-guard', $x$'merge into agent_board.boards b using (select line''x\'' as q, ''y'' as r) s on b.id = s.id when matched then update set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a57-write-re-bare',       $x$'delete from boards where x' ~ agent_board_test.write_re('boards')$x$, true),
+  ('a58-writes-any-bare',     $x$'delete from boards where x' ~ agent_board_test.writes_any_re(array['claims','boards'])$x$, true),
+  ('a59-set-scalar-col',      $x$'update agent_board.boards set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a60-insert-collist-col',  $x$'insert into agent_board.boards (id, claim_policy) values (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a61-ins-novals-via-col-write', $x$'insert into agent_board.boards values (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a62-select-into-via-col-write', $x$'select 1 into agent_board.boards' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a20c-merge-ins-novals-bare', $x$'merge into boards b using s on b.id = s.id when not matched then insert values (1)' ~ ('(?c)' || agent_board_test.merge_insert_all_columns_frag('boards'))$x$, true),
+  ('a64-stmt-frag-bare',      $x$'update boards set x' ~ agent_board_test.re(agent_board_test.stmt_frag('update','boards'))$x$, true),
+  ('a65-call-frag-bare',      $x$'perform acquire_claim(1)' ~ agent_board_test.re(agent_board_test.call_frag('acquire_claim'))$x$, true),
+  ('r40-stmt-re-i-flag',      $x$regexp_instr('UPDATE "AGENT_BOARD"."claims" set x', agent_board_test.stmt_re('update','claims'), 1, 1, 0, 'i') > 0$x$, false),
+  ('r42-merge-col-in-next-when-pred', $x$'merge into agent_board.boards b using s on b.id = s.id when matched then update set slug = 1 when not matched by source and claim_policy = 3 then delete' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r43-re-i-flag',           $x$regexp_instr('x "AGENT_BOARD"."boards" y', agent_board_test.re(agent_board_test.qname_frag('boards')), 1, 1, 0, 'i') > 0$x$, false),
+  ('r44-re-groups-the-frag',  $x$'a' ~ (agent_board_test.re('a|b') || 'x')$x$, false),
+  ('r45-select-into-var-from-write', $x$'select 1 into v from agent_board.boards' ~ agent_board_test.write_re('boards')$x$, false),
+  ('r46-write-re-i-flag',     $x$regexp_instr('DELETE FROM "AGENT_BOARD"."boards"', agent_board_test.write_re('boards'), 1, 1, 0, 'i') > 0$x$, false),
+  ('r47-writes-any-re-i-flag', $x$regexp_instr('DELETE FROM "AGENT_BOARD"."boards"', agent_board_test.writes_any_re(array['boards']), 1, 1, 0, 'i') > 0$x$, false),
+  ('r48-col-write-re-i-flag', $x$regexp_instr('UPDATE "AGENT_BOARD"."boards" set claim_policy = 1', agent_board_test.col_write_re('boards','claim_policy'), 1, 1, 0, 'i') > 0$x$, false),
+  ('r49-col-write-bare-when-required', $x$'update boards set claim_policy = 1' ~ agent_board_test.re(agent_board_test.col_write_frag('boards','claim_policy', false))$x$, false),
+  ('r50-write-bare-when-required', $x$'delete from boards where x' ~ agent_board_test.re(agent_board_test.write_frag('boards', false))$x$, false),
+  ('r51-writes-any-bare-when-required', $x$'delete from boards where x' ~ agent_board_test.re(agent_board_test.writes_any_frag(array['boards'], false))$x$, false),
+  ('r52-merge-ins-bare-when-required', $x$'merge into boards b using s on b.id = s.id when not matched then insert values (1)' ~ agent_board_test.re(agent_board_test.merge_insert_all_columns_frag('boards', false))$x$, false),
+  ('r53-ins-novals-bare-when-required', $x$'insert into boards values (1)' ~ agent_board_test.re(agent_board_test.insert_all_columns_frag('boards', false))$x$, false),
+  ('a68-dotted-name-quoted-parts', $x$'update "auth"."users" set x' ~ agent_board_test.stmt_re('update','auth.users')$x$, true),
+  ('r54-set-run-from-terminator-no-where', $x$'update agent_board.boards set slug = x from other o join p on claim_policy = o.id' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r55-set-run-returning-terminator-eq', $x$'update agent_board.boards set slug = x returning claim_policy = 1 as is_one' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r56-qname-prefix-word',    $x$'from dashboards d' ~ agent_board_test.qname_re('boards')$x$, false),
+  ('r57-same-stmt-estring-guard', $x$'merge into agent_board.boards b using (select line''a\'' as q, ''b'' as r, ''c'' as t, ''d) s on b.id = s.id when matched then update set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r58-set-run-estring-guard', $x$'update agent_board.boards set note = line''a\'', slug = ''b'', x = ''c'', y = ''d claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r59-dotted-name-dot-is-literal', $x$'update authxusers set x' ~ agent_board_test.stmt_re('update','auth.users')$x$, false),
+  ('a70-row-lock-for-update',   $x$'select 1 from agent_board.claims c where c.id = x for update' ~ agent_board_test.row_lock_re('claims')$x$, true),
+  ('a71-row-lock-no-key-update', $x$'select 1 from claims for no key update of c' ~ agent_board_test.row_lock_re('claims')$x$, true),
+  ('a72-row-lock-key-share',    $x$'select 1 from "agent_board"."claims" FOR KEY SHARE' ~ agent_board_test.row_lock_re('claims')$x$, true),
+  ('a73-row-lock-share',        $x$'select 1 from claims for share nowait' ~ agent_board_test.row_lock_re('claims')$x$, true),
+  ('r60-row-lock-in-literal',   $x$'select 1 from agent_board.claims where note = ''for update''' ~ agent_board_test.row_lock_re('claims')$x$, false),
+  ('r61-row-lock-next-stmt',    $x$'select 1 from agent_board.claims; select 1 from boards for update' ~ agent_board_test.row_lock_re('claims')$x$, false),
+  ('r62-row-lock-suffix-word',  $x$'select 1 from agent_board.claims for updates' ~ agent_board_test.row_lock_re('claims')$x$, false),
+  ('r63-row-lock-other-rel',    $x$'select 1 from agent_board.boards for update' ~ agent_board_test.row_lock_re('claims')$x$, false),
+  ('r64-row-lock-prefix-word',  $x$'select 1 from agent_board.claims therefor update' ~ agent_board_test.row_lock_re('claims')$x$, false),
+  -- Consiliency/message-board#435 codex round 1: an identifier that ENDS in a verb is not the verb.
+  ('r65-verb-prefix-word',      $x$'xupdate agent_board.boards set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  -- Consiliency/message-board#435 codex round 2: the ON CONFLICT upsert assigns the column too.
+  ('a74-upsert-set-col',        $x$'insert into agent_board.boards (id) values (1) on conflict (id) do update set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a74b-upsert-set-row-form',  $x$'insert into boards (id) values (1) on conflict (id) do update set (slug, claim_policy) = (1, 2)' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('a74c-upsert-excluded-rhs',  $x$'insert into agent_board.boards as b (id) values (1) on conflict on constraint boards_pkey do update set slug = excluded.slug, claim_policy = excluded.claim_policy' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, true),
+  ('r66-upsert-col-in-where',   $x$'insert into agent_board.boards (id) values (1) on conflict (id) do update set slug = 1 where claim_policy = 2' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  ('r66b-upsert-do-nothing',    $x$'insert into agent_board.boards (id) values (1) on conflict (id) do nothing returning claim_policy' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  -- and the same seat's `"b;x"`: a `;` inside a DOUBLE-QUOTED identifier ends same_stmt()'s span.
+  -- Labelled, not fixed: no live body spells an identifier that way, and closing it means a
+  -- quoted-identifier arm in same_stmt AND set_run AND every one of their eleven revert bodies.
+  ('k2-quoted-ident-semicolon-KNOWN-MISS', $x$'update boards as "b;x" set claim_policy = 1' ~ agent_board_test.col_write_re('boards','claim_policy')$x$, false),
+  -- col_ref_frag: a column READ, qualified or bare (#417 PR 3). Each arm has its own row so that a
+  -- revert dropping one arm is named by one row, not concealed by the other.
+  ('a75-colref-qualified',      $x$'where bm.membership_state in (1)' ~ ('(?c)' || agent_board_test.col_ref_frag('membership_state'))$x$, true),
+  ('a75b-colref-qualified-quoted-alias', $x$'order by "M" . created_at desc' ~ ('(?c)' || agent_board_test.col_ref_frag('created_at'))$x$, true),
+  ('a76-colref-bare',           $x$'set membership_state = 1' ~ ('(?c)' || agent_board_test.col_ref_frag('membership_state'))$x$, true),
+  ('r67-colref-suffix-word',    $x$'where bm.membership_states in (1)' ~ ('(?c)' || agent_board_test.col_ref_frag('membership_state'))$x$, false),
+  ('r67b-colref-prefix-word',   $x$'where bm.xmembership_state in (1) or xmembership_state = 2' ~ ('(?c)' || agent_board_test.col_ref_frag('membership_state'))$x$, false);
+
+insert into _mrow(label, expr, want, costly) values
+  ('a66-lock-edges-quoted-callee', $x$exists (select 1 from agent_board_test.lock_edges() where fn_name = '_probe416_quoted_callee' and rel_name = 'agent_board.claims' and lock_mode = 'update' and via = 'callee:acquire_claim')$x$, true, true),
+  ('a67-closure-quoted-callee', $x$exists (select 1 from agent_board_test.fn_call_closure() where root_name = '_probe416_quoted_callee' and reached_name = 'acquire_claim')$x$, true, true);
+
+create function pg_temp.mverdict(p_expr text) returns text
+language plpgsql as $f$
+declare v boolean;
+begin
+  execute format('select (%s)', p_expr) into v;
+  return coalesce(v::text, 'null');
+exception when others then
+  -- A row whose expression cannot compile, or whose matcher raises, reports the MESSAGE. A row that
+  -- expects a raise names the message it expects, so a raise for the wrong reason still fails; a
+  -- row that expects true/false cannot be satisfied by any raise.
+  return 'raises: ' || sqlerrm;
+end $f$;
+
+select is(
+  (select coalesce(string_agg(label || '=' || pg_temp.mverdict(expr), ', ' order by label), '<none>')
+     from _mrow),
+  (select coalesce(string_agg(label || '=' || want, ', ' order by label), '<none>') from _mrow),
+  'CPR-0 MATCHER BEHAVIOUR: over PLAIN and DOUBLE-QUOTED identifiers, the matchers accept the spellings PostgreSQL resolves to our object and reject those it resolves elsewhere; a write matcher sees only the STATEMENT it started (literals and comments are spans, not boundaries), an assignment matcher sees only the SET list, and the write shapes (INSERT without a column list, MERGE ... THEN INSERT, COPY FROM, SELECT INTO, multi-relation TRUNCATE) are each a named row — Unicode-escape identifiers (U&"...") are OUT OF SCOPE and unhandled, three-level SET-list parentheses (k1) and a `;` inside a double-quoted identifier (k2) are labelled KNOWN-MISSes, so this is not a claim about every spelling');
+
+-- CPR-0a. EVERY RULE HAS A ROW THAT FAILS WITHOUT IT — compiled by the database, not by hand.
+-- ONE BEHAVIOUR PER ENTRY, AND EACH NAMES THE ROW THAT MUST FLIP. Both are corrections.
+--
+-- THE SPLIT PAID FOR ITSELF ON ITS FIRST RUN, which is the answer to "why are these so finely
+-- divided": separating the behaviours immediately exposed FOUR matcher rules the coarser hand list
+-- had never reverted — ident_re's quoted alternative, qname_frag's OPTIONAL qualifier, call_re's own
+-- director, and stmt_re's `\s+` between verb and relation. Two of them had no row at all (a18, r16
+-- were added for them). A reviewer tempted to recombine entries should read that as the cost.
+--
+-- NO DESCRIPTION CARRIES A COUNT, and the rule that replaced is worth recording because it was
+-- WRONG in a way that took a reviewer to see. It said a count is "safe" when it sits beside its own
+-- assertion's expected value, since the two would fail together. They do not. PROXIMITY IS NOT
+-- DERIVATION: nothing computes the count from the expected value, so the assertion fails on drift
+-- only until a maintainer updates the expected value — which is the normal maintenance path — and
+-- from that moment the count is silently wrong with nothing failing.
+--
+-- Measured rather than argued: add a function to agent_board_test, and CPR-0b fails; update its
+-- expected value the way a maintainer would, and it passes again while any count in its prose is now
+-- false. So the "safe" category did not exist. There are only counts that are easier to notice and
+-- counts that are harder, and the durable move is the one this package already made when its runner
+-- dropped "28 tests" and "42-migration union": delete them. The expected values enumerate every
+-- member by name; a reader who wants a number can count one that cannot drift.
+--
+-- THE RECURSION IS THE POINT, not an aside: the rule written to prevent stale counts made a claim
+-- broader than its own mechanism supported — the same shape as every finding in this review, in the
+-- sentence codifying the lesson from the previous one.
+--
+-- IN THESE TWO ASSERTIONS the expected values enumerate every entry by name, so no count appears in
+-- either description: it would add nothing a reader cannot see and one more thing that can go stale.
+--
+-- COMPOUND ENTRIES LET A COVERED BRANCH CONCEAL AN UNCOVERED SIBLING: `keyword exclusions` reverted
+-- VALUES and SELECT together, and `lead_guard` reverted its dot-whitespace and non-ASCII guards
+-- together, so deleting one row still left the rule reporting as gated through the other. That is
+-- the r06 defect at the RULE level — the map certifying a rule it only half tests.
+--
+-- AND "SOME ROW FLIPPED" IS NOT "THE ROW FOR THIS RULE FLIPPED". The gate now requires the NAMED
+-- row, so a rule cannot borrow coverage from an unrelated one.
+-- ONE RULE PER SIGNATURE, INCLUDING EACH DELEGATE (Consiliency/message-board#416 PR 1). The family
+-- now has 2-arity cores (`…(name, p_bare_ok)`) and 1-arity delegates that pass `true`. A revert of
+-- a delegate no longer touches a path that goes through the core, so the rules below target the
+-- CORE for a behaviour and the DELEGATE for exactly one thing — that it passes `true` — with a row
+-- that calls the delegate directly. `fn` is a regprocedure spelling; CPR-0b keys on the OID, so a
+-- rule that names a signature which does not exist fails there rather than silently gating nothing.
+-- The revert must recreate the SAME signature: a revert that dropped or narrowed one would be
+-- restored by CPR-0a's `pg_get_functiondef` round-trip and read as gated.
+create temp table _mrule (rule_name text primary key, fn text, expect_row text, revert_sql text) on commit drop;
+
+insert into _mrule(rule_name, fn, expect_row, revert_sql) values
+  ('ci_re: a space becomes \s+', 'agent_board_test.ci_re(text)', 'a08-cire-phrase', $r$
+     create or replace function agent_board_test.ci_re(p_text text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select coalesce(string_agg(case when c ~ '[A-Za-z]' then '[' || upper(c) || lower(c) || ']' else c end, ''), '')
+         from regexp_split_to_table(p_text, '') as c $b$; $r$),
+  ('ident_chars: $ is an identifier character', 'agent_board_test.ident_chars()', 'r05-dollar-lead', $r$
+     create or replace function agent_board_test.ident_chars() returns text
+     language sql immutable set search_path to pg_catalog as $b$ select 'A-Za-z0-9_' $b$; $r$),
+  ('ident_re: the quoted alternative', 'agent_board_test.ident_re(text)', 'a04-quoted-lower', $r$
+     create or replace function agent_board_test.ident_re(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.ci_re(p_name) || ')' $b$; $r$),
+  ('ident_any_frag: the quoted alternative', 'agent_board_test.ident_any_frag()', 'a21b-three-part-quoted-db', $r$
+     create or replace function agent_board_test.ident_any_frag() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:[A-Za-z_][' || agent_board_test.ident_chars() || ']*)' $b$; $r$),
+  ('lead_guard: reject a dot with whitespace', 'agent_board_test.lead_guard()', 'r02-dot-space', $r$
+     create or replace function agent_board_test.lead_guard() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?<![' || agent_board_test.ident_chars() || '."])(?<![^\x00-\x7F])' $b$; $r$),
+  ('lead_guard: reject a leading non-ASCII letter', 'agent_board_test.lead_guard()', 'r07-nonascii-lead', $r$
+     create or replace function agent_board_test.lead_guard() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?<![' || agent_board_test.ident_chars() || '."])(?<!\.\s*)' $b$; $r$),
+  ('lead_guard: reject a leading identifier character', 'agent_board_test.lead_guard()', 'r56-qname-prefix-word', $r$
+     create or replace function agent_board_test.lead_guard() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?<![."])(?<![^\x00-\x7F])(?<!\.\s*)' $b$; $r$),
+  ('trail_guard: reject a trailing non-ASCII letter', 'agent_board_test.trail_guard()', 'r08-nonascii-trail', $r$
+     create or replace function agent_board_test.trail_guard() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?![' || agent_board_test.ident_chars() || '])' $b$; $r$),
+  ('trail_guard: reject a trailing identifier character', 'agent_board_test.trail_guard()', 'r23-write-suffix-word', $r$
+     create or replace function agent_board_test.trail_guard() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?![^\x00-\x7F])' $b$; $r$),
+  ('same_stmt: a literal is a span, not a boundary', 'agent_board_test.same_stmt()', 'a52-merge-span-lit-semicolon', $r$
+     create or replace function agent_board_test.same_stmt() returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '[^;]*' $b$; $r$),
+  ('same_stmt: the E-string arm', 'agent_board_test.same_stmt()', 'a53-merge-span-estring', $r$
+     create or replace function agent_board_test.same_stmt() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select $s$(?:[^;']|'(?:[^']|'')*')*$s$ $b$; $r$),
+  ('same_stmt: E must be a standalone token', 'agent_board_test.same_stmt()', 'r57-same-stmt-estring-guard', $r$
+     create or replace function agent_board_test.same_stmt() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select $s$(?:[^;']|[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*')*$s$ $b$; $r$),
+  -- set_run: every revert keeps the CTE shape so that the one changed piece is the behaviour named.
+  ('set_run: a terminator ends the run (the lookahead)', 'agent_board_test.set_run(text)', 'r25-col-in-where', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with lit as (select $s$(?<![A-Za-z0-9_$])[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*'$s$ as l),
+       p0 as (select '\((?:[^();'']|' || l || ')*\)' as p from lit),
+       p1 as (select '\((?:[^();'']|' || lit.l || '|' || p0.p || ')*\)' as p from lit, p0)
+       select '(?:(?:[^;''()]|' || lit.l || '|' || p1.p || '))*' from lit, p1 $b$; $r$),
+  ('set_run: a parenthesised span is whole', 'agent_board_test.set_run(text)', 'a26-set-subquery-then-col', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with chars as (select c, ord, coalesce(lag(c) over (order by ord), '') as prev
+                        from regexp_split_to_table(p_terms, '') with ordinality as x(c, ord)),
+       t as (select string_agg(case when c ~ '[A-Za-z]' and prev <> '\' then '[' || upper(c) || lower(c) || ']' else c end, '' order by ord) as folded from chars),
+       lit as (select $s$(?<![A-Za-z0-9_$])[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*'$s$ as l)
+       select '(?:(?!\m(?:' || t.folded || ')\M)(?:[^;'']|' || lit.l || '))*' from t, lit $b$; $r$),
+  ('set_run: parentheses nest two levels', 'agent_board_test.set_run(text)', 'a55-set-two-level-paren', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with chars as (select c, ord, coalesce(lag(c) over (order by ord), '') as prev
+                        from regexp_split_to_table(p_terms, '') with ordinality as x(c, ord)),
+       t as (select string_agg(case when c ~ '[A-Za-z]' and prev <> '\' then '[' || upper(c) || lower(c) || ']' else c end, '' order by ord) as folded from chars),
+       lit as (select $s$(?<![A-Za-z0-9_$])[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*'$s$ as l),
+       p0 as (select '\((?:[^();'']|' || l || ')*\)' as p from lit)
+       select '(?:(?!\m(?:' || t.folded || ')\M)(?:[^;''()]|' || lit.l || '|' || p0.p || '))*' from t, lit, p0 $b$; $r$),
+  ('set_run: terminator letters are case-folded', 'agent_board_test.set_run(text)', 'r38-set-run-upper-terminator', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with lit as (select $s$(?<![A-Za-z0-9_$])[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*'$s$ as l),
+       p0 as (select '\((?:[^();'']|' || l || ')*\)' as p from lit),
+       p1 as (select '\((?:[^();'']|' || lit.l || '|' || p0.p || ')*\)' as p from lit, p0)
+       select '(?:(?!\m(?:' || p_terms || ')\M)(?:[^;''()]|' || lit.l || '|' || p1.p || '))*' from lit, p1 $b$; $r$),
+  ('set_run: a backslash-escaped letter is NOT folded', 'agent_board_test.set_run(text)', 'r42-merge-col-in-next-when-pred', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with t as (select string_agg(case when c ~ '[A-Za-z]' then '[' || upper(c) || lower(c) || ']' else c end, '') as folded
+                    from regexp_split_to_table(p_terms, '') as c),
+       lit as (select $s$(?<![A-Za-z0-9_$])[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*'$s$ as l),
+       p0 as (select '\((?:[^();'']|' || l || ')*\)' as p from lit),
+       p1 as (select '\((?:[^();'']|' || lit.l || '|' || p0.p || ')*\)' as p from lit, p0)
+       select '(?:(?!\m(?:' || t.folded || ')\M)(?:[^;''()]|' || lit.l || '|' || p1.p || '))*' from t, lit, p1 $b$; $r$),
+  ('set_run: a literal in the SET list is a span', 'agent_board_test.set_run(text)', 'a19-span-lit-semicolon', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with chars as (select c, ord, coalesce(lag(c) over (order by ord), '') as prev
+                        from regexp_split_to_table(p_terms, '') with ordinality as x(c, ord)),
+       t as (select string_agg(case when c ~ '[A-Za-z]' and prev <> '\' then '[' || upper(c) || lower(c) || ']' else c end, '' order by ord) as folded from chars),
+       p0 as (select '\((?:[^();])*\)' as p),
+       p1 as (select '\((?:[^();]|' || p0.p || ')*\)' as p from p0)
+       select '(?:(?!\m(?:' || t.folded || ')\M)(?:[^;()]|' || p1.p || '))*' from t, p1 $b$; $r$),
+  ('set_run: the E-string arm', 'agent_board_test.set_run(text)', 'a28-span-estring', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with chars as (select c, ord, coalesce(lag(c) over (order by ord), '') as prev
+                        from regexp_split_to_table(p_terms, '') with ordinality as x(c, ord)),
+       t as (select string_agg(case when c ~ '[A-Za-z]' and prev <> '\' then '[' || upper(c) || lower(c) || ']' else c end, '' order by ord) as folded from chars),
+       lit as (select $s$'(?:[^']|'')*'$s$ as l),
+       p0 as (select '\((?:[^();'']|' || l || ')*\)' as p from lit),
+       p1 as (select '\((?:[^();'']|' || lit.l || '|' || p0.p || ')*\)' as p from lit, p0)
+       select '(?:(?!\m(?:' || t.folded || ')\M)(?:[^;''()]|' || lit.l || '|' || p1.p || '))*' from t, lit, p1 $b$; $r$),
+  ('set_run: E must be a standalone token', 'agent_board_test.set_run(text)', 'r58-set-run-estring-guard', $r$
+     create or replace function agent_board_test.set_run(p_terms text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       with chars as (select c, ord, coalesce(lag(c) over (order by ord), '') as prev
+                        from regexp_split_to_table(p_terms, '') with ordinality as x(c, ord)),
+       t as (select string_agg(case when c ~ '[A-Za-z]' and prev <> '\' then '[' || upper(c) || lower(c) || ']' else c end, '' order by ord) as folded from chars),
+       lit as (select $s$[Ee]'(?:[^'\\]|\\.|'')*'|'(?:[^']|'')*'$s$ as l),
+       p0 as (select '\((?:[^();'']|' || l || ')*\)' as p from lit),
+       p1 as (select '\((?:[^();'']|' || lit.l || '|' || p0.p || ')*\)' as p from lit, p0)
+       select '(?:(?!\m(?:' || t.folded || ')\M)(?:[^;''()]|' || lit.l || '|' || p1.p || '))*' from t, lit, p1 $b$; $r$),
+  ('re: the (?c) director', 'agent_board_test.re(text)', 'r43-re-i-flag', $r$
+     create or replace function agent_board_test.re(p_frag text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '(?:' || p_frag || ')' $b$; $r$),
+  ('re: the frag is grouped', 'agent_board_test.re(text)', 'r44-re-groups-the-frag', $r$
+     create or replace function agent_board_test.re(p_frag text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '(?c)' || p_frag $b$; $r$),
+  ('qname_frag(core): the qualifier is OPTIONAL when bare is ok', 'agent_board_test.qname_frag(text,boolean)', 'a02-unqualified', $r$
+     create or replace function agent_board_test.qname_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('qname_frag(core): the qualifier is REQUIRED when bare is not ok', 'agent_board_test.qname_frag(text,boolean)', 'r24-bare-when-required', $r$
+     create or replace function agent_board_test.qname_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('qname_frag(core): an optional database component', 'agent_board_test.qname_frag(text,boolean)', 'a21-three-part-name', $r$
+     create or replace function agent_board_test.qname_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:' || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)' || case when p_bare_ok then '?' else '' end
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('qname_frag(core): the database component is bound to the schema', 'agent_board_test.qname_frag(text,boolean)', 'r01-other-schema', $r$
+     create or replace function agent_board_test.qname_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?(?:'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)' || case when p_bare_ok then '?' else '' end
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('qname_frag(core): a dotted name is split at the dot', 'agent_board_test.qname_frag(text,boolean)', 'a68-dotted-name-quoted-parts', $r$
+     create or replace function agent_board_test.qname_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?'
+           || agent_board_test.ident_re('agent_board')
+           || '\s*\.\s*)' || case when p_bare_ok then '?' else '' end
+           || agent_board_test.ident_re(p_name)
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('qname_frag(delegate): bare is ok', 'agent_board_test.qname_frag(text)', 'a50-qname-re-bare', $r$
+     create or replace function agent_board_test.qname_frag(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.qname_frag(p_name, false) $b$; $r$),
+  ('qname_re: the (?c) director', 'agent_board_test.qname_re(text)', 'r11-i-flag', $r$
+     create or replace function agent_board_test.qname_re(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.qname_frag(p_name) $b$; $r$),
+  ('call_frag(core): whitespace may precede the paren', 'agent_board_test.call_frag(text,boolean)', 'a10-call-space', $r$
+     create or replace function agent_board_test.call_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)' || case when p_bare_ok then '?' else '' end
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || '\(' $b$; $r$),
+  ('call_frag(core): the qualifier is REQUIRED when bare is not ok', 'agent_board_test.call_frag(text,boolean)', 'r31-bare-callee-when-required', $r$
+     create or replace function agent_board_test.call_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || '\s*\(' $b$; $r$),
+  ('call_frag(core): the callee may be quoted', 'agent_board_test.call_frag(text,boolean)', 'a29-quoted-callee', $r$
+     create or replace function agent_board_test.call_frag(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard()
+           || '(?:(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*)?'
+           || agent_board_test.ident_re(case when p_name like '%.%' then split_part(p_name, '.', 1) else 'agent_board' end)
+           || '\s*\.\s*)' || case when p_bare_ok then '?' else '' end
+           || agent_board_test.ci_re(case when p_name like '%.%' then split_part(p_name, '.', 2) else p_name end)
+           || '\s*\(' $b$; $r$),
+  ('call_frag(delegate): bare is ok', 'agent_board_test.call_frag(text)', 'a65-call-frag-bare', $r$
+     create or replace function agent_board_test.call_frag(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.call_frag(p_name, false) $b$; $r$),
+  ('call_re(core): the (?c) director', 'agent_board_test.call_re(text,boolean)', 'r16-call-i-flag', $r$
+     create or replace function agent_board_test.call_re(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.call_frag(p_name, p_bare_ok) $b$; $r$),
+  ('call_re(core): the flag is passed through', 'agent_board_test.call_re(text,boolean)', 'a48-call-re-two-eq-frag', $r$
+     create or replace function agent_board_test.call_re(p_name text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '(?c)' || agent_board_test.call_frag(p_name, true) $b$; $r$),
+  ('call_re(delegate): bare is ok', 'agent_board_test.call_re(text)', 'a10-call-space', $r$
+     create or replace function agent_board_test.call_re(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.call_re(p_name, false) $b$; $r$),
+  ('col_frag: the column token carries identifier rules', 'agent_board_test.col_frag(text)', 'a12-col-upper', $r$
+     create or replace function agent_board_test.col_frag(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.lead_guard() || p_name || agent_board_test.trail_guard() $b$; $r$),
+  ('col_ref_frag: the qualified arm', 'agent_board_test.col_ref_frag(text)', 'a75-colref-qualified', $r$
+     create or replace function agent_board_test.col_ref_frag(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_frag(p_name) || ')' $b$; $r$),
+  ('col_ref_frag: the bare arm', 'agent_board_test.col_ref_frag(text)', 'a76-colref-bare', $r$
+     create or replace function agent_board_test.col_ref_frag(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*' || agent_board_test.ident_re(p_name) || agent_board_test.trail_guard() || ')' $b$; $r$),
+  ('col_ref_frag: the qualified arm ends at an identifier boundary', 'agent_board_test.col_ref_frag(text)', 'r67-colref-suffix-word', $r$
+     create or replace function agent_board_test.col_ref_frag(p_name text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.ident_any_frag() || '\s*\.\s*' || agent_board_test.ident_re(p_name)
+              || '|' || agent_board_test.col_frag(p_name) || ')' $b$; $r$),
+  ('stmt_frag(core): \s+ between the verb and the relation', 'agent_board_test.stmt_frag(text,text,boolean)', 'a18-verb-rel-spaces', $r$
+     create or replace function agent_board_test.stmt_frag(p_verbs text, p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '\m(?:' || (select string_agg(agent_board_test.ci_re(v), '|') from regexp_split_to_table(p_verbs, '\|') as v)
+           || ') (?:' || agent_board_test.ci_re('only') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok) $b$; $r$),
+  ('stmt_frag(core): the flag reaches the relation', 'agent_board_test.stmt_frag(text,text,boolean)', 'r24-bare-when-required', $r$
+     create or replace function agent_board_test.stmt_frag(p_verbs text, p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '\m(?:' || (select string_agg(agent_board_test.ci_re(v), '|') from regexp_split_to_table(p_verbs, '\|') as v)
+           || ')\s+(?:' || agent_board_test.ci_re('only') || '\s+)?' || agent_board_test.qname_frag(p_rel, true) $b$; $r$),
+  ('stmt_frag(core): the verb starts a word', 'agent_board_test.stmt_frag(text,text,boolean)', 'r65-verb-prefix-word', $r$
+     create or replace function agent_board_test.stmt_frag(p_verbs text, p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || (select string_agg(agent_board_test.ci_re(v), '|') from regexp_split_to_table(p_verbs, '\|') as v)
+           || ')\s+(?:' || agent_board_test.ci_re('only') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok) $b$; $r$),
+  ('stmt_frag(delegate): bare is ok', 'agent_board_test.stmt_frag(text,text)', 'a64-stmt-frag-bare', $r$
+     create or replace function agent_board_test.stmt_frag(p_verbs text, p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.stmt_frag(p_verbs, p_rel, false) $b$; $r$),
+  ('stmt_re(core): the (?c) director', 'agent_board_test.stmt_re(text,text,boolean)', 'r40-stmt-re-i-flag', $r$
+     create or replace function agent_board_test.stmt_re(p_verbs text, p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.stmt_frag(p_verbs, p_rel, p_bare_ok) $b$; $r$),
+  ('stmt_re(core): the flag is passed through', 'agent_board_test.stmt_re(text,text,boolean)', 'r24-bare-when-required', $r$
+     create or replace function agent_board_test.stmt_re(p_verbs text, p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '(?c)' || agent_board_test.stmt_frag(p_verbs, p_rel, true) $b$; $r$),
+  ('stmt_re(delegate): bare is ok', 'agent_board_test.stmt_re(text,text)', 'a02-unqualified', $r$
+     create or replace function agent_board_test.stmt_re(p_verbs text, p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.stmt_re(p_verbs, p_rel, false) $b$; $r$),
+  ('insert rule(core): the VALUES exclusion', 'agent_board_test.insert_all_columns_frag(text,boolean)', 'a13-ins-novals', $r$
+     create or replace function agent_board_test.insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
+           || agent_board_test.ci_re('select') || '(?![A-Za-z0-9_$]))'
+           || agent_board_test.ident_any_frag() || ')?\s*\()' $b$; $r$),
+  ('insert rule(core): the SELECT exclusion', 'agent_board_test.insert_all_columns_frag(text,boolean)', 'a14-ins-select', $r$
+     create or replace function agent_board_test.insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
+           || agent_board_test.ci_re('values') || '(?![A-Za-z0-9_$]))'
+           || agent_board_test.ident_any_frag() || ')?\s*\()' $b$; $r$),
+  ('insert rule(core): no backtracking before the paren', 'agent_board_test.insert_all_columns_frag(text,boolean)', 'r13-ins-collist', $r$
+     create or replace function agent_board_test.insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || '\s*(?!\()' $b$; $r$),
+  ('insert rule(core): the quoted-alias alternative', 'agent_board_test.insert_all_columns_frag(text,boolean)', 'r15-ins-qalias', $r$
+     create or replace function agent_board_test.insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
+           || agent_board_test.ci_re('values') || '(?![A-Za-z0-9_$])|'
+           || agent_board_test.ci_re('select') || '(?![A-Za-z0-9_$]))'
+           || '[A-Za-z_][A-Za-z0-9_$]*)?\s*\()' $b$; $r$),
+  ('insert rule(core): the flag reaches the relation', 'agent_board_test.insert_all_columns_frag(text,boolean)', 'r53-ins-novals-bare-when-required', $r$
+     create or replace function agent_board_test.insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('insert into', p_rel, true)
+           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
+           || agent_board_test.ci_re('values') || '(?![A-Za-z0-9_$])|'
+           || agent_board_test.ci_re('select') || '(?![A-Za-z0-9_$]))'
+           || agent_board_test.ident_any_frag() || ')?\s*\()' $b$; $r$),
+  ('insert rule(delegate): bare is ok', 'agent_board_test.insert_all_columns_frag(text)', 'a51-ins-novals-bare', $r$
+     create or replace function agent_board_test.insert_all_columns_frag(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.insert_all_columns_frag(p_rel, false) $b$; $r$),
+  ('insert re: composed from the frag', 'agent_board_test.insert_all_columns_re(text)', 'a17-ins-re-eq-frag', $r$
+     create or replace function agent_board_test.insert_all_columns_re(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.insert_all_columns_frag(p_rel) $b$; $r$),
+  ('merge insert rule(core): a column list is refused', 'agent_board_test.merge_insert_all_columns_frag(text,boolean)', 'r18-merge-ins-collist', $r$
+     create or replace function agent_board_test.merge_insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then') || '\s+' || agent_board_test.ci_re('insert') || '(?![A-Za-z0-9_$])' $b$; $r$),
+  ('merge insert rule(core): THEN INSERT is required', 'agent_board_test.merge_insert_all_columns_frag(text,boolean)', 'r19-merge-do-nothing', $r$
+     create or replace function agent_board_test.merge_insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) $b$; $r$),
+  ('merge insert rule(core): the flag reaches the relation', 'agent_board_test.merge_insert_all_columns_frag(text,boolean)', 'r52-merge-ins-bare-when-required', $r$
+     create or replace function agent_board_test.merge_insert_all_columns_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.stmt_frag('merge into', p_rel, true) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then') || '\s+' || agent_board_test.ci_re('insert')
+           || '\s*(?:' || agent_board_test.ci_re('default values') || '|' || agent_board_test.ci_re('values')
+           || '|' || agent_board_test.ci_re('overriding') || ')(?![A-Za-z0-9_$])' $b$; $r$),
+  ('merge insert rule(delegate): bare is ok', 'agent_board_test.merge_insert_all_columns_frag(text)', 'a20c-merge-ins-novals-bare', $r$
+     create or replace function agent_board_test.merge_insert_all_columns_frag(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.merge_insert_all_columns_frag(p_rel, false) $b$; $r$),
+  -- write_frag: each revert drops or narrows ONE arm of the write grammar.
+  ('write_frag(core): the DML verbs', 'agent_board_test.write_frag(text,boolean)', 'a57-write-re-bare', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\([^)]*\))?\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('write_frag(core): TRUNCATE names a list', 'agent_board_test.write_frag(text,boolean)', 'a36-truncate-list-second', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\([^)]*\))?\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('write_frag(core): TRUNCATE [TABLE] [ONLY]', 'agent_board_test.write_frag(text,boolean)', 'a23-truncate-table-only', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate') || '\s+'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\([^)]*\))?\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('write_frag(core): COPY only writes when FROM', 'agent_board_test.write_frag(text,boolean)', 'r22-copy-to', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('write_frag(core): COPY may carry a column list', 'agent_board_test.write_frag(text,boolean)', 'a22b-copy-collist-from', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('write_frag(core): SELECT INTO a table is a write', 'agent_board_test.write_frag(text,boolean)', 'a42-select-into-table', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\([^)]*\))?\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || ')' $b$; $r$),
+  ('write_frag(core): INTO must name the relation, not a variable', 'agent_board_test.write_frag(text,boolean)', 'r45-select-into-var-from-write', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, p_bare_ok)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\([^)]*\))?\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\M' || agent_board_test.same_stmt() || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('write_frag(core): the flag reaches every arm', 'agent_board_test.write_frag(text,boolean)', 'r50-write-bare-when-required', $r$
+     create or replace function agent_board_test.write_frag(p_rel text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('insert into|merge into|update|delete from', p_rel, true)
+           || '|' || agent_board_test.lead_guard() || agent_board_test.ci_re('truncate')
+           || '(?:\s+' || agent_board_test.ci_re('table') || ')?\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
+           || '(?:[A-Za-z_"][A-Za-z0-9_."]*\s*\*?\s*,\s*(?:' || agent_board_test.ci_re('only') || '\s+)?)*'
+           || agent_board_test.qname_frag(p_rel, true)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, true)
+           || '\s*(?:\([^)]*\))?\s*' || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, true)
+           || ')' $b$; $r$),
+  ('write_frag(delegate): bare is ok', 'agent_board_test.write_frag(text)', 'a57-write-re-bare', $r$
+     create or replace function agent_board_test.write_frag(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.write_frag(p_rel, false) $b$; $r$),
+  ('write_re: the (?c) director', 'agent_board_test.write_re(text)', 'r46-write-re-i-flag', $r$
+     create or replace function agent_board_test.write_re(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.write_frag(p_rel) $b$; $r$),
+  ('writes_any_frag(core): an empty list is refused', 'agent_board_test.writes_any_frag(text[],boolean)', 'r37-writes-any-empty-refused', $r$
+     create or replace function agent_board_test.writes_any_frag(p_rels text[], p_bare_ok boolean) returns text
+     language plpgsql immutable set search_path to pg_catalog as $b$
+     begin
+       return '(?:' || coalesce((select string_agg(agent_board_test.write_frag(r, p_bare_ok), '|') from unnest(p_rels) as r), 'x') || ')';
+     end $b$; $r$),
+  ('writes_any_frag(core): the union covers every relation', 'agent_board_test.writes_any_frag(text[],boolean)', 'a43-writes-any', $r$
+     create or replace function agent_board_test.writes_any_frag(p_rels text[], p_bare_ok boolean) returns text
+     language plpgsql immutable set search_path to pg_catalog as $b$
+     begin
+       if p_rels is null or cardinality(p_rels) = 0 then
+         raise exception 'writes_any_frag: the relation list is empty';
+       end if;
+       return '(?:' || agent_board_test.write_frag(p_rels[1], p_bare_ok) || ')';
+     end $b$; $r$),
+  ('writes_any_frag(core): the flag reaches every relation', 'agent_board_test.writes_any_frag(text[],boolean)', 'r51-writes-any-bare-when-required', $r$
+     create or replace function agent_board_test.writes_any_frag(p_rels text[], p_bare_ok boolean) returns text
+     language plpgsql immutable set search_path to pg_catalog as $b$
+     begin
+       if p_rels is null or cardinality(p_rels) = 0 then
+         raise exception 'writes_any_frag: the relation list is empty';
+       end if;
+       return '(?:' || (select string_agg(agent_board_test.write_frag(r, true), '|') from unnest(p_rels) as r) || ')';
+     end $b$; $r$),
+  ('writes_any_frag(delegate): bare is ok', 'agent_board_test.writes_any_frag(text[])', 'a58-writes-any-bare', $r$
+     create or replace function agent_board_test.writes_any_frag(p_rels text[]) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.writes_any_frag(p_rels, false) $b$; $r$),
+  ('writes_any_re: the (?c) director', 'agent_board_test.writes_any_re(text[])', 'r47-writes-any-re-i-flag', $r$
+     create or replace function agent_board_test.writes_any_re(p_rels text[]) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.writes_any_frag(p_rels) $b$; $r$),
+  ('writes_any_re: composed from the frag', 'agent_board_test.writes_any_re(text[])', 'a47-writes-any-re-eq-frag', $r$
+     create or replace function agent_board_test.writes_any_re(p_rels text[]) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '(?c)(?:' || agent_board_test.writes_any_frag(p_rels) || ')' $b$; $r$),
+  -- row_lock_frag / row_lock_re: the explicit locking clause, and the clause bound to a relation
+  -- within one statement.
+  ('row_lock_frag: NO KEY is an admitted qualifier', 'agent_board_test.row_lock_frag()', 'a71-row-lock-no-key-update', $r$
+     create or replace function agent_board_test.row_lock_frag() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '\m' || agent_board_test.ci_re('for') || '\s+(?:'
+           || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')'
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('row_lock_frag: the lock word is whole', 'agent_board_test.row_lock_frag()', 'r62-row-lock-suffix-word', $r$
+     create or replace function agent_board_test.row_lock_frag() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '\m' || agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:'
+           || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')' $b$; $r$),
+  ('row_lock_frag: FOR starts a word', 'agent_board_test.row_lock_frag()', 'r64-row-lock-prefix-word', $r$
+     create or replace function agent_board_test.row_lock_frag() returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:'
+           || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')'
+           || agent_board_test.trail_guard() $b$; $r$),
+  ('row_lock_re: the clause is bound to ONE statement', 'agent_board_test.row_lock_re(text)', 'r61-row-lock-next-stmt', $r$
+     create or replace function agent_board_test.row_lock_re(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?c)' || agent_board_test.qname_frag(p_rel) || '(?:.|\n)*' || agent_board_test.row_lock_frag() $b$; $r$),
+  ('row_lock_re: a literal is stepped over, not a boundary', 'agent_board_test.row_lock_re(text)', 'r60-row-lock-in-literal', $r$
+     create or replace function agent_board_test.row_lock_re(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?c)' || agent_board_test.qname_frag(p_rel) || '[^;]*' || agent_board_test.row_lock_frag() $b$; $r$),
+  ('row_lock_re: bound to the named relation', 'agent_board_test.row_lock_re(text)', 'r63-row-lock-other-rel', $r$
+     create or replace function agent_board_test.row_lock_re(p_rel text) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?c)' || agent_board_test.same_stmt() || agent_board_test.row_lock_frag() $b$; $r$),
+  -- col_assign_frag: arm (1) UPDATE ... SET, arm (3) MERGE ... THEN UPDATE SET. The row form and the
+  -- terminators are each one revert.
+  ('col_assign_frag: the scalar SET arm', 'agent_board_test.col_assign_frag(text,text,boolean)', 'a59-set-scalar-col', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || '\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: the row-form SET arm', 'agent_board_test.col_assign_frag(text,text,boolean)', 'a25-set-row-form', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: the MERGE arm', 'agent_board_test.col_assign_frag(text,text,boolean)', 'a31-merge-when-matched-and-pred', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: the column is in ASSIGNMENT position (not merely after SET)', 'agent_board_test.col_assign_frag(text,text,boolean)', 'r25-col-in-where', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.same_stmt()
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: FROM ends the SET list', 'agent_board_test.col_assign_frag(text,text,boolean)', 'r54-set-run-from-terminator-no-where', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: RETURNING ends the SET list', 'agent_board_test.col_assign_frag(text,text,boolean)', 'r55-set-run-returning-terminator-eq', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: WHEN ends the MERGE SET list', 'agent_board_test.col_assign_frag(text,text,boolean)', 'r42-merge-col-in-next-when-pred', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: the flag reaches the relation', 'agent_board_test.col_assign_frag(text,text,boolean)', 'r49-col-write-bare-when-required', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, true) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, true) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('where|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: the upsert arm', 'agent_board_test.col_assign_frag(text,text,boolean)', 'a74-upsert-set-col', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || ')' $b$; $r$),
+  ('col_assign_frag: WHERE ends the upsert SET list', 'agent_board_test.col_assign_frag(text,text,boolean)', 'r66-upsert-col-in-where', $r$
+     create or replace function agent_board_test.col_assign_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.stmt_frag('update', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('set') || '\M' || agent_board_test.set_run('where|from|returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then update set') || '\M'
+           || agent_board_test.set_run('when\s+(?:not\s+)?matched|returning')
+           || agent_board_test.col_frag(p_col) || '\s*='
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('do update set') || '\M' || agent_board_test.set_run('returning')
+           || '(?:' || agent_board_test.col_frag(p_col) || '|\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\))\s*='
+           || ')' $b$; $r$),
+  -- col_write_frag: the union of the assignment arms and every write SHAPE. Each revert drops or
+  -- narrows exactly one arm.
+  ('col_write_frag(core): the INSERT column-list arm', 'agent_board_test.col_write_frag(text,text,boolean)', 'a60-insert-collist-col', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the INSERT alias before the column list', 'agent_board_test.col_write_frag(text,text,boolean)', 'a40-insert-alias-collist', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the column must be INSIDE the INSERT column list', 'agent_board_test.col_write_frag(text,text,boolean)', 'r28-insert-select-col', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok) || agent_board_test.same_stmt() || agent_board_test.col_frag(p_col)
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the MERGE column-list arm', 'agent_board_test.col_write_frag(text,text,boolean)', 'a41-merge-ins-collist-col', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the INSERT-without-column-list arm', 'agent_board_test.col_write_frag(text,text,boolean)', 'a61-ins-novals-via-col-write', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the MERGE-without-column-list arm', 'agent_board_test.col_write_frag(text,text,boolean)', 'a20b-merge-ins-novals-via-col-write', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the COPY arm names the column', 'agent_board_test.col_write_frag(text,text,boolean)', 'a38-copy-collist-col-from', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): a COPY column list must NAME the column', 'agent_board_test.col_write_frag(text,text,boolean)', 'r32-copy-other-cols-from', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\([^)]*\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the SELECT INTO arm', 'agent_board_test.col_write_frag(text,text,boolean)', 'a62-select-into-via-col-write', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || ')' $b$; $r$),
+  ('col_write_frag(core): INTO must name the relation, not a variable', 'agent_board_test.col_write_frag(text,text,boolean)', 'r36-select-into-var-from', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, p_bare_ok)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, p_bare_ok) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, p_bare_ok)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, p_bare_ok)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\M' || agent_board_test.same_stmt() || agent_board_test.qname_frag(p_rel, p_bare_ok)
+           || ')' $b$; $r$),
+  ('col_write_frag(core): the flag reaches every arm', 'agent_board_test.col_write_frag(text,text,boolean)', 'r49-col-write-bare-when-required', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text, p_bare_ok boolean) returns text
+     language sql immutable set search_path to pg_catalog as $b$
+       select '(?:' || agent_board_test.col_assign_frag(p_rel, p_col, true)
+           || '|' || agent_board_test.stmt_frag('insert into', p_rel, true)
+           || '(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?' || agent_board_test.ident_any_frag() || ')?'
+           || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.stmt_frag('merge into', p_rel, true) || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('then insert') || '\s*\([^)]*' || agent_board_test.col_frag(p_col) || '[^)]*\)'
+           || '|' || agent_board_test.insert_all_columns_frag(p_rel, true)
+           || '|' || agent_board_test.merge_insert_all_columns_frag(p_rel, true)
+           || '|' || agent_board_test.stmt_frag('copy', p_rel, true)
+           || '\s*(?:\((?:[^)]*' || agent_board_test.col_frag(p_col) || '[^)]*)\))?\s*'
+           || agent_board_test.ci_re('from') || agent_board_test.trail_guard()
+           || '|' || '\m' || agent_board_test.ci_re('select') || '\M' || agent_board_test.same_stmt()
+           || '\m' || agent_board_test.ci_re('into') || '\s+(?:(?:' || agent_board_test.ci_re('temporary')
+           || '|' || agent_board_test.ci_re('temp') || '|' || agent_board_test.ci_re('unlogged') || ')\s+)?'
+           || '(?:' || agent_board_test.ci_re('table') || '\s+)?' || agent_board_test.qname_frag(p_rel, true)
+           || ')' $b$; $r$),
+  ('col_write_frag(delegate): bare is ok', 'agent_board_test.col_write_frag(text,text)', 'a19-span-lit-semicolon', $r$
+     create or replace function agent_board_test.col_write_frag(p_rel text, p_col text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.col_write_frag(p_rel, p_col, false) $b$; $r$),
+  ('col_write_re: the (?c) director', 'agent_board_test.col_write_re(text,text)', 'r48-col-write-re-i-flag', $r$
+     create or replace function agent_board_test.col_write_re(p_rel text, p_col text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select agent_board_test.col_write_frag(p_rel, p_col) $b$; $r$),
+  ('col_write_re: composed from the frag', 'agent_board_test.col_write_re(text,text)', 'a45-col-write-re-eq-frag', $r$
+     create or replace function agent_board_test.col_write_re(p_rel text, p_col text) returns text
+     language sql immutable set search_path to pg_catalog as $b$ select '(?c)(?:' || agent_board_test.col_write_frag(p_rel, p_col) || ')' $b$; $r$),
+  -- The two body readers are GATED rather than exempt: their fixture is the quoted-callee function
+  -- created above, and the revert empties each of them while keeping its signature.
+  ('lock_edges: a quoted callee is an edge', 'agent_board_test.lock_edges()', 'a66-lock-edges-quoted-callee', $r$
+     create or replace function agent_board_test.lock_edges()
+     returns table(fn_oid oid, fn_name text, fn_sig text, rel_oid oid, rel_name text, lock_mode text, via text, path integer[], own boolean, origin_oid oid, origin_name text)
+     language sql stable set search_path to pg_catalog as $b$
+       select null::oid, null::text, null::text, null::oid, null::text, null::text, null::text, null::integer[], null::boolean, null::oid, null::text where false $b$; $r$),
+  ('fn_call_closure: a quoted callee is reached', 'agent_board_test.fn_call_closure()', 'a67-closure-quoted-callee', $r$
+     create or replace function agent_board_test.fn_call_closure()
+     returns table(root_oid oid, root_name text, reached_oid oid, reached_name text)
+     language sql stable as $b$
+       select null::oid, null::text, null::oid, null::text where false $b$; $r$);
+
+create temp table _mflip (rule_name text, expect_row text, flipped text, named_row_flipped boolean) on commit drop;
+
+do $mut$
+declare
+  r      record;
+  v_save text;
+  v_hits text;
+begin
+  for r in select * from _mrule order by rule_name loop
+    v_save := pg_get_functiondef(r.fn::regprocedure);
+    execute r.revert_sql;
+    select coalesce(string_agg(m.label, ' ' order by m.label), '<NONE>')
+      into v_hits
+      from _mrow m
+     where (not m.costly or r.fn in ('agent_board_test.lock_edges()', 'agent_board_test.fn_call_closure()'))
+       and pg_temp.mverdict(m.expr) <> m.want;
+    execute v_save;                       -- restore before the next rule
+    insert into _mflip
+    values (r.rule_name, r.expect_row, v_hits,
+            v_hits ~ ('(^| )' || r.expect_row || '( |$)'));
+  end loop;
+end $mut$;
+
+select is(
+  (select coalesce(string_agg(rule_name || ' (wanted ' || expect_row || ', got ' || flipped || ')',
+                              '; ' order by rule_name), '<none>')
+     from _mflip where not named_row_flipped),
+  '<none>',
+  'CPR-0a REVERT MAP (mechanical): reverting each rule makes THE ROW NAMED FOR THAT RULE fail — one behaviour per entry and a named row per entry, so a compound revert cannot let a covered branch conceal an uncovered sibling and no rule can borrow coverage from an unrelated row — the map is compiled by reverting each rule and re-evaluating the rows, not by hand, because three separate rows have now certified axes they did not test and a human reading the table caught none of them');
+
+-- CPR-0b. AND THE RULE INVENTORY IS RECONCILED AGAINST THE CATALOG, because _mrule is still written
+-- by hand and a matcher added without an entry would be SILENTLY UNGATED — which contradicts
+-- CPR-0a's own sentence. Deriving "every rule a regex-building function implements" from its source
+-- is not mechanical; deriving "every FUNCTION in this schema is either gated or positively NOT a
+-- matcher" is, and it closes the exposure that matters: a new matcher cannot arrive unnoticed.
+--
+-- THE EXEMPTION IS NOW ASSERTED, NOT LISTED (Consiliency/message-board#416 PR 1). The previous
+-- version named the ungated functions `NOT-GATED` and called them "body readers and lock helpers,
+-- which build no regex" — prose nothing checked. A helper that RETURNS `'\m' || p_name || '\M'`,
+-- or one that builds a pattern from a variable, would have joined that list with the same label.
+-- Every function without an `_mrule` row now has to satisfy, over its literal-STRIPPED source:
+--   (2a) every regex-operator right-hand side in its body (`~`, `~*`, `!~`, `!~*`, the pattern
+--        argument of `regexp_*(…)`, and `substring(… from …)`) is a constant — a literal collapses
+--        to whitespace under strip_sql — or a call to a GATED function, with nothing else on that
+--        side (a variable, a column, a parameter, an ungated call);
+--   (2b) when it RETURNS text, it is not called on the pattern side of any regex operator in this
+--        schema, nor inside the body of any GATED text-returning function.
+-- The second half of (2b) is narrower than "any gated function" on purpose: `lock_edges()` and
+-- `fn_call_closure()` are gated (rows a66/a67) and READ bodies through `stripped_body`, which
+-- returns text; calling a body reader from a gated matcher is the thing (2b) exists to catch only
+-- when the gated function is itself building a pattern. `bare_ok(oid)` returns boolean and is
+-- outside (2b) by construction. The third conjunct — not called on the pattern side of any
+-- comparison in a TEST FILE — is asserted by scripts/check-test-source-scan-literals.mjs, because
+-- pg_proc cannot see the test files.
+--
+-- A function failing (2a) reads `UNGATED-BUILDS-PATTERN <token>`; one failing (2b) reads
+-- `UNGATED-CALLED-IN-PATTERN <where>`. Both fail by name; the expected value names every
+-- signature, so a new function of any kind appears here and must be classified deliberately.
+create function pg_temp.pattern_operands(p_body text) returns setof text
+language plpgsql as $f$
+declare
+  v_pos int := 1; v_len int := length(p_body); v_start int; v_depth int; v_i int; v_c text;
+  v_rhs text; v_args text; v_k int; v_hit text;
+begin
+  loop
+    v_hit := substring(p_body from v_pos);
+    -- source-scan: loud-literal CPR-0b's own tokenizer over the FAMILY's bodies; the family cannot be its own scanner
+    v_start := regexp_instr(v_hit, '(!?~\*?|(?<![A-Za-z0-9_])(?:regexp_[A-Za-z_]+|substring)\s*\()', 1, 1, 0, 'i');
+    exit when v_start = 0;
+    v_start := v_pos + v_start - 1;
+    if substr(p_body, v_start, 1) in ('~', '!') then
+      -- an operator: the operand runs to the next depth-0 `,` `)` `;` or clause keyword
+      v_i := v_start;
+      while substr(p_body, v_i, 1) in ('!', '~', '*') loop v_i := v_i + 1; end loop;
+      v_rhs := ''; v_depth := 0;
+      while v_i <= v_len loop
+        v_c := substr(p_body, v_i, 1);
+        if v_c = '(' then v_depth := v_depth + 1;
+        elsif v_c = ')' then
+          exit when v_depth = 0;
+          v_depth := v_depth - 1;
+        elsif v_depth = 0 and v_c in (',', ';') then exit;
+        -- source-scan: loud-literal CPR-0b's own tokenizer over the FAMILY's bodies; the family cannot be its own scanner
+        elsif v_depth = 0 and v_rhs ~ '\s$'
+          -- source-scan: loud-literal CPR-0b's own tokenizer over the FAMILY's bodies; the family cannot be its own scanner
+          and substring(p_body from v_i) ~* '^(and|or|then|loop|else|end|when|into|as|from|where|order|group|limit)(?![A-Za-z0-9_])' then exit;
+        end if;
+        v_rhs := v_rhs || v_c; v_i := v_i + 1;
+      end loop;
+      return next btrim(v_rhs);
+      v_pos := v_i;
+    else
+      -- regexp_*( or substring(: the pattern is the second depth-0 argument, or the FROM operand
+      v_i := v_start + position('(' in substr(p_body, v_start));
+      v_depth := 0; v_args := ''; v_k := 1; v_rhs := null;
+      while v_i <= v_len loop
+        v_c := substr(p_body, v_i, 1);
+        if v_c = '(' then v_depth := v_depth + 1;
+        elsif v_c = ')' then
+          exit when v_depth = 0;
+          v_depth := v_depth - 1;
+        -- source-scan: loud-literal CPR-0b's own tokenizer over the FAMILY's bodies; the family cannot be its own scanner
+        elsif v_depth = 0 and (v_c = ',' or (v_args ~ '\s$' and substring(p_body from v_i) ~* '^from(?![A-Za-z0-9_])')) then
+          if v_k = 2 then v_rhs := v_args; end if;
+          v_k := v_k + 1; v_args := '';
+          v_i := v_i + case when v_c = ',' then 1 else 4 end;
+          continue;
+        -- source-scan: loud-literal CPR-0b's own tokenizer over the FAMILY's bodies; the family cannot be its own scanner
+        elsif v_depth = 0 and v_args ~ '\s$' and substring(p_body from v_i) ~* '^for(?![A-Za-z0-9_])' then
+          exit;
+        end if;
+        v_args := v_args || v_c; v_i := v_i + 1;
+      end loop;
+      if v_k = 2 then v_rhs := v_args; end if;
+      return next btrim(coalesce(v_rhs, '<no pattern argument>'));
+      v_pos := v_i + 1;
+    end if;
+  end loop;
+end $f$;
+
+-- The operand with every GATED call (and its argument list) removed; what remains must be empty
+-- or a number — anything else is a token that BUILDS the pattern.
+create function pg_temp.pattern_residue(p_operand text) returns text
+language plpgsql as $f$
+declare v text := p_operand; v_pos int; v_i int; v_depth int; v_c text; v_gated text;
+begin
+  loop
+    select string_agg(distinct regexp_replace(r.fn, '^agent_board_test\.([^(]+)\(.*$', '\1'), '|') into v_gated from _mrule r;
+    -- source-scan: loud-literal CPR-0b's own residue scanner over the FAMILY's operands; the family cannot be its own scanner
+    v_pos := regexp_instr(v, '(?<![A-Za-z0-9_])agent_board_test\s*\.\s*(?:' || v_gated || ')\s*\(', 1, 1, 0, 'c');
+    exit when v_pos = 0;
+    v_i := v_pos + position('(' in substr(v, v_pos)); v_depth := 0;
+    while v_i <= length(v) loop
+      v_c := substr(v, v_i, 1);
+      if v_c = '(' then v_depth := v_depth + 1;
+      elsif v_c = ')' then
+        exit when v_depth = 0;
+        v_depth := v_depth - 1;
+      end if;
+      v_i := v_i + 1;
+    end loop;
+    v := substr(v, 1, v_pos - 1) || ' ' || substr(v, v_i + 1);
+  end loop;
+  return btrim(regexp_replace(regexp_replace(v, '\|\||[()]', ' ', 'g'), '(?<![A-Za-z0-9_$.])[0-9]+(?![A-Za-z0-9_$.])', ' ', 'g'));
+end $f$;
+
+create temp table _mfn on commit drop as
+  select p.oid, p.proname || '(' || array_to_string(p.proargtypes::oid[]::regtype[], ',') || ')' as sig,
+         p.proname, p.prorettype = 'text'::regtype as returns_text,
+         exists (select 1 from _mrule r where r.fn::regprocedure = p.oid) as gated,
+         agent_board_test.stripped_body(p.oid, false) as body
+    from pg_proc p where p.pronamespace = 'agent_board_test'::regnamespace;
+
+create temp table _moperand on commit drop as
+  select f.sig, o.operand, pg_temp.pattern_residue(o.operand) as residue
+    from _mfn f, lateral pg_temp.pattern_operands(f.body) as o(operand);
+
+select is(
+  (select string_agg(f.sig || '=' ||
+            case
+              when f.gated then 'gated'
+              when exists (select 1 from _moperand o where o.sig = f.sig and o.residue <> '')
+                then 'UNGATED-BUILDS-PATTERN ' || (select string_agg(o.residue, ' ') from _moperand o where o.sig = f.sig and o.residue <> '')
+              when f.returns_text and exists (select 1 from _moperand o where o.operand ~ agent_board_test.call_re('agent_board_test.' || f.proname, true))
+                then 'UNGATED-CALLED-IN-PATTERN ' || (select string_agg(o.sig, ' ') from _moperand o where o.operand ~ agent_board_test.call_re('agent_board_test.' || f.proname, true))
+              when f.returns_text and exists (select 1 from _mfn g where g.gated and g.returns_text and g.body ~ agent_board_test.call_re('agent_board_test.' || f.proname, true))
+                then 'UNGATED-CALLED-IN-PATTERN ' || (select string_agg(g.sig, ' ') from _mfn g where g.gated and g.returns_text and g.body ~ agent_board_test.call_re('agent_board_test.' || f.proname, true))
+              -- A gated body that returns ROWS (`lock_edges`, `fn_call_closure`) builds its patterns
+              -- into COLUMNS and applies them by column reference, so neither the operand rule nor
+              -- the text-body rule above sees a helper it calls. Every ungated text function such a
+              -- body calls is convicted, EXCEPT a subject producer — identified by what it does
+              -- (it is `strip_sql`, or its body calls it), never by a name list. A helper that both
+              -- strips and builds a pattern would pass this conjunct: recorded, not closed
+              -- (codex, PR #435 round 1, m11d).
+              when f.returns_text and (f.sig = 'strip_sql(text,boolean)' or f.body ~ agent_board_test.call_re('agent_board_test.strip_sql', false))
+                then 'subject-producer'
+              when f.returns_text
+                and exists (select 1 from _mfn g where g.gated and not g.returns_text and g.body ~ agent_board_test.call_re('agent_board_test.' || f.proname, true))
+                then 'UNGATED-CALLED-IN-GATED-BODY ' || (select string_agg(g.sig, ' ') from _mfn g where g.gated and not g.returns_text and g.body ~ agent_board_test.call_re('agent_board_test.' || f.proname, true))
+              else 'not-a-matcher'
+            end, '; ' order by f.sig)
+     from _mfn f),
+  'bare_ok(oid)=not-a-matcher; '
+  'call_frag(text)=gated; '
+  'call_frag(text,boolean)=gated; '
+  'call_re(text)=gated; '
+  'call_re(text,boolean)=gated; '
+  'ci_re(text)=gated; '
+  'col_assign_frag(text,text,boolean)=gated; '
+  'col_frag(text)=gated; '
+  'col_ref_frag(text)=gated; '
+  'col_write_frag(text,text)=gated; '
+  'col_write_frag(text,text,boolean)=gated; '
+  'col_write_re(text,text)=gated; '
+  'fn_call_closure()=gated; '
+  'ident_any_frag()=gated; '
+  'ident_chars()=gated; '
+  'ident_re(text)=gated; '
+  'insert_all_columns_frag(text)=gated; '
+  'insert_all_columns_frag(text,boolean)=gated; '
+  'insert_all_columns_re(text)=gated; '
+  'lead_guard()=gated; '
+  'lock_edges()=gated; '
+  'merge_insert_all_columns_frag(text)=gated; '
+  'merge_insert_all_columns_frag(text,boolean)=gated; '
+  'qname_frag(text)=gated; '
+  'qname_frag(text,boolean)=gated; '
+  'qname_re(text)=gated; '
+  're(text)=gated; '
+  'row_lock_frag()=gated; '
+  'row_lock_rank(text)=not-a-matcher; '
+  'row_lock_re(text)=gated; '
+  'row_locks_conflict(text,text)=not-a-matcher; '
+  'same_stmt()=gated; '
+  'set_run(text)=gated; '
+  'stmt_frag(text,text)=gated; '
+  'stmt_frag(text,text,boolean)=gated; '
+  'stmt_re(text,text)=gated; '
+  'stmt_re(text,text,boolean)=gated; '
+  'strip_sql(text,boolean)=subject-producer; '
+  'stripped_body(oid,boolean)=subject-producer; '
+  'stripped_def(oid,boolean)=subject-producer; '
+  'stripped_viewdef(oid,boolean)=subject-producer; '
+  'trail_guard()=gated; '
+  'write_frag(text)=gated; '
+  'write_frag(text,boolean)=gated; '
+  'write_re(text)=gated; '
+  'writes_any_frag(text[])=gated; '
+  'writes_any_frag(text[],boolean)=gated; '
+  'writes_any_re(text[])=gated',
+  'CPR-0b RULE INVENTORY: every function in agent_board_test is either covered by a CPR-0a rule (keyed by OID, so a rule naming a missing signature gates nothing and fails here) or POSITIVELY not a matcher — every regex operand in its body is a constant or a gated call, and if it returns text it is called on no pattern side, in no gated matcher body, and in no gated ROW-returning body unless it is a subject producer (it strips); the expected value names every signature, so a new function appears here by name and a helper that merely returns a pattern for others to use is convicted where it is used');
+
+-- The fixture is DROPPED here, not left to the transaction's rollback: the census assertions below
+-- read agent_board's catalog, and a probe that calls acquire_claim would otherwise appear in
+-- CPR-14c's callee direction as one more caller of the claims row lock.
+drop function agent_board._probe416_quoted_callee(uuid);
+
 -- ===========================================================================
 -- THE CLASS (rule 1). Catalog-derived on every run.
 -- ===========================================================================
@@ -183,16 +1547,23 @@ select is(
 select is(
   (select string_agg(x.proname || '=' ||
             case when regexp_instr(b.body, agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0) = 0 then 'NO-LOCK'
-                 when regexp_instr(b.body, x.decision, 1, 1, 0, 'i') = 0 then 'NO-DECISION'
+                 when regexp_instr(b.body, x.decision, 1, 1, 0) = 0 then 'NO-DECISION'
                  when regexp_instr(b.body, agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0)
-                        < regexp_instr(b.body, x.decision, 1, 1, 0, 'i')
+                        < regexp_instr(b.body, x.decision, 1, 1, 0)
                    then 'lock-first'
                  else 'DECISION-FIRST' end, ', ' order by x.proname)
-     from (values
-             ('acquire_claim',          agent_board_test.call_re('_claimgate_board_claim_policy_of')),
-             ('renew_claim',            agent_board_test.call_re('_claimgate_board_claim_policy_of')),
-             ('set_board_claim_policy', 'into\s+v_prev_policy')
-           ) as x(proname, decision)
+     -- Each row binds `decision` BY NAME (not a VALUES alias), so the lint traces the pattern
+     -- `regexp_instr(b.body, x.decision, …)` reads to these three expressions (#437 round 1). No
+     -- 'i' flag: the family carries its own case classes and its header forbids the flag (round 2).
+     from (select 'acquire_claim'::text as proname,
+                  agent_board_test.call_re('_claimgate_board_claim_policy_of') as decision
+           union all
+           select 'renew_claim'::text as proname,
+                  agent_board_test.call_re('_claimgate_board_claim_policy_of') as decision
+           union all
+           select 'set_board_claim_policy'::text as proname,
+                  agent_board_test.re(agent_board_test.ci_re('into') || '\s+' || agent_board_test.ident_re('v_prev_policy')) as decision
+           ) as x
      join pg_proc p on p.proname = x.proname
      join pg_namespace n on n.oid = p.pronamespace and n.nspname = 'agent_board'
      cross join lateral (select agent_board_test.stripped_body(p.oid, true) as body) b),
@@ -226,10 +1597,15 @@ select is(
             regexp_instr(agent_board_test.stripped_body(p.oid, true),
               agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0) as board_pos,
             regexp_instr(agent_board_test.stripped_body(p.oid, true),
-              'pg_(try_)?advisory_xact_lock\s*\(\s*hashtext\s*\(', 1, 1, 0, 'i') as quota_pos
+              agent_board_test.re('(?:' || agent_board_test.call_frag('pg_catalog.pg_advisory_xact_lock', true)
+                                  || '|' || agent_board_test.call_frag('pg_catalog.pg_try_advisory_xact_lock', true)
+                                  || ')\s*' || agent_board_test.call_frag('pg_catalog.hashtext', true)), 1, 1, 0) as quota_pos
        from pg_proc p join pg_namespace n on n.oid = p.pronamespace
       where n.nspname = 'agent_board'
-        and agent_board_test.stripped_body(p.oid, true) ~* 'pg_(try_)?advisory_xact_lock\s*\(\s*hashtext\s*\('
+        and agent_board_test.stripped_body(p.oid, true)
+            ~ agent_board_test.re('(?:' || agent_board_test.call_frag('pg_catalog.pg_advisory_xact_lock', true)
+                                  || '|' || agent_board_test.call_frag('pg_catalog.pg_try_advisory_xact_lock', true)
+                                  || ')\s*' || agent_board_test.call_frag('pg_catalog.hashtext', true))
    )
    select coalesce(string_agg(proname || '=' ||
             (case when board_pos = 0            then 'no-board-lock'
@@ -260,41 +1636,20 @@ select is(
 -- asserted, because an advisory lock only excludes callers that also take it.
 -- ===========================================================================
 
--- CPR-6. Source bound.
+-- CPR-6. Source bound. The population is `col_write_re('boards','claim_policy')` — a statement
+-- that ASSIGNS the column, positionally, over the LITERAL-KEEPING body so a `set claim_policy`
+-- assembled inside an `execute format(...)` string is still seen. It used to be a site-local
+-- composition, `stmt_re(...) || '[^;]*' || col_frag(...)`, which read `update boards set slug = x
+-- where claim_policy = y` as a writer (R1a) and a literal `'a;b'` as a statement boundary (P2a);
+-- the COPY, INSERT-with-no-column-list and SELECT-INTO arms it carried are inside the matcher now,
+-- pinned by CPR-0's rows rather than by this comment.
 select is(
   (select coalesce(string_agg(p.proname, ', ' order by p.proname), '')
      from pg_proc p join pg_namespace n on n.oid = p.pronamespace
     where n.nspname not in ('pg_catalog', 'information_schema', 'agent_board_test')
       and n.nspname !~ '^pg_'
       and p.prolang <> (select oid from pg_language where lanname = 'internal')
-      and agent_board_test.stripped_body(p.oid, true)
-            ~ (agent_board_test.stmt_re('update|merge into|insert into', 'boards')
-               || '[^;]*' || agent_board_test.col_frag('claim_policy')
-              -- COPY, parsed by POSITION rather than by token. Three things this gets right that a
-              -- verb-plus-token test did not:
-              --   * `copy boards from …` with NO column list writes EVERY column, claim_policy
-              --     included, and contains no claim_policy token — the widest form of the verb.
-              --   * the direction word must follow the relation and its optional column list, so
-              --     `copy boards to '/tmp/from.csv'` cannot match on a PATH containing "from".
-              --     (Literals are kept by this scan, so the path really is in the text.)
-              --   * a column list that does NOT name claim_policy (`copy boards (slug) from …`)
-              --     writes only that column and is correctly NOT a member: the optional group fails
-              --     to match it, and the direction word is then not where the pattern requires.
-               || '|' || agent_board_test.ci_re('copy') || '\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
-               || agent_board_test.qname_frag('boards')
-               || '\s*(?:\([^)]*' || agent_board_test.col_frag('claim_policy') || '[^)]*\)\s*)?'
-               || agent_board_test.ci_re('from') || '(?![A-Za-z0-9_])'
-              -- INSERT WITH NO COLUMN LIST, the same shape as COPY without one and a PRE-EXISTING
-              -- hole rather than one this change introduced: `insert into boards values (…)` and
-              -- `insert into boards select …` write EVERY column, claim_policy included, and carry
-              -- no claim_policy token. COPY was special-cased and INSERT was not.
-              -- The INSERT-without-column-list rule is a NAMED OBJECT, embedded VERBATIM — the frag,
-              -- not `replace(re, '(?c)', '')`. CPR-0's rows compile this same frag, so row and
-              -- production are one object rather than two strings that agree today.
-               || '|' || agent_board_test.insert_all_columns_frag('boards')
-               || '|\m' || agent_board_test.ci_re('select') || '(?![A-Za-z0-9_])[^;]*\m'
-               || agent_board_test.ci_re('into') || '(?![A-Za-z0-9_])[^;]*'
-               || agent_board_test.qname_frag('boards') || '[^;]*' || agent_board_test.col_frag('claim_policy'))),
+      and agent_board_test.stripped_body(p.oid, true) ~ agent_board_test.col_write_re('boards', 'claim_policy')),
   'set_board_claim_policy',
   'CPR-6 SOLE WRITER (source): across EVERY non-system schema, exactly one function has a statement targeting boards that mentions claim_policy — a STATEMENT test rather than an enumeration of assignment spellings, so the multi-column form `set (slug, claim_policy) = (…)` lands here too, and a SECURITY DEFINER writer in another schema cannot bypass the premise by living outside agent_board');
 
@@ -334,7 +1689,7 @@ select is(
             (agent_board_test.stripped_body(p.oid, true) ~ agent_board_test.qname_re('claims'))::text, ', ' order by p.proname)
      from pg_proc p join pg_namespace n on n.oid = p.pronamespace
     where n.nspname = 'agent_board'
-      and agent_board_test.stripped_body(p.oid, true) ~* '\mexecute\M'),
+      and agent_board_test.stripped_body(p.oid, true) ~ agent_board_test.re('\m' || agent_board_test.ci_re('execute') || '\M')),
   'get_bundle_compatibility:mentions_boards=false/mentions_threads=false/mentions_claims=false, mark_retention_metadata:mentions_boards=false/mentions_threads=false/mentions_claims=false',
   'CPR-9 SOLE WRITER (EXECUTE token): the functions in agent_board that contain an `execute` token are these and neither names boards, threads or claims — a third, or either one gaining any of the three, fails here. The range is that token, not dynamic SQL in general: a statement assembled and run some other way is outside it. The claims field is what makes a dynamic claims writer visible, since CPR-14a strips literals and cannot see one');
 
@@ -378,10 +1733,12 @@ select is(
 -- valid forms were unmatched: the multi-column form `set (board_id, …) = (…)`, a
 -- `MERGE … WHEN MATCHED THEN UPDATE SET board_id`, and a plain INSERT naming board_id in its COLUMN
 -- LIST rather than an assignment. The population is now "a statement targeting threads that mentions
--- board_id at all", which admits every spelling of assignment including ones nobody has thought of;
--- it is deliberately WIDER than assignment (an UPDATE merely reading board_id in its WHERE lands
--- here too), because a false member is labelled and must be decided about, while a missed one is
--- invisible. Measured: the widening leaves today's population unchanged.
+-- board_id at all", which admitted every spelling of assignment — and every READ of the column in
+-- a WHERE clause (R1a), which is a false member with a label, not a writer. The population is now
+-- `col_write_re('threads','board_id')`: a statement that ASSIGNS the column, positionally — scalar
+-- SET, the multi-column SET row, MERGE's UPDATE SET, an INSERT naming it in its column list, and
+-- the no-column-list INSERT / COPY / SELECT INTO forms that write every column — pinned by CPR-0's
+-- rows. Measured: today's population is unchanged.
 --
 -- CPR-12. And the only one that assigns `board_id` does it FIRST-BOARD-WINS. That guard is what
 -- makes the transition null -> board and never board -> board, which is why locking the board
@@ -391,14 +1748,16 @@ select is(
 select is(
   (select coalesce(string_agg(p.proname || '[' ||
             (case when agent_board_test.stripped_body(p.oid, true)
-                       ~ 'update\s+agent_board\.threads\s+t\s+set\s+board_id\s*=\s*p_board_id\s+where\s+t\.board_id\s+is\s+null'
+                       ~ agent_board_test.re(agent_board_test.col_assign_frag('threads', 'board_id', agent_board_test.bare_ok(p.oid))
+                                             || '\s*' || agent_board_test.ident_re('p_board_id') || agent_board_test.same_stmt()
+                                             || '\m' || agent_board_test.ci_re('where') || '\s+' || agent_board_test.col_ref_frag('board_id')
+                                             || '\s+' || agent_board_test.ci_re('is null') || '\M')
                   then 'first-board-wins' else 'UNGUARDED' end) || ']', ', ' order by p.proname), '<none>')
      from pg_proc p join pg_namespace n on n.oid = p.pronamespace
     where n.nspname not in ('pg_catalog', 'information_schema', 'agent_board_test')
       and n.nspname !~ '^pg_'
       and p.prolang <> (select oid from pg_language where lanname = 'internal')
-      and agent_board_test.stripped_body(p.oid, true)
-            ~ (agent_board_test.stmt_re('update|merge into|insert into', 'threads') || '[^;]*' || agent_board_test.col_frag('board_id'))),
+      and agent_board_test.stripped_body(p.oid, true) ~ agent_board_test.col_write_re('threads', 'board_id')),
   '_upsert_delivery_recipient[first-board-wins]',
   'CPR-12 BOARD IMMUTABILITY: the sole writer of threads.board_id stamps only where it is null (OBSGATE first-board-wins), so a board can be gained but never moved');
 
@@ -485,7 +1844,7 @@ select is(
   (select coalesce(string_agg(p.proname, ', ' order by p.proname), '<none>')
      from pg_proc p join pg_namespace n on n.oid = p.pronamespace
     where n.nspname = 'agent_board'
-      and agent_board_test.stripped_body(p.oid, true) ~ (agent_board_test.qname_re('claims') || '[^;]*\m' || agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:' || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')(?![A-Za-z0-9_])')),
+      and agent_board_test.stripped_body(p.oid, true) ~ agent_board_test.row_lock_re('claims')),
   '<none>',
   'CPR-14 LOCK ORDER: no function in agent_board takes a claims row lock through an EXPLICIT locking clause (for update / for no key update / for share / for key share) — the spelling that could sit anywhere in a body; the UPDATE-shaped row locks, which CPR-14a enumerates and orders, are not this assertion''s subject');
 
@@ -563,15 +1922,8 @@ select is(
      select proname,
             regexp_instr(body, agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0) as lock_pos,
             least(
-              coalesce(nullif(regexp_instr(body,
-                agent_board_test.stmt_re('update|delete from|merge into', 'claims'),
-                1, 1, 0, 'i'), 0), 2147483647),
-              coalesce(nullif(regexp_instr(body,
-                agent_board_test.qname_re('claims') || '[^;]*\m' || agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:' || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')(?![A-Za-z0-9_])',
-                1, 1, 0, 'i'), 0), 2147483647),
-              coalesce(nullif(regexp_instr(body,
-                agent_board_test.stmt_re('insert into', 'claims'),
-                1, 1, 0, 'i'), 0), 2147483647)
+              coalesce(nullif(regexp_instr(body, agent_board_test.write_re('claims'), 1, 1, 0), 0), 2147483647),
+              coalesce(nullif(regexp_instr(body, agent_board_test.row_lock_re('claims'), 1, 1, 0), 0), 2147483647)
             ) as row_pos
        from bodies
    )
@@ -623,12 +1975,16 @@ select is(
      select oid, proname, body from bodies where body ~ agent_board_test.qname_re('claims')
    ), censused as (
      select oid from mentioners
-      where body ~ agent_board_test.stmt_re('update|delete from|merge into', 'claims')
-         or body ~ (agent_board_test.qname_re('claims') || '[^;]*\m' || agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:' || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')(?![A-Za-z0-9_])')
-         or body ~ agent_board_test.stmt_re('insert into', 'claims')
+      where body ~ agent_board_test.write_re('claims')
+         or body ~ agent_board_test.row_lock_re('claims')
+   ), class_rels as (
+     -- every relation in agent_board, from pg_class: a write to ANY of them is the verb.
+     select array_agg(c.relname order by c.relname) as rels
+       from pg_class c join pg_namespace n on n.oid = c.relnamespace
+      where n.nspname = 'agent_board' and c.relkind in ('r', 'p', 'v', 'm', 'f')
    )
    select coalesce(string_agg(m.oid::regprocedure::text || '[' ||
-            (case when m.body ~* '\m(update|delete|insert|merge|truncate|copy)\M|\mselect\M[^;]*\minto\M'
+            (case when m.body ~ agent_board_test.writes_any_re((select rels from class_rels))
                   then 'HAS-WRITE-VERB' else 'no-write-verb' end) || ']', ', ' order by m.oid::regprocedure::text), '<none>')
      from mentioners m
     where m.oid not in (select oid from censused)),
@@ -665,9 +2021,11 @@ select is(
             ', ' order by x.proname)
      from (select p.proname,
                   substring(agent_board_test.stripped_body(p.oid)
-                            from '"?_claimgate_lock_board_policy"?\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)') as locked,
+                            from agent_board_test.re(agent_board_test.call_frag('_claimgate_lock_board_policy')
+                                                     || '\s*(' || agent_board_test.ident_any_frag() || ')\s*\)')) as locked,
                   substring(agent_board_test.stripped_body(p.oid)
-                            from '"?_claimgate_board_claim_policy_of"?\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)') as resolved
+                            from agent_board_test.re(agent_board_test.call_frag('_claimgate_board_claim_policy_of')
+                                                     || '\s*(' || agent_board_test.ident_any_frag() || ')\s*\)')) as resolved
              from pg_proc p join pg_namespace n on n.oid = p.pronamespace
             where n.nspname = 'agent_board'
               and p.prolang <> (select oid from pg_language where lanname = 'internal')
@@ -706,7 +2064,8 @@ select is(
                   (select count(*) from regexp_matches(agent_board_test.stripped_body(p.oid),
                      agent_board_test.call_re('_claimgate_board_claim_policy_of'), 'g')) as resolvers,
                   agent_board_test.stripped_body(p.oid)
-                    ~* '"?_claimgate_board_claim_policy_of"?\s*\(\s*[A-Za-z_][A-Za-z0-9_]*\s*\)' as bare
+                    ~ agent_board_test.re(agent_board_test.call_frag('_claimgate_board_claim_policy_of')
+                                          || '\s*' || agent_board_test.ident_any_frag() || '\s*\)') as bare
              from pg_proc p join pg_namespace n on n.oid = p.pronamespace
             where n.nspname = 'agent_board'
               and p.prolang <> (select oid from pg_language where lanname = 'internal')
@@ -780,20 +2139,19 @@ select is(
         and p.prolang <> (select oid from pg_language where lanname = 'internal')
    ), rowlockers as (
      select oid from fns
-      where body ~ agent_board_test.stmt_re('update|delete from|merge into', 'claims')
-         or body ~ agent_board_test.stmt_re('insert into', 'claims')
-         or body ~ (agent_board_test.qname_re('claims') || '[^;]*\m' || agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:' || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')(?![A-Za-z0-9_])')
+      where body ~ agent_board_test.write_re('claims')
+         or body ~ agent_board_test.row_lock_re('claims')
    ), reaches_rowlock as (
      select distinct c.root_oid as oid
        from agent_board_test.fn_call_closure() c
       where c.reached_oid in (select oid from rowlockers)
    ), edges as (
      select r.proname as caller, e.proname as callee,
-            regexp_instr(r.body, '\m' || e.proname || '\M\s*\(', 1, 1, 0, 'i') as call_pos,
+            regexp_instr(r.body, agent_board_test.call_re(e.proname, agent_board_test.bare_ok(r.oid)), 1, 1, 0) as call_pos,
             regexp_instr(r.body, agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0) as lock_pos
        from fns r join fns e on e.oid <> r.oid
       where e.oid in (select oid from reaches_rowlock)
-        and r.body ~ agent_board_test.call_re(e.proname)
+        and r.body ~ agent_board_test.call_re(e.proname, agent_board_test.bare_ok(r.oid))
         and regexp_instr(r.body, agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0) > 0
    )
    select coalesce(string_agg(distinct caller || '->' || callee, ', '
@@ -817,9 +2175,8 @@ select is(
         and p.prolang <> (select oid from pg_language where lanname = 'internal')
    ), rowlockers as (
      select oid from fns
-      where body ~ agent_board_test.stmt_re('update|delete from|merge into', 'claims')
-         or body ~ agent_board_test.stmt_re('insert into', 'claims')
-         or body ~ (agent_board_test.qname_re('claims') || '[^;]*\m' || agent_board_test.ci_re('for') || '\s+(?:' || agent_board_test.ci_re('no key') || '\s+)?(?:' || agent_board_test.ci_re('update') || '|' || agent_board_test.ci_re('share') || '|' || agent_board_test.ci_re('key share') || ')(?![A-Za-z0-9_])')
+      where body ~ agent_board_test.write_re('claims')
+         or body ~ agent_board_test.row_lock_re('claims')
    )
    select coalesce(string_agg(distinct c.root_name, ', ' order by c.root_name), '<none>')
      from agent_board_test.fn_call_closure() c
@@ -830,267 +2187,6 @@ select is(
   'CPR-14d LOCK ORDER (callee direction, membership half): these are the functions that reach BOTH a claims row-locker and the board lock through their call closures — a fourth, wrapper or composer alike, is named here and must be decided about rather than exempted by a predicate');
 
 -- ---------------------------------------------------------------------------
--- CPR-0 / CPR-0a. THE MATCHERS' BEHAVIOUR TABLE, AND A GATE ON THE TABLE ITSELF.
---
--- WHY BOTH. The identifier matchers drifted four times across three review rounds, and every
--- version passed its accept cases. So a table was added. Then the SAME defect appeared INSIDE the
--- table three times: rows that pass for a reason unrelated to the rule they are named for — first
--- r06 (tested `$` through an adjacency that rejected it earlier), then a12/r13 (compiled a
--- reconstruction rather than the production object), then a13/a14/a15 (keyword branches that the
--- subject text could never exercise). Each was found by a different reviewer, after the previous
--- fix, by the same procedure: revert a rule and see which rows move.
---
--- THREE OCCURRENCES IS ENOUGH EVIDENCE THAT A HAND-COMPILED REVERT MAP CANNOT BE TRUSTED, because
--- compiling it is the same act as writing the rows. So the map is mechanical now: CPR-0a reverts
--- each rule in turn, re-evaluates every row, and requires at least one row to flip. A rule with no
--- flipping row FAILS AND NAMES ITSELF — which is what would have caught all three, and none of
--- which a human reading the table did.
---
--- The rows are DATA rather than inline expressions so both assertions evaluate the same list: a
--- row CPR-0 checks and CPR-0a cannot re-evaluate would be back to two lists that agree today.
--- ---------------------------------------------------------------------------
-create temp table _mrow (label text primary key, expr text, want boolean) on commit drop;
-
-insert into _mrow(label, expr, want) values
-  -- ACCEPTS: spellings PostgreSQL resolves to OUR object
-  ('a01-qualified',      $x$'update agent_board.claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
-  ('a02-unqualified',    $x$'update claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
-  ('a03-upper-unquoted', $x$'UPDATE AGENT_BOARD.CLAIMS SET x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
-  ('a04-quoted-lower',   $x$'update "agent_board"."claims" set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
-  ('a05-verb-newline',   $x$'insert' || chr(10) || 'into claims v' ~ agent_board_test.stmt_re('insert into','claims')$x$, true),
-  ('a06-verb-2spaces',   $x$'delete  from claims where x' ~ agent_board_test.stmt_re('delete from','claims')$x$, true),
-  ('a07-verb-tab',       $x$'merge' || chr(9) || 'into claims m' ~ agent_board_test.stmt_re('merge into','claims')$x$, true),
-  -- a08 gates ci_re's OWN space rule, which a05-a07 do NOT: they exercise whitespace inside a verb
-  -- through stmt_re, which would still work if ci_re emitted a literal space and stmt_re rewrote it.
-  ('a08-cire-phrase',    $x$'no' || chr(10) || 'key' ~ ('(?c)' || agent_board_test.ci_re('no key'))$x$, true),
-  ('a09-inheritance',    $x$'update agent_board.boards* set x' ~ agent_board_test.stmt_re('update','boards')$x$, true),
-  ('a10-call-space',     $x$'perform _claimgate_lock_board_policy (v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, true),
-  ('a11-call-quoted',    $x$'perform agent_board."_claimgate_lock_board_policy"(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, true),
-  ('a12-col-upper',      $x$'set CLAIM_POLICY = x' ~ agent_board_test.col_frag('claim_policy')$x$, true),
-  ('a13-ins-novals',     $x$'insert into agent_board.boards values (1,2)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
-  ('a14-ins-select',     $x$'insert into agent_board.boards select (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
-  -- a15/a16 cover two INSERT FORMS the rule must census. They do NOT gate a keyword exclusion, and
-  -- that is stated rather than implied: DEFAULT is only ever followed by VALUES and OVERRIDING by
-  -- SYSTEM/USER, so neither can be mistaken for an alias-before-`(`. The exclusions for them were
-  -- therefore DEAD CODE and have been removed rather than kept with rows that cannot gate them.
-  ('a15-ins-default',    $x$'insert into agent_board.boards default values' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
-  ('a16-ins-overriding', $x$'insert into agent_board.boards overriding user value values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, true),
-  ('a17-ins-re-eq-frag', $x$agent_board_test.insert_all_columns_re('boards') = '(?c)' || agent_board_test.insert_all_columns_frag('boards')$x$, true),
-  -- REJECTS: spellings PostgreSQL resolves ELSEWHERE
-  ('a18-verb-rel-spaces', $x$'update  agent_board.claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, true),
-  ('r01-other-schema',   $x$'update other.claims set x' ~ agent_board_test.stmt_re('update','claims')$x$, false),
-  ('r02-dot-space',      $x$'perform other . _claimgate_lock_board_policy(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, false),
-  ('r03-quoted-upper',   $x$'update "AGENT_BOARD"."claims" set x' ~ agent_board_test.stmt_re('update','claims')$x$, false),
-  ('r04-prefix-word',    $x$'update dashboards set x' ~ agent_board_test.stmt_re('update','boards')$x$, false),
-  ('r05-dollar-lead',    $x$'perform x$_claimgate_lock_board_policy(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, false),
-  ('r06-dollar-rel',     $x$'from x$claims c' ~ agent_board_test.qname_re('claims')$x$, false),
-  ('r07-nonascii-lead',  $x$'perform ' || chr(233) || '_claimgate_lock_board_policy(v)' ~ agent_board_test.call_re('_claimgate_lock_board_policy')$x$, false),
-  ('r08-nonascii-trail', $x$'from claims' || chr(233) || ' c' ~ agent_board_test.qname_re('claims')$x$, false),
-  ('r09-col-nonascii',   $x$'set claim_policy' || chr(233) || ' = x' ~ agent_board_test.col_frag('claim_policy')$x$, false),
-  ('r10-col-dollar',     $x$'set x$claim_policy = x' ~ agent_board_test.col_frag('claim_policy')$x$, false),
-  ('r11-i-flag',         $x$regexp_instr('x "AGENT_BOARD"."claims" y', agent_board_test.qname_re('claims'), 1, 1, 0, 'i') > 0$x$, false),
-  ('r12-ci-operator',    $x$'x "AGENT_BOARD"."claims" y' ~* agent_board_test.qname_re('claims')$x$, false),
-  ('r13-ins-collist',    $x$'insert into agent_board.boards (slug) values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, false),
-  ('r14-ins-alias',      $x$'insert into agent_board.boards as b(slug) values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, false),
-  ('r16-call-i-flag',    $x$regexp_instr('perform "AGENT_BOARD"."_claimgate_lock_board_policy"(v)', agent_board_test.call_re('_claimgate_lock_board_policy'), 1, 1, 0, 'i') > 0$x$, false),
-  ('r15-ins-qalias',     $x$'insert into agent_board.boards as "b"(slug) values (1)' ~ agent_board_test.insert_all_columns_frag('boards')$x$, false);
-
-create function pg_temp.mverdict(p_expr text) returns boolean
-language plpgsql as $f$
-declare v boolean;
-begin
-  execute format('select (%s)', p_expr) into v;
-  return coalesce(v, false);
-exception when others then
-  -- A row whose expression cannot compile is a FAILED row, not a skipped one: returning null here
-  -- would let a broken pattern read as agreement with a `false` expectation.
-  return not (select want from _mrow where expr = p_expr);
-end $f$;
-
-select is(
-  (select coalesce(string_agg(label || '=' || pg_temp.mverdict(expr)::text, ', ' order by label), '<none>')
-     from _mrow),
-  (select coalesce(string_agg(label || '=' || want::text, ', ' order by label), '<none>') from _mrow),
-  'CPR-0 MATCHER BEHAVIOUR: over PLAIN and DOUBLE-QUOTED identifiers, the matchers accept the spellings PostgreSQL resolves to our object and reject those it resolves elsewhere — Unicode-escape identifiers (U&"...") are OUT OF SCOPE and unhandled, so this is not a claim about every spelling');
-
--- CPR-0a. EVERY RULE HAS A ROW THAT FAILS WITHOUT IT — compiled by the database, not by hand.
--- ONE BEHAVIOUR PER ENTRY, AND EACH NAMES THE ROW THAT MUST FLIP. Both are corrections.
---
--- THE SPLIT PAID FOR ITSELF ON ITS FIRST RUN, which is the answer to "why are these so finely
--- divided": separating the behaviours immediately exposed FOUR matcher rules the coarser hand list
--- had never reverted — ident_re's quoted alternative, qname_frag's OPTIONAL qualifier, call_re's own
--- director, and stmt_re's `\s+` between verb and relation. Two of them had no row at all (a18, r16
--- were added for them). A reviewer tempted to recombine entries should read that as the cost.
---
--- NO DESCRIPTION CARRIES A COUNT, and the rule that replaced is worth recording because it was
--- WRONG in a way that took a reviewer to see. It said a count is "safe" when it sits beside its own
--- assertion's expected value, since the two would fail together. They do not. PROXIMITY IS NOT
--- DERIVATION: nothing computes the count from the expected value, so the assertion fails on drift
--- only until a maintainer updates the expected value — which is the normal maintenance path — and
--- from that moment the count is silently wrong with nothing failing.
---
--- Measured rather than argued: add a function to agent_board_test, and CPR-0b fails; update its
--- expected value the way a maintainer would, and it passes again while any count in its prose is now
--- false. So the "safe" category did not exist. There are only counts that are easier to notice and
--- counts that are harder, and the durable move is the one this package already made when its runner
--- dropped "28 tests" and "42-migration union": delete them. The expected values enumerate every
--- member by name; a reader who wants a number can count one that cannot drift.
---
--- THE RECURSION IS THE POINT, not an aside: the rule written to prevent stale counts made a claim
--- broader than its own mechanism supported — the same shape as every finding in this review, in the
--- sentence codifying the lesson from the previous one.
---
--- IN THESE TWO ASSERTIONS the expected values enumerate every entry by name, so no count appears in
--- either description: it would add nothing a reader cannot see and one more thing that can go stale.
---
--- COMPOUND ENTRIES LET A COVERED BRANCH CONCEAL AN UNCOVERED SIBLING: `keyword exclusions` reverted
--- VALUES and SELECT together, and `lead_guard` reverted its dot-whitespace and non-ASCII guards
--- together, so deleting one row still left the rule reporting as gated through the other. That is
--- the r06 defect at the RULE level — the map certifying a rule it only half tests.
---
--- AND "SOME ROW FLIPPED" IS NOT "THE ROW FOR THIS RULE FLIPPED". The gate now requires the NAMED
--- row, so a rule cannot borrow coverage from an unrelated one.
-create temp table _mrule (rule_name text primary key, fn text, expect_row text, revert_sql text) on commit drop;
-
-insert into _mrule(rule_name, fn, expect_row, revert_sql) values
-  ('ci_re: a space becomes \s+', 'agent_board_test.ci_re(text)', 'a08-cire-phrase', $r$
-     create or replace function agent_board_test.ci_re(p_text text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select coalesce(string_agg(case when c ~ '[A-Za-z]' then '[' || upper(c) || lower(c) || ']' else c end, ''), '')
-         from regexp_split_to_table(p_text, '') as c $b$; $r$),
-  ('ident_chars: $ is an identifier character', 'agent_board_test.ident_chars()', 'r05-dollar-lead', $r$
-     create or replace function agent_board_test.ident_chars() returns text
-     language sql immutable set search_path to pg_catalog as $b$ select 'A-Za-z0-9_' $b$; $r$),
-  ('ident_re: the quoted alternative', 'agent_board_test.ident_re(text)', 'a04-quoted-lower', $r$
-     create or replace function agent_board_test.ident_re(p_name text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select '(?:' || agent_board_test.ci_re(p_name) || ')' $b$; $r$),
-  ('lead_guard: reject a dot with whitespace', 'agent_board_test.lead_guard()', 'r02-dot-space', $r$
-     create or replace function agent_board_test.lead_guard() returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select '(?<![' || agent_board_test.ident_chars() || '."])(?<![^\x00-\x7F])' $b$; $r$),
-  ('lead_guard: reject a leading non-ASCII letter', 'agent_board_test.lead_guard()', 'r07-nonascii-lead', $r$
-     create or replace function agent_board_test.lead_guard() returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select '(?<![' || agent_board_test.ident_chars() || '."])(?<!\.\s*)' $b$; $r$),
-  ('trail_guard: reject a trailing non-ASCII letter', 'agent_board_test.trail_guard()', 'r08-nonascii-trail', $r$
-     create or replace function agent_board_test.trail_guard() returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select '(?![' || agent_board_test.ident_chars() || '])' $b$; $r$),
-  ('qname_frag: the qualifier is OPTIONAL', 'agent_board_test.qname_frag(text)', 'a02-unqualified', $r$
-     create or replace function agent_board_test.qname_frag(p_name text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.lead_guard() || agent_board_test.ident_re('agent_board')
-           || '\s*\.\s*' || agent_board_test.ident_re(p_name) || agent_board_test.trail_guard() $b$; $r$),
-  ('qname_re: the (?c) director', 'agent_board_test.qname_re(text)', 'r11-i-flag', $r$
-     create or replace function agent_board_test.qname_re(p_name text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.qname_frag(p_name) $b$; $r$),
-  ('call_frag: whitespace may precede the paren', 'agent_board_test.call_frag(text)', 'a10-call-space', $r$
-     create or replace function agent_board_test.call_frag(p_name text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.lead_guard() || '(?:' || agent_board_test.ident_re('agent_board')
-           || '\s*\.\s*)?' || agent_board_test.ident_re(p_name) || '\(' $b$; $r$),
-  ('call_re: the (?c) director', 'agent_board_test.call_re(text)', 'r16-call-i-flag', $r$
-     create or replace function agent_board_test.call_re(p_name text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.call_frag(p_name) $b$; $r$),
-  ('col_frag: the column token carries identifier rules', 'agent_board_test.col_frag(text)', 'a12-col-upper', $r$
-     create or replace function agent_board_test.col_frag(p_name text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.lead_guard() || p_name || agent_board_test.trail_guard() $b$; $r$),
-  ('stmt_re: \s+ between the verb and the relation', 'agent_board_test.stmt_re(text,text)', 'a18-verb-rel-spaces', $r$
-     create or replace function agent_board_test.stmt_re(p_verbs text, p_rel text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select '(?c)(?:' || (select string_agg(agent_board_test.ci_re(v), '|')
-                              from regexp_split_to_table(p_verbs, '\|') as v)
-           || ') (?:' || agent_board_test.ci_re('only') || '\s+)?' || agent_board_test.qname_frag(p_rel) $b$; $r$),
-  ('insert rule: the VALUES exclusion', 'agent_board_test.insert_all_columns_frag(text)', 'a13-ins-novals', $r$
-     create or replace function agent_board_test.insert_all_columns_frag(p_rel text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.ci_re('insert into') || '\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
-           || agent_board_test.qname_frag(p_rel)
-           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
-           || agent_board_test.ci_re('select') || '(?![A-Za-z0-9_$]))'
-           || '(?:"[^"]*"|[A-Za-z_][A-Za-z0-9_$]*))?\s*\()' $b$; $r$),
-  ('insert rule: the SELECT exclusion', 'agent_board_test.insert_all_columns_frag(text)', 'a14-ins-select', $r$
-     create or replace function agent_board_test.insert_all_columns_frag(p_rel text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.ci_re('insert into') || '\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
-           || agent_board_test.qname_frag(p_rel)
-           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
-           || agent_board_test.ci_re('values') || '(?![A-Za-z0-9_$]))'
-           || '(?:"[^"]*"|[A-Za-z_][A-Za-z0-9_$]*))?\s*\()' $b$; $r$),
-  ('insert rule: no backtracking before the paren', 'agent_board_test.insert_all_columns_frag(text)', 'r13-ins-collist', $r$
-     create or replace function agent_board_test.insert_all_columns_frag(p_rel text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.ci_re('insert into') || '\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
-           || agent_board_test.qname_frag(p_rel) || '\s*(?!\()' $b$; $r$),
-  ('insert rule: the quoted-alias alternative', 'agent_board_test.insert_all_columns_frag(text)', 'r15-ins-qalias', $r$
-     create or replace function agent_board_test.insert_all_columns_frag(p_rel text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.ci_re('insert into') || '\s+(?:' || agent_board_test.ci_re('only') || '\s+)?'
-           || agent_board_test.qname_frag(p_rel)
-           || '(?!(?:\s+(?:' || agent_board_test.ci_re('as') || '\s+)?(?!'
-           || agent_board_test.ci_re('values') || '(?![A-Za-z0-9_$])|'
-           || agent_board_test.ci_re('select') || '(?![A-Za-z0-9_$]))'
-           || '[A-Za-z_][A-Za-z0-9_$]*)?\s*\()' $b$; $r$),
-  ('insert re: composed from the frag', 'agent_board_test.insert_all_columns_re(text)', 'a17-ins-re-eq-frag', $r$
-     create or replace function agent_board_test.insert_all_columns_re(p_rel text) returns text
-     language sql immutable set search_path to pg_catalog as $b$
-       select agent_board_test.insert_all_columns_frag(p_rel) $b$; $r$);
-
-create temp table _mflip (rule_name text, expect_row text, flipped text, named_row_flipped boolean) on commit drop;
-
-do $mut$
-declare
-  r      record;
-  v_save text;
-  v_hits text;
-begin
-  for r in select * from _mrule order by rule_name loop
-    v_save := pg_get_functiondef(r.fn::regprocedure);
-    execute r.revert_sql;
-    select coalesce(string_agg(m.label, ' ' order by m.label), '<NONE>')
-      into v_hits
-      from _mrow m
-     where pg_temp.mverdict(m.expr) <> m.want;
-    execute v_save;                       -- restore before the next rule
-    insert into _mflip
-    values (r.rule_name, r.expect_row, v_hits,
-            v_hits ~ ('(^| )' || r.expect_row || '( |$)'));
-  end loop;
-end $mut$;
-
-select is(
-  (select coalesce(string_agg(rule_name || ' (wanted ' || expect_row || ', got ' || flipped || ')',
-                              '; ' order by rule_name), '<none>')
-     from _mflip where not named_row_flipped),
-  '<none>',
-  'CPR-0a REVERT MAP (mechanical): reverting each rule makes THE ROW NAMED FOR THAT RULE fail — one behaviour per entry and a named row per entry, so a compound revert cannot let a covered branch conceal an uncovered sibling and no rule can borrow coverage from an unrelated row — the map is compiled by reverting each rule and re-evaluating the rows, not by hand, because three separate rows have now certified axes they did not test and a human reading the table caught none of them');
-
--- CPR-0b. AND THE RULE INVENTORY IS RECONCILED AGAINST THE CATALOG, because _mrule is still written
--- by hand and a matcher added without an entry would be SILENTLY UNGATED — which contradicts
--- CPR-0a's own sentence. Deriving "every rule a regex-building function implements" from its source
--- is not mechanical; deriving "every FUNCTION in this schema is either gated or positively exempted"
--- is, and it closes the exposure that matters: a new matcher cannot arrive unnoticed.
---
--- Every function in agent_board_test is classified. A new matcher appears as `NOT-GATED` and fails;
--- a new helper appears too and must be exempted deliberately. That is rule 1 applied to the gate's
--- own inventory: the classification comes from pg_proc, and the exemptions are asserted positively
--- rather than by absence.
-select is(
-  (select string_agg(p.proname || '=' ||
-            (case when exists (select 1 from _mrule r where r.fn like '%.' || p.proname || '(%')
-                  then 'gated' else 'NOT-GATED' end), ', ' order by p.proname)
-     from pg_proc p where p.pronamespace = 'agent_board_test'::regnamespace),
-  'call_frag=gated, call_re=gated, ci_re=gated, col_frag=gated, fn_call_closure=NOT-GATED, '
-  'ident_chars=gated, ident_re=gated, insert_all_columns_frag=gated, insert_all_columns_re=gated, '
-  'lead_guard=gated, lock_edges=NOT-GATED, qname_frag=gated, qname_re=gated, '
-  'row_lock_rank=NOT-GATED, row_locks_conflict=NOT-GATED, stmt_re=gated, strip_sql=NOT-GATED, '
-  'stripped_body=NOT-GATED, stripped_def=NOT-GATED, stripped_viewdef=NOT-GATED, trail_guard=gated',
-  'CPR-0b RULE INVENTORY: every function in agent_board_test is either covered by a CPR-0a rule or positively listed as not a pattern matcher — the NOT-GATED entries are body readers and lock helpers, which build no regex, and the expected value names every one of them; a new matcher added without a rule appears here as NOT-GATED and fails by name');
-
 -- CPR-15/16. And no session can take one either — the OPERATION, not a privilege proxy for it.
 -- `select ... for update` on claims is refused with 42501 to both roles that can read the table,
 -- because a row lock needs UPDATE/DELETE privilege and neither holds it at table or column level.
@@ -1116,35 +2212,63 @@ select throws_ok(
 -- THE HELPERS: contract and authorization.
 -- ===========================================================================
 
+-- CPR-17..21. EACH IS lives_ok + A SEPARATE STATE CHECK (rule 3 / #113), not a bare `is((select
+-- rpc()), …)`: a resolver that RAISES inside a bare `is` aborts the transaction, pgTAP emits no
+-- `not ok` for it or for anything after it, and the file "passes" with fewer assertions than its
+-- plan. The result is captured by name into `_cpr_out` under lives_ok, so a raise is a NAMED `not
+-- ok` and the paired check then fails BY COMPARISON (no row -> null, never equal to the sentinel)
+-- rather than raising again; the file runs to plan(N). A null result is stored as the sentinel
+-- '<null>', so "no row because it raised" and "returned null" are different values.
+create temp table _cpr_out(site text primary key, v text);
+
 -- CPR-17/18. The null fallbacks, which are what make the "board stamped mid-wait" drift
 -- CONSERVATIVE rather than a hole: an absent board resolves to the ENFORCING policy.
+select lives_ok(
+  $$ insert into _cpr_out select 'CPR-17', coalesce(agent_board._claimgate_board_of_thread(null)::text, '<null>') $$,
+  'CPR-17 NULL FALLBACK (runs): the thread-to-board walk accepts a null thread without raising');
 select is(
-  (select agent_board._claimgate_board_of_thread(null)),
-  null::uuid,
+  (select v from _cpr_out where site = 'CPR-17'),
+  '<null>',
   'CPR-17 NULL FALLBACK: a null thread has no board — so nothing is locked and nothing can go stale');
 
+select lives_ok(
+  $$ insert into _cpr_out select 'CPR-18', coalesce(agent_board._claimgate_board_claim_policy_of(null)::text, '<null>') $$,
+  'CPR-18 NULL FALLBACK (runs): the board-to-policy half accepts a null board without raising');
 select is(
-  (select agent_board._claimgate_board_claim_policy_of(null)),
+  (select v from _cpr_out where site = 'CPR-18'),
   'inherit',
   'CPR-18 NULL FALLBACK: an absent board resolves to inherit, the ENFORCING answer — a board stamped onto a null-board thread mid-wait can therefore only make this path stricter, never permissive');
 
 -- CPR-19/20. The composition is the SAME function it replaced. `_claimgate_board_claim_policy` is
 -- what the census view resolves through and what BCP-5 pins; decomposing it into the two halves
--- the enforcement paths call separately must not have moved its answer on either case.
+-- the enforcement paths call separately must not have moved its answer on either case. Both sides
+-- of CPR-19 are captured under lives_ok — the composed resolver AND the two halves — so a raise in
+-- either is named rather than aborting.
+select lives_ok(
+  $$ insert into _cpr_out
+     select 'CPR-19', coalesce((select agent_board._claimgate_board_claim_policy(c.thread) from _cpr c)::text, '<null>')
+     union all
+     select 'CPR-19-halves', coalesce((select agent_board._claimgate_board_claim_policy_of(agent_board._claimgate_board_of_thread(c.thread)) from _cpr c)::text, '<null>') $$,
+  'CPR-19 COMPOSITION (runs): the thread-keyed resolver and the composed halves both resolve the board-linked fixture thread without raising');
 select is(
-  (select agent_board._claimgate_board_claim_policy(c.thread) from _cpr c),
-  (select agent_board._claimgate_board_claim_policy_of(agent_board._claimgate_board_of_thread(c.thread)) from _cpr c),
+  (select v from _cpr_out where site = 'CPR-19'),
+  (select v from _cpr_out where site = 'CPR-19-halves'),
   'CPR-19 COMPOSITION: for a board-linked thread the thread-keyed resolver and the two halves agree — one definition of the walk, not two');
 
+select lives_ok(
+  $$ insert into _cpr_out select 'CPR-20', coalesce((select agent_board._claimgate_board_claim_policy(c.free_thread) from _cpr c)::text, '<null>') $$,
+  'CPR-20 COMPOSITION (runs): the thread-keyed resolver accepts a thread with no board without raising');
 select is(
-  (select agent_board._claimgate_board_claim_policy(c.free_thread) from _cpr c),
+  (select v from _cpr_out where site = 'CPR-20'),
   'inherit',
   'CPR-20 COMPOSITION: a thread with NO board still resolves inherit — a claim cannot opt itself out by omitting the board (BCP-5''s rule, unchanged by the decomposition)');
 
 -- CPR-21. And the board-linked fixture really is advisory, so CPR-19 is comparing something.
--- Without this CPR-19 could agree on 'inherit' twice and prove nothing.
+-- Without this CPR-19 could agree on 'inherit' twice and prove nothing. Read from the SAME capture
+-- CPR-19 compared, so it is that comparison's discrimination that is pinned; and CPR-19 itself
+-- cannot pass on two absent rows, because the sentinel check here names the value.
 select is(
-  (select agent_board._claimgate_board_claim_policy(c.thread) from _cpr c),
+  (select v from _cpr_out where site = 'CPR-19'),
   'advisory',
   'CPR-21 DISCRIMINATION: the fixture board is advisory, so CPR-19 compares a non-default answer rather than agreeing on the fallback twice');