@consiliency/agent-board-schema 1.60.0 → 1.64.0

package/tests/agent_board_session_identity_mint.test.sql

@@ -0,0 +1,233 @@
+-- Reservation and bounded mint transitions enter the real service-role RPCs.
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+begin;
+grant usage on schema extensions to service_role, authenticated;
+select plan(44);
+
+create temp table _sid_mint_root(root_id uuid, suffix text);
+create temp table _sid_children(label text primary key, agent_id uuid, key_id uuid, expires_at timestamptz);
+do $$
+declare v_root uuid := gen_random_uuid(); v_owner uuid; v_auth uuid;
+begin
+  v_owner := public.ensure_github_user('sid-res-owner-' || v_root, 'sid-res-owner-' || v_root || '@example.test', 'sid-res-owner-' || v_root, 'SID owner');
+  v_auth := public.ensure_github_user('sid-res-root-' || v_root, 'sid-res-root-' || v_root || '@example.test', 'sid-res-root-' || v_root, 'SID root');
+  insert into agent_board.agents(id, agent_type, handle, display_name, status, auth_user_id, owner_user_id)
+  values (v_root, 'agent', 'sid-res-root-' || v_root, 'SID root', 'active', v_auth, v_owner);
+  insert into agent_board.session_identities(agent_id, root_agent_id, depth) values (v_root, v_root, 0);
+  insert into _sid_mint_root values (v_root, substr(v_root::text, 1, 8));
+end;
+$$;
+grant select on _sid_mint_root, _sid_children to service_role;
+grant insert on _sid_children to service_role;
+
+create function pg_temp.sid_child(p_label text, p_alias text)
+returns void language plpgsql as $$
+declare v_root uuid; v_suffix text;
+begin
+  select root_id, suffix into v_root, v_suffix from _sid_mint_root;
+  insert into _sid_children
+  select p_label, m.child_agent_id, m.signing_key_id, m.grant_expires_at
+    from agent_board.mint_delegated_child(v_root, 'sid-res-' || p_label || '-' || v_suffix,
+      '[]'::jsonb, public.test_pubkey(v_suffix || p_label), interval '8 hours', false, 'codex', p_alias, null) m;
+end;
+$$;
+create function pg_temp.sid_child_refuse(p_call text)
+returns void language plpgsql as $$
+begin
+  execute p_call;
+  raise exception 'expected refusal but RPC succeeded' using errcode = 'P0001';
+end;
+$$;
+grant execute on function pg_temp.sid_child(text, text), pg_temp.sid_child_refuse(text) to service_role;
+select set_config('request.jwt.claim.role', 'service_role', true);
+set local role service_role;
+select lives_ok($q$select agent_board.upsert_delegation_policy((select root_id from _sid_mint_root), 'root_minted', '[]', 200, interval '8 hours', true)$q$,
+  'EC-SIDSCHEMA-1-reservation-policy: trusted root policy is configured');
+reset role;
+select is((select count(*) from agent_board.delegation_policies where root_agent_id = (select root_id from _sid_mint_root) and revoked_at is null), 1::bigint,
+  'EC-SIDSCHEMA-1-reservation-policy-state: exactly one active policy was created');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_child(label, 'alias-' || label) from unnest(array['live','young','lapsed','revoked','stale']) label$q$,
+  'EC-SIDSCHEMA-1-reservation-mint: session child mint reserves an initial id for every child');
+reset role;
+select is((select count(*) from _sid_children), 5::bigint,
+  'EC-SIDSCHEMA-1-reservation-mint-state: each allowed mint returned its child, key and grant');
+select is((select count(*) from agent_board.session_id_aliases where root_agent_id = (select root_id from _sid_mint_root)), 5::bigint,
+  'EC-SIDSCHEMA-1-reservation-aliases: every initial mint writes its reservation');
+select is((select count(*) from agent_board.session_identities si join _sid_children c on c.agent_id = si.agent_id
+  join agent_board.session_id_aliases a on a.id = si.lease_alias_id where a.identity_agent_id = si.agent_id and a.session_id = 'alias-' || c.label), 5::bigint,
+  'EC-SIDSCHEMA-1-mint-reservation-pointer: every real session mint stores its specific reserved alias');
+select is((select count(*) from agent_board.session_identities where root_agent_id = (select root_id from _sid_mint_root) and identity_kind = 'session' and holder_secret_hash is null), 5::bigint,
+  'EC-SIDSCHEMA-1-reservation-unclaimed: child mint does not create a holder lease');
+
+-- Claim the two lease-bearing cases through real key challenges and token mint.
+update agent_board.session_identities set approved_risky_digest = 'approved', current_risky_digest = 'approved', resolution_state = 'active'
+  where agent_id in (select agent_id from _sid_children where label in ('live', 'lapsed'));
+create temp table _sid_res_tokens(agent_id uuid, epoch bigint);
+grant insert on _sid_res_tokens to service_role;
+create function pg_temp.sid_claim_reservations()
+returns void language plpgsql as $$
+declare v_child record; v_challenge record;
+begin
+  for v_child in select * from _sid_children where label in ('live', 'lapsed') order by label loop
+    select * into v_challenge from agent_board.issue_signing_key_challenge(v_child.agent_id, 'delegated-ephemeral');
+    insert into _sid_res_tokens
+    select v_child.agent_id, m.identity_lease_epoch from agent_board.mint_fleet_agent_session(
+      v_challenge.challenge_id, split_part(v_challenge.challenge, ':', 3), v_child.key_id, v_child.agent_id,
+      900, null, 'alias-' || v_child.label) m;
+  end loop;
+end;
+$$;
+grant execute on function pg_temp.sid_claim_reservations() to service_role;
+set local role service_role;
+select lives_ok('select pg_temp.sid_claim_reservations()', 'EC-SIDSCHEMA-1-reservation-claims: proven child keys claim the live and lapsed fixtures');
+reset role;
+select is((select count(*) from _sid_res_tokens where epoch = 0), 2::bigint,
+  'EC-SIDSCHEMA-1-reservation-claims-state: two first claims start epoch-zero leases');
+update agent_board.session_identities set last_heartbeat = now() - interval '180 seconds'
+  where agent_id = (select agent_id from _sid_children where label = 'lapsed');
+update agent_board.session_identities set created_at = now() - interval '180 seconds'
+  where agent_id in (select agent_id from _sid_children where label in ('revoked', 'stale'));
+select agent_board._revoke_agent_principal((select agent_id from _sid_children where label = 'revoked'), (select root_id from _sid_mint_root), 'reservation fixture revoked');
+update agent_board.session_identities set tombstoned_at = now(), tombstone_reason = 'revoked'
+  where agent_id = (select agent_id from _sid_children where label = 'revoked');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_child('duplicate-live', 'alias-live')$q$),
+  '42501', 'duplicate_live_session', 'EC-SIDSCHEMA-1-reservation-live: duplicate live reservation refuses by name');
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_child('duplicate-young', 'alias-young')$q$),
+  '42501', 'identity_lease_live', 'EC-SIDSCHEMA-1-reservation-young: younger-than-180-second reservation is not superseded');
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_child('duplicate-lapsed', 'alias-lapsed')$q$),
+  '42501', 'identity_lease_lapsed', 'EC-SIDSCHEMA-1-reservation-lapsed: claimed lapsed identity must be reclaimed, not re-minted');
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_child('duplicate-revoked', 'alias-revoked')$q$),
+  '42501', 'identity_tombstoned', 'EC-SIDSCHEMA-1-reservation-revoked: revoked unclaimed reservation cannot be superseded');
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_child('missing-id', null)$q$),
+  '22023', 'unattributed_session_refused', 'EC-SIDSCHEMA-1-reservation-id-required: session-form mint must supply its session id');
+select lives_ok($q$select pg_temp.sid_child('replacement', 'alias-stale')$q$,
+  'EC-SIDSCHEMA-1-reservation-stale: exactly 180-second-old unclaimed reservation is superseded');
+reset role;
+select is((select count(*) from _sid_children where label = 'replacement'), 1::bigint,
+  'EC-SIDSCHEMA-1-reservation-replacement: stale replacement returns a new principal');
+select is((select tombstone_reason from agent_board.session_identities where agent_id = (select agent_id from _sid_children where label = 'stale')), 'superseded_unclaimed',
+  'EC-SIDSCHEMA-1-reservation-tombstone: old unclaimed identity is permanently tombstoned');
+select is((select status from agent_board.agents where id = (select agent_id from _sid_children where label = 'stale')), 'revoked',
+  'EC-SIDSCHEMA-1-reservation-principal: supersede writes through to agent status');
+select is((select status || '/' || proof_state from agent_board.agent_signing_keys where id = (select key_id from _sid_children where label = 'stale')), 'revoked/revoked',
+  'EC-SIDSCHEMA-1-reservation-key: supersede revokes the old child key');
+select ok((select revoked_at is not null from agent_board.delegation_grants where child_agent_id = (select agent_id from _sid_children where label = 'stale')),
+  'EC-SIDSCHEMA-1-reservation-grant: supersede revokes the old grant');
+select is((select identity_agent_id from agent_board.session_id_aliases where root_agent_id = (select root_id from _sid_mint_root) and session_id = 'alias-stale'),
+  (select agent_id from _sid_children where label = 'replacement'),
+  'EC-SIDSCHEMA-1-reservation-repoint: reserved alias resolves to the newly minted identity');
+-- A separate root keeps reservation fixtures out of the bounded-authority census.
+create temp table _sid_bound_root(root_id uuid, board_id uuid, suffix text);
+create temp table _sid_bound_children(label text primary key, agent_id uuid, key_id uuid, expires_at timestamptz);
+do $$
+declare v_root uuid := gen_random_uuid(); v_board uuid := gen_random_uuid(); v_auth uuid;
+begin
+  v_auth := public.ensure_github_user('sid-bound-' || v_root, 'sid-bound-' || v_root || '@example.test', 'sid-bound-' || v_root, 'Bound root');
+  insert into agent_board.agents(id, agent_type, handle, display_name, status, auth_user_id)
+  values (v_root, 'agent', 'sid-bound-' || v_root, 'Bound root', 'active', v_auth);
+  insert into agent_board.session_identities(agent_id, root_agent_id, depth, approved_risky_digest, current_risky_digest)
+  values (v_root, v_root, 0, 'approved', 'approved');
+  insert into agent_board.boards(id, slug, name, created_by_agent_id)
+  values (v_board, 'sid-bound-' || v_root, 'Bound room', v_root);
+  insert into agent_board.board_memberships(board_id, agent_id, membership_state, role)
+  values (v_board, v_root, 'joined', 'owner');
+  insert into _sid_bound_root values (v_root, v_board, substr(v_root::text, 1, 8));
+end;
+$$;
+grant select on _sid_bound_root, _sid_bound_children to service_role;
+grant insert on _sid_bound_children to service_role;
+create function pg_temp.sid_bound(p_label text, p_parent text default null,
+  p_scopes jsonb default '["read"]', p_role text default null, p_fork text default null)
+returns void language plpgsql as $$
+declare v_parent uuid; v_root uuid; v_board uuid; v_suffix text; v_rooms jsonb; v_fork uuid;
+begin
+  select root_id, board_id, suffix into v_root, v_board, v_suffix from _sid_bound_root;
+  v_parent := coalesce((select agent_id from _sid_bound_children where label = p_parent), v_root);
+  v_fork := (select agent_id from _sid_bound_children where label = p_fork);
+  if p_role is not null then v_rooms := jsonb_build_array(jsonb_build_object('board_id', v_board, 'role', p_role)); end if;
+  insert into _sid_bound_children
+  select p_label, m.child_agent_id, m.signing_key_id, m.grant_expires_at
+    from agent_board.mint_delegated_child(v_parent, 'sid-bound-' || p_label || '-' || v_suffix,
+      p_scopes, public.test_pubkey(v_suffix || p_label), interval '14 days', false,
+      'claude', 'bound-' || p_label, '0', v_rooms,
+      '{"resolution":"resolved","risky_digest":"approved","recorded":{"version":"one"}}', v_fork) m;
+end;
+$$;
+grant execute on function pg_temp.sid_bound(text, text, jsonb, text, text) to service_role;
+set local role service_role;
+select lives_ok($q$select agent_board.upsert_delegation_policy((select root_id from _sid_bound_root), 'root_minted', '["read","write"]', 200, interval '14 days', true)$q$,
+  'EC-SIDSCHEMA-2-policy: root authority is configured through its sole writer');
+reset role;
+select is((select allowed_scopes from agent_board.delegation_policies where root_agent_id = (select root_id from _sid_bound_root)), '["read","write"]'::jsonb,
+  'EC-SIDSCHEMA-2-policy-state: explicit root scopes are stored');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_bound('parent', null, '["read"]', 'admin')$q$,
+  'EC-SIDSCHEMA-2-depth-one: approved root mints its explicit-room session');
+reset role;
+select is((select bm.role from agent_board.board_memberships bm where bm.agent_id = (select agent_id from _sid_bound_children where label = 'parent')), 'admin',
+  'EC-SIDSCHEMA-2-room-role: exactly the parent-chosen bounded role is written');
+select is((select count(*) from agent_board.board_memberships bm where bm.agent_id = (select agent_id from _sid_bound_children where label = 'parent')), 1::bigint,
+  'EC-SIDSCHEMA-2-room-count: exactly the explicitly requested room is admitted');
+select is((select expires_at from _sid_bound_children where label = 'parent'), now() + interval '7 days',
+  'EC-SIDSCHEMA-2-ttl: approved session lifetime is capped at seven days');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_bound('no-room')$q$, 'EC-SIDSCHEMA-2-no-room: omitting rooms is an allowed empty request');
+reset role;
+select is((select count(*) from agent_board.board_memberships where agent_id = (select agent_id from _sid_bound_children where label = 'no-room')), 0::bigint,
+  'EC-SIDSCHEMA-2-no-default-room: omitted rooms never create a default membership');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_bound('grandchild', 'parent', '["read"]', 'observer')$q$,
+  'EC-SIDSCHEMA-2-depth-two: depth-one session may mint a bounded sub-agent');
+reset role;
+select is((select depth from agent_board.session_identities where agent_id = (select agent_id from _sid_bound_children where label = 'grandchild')), 2::smallint,
+  'EC-SIDSCHEMA-2-depth-two-state: successful sub-agent is depth two');
+select is((select root_agent_id from agent_board.agents where id = (select agent_id from _sid_bound_children where label = 'grandchild')), (select root_id from _sid_bound_root),
+  'EC-SIDSCHEMA-2-true-root: depth-two principal records the depth-zero root, not its parent');
+select is((select parent_agent_id from agent_board.agents where id = (select agent_id from _sid_bound_children where label = 'grandchild')), (select agent_id from _sid_bound_children where label = 'parent'),
+  'EC-SIDSCHEMA-2-parent: depth-two principal retains its immediate parent');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('third', 'grandchild')$q$),
+  '42501', 'identity_depth_exceeded', 'EC-SIDSCHEMA-2-depth-three: depth three refuses by name');
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('inflated-role', 'parent', '["read"]', 'owner')$q$),
+  '42501', 'room_authority_exceeded', 'EC-SIDSCHEMA-2-role-bound: sub-agent cannot outrank its parent');
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('inflated-scope', 'parent', '["write"]')$q$),
+  '42501', 'scope_exceeded: requested scopes are not a subset of the root allowed_scopes', 'EC-SIDSCHEMA-2-scope-bound: sub-agent uses granted scopes, not root latitude');
+select lives_ok($q$select pg_temp.sid_bound('fork', null, '["read"]', null, 'parent')$q$,
+  'EC-SIDSCHEMA-2-fork: a new related session may fork a live same-parent identity');
+reset role;
+select is((select forked_from from agent_board.session_identities where agent_id = (select agent_id from _sid_bound_children where label = 'fork')), (select agent_id from _sid_bound_children where label = 'parent'),
+  'EC-SIDSCHEMA-2-fork-state: new identity retains fork provenance');
+-- A self-written depth-one policy must not expand the parent's granted scopes.
+insert into agent_board.delegation_policies(root_agent_id, mode, allowed_scopes, child_ttl_ceiling)
+select agent_id, 'root_minted', '["read","write"]', interval '14 days' from _sid_bound_children where label = 'parent';
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('self-scope', 'parent', '["write"]')$q$),
+  '42501', 'scope_exceeded: requested scopes are not a subset of the root allowed_scopes', 'EC-SIDSCHEMA-2-self-scope: self-written policy cannot widen a session grant');
+reset role;
+update agent_board.delegation_grants set grant_expires_at = now() where child_agent_id = (select agent_id from _sid_bound_children where label = 'parent');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('expired-parent', 'parent')$q$),
+  '42501', 'identity_parent_inactive', 'EC-SIDSCHEMA-2-ancestor-expiry: expired parent grant refuses mint');
+reset role;
+update agent_board.delegation_grants set grant_expires_at = now() + interval '7 days', revoked_at = now()
+where child_agent_id = (select agent_id from _sid_bound_children where label = 'parent');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('revoked-parent', 'parent')$q$),
+  '42501', 'identity_parent_inactive', 'EC-SIDSCHEMA-2-ancestor-revoke: revoked parent grant refuses mint');
+reset role;
+update agent_board.delegation_grants set revoked_at = null where child_agent_id = (select agent_id from _sid_bound_children where label = 'parent');
+update agent_board.session_identities set resolution_state = 'frozen' where agent_id = (select root_id from _sid_bound_root);
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_child_refuse(%L)', $q$select pg_temp.sid_bound('frozen-root', 'parent')$q$),
+  '42501', 'identity_fingerprint_unapproved', 'EC-SIDSCHEMA-2-ancestor-freeze: frozen depth-zero ancestor refuses depth-two mint');
+reset role;
+update agent_board.session_identities set resolution_state = 'active' where agent_id = (select root_id from _sid_bound_root);
+select is((select count(*) from _sid_bound_children), 4::bigint,
+  'EC-SIDSCHEMA-2-refusal-state: refused mints do not leave extra principals');
+select is((select count(*) from pg_proc p join pg_namespace n on n.oid = p.pronamespace where n.nspname = 'agent_board' and p.proname = 'mint_delegated_child'), 1::bigint,
+  'EC-SIDSCHEMA-2-single-mint: catalog contains exactly one child-mint signature');
+select finish();
+rollback;

