@consiliency/agent-board-schema 1.22.0 → 1.24.0

package/tests/isolation/specs/atomic_fleet_onboarding.spec

@@ -0,0 +1,106 @@
+# Consiliency/message-board#162 — two first composed fleet onboardings for one
+# bounded invite serialize and converge on the same complete authority chain.
+
+setup
+{
+  insert into agent_board.agents(id, agent_type, kind, handle, display_name, status)
+  values ('16220000-0000-0000-0000-000000000001', 'agent', 'agent',
+          'atomic-race-owner', 'Atomic Race Owner', 'active');
+
+  select count(*) from agent_board.create_board(
+    '16220000-0000-0000-0000-000000000001',
+    'atomic-race-board', 'Atomic Race Board',
+    'Consiliency/message-board#162 isolation proof', jsonb_build_object(), 'private'
+  );
+
+  insert into agent_board.fleet_trust_domains(
+    id, slug, display_name, domain_kind, owner_agent_id, lifecycle_state, approved_at
+  ) values (
+    '16220000-0000-0000-0000-000000000002', 'atomic-race-domain',
+    'Atomic Race Domain', 'tailnet', '16220000-0000-0000-0000-000000000001',
+    'active', now()
+  );
+  insert into agent_board.fleet_machines(
+    id, trust_domain_id, owner_agent_id, machine_label, machine_fingerprint,
+    lifecycle_state, enrollment_source, enrolled_at
+  ) values (
+    '16220000-0000-0000-0000-000000000003',
+    '16220000-0000-0000-0000-000000000002',
+    '16220000-0000-0000-0000-000000000001',
+    'claw', 'sha256:atomic-race-machine', 'active', 'portal', now()
+  );
+  insert into agent_board.identity_providers(
+    issuer, audience, supported, policy_approved,
+    allowed_scopes, allowed_board_scopes, allowed_agent_kinds
+  ) values (
+    'https://atomic-race.test', 'message-board', true, true,
+    ARRAY['board:send'], ARRAY[]::text[], ARRAY['agent']
+  );
+  select count(*) from agent_board.create_fleet_onboarding_invite(
+    (select id from agent_board.boards where slug = 'atomic-race-board'),
+    '16220000-0000-0000-0000-000000000003',
+    'codex', 'phase-loop', 'message-board', 'sha256:atomic-race-repo',
+    'worker', 'phase_worker', 'atomic-race-agent', 1,
+    now() + interval '1 hour', '16220000-0000-0000-0000-000000000001',
+    jsonb_build_object()
+  );
+}
+
+session "first"
+step "first_begin" { BEGIN; SET LOCAL "request.jwt.claim.role" = 'service_role'; }
+step "first_onboard" {
+  select identity_disposition, membership_disposition, binding_disposition
+    from agent_board.onboard_federated_fleet_agent(
+      'https://atomic-race.test', 'message-board', 'human-race',
+      jsonb_build_object('iss','https://atomic-race.test','aud','message-board','sub','human-race','iat',100),
+      'atomic-race-agent',
+      'eRHZmllEy_TZHAG2zB-Qe_a5BFLkaavMTazWWfaE3f0',
+      'raw_ed25519_base64url',
+      'sha256:z8d5LQPfBMYnfZfvu8wVz684_jkp578-SPDU2OMObS8',
+      true, null, 'agent', ARRAY['board:send'], ARRAY[]::text[],
+      (select code from agent_board.board_invite_tokens where created_by_agent_id = '16220000-0000-0000-0000-000000000001'),
+      (select id from agent_board.boards where slug = 'atomic-race-board'),
+      '16220000-0000-0000-0000-000000000003',
+      'codex', 'phase-loop', 'message-board', 'sha256:atomic-race-repo',
+      'worker', 'phase_worker', 'atomic-race-agent'
+    );
+}
+step "first_commit" { COMMIT; }
+
+session "second"
+step "second_begin" { BEGIN; SET LOCAL "request.jwt.claim.role" = 'service_role'; }
+step "second_onboard" {
+  select identity_disposition, membership_disposition, binding_disposition
+    from agent_board.onboard_federated_fleet_agent(
+      'https://atomic-race.test', 'message-board', 'human-race',
+      jsonb_build_object('iss','https://atomic-race.test','aud','message-board','sub','human-race','iat',200,'jti','rotated'),
+      'atomic-race-agent',
+      'eRHZmllEy_TZHAG2zB-Qe_a5BFLkaavMTazWWfaE3f0',
+      'raw_ed25519_base64url',
+      'sha256:z8d5LQPfBMYnfZfvu8wVz684_jkp578-SPDU2OMObS8',
+      true, null, 'agent', ARRAY['board:send'], ARRAY[]::text[],
+      (select code from agent_board.board_invite_tokens where created_by_agent_id = '16220000-0000-0000-0000-000000000001'),
+      (select id from agent_board.boards where slug = 'atomic-race-board'),
+      '16220000-0000-0000-0000-000000000003',
+      'codex', 'phase-loop', 'message-board', 'sha256:atomic-race-repo',
+      'worker', 'phase_worker', 'atomic-race-agent'
+    );
+}
+step "second_commit" { COMMIT; }
+
+session "check"
+step "check" {
+  select count(*) as agents,
+         (select count(*) from agent_board.agent_signing_keys k
+           join agent_board.agents a on a.id=k.agent_id
+          where a.handle='atomic-race-agent') as keys,
+         (select count(*) from agent_board.board_invite_redemptions r
+           join agent_board.board_invite_tokens i on i.id=r.invite_id
+          where i.created_by_agent_id='16220000-0000-0000-0000-000000000001') as redemptions,
+         (select count(*) from agent_board.fleet_machine_agents b
+           join agent_board.agents a on a.id=b.agent_id
+          where a.handle='atomic-race-agent') as bindings
+    from agent_board.agents where handle='atomic-race-agent';
+}
+
+permutation "first_begin" "first_onboard" "second_begin" "second_onboard" "first_commit" "second_commit" "check"

