@consiliency/agent-board-schema 1.2.0 → 1.4.0

package/tests/agent_board_send_role_gate.test.sql

@@ -0,0 +1,177 @@
+-- MBSENDAUTHZ SL-1 pgTAP: _current_agent_can_send_to_board, the board-role send
+-- gate on the board-target sends, boardless-send invariance, and service_role
+-- bypass telemetry with the frozen origin discriminator.
+--
+-- Runs as the postgres db role; request.jwt.claim.role toggles _is_service_role()
+-- (''/service_role => true, 'authenticated' => false), request.jwt.claim.sub picks
+-- the acting agent.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(16);
+
+create temp table _srg_fixture (
+  board uuid,
+  member_agent uuid,
+  observer_agent uuid,
+  nonmember_agent uuid,
+  recipient_agent uuid,
+  member_user uuid,
+  observer_user uuid,
+  nonmember_user uuid,
+  thread_member uuid,
+  thread_observer uuid,
+  thread_dm uuid
+) on commit drop;
+
+do $$
+declare
+  v_suffix text := replace(substr(gen_random_uuid()::text, 1, 8), '-', '');
+  v_member_user uuid;
+  v_observer_user uuid;
+  v_nonmember_user uuid;
+  v_member uuid := gen_random_uuid();
+  v_observer uuid := gen_random_uuid();
+  v_nonmember uuid := gen_random_uuid();
+  v_recipient uuid := gen_random_uuid();
+  v_board uuid;
+  v_thread_member uuid := gen_random_uuid();
+  v_thread_observer uuid := gen_random_uuid();
+  v_thread_dm uuid := gen_random_uuid();
+begin
+  v_member_user := public.ensure_github_user('srg-member-' || v_suffix, 'srg-member-' || v_suffix || '@example.test', 'srg-member-' || v_suffix, 'SRG Member');
+  v_observer_user := public.ensure_github_user('srg-observer-' || v_suffix, 'srg-observer-' || v_suffix || '@example.test', 'srg-observer-' || v_suffix, 'SRG Observer');
+  v_nonmember_user := public.ensure_github_user('srg-nonmember-' || v_suffix, 'srg-nonmember-' || v_suffix || '@example.test', 'srg-nonmember-' || v_suffix, 'SRG Nonmember');
+
+  insert into agent_board.agents(id, agent_type, handle, display_name, status, auth_user_id, owner_user_id)
+  values
+    (v_member, 'agent', 'srg-member-' || v_suffix, 'SRG Member', 'active', v_member_user, v_member_user),
+    (v_observer, 'agent', 'srg-observer-' || v_suffix, 'SRG Observer', 'active', v_observer_user, v_observer_user),
+    (v_nonmember, 'agent', 'srg-nonmember-' || v_suffix, 'SRG Nonmember', 'active', v_nonmember_user, v_nonmember_user),
+    (v_recipient, 'agent', 'srg-recipient-' || v_suffix, 'SRG Recipient', 'active', null, null);
+
+  select board_id into v_board
+    from agent_board.create_board(v_member, 'srg-board-' || v_suffix, 'SRG Board', 'send role gate test', '{}'::jsonb, 'private');
+
+  -- member: role member; observer: role observer. Both active.
+  insert into agent_board.board_memberships(board_id, agent_id, membership_state, created_by_agent_id, role)
+  values
+    (v_board, v_member, 'joined', v_member, 'member'),
+    (v_board, v_observer, 'joined', v_member, 'observer');
+
+  -- Threads each sending actor can access (inherit mode; creator has access).
+  insert into agent_board.threads(id, thread_type, created_by_agent_id, subject)
+  values
+    (v_thread_member, 'coordination', v_member, 'SRG member thread'),
+    (v_thread_observer, 'coordination', v_observer, 'SRG observer thread'),
+    (v_thread_dm, 'coordination', v_member, 'SRG dm thread');
+
+  insert into _srg_fixture values
+    (v_board, v_member, v_observer, v_nonmember, v_recipient,
+     v_member_user, v_observer_user, v_nonmember_user,
+     v_thread_member, v_thread_observer, v_thread_dm);
+end
+$$;
+
+-- 1. _current_agent_can_send_to_board -----------------------------------------
+select has_function('agent_board', '_current_agent_can_send_to_board', array['uuid'], '_current_agent_can_send_to_board exists');
+
+select set_config('request.jwt.claim.role', 'service_role', true);
+select is(
+  agent_board._current_agent_can_send_to_board((select board from _srg_fixture)),
+  true, 'service_role may always send to board');
+
+select set_config('request.jwt.claim.role', 'authenticated', true);
+select set_config('request.jwt.claim.sub', (select member_user from _srg_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_send_to_board((select board from _srg_fixture)),
+  true, 'active member (role member) may send to board');
+
+select set_config('request.jwt.claim.sub', (select observer_user from _srg_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_send_to_board((select board from _srg_fixture)),
+  false, 'observer board member may not send to board');
+
+select set_config('request.jwt.claim.sub', (select nonmember_user from _srg_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_send_to_board((select board from _srg_fixture)),
+  false, 'non-member may not send to board');
+
+-- 2. Board-target sends enforce the role gate on the authenticated path -------
+select set_config('request.jwt.claim.sub', (select observer_user from _srg_fixture)::text, true);
+select throws_ok(
+  (select format($q$select agent_board.post_board_message(%L::uuid, %L::uuid, %L::uuid, 'sub', 'body')$q$,
+     thread_observer, observer_agent, board) from _srg_fixture),
+  '42501', 'board send requires a non-observer board role',
+  'post_board_message rejects an observer board member');
+
+select set_config('request.jwt.claim.sub', (select member_user from _srg_fixture)::text, true);
+select lives_ok(
+  (select format($q$select agent_board.post_board_message(%L::uuid, %L::uuid, %L::uuid, 'sub', 'body')$q$,
+     thread_member, member_agent, board) from _srg_fixture),
+  'post_board_message admits a member board member');
+
+select set_config('request.jwt.claim.sub', (select observer_user from _srg_fixture)::text, true);
+select throws_ok(
+  (select format($q$select agent_board.create_tasking_delivery(%L::uuid, %L::uuid, 'title', null, null, %L::uuid)$q$,
+     thread_observer, observer_agent, board) from _srg_fixture),
+  '42501', 'board send requires a non-observer board role',
+  'create_tasking_delivery (board target) rejects an observer board member');
+
+select set_config('request.jwt.claim.sub', (select member_user from _srg_fixture)::text, true);
+select lives_ok(
+  (select format($q$select agent_board.create_tasking_delivery(%L::uuid, %L::uuid, 'title', null, null, %L::uuid)$q$,
+     thread_member, member_agent, board) from _srg_fixture),
+  'create_tasking_delivery (board target) admits a member board member');
+
+-- 3. Boardless direct send is unaffected by the role gate ---------------------
+-- The observer holds only an observer board role, but a board-less DM never
+-- consults the board role gate.
+select set_config('request.jwt.claim.sub', (select observer_user from _srg_fixture)::text, true);
+select lives_ok(
+  (select format($q$select agent_board.send_direct_message(%L::uuid, %L::uuid, %L::uuid, 'sub', 'body')$q$,
+     thread_observer, observer_agent, recipient_agent) from _srg_fixture),
+  'send_direct_message on a board-less thread is unaffected by the board role gate (observer sender admitted)');
+
+-- 4. service_role bypass telemetry: exactly one row, origin from p_metadata ----
+select set_config('request.jwt.claim.role', 'service_role', true);
+select set_config('request.jwt.claim.sub', '', true);
+select lives_ok(
+  (select format($q$select agent_board.post_board_message(%L::uuid, %L::uuid, %L::uuid, 'sub', 'body', 'comment', 'medium', null, %L::jsonb)$q$,
+     thread_member, member_agent, board,
+     jsonb_build_object('signed_write', jsonb_build_object('origin', 'ef'))) from _srg_fixture),
+  'service_role post_board_message succeeds (guarded bypass)');
+
+select is(
+  (select count(*)::int from agent_board.send_authz_telemetry
+    where kind = 'service_role_bypass'
+      and operation = 'post_board_message'
+      and actor_agent_id = (select member_agent from _srg_fixture)),
+  1, 'exactly one service_role_bypass telemetry row is recorded for the send');
+
+select is(
+  (select origin from agent_board.send_authz_telemetry
+    where kind = 'service_role_bypass' and operation = 'post_board_message'
+      and actor_agent_id = (select member_agent from _srg_fixture)
+    order by recorded_at desc limit 1),
+  'ef', 'bypass telemetry origin is resolved from p_metadata signed_write origin');
+
+select set_config('request.jwt.claim.role', '', true);
+
+-- 5. Enforcement live (MBSESSION): the 8 core sends are re-granted to
+-- authenticated; the board-role gate asserted above still governs who may send.
+select function_privs_are(
+  'agent_board', 'post_board_message', array['uuid','uuid','uuid','text','text','text','text','text','jsonb'],
+  'authenticated', array['EXECUTE'], 'post_board_message execute is granted to authenticated (scoped send live)');
+select function_privs_are(
+  'agent_board', 'create_tasking_delivery', array['uuid','uuid','text','text','uuid[]','uuid','text','text','text','jsonb'],
+  'authenticated', array['EXECUTE'], 'create_tasking_delivery execute is granted to authenticated (scoped send live)');
+select function_privs_are(
+  'agent_board', 'send_direct_message', array['uuid','uuid','uuid','text','text','text','text','text','jsonb'],
+  'authenticated', array['EXECUTE'], 'send_direct_message execute is granted to authenticated (scoped send live)');
+
+select finish();
+
+rollback;

package/tests/agent_board_signing_challenge_pending_cap.test.sql

@@ -0,0 +1,87 @@
+-- MBHARDEN SL-1 pgTAP: issue_signing_key_challenge enforces a per-key cap of
+-- N=16 concurrently-pending challenges; <=16 issue as before, the 17th is
+-- rejected, and expired/consumed challenges do not count toward the cap.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(4);
+
+select has_function(
+  'agent_board', 'issue_signing_key_challenge', array['uuid', 'text', 'interval'],
+  'issue_signing_key_challenge exists');
+
+-- Block 1: 16 pending challenges are allowed; the 17th is rejected by the cap.
+do $$
+declare
+  v_agent uuid := '00000000-0000-0000-0000-0000000000c1';
+  v_i int;
+  v_c record;
+begin
+  insert into agent_board.agents(id, agent_type, handle, display_name)
+  values (v_agent, 'agent', 'pcap-agent', 'PCAP Agent');
+  insert into agent_board.agent_signing_keys(
+    agent_id, key_id, key_version, public_key, public_key_format, fingerprint)
+  values (
+    v_agent, 'primary', 1, repeat('A', 43), 'raw_ed25519_base64url',
+    'sha256:' || repeat('Z', 43));
+
+  set local role service_role;
+
+  for v_i in 1..16 loop
+    select * into v_c
+      from agent_board.issue_signing_key_challenge(v_agent, 'primary', interval '5 minutes');
+    if v_c.challenge_id is null then
+      raise exception 'pending challenge % was not issued below the cap', v_i;
+    end if;
+  end loop;
+
+  begin
+    perform *
+      from agent_board.issue_signing_key_challenge(v_agent, 'primary', interval '5 minutes');
+    raise exception 'the 17th pending challenge was NOT rejected by the cap';
+  exception
+    when others then
+      if sqlerrm !~ 'challenge_pending_cap' then
+        raise;
+      end if;
+  end;
+end
+$$;
+reset role;
+
+select pass('16 pending challenges issue below the cap');
+select pass('the 17th concurrently-pending challenge is rejected (challenge_pending_cap)');
+
+-- Expire one pending challenge (as owner), then a new challenge succeeds: expired
+-- rows do not count toward the cap.
+update agent_board.agent_signing_key_challenges
+   set expires_at = now() - interval '1 minute'
+ where id = (
+   select id from agent_board.agent_signing_key_challenges
+    where agent_id = '00000000-0000-0000-0000-0000000000c1'
+      and proof_state = 'pending'
+    order by created_at
+    limit 1);
+
+do $$
+declare
+  v_agent uuid := '00000000-0000-0000-0000-0000000000c1';
+  v_c record;
+begin
+  set local role service_role;
+  select * into v_c
+    from agent_board.issue_signing_key_challenge(v_agent, 'primary', interval '5 minutes');
+  if v_c.challenge_id is null then
+    raise exception 'a new challenge was rejected even though an expired row freed a slot';
+  end if;
+end
+$$;
+reset role;
+
+select pass('an expired pending challenge frees a slot under the cap');
+
+select finish();
+
+rollback;

package/tests/agent_board_signing_challenge_reaper.test.sql

@@ -0,0 +1,74 @@
+-- MBHARDEN SL-1 pgTAP: reap_expired_signing_key_challenges deletes only rows
+-- whose expires_at is older than the grace argument, leaves unexpired rows, returns
+-- the affected count, and is revoked from authenticated.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(9);
+
+select has_function(
+  'agent_board', 'reap_expired_signing_key_challenges', array['interval'],
+  'reap_expired_signing_key_challenges(interval) exists');
+
+-- Seed: one agent + key, then three challenges at old (>7d) / recent (<7d) / future
+-- expires_at. All are pending (proof_state='pending', consumed_at null) — valid per
+-- the consumed-shape check regardless of expires_at.
+do $$
+declare
+  v_agent uuid := gen_random_uuid();
+  v_key uuid;
+begin
+  insert into agent_board.agents(id, agent_type, handle, display_name)
+  values (v_agent, 'agent', 'reap-chal-agent', 'REAP CHAL Agent');
+  insert into agent_board.agent_signing_keys(
+    agent_id, key_id, key_version, public_key, public_key_format, fingerprint)
+  values (
+    v_agent, 'primary', 1, repeat('A', 43), 'raw_ed25519_base64url',
+    'sha256:' || repeat('Z', 43))
+  returning id into v_key;
+
+  insert into agent_board.agent_signing_key_challenges(
+    signing_key_id, agent_id, challenge_nonce, challenge_bytes, expires_at)
+  values
+    (v_key, v_agent, 'nonce-old', 'bytes-old', now() - interval '30 days'),
+    (v_key, v_agent, 'nonce-recent', 'bytes-recent', now() - interval '1 hour'),
+    (v_key, v_agent, 'nonce-future', 'bytes-future', now() + interval '10 minutes');
+end
+$$;
+
+-- Default 7-day grace: removes only the 30-day-old row.
+select is(
+  agent_board.reap_expired_signing_key_challenges(),
+  1::bigint, 'default (7 day) reap removes exactly the one row expired > 7 days ago');
+select ok(
+  not exists (select 1 from agent_board.agent_signing_key_challenges where challenge_nonce = 'nonce-old'),
+  'the 30-day-old challenge was deleted');
+select ok(
+  exists (select 1 from agent_board.agent_signing_key_challenges where challenge_nonce = 'nonce-recent'),
+  'the 1-hour-old challenge survives the 7-day grace');
+select ok(
+  exists (select 1 from agent_board.agent_signing_key_challenges where challenge_nonce = 'nonce-future'),
+  'the not-yet-expired challenge survives the 7-day grace');
+
+-- Zero grace: removes any past-expires_at row (the recent one) but not the future one.
+select is(
+  agent_board.reap_expired_signing_key_challenges(interval '0 seconds'),
+  1::bigint, 'zero-grace reap removes exactly the remaining past-expires_at row');
+select ok(
+  not exists (select 1 from agent_board.agent_signing_key_challenges where challenge_nonce = 'nonce-recent'),
+  'the 1-hour-old challenge is deleted under zero grace');
+select ok(
+  exists (select 1 from agent_board.agent_signing_key_challenges where challenge_nonce = 'nonce-future'),
+  'a not-yet-expired challenge is never reaped');
+
+-- Privilege: execute revoked from authenticated.
+select function_privs_are(
+  'agent_board', 'reap_expired_signing_key_challenges', array['interval'],
+  'authenticated', array[]::text[],
+  'reap_expired_signing_key_challenges execute is revoked from authenticated');
+
+select finish();
+
+rollback;

package/tests/agent_board_thread_acl.test.sql

@@ -0,0 +1,129 @@
+-- MBAUTHZ SL-2 (Lane B) pgTAP: threads.access_mode, thread_memberships (+RLS),
+-- and the redefined _current_agent_can_access_thread.
+--
+-- The suite runs as the postgres db role (superuser, so it can call the
+-- grant-revoked access helper), and simulates callers by toggling
+-- request.jwt.claim.role / request.jwt.claim.sub: role='authenticated' makes
+-- _is_service_role() false so the real access logic runs; role='service_role'
+-- exercises the short-circuit.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(14);
+
+create temp table _thread_acl_fixture (
+  thread_inherit uuid,
+  thread_restricted uuid,
+  creator_user uuid,
+  member_user uuid,
+  stranger_user uuid,
+  expired_user uuid,
+  revoked_user uuid
+) on commit drop;
+
+do $$
+declare
+  v_suffix text := replace(substr(gen_random_uuid()::text, 1, 8), '-', '');
+  v_creator_user uuid;
+  v_member_user uuid;
+  v_stranger_user uuid;
+  v_expired_user uuid;
+  v_revoked_user uuid;
+  v_creator uuid := gen_random_uuid();
+  v_member uuid := gen_random_uuid();
+  v_stranger uuid := gen_random_uuid();
+  v_expired uuid := gen_random_uuid();
+  v_revoked uuid := gen_random_uuid();
+  v_thread_inherit uuid := gen_random_uuid();
+  v_thread_restricted uuid := gen_random_uuid();
+begin
+  v_creator_user := public.ensure_github_user('acl-creator-' || v_suffix, 'acl-creator-' || v_suffix || '@example.test', 'acl-creator-' || v_suffix, 'ACL Creator');
+  v_member_user := public.ensure_github_user('acl-member-' || v_suffix, 'acl-member-' || v_suffix || '@example.test', 'acl-member-' || v_suffix, 'ACL Member');
+  v_stranger_user := public.ensure_github_user('acl-stranger-' || v_suffix, 'acl-stranger-' || v_suffix || '@example.test', 'acl-stranger-' || v_suffix, 'ACL Stranger');
+  v_expired_user := public.ensure_github_user('acl-expired-' || v_suffix, 'acl-expired-' || v_suffix || '@example.test', 'acl-expired-' || v_suffix, 'ACL Expired');
+  v_revoked_user := public.ensure_github_user('acl-revoked-' || v_suffix, 'acl-revoked-' || v_suffix || '@example.test', 'acl-revoked-' || v_suffix, 'ACL Revoked');
+
+  insert into agent_board.agents(id, agent_type, handle, display_name, status, auth_user_id, owner_user_id)
+  values
+    (v_creator, 'agent', 'acl-creator-' || v_suffix, 'ACL Creator', 'active', v_creator_user, v_creator_user),
+    (v_member, 'agent', 'acl-member-' || v_suffix, 'ACL Member', 'active', v_member_user, v_member_user),
+    (v_stranger, 'agent', 'acl-stranger-' || v_suffix, 'ACL Stranger', 'active', v_stranger_user, v_stranger_user),
+    (v_expired, 'agent', 'acl-expired-' || v_suffix, 'ACL Expired', 'active', v_expired_user, v_expired_user),
+    (v_revoked, 'agent', 'acl-revoked-' || v_suffix, 'ACL Revoked', 'active', v_revoked_user, v_revoked_user);
+
+  -- inherit thread (default access_mode) and a restricted thread.
+  insert into agent_board.threads(id, thread_type, created_by_agent_id, subject)
+  values (v_thread_inherit, 'coordination', v_creator, 'ACL inherit thread');
+  insert into agent_board.threads(id, thread_type, created_by_agent_id, subject, access_mode)
+  values (v_thread_restricted, 'coordination', v_creator, 'ACL restricted thread', 'restricted');
+
+  -- ACL on the restricted thread: active member, expired member, revoked member.
+  insert into agent_board.thread_memberships(thread_id, agent_id, role, granted_by_agent_id, expires_at, revoked_at)
+  values
+    (v_thread_restricted, v_member, 'member', v_creator, null, null),
+    (v_thread_restricted, v_expired, 'member', v_creator, now() - interval '1 hour', null),
+    (v_thread_restricted, v_revoked, 'member', v_creator, null, now() - interval '1 hour');
+
+  insert into _thread_acl_fixture values
+    (v_thread_inherit, v_thread_restricted, v_creator_user, v_member_user, v_stranger_user, v_expired_user, v_revoked_user);
+end
+$$;
+
+-- Structure -----------------------------------------------------------------
+select has_column('agent_board', 'threads', 'access_mode', 'threads has access_mode');
+select col_type_is('agent_board', 'threads', 'access_mode', 'text', 'access_mode is text');
+select col_has_check('agent_board', 'threads', 'access_mode', 'access_mode is check-constrained');
+select is(
+  (select access_mode from agent_board.threads t join _thread_acl_fixture f on t.id = f.thread_inherit),
+  'inherit', 'access_mode defaults to inherit');
+select has_table('agent_board', 'thread_memberships', 'thread_memberships table exists');
+select has_column('agent_board', 'thread_memberships', 'thread_id', 'thread_memberships has thread_id');
+select is(
+  (select relrowsecurity from pg_class where oid = 'agent_board.thread_memberships'::regclass),
+  true, 'RLS is enabled on thread_memberships');
+
+-- inherit mode: historical OR preserved -------------------------------------
+select set_config('request.jwt.claim.role', 'authenticated', true);
+select set_config('request.jwt.claim.sub', (select creator_user from _thread_acl_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_inherit from _thread_acl_fixture)),
+  true, 'inherit: creator retains access');
+
+select set_config('request.jwt.claim.sub', (select stranger_user from _thread_acl_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_inherit from _thread_acl_fixture)),
+  false, 'inherit: unrelated agent has no access');
+
+-- service_role short-circuit: restricted thread, no membership -> allowed ----
+select set_config('request.jwt.claim.role', 'service_role', true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_restricted from _thread_acl_fixture)),
+  true, 'service_role bypasses restricted access');
+
+-- restricted mode -----------------------------------------------------------
+select set_config('request.jwt.claim.role', 'authenticated', true);
+select set_config('request.jwt.claim.sub', (select creator_user from _thread_acl_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_restricted from _thread_acl_fixture)),
+  false, 'restricted: creator without an ACL grant is denied');
+
+select set_config('request.jwt.claim.sub', (select member_user from _thread_acl_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_restricted from _thread_acl_fixture)),
+  true, 'restricted: active ACL member is granted');
+
+select set_config('request.jwt.claim.sub', (select expired_user from _thread_acl_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_restricted from _thread_acl_fixture)),
+  false, 'restricted: expired ACL member is denied');
+
+select set_config('request.jwt.claim.sub', (select revoked_user from _thread_acl_fixture)::text, true);
+select is(
+  agent_board._current_agent_can_access_thread((select thread_restricted from _thread_acl_fixture)),
+  false, 'restricted: revoked ACL member is denied');
+
+select finish();
+
+rollback;