package/tests/agent_board_session_identity_panel_r1.test.sql

@@ -0,0 +1,194 @@
+-- Production-path controls and independent review-regression refusals.
+create extension if not exists pgtap with schema extensions;
+set search_path=extensions,public,agent_board;
+begin;
+grant usage on schema extensions to authenticated,service_role;
+select plan(39);
+create temp table _sid_r1(label text primary key, agent_id uuid, auth_id uuid, key_id uuid);
+create temp table _sid_r1_results(label text, agent_id uuid, session_id text);
+do $$
+declare v_label text; v_id uuid; v_auth uuid; v_owner uuid; v_key uuid;
+begin
+  foreach v_label in array array['owner','root','bare'] loop
+    v_id:=gen_random_uuid(); v_key:=gen_random_uuid();
+    v_auth:=public.ensure_github_user('sid-r1-'||v_id,'sid-r1-'||v_id||'@example.test','sid-r1-'||v_id,'Review fixture');
+    if v_label='owner' then v_owner:=v_auth; end if;
+    insert into agent_board.agents(id,agent_type,handle,display_name,status,auth_user_id,owner_user_id)
+    values(v_id,case when v_label='owner' then 'human' else 'agent' end,'sid-r1-'||v_id,'Review fixture','active',v_auth,v_owner);
+    insert into agent_board.session_identities(agent_id,root_agent_id,depth) values(v_id,v_id,0);
+    insert into agent_board.agent_signing_keys(id,agent_id,key_id,key_version,public_key,public_key_format,fingerprint,status,proof_state)
+    values(v_key,v_id,'primary',1,public.test_pubkey(v_key::text),'raw_ed25519_base64url',public.test_key_fingerprint(v_key::text),'active','proven');
+    insert into _sid_r1 values(v_label,v_id,v_auth,v_key);
+  end loop;
+end;
+$$;
+-- A pre-commit principal can still have no identity row; this path stays additive.
+delete from agent_board.session_identities where agent_id=(select agent_id from _sid_r1 where label='bare');
+grant select,insert on _sid_r1,_sid_r1_results to service_role;
+grant select on _sid_r1,_sid_r1_results to authenticated;
+create function pg_temp.sid_r1_subject(p_label text) returns void language sql as $$
+  select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r1 where label=p_label),true);
+$$;
+create function pg_temp.sid_r1_legacy(p_parent text,p_label text) returns void language plpgsql as $$
+declare v_mint record;
+begin
+  select * into v_mint from agent_board.mint_delegated_child((select agent_id from _sid_r1 where label=p_parent),
+    'sid-r1-'||p_label||'-'||gen_random_uuid(),'["read"]',public.test_pubkey(p_label),interval '1 hour');
+  insert into _sid_r1 select p_label,v_mint.child_agent_id,a.auth_user_id,v_mint.signing_key_id
+    from agent_board.agents a where a.id=v_mint.child_agent_id;
+end;
+$$;
+create function pg_temp.sid_r1_token(p_label text) returns void language plpgsql as $$
+declare v_fx record; v_challenge record;
+begin
+  select * into v_fx from _sid_r1 where label=p_label;
+  select * into v_challenge from agent_board.issue_signing_key_challenge(v_fx.agent_id,
+    case when p_label in ('root','bare') then 'primary' else 'delegated-ephemeral' end);
+  insert into _sid_r1_results select p_label,v_fx.agent_id,m.session_id from agent_board.mint_fleet_agent_session(
+    v_challenge.challenge_id,split_part(v_challenge.challenge,':',3),v_fx.key_id,v_fx.agent_id) m;
+end;
+$$;
+create function pg_temp.sid_r1_session(p_label text,p_alias text,p_fork text default null) returns void language plpgsql as $$
+declare v_mint record;
+begin
+  select * into v_mint from agent_board.mint_delegated_child((select agent_id from _sid_r1 where label='root'),
+    'sid-r1-'||p_label||'-'||gen_random_uuid(),'["read"]',public.test_pubkey(p_label),interval '1 hour',false,
+    'claude',p_alias,null,'[]','{"resolution":"resolved","risky_digest":"approved"}',
+    (select agent_id from _sid_r1 where label=p_fork));
+  insert into _sid_r1 select p_label,v_mint.child_agent_id,a.auth_user_id,v_mint.signing_key_id
+    from agent_board.agents a where a.id=v_mint.child_agent_id;
+end;
+$$;
+create function pg_temp.sid_r1_refuse(p_sql text) returns void language plpgsql as $$
+begin execute p_sql; raise exception 'expected refusal but RPC succeeded' using errcode='P0001'; end;
+$$;
+grant execute on function pg_temp.sid_r1_subject(text),pg_temp.sid_r1_refuse(text) to authenticated,service_role;
+grant execute on function pg_temp.sid_r1_legacy(text,text),pg_temp.sid_r1_token(text),pg_temp.sid_r1_session(text,text,text) to service_role;
+select set_config('request.jwt.claims','{}',true);
+select set_config('request.jwt.claim.role','service_role',true);
+set local role service_role;
+select lives_ok($q$select agent_board.upsert_delegation_policy((select agent_id from _sid_r1 where label='root'),'root_minted','["read"]',200,interval '7 days',true);
+select agent_board.upsert_delegation_policy((select agent_id from _sid_r1 where label='bare'),'root_minted','["read"]',200,interval '7 days',true)$q$,'R1-policy-control: both real legacy policies are configured');
+reset role;
+select is((select count(*) from agent_board.delegation_policies where root_agent_id in(select agent_id from _sid_r1 where label in('root','bare'))),2::bigint,'R1-policy-state: both policies exist');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_r1_legacy('root','legacy-child'); select pg_temp.sid_r1_legacy('bare','bare-child')$q$,'R1-legacy-child-control: never-frozen and absent identity rows preserve legacy child mint');
+reset role;
+select is((select count(*) from _sid_r1 where label in('legacy-child','bare-child')),2::bigint,'R1-legacy-child-state: both legacy children were returned');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_r1_token('root'); select pg_temp.sid_r1_token('bare')$q$,'R1-legacy-token-control: never-frozen and absent identity rows preserve token mint');
+reset role;
+select is((select count(*) from _sid_r1_results),2::bigint,'R1-legacy-token-state: both real PoP issuances returned tokens');
+set local role service_role;
+select pg_temp.sid_r1_subject('root');
+select lives_ok($q$select agent_board.record_session_identity_state((select agent_id from _sid_r1 where label='root'),'{"resolution":"resolved","risky_digest":"changed"}')$q$,'R1-freeze-control: real recorded risky reading freezes a legacy parent');
+reset role;
+select is((select resolution_state from agent_board.session_identities where agent_id=(select agent_id from _sid_r1 where label='root')),'frozen','R1-freeze-state: root is explicitly frozen');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select pg_temp.sid_r1_legacy('root','forbidden')$q$),'42501','identity_fingerprint_unapproved','R1-F001-legacy-child: frozen root cannot bypass approval through legacy child mint');
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select pg_temp.sid_r1_token('root')$q$),'42501','identity_fingerprint_unapproved','R1-F001-legacy-token: frozen root cannot bypass approval through legacy token mint');
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select pg_temp.sid_r1_token('legacy-child')$q$),'42501','identity_fingerprint_unapproved','R1-F001-ancestor-token: legacy child token checks its frozen ancestor');
+reset role;
+select is((select count(*) from _sid_r1_results),2::bigint,'R1-freeze-refusal-state: frozen issuances create no token result');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select agent_board.record_session_identity_state((select agent_id from _sid_r1 where label='root'),'{"resolution":"Unresolved","risky_digest":"changed"}')$q$),'22023','invalid identity fingerprint resolution','R1-N1-record-vocabulary: out-of-vocabulary reading is refused');
+reset role;
+select is((select recorded_fingerprint->>'resolution' from agent_board.session_identities where agent_id=(select agent_id from _sid_r1 where label='root')),'resolved','R1-N1-record-state: bad spelling does not replace the reading');
+-- Historical/malformed stored metadata must not be laundered by a fresh approval argument.
+update agent_board.session_identities set recorded_fingerprint='{"resolution":"Unresolved"}' where agent_id=(select agent_id from _sid_r1 where label='root');
+set local role service_role;
+select pg_temp.sid_r1_subject('owner');
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select agent_board.approve_identity_state((select agent_id from _sid_r1 where label='root'),'changed','{"resolution":"resolved"}')$q$),'42501','identity_fingerprint_unapproved','R1-N1-approval-exact: any stored state other than exactly resolved refuses approval');
+reset role;
+update agent_board.session_identities set recorded_fingerprint='{"resolution":"resolved"}' where agent_id=(select agent_id from _sid_r1 where label='root');
+set local role service_role;
+select lives_ok($q$select agent_board.approve_identity_state((select agent_id from _sid_r1 where label='root'),'changed','{"resolution":"resolved"}')$q$,'R1-owner-control: unrevoked human approves resolved reading');
+reset role;
+select is((select resolution_state from agent_board.session_identities where agent_id=(select agent_id from _sid_r1 where label='root')),'active','R1-owner-control-state: approval thaws the identity');
+-- Matching digest for session fixtures; still no implicit lease on the legacy root.
+update agent_board.session_identities set approved_risky_digest='approved',current_risky_digest='approved' where agent_id=(select agent_id from _sid_r1 where label='root');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_r1_session('unclaimed','r1-unclaimed'); select pg_temp.sid_r1_session('fork','r1-fork','unclaimed')$q$,'R1-N2-fork-control: real mint creates an unclaimed reservation and related fork');
+reset role;
+update agent_board.session_identities set holder_secret_hash=digest('fork-holder','sha256'),last_heartbeat=now() where agent_id=(select agent_id from _sid_r1 where label='fork');
+update agent_board.session_identities set created_at=now()-interval '181 seconds' where agent_id=(select agent_id from _sid_r1 where label='unclaimed');
+select ok((select agent_board._session_identity_lease_live(agent_id) from _sid_r1 where label='fork'),'R1-N2-live-fork-state: fork has a live lease before supersede');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_r1_session('replacement','r1-unclaimed')$q$,'R1-N2-supersede-control: conflicting mint supersedes the stale unclaimed reservation');
+reset role;
+select is((select tombstone_reason from agent_board.session_identities where agent_id=(select agent_id from _sid_r1 where label='unclaimed')),'superseded_unclaimed','R1-N2-superseded-state: only the stale reservation is superseded');
+select ok((select si.tombstoned_at is null and a.status='active' and si.credential_epoch=0 and g.revoked_at is null
+  from _sid_r1 f join agent_board.session_identities si on si.agent_id=f.agent_id join agent_board.agents a on a.id=f.agent_id
+  join agent_board.delegation_grants g on g.child_agent_id=f.agent_id where f.label='fork'),'R1-N2-fork-survives: supersede leaves a live fork and its credentials intact');
+select set_config('request.jwt.claim.role','authenticated',true);
+set local role authenticated;
+select lives_ok($q$select agent_board.revoke_session_identity((select agent_id from _sid_r1 where label='replacement'))$q$,'R1-revoke-control: real owner revoke remains authorised');
+reset role;
+-- Real revocation of the old source must still traverse its surviving fork.
+set local role authenticated;
+select lives_ok($q$select agent_board.revoke_session_identity((select agent_id from _sid_r1 where label='unclaimed'))$q$,'R1-N2-real-revoke-control: ordinary revoke still closes related forks');
+reset role;
+select ok((select tombstoned_at is not null from agent_board.session_identities where agent_id=(select agent_id from _sid_r1 where label='fork')),'R1-N2-real-revoke-state: fork is tombstoned by real revoke');
+select set_config('request.jwt.claim.role','service_role',true);
+set local role service_role;
+select pg_temp.sid_r1_subject('root');
+select lives_ok($q$select * from agent_board.revoke_fleet_subject('agent',(select agent_id from _sid_r1 where label='owner'),(select agent_id from _sid_r1 where label='root'),'review owner revocation')$q$,'R1-ledger-control: real fleet revocation permanently revokes the human owner');
+reset role;
+select ok((select a.status='active' and agent_board._actor_fleet_revoked(a.id) from agent_board.agents a join _sid_r1 f on f.agent_id=a.id where f.label='owner'),'R1-ledger-state: legacy human stays active while permanently ledger-revoked');
+set local role service_role;
+select pg_temp.sid_r1_subject('owner');
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select agent_board.approve_identity_state((select agent_id from _sid_r1 where label='root'),'approved','{"resolution":"resolved"}')$q$),'42501','fleet_revoked: approve_identity_state is not permitted for a fleet-revoked agent','R1-F002-approve-ledger: ledger-revoked human owner cannot approve');
+reset role;
+select set_config('request.jwt.claim.role','authenticated',true);
+set local role authenticated;
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select agent_board.rename_agent((select agent_id from _sid_r1 where label='root'),'forbidden')$q$),'42501','fleet_revoked: rename_agent is not permitted for a fleet-revoked agent','R1-F002-rename-ledger: ledger-revoked human owner cannot rename');
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select agent_board.revoke_session_identity((select agent_id from _sid_r1 where label='root'))$q$),'42501','fleet_revoked: revoke_session_identity is not permitted for a fleet-revoked agent','R1-F002-revoke-ledger: ledger-revoked human owner cannot revoke');
+reset role;
+select is((select display_name from agent_board.agents where id=(select agent_id from _sid_r1 where label='root')),'Review fixture','R1-ledger-refusal-state: refused rename leaves the target untouched');
+
+-- The class is derived from bodies/call closure, not an authored RPC name list.
+-- Scanner floor: recognizes _session_identity_owner calls or the exact inline
+-- human.agent_type = 'human' spelling plus auth.uid. Differently named aliases,
+-- joins or ownership helpers must extend this scanner; it does not prove
+-- arbitrary control flow. Panel-r2 adds a positive authorization-condition pin.
+create temp view _sid_r1_owner_paths as
+select p.oid,p.proname,agent_board_test.stripped_body(p.oid) body
+from pg_proc p where p.pronamespace='agent_board'::regnamespace and p.prokind='f'
+  and (agent_board_test.stripped_body(p.oid) ~ agent_board_test.call_re('_session_identity_owner')
+    or (agent_board_test.stripped_body(p.oid,true) like '%human.agent_type = ''human''%'
+      and agent_board_test.stripped_body(p.oid) ~ agent_board_test.call_re('auth.uid',false)))
+  and agent_board_test.stripped_body(p.oid) ~ agent_board_test.re(
+    agent_board_test.write_frag('agents',agent_board_test.bare_ok(p.oid)) || '|'
+    || agent_board_test.write_frag('session_identities',agent_board_test.bare_ok(p.oid)) || '|'
+    || agent_board_test.call_frag('_revoke_agent_principal'));
+select ok((select count(*)>0 from _sid_r1_owner_paths),'R1-owner-class-populated: owner-path writers are discovered from the catalog');
+select is((select coalesce(string_agg(proname,', ' order by proname),'') from _sid_r1_owner_paths
+  where not exists(select 1 from agent_board_test.fn_call_closure() c
+    where c.root_oid=oid and c.reached_oid='agent_board._assert_actor_not_fleet_revoked(uuid,text)'::regprocedure)),
+  '','R1-owner-class: every discovered human-owner writer reaches locked permanent-ledger refusal');
+select ok(agent_board_test.stripped_body('agent_board._session_identity_owner(uuid)'::regprocedure,true) like '%human.agent_type = ''human''%'
+  and agent_board_test.stripped_body('agent_board._session_identity_owner(uuid)'::regprocedure,true) like '%human.status = ''active''%'
+  and agent_board_test.stripped_body('agent_board._session_identity_owner(uuid)'::regprocedure) like '%root.owner_user_id = auth.uid()%'
+  and pg_get_function_result('agent_board._session_identity_owner(uuid)'::regprocedure)='boolean',
+  'R1-owner-predicate-positive: exempt predicate returns only a human ownership boolean, not an authority mutation');
+select ok(position('current_agent_id()' in agent_board_test.stripped_body('agent_board.heartbeat_session_identity(uuid)'::regprocedure))
+  < position('for update' in agent_board_test.stripped_body('agent_board.heartbeat_session_identity(uuid)'::regprocedure)),
+  'R1-heartbeat-authorise-first: resolver authorisation precedes the first identity lock');
+select ok(position('_session_identity_owner(' in agent_board_test.stripped_body('agent_board.revoke_session_identity(uuid)'::regprocedure))
+  < position('for update' in agent_board_test.stripped_body('agent_board.revoke_session_identity(uuid)'::regprocedure)),
+  'R1-revoke-authorise-first: owner/ancestor authorisation precedes the first target lock');
+select ok(agent_board_test.stripped_body('agent_board.revoke_agent(uuid,text)'::regprocedure,true) like '%revocation requires a resolved actor%'
+  and agent_board_test.stripped_body('agent_board.revoke_agent(uuid,text)'::regprocedure) not like '%coalesce(agent_board.current_agent_id(), p_agent_id)%',
+  'R1-admin-revoker: unresolved platform-admin principal refuses rather than blaming the target');
+create temp table _sid_r1_admin(auth_id uuid);
+insert into _sid_r1_admin select public.ensure_github_user('sid-r1-admin-'||gen_random_uuid(),'sid-r1-admin@example.test','sid-r1-admin-'||gen_random_uuid(),'Unresolved admin');
+insert into public.user_org_roles(user_id,role) select auth_id,'platform_admin' from _sid_r1_admin;
+grant select on _sid_r1_admin to authenticated;
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r1_admin),true);
+set local role authenticated;
+select throws_ok(format('select pg_temp.sid_r1_refuse(%L)',$q$select * from agent_board.revoke_agent((select agent_id from _sid_r1 where label='root'),'review unresolved admin')$q$),
+  '42501','revocation requires a resolved actor','R1-admin-unresolved: actual admin without a board principal cannot blame the target');
+reset role;
+select is((select status from agent_board.agents where id=(select agent_id from _sid_r1 where label='root')),'active','R1-admin-unresolved-state: unresolved actor refusal leaves principal active');
+select finish();
+rollback;