package/tests/isolation/specs/atomic_fleet_subtree_lock_order.spec

@@ -0,0 +1,147 @@
+# Consiliency/message-board#162 — a complete fleet retry and human-subtree
+# revocation can touch both the invite creator and enrolled agent. Hold the
+# fingerprint lock to pause onboarding before its principal locks, then prove
+# the subtree's enrolled-agent-before-creator UUID order cannot deadlock it.
+
+setup
+{
+  insert into agent_board.agents(id, agent_type, kind, handle, display_name, status)
+  values ('ffffffff-ffff-ffff-ffff-ffffffffff01', 'agent', 'agent',
+          'atomic-subtree-owner', 'Atomic Subtree Owner', 'active');
+  select count(*) from agent_board.create_board(
+    'ffffffff-ffff-ffff-ffff-ffffffffff01',
+    'atomic-subtree-board', 'Atomic Subtree Board',
+    'Consiliency/message-board#162 subtree lock-order proof',
+    jsonb_build_object(), 'private'
+  );
+  insert into agent_board.fleet_trust_domains(
+    id, slug, display_name, domain_kind, owner_agent_id, lifecycle_state, approved_at
+  ) values (
+    '16270000-0000-0000-0000-000000000002', 'atomic-subtree-domain',
+    'Atomic Subtree Domain', 'tailnet', 'ffffffff-ffff-ffff-ffff-ffffffffff01',
+    'active', now()
+  );
+  insert into agent_board.fleet_machines(
+    id, trust_domain_id, owner_agent_id, machine_label, machine_fingerprint,
+    lifecycle_state, enrollment_source, enrolled_at
+  ) values (
+    '16270000-0000-0000-0000-000000000003',
+    '16270000-0000-0000-0000-000000000002',
+    'ffffffff-ffff-ffff-ffff-ffffffffff01',
+    'claw', 'sha256:atomic-subtree-machine', 'active', 'portal', now()
+  );
+  insert into agent_board.identity_providers(
+    issuer, audience, supported, policy_approved,
+    allowed_scopes, allowed_board_scopes, allowed_agent_kinds
+  ) values (
+    'https://atomic-subtree.test', 'message-board', true, true,
+    ARRAY['board:send'], ARRAY[]::text[], ARRAY['agent']
+  );
+  select count(*) from agent_board.create_fleet_onboarding_invite(
+    (select id from agent_board.boards where slug='atomic-subtree-board'),
+    '16270000-0000-0000-0000-000000000003', 'codex', 'phase-loop',
+    'message-board', 'sha256:atomic-subtree-repo', 'worker', 'phase_worker',
+    'atomic-subtree-agent', 1, now() + interval '1 hour',
+    'ffffffff-ffff-ffff-ffff-ffffffffff01', jsonb_build_object()
+  );
+  select count(*) from agent_board.onboard_federated_fleet_agent(
+    'https://atomic-subtree.test', 'message-board', 'human-subtree',
+    jsonb_build_object('iss','https://atomic-subtree.test','aud','message-board','sub','human-subtree'),
+    'atomic-subtree-agent',
+    'yd_DIFGWGusVg3SbktDJQ1bE5UWvtR33xln4b05JIhk',
+    'raw_ed25519_base64url',
+    'sha256:NeVC2vx1MbTY56jUwJcLLr6YwB4IKCERsXWbUwhf5pA',
+    true, null, 'agent', ARRAY['board:send'], ARRAY[]::text[],
+    (select code from agent_board.board_invite_tokens where created_by_agent_id='ffffffff-ffff-ffff-ffff-ffffffffff01'),
+    (select id from agent_board.boards where slug='atomic-subtree-board'),
+    '16270000-0000-0000-0000-000000000003', 'codex', 'phase-loop',
+    'message-board', 'sha256:atomic-subtree-repo', 'worker', 'phase_worker',
+    'atomic-subtree-agent'
+  );
+  update agent_board.agents
+     set owner_user_id = (
+       select owner_user_id from agent_board.agents where handle='atomic-subtree-agent'
+     )
+   where id='ffffffff-ffff-ffff-ffff-ffffffffff01';
+}
+
+teardown
+{
+  delete from agent_board.fleet_human_revocations;
+  delete from agent_board.fleet_revocation_events where agent_id in (
+    select id from agent_board.agents where handle in ('atomic-subtree-owner','atomic-subtree-agent')
+  );
+  delete from agent_board.fleet_machine_agents where machine_id='16270000-0000-0000-0000-000000000003';
+  delete from agent_board.fleet_repo_scopes where harness_registration_id in (
+    select id from agent_board.fleet_harness_registrations where machine_id='16270000-0000-0000-0000-000000000003'
+  );
+  delete from agent_board.fleet_harness_registrations where machine_id='16270000-0000-0000-0000-000000000003';
+  delete from agent_board.board_invite_redemptions where invite_id in (
+    select id from agent_board.board_invite_tokens where created_by_agent_id='ffffffff-ffff-ffff-ffff-ffffffffff01'
+  );
+  truncate agent_board.fleet_onboarding_invite_bounds;
+  delete from agent_board.board_invite_tokens where created_by_agent_id='ffffffff-ffff-ffff-ffff-ffffffffff01';
+  delete from agent_board.board_memberships where board_id in (
+    select id from agent_board.boards where slug='atomic-subtree-board'
+  );
+  delete from agent_board.enrollment_federation_audit where issuer='https://atomic-subtree.test';
+  delete from agent_board.agent_signing_keys where agent_id in (
+    select id from agent_board.agents where handle='atomic-subtree-agent'
+  );
+  delete from agent_board.agents where handle='atomic-subtree-agent';
+  delete from agent_board.boards where slug='atomic-subtree-board';
+  delete from agent_board.fleet_machines where id='16270000-0000-0000-0000-000000000003';
+  delete from agent_board.fleet_trust_domains where id='16270000-0000-0000-0000-000000000002';
+  delete from agent_board.agents where id='ffffffff-ffff-ffff-ffff-ffffffffff01';
+  delete from agent_board.identity_providers where issuer='https://atomic-subtree.test';
+}
+
+session "blocker"
+step "blocker_begin" { BEGIN; }
+step "blocker_lock" {
+  select pg_advisory_xact_lock(hashtextextended('sha256:NeVC2vx1MbTY56jUwJcLLr6YwB4IKCERsXWbUwhf5pA', 0));
+}
+step "blocker_commit" { COMMIT; }
+
+session "retry"
+step "retry_begin" { BEGIN; SET LOCAL "request.jwt.claim.role" = 'service_role'; }
+step "retry_onboard" {
+  select identity_disposition, binding_disposition
+  from agent_board.onboard_federated_fleet_agent(
+    'https://atomic-subtree.test', 'message-board', 'human-subtree',
+    jsonb_build_object('iss','https://atomic-subtree.test','aud','message-board','sub','human-subtree','iat',200),
+    'atomic-subtree-agent',
+    'yd_DIFGWGusVg3SbktDJQ1bE5UWvtR33xln4b05JIhk',
+    'raw_ed25519_base64url',
+    'sha256:NeVC2vx1MbTY56jUwJcLLr6YwB4IKCERsXWbUwhf5pA',
+    true, null, 'agent', ARRAY['board:send'], ARRAY[]::text[],
+    (select code from agent_board.board_invite_tokens where created_by_agent_id='ffffffff-ffff-ffff-ffff-ffffffffff01'),
+    (select id from agent_board.boards where slug='atomic-subtree-board'),
+    '16270000-0000-0000-0000-000000000003', 'codex', 'phase-loop',
+    'message-board', 'sha256:atomic-subtree-repo', 'worker', 'phase_worker',
+    'atomic-subtree-agent'
+  );
+}
+step "retry_commit" { COMMIT; }
+
+session "subtree"
+step "subtree_begin" { BEGIN; SET LOCAL "request.jwt.claim.role" = 'service_role'; }
+step "revoke_human_subtree" {
+  select revoked_agent_count
+  from agent_board.revoke_human_subtree(
+    (select owner_user_id from agent_board.agents where handle='atomic-subtree-agent'),
+    'ffffffff-ffff-ffff-ffff-ffffffffff01', 'isolation subtree revoke'
+  );
+}
+step "subtree_commit" { COMMIT; }
+
+session "check"
+step "check" {
+  select
+    (select status from agent_board.agents where id='ffffffff-ffff-ffff-ffff-ffffffffff01') as creator_status,
+    (select status from agent_board.agents where handle='atomic-subtree-agent') as enrolled_status,
+    (select status from agent_board.agent_signing_keys where fingerprint='sha256:NeVC2vx1MbTY56jUwJcLLr6YwB4IKCERsXWbUwhf5pA') as key_status,
+    (select count(*) from agent_board.fleet_machine_agents where machine_id='16270000-0000-0000-0000-000000000003') as bindings;
+}
+
+permutation "blocker_begin" "blocker_lock" "retry_begin" "retry_onboard" "subtree_begin" "revoke_human_subtree" "blocker_commit" "subtree_commit" "retry_commit" "check"

