@consiliency/agent-board-schema 1.60.0 → 1.63.0

package/tests/agent_board_session_identity_limits.test.sql

@@ -0,0 +1,208 @@
+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(34);
+create temp table _sid_limits_root(root_id uuid, owner_auth uuid);
+create temp table _sid_limits_minted(label text primary key, agent_id uuid, key_id uuid);
+create temp table _sid_limits_tokens(label text, epoch bigint);
+create temp table _sid_limits_history(agent_id uuid, n int);
+do $$ declare r uuid := gen_random_uuid(); u uuid; begin
+  u := public.ensure_github_user('sid-limits-' || r, 'sid-limits-' || r || '@example.test', 'sid-limits-' || r, 'Limits');
+  insert into agent_board.agents(id, agent_type, handle, display_name, status, auth_user_id, owner_user_id)
+  values (r, 'agent', 'sid-limits-' || r, 'Limits root', 'active', u, u);
+  insert into agent_board.session_identities(agent_id, root_agent_id, depth, approved_risky_digest, current_risky_digest)
+  values (r, r, 0, 'approved', 'approved');
+  insert into _sid_limits_root values (r, u);
+end $$;
+grant select on _sid_limits_root, _sid_limits_minted, _sid_limits_history to service_role;
+grant insert on _sid_limits_minted, _sid_limits_tokens to service_role;
+create function pg_temp.sid_limits_mint(p_label text, p_parent text default null)
+returns void language plpgsql as $$ declare p uuid; begin
+  p := coalesce((select agent_id from _sid_limits_minted where label = p_parent), (select root_id from _sid_limits_root));
+  insert into _sid_limits_minted
+  select p_label, child_agent_id, signing_key_id from agent_board.mint_delegated_child(p,
+    'sid-limits-' || p_label || '-' || substr(p::text, 1, 8), '[]', public.test_pubkey(p_label || p), interval '7 days', false,
+    'claude', p_label, case when p_parent is not null then '0' end, '[]', '{"resolution":"resolved","risky_digest":"approved"}');
+end $$;
+create function pg_temp.sid_limits_claim(p_label text)
+returns void language plpgsql as $$ declare m record; c record; begin
+  select * into m from _sid_limits_minted where label = p_label;
+  select * into c from agent_board.issue_signing_key_challenge(m.agent_id, 'delegated-ephemeral');
+  insert into _sid_limits_tokens select p_label, s.identity_lease_epoch from agent_board.mint_fleet_agent_session(
+    c.challenge_id, split_part(c.challenge, ':', 3), m.key_id, m.agent_id, 900, null, p_label) s;
+end $$;
+create function pg_temp.sid_limits_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_limits_mint(text, text), pg_temp.sid_limits_claim(text), pg_temp.sid_limits_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_limits_root), 'root_minted', '[]', 200, interval '7 days', true)$q$,
+  'EC-SIDSCHEMA-6-limits-policy: real sole policy writer configures the accepted root cap');
+reset role;
+select is((select max_active_children from agent_board.delegation_policies where root_agent_id = (select root_id from _sid_limits_root)), 200,
+  'EC-SIDSCHEMA-6-limits-policy-state: the policy does not restore the old 25 limit');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_limits_mint('parent'); select pg_temp.sid_limits_claim('parent'); select pg_temp.sid_limits_mint('a'); select pg_temp.sid_limits_mint('b')$q$,
+  'EC-SIDSCHEMA-6-limits-control: real mints reserve two identities and claim their depth-one parent');
+reset role;
+select is((select count(*) from _sid_limits_minted), 3::bigint, 'EC-SIDSCHEMA-6-limits-control-state: all real minted principals exist');
+-- A mixed historical census: 20 live depth-two sessions, 179 active legacy
+-- depth-one grants, and one expired legacy grant available for reactivation.
+insert into _sid_limits_history select gen_random_uuid(), n from generate_series(1, 200) n;
+insert into agent_board.agents(id, agent_type, handle, display_name, status, owner_user_id, parent_agent_id, root_agent_id)
+select h.agent_id, 'agent', 'sid-history-' || h.agent_id, 'Quota fixture', 'active', r.owner_auth,
+  case when h.n <= 20 then (select agent_id from _sid_limits_minted where label = 'parent') else r.root_id end, r.root_id
+from _sid_limits_history h cross join _sid_limits_root r;
+insert into agent_board.session_identities(agent_id, parent_agent_id, root_agent_id, depth, identity_kind, harness,
+  holder_secret_hash, last_heartbeat, approved_risky_digest, current_risky_digest, created_at)
+select h.agent_id, a.parent_agent_id, a.root_agent_id, case when h.n <= 20 then 2 else 1 end,
+  case when h.n <= 20 then 'session' else 'legacy' end, case when h.n <= 20 then 'codex' end,
+  case when h.n <= 20 then extensions.digest(h.agent_id::text, 'sha256') end,
+  case when h.n <= 20 then now() end, 'approved', 'approved', now() - interval '2 hours'
+from _sid_limits_history h join agent_board.agents a on a.id = h.agent_id;
+insert into agent_board.session_id_aliases(identity_agent_id, root_agent_id, harness, session_id)
+select h.agent_id, r.root_id, 'codex', h.agent_id::text from _sid_limits_history h cross join _sid_limits_root r where h.n <= 20;
+update agent_board.session_identities si set lease_alias_id = al.id from agent_board.session_id_aliases al
+where al.identity_agent_id = si.agent_id and si.agent_id in (select agent_id from _sid_limits_history);
+insert into agent_board.delegation_grants(child_agent_id, root_agent_id, parent_agent_id, delegation_policy_id, granted_scopes, grant_expires_at, created_at)
+select h.agent_id, r.root_id, a.parent_agent_id, dp.id, '[]',
+  case when h.n = 200 then now() - interval '1 second' else now() + interval '4 hours' end, now() - interval '2 hours'
+from _sid_limits_history h cross join _sid_limits_root r join agent_board.agents a on a.id = h.agent_id
+join agent_board.delegation_policies dp on dp.root_agent_id = r.root_id;
+create temp view _sid_live_count as
+select count(*) as total from agent_board.delegation_grants g join agent_board.agents a on a.id = g.child_agent_id
+left join agent_board.session_identities si on si.agent_id = a.id
+where g.root_agent_id = (select root_id from _sid_limits_root) and a.status = 'active' and g.revoked_at is null and g.grant_expires_at > now()
+and (si.identity_kind is distinct from 'session' or agent_board._session_identity_lease_live(a.id));
+select is((select total from _sid_live_count), 200::bigint,
+  'EC-SIDSCHEMA-6-depth-two-census: root boundary includes all 20 live depth-two identities plus legacy grants');
+select is((select count(*) from agent_board.session_identities where root_agent_id = (select root_id from _sid_limits_root) and identity_kind = 'session' and holder_secret_hash is null), 2::bigint,
+  'EC-SIDSCHEMA-6-unclaimed-census: both reservations hold no active lease');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_limits_refuse(%L)', $q$select pg_temp.sid_limits_claim('a')$q$),
+  '42501', 'identity_limit_active_exceeded', 'EC-SIDSCHEMA-6-first-claim-limit: first claim recounts the mixed descendant-wide active boundary');
+select throws_ok(format('select pg_temp.sid_limits_refuse(%L)', $q$select agent_board.renew_delegated_grant((select agent_id from _sid_limits_history where n = 200), interval '1 hour')$q$),
+  '42501', 'identity_limit_active_exceeded', 'EC-SIDSCHEMA-6-expired-renew-limit: expired legacy renewal cannot reactivate past the active limit');
+reset role;
+update agent_board.agents set status = 'suspended' where id = (select agent_id from _sid_limits_history where n = 199);
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_limits_claim('a')$q$, 'EC-SIDSCHEMA-6-first-below-control: the same real first claim succeeds at 199 active identities');
+reset role;
+select is((select total from _sid_live_count), 200::bigint, 'EC-SIDSCHEMA-6-first-below-state: first claim reaches exactly 200, not 25');
+select is((select epoch from _sid_limits_tokens where label = 'a'), 0::bigint, 'EC-SIDSCHEMA-6-first-epoch: below-limit first claim holds its original epoch');
+update agent_board.session_identities set last_heartbeat = now() - interval '181 seconds' where agent_id = (select agent_id from _sid_limits_minted where label = 'a');
+update agent_board.agents set status = 'active' where id = (select agent_id from _sid_limits_history where n = 199);
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_limits_refuse(%L)', $q$select pg_temp.sid_limits_claim('a')$q$),
+  '42501', 'identity_limit_active_exceeded', 'EC-SIDSCHEMA-6-reclaim-limit: lapsed holder reclaim recounts rather than bypassing the active cap');
+reset role;
+select is((select credential_epoch from agent_board.session_identities where agent_id = (select agent_id from _sid_limits_minted where label = 'a')), 0::bigint,
+  'EC-SIDSCHEMA-6-reclaim-refusal-state: refused reclaim never rotates the holder epoch');
+update agent_board.agents set status = 'suspended' where id = (select agent_id from _sid_limits_history where n = 199);
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_limits_claim('a')$q$, 'EC-SIDSCHEMA-6-reclaim-below-control: the real continuity reclaim succeeds below the cap');
+reset role;
+select is((select max(epoch) from _sid_limits_tokens where label = 'a'), 1::bigint, 'EC-SIDSCHEMA-6-reclaim-below-state: allowed reclaim rotates the epoch once');
+update agent_board.session_identities set last_heartbeat = now() - interval '181 seconds' where agent_id = (select agent_id from _sid_limits_minted where label = 'a');
+set local role service_role;
+select lives_ok($q$select agent_board.renew_delegated_grant((select agent_id from _sid_limits_history where n = 200), interval '1 hour')$q$,
+  'EC-SIDSCHEMA-6-expired-below-control: real expired legacy renewal succeeds below the mixed cap');
+reset role;
+select is((select total from _sid_live_count), 200::bigint, 'EC-SIDSCHEMA-6-expired-below-state: expired renewal consumes the last active slot');
+update agent_board.agents set status = 'suspended' where id in (select agent_id from _sid_limits_history where n > 20);
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_limits_refuse(%L)', $q$select pg_temp.sid_limits_mint('over-parent', 'parent')$q$),
+  '42501', 'identity_limit_active_exceeded', 'EC-SIDSCHEMA-6-parent-active: depth-one parent refuses its twenty-first active child');
+reset role;
+update agent_board.session_identities set last_heartbeat = now() - interval '181 seconds' where agent_id = (select agent_id from _sid_limits_history where n = 20);
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_limits_mint('under-parent', 'parent'); select pg_temp.sid_limits_claim('under-parent')$q$,
+  'EC-SIDSCHEMA-6-parent-below-control: a real depth-two mint and claim take the twentieth parent slot');
+reset role;
+select is((select depth from agent_board.session_identities where agent_id = (select agent_id from _sid_limits_minted where label = 'under-parent')), 2::smallint,
+  'EC-SIDSCHEMA-6-parent-below-state: the allowed child has actual stored depth two');
+update agent_board.delegation_grants set created_at = now() - interval '2 hours' where root_agent_id = (select root_id from _sid_limits_root);
+update agent_board.delegation_grants set created_at = now(), revoked_at = now()
+where child_agent_id in (select agent_id from _sid_limits_history where n between 21 and 79);
+select is((select count(*) from agent_board.delegation_grants where root_agent_id = (select root_id from _sid_limits_root) and created_at > now() - interval '3600 seconds'), 59::bigint,
+  'EC-SIDSCHEMA-6-hourly-fixture: 59 revoked historical mints still consume the root rolling hour');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_limits_mint('hour-allowed')$q$,
+  'EC-SIDSCHEMA-6-hourly-sixty-control: a real root mint takes the sixtieth hourly slot, beyond the old 25 limit');
+reset role;
+select is((select count(*) from agent_board.delegation_grants where root_agent_id = (select root_id from _sid_limits_root) and created_at > now() - interval '3600 seconds'), 60::bigint,
+  'EC-SIDSCHEMA-6-hourly-sixty-state: root hourly accounting reaches exactly sixty');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_limits_refuse(%L)', $q$select pg_temp.sid_limits_mint('hour-refused')$q$),
+  '42501', 'identity_limit_hourly_exceeded', 'EC-SIDSCHEMA-6-hourly-root: sixty-first mint refuses by the accepted root code');
+reset role;
+select is((select count(*) from _sid_limits_minted where label = 'hour-refused'), 0::bigint,
+  'EC-SIDSCHEMA-6-hourly-refusal-state: hourly refusal provisions no identity');
+update agent_board.delegation_grants set created_at = now() - interval '2 hours' where root_agent_id = (select root_id from _sid_limits_root);
+update agent_board.delegation_grants set created_at = now()
+where child_agent_id in (select agent_id from _sid_limits_history where n between 1 and 10);
+update agent_board.session_identities set last_heartbeat = now() - interval '181 seconds' where agent_id = (select agent_id from _sid_limits_minted where label = 'under-parent');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_limits_refuse(%L)', $q$select pg_temp.sid_limits_mint('hour-parent-refused', 'parent')$q$),
+  '42501', 'identity_limit_hourly_exceeded', 'EC-SIDSCHEMA-6-hourly-parent: depth-one parent counts all ten depth-two mints in its hour');
+reset role;
+select is((select count(*) from _sid_limits_minted where label = 'hour-parent-refused'), 0::bigint,
+  'EC-SIDSCHEMA-6-hourly-parent-state: parent hourly refusal leaves no new principal');
+-- The quota/activation writer population comes from column writes in the
+-- catalog. Named-call closure also includes wrappers; no hand RPC exemption.
+create temp view _sid_activation_writers as
+select p.oid, p.proname, agent_board_test.stripped_body(p.oid) as body
+from pg_proc p where p.pronamespace = 'agent_board'::regnamespace
+  and (agent_board_test.stripped_body(p.oid) ~ agent_board_test.col_write_re('delegation_grants', 'grant_expires_at')
+    or agent_board_test.stripped_body(p.oid) ~ agent_board_test.col_write_re('session_identities', 'holder_secret_hash'));
+select is((select string_agg(proname, ', ' order by proname) from _sid_activation_writers),
+  '_session_identity_agent_lineage, mint_delegated_child, mint_fleet_agent_session, readmit_session_identity, renew_delegated_grant',
+  'EC-SIDSCHEMA-6-activation-population: every discovered expiry or holder writer has a positive activation path');
+-- An INSERT is conservatively a writer of defaulted columns too. This one
+-- writes a legacy/default-NULL identity, not a live holder or grant. Prove the
+-- exemption through the real constructor, separately from the absence class.
+create temp table _sid_limits_constructor(agent_id uuid);
+grant insert,select on _sid_limits_constructor to service_role;
+set local role service_role;
+select lives_ok($$insert into _sid_limits_constructor select agent_id from agent_board.register_agent('system',
+  'sid-limit-constructor-' || gen_random_uuid(),'Quota-free legacy constructor'); set constraints all immediate$$,
+  'EC-SIDSCHEMA-6-constructor-control: real registration and deferred legacy identity construction execute');
+reset role;
+select is((select count(*) from _sid_limits_constructor c join agent_board.session_identities si on si.agent_id=c.agent_id
+  where si.identity_kind='legacy' and si.holder_secret_hash is null and si.last_heartbeat is null and si.lease_alias_id is null),
+  1::bigint,'EC-SIDSCHEMA-6-constructor-state: the positively exempt constructor writes only a lease-free legacy identity');
+select is((select count(*) from agent_board.delegation_grants g join _sid_limits_constructor c on c.agent_id=g.child_agent_id),
+  0::bigint,'EC-SIDSCHEMA-6-constructor-grant-state: construction creates no grant or expiry and cannot activate a quota slot');
+create temp view _sid_unlocked_activation as
+select * from _sid_activation_writers
+where oid<>'agent_board._session_identity_agent_lineage()'::regprocedure and (
+  regexp_instr(body, agent_board_test.row_lock_re('agents')) = 0
+  or regexp_instr(body, agent_board_test.row_lock_re('agents')) >= least(
+    nullif(regexp_instr(body, agent_board_test.col_write_re('delegation_grants', 'grant_expires_at')), 0),
+    nullif(regexp_instr(body, agent_board_test.col_write_re('session_identities', 'holder_secret_hash')), 0)));
+create temp view _sid_unlocked_activation_class as
+select distinct c.root_name from agent_board_test.fn_call_closure() c
+join _sid_unlocked_activation u on u.oid = c.reached_oid;
+select is((select coalesce(string_agg(root_name, ', ' order by root_name), '') from _sid_unlocked_activation_class), '',
+  'EC-SIDSCHEMA-6-root-lock-class: every discovered activation writer and wrapper locks the root before its census-changing write');
+create function agent_board.sid_unlocked_activation_probe(p_child uuid)
+returns void language sql security definer set search_path = '' as $probe$
+  /* SELECT id FROM agent_board.agents FOR UPDATE; */
+  UPDATE agent_board.delegation_grants SET grant_expires_at = now() + interval '1 hour' WHERE child_agent_id = p_child;
+$probe$;
+create function agent_board.sid_unlocked_activation_wrapper(p_child uuid)
+returns void language sql security definer set search_path = '' as $probe$
+  SELECT agent_board.sid_unlocked_activation_probe(/* wrapper */ p_child);
+$probe$;
+select is((select string_agg(root_name, ', ' order by root_name) from _sid_unlocked_activation_class
+  where root_name in ('sid_unlocked_activation_probe', 'sid_unlocked_activation_wrapper')),
+  'sid_unlocked_activation_probe, sid_unlocked_activation_wrapper',
+  'EC-SIDSCHEMA-6-root-lock-canary: new uppercase unguarded writer and commented wrapper name themselves');
+select is((select proname from _sid_unlocked_activation where proname = 'sid_unlocked_activation_probe'), 'sid_unlocked_activation_probe',
+  'EC-SIDSCHEMA-6-root-lock-decoy: a comment cannot masquerade as an executable accounting lock');
+select finish();
+rollback;