package/tests/agent_board_workload_providers_rls.test.sql

@@ -0,0 +1,40 @@
+begin;
+select plan(5);
+
+-- After the corrective, workload_providers must have RLS ENABLED so a
+-- RESTRICTIVE deny (the b2 client-JWT overlay on adopters that carry it) can
+-- actually enforce — it is inert on an RLS-disabled table.
+
+select ok(
+  (select relrowsecurity from pg_class c join pg_namespace n on n.oid=c.relnamespace
+    where n.nspname='agent_board' and c.relname='workload_providers'),
+  'workload_providers has RLS enabled');
+
+select is(
+  (select count(*)::int from pg_policy pol join pg_class c on c.oid=pol.polrelid
+     join pg_namespace n on n.oid=c.relnamespace
+    where n.nspname='agent_board' and c.relname='workload_providers'
+      and pol.polname='workload_providers_authenticated_read'),
+  1, 'workload_providers_authenticated_read policy exists');
+
+select is(
+  (select pg_get_expr(polqual, polrelid) from pg_policy pol join pg_class c on c.oid=pol.polrelid
+     join pg_namespace n on n.oid=c.relnamespace
+    where n.nspname='agent_board' and c.relname='workload_providers'
+      and pol.polname='workload_providers_authenticated_read'),
+  'true', 'authenticated read predicate is true (global registry, fleet-readable)');
+
+select is(
+  (select count(*)::int from pg_policy pol join pg_class c on c.oid=pol.polrelid
+     join pg_namespace n on n.oid=c.relnamespace
+    where n.nspname='agent_board' and c.relname='workload_providers'
+      and pol.polname='workload_providers_deny_anon'),
+  1, 'workload_providers_deny_anon policy exists');
+
+-- canonical fleet-read grant is preserved
+select ok(
+  has_table_privilege('authenticated', 'agent_board.workload_providers', 'SELECT'),
+  'authenticated retains SELECT grant on workload_providers');
+
+select * from finish();
+rollback;