package/tests/isolation/specs/ceiling_setter_lock_before_upsert.spec

@@ -0,0 +1,117 @@
+# Consiliency/message-board#196 — set_board_authority_ceiling must HOLD the
+# board-keyed ceiling advisory lock BEFORE it touches board_authority_ceilings.
+#
+# WHY THIS SPEC EXISTS. The ordering was pinned only by a positional pgTAP
+# assertion over RAW function text ('the ceiling setter holds the same lock
+# before its owner gate and upsert'). Moving the `perform
+# agent_board._lock_board_authority_ceiling(p_board_id)` to the END of the
+# function made that assertion fail -- and adding ONE `--` comment naming the
+# marker made the whole file pass 52/52 with the ordering violated. Measured
+# against all 20 committed specs, NOTHING else moved: this ordering had no
+# runtime backstop at all.
+#
+# HOW THE ORDER IS OBSERVED (a lock trace, not a return value). The outcome of
+# the call is the same in both orders, so the observable has to be what the
+# transaction is HOLDING while it is blocked:
+#   * a guard session holds the ceiling advisory lock, so the setter blocks --
+#     isolationtester prints `<waiting ...>`;
+#   * a third session then probes the ceiling ROW with `for update nowait`.
+#     CORRECT ORDER: the setter is parked on the advisory lock and has not
+#     reached its upsert, so the row is free and the probe returns 'admin'.
+#     LOCK-LAST ORDER: the setter already ran `on conflict do update`, so it
+#     holds the row and the probe fails immediately with
+#     `ERROR: could not obtain lock on row in relation "board_authority_ceilings"`.
+# NOWAIT is what makes this terminate in BOTH states -- the probe never joins the
+# wait graph, so a violated ordering produces a diff, never a hang.
+#
+# The ceiling row is SEEDED in setup on purpose: with no pre-existing row the
+# upsert takes the INSERT path and there is no row for the probe to witness.
+#
+# MUTATION-VERIFIED: `perform agent_board._lock_board_authority_ceiling(p_board_id)`
+# relocated after the upsert -> this golden changes (probe errors instead of
+# returning 'admin'). Clean schema -> byte-identical across 10 runs.
+
+setup
+{
+  insert into auth.users (id) values ('19600000-0000-0000-0000-0000000000a1');
+  insert into agent_board.agents(id, agent_type, kind, handle, display_name, status, auth_user_id)
+  values ('19600000-0000-0000-0000-000000000001', 'agent', 'agent',
+          'ceiling-order-owner', 'Ceiling Order Owner', 'active',
+          '19600000-0000-0000-0000-0000000000a1');
+  select count(*) from agent_board.create_board(
+    '19600000-0000-0000-0000-000000000001',
+    'ceiling-order-board', 'Ceiling Order Board',
+    'Consiliency/message-board#196 ceiling setter lock-order probe',
+    jsonb_build_object(), 'private'
+  );
+  insert into agent_board.board_authority_ceilings(board_id, max_grantable_role)
+  values ((select id from agent_board.boards where slug='ceiling-order-board'), 'admin');
+}
+
+teardown
+{
+  delete from agent_board.board_authority_ceilings where board_id in (
+    select id from agent_board.boards where slug='ceiling-order-board'
+  );
+  delete from agent_board.board_memberships where board_id in (
+    select id from agent_board.boards where slug='ceiling-order-board'
+  );
+  delete from agent_board.boards where slug='ceiling-order-board';
+  delete from agent_board.agents where id='19600000-0000-0000-0000-000000000001';
+  delete from auth.users where id='19600000-0000-0000-0000-0000000000a1';
+}
+
+# Holds the SAME board-keyed advisory lock the setter must take first. It calls
+# the helper rather than re-deriving the key, so a key-derivation change cannot
+# silently make this guard lock a different object.
+session "holder"
+step "holder_begin" { BEGIN; }
+step "hold_ceiling_lock" {
+  select agent_board._lock_board_authority_ceiling(
+    (select id from agent_board.boards where slug='ceiling-order-board')) as locked;
+}
+step "holder_commit" { COMMIT; }
+
+# The ceiling setter is owner-gated on current_agent_id(), so it runs as the owner
+# under `authenticated` (service_role's current_agent_id() is null and the gate
+# rejects it).
+session "setter"
+step "setter_begin" {
+  BEGIN;
+  SET LOCAL ROLE authenticated;
+  SET LOCAL "request.jwt.claim.role" = 'authenticated';
+  SET LOCAL "request.jwt.claim.sub" = '19600000-0000-0000-0000-0000000000a1';
+}
+step "set_ceiling" {
+  select ceiling_max_grantable_role from agent_board.set_board_authority_ceiling(
+    (select id from agent_board.boards where slug='ceiling-order-board'),
+    'member'
+  );
+}
+step "setter_commit" { COMMIT; }
+
+# NOWAIT probe: witnesses whether the blocked setter is already holding the
+# ceiling row. Never blocks, so the permutation terminates in both orders.
+session "probe"
+step "probe_begin" { BEGIN; }
+step "probe_ceiling_row" {
+  select max_grantable_role from agent_board.board_authority_ceilings
+   where board_id = (select id from agent_board.boards where slug='ceiling-order-board')
+   for update nowait;
+}
+step "probe_commit" { COMMIT; }
+
+session "check"
+step "check" {
+  select max_grantable_role from agent_board.board_authority_ceilings
+   where board_id = (select id from agent_board.boards where slug='ceiling-order-board');
+}
+
+# THE ORDERING PROBE. The setter is parked on the advisory lock; the ceiling row
+# must still be free.
+permutation "holder_begin" "hold_ceiling_lock" "setter_begin" "set_ceiling" "probe_begin" "probe_ceiling_row" "probe_commit" "holder_commit" "setter_commit" "check"
+
+# Uncontended control: with nobody holding the advisory lock the setter completes
+# in one step, so a `<waiting ...>` above is attributable to the lock and not to
+# some unrelated serialization.
+permutation "setter_begin" "set_ceiling" "setter_commit" "probe_begin" "probe_ceiling_row" "probe_commit" "check"

