@consiliency/agent-board-schema 1.68.0 → 1.74.0

package/tests/agent_board_667_native_cast_effect.test.sql

@@ -0,0 +1,88 @@
+-- This is a caller/boundary witness, not an exemption from the opaque-routine
+-- census. A selected domain check can invoke a guarded history writer even
+-- though the native wrapper is IMMUTABLE. Missing platform code gets no credit.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+begin;
+select plan(16);
+select set_config('request.jwt.claim.role','service_role',true);
+insert into agent_board.agents(id,agent_type,handle,display_name,status)
+values ('667e0000-0000-4000-8000-000000000001','agent','native-cast-probe','Native cast probe','active');
+insert into agent_board.threads(id,thread_type,created_by_agent_id,subject)
+values ('667e0000-0000-4000-8000-000000000010','coordination','667e0000-0000-4000-8000-000000000001','Private cast probe');
+insert into agent_board.boards(id,slug,name,created_by_agent_id,visibility,status)
+values ('667e0000-0000-4000-8000-000000000020','native-cast-probe-board','Native cast probe','667e0000-0000-4000-8000-000000000001','private','active');
+create schema xb_native_cast_probe;
+create function xb_native_cast_probe.write_guarded_history(p_value integer)
+returns boolean language plpgsql volatile as $$
+begin
+  perform agent_board.create_task('667e0000-0000-4000-8000-000000000010','667e0000-0000-4000-8000-000000000001','Written through a domain expression');
+  return true;
+end$$;
+create domain xb_native_cast_probe.writing_integer as integer
+check (xb_native_cast_probe.write_guarded_history(value));
+create temp table xb_native_cast_answer(value jsonb) on commit drop;
+select is((select count(*) from agent_board.threads where id='667e0000-0000-4000-8000-000000000010' and board_id is null),
+  1::bigint,'XB conversion fixture starts as an unstamped private thread');
+select diag('Native realtime.cast absent: no platform execution or disposition credit')
+where to_regprocedure('realtime."cast"(text,regtype)') is null;
+select * from skip('native realtime.cast absent',7)
+where to_regprocedure('realtime."cast"(text,regtype)') is null;
+select is(md5(pg_get_functiondef(to_regprocedure('realtime."cast"(text,regtype)'))),
+  '2d38c9a2b85fe787afe48a12c02839e8','XB native cast definition matches the captured CI body')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+select lives_ok($$insert into xb_native_cast_answer select realtime."cast"('4','xb_native_cast_probe.writing_integer'::regtype)$$,
+  'XB native cast executes the domain conversion')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+select is((select value from xb_native_cast_answer),'4'::jsonb,'XB native cast returns the converted value')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+select is((select count(*) from agent_board.tasks where thread_id='667e0000-0000-4000-8000-000000000010'),1::bigint,
+  'XB native cast domain check executes the guarded history writer')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+-- Both equality overloads dynamically cast their operands. These checks are
+-- separately conditional on each full identity; absence is not execution credit.
+select diag('Native four-argument equality absent: no platform execution credit')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is null;
+select * from skip('native four-argument equality absent',4)
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is null;
+select is(md5(pg_get_functiondef(to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)'))),
+  'dc96014b6232b30f11a6465db31bd20a','XB native four-argument equality definition matches CI')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is not null;
+create temp table xb_equality_answer(arity integer, value boolean) on commit drop;
+select lives_ok($$insert into xb_equality_answer select 4,realtime.check_equality_op('eq','xb_native_cast_probe.writing_integer'::regtype,'4','4')$$,
+  'XB native four-argument equality executes selected conversions')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is not null;
+select is((select value from xb_equality_answer where arity=4),true,'XB native four-argument equality returns true')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is not null;
+select is((select count(*) from agent_board.tasks where thread_id='667e0000-0000-4000-8000-000000000010'),
+  (case when to_regprocedure('realtime."cast"(text,regtype)') is null then 2 else 3 end)::bigint,
+  'XB native four-argument equality conversions invoke the guarded writer twice')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is not null;
+select diag('Native five-argument equality absent: no platform execution credit')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)') is null;
+select * from skip('native five-argument equality absent',4)
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)') is null;
+select is(md5(pg_get_functiondef(to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)'))),
+  '3db26de03f6feab4f7fc8f9a8a48c07e','XB native five-argument equality definition matches CI')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)') is not null;
+select lives_ok($$insert into xb_equality_answer select 5,realtime.check_equality_op('eq','xb_native_cast_probe.writing_integer'::regtype,'4','4',true)$$,
+  'XB native five-argument equality executes selected conversions')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)') is not null;
+select is((select value from xb_equality_answer where arity=5),false,'XB native five-argument equality negates its result')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)') is not null;
+select is((select count(*) from agent_board.tasks where thread_id='667e0000-0000-4000-8000-000000000010'),
+  (2 + case when to_regprocedure('realtime."cast"(text,regtype)') is null then 0 else 1 end
+     + case when to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text)') is null then 0 else 2 end)::bigint,
+  'XB native five-argument equality conversions invoke the guarded writer twice')
+where to_regprocedure('realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)') is not null;
+select throws_ok($$select * from agent_board.post_board_message('667e0000-0000-4000-8000-000000000010','667e0000-0000-4000-8000-000000000001','667e0000-0000-4000-8000-000000000020','subject','body')$$,
+  '42501','thread has private history','XB native cast indirect history prevents association')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+select is((select count(*) from agent_board.messages where thread_id='667e0000-0000-4000-8000-000000000010'),0::bigint,
+  'XB native cast refused association inserts no message')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+select is((select board_id from agent_board.threads where id='667e0000-0000-4000-8000-000000000010'),null::uuid,
+  'XB native cast private thread remains unstamped')
+where to_regprocedure('realtime."cast"(text,regtype)') is not null;
+select * from finish();
+rollback;

