@consiliency/agent-board-schema 1.64.0 → 1.74.0

package/tests/agent_board_667_history_class.test.sql

@@ -0,0 +1,785 @@
+-- Catalog-derived history and writer dispositions, coupled to #667 behavior and
+-- mutation witnesses. Unsupported routine and entry paths fail by full identity.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+begin;
+-- Like WEC-24, own the parser prerequisite inside this test's transaction. CI
+-- starts with the extension available but not installed; another file's rolled
+-- back installation cannot supply it. Missing availability still fails closed.
+do $$
+begin
+  if exists (select 1 from pg_available_extensions where name='plpgsql_check') then
+    execute 'create extension if not exists plpgsql_check with schema extensions';
+  end if;
+end $$;
+select plan(61);
+-- Procedure bodies and CALL edges are outside the function parsers below.
+-- Fail closed on every non-extension application procedure until its complete
+-- history and caller effects receive an explicit positive disposition.
+select is(
+  (select string_agg(format('%I.%I(%s)', n.nspname, p.proname,
+                           pg_get_function_identity_arguments(p.oid)), ', '
+                     order by n.nspname, p.proname, p.oid::regprocedure::text)
+     from pg_proc p join pg_namespace n on n.oid=p.pronamespace
+    where p.prokind='p'
+      and n.nspname not in ('pg_catalog','information_schema','agent_board_test')
+      and n.nspname not like 'pg_%'
+      and not exists (select 1 from pg_depend d
+        where d.classid='pg_proc'::regclass and d.objid=p.oid and d.deptype='e')),
+  null::text, 'XB application procedures and CALL paths require explicit disposition');
+-- Supabase ships DDL event-trigger handlers outside extension membership. They
+-- are not ordinary RPC entry points: prove the PostgreSQL refusal for every
+-- catalog-derived handler instead of excluding a platform schema or name. The
+-- control keeps this exemption exercised on minimal local substrates too.
+create schema xb_event_trigger_probe;
+create function xb_event_trigger_probe.not_rpc() returns event_trigger language plpgsql as $body$
+begin execute 'select 1'; end $body$;
+create function pg_temp.xb_event_trigger_call_problem(p_fn oid) returns text language plpgsql as $body$
+begin
+  execute format('select %s()',p_fn::regproc);
+  return 'ordinary invocation succeeded';
+exception when others then
+  if sqlstate='0A000' and sqlerrm='trigger functions can only be called as triggers' then
+    return null;
+  end if;
+  return sqlstate || ':' || sqlerrm;
+end $body$;
+select is((select case when count(*)=0 then 'event-trigger control missing'
+  else string_agg(format('%s: %s',f.oid::regprocedure,x.problem), ', ' order by f.oid::regprocedure::text)
+       filter (where x.problem is not null) end
+  from pg_proc f join pg_namespace n on n.oid=f.pronamespace
+  cross join lateral pg_temp.xb_event_trigger_call_problem(f.oid) x(problem)
+  where f.prokind='f' and f.prorettype='event_trigger'::regtype
+    and n.nspname not in ('pg_catalog','information_schema','agent_board_test') and n.nspname not like 'pg_%'
+    and not exists (select 1 from pg_depend d where d.classid='pg_proc'::regclass and d.objid=f.oid and d.deptype='e')),
+  null::text, 'XB DDL event-trigger handlers cannot be invoked as ordinary RPCs');
+-- Enumerate from constraints, not a hand-written list. The receipt exemption is
+-- permitted only while its complete catalog shape has no caller-content columns.
+-- Each relation must carry the exact closed predicate, not merely its name: a
+-- name scan survived `... where thread_id = p_thread_id and false` (#707 B1).
+-- The exemption is positive: read_receipts must itself be a direct thread FK.
+select is(
+  (select string_agg(problem, ', ' order by problem) from (
+    select 'agent_board.read_receipts: exemption is not a direct thread FK' as problem
+     where not exists (select 1 from pg_constraint where contype='f'
+       and conrelid='agent_board.read_receipts'::regclass and confrelid='agent_board.threads'::regclass)
+    union all
+    select 'direct thread-FK history census is empty'
+     where not exists (select 1 from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass
+       and conrelid <> 'agent_board.read_receipts'::regclass)
+    union all
+    select format('%I.%I', n.nspname, c.relname)
+      from (select distinct conrelid from pg_constraint
+             where contype='f' and confrelid='agent_board.threads'::regclass
+               and conrelid <> 'agent_board.read_receipts'::regclass) fk
+      join pg_class c on c.oid=fk.conrelid
+      join pg_namespace n on n.oid=c.relnamespace
+     where agent_board_test.stripped_body('agent_board._associate_empty_thread(uuid,uuid)'::regprocedure)
+       !~ agent_board_test.re(agent_board_test.ci_re('exists') || '\s*\(\s*' || agent_board_test.ci_re('select')
+         || '\s+1\s+' || agent_board_test.ci_re('from') || '\s+' || agent_board_test.qname_frag(n.nspname||'.'||c.relname,false)
+         || '\s+' || agent_board_test.ci_re('where') || '\s+' || agent_board_test.col_ref_frag('thread_id')
+         || '\s*=\s*' || agent_board_test.ident_re('p_thread_id') || '\s*\)')) p),
+  null::text, 'XB every direct thread-FK relation has its exact thread-history predicate');
+select is(
+  (select array_agg(a.attname::text order by a.attnum) from pg_attribute a
+    where a.attrelid='agent_board.read_receipts'::regclass and a.attnum>0 and not a.attisdropped),
+  array['thread_id','agent_id','last_read_message_sequence','last_read_at']::text[],
+  'XB receipt exemption has only subject, bounded sequence and timestamp columns');
+-- Every catalog-discovered one-hop edge must be an enforced, validated single-column
+-- FK to its parent. This pins parent existence, not the remaining writer closure.
+select is(
+  (with direct as (select distinct conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass), edges as (
+    select f.oid, f.conrelid, f.conname, f.convalidated, cardinality(f.conkey) as nkeys
+      from pg_constraint f join direct d on d.conrelid=f.confrelid where f.contype='f')
+   select string_agg(format('%s.%I',conrelid::regclass,conname), ', ' order by conrelid::regclass::text, conname)
+     from edges where not convalidated or nkeys<>1),
+  null::text, 'XB one-hop parent-existence FKs are validated and single-column');
+-- Reviewed one-hop FK identities, derived from the fresh pg_constraint census.
+-- Each entry is positively checked against a validated FK below. This records
+-- relational parent existence only; parent history and writer behavior still
+-- require the separate witnesses and closure proof.
+create temp table xb_onehop_reviewed(child oid,parent oid, constraint_name text, primary key(child,parent,constraint_name)) on commit drop;
+insert into xb_onehop_reviewed values
+  ('agent_board.artifacts'::regclass,'agent_board.messages'::regclass,'artifacts_message_id_fkey'),
+  ('agent_board.artifacts'::regclass,'agent_board.task_events'::regclass,'artifacts_task_event_id_fkey'),
+  ('agent_board.artifacts'::regclass,'agent_board.tasks'::regclass,'artifacts_task_id_fkey'),
+  ('agent_board.callback_outbox_events'::regclass,'agent_board.messages'::regclass,'callback_outbox_events_source_message_id_fkey'),
+  ('agent_board.callback_outbox_events'::regclass,'agent_board.tasks'::regclass,'callback_outbox_events_source_task_id_fkey'),
+  ('agent_board.claims'::regclass,'agent_board.tasks'::regclass,'claims_task_id_fkey'),
+  ('agent_board.conflicts'::regclass,'agent_board.tasks'::regclass,'conflicts_task_id_fkey'),
+  ('agent_board.delegations'::regclass,'agent_board.tasks'::regclass,'delegations_child_task_id_fkey'),
+  ('agent_board.delegations'::regclass,'agent_board.tasks'::regclass,'delegations_parent_task_id_fkey'),
+  ('agent_board.delivery_recipients'::regclass,'agent_board.messages'::regclass,'delivery_recipients_source_message_id_fkey'),
+  ('agent_board.delivery_recipients'::regclass,'agent_board.tasks'::regclass,'delivery_recipients_source_task_id_fkey'),
+  ('agent_board.escalations'::regclass,'agent_board.tasks'::regclass,'escalations_task_id_fkey'),
+  ('agent_board.inbox_items'::regclass,'agent_board.messages'::regclass,'inbox_items_source_message_id_fkey'),
+  ('agent_board.inbox_items'::regclass,'agent_board.tasks'::regclass,'inbox_items_source_task_id_fkey'),
+  ('agent_board.messages'::regclass,'agent_board.tasks'::regclass,'messages_task_id_fkey'),
+  ('agent_board.signature_evidence'::regclass,'agent_board.artifacts'::regclass,'signature_evidence_source_artifact_id_fkey'),
+  ('agent_board.signature_evidence'::regclass,'agent_board.messages'::regclass,'signature_evidence_source_message_id_fkey'),
+  ('agent_board.signature_evidence'::regclass,'agent_board.task_events'::regclass,'signature_evidence_source_task_event_id_fkey'),
+  ('agent_board.task_events'::regclass,'agent_board.tasks'::regclass,'task_events_task_id_fkey'),
+  ('agent_board.tasks'::regclass,'agent_board.tasks'::regclass,'tasks_parent_task_id_fkey'),
+  ('agent_board.tasks'::regclass,'agent_board.tasks'::regclass,'tasks_root_task_id_fkey');
+create temp table xb_onehop_actual on commit drop as
+with direct as (select distinct conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass)
+select f.conrelid as child,f.confrelid as parent,f.conname::text as constraint_name,f.convalidated
+  from pg_constraint f join direct d on d.conrelid=f.confrelid where f.contype='f';
+select is((select string_agg(format('%s -> %s (%s)',a.child::regclass,a.parent::regclass,a.constraint_name), ', '
+                            order by a.child::regclass::text,a.parent::regclass::text,a.constraint_name)
+  from xb_onehop_actual a where not exists (select 1 from xb_onehop_reviewed r
+    where r.child=a.child and r.parent=a.parent and r.constraint_name=a.constraint_name)),
+  null::text, 'XB unreviewed one-hop FK names itself');
+select is((select string_agg(format('%s -> %s (%s)',r.child::regclass,r.parent::regclass,r.constraint_name), ', '
+                            order by r.child::regclass::text,r.parent::regclass::text,r.constraint_name)
+  from xb_onehop_reviewed r where not exists (select 1 from xb_onehop_actual a
+    where a.child=r.child and a.parent=r.parent and a.constraint_name=r.constraint_name and a.convalidated)),
+  null::text, 'XB each reviewed one-hop entry is a real validated FK to its claimed parent');
+
+-- Every actual one-hop edge points to a direct thread-FK parent.  Bind each
+-- discovered parent to the actual association predicate; the boundary and
+-- writer behavior tests separately prove task, message, event and artifact
+-- predicates with isolated history and omission mutations. This does not claim
+-- that parent existence alone proves each descendant's anchor semantics.
+select is((select string_agg(parent::regclass::text, ', ' order by parent::regclass::text)
+  from (select distinct parent from xb_onehop_actual) parents
+  join pg_class c on c.oid=parents.parent join pg_namespace n on n.oid=c.relnamespace
+  where agent_board_test.stripped_body('agent_board._associate_empty_thread(uuid,uuid)'::regprocedure)
+    !~ agent_board_test.re(agent_board_test.ci_re('exists') || '\s*\(\s*' || agent_board_test.ci_re('select')
+      || '\s+1\s+' || agent_board_test.ci_re('from') || '\s+' || agent_board_test.qname_frag(n.nspname||'.'||c.relname,false)
+      || '\s+' || agent_board_test.ci_re('where') || '\s+' || agent_board_test.col_ref_frag('thread_id')
+      || '\s*=\s*' || agent_board_test.ident_re('p_thread_id') || '\s*\)')),
+  null::text, 'XB every discovered one-hop parent has its own thread-history predicate');
+
+-- A bounded production PL/pgSQL call graph, built from catalog identities and
+-- parser-resolved OIDs. SQL-language and trigger edges are checked separately
+-- below; application procedures fail closed above. Parser failures and dynamic
+-- SQL remain visible by full identity instead of being treated as safe.
+create function pg_temp.xb_dependencies(p_fn oid) returns table(dep_oid oid, problem text) language plpgsql as $body$
+begin
+  return query select d.oid::oid, null::text
+    from extensions.plpgsql_show_dependency_tb(p_fn::regprocedure,0::oid) d where d.type='FUNCTION';
+exception when others then
+  return query select null::oid, sqlstate || ':' || sqlerrm;
+end $body$;
+create temp table xb_plpgsql on commit drop as
+select p.oid, format('%I.%I(%s)',n.nspname,p.proname,oidvectortypes(p.proargtypes)) as identity,
+       (has_function_privilege('authenticated',p.oid,'EXECUTE') or has_function_privilege('service_role',p.oid,'EXECUTE')
+        or has_function_privilege('anon',p.oid,'EXECUTE') or has_function_privilege('agent_board_delegate',p.oid,'EXECUTE')) as root,
+       agent_board_test.stripped_body(p.oid) ~ agent_board_test.re('\m' || agent_board_test.ci_re('execute') || '\M') as opaque
+  from pg_proc p join pg_namespace n on n.oid=p.pronamespace join pg_language l on l.oid=p.prolang
+ where p.prokind='f' and l.lanname='plpgsql' and p.prorettype not in ('trigger'::regtype,'event_trigger'::regtype)
+   and n.nspname not in ('pg_catalog','information_schema','agent_board_test') and n.nspname not like 'pg_%'
+   and not exists (select 1 from pg_depend d where d.classid='pg_proc'::regclass and d.objid=p.oid and d.deptype='e');
+create temp table xb_edges on commit drop as
+select f.oid as source,d.dep_oid,d.problem from xb_plpgsql f cross join lateral pg_temp.xb_dependencies(f.oid) d;
+create temp table xb_reachable on commit drop as
+with recursive reach(root,oid,path) as (
+  select oid,oid,array[oid] from xb_plpgsql where root
+  union all select r.root,e.dep_oid,r.path||e.dep_oid from reach r join xb_edges e on e.source=r.oid
+    join xb_plpgsql f on f.oid=e.dep_oid where not e.dep_oid=any(r.path)
+) select distinct oid from reach;
+select ok((select count(*)>0 from xb_plpgsql where root) and (select count(*)>0 from xb_edges where dep_oid is not null),
+  'XB PL/pgSQL callable roots and parser edges are nonempty');
+select is((select string_agg(distinct f.identity || ':' || e.problem, ', ' order by f.identity || ':' || e.problem)
+  from xb_plpgsql f join xb_edges e on e.source=f.oid where e.problem is not null),
+  null::text, 'XB PL/pgSQL parser failures name themselves even on internal functions');
+-- The exact reviewed body is bounded to four UPDATE templates over eight
+-- literal validator targets. Its real effects on all eight targets, including
+-- every row-level side write and anchor, are exercised in the companion
+-- agent_board_667_retention test. The body binding forces a fresh disposition
+-- for any new template, target, call or expression; it is not behavioral proof.
+select is(md5(pg_get_functiondef('agent_board.mark_retention_metadata(text,timestamptz,uuid,text)'::regprocedure)),
+  'ce1b6fb7c62f4e4b4110fcf09f18211e', 'XB retention reviewed validator and UPDATE templates remain exact');
+-- Conversion templates select typed scalar literals, not relations. Their type,
+-- operator, range and text-search dispatch must stay inside the finite primitive
+-- reference; custom or drifted callbacks close admission. Other platform dynamic
+-- SQL (including apply_rls and Storage) remains unresolved by this admission.
+\ir fixtures/agent_board_667_conversion_guard.sql
+select is((select string_agg(identity||': '||problem, ', ' order by identity,problem) from (
+    select * from pg_temp.xb_cf_problems() union all select * from pg_temp.xb_cf_wrapper_problems()) p),
+  null::text,'XB native conversion dispatch and metadata require exact disposition')
+where exists(select 1 from pg_temp.xb_cf_wrappers where to_regprocedure(identity) is not null);
+select * from skip('native conversion wrappers absent; no platform disposition credit',1)
+where not exists(select 1 from pg_temp.xb_cf_wrappers where to_regprocedure(identity) is not null);
+create temp table xb_native_conversion_admitted on commit drop as select fn from pg_temp.xb_cf_admitted();
+-- The two native senders have a separate, positive destination/effect class.
+-- Storage readers and apply_rls require their own positive proofs.
+\ir fixtures/agent_board_667_sender_guard.sql
+select is((select string_agg(identity||': '||problem, ', ' order by identity,problem) from pg_temp.xb_sf_problems()),
+  null::text,'XB native sender destination and effects require exact disposition')
+where exists(select 1 from pg_temp.xb_sf_reference where kind='wrapper' and to_regprocedure(identity) is not null);
+select * from skip('native senders absent; no platform sender disposition credit',1)
+where not exists(select 1 from pg_temp.xb_sf_reference where kind='wrapper' and to_regprocedure(identity) is not null);
+insert into xb_native_conversion_admitted select fn from pg_temp.xb_sf_admitted();
+-- One Storage SELECT template has its own target, resolution, aggregate and
+-- callback proof. Each other reader requires a separate disposition.
+\ir fixtures/agent_board_667_timestamp_guard.sql
+select is((select string_agg(identity||': '||problem, ', ' order by identity,problem) from pg_temp.xb_st_problems()),
+  null::text,'XB native timestamp reader and effects require exact disposition')
+where to_regprocedure('storage.search_by_timestamp(text,text,integer,integer,text,text,text,text,text,text,text)') is not null;
+select * from skip('native timestamp reader absent; no native Storage disposition credit',1)
+where to_regprocedure('storage.search_by_timestamp(text,text,integer,integer,text,text,text,text,text,text,text)') is null;
+insert into xb_native_conversion_admitted select fn from pg_temp.xb_st_admitted();
+-- Search has separate source-derived constructor, expression and callback proof.
+-- The delimiter listing and apply_rls have separate proofs below.
+\ir fixtures/agent_board_667_search_guard.sql
+select is((select string_agg(identity||': '||problem, ', ' order by identity,problem) from pg_temp.xb_ss_problems()),
+  null::text,'XB native search constructor and effect class require exact disposition')
+where to_regprocedure('storage.search(text,text,integer,integer,integer,text,text,text,text,text)') is not null;
+select * from skip('native search absent; no native search disposition credit',1)
+where to_regprocedure('storage.search(text,text,integer,integer,integer,text,text,text,text,text)') is null;
+insert into xb_native_conversion_admitted select fn from pg_temp.xb_ss_admitted();
+-- Delimiter listing is a distinct source/record/dispatch effect class.
+\ir fixtures/agent_board_667_delimiter_guard.sql
+select is((select string_agg(identity||': '||problem, ', ' order by identity,problem) from pg_temp.xb_sd_problems()),
+  null::text,'XB native delimiter constructor and effect class require exact disposition')
+where to_regprocedure('storage.list_objects_with_delimiter(text,text,text,integer,text,text,text,text,text,timestamp with time zone,text)') is not null;
+select * from skip('native delimiter absent; no native delimiter disposition credit',1)
+where to_regprocedure('storage.list_objects_with_delimiter(text,text,text,integer,text,text,text,text,text,timestamp with time zone,text)') is null;
+insert into xb_native_conversion_admitted select fn from pg_temp.xb_sd_admitted();
+-- apply_rls prepares a SELECT over a caller-selected row-security relation and
+-- executes it as each subscriber role. Its target, policy, helper-body and
+-- built-in closure is separate; same-named relations close search-path redirection.
+\ir fixtures/agent_board_667_apply_rls_guard.sql
+select is((select string_agg(identity||': '||problem, ', ' order by identity,problem) from pg_temp.xb_ar_problems()),
+  null::text,'XB native apply_rls target, policy and helper closure require exact disposition')
+where to_regprocedure('realtime.apply_rls(jsonb,integer)') is not null;
+select * from skip('native apply_rls absent; no native apply_rls disposition credit',1)
+where to_regprocedure('realtime.apply_rls(jsonb,integer)') is null;
+insert into xb_native_conversion_admitted select fn from pg_temp.xb_ar_admitted();
+
+select is((select string_agg(f.identity, ', ' order by f.identity) from xb_plpgsql f
+  where f.opaque and f.oid <> 'agent_board.mark_retention_metadata(text,timestamptz,uuid,text)'::regprocedure
+    and not exists(select 1 from xb_native_conversion_admitted a where a.fn=f.oid)),
+  null::text, 'XB other opaque PL/pgSQL identities require disposition');
+-- Failure evidence only. Keep each unresolved definition on one JSON-escaped
+-- diagnostic line so CI records its exact body and metadata without accepting it.
+select diag('         have: OPAQUE_DEFINITION ' || jsonb_build_object(
+  'identity',f.identity,'definition',pg_get_functiondef(f.oid),
+  'definition_md5',md5(pg_get_functiondef(f.oid)),
+  'owner',pg_get_userbyid(p.proowner),'acl',p.proacl,
+  'volatility',p.provolatile,'security_definer',p.prosecdef)::text)
+from xb_plpgsql f join pg_proc p on p.oid=f.oid
+where f.opaque and f.oid <> 'agent_board.mark_retention_metadata(text,timestamptz,uuid,text)'::regprocedure
+  and not exists(select 1 from xb_native_conversion_admitted a where a.fn=f.oid)
+order by f.identity;
+-- source-scan: raw-subject the literal validator values are data; the exact definition binding above prevents comments or an alternate body from satisfying this extraction
+select is((select array_agg(m[1] order by m[1]) from regexp_matches(
+  substring(pg_get_functiondef('agent_board.mark_retention_metadata(text,timestamptz,uuid,text)'::regprocedure)
+    from 'if p_table_name not in \((.*?)\) then'), '''([a-z_]+)''', 'g') m),
+  array['board_memberships','callback_delivery_attempts','callback_outbox_events','delivery_recipients',
+        'inbox_items','messages','presence','task_events']::text[], 'XB retention validator admits exactly eight named targets');
+select is((with direct as (select distinct conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass),
+  onehop as (select f.conrelid from pg_constraint f join direct d on d.conrelid=f.confrelid where f.contype='f'),
+  targets as (select c.oid,c.relname from pg_class c join pg_namespace n on n.oid=c.relnamespace
+    where n.nspname='agent_board' and c.relname=any(array['messages','task_events','presence','callback_outbox_events',
+      'callback_delivery_attempts','inbox_items','delivery_recipients','board_memberships']))
+  select string_agg(relname || ':' || case when oid in (select conrelid from direct) then 'direct'
+    when oid in (select conrelid from onehop) then 'onehop' else 'outside' end, ', ' order by relname) from targets),
+  'board_memberships:outside, callback_delivery_attempts:outside, callback_outbox_events:onehop, delivery_recipients:onehop, inbox_items:onehop, messages:direct, presence:direct, task_events:direct',
+  'XB retention targets are related to the actual history FK graph');
+
+-- Additional fail-closed entry-point checks. The source matcher below recognises
+-- agent_board-qualified or bare relation writes, so a discovered history relation
+-- in any other namespace is itself an unresolved named finding. SQL bodies are
+-- scanned conservatively against every catalog-derived writer name; a matching
+-- route is reported for behavioral disposition, never assumed safe. This does
+-- not yet resolve arbitrary SQL calls or prove every writer's lock behavior.
+create temp table xb_history_relations 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 from direct
+union select f.conrelid from pg_constraint f join direct d on d.conrelid=f.confrelid where f.contype='f';
+select is((select string_agg(r.relid::regclass::text, ', ' order by r.relid::regclass::text)
+  from xb_history_relations r join pg_class c on c.oid=r.relid join pg_namespace n on n.oid=c.relnamespace
+  where n.nspname<>'agent_board'), null::text, 'XB history relations outside the supported matcher schema name themselves');
+select is((select string_agg(format('%s.%I -> %s',t.tgrelid::regclass,t.tgname,t.tgfoid::regprocedure), ', '
+  order by t.tgrelid::regclass::text,t.tgname)
+  from pg_trigger t join xb_history_relations r on r.relid=t.tgrelid where not t.tgisinternal),
+  null::text, 'XB DML trigger entry points on history relations name themselves');
+select is((select string_agg(format('%s.%I',rw.ev_class::regclass,rw.rulename), ', ' order by rw.ev_class::regclass::text,rw.rulename)
+  from pg_rewrite rw join xb_history_relations r on r.relid=rw.ev_class where rw.ev_type<>'1'),
+  null::text, 'XB DML rule entry points on history relations name themselves');
+-- No non-extension application function in an unsupported language is silently
+-- omitted from the SQL/PL/pgSQL graph. It must be named and disposed first.
+select is((select string_agg(format('%s [%s]',p.oid::regprocedure,l.lanname), ', '
+    order by p.oid::regprocedure::text)
+  from pg_proc p join pg_namespace n on n.oid=p.pronamespace join pg_language l on l.oid=p.prolang
+  where p.prokind='f' and p.prorettype<>'trigger'::regtype and l.lanname not in ('sql','plpgsql')
+    and n.nspname not in ('pg_catalog','information_schema','agent_board_test') and n.nspname not like 'pg_%'
+    and not exists (select 1 from pg_depend d where d.classid='pg_proc'::regclass and d.objid=p.oid and d.deptype='e')),
+  null::text, 'XB unsupported application function languages name themselves');
+create temp table xb_routines on commit drop as
+select p.oid,n.nspname,p.proname,l.lanname,agent_board_test.stripped_body(p.oid) as body,
+  (has_function_privilege('authenticated',p.oid,'EXECUTE') or has_function_privilege('service_role',p.oid,'EXECUTE')
+   or has_function_privilege('anon',p.oid,'EXECUTE') or has_function_privilege('agent_board_delegate',p.oid,'EXECUTE')) as callable
+from pg_proc p join pg_namespace n on n.oid=p.pronamespace join pg_language l on l.oid=p.prolang
+where p.prokind='f' and p.prorettype<>'trigger'::regtype and l.lanname in ('sql','plpgsql')
+  and n.nspname not in ('pg_catalog','information_schema','agent_board_test') and n.nspname not like 'pg_%'
+  and not exists (select 1 from pg_depend d where d.classid='pg_proc'::regclass and d.objid=p.oid and d.deptype='e');
+-- Enumerate direct thread-FK INSERT sites from the live catalog and source,
+-- then compare them to independently reviewed exact signatures and relations.
+-- The mechanism checks below are structural prerequisites, coupled to the
+-- focused behavior/mutation tests and the call-edge assertions below.
+create temp table xb_direct_insert_actual on commit drop as
+select distinct f.oid, d.relid from xb_routines f cross join lateral (
+  select distinct fk.conrelid as relid,c.relname from pg_constraint fk join pg_class c on c.oid=fk.conrelid
+  where fk.contype='f' and fk.confrelid='agent_board.threads'::regclass) d
+where f.body ~ agent_board_test.stmt_re('insert into',d.relname);
+create temp table xb_direct_insert_reviewed(fn oid,relid oid,mechanism text,primary key(fn,relid)) on commit drop;
+insert into xb_direct_insert_reviewed values
+ ('agent_board.heartbeat(uuid,uuid,text,text,interval,jsonb)'::regprocedure,'agent_board.presence'::regclass,'locked_post'),
+ ('agent_board._insert_thread_message(uuid,uuid,text,text,uuid,jsonb)'::regprocedure,'agent_board.messages'::regclass,'message_sequence'),
+ ('agent_board.create_task(uuid,uuid,text,text,uuid,uuid,text,text,jsonb)'::regprocedure,'agent_board.tasks'::regclass,'locked_post'),
+ ('agent_board.create_task(uuid,uuid,text,text,uuid,uuid,text,text,jsonb)'::regprocedure,'agent_board.task_events'::regclass,'locked_post'),
+ ('agent_board.acquire_claim(uuid,text,text,timestamptz,uuid,uuid,jsonb)'::regprocedure,'agent_board.claims'::regclass,'locked_post'),
+ ('agent_board.mark_read(uuid,uuid,bigint)'::regprocedure,'agent_board.read_receipts'::regclass,'receipt'),
+ ('agent_board.add_artifact(uuid,text,text,text,uuid,uuid,uuid,uuid,jsonb)'::regprocedure,'agent_board.artifacts'::regclass,'locked_post'),
+ ('agent_board.raise_conflict(uuid,uuid,text,text,text,uuid,jsonb)'::regprocedure,'agent_board.conflicts'::regclass,'locked_post'),
+ ('agent_board.raise_escalation(uuid,uuid,text,text,text,uuid,uuid,jsonb)'::regprocedure,'agent_board.escalations'::regclass,'locked_post'),
+ ('agent_board._append_task_event(text,uuid,uuid,text,jsonb,text,uuid,timestamptz)'::regprocedure,'agent_board.task_events'::regclass,'task_parent');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+  order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_direct_insert_actual a join pg_proc p on p.oid=a.oid join pg_namespace pn on pn.oid=p.pronamespace
+  join pg_class c on c.oid=a.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists (select 1 from xb_direct_insert_reviewed r where r.fn=a.oid and r.relid=a.relid)),
+  null::text, 'XB unreviewed direct thread-history inserters name their full identities');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+  order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_direct_insert_reviewed r join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+  join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists (select 1 from xb_direct_insert_actual a where a.oid=r.fn and a.relid=r.relid)),
+  null::text, 'XB each reviewed direct inserter actually writes its stated relation');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I [%s]',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname,r.mechanism), ', '
+  order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_direct_insert_reviewed r join xb_routines f on f.oid=r.fn
+  join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+  join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not case r.mechanism
+    when 'locked_post' then f.body ~ agent_board_test.row_lock_re('threads')
+      and f.body ~ agent_board_test.call_re('_current_agent_can_post_to_thread',true)
+    when 'message_sequence' then f.body ~ agent_board_test.call_re('_next_thread_message_sequence',true)
+      and f.body ~ agent_board_test.call_re('_current_agent_can_post_to_thread',true)
+    when 'receipt' then f.body ~ agent_board_test.call_re('_agent_can_access_thread',true)
+    when 'task_parent' then f.body ~ agent_board_test.row_lock_re('threads')
+      and f.body ~ agent_board_test.call_re('_current_agent_can_mutate_task',true)
+      and exists(select 1 from xb_onehop_actual a where a.child='agent_board.task_events'::regclass
+        and a.parent='agent_board.tasks'::regclass and a.constraint_name='task_events_task_id_fkey' and a.convalidated)
+    else false end), null::text, 'XB each direct inserter has its positively checked mechanism prerequisites');
+-- For each conditional first-history writer, bind the thread row being
+-- locked to the same argument rechecked for posting before that relation's
+-- INSERT. Runtime race witnesses separately prove lock/wait behavior.
+create temp table xb_locked_writer_arguments(fn oid primary key,thread_arg text not null) on commit drop;
+insert into xb_locked_writer_arguments values
+ ('agent_board.heartbeat(uuid,uuid,text,text,interval,jsonb)'::regprocedure,'v_effective_thread'),
+ ('agent_board.create_task(uuid,uuid,text,text,uuid,uuid,text,text,jsonb)'::regprocedure,'p_thread_id'),
+ ('agent_board.acquire_claim(uuid,text,text,timestamptz,uuid,uuid,jsonb)'::regprocedure,'v_thread_id'),
+ ('agent_board.add_artifact(uuid,text,text,text,uuid,uuid,uuid,uuid,jsonb)'::regprocedure,'v_anchor_thread'),
+ ('agent_board.raise_conflict(uuid,uuid,text,text,text,uuid,jsonb)'::regprocedure,'p_thread_id'),
+ ('agent_board.raise_escalation(uuid,uuid,text,text,text,uuid,uuid,jsonb)'::regprocedure,'p_thread_id');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_direct_insert_reviewed r join xb_locked_writer_arguments a on a.fn=r.fn join xb_routines f on f.oid=r.fn
+    join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where r.mechanism='locked_post' and f.body !~ agent_board_test.re(agent_board_test.qname_frag('threads',true)
+    || agent_board_test.same_stmt() || agent_board_test.col_ref_frag('id') || '\s*=\s*' || agent_board_test.ident_re(a.thread_arg)
+    || agent_board_test.same_stmt() || '\m' || agent_board_test.ci_re('for no key update') || '[^;]*;[\s\S]*?'
+    || agent_board_test.call_frag('_current_agent_can_post_to_thread',true) || '\s*' || agent_board_test.ident_re(a.thread_arg)
+    || '\s*\)[\s\S]*?' || agent_board_test.stmt_frag('insert into',c.relname,true))),null::text,
+  'XB locked direct writers recheck the locked thread posting gate before insertion');
+-- Materialize source-derived writer pairs once before classifying their
+-- operations. The same catalog population drives both UPDATE classification
+-- and the recursive caller graph below.
+create temp table xb_writer_patterns on commit drop as
+select h.relid, agent_board_test.write_re(c.relname) as pattern
+  from xb_history_relations h join pg_class c on c.oid=h.relid;
+create temp table xb_history_writer_pairs on commit drop as
+select distinct f.oid,r.relid from xb_routines f cross join xb_writer_patterns r where f.body ~ r.pattern;
+-- An UPDATE-only path can operate on a pre-existing history row without a
+-- first-association lock only while its catalog-derived parent/thread FK
+-- columns cannot be reassigned and the routine cannot insert or delete that
+-- relation.  Enumerate the population independently from the dispositions.
+create temp table xb_update_only_actual on commit drop as
+select distinct f.oid,h.relid from xb_history_writer_pairs h join xb_routines f on f.oid=h.oid
+  join pg_class c on c.oid=h.relid
+where f.body ~ agent_board_test.stmt_re('update',c.relname)
+  and f.body !~ agent_board_test.stmt_re('insert into',c.relname);
+create temp table xb_update_only_reviewed(fn oid,relid oid,allowed_columns text[] not null,primary key(fn,relid)) on commit drop;
+insert into xb_update_only_reviewed values
+ ('agent_board._append_task_event(text,uuid,uuid,text,jsonb,text,uuid,timestamptz)'::regprocedure,'agent_board.tasks'::regclass,array['assigned_agent_id','completed_at','status','updated_at']::text[]),
+ ('agent_board.claim_callback_outbox_events(integer)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['locked_at','outbox_status','updated_at']::text[]),
+ ('agent_board.disable_callback_delivery_endpoint(uuid,uuid,text,text,jsonb)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['last_error_at','locked_at','metadata','outbox_status','updated_at']::text[]),
+ ('agent_board.record_callback_delivery_retry(uuid,uuid,integer,text,timestamptz,jsonb)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['available_at','last_error_at','locked_at','metadata','outbox_status','updated_at']::text[]),
+ ('agent_board.record_callback_delivery_success(uuid,uuid,integer,jsonb)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['delivered_at','last_error_at','locked_at','metadata','outbox_status','updated_at']::text[]),
+ ('agent_board.record_callback_delivery_terminal_failure(uuid,uuid,integer,text,jsonb)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['last_error_at','locked_at','metadata','outbox_status','updated_at']::text[]),
+ ('agent_board.update_inbox_item_state(uuid,uuid,text,jsonb)'::regprocedure,'agent_board.inbox_items'::regclass,array['action_state','metadata','updated_at']::text[]),
+ ('agent_board.reclaim_fleet_machine(uuid,uuid,uuid,text,uuid)'::regprocedure,'agent_board.claims'::regclass,array['metadata','released_at','status','updated_at']::text[]),
+ ('agent_board.release_claim(uuid)'::regprocedure,'agent_board.claims'::regclass,array['released_at','resource_key','status','updated_at']::text[]),
+ ('agent_board.renew_claim(uuid,timestamptz)'::regprocedure,'agent_board.claims'::regclass,array['lease_expires_at','resource_key','updated_at']::text[]),
+ ('agent_board.resolve_conflict(uuid,uuid,jsonb)'::regprocedure,'agent_board.conflicts'::regclass,array['details','resolved_at','resolved_by_agent_id','status','updated_at']::text[]),
+ ('agent_board.resolve_escalation(uuid,uuid,jsonb)'::regprocedure,'agent_board.escalations'::regclass,array['details','resolved_at','resolved_by_agent_id','status','updated_at']::text[]),
+ ('agent_board.set_board_claim_policy(uuid,text)'::regprocedure,'agent_board.claims'::regclass,array['lease_expires_at','updated_at']::text[]);
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_update_only_actual a join pg_proc p on p.oid=a.oid join pg_namespace pn on pn.oid=p.pronamespace
+  join pg_class c on c.oid=a.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists(select 1 from xb_update_only_reviewed r where r.fn=a.oid and r.relid=a.relid)), null::text,
+  'XB unreviewed existing-row history writers name their full identities');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_update_only_reviewed r join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+  join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists(select 1 from xb_update_only_actual a where a.oid=r.fn and a.relid=r.relid)), null::text,
+  'XB every reviewed existing-row path actually updates its claimed relation');
+select is((select string_agg(distinct format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname))
+  from xb_update_only_reviewed r join xb_routines f on f.oid=r.fn join pg_proc p on p.oid=r.fn
+  join pg_namespace pn on pn.oid=p.pronamespace join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where f.body ~ agent_board_test.stmt_re('delete from',c.relname)
+    or exists(select 1 from pg_constraint fk join lateral unnest(fk.conkey) k(attnum) on true
+      join pg_attribute a on a.attrelid=fk.conrelid and a.attnum=k.attnum
+      where fk.contype='f' and fk.conrelid=r.relid and (fk.confrelid='agent_board.threads'::regclass
+        or fk.confrelid in (select relid from xb_history_relations))
+        and f.body ~ agent_board_test.col_write_re(c.relname,a.attname))), null::text,
+  'XB existing-row paths neither delete history nor reassign a catalog-derived thread or parent anchor');
+-- Pin the actual assigned columns for each independently discovered update
+-- path, not just the absence of parent-column assignments. A new state effect
+-- therefore requires its own disposition.
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_update_only_reviewed r join xb_routines f on f.oid=r.fn join pg_proc p on p.oid=r.fn
+  join pg_namespace pn on pn.oid=p.pronamespace join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where r.allowed_columns is distinct from coalesce((select array_agg(a.attname::text order by a.attname::text)
+    from pg_attribute a where a.attrelid=r.relid and a.attnum>0 and not a.attisdropped
+      and f.body ~ agent_board_test.col_write_re(c.relname,a.attname)),array[]::text[])),null::text,
+  'XB each existing-row writer assigns exactly its reviewed catalog columns');
+-- ON CONFLICT DO UPDATE can mutate an existing row even though the routine
+-- is also an inserter. Enumerate those branches separately and pin the SET
+-- columns; behavioral retry controls prove the two delivery upserts preserve
+-- their original source anchors, while heartbeat remains a locked writer.
+create temp table xb_upsert_actual on commit drop as
+select w.oid,w.relid,m[1] as update_fragment from xb_history_writer_pairs w
+  join xb_routines f on f.oid=w.oid join pg_class c on c.oid=w.relid
+  cross join lateral regexp_matches(f.body,agent_board_test.re(agent_board_test.ci_re('on conflict')
+    || agent_board_test.same_stmt() || agent_board_test.ci_re('do update') || '\s+'
+    || agent_board_test.ci_re('set') || '([^;]*)'),'g') m
+where f.body ~ agent_board_test.stmt_re('insert into',c.relname);
+create temp table xb_upsert_reviewed(fn oid,relid oid,allowed_columns text[] not null,primary key(fn,relid)) on commit drop;
+insert into xb_upsert_reviewed values
+ ('agent_board.heartbeat(uuid,uuid,text,text,interval,jsonb)'::regprocedure,'agent_board.presence'::regclass,
+  array['activity_summary','availability','expires_at','last_heartbeat_at','metadata','thread_id','updated_at']),
+ ('agent_board.mark_read(uuid,uuid,bigint)'::regprocedure,'agent_board.read_receipts'::regclass,
+  array['last_read_at','last_read_message_sequence']),
+ ('agent_board._upsert_delivery_recipient(text,uuid,text,uuid,uuid,uuid,uuid,uuid,jsonb)'::regprocedure,'agent_board.delivery_recipients'::regclass,
+  array['metadata']),
+ ('agent_board._upsert_inbox_item(uuid,uuid,uuid,text,text,uuid,uuid,uuid,text,text,text,boolean,boolean,jsonb,jsonb)'::regprocedure,'agent_board.inbox_items'::regclass,
+  array['board_id','fetch_descriptor','metadata','preview','priority','subject','updated_at','visible_in_board_feed','visible_in_inbox']);
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_upsert_actual a join pg_proc p on p.oid=a.oid join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=a.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists(select 1 from xb_upsert_reviewed r where r.fn=a.oid and r.relid=a.relid)),null::text,
+  'XB unreviewed history upsert branches name their full identities');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_upsert_reviewed r join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where (select count(*) from xb_upsert_actual a where a.oid=r.fn and a.relid=r.relid)<>1),null::text,
+  'XB each reviewed history upsert has exactly one parsed update branch');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_upsert_reviewed r join xb_upsert_actual u on u.oid=r.fn and u.relid=r.relid
+    join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where r.allowed_columns is distinct from coalesce((select array_agg(a.attname::text order by a.attname::text)
+    from pg_attribute a where a.attrelid=r.relid and a.attnum>0 and not a.attisdropped
+      and (regexp_match(agent_board_test.stripped_body(r.fn),agent_board_test.re(agent_board_test.ci_re('on conflict')
+        || agent_board_test.same_stmt() || agent_board_test.ci_re('do update') || '\s+'
+        || agent_board_test.ci_re('set') || '([^;]*)')))[1]
+        ~ agent_board_test.re(agent_board_test.col_frag(a.attname) || '\s*=')),array[]::text[])),null::text,
+  'XB each history upsert assigns exactly its reviewed catalog columns');
+-- A routine can contain a separate UPDATE as well as an INSERT into the
+-- same history relation. Such a mixed writer is neither an update-only
+-- exemption nor necessarily an ON CONFLICT branch, so enumerate it explicitly.
+create temp table xb_mixed_writers on commit drop as
+select w.oid,w.relid from xb_history_writer_pairs w join xb_routines f on f.oid=w.oid join pg_class c on c.oid=w.relid
+where f.body ~ agent_board_test.stmt_re('insert into',c.relname) and f.body ~ agent_board_test.stmt_re('update',c.relname);
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+  order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_mixed_writers w join pg_proc p on p.oid=w.oid join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=w.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not (w.oid='agent_board.acquire_claim(uuid,text,text,timestamptz,uuid,uuid,jsonb)'::regprocedure
+    and w.relid='agent_board.claims'::regclass)),null::text,
+  'XB unreviewed mixed insert and update writers name their full identities');
+select ok(exists(select 1 from xb_mixed_writers where oid='agent_board.acquire_claim(uuid,text,text,timestamptz,uuid,uuid,jsonb)'::regprocedure
+  and relid='agent_board.claims'::regclass), 'XB reviewed acquire-claim mixed writer actually exists');
+select is((select array_agg(a.attname::text order by a.attname::text) from pg_attribute a
+  where a.attrelid='agent_board.claims'::regclass and a.attnum>0 and not a.attisdropped
+    and agent_board_test.stripped_body('agent_board.acquire_claim(uuid,text,text,timestamptz,uuid,uuid,jsonb)'::regprocedure)
+      ~ agent_board_test.re(agent_board_test.col_assign_frag('claims',a.attname,true))),
+  array['status','updated_at']::text[], 'XB acquire-claim existing-row update assigns only status and timestamp');
+-- Classify INSERTs into relations one enforced edge beyond a direct
+-- thread-FK parent. The anchor-column assertion is a structural premise;
+-- behavior of the common parent predicates is witnessed separately.
+create temp table xb_onehop_insert_actual on commit drop as
+select distinct w.oid,w.relid from xb_history_writer_pairs w join xb_routines f on f.oid=w.oid
+  join pg_class c on c.oid=w.relid
+where w.relid in (select child from xb_onehop_actual)
+  and w.relid not in (select conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass)
+  and f.body ~ agent_board_test.stmt_re('insert into',c.relname);
+create temp table xb_onehop_insert_reviewed(fn oid,relid oid,anchors text[],primary key(fn,relid)) on commit drop;
+insert into xb_onehop_insert_reviewed values
+ ('agent_board._queue_board_post_callbacks(uuid,uuid,text,text,text,jsonb)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['source_message_id']),
+ ('agent_board._queue_inbox_callbacks(uuid,text)'::regprocedure,'agent_board.callback_outbox_events'::regclass,array['source_message_id','source_task_id']),
+ ('agent_board._record_signed_write_evidence(text,uuid,text,jsonb,jsonb)'::regprocedure,'agent_board.signature_evidence'::regclass,array['source_message_id','source_task_event_id']),
+ ('agent_board._upsert_delivery_recipient(text,uuid,text,uuid,uuid,uuid,uuid,uuid,jsonb)'::regprocedure,'agent_board.delivery_recipients'::regclass,array['source_message_id','source_task_id']),
+ ('agent_board._upsert_inbox_item(uuid,uuid,uuid,text,text,uuid,uuid,uuid,text,text,text,boolean,boolean,jsonb,jsonb)'::regprocedure,'agent_board.inbox_items'::regclass,array['source_message_id','source_task_id']),
+ ('agent_board.delegate_task(uuid,uuid,text,text,uuid,text,text,jsonb)'::regprocedure,'agent_board.delegations'::regclass,array['child_task_id','parent_task_id']),
+ ('agent_board.evaluate_signed_write_fleet_policy(text,jsonb,jsonb)'::regprocedure,'agent_board.signature_evidence'::regclass,array[]::text[]);
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_onehop_insert_actual a join pg_proc p on p.oid=a.oid join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=a.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists(select 1 from xb_onehop_insert_reviewed r where r.fn=a.oid and r.relid=a.relid)),null::text,
+  'XB unreviewed one-hop inserters name their full identities');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_onehop_insert_reviewed r join pg_proc p on p.oid=r.fn join pg_namespace pn on pn.oid=p.pronamespace
+    join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where not exists(select 1 from xb_onehop_insert_actual a where a.oid=r.fn and a.relid=r.relid)),null::text,
+  'XB each reviewed one-hop inserter actually writes its claimed relation');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_onehop_insert_reviewed r join xb_routines f on f.oid=r.fn join pg_proc p on p.oid=r.fn
+    join pg_namespace pn on pn.oid=p.pronamespace join pg_class c on c.oid=r.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where r.anchors is distinct from coalesce((select array_agg(distinct a.attname::text order by a.attname::text)
+    from pg_constraint fk join lateral unnest(fk.conkey) k(attnum) on true
+      join pg_attribute a on a.attrelid=fk.conrelid and a.attnum=k.attnum
+    where fk.contype='f' and fk.convalidated and fk.conrelid=r.relid
+      and fk.confrelid in (select distinct conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass)
+      and f.body ~ agent_board_test.col_write_re(c.relname,a.attname)),array[]::text[])),null::text,
+  'XB each one-hop inserter writes exactly its reviewed parent-anchor columns');
+-- A writer detected by the shared catalog matcher but not classified as an
+-- INSERT or UPDATE is not silently omitted (for example DELETE, MERGE, COPY,
+-- TRUNCATE or a future syntax matched by write_re).
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_history_writer_pairs w join xb_routines f on f.oid=w.oid join pg_proc p on p.oid=w.oid
+    join pg_namespace pn on pn.oid=p.pronamespace join pg_class c on c.oid=w.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where f.body !~ agent_board_test.stmt_re('insert into',c.relname)
+    and f.body !~ agent_board_test.stmt_re('update',c.relname)),null::text,
+  'XB unsupported history write forms name their full identities');
+-- A routine may combine a reviewed INSERT or UPDATE with a separate DELETE;
+-- check deletion independently so the supported statement cannot mask it.
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_history_writer_pairs w join xb_routines f on f.oid=w.oid join pg_proc p on p.oid=w.oid
+    join pg_namespace pn on pn.oid=p.pronamespace join pg_class c on c.oid=w.relid join pg_namespace rn on rn.oid=c.relnamespace
+  where f.body ~ agent_board_test.stmt_re('delete from',c.relname)),null::text,
+  'XB history writers with a deletion statement name their full identities');
+-- Supported INSERT/UPDATE text cannot hide a second unsupported operation on
+-- the same relation. Match the other write forms independently by target.
+create temp table xb_other_write_patterns on commit drop as
+select h.relid,agent_board_test.re('(?:' || agent_board_test.stmt_frag('merge into',c.relname,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(c.relname,true)
+  || '|' || agent_board_test.stmt_frag('copy',c.relname,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(c.relname,true) || ')') as pattern
+  from xb_history_relations h join pg_class c on c.oid=h.relid;
+select is((select string_agg(format('%I.%I(%s) -> %I.%I',pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname), ', '
+    order by pn.nspname,p.proname,oidvectortypes(p.proargtypes),rn.nspname,c.relname)
+  from xb_history_writer_pairs w join xb_routines f on f.oid=w.oid join pg_proc p on p.oid=w.oid
+    join pg_namespace pn on pn.oid=p.pronamespace join pg_class c on c.oid=w.relid join pg_namespace rn on rn.oid=c.relnamespace
+    join xb_other_write_patterns pat on pat.relid=w.relid where f.body ~ pat.pattern),null::text,
+  'XB unsupported additional history write forms name their full identities');
+create temp table xb_source_writers on commit drop as
+select distinct f.oid,f.nspname,f.proname from xb_routines f join xb_history_writer_pairs w on w.oid=f.oid;
+-- SQL string bodies have no reliable pg_depend call edges. Conservatively
+-- match each routine name and include every overload when arguments are opaque.
+-- This catches transitive SQL-to-SQL paths; it does not claim semantic resolution.
+create temp table xb_sql_call_patterns on commit drop as
+select oid, agent_board_test.call_re(nspname||'.'||proname,true) as pattern from xb_routines;
+create temp table xb_sql_call_edges on commit drop as
+select s.oid as source,t.oid as target from xb_routines s cross join xb_sql_call_patterns t
+where s.lanname='sql' and s.oid<>t.oid and s.body ~ t.pattern;
+create temp table xb_all_call_edges on commit drop as
+select source,target from xb_sql_call_edges
+union select source,dep_oid as target from xb_edges where dep_oid is not null;
+create temp table xb_reaches_writer on commit drop as
+with recursive reaches_writer(oid) as (
+  select oid from xb_source_writers
+  union select e.source from xb_all_call_edges e join reaches_writer r on r.oid=e.target
+) select oid from reaches_writer;
+select is((select string_agg(s.oid::regprocedure::text, ', ' order by s.oid::regprocedure::text)
+    from xb_routines s join xb_reaches_writer r on r.oid=s.oid where s.lanname='sql'),
+  null::text, 'XB SQL routes through SQL or PL/pgSQL to history writers name themselves');
+-- Derive every direct sink caller independently of the reviewed disposition.
+-- The stripped call has simple positional arguments through position eight;
+-- if a new spelling cannot be parsed it is a named failure rather than a
+-- guessed NULL-only route. String literals are intentionally stripped.
+create temp table xb_sink_calls on commit drop as
+select f.oid, regexp_split_to_array(m[1],',') as arguments,
+  regexp_replace((regexp_split_to_array(m[1],','))[7], '\s+', '', 'g') as board_arg
+from xb_routines f cross join lateral regexp_matches(f.body,
+  agent_board_test.call_re('_upsert_delivery_recipient',true) || '((?:[^,;]*,){7}[^,;]*)','g') m;
+select is((select string_agg(f.oid::regprocedure::text, ', ' order by f.oid::regprocedure::text)
+  from xb_routines f where f.body ~ agent_board_test.call_re('_upsert_delivery_recipient',true)
+    and (select count(*) from regexp_matches(f.body, agent_board_test.call_re('_upsert_delivery_recipient',true),'g'))
+        <> (select count(*) from xb_sink_calls c where c.oid=f.oid)), null::text,
+  'XB unparseable delivery-sink calls name their full routine identity');
+-- Any complex positional expression can conceal nested commas and change
+-- argument numbering; refuse that call by identity until reviewed.
+select is((select string_agg(distinct c.oid::regprocedure::text, ', ' order by c.oid::regprocedure::text)
+  from xb_sink_calls c cross join lateral unnest(c.arguments) a(arg)
+  where translate(a.arg,E' \t\r\n','') !~ '^([a-z_][a-z0-9_.]*)?$'), null::text,
+  'XB complex delivery-sink arguments require disposition by caller identity');
+select is((select string_agg(format('%I.%I(%s)[%s]',n.nspname,p.proname,replace(oidvectortypes(p.proargtypes), ', ', ','),c.board_arg), ', '
+    order by n.nspname::text collate "C",p.proname::text collate "C",oidvectortypes(p.proargtypes),c.board_arg)
+  from xb_sink_calls c join pg_proc p on p.oid=c.oid join pg_namespace n on n.oid=p.pronamespace),
+  'agent_board._deliver_board_message(uuid,text,text,text)[p_board_id], agent_board.create_tasking_delivery(uuid,uuid,text,text,uuid[],uuid,text,text,text,jsonb)[null], agent_board.create_tasking_delivery(uuid,uuid,text,text,uuid[],uuid,text,text,text,jsonb)[p_board_id], agent_board.send_direct_message(uuid,uuid,uuid,text,text,text,text,text,jsonb)[null], agent_board.send_multicast_message(uuid,uuid,uuid[],text,text,text,text,text,jsonb)[null]',
+  'XB every delivery-sink call has an explicitly classified board argument');
+select is((select string_agg(oid::regprocedure::text, ', ' order by oid::regprocedure::text)
+  from (select distinct c.oid from xb_sink_calls c where c.board_arg<>'null') c
+  where not exists (select 1 from xb_routines f where f.oid=c.oid
+    and f.body ~ agent_board_test.call_re('_associate_empty_thread',true))), null::text,
+  'XB each non-NULL board sink caller invokes the early association boundary');
+select ok((select count(*)=2 and bool_and(board_arg='null') from xb_sink_calls c
+  join pg_proc p on p.oid=c.oid where p.proname in ('send_direct_message','send_multicast_message')),
+  'XB direct and multicast sink paths positively bind a NULL board');
+-- Catalog/OID call closure includes descriptor and signed wrappers, not only
+-- the routines that directly name the sink. Unknown intermediaries are named.
+create temp table xb_sink_caller_closure on commit drop as
+with recursive t(oid) as (select distinct oid from xb_sink_calls
+  union select e.source from xb_all_call_edges e join t on t.oid=e.target)
+select oid from t;
+create temp table xb_sink_wrapper_reviewed(fn oid not null,target oid not null,primary key(fn,target)) on commit drop;
+insert into xb_sink_wrapper_reviewed values
+ ('agent_board.post_board_message(uuid,uuid,uuid,text,text,text,text,text,jsonb)'::regprocedure,'agent_board._deliver_board_message(uuid,text,text,text)'::regprocedure),
+ ('agent_board.post_message(uuid,uuid,text,text,uuid,jsonb)'::regprocedure,'agent_board._deliver_board_message(uuid,text,text,text)'::regprocedure),
+ ('agent_board.post_board_message(uuid,uuid,text,text,text,text,text,text,text,jsonb)'::regprocedure,'agent_board.post_board_message(uuid,uuid,uuid,text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.create_tasking_delivery(uuid,uuid,text,text,jsonb,text,text,text,text,text,jsonb)'::regprocedure,'agent_board.create_tasking_delivery(uuid,uuid,text,text,uuid[],uuid,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.send_direct_message(uuid,uuid,jsonb,text,text,text,text,text,text,jsonb)'::regprocedure,'agent_board.send_direct_message(uuid,uuid,uuid,text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.send_multicast_message(uuid,uuid,jsonb,text,text,text,text,text,text,jsonb)'::regprocedure,'agent_board.send_multicast_message(uuid,uuid,uuid[],text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.signed_post_board_message(jsonb,jsonb)'::regprocedure,'agent_board.post_board_message(uuid,uuid,uuid,text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.signed_create_tasking_delivery(jsonb,jsonb)'::regprocedure,'agent_board.create_tasking_delivery(uuid,uuid,text,text,uuid[],uuid,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.signed_send_direct_message(jsonb,jsonb)'::regprocedure,'agent_board.send_direct_message(uuid,uuid,uuid,text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.signed_send_multicast_message(jsonb,jsonb)'::regprocedure,'agent_board.send_multicast_message(uuid,uuid,uuid[],text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.signed_create_tasking_delivery(jsonb,jsonb)'::regprocedure,'agent_board.create_tasking_delivery(uuid,uuid,text,text,jsonb,text,text,text,text,text,jsonb)'::regprocedure),
+ ('agent_board.signed_send_multicast_message(jsonb,jsonb)'::regprocedure,'agent_board.send_multicast_message(uuid,uuid,jsonb,text,text,text,text,text,text,jsonb)'::regprocedure);
+select is((select string_agg(format('%I.%I(%s)',n.nspname,p.proname,oidvectortypes(p.proargtypes)), ', '
+  order by n.nspname,p.proname,oidvectortypes(p.proargtypes))
+  from xb_sink_caller_closure t join pg_proc p on p.oid=t.oid join pg_namespace n on n.oid=p.pronamespace
+  where not exists(select 1 from xb_sink_calls c where c.oid=t.oid)
+    and not exists(select 1 from xb_sink_wrapper_reviewed r where r.fn=t.oid)), null::text,
+  'XB unreviewed transitive delivery callers name their full identities');
+select is((select string_agg(format('%I.%I(%s)',n.nspname,p.proname,oidvectortypes(p.proargtypes)), ', '
+  order by n.nspname,p.proname,oidvectortypes(p.proargtypes))
+  from xb_sink_wrapper_reviewed r join pg_proc p on p.oid=r.fn join pg_namespace n on n.oid=p.pronamespace
+  where not exists(select 1 from xb_all_call_edges e where e.source=r.fn and e.target=r.target)
+     or not exists(select 1 from xb_sink_caller_closure t where t.oid=r.fn)), null::text,
+  'XB each reviewed delivery wrapper reaches its exact sink-caller overload');
+select is((select string_agg(format('%I.%I(%s) -> %I.%I(%s)',sn.nspname,sp.proname,oidvectortypes(sp.proargtypes),
+    tn.nspname,tp.proname,oidvectortypes(tp.proargtypes)), ', ' order by sn.nspname,sp.proname,oidvectortypes(sp.proargtypes),tn.nspname,tp.proname)
+  from xb_all_call_edges e
+  join pg_proc sp on sp.oid=e.source join pg_namespace sn on sn.oid=sp.pronamespace
+  join pg_proc tp on tp.oid=e.target join pg_namespace tn on tn.oid=tp.pronamespace
+  where e.source in (select fn from xb_sink_wrapper_reviewed) and e.target in (select oid from xb_sink_caller_closure)
+    and not exists(select 1 from xb_sink_wrapper_reviewed r where r.fn=e.source and r.target=e.target)), null::text,
+  'XB delivery wrappers have no other undispositioned delivery-call edge');
+-- Delegation does not call the sink: it creates its child against the parent
+-- task's stored thread. The writer test proves the resulting parent/child state.
+select ok((select f.body ~ agent_board_test.re(agent_board_test.call_frag('create_task',true)
+  || '\s*' || agent_board_test.ident_re('v_parent') || '\s*\.\s*' || agent_board_test.ident_re('thread_id') || '\s*,')
+  and exists(select 1 from xb_edges e where e.source=f.oid and e.dep_oid='agent_board.create_task(uuid,uuid,text,text,uuid,uuid,text,text,jsonb)'::regprocedure)
+  and not exists(select 1 from xb_sink_caller_closure t where t.oid=f.oid)
+  from xb_routines f where f.oid='agent_board.delegate_task(uuid,uuid,text,text,uuid,text,text,jsonb)'::regprocedure),
+  'XB delegation binds create_task to its parent thread and is not a sink caller');
+-- Trigger callers can live on a relation outside the history FK graph. Parse each
+-- non-extension trigger with its actual row type; unresolved or dynamic bodies,
+-- any history relation dependency, and calls reaching a writer are reported.
+create function pg_temp.xb_trigger_dependencies(p_fn oid,p_rel oid)
+returns table(dep_oid oid,dep_type text,problem text) language plpgsql as $body$
+begin
+  return query select d.oid::oid,d.type::text,null::text
+    from extensions.plpgsql_show_dependency_tb(p_fn::regprocedure,p_rel::regclass) d;
+exception when others then return query select null::oid,null::text,sqlstate || ':' || sqlerrm;
+end $body$;
+create temp table xb_application_triggers on commit drop as
+select t.oid,t.tgrelid,t.tgname,t.tgfoid,
+  agent_board_test.stripped_body(t.tgfoid) ~ agent_board_test.re('\m' || agent_board_test.ci_re('execute') || '\M') as opaque
+from pg_trigger t join pg_class c on c.oid=t.tgrelid join pg_namespace n on n.oid=c.relnamespace
+where not t.tgisinternal and n.nspname not in ('pg_catalog','information_schema','agent_board_test')
+  and n.nspname not like 'pg_%'
+  and not exists (select 1 from pg_depend d where d.classid='pg_trigger'::regclass and d.objid=t.oid and d.deptype='e');
+create temp table xb_trigger_deps on commit drop as
+select t.oid,t.tgrelid,t.tgname,t.tgfoid,t.opaque,d.dep_oid,d.dep_type,d.problem
+from xb_application_triggers t left join lateral pg_temp.xb_trigger_dependencies(t.tgfoid,t.tgrelid) d on true;
+select ok((select count(*)>0 from xb_application_triggers), 'XB application trigger parser population is nonempty');
+select is((select string_agg(distinct format('%s.%I -> %s [%s]',t.tgrelid::regclass,t.tgname,t.tgfoid::regprocedure,
+    case when t.problem is not null then 'PARSER-ERROR:'||t.problem when t.opaque then 'DYNAMIC'
+         when t.dep_type='RELATION' then 'HISTORY-RELATION:'||t.dep_oid::regclass::text
+         else 'WRITER-CALL:'||t.dep_oid::regprocedure::text end), ', '
+    order by format('%s.%I -> %s [%s]',t.tgrelid::regclass,t.tgname,t.tgfoid::regprocedure,
+    case when t.problem is not null then 'PARSER-ERROR:'||t.problem when t.opaque then 'DYNAMIC'
+         when t.dep_type='RELATION' then 'HISTORY-RELATION:'||t.dep_oid::regclass::text
+         else 'WRITER-CALL:'||t.dep_oid::regprocedure::text end))
+  from xb_trigger_deps t where t.problem is not null or t.opaque
+    or (t.dep_type='RELATION' and t.dep_oid in (select relid from xb_history_relations))
+    or (t.dep_type='FUNCTION' and t.dep_oid in (select oid from xb_reaches_writer))),
+  null::text, 'XB trigger paths to history or writers and unresolved triggers name themselves');
+
+-- DML rules can originate on a relation outside the FK class. Their stored
+-- actions may write another relation or call a writer; fail closed on every
+-- non-extension application DML rule until its effect is positively reviewed.
+select is((select string_agg(format('%s.%I',rw.ev_class::regclass,rw.rulename), ', '
+                order by rw.ev_class::regclass::text,rw.rulename)
+  from pg_rewrite rw join pg_class c on c.oid=rw.ev_class join pg_namespace n on n.oid=c.relnamespace
+  where rw.ev_type<>'1' and n.nspname not in ('pg_catalog','information_schema','agent_board_test')
+    and n.nspname not like 'pg_%'
+    and not exists (select 1 from pg_depend d where d.classid='pg_class'::regclass and d.objid=c.oid and d.deptype='e')),
+  null::text, 'XB application DML rules name themselves for disposition');
+
+-- Canary relations and overloads are deliberately created in another schema.
+-- These assertions pin discovery primitives, not a proof that every writer has a
+-- safe lock or that arbitrary dynamic SQL can be resolved.
+create schema xb_class_probe;
+create table xb_class_probe.onehop (id uuid primary key, task_id uuid references agent_board.tasks(id));
+create function xb_class_probe.writer(p_id uuid, p_task uuid) returns void language plpgsql as $body$
+begin insert into xb_class_probe.onehop(id,task_id) values (p_id,p_task); end $body$;
+create function xb_class_probe.writer(p_id uuid, p_task uuid, p_extra text) returns void language plpgsql as $body$
+begin insert into xb_class_probe.onehop(id,task_id) values (p_id,p_task); end $body$;
+create function xb_class_probe.relay(p_id uuid, p_task uuid) returns void language plpgsql as $body$
+begin perform xb_class_probe.writer(p_id,p_task); end $body$;
+create function xb_class_probe.opaque(p_id uuid, p_task uuid) returns void language plpgsql as $body$
+begin execute 'select xb_class_probe.writer($1,$2)' using p_id,p_task; end $body$;
+select is(
+  (with direct as (select distinct conrelid from pg_constraint where contype='f' and confrelid='agent_board.threads'::regclass)
+   select string_agg(format('%s.%I', f.conrelid::regclass, f.conname), ', ' order by f.conrelid::regclass::text, f.conname)
+     from pg_constraint f join direct d on d.conrelid=f.confrelid
+    where f.contype='f' and f.conrelid='xb_class_probe.onehop'::regclass),
+  'xb_class_probe.onehop.onehop_task_id_fkey', 'XB valid injected one-hop FK is discovered and named');
+select is(
+  (select count(*) from pg_proc p join pg_namespace n on n.oid=p.pronamespace
+    where n.nspname='xb_class_probe' and p.proname='writer'
+      and exists (select 1 from extensions.plpgsql_show_dependency_tb(p.oid::regprocedure,0::oid) d
+                   where d.type='RELATION' and d.oid='xb_class_probe.onehop'::regclass)),
+  2::bigint, 'XB injected cross-schema writer overloads are independently discovered');
+select ok(
+  exists (select 1 from extensions.plpgsql_show_dependency_tb('xb_class_probe.relay(uuid,uuid)'::regprocedure,0::oid) d
+    where d.type='FUNCTION' and d.oid='xb_class_probe.writer(uuid,uuid)'::regprocedure),
+  'XB parser resolves the injected cross-schema relay to its exact writer overload');
+select is(
+  (select string_agg(p.oid::regprocedure::text, ', ' order by p.oid::regprocedure::text)
+     from pg_proc p join pg_namespace n on n.oid=p.pronamespace
+    where n.nspname='xb_class_probe'
+      and agent_board_test.stripped_body(p.oid) ~ agent_board_test.re('\m' || agent_board_test.ci_re('execute') || '\M')),
+  'xb_class_probe.opaque(uuid,uuid)', 'XB opaque injected SQL path is flagged by full identity');
+select * from finish();
+rollback;