package/tests/isolation/specs/enroll_identity_board_owner_lock_order.spec

@@ -0,0 +1,117 @@
+# Consiliency/message-board#194 — enroll_federated_identity is the THIRD federated
+# write route and the one that inverted board/owner order. It was a session in NO
+# lock-order spec, which is why the cycle shipped: atomic_fedsession_fleet_lock_order
+# pairs enroll_federated_human against onboard_federated_fleet_agent only.
+#
+# WHAT IS ASSERTED, AND WHY IT IS NOT THE DEADLOCK ITSELF.
+# The invariant is an ORDER: this route must hold the invite's board BEFORE it takes
+# the auth.users owner lock. A guard session holds the owner row, so the enrollment
+# blocks there in BOTH the pre-fix and post-fix schema -- and a third session then
+# asks, with NOWAIT, whether the board is already held:
+#
+#   pre-fix   the board is FREE while the enrollment waits on the owner
+#             -> `bprobe_board_nowait` SUCCEEDS and returns the row
+#   post-fix  the enrollment already holds the board FOR UPDATE
+#             -> it fails with 55P03 could not obtain lock on relation "boards"
+#
+# The `check` row is IDENTICAL in both runs (the enrollment completes and redeems
+# once the guard commits). Do not read that as "no difference": the entire golden
+# diff is the bprobe step, and that step IS the ordering claim.
+#
+# WHY NOT DRIVE THE ABBA DIRECTLY. A permutation pairing this route against
+# enroll_federated_human does reproduce the real cycle -- measured on the pre-fix
+# schema: pg_stat_database.deadlocks = 1, and with ONLY the class-40 re-raise applied
+# the victim surfaces `ERROR: deadlock detected`. But as shipped, the victim SWALLOWED
+# 40P01, returned success with invite_redeemed=f and no membership, and held the owner
+# row to commit -- so the counterpart session waited on it indefinitely and the
+# permutation had to be interrupted. An unbounded hang is not a failing test; it is
+# indistinguishable from an environment fault, and this runner has no per-spec
+# timeout. The shape below terminates in both schemas and discriminates in both.
+
+setup
+{
+  insert into agent_board.agents(id, agent_type, kind, handle, display_name, status)
+  values ('194b0000-0000-0000-0000-000000000001', 'agent', 'agent',
+          'lo194-iso-owner', 'LO194 Iso Owner', 'active');
+
+  select count(*) from agent_board.create_board(
+    '194b0000-0000-0000-0000-000000000001',
+    'lo194-iso-board', 'LO194 Iso Board',
+    'Consiliency/message-board#194 enroll lock-order proof',
+    jsonb_build_object(), 'private'
+  );
+
+  insert into agent_board.identity_providers(
+    issuer, audience, supported, policy_approved,
+    allowed_scopes, allowed_board_scopes, allowed_agent_kinds
+  ) values (
+    'https://lo194-iso.test', 'message-board', true, true,
+    ARRAY[]::text[], ARRAY[]::text[], ARRAY['agent','human']
+  );
+
+  insert into agent_board.board_invite_tokens(
+    code, board_id, preset_role, preset_membership_state, max_uses,
+    expires_at, created_by_agent_id)
+  select 'lo194-iso-code', b.id, 'member', 'joined', 10,
+         now() + interval '1 hour', '194b0000-0000-0000-0000-000000000001'
+    from agent_board.boards b
+   where b.slug = 'lo194-iso-board';
+
+  -- Materialize the owner auth.users row the enrollment will derive, so the guard
+  -- holds the SAME row (a race to INSERT it would block on the unique index, not on
+  -- the lock order under test).
+  create table lo194_owner as
+  select agent_board._ensure_agent_auth_user(
+    'fed-human-' || substr(
+      encode(extensions.digest(
+        convert_to('https://lo194-iso.test' || '|' || 'iso-human', 'UTF8'), 'sha256'), 'hex'),
+      1, 32)) as uid;
+}
+
+# Holds the human owner row, so the enrollment parks on it in either schema.
+session "ohold"
+step "ohold_begin" { BEGIN; }
+step "ohold_lock" {
+  select 1 as locked from auth.users u
+   where u.id = (select uid from lo194_owner)
+   for update;
+}
+step "ohold_commit" { COMMIT; }
+
+session "enroll"
+step "enroll_begin" { BEGIN; SET LOCAL "request.jwt.claim.role" = 'service_role'; }
+step "enroll_enroll" {
+  select agent_handle, invite_redeemed
+    from agent_board.enroll_federated_identity(
+      'https://lo194-iso.test', 'message-board', 'iso-human',
+      jsonb_build_object('iss','https://lo194-iso.test','aud','message-board','sub','iso-human'),
+      'lo194-iso-agent',
+      public.test_pubkey('lo194-iso-k1'), 'raw_ed25519_base64url',
+      public.test_key_fingerprint('lo194-iso-k1'),
+      true, null, 'agent', ARRAY[]::text[], ARRAY[]::text[],
+      'lo194-iso-code'
+    );
+}
+step "enroll_commit" { COMMIT; }
+
+# THE ORDERING ASSERTION. One unwrapped statement, so whatever lock it takes is
+# released the instant it returns and no other session can ever wait on it.
+session "bprobe"
+step "bprobe_board_nowait" {
+  select slug from agent_board.boards where slug='lo194-iso-board' for update nowait;
+}
+
+session "check"
+step "check" {
+  select
+    (select count(*) from agent_board.board_memberships m
+      join agent_board.agents a on a.id = m.agent_id
+     where m.board_id = (select id from agent_board.boards where slug='lo194-iso-board')
+       and a.handle = 'lo194-iso-agent'
+       and m.membership_state = 'joined') as enrolled_agent_memberships,
+    (select count(*) from agent_board.board_invite_redemptions r
+      join agent_board.board_invite_tokens t on t.id = r.invite_id
+     where t.code = 'lo194-iso-code') as redemptions;
+}
+
+permutation "ohold_begin" "ohold_lock" "enroll_begin" "enroll_enroll" "bprobe_board_nowait" "ohold_commit" "enroll_commit" "check"