package/tests/agent_board_667_realtime_apply_behavior.test.sql

@@ -0,0 +1,117 @@
+-- Native apply_rls own-row, role, prepared-target and history witnesses. These
+-- are runtime observations, distinct from the effect-class disposition.
+create extension if not exists pgtap with schema extensions;set search_path=extensions,public,agent_board;begin;
+select to_regprocedure('realtime.apply_rls(jsonb,integer)') is not null as native_present \gset
+\if :native_present
+select plan(26);
+create schema xb_ar_own;
+create table xb_ar_own.notes(id integer primary key,owner text not null);
+alter table xb_ar_own.notes enable row level security;
+create policy xb_ar_own_claims on xb_ar_own.notes for select to authenticated
+  using (owner=(nullif(current_setting('request.jwt.claims',true),'')::jsonb->>'sub'));
+create table xb_ar_own.plain(id integer primary key);
+create table xb_ar_own.effect(n text);
+grant usage on schema xb_ar_own to authenticated;
+grant select on xb_ar_own.notes,xb_ar_own.plain to authenticated;
+grant insert on xb_ar_own.effect to authenticated;
+insert into xb_ar_own.notes values(1,'alice'),(2,'bob');
+insert into realtime.subscription(subscription_id,entity,claims) values
+ ('66700000-0000-4000-8000-0000000000a1','xb_ar_own.notes','{"role":"authenticated","sub":"alice"}'),
+ ('66700000-0000-4000-8000-0000000000b2','xb_ar_own.notes','{"role":"authenticated","sub":"bob"}'),
+ ('66700000-0000-4000-8000-0000000000c3','xb_ar_own.plain','{"role":"authenticated","sub":"alice"}');
+create temp table ar_out(wal jsonb,is_rls_enabled boolean,subscription_ids uuid[],errors text[]) on commit drop;
+create function pg_temp.ar_wal(p_table text,p_action text,p_id integer) returns jsonb language sql as $f$
+  select jsonb_build_object('action',p_action,'schema','xb_ar_own','table',p_table,'timestamp','2026-10-27 00:00:00+00',
+    'columns',jsonb_build_array(jsonb_build_object('name','id','type','int4','value',p_id)),
+    'identity',jsonb_build_array(jsonb_build_object('name','id','type','int4','value',p_id)),
+    'pk',jsonb_build_array(jsonb_build_object('name','id','type','int4')))
+$f$;
+create temp table ar_history on commit drop as
+  with direct as (select distinct conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass)
+  select conrelid as relid,0::bigint as n from direct
+  union select f.conrelid,0 from pg_constraint f join direct d on d.conrelid=f.confrelid where f.contype='f';
+do $$ declare r record; begin
+  for r in select relid from pg_temp.ar_history loop
+    execute format('update pg_temp.ar_history set n=(select count(*) from %s) where relid=%s',r.relid::regclass,r.relid);
+  end loop; end $$;
+
+-- Own-row visibility is decided by the subscriber's role and claims.
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(pg_temp.ar_wal('notes','I',1))$c$,'AR alice row native call lives');
+select is((select subscription_ids from ar_out),array['66700000-0000-4000-8000-0000000000a1']::uuid[],'AR only the owning subscriber sees alice row');
+select ok((select is_rls_enabled and errors='{}' from ar_out),'AR alice row took the row-security path without errors');
+truncate ar_out;
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(pg_temp.ar_wal('notes','I',2))$c$,'AR bob row native call lives');
+select is((select subscription_ids from ar_out),array['66700000-0000-4000-8000-0000000000b2']::uuid[],'AR only the owning subscriber sees bob row');
+-- Exit state: the role is reset; the last subscriber's claims stay set for the
+-- remainder of this transaction. This is native behavior, recorded not endorsed.
+select is(current_user::text,'postgres','AR caller role is restored after the subscriber role switches');
+select ok(current_setting('request.jwt.claims')::jsonb in('{"role":"authenticated","sub":"alice"}'::jsonb,'{"role":"authenticated","sub":"bob"}'::jsonb),
+  'AR subscriber claims remain set after return');
+select is((select count(*) from pg_prepared_statements where name='walrus_rls_stmt'),1::bigint,'AR prepared target remains a session resource');
+select ok((select statement from pg_prepared_statements where name='walrus_rls_stmt') ~ 'from\s+xb_ar_own\.notes\s+where\s+id=''2''',
+  'AR prepared target is schema-qualified when the relation is not on the search path');
+
+-- PREPARE/EXECUTE is reached only for a row-security entity and a non-DELETE.
+deallocate walrus_rls_stmt;
+truncate ar_out;
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(pg_temp.ar_wal('notes','D',1))$c$,'AR delete native call lives');
+select is((select count(*) from pg_prepared_statements where name='walrus_rls_stmt'),0::bigint,'AR delete does not prepare the target');
+select is((select array_agg(x order by x) from ar_out cross join unnest(subscription_ids) x),
+  array['66700000-0000-4000-8000-0000000000a1','66700000-0000-4000-8000-0000000000b2']::uuid[],
+  'AR delete is delivered by filter without a row-security check');
+truncate ar_out;
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(pg_temp.ar_wal('plain','I',1))$c$,'AR non-row-security native call lives');
+select is((select count(*) from pg_prepared_statements where name='walrus_rls_stmt'),0::bigint,'AR non-row-security entity does not prepare the target');
+select is((select subscription_ids from ar_out),array['66700000-0000-4000-8000-0000000000c3']::uuid[],'AR non-row-security subscriber is delivered');
+
+-- The role switch cannot exceed the session user's SET membership.
+create role xb_ar_unsettable nologin;
+grant select on xb_ar_own.notes to xb_ar_unsettable;
+select ok(not pg_has_role(session_user,'xb_ar_unsettable','SET'),'AR control role is not settable by the session user');
+insert into realtime.subscription(subscription_id,entity,claims) values
+ ('66700000-0000-4000-8000-0000000000d4','xb_ar_own.notes','{"role":"xb_ar_unsettable","sub":"alice"}');
+select throws_ok($c$select * from realtime.apply_rls(pg_temp.ar_wal('notes','I',1))$c$,'42501',null,
+  'AR an unsettable subscriber role is refused, not assumed');
+delete from realtime.subscription where subscription_id='66700000-0000-4000-8000-0000000000d4';
+
+-- A board relation reaches its real policies and helpers, without history writes.
+grant usage on schema agent_board to authenticated;
+insert into realtime.subscription(subscription_id,entity,claims) values
+ ('66700000-0000-4000-8000-0000000000e5','agent_board.threads','{"role":"authenticated","sub":"66700000-0000-4000-8000-0000000000ff"}');
+truncate ar_out;
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(jsonb_build_object('action','I','schema','agent_board','table','threads',
+  'timestamp','2026-10-27 00:00:00+00','columns',jsonb_build_array(jsonb_build_object('name','id','type','uuid','value','66700000-0000-4000-8000-0000000000ff')),
+  'pk',jsonb_build_array(jsonb_build_object('name','id','type','uuid'))))$c$,'AR board thread native call lives');
+select ok((select is_rls_enabled and errors='{}' and subscription_ids='{}' from ar_out),'AR board thread row-security check ran and refused visibility');
+select ok((select statement from pg_prepared_statements where name='walrus_rls_stmt') ~ 'from\s+(agent_board\.)?threads\s',
+  'AR board thread was the prepared target');
+create function pg_temp.ar_history_changed() returns bigint language plpgsql as $f$
+declare r record; changed bigint:=0; now_n bigint; begin
+  for r in select relid,n from pg_temp.ar_history loop
+    execute format('select count(*) from %s',r.relid::regclass) into now_n;
+    if now_n<>r.n then changed:=changed+1; end if;
+  end loop; return changed; end $f$;
+select is(pg_temp.ar_history_changed(),0::bigint,'AR no history relation changed during the native calls');
+select ok((select count(*)>=8 from pg_temp.ar_history),'AR history snapshot covers the catalog-derived history relations');
+
+-- Redirection witness. With the target on the search path its regclass text is
+-- unqualified, and PostgreSQL re-parses the prepared statement under the
+-- subscriber role's "$user" schema. The guard must therefore include every
+-- relation that shares a target's relname; see the apply_rls controls.
+create schema authenticated;
+grant usage on schema authenticated to authenticated;
+create function authenticated.xb_ar_redirect_probe() returns boolean language sql
+  as $f$insert into xb_ar_own.effect values('redirected') returning true$f$;
+create view authenticated.notes as select 1 as id where authenticated.xb_ar_redirect_probe();
+grant select on authenticated.notes to authenticated;
+truncate ar_out;
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(pg_temp.ar_wal('notes','I',1))$c$,'AR qualified control native call lives');
+select is((select count(*) from xb_ar_own.effect),0::bigint,'AR qualified target is not redirected');
+set local search_path="$user",xb_ar_own,extensions,public,agent_board;
+truncate ar_out;
+select lives_ok($c$insert into ar_out select * from realtime.apply_rls(pg_temp.ar_wal('notes','I',1))$c$,'AR unqualified target native call lives');
+select is((select count(*) from xb_ar_own.effect),2::bigint,'AR unqualified target is re-resolved under each subscriber role');
+\else
+select plan(1);select ok(to_regprocedure('realtime.apply_rls(jsonb,integer)') is null,'AR native apply_rls absent; no native behavior credit');
+\endif
+select * from finish();rollback;