package/tests/agent_board_session_identity_lineage.test.sql

@@ -0,0 +1,64 @@
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+begin;
+select plan(8);
+grant usage on schema extensions to service_role, authenticated;
+create temp table _sid_lineage_ids(label text primary key, agent_id uuid);
+insert into _sid_lineage_ids select label,gen_random_uuid() from unnest(array['root','other-root','child','grandchild']) label;
+insert into agent_board.agents(id,agent_type,handle,display_name,status,parent_agent_id,root_agent_id)
+select agent_id,'system','sid-lineage-' || agent_id,'Lineage fixture','active',null,null
+from _sid_lineage_ids where label in ('root','other-root');
+insert into agent_board.agents(id,agent_type,handle,display_name,status,parent_agent_id,root_agent_id)
+select agent_id,'system','sid-lineage-' || agent_id,'Lineage fixture','active',
+  (select agent_id from _sid_lineage_ids where label='root'),(select agent_id from _sid_lineage_ids where label='root')
+from _sid_lineage_ids where label='child';
+insert into agent_board.agents(id,agent_type,handle,display_name,status,parent_agent_id,root_agent_id)
+select agent_id,'system','sid-lineage-' || agent_id,'Lineage fixture','active',
+  (select agent_id from _sid_lineage_ids where label='child'),(select agent_id from _sid_lineage_ids where label='root')
+from _sid_lineage_ids where label='grandchild';
+insert into agent_board.session_identities(agent_id,parent_agent_id,root_agent_id,depth)
+select a.id,a.parent_agent_id,coalesce(a.root_agent_id,a.id),
+  case l.label when 'child' then 1 when 'grandchild' then 2 else 0 end
+from agent_board.agents a join _sid_lineage_ids l on l.agent_id=a.id;
+select lives_ok('set constraints all immediate','EC-SIDSCHEMA-1-lineage-control: valid depth-zero, one and two lineage commits its constraints');
+select is((select count(*) from agent_board.session_identities where agent_id in (select agent_id from _sid_lineage_ids)),4::bigint,
+  'EC-SIDSCHEMA-1-lineage-control-state: every fixture has exactly one identity');
+create function pg_temp.sid_lineage_bad(p_mode text) returns void language plpgsql as $$
+begin
+  set constraints all deferred;
+  if p_mode='agent-update' then
+    update agent_board.agents set root_agent_id=(select agent_id from _sid_lineage_ids where label='other-root')
+    where id=(select agent_id from _sid_lineage_ids where label='child');
+  elsif p_mode='missing-parent' then
+    delete from agent_board.session_identities where agent_id=(select agent_id from _sid_lineage_ids where label='root');
+    update agent_board.session_identities set depth=depth where agent_id=(select agent_id from _sid_lineage_ids where label='child');
+  elsif p_mode='cycle' then
+    update agent_board.agents set parent_agent_id=(select agent_id from _sid_lineage_ids where label='grandchild')
+    where id=(select agent_id from _sid_lineage_ids where label='child');
+  end if;
+  set constraints all immediate;
+  raise exception 'expected lineage refusal but change succeeded' using errcode='P0001';
+end $$;
+select throws_ok($$select pg_temp.sid_lineage_bad('agent-update')$$,'23514','session identity lineage mismatch',
+  'EC-SIDSCHEMA-1-lineage-agent-update: agents lineage cannot diverge from its identity');
+select throws_ok($$select pg_temp.sid_lineage_bad('missing-parent')$$,'23514','session identity lineage mismatch',
+  'EC-SIDSCHEMA-1-lineage-missing-parent: a missing identity parent is refused, never a NULL comparison');
+select throws_ok($$select pg_temp.sid_lineage_bad('cycle')$$,'23514',null,
+  'EC-SIDSCHEMA-1-lineage-cycle: agent lineage cannot become cyclic');
+select ok((select a.parent_agent_id=si.parent_agent_id and a.root_agent_id=si.root_agent_id from agent_board.agents a
+  join agent_board.session_identities si on si.agent_id=a.id where a.id=(select agent_id from _sid_lineage_ids where label='child')),
+  'EC-SIDSCHEMA-1-lineage-refusal-state: every refused mutation rolls back both lineages');
+create temp table _sid_lineage_registered(agent_id uuid);
+grant insert,select on _sid_lineage_registered to service_role;
+select set_config('request.jwt.claim.role','service_role',true);
+set local role service_role;
+select lives_ok($$insert into _sid_lineage_registered select agent_id from agent_board.register_agent('system',
+  'sid-lineage-registered-' || gen_random_uuid(),'Registered lineage'); set constraints all immediate$$,
+  'EC-SIDSCHEMA-1-lineage-constructor: the real legacy registration path commits without a session lease');
+reset role;
+select is((select identity_kind || '/' || depth::text || '/' || (holder_secret_hash is null)::text || '/' ||
+  (approved_risky_digest is null)::text || '/' || (forked_from is null and readmitted_from is null and lease_alias_id is null)::text
+  from agent_board.session_identities where agent_id=(select agent_id from _sid_lineage_registered)),
+  'legacy/0/true/true/true','EC-SIDSCHEMA-1-lineage-constructor-state: future legacy principals have an identity but no implicit lease, approval or continuity links');
+select finish();
+rollback;