package/tests/isolation/specs/fedsession_provider_absent_owner_lock.spec

@@ -0,0 +1,63 @@
+# Consiliency/message-board#193 — enroll_federated_human, with the provider ABSENT,
+# must fail BEFORE it takes the auth.users owner lock.
+#
+# WHY A LOCK TRACE AND NOT A RETURN VALUE. The defect is an ORDER, and the outcome
+# of the absent-provider call is 42501 either way (pre-fix from the delegate's
+# step (4), post-fix from the pre-lock gate). What differs is what the transaction
+# is HOLDING when it gets there. A guard session holds the owner's auth.users row,
+# so:
+#   * PRE-FIX  the call blocks -- isolationtester prints `<waiting ...>` -- which is
+#     the observable form of "it took the owner lock while the provider ordering was
+#     skipped entirely". That is the state from which the delegate, on its fresh READ
+#     COMMITTED snapshot, could see a concurrently-committed provider and reach its
+#     default board while still holding the owner: owner -> board, inverted against
+#     fleet onboarding's board -> owner.
+#   * POST-FIX it raises immediately, with NO `<waiting ...>` line at all.
+# Re-introducing the skip therefore changes the golden. Mutation-verified both ways.
+#
+# The owner row is materialized directly through _ensure_agent_auth_user for an
+# (issuer, subject) whose provider NEVER exists, which is the shape the existing
+# atomic_fedsession_fleet_lock_order fixture cannot express: it creates the provider
+# and the human before concurrency begins.
+
+setup
+{
+  create table lo193_owner as
+  select agent_board._ensure_agent_auth_user(
+    'fed-human-' || substr(
+      encode(extensions.digest(
+        convert_to('https://lo193-iso.test' || '|' || 'iso-orphan', 'UTF8'), 'sha256'), 'hex'),
+      1, 32)) as uid;
+}
+
+# Holds the human owner row that the absent-provider path must never reach.
+session "ohold"
+step "ohold_begin" { BEGIN; }
+step "ohold_lock" {
+  select 1 as locked from auth.users u
+   where u.id = (select uid from lo193_owner)
+   for update;
+}
+step "ohold_commit" { COMMIT; }
+
+session "portal"
+step "portal_begin" { BEGIN; SET LOCAL "request.jwt.claim.role" = 'service_role'; }
+step "portal_enroll" {
+  select status from agent_board.enroll_federated_human(
+    'https://lo193-iso.test', 'message-board', 'iso-orphan',
+    jsonb_build_object('sub','iso-orphan'), 'Iso Orphan'
+  );
+}
+step "portal_commit" { COMMIT; }
+
+session "check"
+step "check" {
+  select
+    (select count(*) from agent_board.agents a
+      where a.kind = 'human'
+        and a.metadata #>> ARRAY['federation','subject'] = 'iso-orphan') as human_agents,
+    (select count(*) from agent_board.identity_providers ip
+      where ip.issuer = 'https://lo193-iso.test') as providers;
+}
+
+permutation "ohold_begin" "ohold_lock" "portal_begin" "portal_enroll" "ohold_commit" "portal_commit" "check"