package/tests/agent_board_667_realtime_apply_controls.test.sql

@@ -0,0 +1,143 @@
+-- Each control installs one catalog edge of a closure class, proves the guard
+-- names its exact identity and closes admission, then proves removal restores
+-- the prior findings. Probes are never executed.
+create extension if not exists pgtap with schema extensions;
+create extension if not exists plpgsql_check with schema extensions;
+set search_path=extensions,public,agent_board;
+begin;
+\ir fixtures/agent_board_667_conversion_guard.sql
+\ir fixtures/agent_board_667_sender_guard.sql
+\ir fixtures/agent_board_667_timestamp_guard.sql
+\ir fixtures/agent_board_667_apply_rls_guard.sql
+select to_regprocedure('realtime.apply_rls(jsonb,integer)') is not null as native_present \gset
+\if :native_present
+select plan(32);
+create temp table ar_prior on commit drop as select * from pg_temp.xb_ar_problems();
+create temp table ar_seen(identity text,problem text) on commit drop;
+create function pg_temp.ar_capture() returns void language plpgsql as $f$
+begin truncate pg_temp.ar_seen; insert into pg_temp.ar_seen select * from pg_temp.xb_ar_problems(); end $f$;
+create function pg_temp.ar_restored() returns boolean language sql as $f$
+  select (select jsonb_agg(jsonb_build_array(identity,problem) order by identity,problem) from pg_temp.xb_ar_problems())
+    is not distinct from (select jsonb_agg(jsonb_build_array(identity,problem) order by identity,problem) from pg_temp.ar_prior)
+$f$;
+create schema xb_ar_ctl;
+create schema xb_ar_ctl2;
+create function xb_ar_ctl.probe() returns boolean language plpgsql as $f$begin return true;end$f$;
+
+-- C1 a relation sharing a row-security target's relname is a possible prepared target.
+create view xb_ar_ctl2.threads as select 1 as id where xb_ar_ctl.probe();
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.xb_ar_rel where rel='xb_ar_ctl2.threads'::regclass
+  and origin='row-security target or same-name resolution'),'AR C1 same-name view enters the closure by relname');
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.probe()' and problem='unreviewed apply_rls executable'),
+  'AR C1 same-name view names its unreviewed callee');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C1 same-name view closes admission');
+drop view xb_ar_ctl2.threads;
+select ok(pg_temp.ar_restored(),'AR C1 removal restores the prior findings');
+
+-- C2 a parsed policy helper must be SELECT-only; a DML body names itself.
+create table xb_ar_ctl.sink(id integer);
+create table xb_ar_ctl.target(id integer);
+alter table xb_ar_ctl.target enable row level security;
+create function xb_ar_ctl.writes() returns boolean language sql set search_path=pg_catalog
+  as $f$select 1;with w as (insert into xb_ar_ctl.sink values(1) returning 1) select exists(select 1 from w)$f$;
+create policy xb_ar_ctl_writes on xb_ar_ctl.target for select using (xb_ar_ctl.writes());
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.writes()' and problem='apply_rls helper is not SELECT-only'),
+  'AR C2 a policy helper that writes names itself');
+select ok(not exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.writes()' and problem='unreviewed apply_rls executable'),
+  'AR C2 the writer is refused by its parsed structure, not by an identity list');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C2 writing helper closes admission');
+drop policy xb_ar_ctl_writes on xb_ar_ctl.target;
+select ok(pg_temp.ar_restored(),'AR C2 removal restores the prior findings');
+
+-- C3 inheritance children of a target are scanned with it.
+create table xb_ar_ctl.xb_ar_child_only() inherits (xb_ar_ctl.target);
+create policy xb_ar_ctl_child on xb_ar_ctl.xb_ar_child_only for select using (xb_ar_ctl.probe());
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.xb_ar_rel where rel='xb_ar_ctl.xb_ar_child_only'::regclass and origin like 'inheritance child of %'),
+  'AR C3 inheritance child enters the closure');
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.probe()' and problem='unreviewed apply_rls executable'),
+  'AR C3 inheritance child names its unreviewed policy callee');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C3 inheritance child closes admission');
+drop table xb_ar_ctl.xb_ar_child_only;
+select ok(pg_temp.ar_restored(),'AR C3 removal restores the prior findings');
+
+-- C4 a pinned-path SQL helper is expanded through its own parsed body.
+create function xb_ar_ctl.helper() returns boolean language sql stable set search_path=pg_catalog
+  as $f$select xb_ar_ctl.probe()$f$;
+create policy xb_ar_ctl_helper on xb_ar_ctl.target for select using (xb_ar_ctl.helper());
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.xb_ar_fn where fn='xb_ar_ctl.probe()'::regprocedure and origin='body of xb_ar_ctl.helper()'),
+  'AR C4 helper body reaches its callee');
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.probe()' and problem='unreviewed apply_rls executable'),
+  'AR C4 helper body names its unreviewed callee');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C4 helper callee closes admission');
+drop policy xb_ar_ctl_helper on xb_ar_ctl.target;
+select ok(pg_temp.ar_restored(),'AR C4 removal restores the prior findings');
+
+-- C5 a body without a pinned search_path resolves names at run time, so
+-- every same-named routine is a possible callee.
+create function xb_ar_ctl.unpinned() returns boolean language sql stable as $f$select pg_catalog.lower('x')='x'$f$;
+create function xb_ar_ctl.lower(text) returns text language plpgsql as $f$begin return $1;end$f$;
+create policy xb_ar_ctl_unpinned on xb_ar_ctl.target for select using (xb_ar_ctl.unpinned());
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.lower(text)' and problem='unreviewed apply_rls executable'),
+  'AR C5 run-time shadow of a helper call names itself');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C5 run-time shadow closes admission');
+drop policy xb_ar_ctl_unpinned on xb_ar_ctl.target;
+drop function xb_ar_ctl.lower(text);
+select ok(pg_temp.ar_restored(),'AR C5 removal restores the prior findings');
+
+-- C6 apply_rls itself has no pinned search_path: a static-call shadow names itself.
+create function xb_ar_ctl.set_config(text,text,boolean) returns text language plpgsql as $f$begin return $2;end$f$;
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.set_config(text,text,boolean)' and problem='unreviewed apply_rls executable'),
+  'AR C6 static-call shadow names itself');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C6 static-call shadow closes admission');
+drop function xb_ar_ctl.set_config(text,text,boolean);
+select ok(pg_temp.ar_restored(),'AR C6 removal restores the prior findings');
+
+-- C7 a relation read inside a policy is itself scanned under row security.
+create table xb_ar_ctl.xb_ar_side_only(id integer);
+create policy xb_ar_ctl_side on xb_ar_ctl.xb_ar_side_only for select using (xb_ar_ctl.probe());
+create policy xb_ar_ctl_reads on xb_ar_ctl.target for select using (exists(select 1 from xb_ar_ctl.xb_ar_side_only));
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.xb_ar_rel where rel='xb_ar_ctl.xb_ar_side_only'::regclass and origin like 'policy %'),
+  'AR C7 policy-read relation enters the closure');
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl.probe()' and problem='unreviewed apply_rls executable'),
+  'AR C7 policy-read relation names its unreviewed policy callee');
+drop policy xb_ar_ctl_reads on xb_ar_ctl.target;
+drop table xb_ar_ctl.xb_ar_side_only;
+select ok(pg_temp.ar_restored(),'AR C7 removal restores the prior findings');
+
+-- C8 an undispositioned relation kind among possible targets names itself.
+create sequence xb_ar_ctl2.target;
+do $$ begin perform pg_temp.ar_capture(); end $$;
+select ok(exists(select 1 from pg_temp.ar_seen where identity='xb_ar_ctl2.target' and problem='unreviewed apply_rls relation kind S'),
+  'AR C8 same-name sequence names its relation kind');
+drop sequence xb_ar_ctl2.target;
+select ok(pg_temp.ar_restored(),'AR C8 removal restores the prior findings');
+
+-- C9 the wrapper declaration is exact; drift closes admission by identity.
+update pg_temp.xb_ar_reference set payload=payload||'{"owner":"drifted"}' where kind='wrapper';
+select ok(exists(select 1 from pg_temp.xb_ar_problems() where identity='realtime.apply_rls(jsonb,integer)'
+  and problem='apply_rls declaration or security drift'),'AR C9 wrapper declaration drift names itself');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C9 wrapper drift closes admission');
+update pg_temp.xb_ar_reference set payload=payload-'owner'||jsonb_build_object('owner',pg_get_userbyid(p.proowner))
+  from pg_proc p where kind='wrapper' and p.oid=to_regprocedure(identity);
+select ok(pg_temp.ar_restored(),'AR C9 restoring the declaration restores the prior findings');
+
+-- C10 a reviewed built-in leaf is admitted only with its exact declaration.
+update pg_temp.xb_ar_reference set payload=payload||'{"definition_md5":"drifted"}'
+  where kind='primitive' and identity='pg_catalog.set_config(text,text,boolean)';
+select ok(exists(select 1 from pg_temp.xb_ar_problems() where identity='pg_catalog.set_config(text,text,boolean)'
+  and problem='unreviewed apply_rls executable'),'AR C10 built-in leaf drift names itself');
+select is((select count(*) from pg_temp.xb_ar_admitted()),0::bigint,'AR C10 built-in leaf drift closes admission');
+\else
+select plan(1);
+select ok(to_regprocedure('realtime.apply_rls(jsonb,integer)') is null
+  and not exists(select 1 from pg_temp.xb_ar_admitted()),'AR absent native apply_rls has no control admission');
+\endif
+select * from finish();
+rollback;