package/tests/agent_board_session_identity_link.test.sql

@@ -0,0 +1,201 @@
+-- Enter the installed service boundary with a forwarded verified holder subject
+-- and epoch. Authority changes use real policy/board RPCs, never a declared flag.
+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(41);
+create temp table _sid_link_root(root_id uuid, root_auth uuid, owner_auth uuid, room_a uuid, room_b uuid, room_c uuid, suffix text);
+create temp table _sid_link_children(label text primary key, agent_id uuid, key_id uuid, auth_id uuid);
+create temp table _sid_link_tokens(label text, epoch bigint);
+create temp table _sid_link_watermark(seq bigint);
+do $$
+declare v_root uuid := gen_random_uuid(); v_auth uuid; v_owner uuid;
+  v_a uuid := gen_random_uuid(); v_b uuid := gen_random_uuid(); v_c uuid := gen_random_uuid(); v_board uuid;
+begin
+  v_owner := public.ensure_github_user('sid-link-owner-' || v_root, 'sid-link-owner-' || v_root || '@example.test', 'sid-link-owner-' || v_root, 'SID owner');
+  v_auth := public.ensure_github_user('sid-link-root-' || v_root, 'sid-link-root-' || v_root || '@example.test', 'sid-link-root-' || v_root, 'SID root');
+  insert into agent_board.agents(agent_type, handle, display_name, status, auth_user_id)
+  values ('human', 'sid-link-owner-' || v_root, 'SID owner', 'active', v_owner);
+  insert into agent_board.agents(id, agent_type, handle, display_name, status, auth_user_id, owner_user_id)
+  values (v_root, 'agent', 'sid-link-root-' || v_root, 'SID root', 'active', v_auth, v_owner);
+  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');
+  foreach v_board in array array[v_a, v_b, v_c] loop
+    insert into agent_board.boards(id, slug, name, created_by_agent_id)
+    values (v_board, 'sid-link-' || v_board, 'SID link 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 agent_board.board_memberships(board_id, agent_id, membership_state, role)
+    select v_board, id, 'joined', 'owner' from agent_board.agents where auth_user_id = v_owner;
+  end loop;
+  insert into _sid_link_root values (v_root, v_auth, v_owner, v_a, v_b, v_c, substr(v_root::text, 1, 8));
+end;
+$$;
+grant select on _sid_link_root, _sid_link_children, _sid_link_tokens to service_role;
+grant insert on _sid_link_children, _sid_link_tokens to service_role;
+create function pg_temp.sid_link_mint(p_label text, p_parent text default null)
+returns void language plpgsql as $$
+declare v_root record; v_parent uuid; v_result record;
+begin
+  select * into v_root from _sid_link_root;
+  v_parent := coalesce((select agent_id from _sid_link_children where label = p_parent), v_root.root_id);
+  select * into v_result from agent_board.mint_delegated_child(v_parent, 'sid-link-' || p_label || '-' || v_root.suffix,
+    '["read","write"]', public.test_pubkey(v_root.suffix || p_label), interval '8 hours', false, 'claude', 'sid-link-' || p_label,
+    case when p_parent is null then null else '0' end,
+    jsonb_build_array(jsonb_build_object('board_id', v_root.room_a, 'role', 'admin'), jsonb_build_object('board_id', v_root.room_b, 'role', 'admin')),
+    '{"resolution":"resolved","risky_digest":"approved"}');
+  insert into _sid_link_children select p_label, v_result.child_agent_id, v_result.signing_key_id, a.auth_user_id
+    from agent_board.agents a where a.id = v_result.child_agent_id;
+end;
+$$;
+create function pg_temp.sid_link_claim(p_label text)
+returns void language plpgsql as $$
+declare v_child record; v_challenge record;
+begin
+  select * into v_child from _sid_link_children where label = p_label;
+  select * into v_challenge from agent_board.issue_signing_key_challenge(v_child.agent_id, 'delegated-ephemeral');
+  insert into _sid_link_tokens select p_label, 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, 'sid-link-' || p_label) m;
+end;
+$$;
+create function pg_temp.sid_link(p_actor text, p_target text, p_alias text)
+returns void language plpgsql as $$
+begin
+  perform set_config('request.jwt.claim.sub', (select auth_id::text from _sid_link_children where label = p_actor), true);
+  perform set_config('request.jwt.claim.identity_lease_epoch', (select epoch::text from _sid_link_tokens where label = p_actor), true);
+  perform agent_board.link_session_alias((select agent_id from _sid_link_children where label = p_target),
+    (select epoch::text from _sid_link_tokens where label = p_actor), p_alias);
+end;
+$$;
+create function pg_temp.sid_link_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_link_mint(text,text), pg_temp.sid_link_claim(text), pg_temp.sid_link(text,text,text), pg_temp.sid_link_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_link_root), 'root_minted', '["read","write"]', 200, interval '7 days', true)$q$,
+  'EC-SIDSCHEMA-3-policy: real root policy permits the authority fixture');
+reset role;
+select is((select count(*) from agent_board.delegation_policies where root_agent_id = (select root_id from _sid_link_root)), 1::bigint,
+  'EC-SIDSCHEMA-3-policy-state: one policy exists');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_link_mint('parent'); select pg_temp.sid_link_claim('parent'); select pg_temp.sid_link_mint('child', 'parent'); select pg_temp.sid_link_claim('child'); select pg_temp.sid_link_mint('sibling'); select pg_temp.sid_link_claim('sibling')$q$,
+  'EC-SIDSCHEMA-3-fixture: real parent, descendant and unrelated sibling hold proved leases');
+reset role;
+select is((select count(*) from _sid_link_tokens where epoch = 0), 3::bigint, 'EC-SIDSCHEMA-3-fixture-state: all three holder contexts exist');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_link_refuse(%L)', $q$select pg_temp.sid_link('sibling', 'parent', 'unrelated')$q$),
+  '42501', 'identity_lease_not_held', 'EC-SIDSCHEMA-3-unrelated: another identity credential cannot link this identity');
+reset role;
+select is((select count(*) from agent_board.session_id_aliases where root_agent_id = (select root_id from _sid_link_root) and session_id = 'unrelated'), 0::bigint,
+  'EC-SIDSCHEMA-3-unrelated-state: refusal creates no alias');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_link('parent', 'parent', 'before-shrink')$q$, 'EC-SIDSCHEMA-3-link-control: the actual holder links under unchanged authority');
+reset role;
+select is((select count(*) from agent_board.session_id_aliases where identity_agent_id = (select agent_id from _sid_link_children where label = 'parent')), 2::bigint,
+  'EC-SIDSCHEMA-3-link-state: holder creates exactly one new alias');
+set local role service_role;
+select lives_ok($q$select agent_board.upsert_delegation_policy((select root_id from _sid_link_root), 'root_minted', '["read"]', 200, interval '7 days', true);
+  select agent_board.grant_board_role((select room_a from _sid_link_root), (select root_id from _sid_link_root), 'observer', (select root_id from _sid_link_root));
+  select agent_board._upsert_board_membership_state((select room_b from _sid_link_root), (select root_id from _sid_link_root), 'left')$q$,
+  'EC-SIDSCHEMA-3-parent-shrink-control: real authority paths narrow policy, role and room');
+reset role;
+select is((select allowed_scopes from agent_board.delegation_policies where root_agent_id = (select root_id from _sid_link_root)), '["read"]'::jsonb,
+  'EC-SIDSCHEMA-3-parent-shrink-state: current policy is narrower');
+insert into _sid_link_watermark select coalesce(max(seq), 0) from agent_board.board_membership_events;
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_link('parent', 'parent', 'after-shrink')$q$, 'EC-SIDSCHEMA-3-shrink-control: holder link rechecks changed authority');
+reset role;
+select is((select granted_scopes from agent_board.delegation_grants where child_agent_id = (select agent_id from _sid_link_children where label = 'parent')), '["read"]'::jsonb,
+  'EC-SIDSCHEMA-3-shrink-scopes: link intersects original scopes with current parent authority');
+select is((select role from agent_board.board_memberships where board_id = (select room_a from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'parent')), 'observer',
+  'EC-SIDSCHEMA-3-shrink-role: link downgrades the identity role');
+select is((select membership_state from agent_board.board_memberships where board_id = (select room_b from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'parent')), 'removed',
+  'EC-SIDSCHEMA-3-shrink-room: link revokes a room the parent lost');
+select is((select granted_scopes from agent_board.delegation_grants where child_agent_id = (select agent_id from _sid_link_children where label = 'child')), '["read"]'::jsonb,
+  'EC-SIDSCHEMA-3-descendant-scopes: narrowing cascades to depth two');
+select is((select role from agent_board.board_memberships where board_id = (select room_a from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'child')), 'observer',
+  'EC-SIDSCHEMA-3-descendant-role: descendant role narrows with its parent');
+select is((select membership_state from agent_board.board_memberships where board_id = (select room_b from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'child')), 'removed',
+  'EC-SIDSCHEMA-3-descendant-room: descendant loses the revoked room');
+select is((select count(*) from agent_board.board_membership_events where seq > (select seq from _sid_link_watermark)
+  and board_id = (select room_b from _sid_link_root) and agent_id in (select agent_id from _sid_link_children where label in ('parent','child'))
+  and provenance = 'operator-designated' and actor_agent_id is null and result_state = 'removed'), 2::bigint,
+  'EC-SIDSCHEMA-3-consent: consent sink derives operator provenance for each removal from the service session');
+select is((select granted_scopes from agent_board.delegation_grants where child_agent_id = (select agent_id from _sid_link_children where label = 'sibling')), '["read","write"]'::jsonb,
+  'EC-SIDSCHEMA-3-unrelated-preserved: linking one lineage never changes a sibling');
+select is((select count(*) from agent_board.board_memberships where board_id = (select room_c from _sid_link_root) and agent_id in (select agent_id from _sid_link_children)), 0::bigint,
+  'EC-SIDSCHEMA-3-no-default-room: link does not grant another parent room');
+-- Operator can widen the parent later, but this identity has permanently lost authority.
+set local role service_role;
+select lives_ok($q$select agent_board.upsert_delegation_policy((select root_id from _sid_link_root), 'root_minted', '["read","write"]', 200, interval '7 days', true);
+  select agent_board.grant_board_role((select room_a from _sid_link_root), (select root_id from _sid_link_root), 'owner',
+    (select id from agent_board.agents where auth_user_id = (select owner_auth from _sid_link_root)));
+  select agent_board._upsert_board_membership_state((select room_b from _sid_link_root), (select root_id from _sid_link_root), 'joined')$q$,
+  'EC-SIDSCHEMA-3-widen-control: current parent authority widens through its actual operators');
+reset role;
+select is((select allowed_scopes from agent_board.delegation_policies where root_agent_id = (select root_id from _sid_link_root)), '["read","write"]'::jsonb,
+  'EC-SIDSCHEMA-3-widen-state: parent regained scopes');
+set local role service_role;
+select lives_ok($q$select pg_temp.sid_link('parent', 'parent', 'after-widen')$q$, 'EC-SIDSCHEMA-3-no-regrant-control: holder links again after widening');
+reset role;
+select is((select granted_scopes from agent_board.delegation_grants where child_agent_id = (select agent_id from _sid_link_children where label = 'parent')), '["read"]'::jsonb,
+  'EC-SIDSCHEMA-3-no-regrant-scopes: widened parent cannot restore removed scopes');
+select is((select role from agent_board.board_memberships where board_id = (select room_a from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'parent')), 'observer',
+  'EC-SIDSCHEMA-3-no-regrant-role: widened parent cannot restore a higher role');
+select is((select membership_state from agent_board.board_memberships where board_id = (select room_b from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'parent')), 'removed',
+  'EC-SIDSCHEMA-3-no-regrant-room: widened parent cannot restore a removed room');
+select is((select granted_scopes from agent_board.delegation_grants where child_agent_id = (select agent_id from _sid_link_children where label = 'child')), '["read"]'::jsonb,
+  'EC-SIDSCHEMA-3-no-regrant-descendant: descendants retain their narrowed scope');
+select is((select count(*) from agent_board.session_id_aliases where identity_agent_id = (select agent_id from _sid_link_children where label = 'parent')), 4::bigint,
+  'EC-SIDSCHEMA-3-final-aliases: all three legitimate links map to one persistent identity');
+select is((select credential_epoch from agent_board.session_identities where agent_id = (select agent_id from _sid_link_children where label = 'parent')), 0::bigint,
+  'EC-SIDSCHEMA-3-stable-identity: authority shrink never rotates the live holder epoch');
+select is((select count(*) from agent_board.board_membership_events where seq > (select seq from _sid_link_watermark)
+  and board_id = (select room_b from _sid_link_root) and agent_id in (select agent_id from _sid_link_children where label in ('parent','child'))), 2::bigint,
+  'EC-SIDSCHEMA-3-append-only: repeated links neither rewrite removal events nor emit phantom removals');
+select ok((select agent_board_test.stripped_body('agent_board.link_session_alias(uuid,text,text)'::regprocedure)
+  ~ agent_board_test.row_lock_re('session_identities')),
+  'EC-SIDSCHEMA-3-identity-lock: deployed linker takes identity row locks as well as the root mutex');
+select ok((select agent_board_test.stripped_body('agent_board.link_session_alias(uuid,text,text)'::regprocedure)
+  ~ agent_board_test.row_lock_re('session_id_aliases')),
+  'EC-SIDSCHEMA-3-alias-lock: deployed linker locks an existing alias before rebinding it');
+insert into agent_board.fleet_revocation_events(subject_kind, subject_id, agent_id, revoked_by_agent_id, revocation_reason)
+select 'agent', root_id, root_id, root_id, 'sid-parent-ledger-control' from _sid_link_root;
+select is((select status from agent_board.agents where id = (select root_id from _sid_link_root)), 'active',
+  'EC-SIDSCHEMA-3-ledger-control: ledger-only parent revocation leaves the principal status active');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_link_refuse(%L)', $q$select pg_temp.sid_link('parent', 'parent', 'ledger-parent')$q$),
+  '42501', 'identity_parent_inactive', 'EC-SIDSCHEMA-3-ledger-ancestor: link refuses a ledger-revoked ancestor even while status and grants are active');
+select throws_ok(format('select pg_temp.sid_link_refuse(%L)', $q$select agent_board.mint_delegated_child((select root_id from _sid_link_root), 'sid-ledger-legacy-' || (select suffix from _sid_link_root), '["read"]', public.test_pubkey('sid-ledger-legacy'))$q$),
+  '42501', 'fleet_revoked: mint_delegated_child is not permitted for a fleet-revoked agent',
+  'EC-SIDSCHEMA-2-ledger-legacy: legacy mint cannot bypass the parent ledger through its no-session path');
+reset role;
+select is((select count(*) from agent_board.session_id_aliases where root_agent_id = (select root_id from _sid_link_root) and session_id = 'ledger-parent'), 0::bigint,
+  'EC-SIDSCHEMA-3-ledger-ancestor-state: parent refusal creates no alias');
+select is((select count(*) from agent_board.agents where handle = 'sid-ledger-legacy-' || (select suffix from _sid_link_root)), 0::bigint,
+  'EC-SIDSCHEMA-2-ledger-legacy-state: failed legacy mint leaves no principal');
+delete from agent_board.fleet_revocation_events where revocation_reason = 'sid-parent-ledger-control'
+  and subject_id = (select root_id from _sid_link_root);
+insert into agent_board.fleet_revocation_events(subject_kind, subject_id, agent_id, revoked_by_agent_id, revocation_reason)
+select 'agent', agent_id, agent_id, (select root_id from _sid_link_root), 'sid-holder-ledger-control'
+from _sid_link_children where label = 'parent';
+select is((select status from agent_board.agents where id = (select agent_id from _sid_link_children where label = 'parent')), 'active',
+  'EC-SIDSCHEMA-3-ledger-holder-control: ledger-only holder revocation does not change its active status');
+set local role service_role;
+select throws_ok(format('select pg_temp.sid_link_refuse(%L)', $q$select pg_temp.sid_link('parent', 'parent', 'ledger-holder')$q$),
+  '42501', 'fleet_revoked: link_session_alias is not permitted for a fleet-revoked agent',
+  'EC-SIDSCHEMA-3-ledger-holder: verified holder cannot bind an alias after permanent ledger revocation');
+reset role;
+select is((select count(*) from agent_board.session_id_aliases where root_agent_id = (select root_id from _sid_link_root) and session_id = 'ledger-holder'), 0::bigint,
+  'EC-SIDSCHEMA-3-ledger-holder-state: late ledger gate rolls back the alias write');
+select is((select role from agent_board.board_memberships where board_id = (select room_a from _sid_link_root) and agent_id = (select agent_id from _sid_link_children where label = 'parent')), 'observer',
+  'EC-SIDSCHEMA-3-ledger-authority-state: refusal leaves narrowed membership authority unchanged');
+select finish();
+rollback;