package/tests/agent_board_session_identity_panel_r2.test.sql

@@ -0,0 +1,174 @@
+-- Real API compatibility controls; no existing suite inputs are accommodated.
+create extension if not exists pgtap with schema extensions;
+set search_path=extensions,public,agent_board;
+begin;
+grant usage on schema extensions to authenticated,service_role;
+select plan(28);
+create temp table _sid_r2(label text primary key,agent_id uuid,auth_id uuid,key_id uuid);
+create temp table _sid_r2_results(label text,status text,revoked_count integer);
+create temp table _sid_r2_challenge(challenge_id uuid,nonce text);
+do $$
+declare v_label text; v_id uuid; v_auth uuid; v_owner uuid;
+begin
+  foreach v_label in array array['owner','parent','service-legacy','admin-legacy'] loop
+    v_id:=gen_random_uuid();
+    v_auth:=public.ensure_github_user('sid-r2-'||v_id,'sid-r2-'||v_id||'@example.test','sid-r2-'||v_id,'Review fixture');
+    if v_label='owner' then v_owner:=v_auth; end if;
+    insert into agent_board.agents(id,agent_type,handle,display_name,status,auth_user_id,owner_user_id)
+      values(v_id,case when v_label='owner' then 'human' else 'agent' end,'sid-r2-'||v_id,'Review fixture','active',v_auth,v_owner);
+    insert into agent_board.session_identities(agent_id,root_agent_id,depth,approved_risky_digest,current_risky_digest,recorded_fingerprint)
+      values(v_id,v_id,0,'approved','approved','{"resolution":"resolved"}');
+    insert into _sid_r2 values(v_label,v_id,v_auth,null);
+  end loop;
+  insert into agent_board.agent_credentials(agent_id,refresh_token_hash,hash_version,credential_label,expires_at)
+    select agent_id,digest(label,'sha256'),1,'review control',now()+interval '1 hour'
+    from _sid_r2 where label in('service-legacy','admin-legacy');
+end;
+$$;
+grant select,insert on _sid_r2,_sid_r2_results,_sid_r2_challenge to service_role;
+grant select,insert on _sid_r2_results to authenticated;
+grant select on _sid_r2 to authenticated;
+create function pg_temp.sid_r2_refuse(p_sql text) returns void language plpgsql as $$
+begin execute p_sql; raise exception 'expected refusal but RPC succeeded' using errcode='P0001'; end;
+$$;
+grant execute on function pg_temp.sid_r2_refuse(text) to authenticated,service_role;
+create function pg_temp.sid_r2_mint(p_label text,p_session boolean) returns void language plpgsql as $$
+declare v_mint record;
+begin
+  select * into v_mint from agent_board.mint_delegated_child((select agent_id from _sid_r2 where label='parent'),
+    'sid-r2-'||p_label||'-'||gen_random_uuid(),'["read"]',public.test_pubkey(p_label),interval '1 hour',false,
+    case when p_session then 'claude' end,case when p_session then 'r2-'||p_label end,null,'[]',
+    case when p_session then '{"resolution":"resolved","risky_digest":"approved"}'::jsonb end);
+  insert into _sid_r2 select p_label,v_mint.child_agent_id,a.auth_user_id,v_mint.signing_key_id
+    from agent_board.agents a where a.id=v_mint.child_agent_id;
+end;
+$$;
+grant execute on function pg_temp.sid_r2_mint(text,boolean) to service_role;
+select set_config('request.jwt.claims','{}',true);
+select set_config('request.jwt.claim.sub','',true);
+select set_config('request.jwt.claim.role','service_role',true);
+set local role service_role;
+select lives_ok($q$insert into _sid_r2_results select 'service',status,revoked_credential_count from agent_board.revoke_agent((select agent_id from _sid_r2 where label='service-legacy'),'operator script')$q$,
+  'R2-F001-service-legacy: service_role without sub still revokes a legacy target');
+reset role;
+select ok((select a.status='suspended' and r.status='suspended' and r.revoked_count=1
+  and c.revoked_at is not null and a.metadata->>'revocationReason'='operator script'
+  from _sid_r2 f join agent_board.agents a on a.id=f.agent_id join agent_board.agent_credentials c on c.agent_id=a.id
+  join _sid_r2_results r on r.label='service' where f.label='service-legacy'),
+  'R2-F001-service-state: suspension, returned credential count and credential revocation remain legacy-compatible');
+create temp table _sid_r2_admin(auth_id uuid);
+insert into _sid_r2_admin select public.ensure_github_user('sid-r2-admin-'||gen_random_uuid(),'sid-r2-admin@example.test','sid-r2-admin-'||gen_random_uuid(),'Unresolved admin');
+insert into public.user_org_roles(user_id,role) select auth_id,'platform_admin' from _sid_r2_admin;
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2_admin),true);
+select set_config('request.jwt.claim.role','authenticated',true);
+set local role authenticated;
+select lives_ok($q$insert into _sid_r2_results select 'admin',status,revoked_credential_count from agent_board.revoke_agent((select agent_id from _sid_r2 where label='admin-legacy'),'Portal admin')$q$,
+  'R2-F001-admin-legacy: Portal platform admin without a board principal still revokes a legacy target');
+reset role;
+select ok((select a.status='suspended' and r.status='suspended' and r.revoked_count=1 and c.revoked_at is not null
+  from _sid_r2 f join agent_board.agents a on a.id=f.agent_id join agent_board.agent_credentials c on c.agent_id=a.id
+  join _sid_r2_results r on r.label='admin' where f.label='admin-legacy'),
+  'R2-F001-admin-state: the real Portal admin control suspends and revokes credentials');
+select set_config('request.jwt.claim.role','service_role',true);
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2 where label='parent'),true);
+set local role service_role;
+select lives_ok($q$select agent_board.upsert_delegation_policy((select agent_id from _sid_r2 where label='parent'),'root_minted','["read"]',200,interval '7 days',true)$q$,
+  'R2-policy-control: real delegation policy admits the review fixtures');
+reset role;
+select ok(exists(select 1 from agent_board.delegation_policies where root_agent_id=(select agent_id from _sid_r2 where label='parent')),
+  'R2-policy-state: configured policy exists');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_r2_mint('legacy-child',false)$q$,'R2-ancestor-mint-control: real legacy child mint succeeds');
+reset role;
+select ok(exists(select 1 from _sid_r2 where label='legacy-child'),'R2-ancestor-mint-state: real legacy child result exists');
+update agent_board.session_identities set current_risky_digest='approved',resolution_state='frozen',recorded_fingerprint='{"resolution":"resolved"}'
+  where agent_id=(select agent_id from _sid_r2 where label='legacy-child');
+set local role service_role;
+select lives_ok($q$select agent_board.approve_identity_state((select agent_id from _sid_r2 where label='legacy-child'),'approved','{"resolution":"resolved"}')$q$,
+  'R2-ancestor-approval-control: unrevoked matching ancestor approves a legacy descendant');
+reset role;
+select is((select resolution_state from agent_board.session_identities where agent_id=(select agent_id from _sid_r2 where label='legacy-child')),'active',
+  'R2-ancestor-approval-state: the allow control really thaws the descendant');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_r2_mint('self',true); select pg_temp.sid_r2_mint('frozen',true)$q$,'R2-session-control: both real session identities are minted');
+reset role;
+select is((select count(*) from _sid_r2 where label in('self','frozen')),2::bigint,'R2-session-state: both session results exist');
+set local role service_role;
+insert into _sid_r2_challenge select challenge_id,split_part(challenge,':',3)
+  from agent_board.issue_signing_key_challenge((select agent_id from _sid_r2 where label='frozen'),'delegated-ephemeral');
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2 where label='self'),true);
+select set_config('request.jwt.claim.identity_lease_epoch','0',true);
+reset role;
+select set_config('request.jwt.claim.role','authenticated',true);
+set local role authenticated;
+select throws_ok(format('select pg_temp.sid_r2_refuse(%L)',$q$select * from agent_board.revoke_fleet_subject('agent',(select agent_id from _sid_r2 where label='self'),(select agent_id from _sid_r2 where label='self'),'superseded_unclaimed')$q$),
+  '22023','superseded_unclaimed is reserved for the supersede path','R2-N2-2-self-reason: self revocation cannot forge the reserved supersede reason');
+reset role;
+select ok((select tombstoned_at is null from agent_board.session_identities where agent_id=(select agent_id from _sid_r2 where label='self')),
+  'R2-N2-2-reason-state: rejected reason leaves the identity live');
+select set_config('request.jwt.claim.role','service_role',true);
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2 where label='owner'),true);
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_r2_refuse(%L)',$q$select * from agent_board.revoke_agent((select agent_id from _sid_r2 where label='self'),'superseded_unclaimed')$q$),
+  '22023','superseded_unclaimed is reserved for the supersede path','R2-N2-2-admin-reason: admin revocation cannot forge the reserved reason');
+select throws_ok(format('select pg_temp.sid_r2_refuse(%L)',$q$select * from agent_board.revoke_agent_subtree((select agent_id from _sid_r2 where label='self'),(select agent_id from _sid_r2 where label='owner'),'superseded_unclaimed')$q$),
+  '22023','superseded_unclaimed is reserved for the supersede path','R2-N2-2-subtree-reason: service subtree revocation cannot forge the reserved reason');
+reset role;
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2 where label='self'),true);
+select set_config('request.jwt.claim.role','authenticated',true);
+set local role authenticated;
+select lives_ok($q$select * from agent_board.revoke_fleet_subject('agent',(select agent_id from _sid_r2 where label='self'),(select agent_id from _sid_r2 where label='self'),'ordinary self revocation')$q$,
+  'R2-self-revoke-control: ordinary self-revocation remains supported');
+reset role;
+select is((select tombstone_reason from agent_board.session_identities where agent_id=(select agent_id from _sid_r2 where label='self')),'revoked',
+  'R2-self-revoke-state: ordinary self-revocation is not mislabelled as supersede');
+update agent_board.session_identities set resolution_state='frozen' where agent_id=(select agent_id from _sid_r2 where label='frozen');
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2 where label='owner'),true);
+set local role authenticated;
+select lives_ok($q$select agent_board.revoke_session_identity((select agent_id from _sid_r2 where label='frozen'))$q$,
+  'R2-frozen-revoke-control: human owner revokes an explicitly frozen session');
+reset role;
+select ok((select resolution_state='frozen' and tombstoned_at is not null from agent_board.session_identities where agent_id=(select agent_id from _sid_r2 where label='frozen')),
+  'R2-frozen-revoke-state: the target is both frozen and tombstoned');
+select set_config('request.jwt.claim.role','service_role',true);
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_r2_refuse(%L)',$q$select * from agent_board.mint_fleet_agent_session((select challenge_id from _sid_r2_challenge),(select nonce from _sid_r2_challenge),(select key_id from _sid_r2 where label='frozen'),(select agent_id from _sid_r2 where label='frozen'),900,null,'r2-frozen')$q$),
+  '42501','identity_tombstoned','R2-N2-1-token-precedence: tombstone takes precedence over fingerprint freeze at token mint');
+select throws_ok(format('select pg_temp.sid_r2_refuse(%L)',$q$select * from agent_board.mint_delegated_child((select agent_id from _sid_r2 where label='frozen'),'r2-forbidden','["read"]',public.test_pubkey('r2-forbidden'),interval '1 hour',false,'claude','r2-forbidden','0','[]','{"resolution":"resolved","risky_digest":"approved"}')$q$),
+  '42501','identity_tombstoned','R2-N2-1-child-precedence: tombstone takes precedence over fingerprint freeze at child mint');
+select set_config('request.jwt.claim.sub',(select auth_id::text from _sid_r2 where label='parent'),true);
+select lives_ok($q$select * from agent_board.revoke_fleet_subject('agent',(select agent_id from _sid_r2 where label='parent'),(select agent_id from _sid_r2 where label='parent'),'ancestor ledger revocation')$q$,
+  'R2-ancestor-ledger-control: real fleet self-revocation records the ancestor permanently');
+reset role;
+update agent_board.session_identities set resolution_state='frozen' where agent_id=(select agent_id from _sid_r2 where label='legacy-child');
+select ok((select a.status='active' and si.tombstoned_at is null and agent_board._actor_fleet_revoked(a.id)
+  from _sid_r2 f join agent_board.agents a on a.id=f.agent_id join agent_board.session_identities si on si.agent_id=a.id where f.label='parent'),
+  'R2-ancestor-ledger-state: active legacy ancestor is permanently revoked without physically closing its legacy descendant');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_r2_refuse(%L)',$q$select agent_board.approve_identity_state((select agent_id from _sid_r2 where label='legacy-child'),'approved','{"resolution":"resolved"}')$q$),
+  '42501','fleet_revoked: approve_identity_state is not permitted for a fleet-revoked agent','R2-N2-3-ancestor-ledger: ledger-revoked ancestor cannot approve');
+reset role;
+select is((select resolution_state from agent_board.session_identities where agent_id=(select agent_id from _sid_r2 where label='legacy-child')),'frozen',
+  'R2-ancestor-refusal-state: refused approval leaves the descendant frozen');
+-- Scanner floor: helper calls or the exact inline human.agent_type ownership
+-- spelling with auth.uid. Other aliases/joins/helpers must extend this scanner.
+-- This source-structural check does not prove arbitrary control flow.
+create temp view _sid_r2_owner_paths as
+select p.oid,p.proname,agent_board_test.stripped_body(p.oid) body
+from pg_proc p where p.pronamespace='agent_board'::regnamespace and p.prokind='f'
+  and (agent_board_test.stripped_body(p.oid) ~ agent_board_test.call_re('_session_identity_owner')
+    or (agent_board_test.stripped_body(p.oid,true) like '%human.agent_type = ''human''%'
+      and agent_board_test.stripped_body(p.oid) ~ agent_board_test.call_re('auth.uid',false)))
+  and agent_board_test.stripped_body(p.oid) ~ agent_board_test.re(
+    agent_board_test.write_frag('agents',agent_board_test.bare_ok(p.oid)) || '|'
+    || agent_board_test.write_frag('session_identities',agent_board_test.bare_ok(p.oid)) || '|'
+    || agent_board_test.call_frag('_revoke_agent_principal'));
+select ok((select count(*)>0 from _sid_r2_owner_paths),'R2-owner-class-populated: ownership writer set is catalog-derived');
+select is((select coalesce(string_agg(proname,', ' order by proname),'') from _sid_r2_owner_paths
+  where not (agent_board_test.stripped_body(oid) ~ agent_board_test.re('if\s+(not\s+)?'||agent_board_test.call_frag('_session_identity_owner'))
+    or (agent_board_test.stripped_body(oid) like '%if not exists (%'
+      and agent_board_test.stripped_body(oid) like '%human.auth_user_id = auth.uid()%'
+      and agent_board_test.stripped_body(oid) like '%target.owner_user_id = auth.uid()%'))),'',
+  'R2-owner-check-positive: every discovered writer actually uses its ownership check as an authorization condition');
+select finish();
+rollback;