package/tests/agent_board_667_realtime_apply_profile.test.sql

@@ -0,0 +1,61 @@
+create extension if not exists pgtap with schema extensions;
+create extension if not exists plpgsql_check with schema extensions;
+set search_path=extensions,public,agent_board;
+begin;
+\ir fixtures/agent_board_667_conversion_guard.sql
+\ir fixtures/agent_board_667_sender_guard.sql
+\ir fixtures/agent_board_667_timestamp_guard.sql
+\ir fixtures/agent_board_667_apply_rls_guard.sql
+select to_regprocedure('realtime.apply_rls(jsonb,integer)') is not null as native_present \gset
+\if :native_present
+select plan(14);
+select is((select string_agg(identity||': '||problem,', ' order by identity,problem) from pg_temp.xb_ar_problems()),null::text,
+  'AR complete target, policy, helper and built-in closure matches');
+select is((select array_agg(fn order by fn) from pg_temp.xb_ar_admitted()),
+  array['realtime.apply_rls(jsonb,integer)'::regprocedure::oid],'AR exactly the native apply_rls OID is admitted');
+do $$ begin perform pg_temp.xb_ar_compute(); end $$;
+select is((select string_agg(c.oid::regclass::text,', ' order by c.oid::regclass::text) from pg_class c
+  where c.relrowsecurity and c.relkind in('r','p') and not exists(select 1 from pg_temp.xb_ar_rel r where r.rel=c.oid)),
+  null::text,'AR every row-security target is in the closure');
+select is((select string_agg(o.oid::regclass::text,', ' order by o.oid::regclass::text) from pg_class t join pg_class o on o.relname=t.relname
+  where t.relrowsecurity and t.relkind in('r','p') and not exists(select 1 from pg_temp.xb_ar_rel r where r.rel=o.oid)),
+  null::text,'AR every relation sharing a target relname is in the closure');
+select ok(exists(select 1 from pg_temp.xb_ar_rel where rel='realtime.subscription'::regclass)
+  and exists(select 1 from pg_temp.xb_ar_rel where rel='pg_catalog.pg_prepared_statements'::regclass),
+  'AR static subscription and prepared-statement reads are in the closure');
+select ok(exists(select 1 from pg_temp.xb_ar_fn where fn='pg_catalog.set_config(text,text,boolean)'::regprocedure),
+  'AR the role and claims switch is a reviewed reached primitive');
+select ok(exists(select 1 from pg_temp.xb_ar_fn where fn='agent_board.current_agent_id()'::regprocedure and origin like 'policy %'),
+  'AR row-security policies reach their helper functions');
+select ok(exists(select 1 from pg_temp.xb_ar_fn where fn='auth.uid()'::regprocedure and origin like 'body of %'),
+  'AR parsed helper bodies reach their own callees');
+select ok(exists(select 1 from pg_temp.xb_ar_fn where fn='realtime.check_equality_op(realtime.equality_op,regtype,text,text,boolean)'::regprocedure),
+  'AR the filter constructor reaches the admitted comparison dispatch');
+select ok((select count(*)>=13 and bool_and(tree is not null and problem is null) from pg_temp.xb_ar_parse),
+  'AR every reached SQL body parsed into a stored tree');
+-- The reference is exact in both directions: no reached built-in is missing
+-- and no listed leaf is stale.
+select is((with reached as (select pg_temp.xb_cf_fn(a.fn) identity from pg_temp.xb_ar_fn a
+    where not exists(select 1 from pg_temp.xb_cf_primitives c where c.fn=a.fn)
+      and not exists(select 1 from pg_temp.xb_cf_wrappers w where to_regprocedure(w.identity)=a.fn)
+      and not exists(select 1 from pg_temp.xb_ar_reference r where r.kind='constructor' and to_regprocedure(r.identity)=a.fn)
+      and not exists(select 1 from pg_temp.xb_ar_parse p where p.fn=a.fn)),
+  listed as (select identity from pg_temp.xb_ar_reference where kind in('primitive','aggregate'))
+  select string_agg(coalesce(r.identity,l.identity),', ' order by coalesce(r.identity,l.identity))
+    from reached r full join listed l on l.identity=r.identity where r.identity is null or l.identity is null),
+  null::text,'AR reviewed built-in leaves equal the reached built-ins exactly');
+select is((select payload->>'prosrc_md5' from pg_temp.xb_ar_reference where kind='coverage'),
+  (select md5(prosrc) from pg_proc where oid='realtime.apply_rls(jsonb,integer)'::regprocedure),
+  'AR source coverage is bound to the actual native body');
+select ok((select bool_and(position(payload->>'syntax' in lower(agent_board_test.stripped_body(p.oid)))>0) from pg_temp.xb_ar_reference r
+  cross join pg_proc p where r.kind='syntax' and p.oid='realtime.apply_rls(jsonb,integer)'::regprocedure),
+  'AR every grammar-form call is present in the native body');
+select is((select count(*) from pg_temp.xb_ar_reference where kind='constructor'),2::bigint,
+  'AR both SQL constructors are pinned declarations');
+\else
+select plan(1);
+select ok(to_regprocedure('realtime.apply_rls(jsonb,integer)') is null
+  and not exists(select 1 from pg_temp.xb_ar_admitted()),'AR absent native apply_rls has no admission or native credit');
+\endif
+select * from finish();
+rollback;