@consiliency/agent-board-schema 1.2.0

package/tests/agent_board_fleet_policy.test.sql

@@ -0,0 +1,370 @@
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(15);
+
+select has_function('agent_board', 'register_fleet_machine', array['uuid', 'uuid', 'text', 'text', 'text', 'jsonb'], 'register_fleet_machine exists');
+select has_function('agent_board', 'set_fleet_receive_policy', array['uuid', 'text', 'text', 'boolean', 'uuid', 'uuid', 'jsonb'], 'set_fleet_receive_policy exists');
+select has_function('agent_board', 'evaluate_fleet_sender_policy', array['uuid', 'uuid', 'uuid', 'uuid', 'text', 'uuid', 'boolean'], 'evaluate_fleet_sender_policy exists');
+select has_function('agent_board', 'revoke_fleet_subject', array['text', 'uuid', 'uuid', 'text', 'jsonb'], 'revoke_fleet_subject exists');
+
+create temp table _fleet_policy_fixture (
+  sender uuid,
+  recipient uuid,
+  external_sender uuid,
+  revoked_sender uuid,
+  revoked_key_sender uuid,
+  tailnet_domain uuid,
+  regenesis_domain uuid,
+  brother_domain uuid,
+  external_domain uuid,
+  sender_machine uuid,
+  external_machine uuid,
+  revoked_machine uuid,
+  revoked_key_machine uuid,
+  receive_policy uuid,
+  signed_evidence uuid,
+  revoked_key_evidence uuid,
+  signing_key uuid,
+  revoked_signing_key uuid
+) on commit drop;
+
+grant all on table _fleet_policy_fixture to authenticated, service_role;
+
+do $$
+declare
+  v_sender uuid := gen_random_uuid();
+  v_recipient uuid := gen_random_uuid();
+  v_external_sender uuid := gen_random_uuid();
+  v_revoked_sender uuid := gen_random_uuid();
+  v_revoked_key_sender uuid := gen_random_uuid();
+  v_tailnet_domain uuid;
+  v_regenesis_domain uuid;
+  v_brother_domain uuid;
+  v_external_domain uuid;
+  v_sender_machine uuid;
+  v_external_machine uuid;
+  v_revoked_machine uuid;
+  v_revoked_key_machine uuid;
+  v_policy uuid;
+  v_signing_key uuid;
+  v_revoked_signing_key uuid;
+  v_signed_evidence uuid;
+  v_revoked_key_evidence uuid;
+begin
+  insert into agent_board.agents(id, agent_type, handle, display_name)
+  values
+    (v_sender, 'agent', 'fleet-policy-tailnet-sender', 'Fleet Policy Tailnet Sender'),
+    (v_recipient, 'agent', 'fleet-policy-recipient', 'Fleet Policy Recipient'),
+    (v_external_sender, 'agent', 'fleet-policy-external-sender', 'Fleet Policy External Sender'),
+    (v_revoked_sender, 'agent', 'fleet-policy-revoked-sender', 'Fleet Policy Revoked Sender'),
+    (v_revoked_key_sender, 'agent', 'fleet-policy-key-sender', 'Fleet Policy Key Sender');
+
+  insert into agent_board.fleet_trust_domains(slug, display_name, domain_kind, owner_agent_id, lifecycle_state, approved_at, metadata)
+  values
+    ('fleet-policy-tailnet', 'Tailnet', 'tailnet', v_recipient, 'active', now(), '{"invitationState":"owner_approved"}'::jsonb),
+    ('fleet-policy-regenesis', 'ReGenesis', 'regenesis', v_recipient, 'active', now(), '{"invitationState":"invited"}'::jsonb),
+    ('fleet-policy-brother-mac', 'Brother Mac', 'development_mac', v_recipient, 'active', now(), '{"invitationState":"invited"}'::jsonb),
+    ('fleet-policy-external', 'External', 'external', v_recipient, 'active', now(), '{"invitationState":"untrusted"}'::jsonb);
+
+  select id into v_tailnet_domain from agent_board.fleet_trust_domains where slug = 'fleet-policy-tailnet';
+  select id into v_regenesis_domain from agent_board.fleet_trust_domains where slug = 'fleet-policy-regenesis';
+  select id into v_brother_domain from agent_board.fleet_trust_domains where slug = 'fleet-policy-brother-mac';
+  select id into v_external_domain from agent_board.fleet_trust_domains where slug = 'fleet-policy-external';
+
+  select machine_id
+    into v_sender_machine
+    from agent_board.register_fleet_machine(v_recipient, v_tailnet_domain, 'tailnet-claw', 'sha256:fleet-policy-tailnet-machine', 'portal', '{"redacted":true}'::jsonb);
+
+  select machine_id
+    into v_external_machine
+    from agent_board.register_fleet_machine(v_recipient, v_external_domain, 'external-runner', 'sha256:fleet-policy-external-machine', 'portal', '{"redacted":true}'::jsonb);
+
+  select machine_id
+    into v_revoked_machine
+    from agent_board.register_fleet_machine(v_recipient, v_tailnet_domain, 'revoked-runner', 'sha256:fleet-policy-revoked-machine', 'portal', '{"redacted":true}'::jsonb);
+
+  select machine_id
+    into v_revoked_key_machine
+    from agent_board.register_fleet_machine(v_recipient, v_tailnet_domain, 'key-runner', 'sha256:fleet-policy-key-machine', 'portal', '{"redacted":true}'::jsonb);
+
+  insert into agent_board.fleet_machine_agents(machine_id, agent_id, agent_role)
+  values
+    (v_sender_machine, v_sender, 'phase_worker'),
+    (v_external_machine, v_external_sender, 'phase_worker'),
+    (v_revoked_machine, v_revoked_sender, 'phase_worker'),
+    (v_revoked_key_machine, v_revoked_key_sender, 'phase_worker');
+
+  select receive_policy_id
+    into v_policy
+    from agent_board.set_fleet_receive_policy(v_recipient, 'deny by default signed', 'deny', true, null, null, '{"senderPolicy":"explicit_allowlist"}'::jsonb);
+
+  insert into agent_board.fleet_trust_sets(receive_policy_id, subject_kind, trust_domain_id, effect)
+  values
+    (v_policy, 'trust_domain', v_tailnet_domain, 'allow'),
+    (v_policy, 'trust_domain', v_regenesis_domain, 'allow'),
+    (v_policy, 'trust_domain', v_brother_domain, 'allow'),
+    (v_policy, 'trust_domain', v_external_domain, 'deny');
+
+  insert into agent_board.agent_signing_keys(agent_id, key_id, key_version, public_key, public_key_format, fingerprint, status, proof_state)
+  values
+    (v_sender, 'primary', 1, repeat('A', 43), 'raw_ed25519_base64url', 'sha256:' || repeat('A', 43), 'active', 'proven'),
+    (v_revoked_key_sender, 'revoked', 1, repeat('B', 43), 'raw_ed25519_base64url', 'sha256:' || repeat('B', 43), 'active', 'proven');
+
+  select id into v_signing_key from agent_board.agent_signing_keys where agent_id = v_sender;
+  select id into v_revoked_signing_key from agent_board.agent_signing_keys where agent_id = v_revoked_key_sender;
+
+  insert into agent_board.signature_evidence(agent_id, signing_key_id, key_id, key_version, source_kind, external_evidence_ref, operation, payload_digest, verification_status, verified_at)
+  values
+    (v_sender, v_signing_key, 'primary', 1, 'external', 'fleet-policy:signed', 'send_direct_message', 'sha256:' || repeat('c', 64), 'verified', now()),
+    (v_revoked_key_sender, v_revoked_signing_key, 'revoked', 1, 'external', 'fleet-policy:revoked-key', 'send_direct_message', 'sha256:' || repeat('d', 64), 'verified', now());
+
+  select id into v_signed_evidence from agent_board.signature_evidence where agent_id = v_sender;
+  select id into v_revoked_key_evidence from agent_board.signature_evidence where agent_id = v_revoked_key_sender;
+
+  perform agent_board.revoke_fleet_subject('machine', v_revoked_machine, v_recipient, 'revoked by policy test', '{"redacted":true}'::jsonb);
+  perform agent_board.revoke_fleet_subject('signing_key', v_revoked_signing_key, v_recipient, 'revoked key by policy test', '{"redacted":true}'::jsonb);
+
+  insert into _fleet_policy_fixture values (
+    v_sender,
+    v_recipient,
+    v_external_sender,
+    v_revoked_sender,
+    v_revoked_key_sender,
+    v_tailnet_domain,
+    v_regenesis_domain,
+    v_brother_domain,
+    v_external_domain,
+    v_sender_machine,
+    v_external_machine,
+    v_revoked_machine,
+    v_revoked_key_machine,
+    v_policy,
+    v_signed_evidence,
+    v_revoked_key_evidence,
+    v_signing_key,
+    v_revoked_signing_key
+  );
+end
+$$;
+
+create temp table _fleet_direct_rpc_fixture (
+  actor_user_id uuid
+) on commit drop;
+
+grant all on table _fleet_direct_rpc_fixture to authenticated, service_role;
+
+do $$
+declare
+  v_user_id uuid;
+  v_suffix text := replace(substr(gen_random_uuid()::text, 1, 8), '-', '');
+begin
+  v_user_id := public.ensure_github_user(
+    'fleet-direct-rpc-' || v_suffix,
+    'fleet-direct-rpc-' || v_suffix || '@example.test',
+    'fleet-direct-rpc-' || v_suffix,
+    'Fleet Direct RPC ' || v_suffix
+  );
+
+  update agent_board.agents
+     set auth_user_id = v_user_id
+   where id = (select sender from _fleet_policy_fixture);
+
+  insert into _fleet_direct_rpc_fixture(actor_user_id)
+  values (v_user_id);
+end
+$$;
+
+set local role authenticated;
+select set_config('request.jwt.claim.role', 'authenticated', true);
+select set_config('request.jwt.claim.sub', (select actor_user_id::text from _fleet_direct_rpc_fixture), true);
+
+do $$
+begin
+  begin
+    perform *
+      from agent_board.register_fleet_machine(
+        (select recipient from _fleet_policy_fixture),
+        (select external_domain from _fleet_policy_fixture),
+        'impersonated-machine',
+        'sha256:fleet-policy-impersonated-machine',
+        'portal',
+        '{"redacted":true}'::jsonb
+      );
+    raise exception 'authenticated register_fleet_machine impersonation unexpectedly succeeded';
+  exception
+    when sqlstate '42501' then null;
+  end;
+
+  begin
+    perform *
+      from agent_board.set_fleet_receive_policy(
+        (select recipient from _fleet_policy_fixture),
+        'impersonated receive policy',
+        'allow',
+        false,
+        null,
+        null,
+        '{"redacted":true}'::jsonb
+      );
+    raise exception 'authenticated set_fleet_receive_policy impersonation unexpectedly succeeded';
+  exception
+    when sqlstate '42501' then null;
+  end;
+
+  begin
+    perform *
+      from agent_board.revoke_fleet_subject(
+        'machine',
+        (select external_machine from _fleet_policy_fixture),
+        (select recipient from _fleet_policy_fixture),
+        'impersonated revocation',
+        '{"redacted":true}'::jsonb
+      );
+    raise exception 'authenticated revoke_fleet_subject impersonation unexpectedly succeeded';
+  exception
+    when sqlstate '42501' then null;
+  end;
+end
+$$;
+
+select pass('authenticated fleet RPC impersonation checks are denied');
+
+reset role;
+select set_config('request.jwt.claim.role', '', true);
+select set_config('request.jwt.claim.sub', '', true);
+
+select is(
+  (select allowed from agent_board.evaluate_fleet_sender_policy(
+    (select sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    (select sender_machine from _fleet_policy_fixture),
+    null,
+    'send_direct_message',
+    (select signed_evidence from _fleet_policy_fixture),
+    false
+  )),
+  true,
+  'Tailnet same-domain sender is allowed with signed evidence'
+);
+
+select is(
+  (select denial_class from agent_board.evaluate_fleet_sender_policy(
+    (select external_sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    (select external_machine from _fleet_policy_fixture),
+    null,
+    'send_direct_message',
+    null,
+    false
+  )),
+  'signature_required',
+  'unsigned external sender is denied before trust-set allow'
+);
+
+select is(
+  (select denial_class from agent_board.evaluate_fleet_sender_policy(
+    (select external_sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    (select external_machine from _fleet_policy_fixture),
+    null,
+    'send_direct_message',
+    (select signed_evidence from _fleet_policy_fixture),
+    false
+  )),
+  'signature_required',
+  'signature evidence must belong to the sender'
+);
+
+select is(
+  (select denial_class from agent_board.evaluate_fleet_sender_policy(
+    (select revoked_sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    (select revoked_machine from _fleet_policy_fixture),
+    null,
+    'send_direct_message',
+    null,
+    false
+  )),
+  'machine_revoked',
+  'revoked machine is denied'
+);
+
+select is(
+  (select denial_class from agent_board.evaluate_fleet_sender_policy(
+    (select revoked_key_sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    (select revoked_key_machine from _fleet_policy_fixture),
+    null,
+    'send_direct_message',
+    (select revoked_key_evidence from _fleet_policy_fixture),
+    false
+  )),
+  'key_revoked',
+  'revoked signing key is denied'
+);
+
+select is(
+  (select denial_class from agent_board.evaluate_fleet_sender_policy(
+    (select sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    gen_random_uuid(),
+    null,
+    'send_direct_message',
+    (select signed_evidence from _fleet_policy_fixture),
+    false
+  )),
+  'domain_denied',
+  'unknown machine is denied'
+);
+
+select is(
+  (select allowed from agent_board.evaluate_fleet_sender_policy(
+    (select sender from _fleet_policy_fixture),
+    (select recipient from _fleet_policy_fixture),
+    (select sender_machine from _fleet_policy_fixture),
+    null,
+    'send_direct_message',
+    (select signed_evidence from _fleet_policy_fixture),
+    true
+  )),
+  true,
+  'direct-RPC compatibility still requires machine and signature checks'
+);
+
+select ok(
+  exists (
+    select 1
+      from agent_board.fleet_trust_sets fts
+     where fts.receive_policy_id = (select receive_policy from _fleet_policy_fixture)
+       and fts.trust_domain_id = (select regenesis_domain from _fleet_policy_fixture)
+       and fts.effect = 'allow'
+  ),
+  'ReGenesis cross-domain allow trust set is present'
+);
+
+select ok(
+  exists (
+    select 1
+      from agent_board.fleet_trust_sets fts
+     where fts.receive_policy_id = (select receive_policy from _fleet_policy_fixture)
+       and fts.trust_domain_id = (select brother_domain from _fleet_policy_fixture)
+       and fts.effect = 'allow'
+  ),
+  'brother-Mac invitation allow trust set is present'
+);
+
+select ok(
+  not exists (
+    select 1
+      from agent_board.fleet_revocation_events
+     where metadata::text ~* '(private key|service-role|secret|raw signature|provider payload|local env)'
+  ),
+  'fleet policy revocation evidence stays metadata-safe'
+);
+
+select finish();
+
+rollback;

package/tests/agent_board_fleet_read_models.test.sql

@@ -0,0 +1,158 @@
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(27);
+
+select has_view('agent_board', 'v_fleet_machine_status', 'fleet machine status view exists');
+select has_view('agent_board', 'v_fleet_receive_policy_status', 'fleet receive policy status view exists');
+select has_view('agent_board', 'v_fleet_delivery_posture', 'fleet delivery posture view exists');
+
+select has_column('agent_board', 'v_fleet_machine_status', 'machine_id', 'machine status exposes machine id');
+select has_column('agent_board', 'v_fleet_machine_status', 'owner_agent_id', 'machine status exposes owner agent');
+select has_column('agent_board', 'v_fleet_machine_status', 'trust_domain_slug', 'machine status exposes trust-domain slug');
+select has_column('agent_board', 'v_fleet_machine_status', 'machine_fingerprint', 'machine status exposes metadata-safe fingerprint');
+select has_column('agent_board', 'v_fleet_machine_status', 'machine_lifecycle_state', 'machine status exposes lifecycle');
+select has_column('agent_board', 'v_fleet_machine_status', 'active_agent_count', 'machine status exposes active agent count');
+
+select has_column('agent_board', 'v_fleet_receive_policy_status', 'receive_policy_id', 'policy status exposes policy id');
+select has_column('agent_board', 'v_fleet_receive_policy_status', 'default_action', 'policy status exposes default action');
+select has_column('agent_board', 'v_fleet_receive_policy_status', 'require_signed_sender', 'policy status exposes signed-sender requirement');
+select has_column('agent_board', 'v_fleet_receive_policy_status', 'allow_trust_set_count', 'policy status exposes allow trust-set count');
+select has_column('agent_board', 'v_fleet_receive_policy_status', 'restrictive_trust_set_count', 'policy status exposes restrictive trust-set count');
+
+select has_column('agent_board', 'v_fleet_delivery_posture', 'delivery_recipient_id', 'delivery posture exposes delivery recipient id');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'sender_agent_id', 'delivery posture exposes sender agent id');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'receive_policy_id', 'delivery posture exposes receive policy id');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'denial_class', 'delivery posture exposes denial class');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'allowed', 'delivery posture exposes allowed flag');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'actionable', 'delivery posture exposes actionable flag');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'key_fingerprint', 'delivery posture exposes key fingerprint');
+select has_column('agent_board', 'v_fleet_delivery_posture', 'fetch_descriptor', 'delivery posture exposes bounded fetch descriptor');
+
+select ok(
+  not exists (
+    select 1
+      from information_schema.columns
+     where table_schema = 'agent_board'
+       and table_name in ('v_fleet_machine_status', 'v_fleet_receive_policy_status', 'v_fleet_delivery_posture')
+       and column_name ~* '(private_key|service_role|secret|token|raw_signature|provider_payload|local_env|body)'
+  ),
+  'fleet read models do not project raw secret, provider, local env, signature, token, or body columns'
+);
+
+do $$
+declare
+  v_sender uuid := gen_random_uuid();
+  v_recipient uuid := gen_random_uuid();
+  v_thread uuid := gen_random_uuid();
+  v_message uuid := gen_random_uuid();
+  v_delivery uuid := gen_random_uuid();
+  v_inbox uuid := gen_random_uuid();
+  v_domain uuid;
+  v_machine uuid;
+  v_policy uuid;
+begin
+  insert into agent_board.agents(id, agent_type, handle, display_name)
+  values
+    (v_sender, 'agent', 'fleet-read-sender', 'Fleet Read Sender'),
+    (v_recipient, 'agent', 'fleet-read-recipient', 'Fleet Read Recipient');
+
+  insert into agent_board.threads(id, created_by_agent_id, subject)
+  values (v_thread, v_sender, 'Fleet read model thread');
+
+  insert into agent_board.messages(id, thread_id, author_agent_id, message_sequence, body)
+  values (v_message, v_thread, v_sender, 1, 'metadata safe message body not projected');
+
+  insert into agent_board.delivery_recipients(id, delivery_mode, recipient_agent_id, source_kind, source_message_id)
+  values (v_delivery, 'direct', v_recipient, 'message', v_message);
+
+  insert into agent_board.inbox_items(
+    id,
+    delivery_recipient_id,
+    recipient_agent_id,
+    delivery_mode,
+    source_kind,
+    source_message_id,
+    subject,
+    preview,
+    fetch_descriptor
+  )
+  values (
+    v_inbox,
+    v_delivery,
+    v_recipient,
+    'direct',
+    'message',
+    v_message,
+    'Fleet read',
+    'bounded preview',
+    jsonb_build_object('view', 'agent_board.v_thread_feed', 'filters', jsonb_build_object('thread_id', v_thread), 'reason', 'fleet read model test')
+  );
+
+  insert into agent_board.fleet_trust_domains(slug, display_name, domain_kind, owner_agent_id, lifecycle_state, approved_at)
+  values ('fleet-read-tailnet', 'Fleet Read Tailnet', 'tailnet', v_recipient, 'active', now())
+  returning id into v_domain;
+
+  select machine_id
+    into v_machine
+    from agent_board.register_fleet_machine(v_recipient, v_domain, 'fleet-read-machine', 'sha256:fleet-read-machine', 'portal', '{"redacted":true}'::jsonb);
+
+  insert into agent_board.fleet_machine_agents(machine_id, agent_id, agent_role)
+  values (v_machine, v_sender, 'phase_worker');
+
+  select receive_policy_id
+    into v_policy
+    from agent_board.set_fleet_receive_policy(v_recipient, 'fleet read allow', 'deny', false, null, null, '{"redacted":true}'::jsonb);
+
+  insert into agent_board.fleet_trust_sets(receive_policy_id, subject_kind, trust_domain_id, effect)
+  values (v_policy, 'trust_domain', v_domain, 'allow');
+end
+$$;
+
+select ok(
+  exists (
+    select 1
+      from agent_board.v_fleet_machine_status
+     where machine_label = 'fleet-read-machine'
+       and active_agent_count = 1
+  ),
+  'machine status view reports active machine-agent bindings'
+);
+
+select ok(
+  exists (
+    select 1
+      from agent_board.v_fleet_receive_policy_status
+     where policy_name = 'fleet read allow'
+       and allow_trust_set_count = 1
+       and restrictive_trust_set_count = 0
+  ),
+  'receive policy status counts allow and restrictive trust sets'
+);
+
+select ok(
+  exists (
+    select 1
+      from agent_board.v_fleet_delivery_posture
+     where allowed = true
+       and actionable = true
+       and denial_class is null
+       and fetch_descriptor ->> 'view' = 'agent_board.v_thread_feed'
+  ),
+  'delivery posture view exposes metadata-safe actionable posture'
+);
+
+select ok(
+  not exists (
+    select 1
+      from agent_board.v_fleet_delivery_posture
+     where coalesce(fetch_descriptor::text, '') ~* '(private key|service-role|secret|raw signature|provider payload|local env)'
+  ),
+  'delivery posture fetch descriptors stay metadata-safe'
+);
+
+select finish();
+
+rollback;

package/tests/agent_board_fleet_registry.test.sql

@@ -0,0 +1,149 @@
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(35);
+
+select has_table('agent_board', 'fleet_trust_domains', 'fleet_trust_domains table exists');
+select has_table('agent_board', 'fleet_machines', 'fleet_machines table exists');
+select has_table('agent_board', 'fleet_harness_registrations', 'fleet_harness_registrations table exists');
+select has_table('agent_board', 'fleet_repo_scopes', 'fleet_repo_scopes table exists');
+select has_table('agent_board', 'fleet_machine_agents', 'fleet_machine_agents table exists');
+select has_table('agent_board', 'fleet_receive_policies', 'fleet_receive_policies table exists');
+select has_table('agent_board', 'fleet_trust_sets', 'fleet_trust_sets table exists');
+select has_table('agent_board', 'fleet_revocation_events', 'fleet_revocation_events table exists');
+
+select has_column('agent_board', 'fleet_trust_domains', 'domain_kind', 'trust domains expose domain kind');
+select has_column('agent_board', 'fleet_trust_domains', 'owner_agent_id', 'trust domains are owner scoped');
+select has_column('agent_board', 'fleet_machines', 'machine_fingerprint', 'machines store metadata-safe fingerprint');
+select has_column('agent_board', 'fleet_machines', 'enrollment_source', 'machines store enrollment source');
+select has_column('agent_board', 'fleet_harness_registrations', 'harness_kind', 'harness registrations store harness kind');
+select has_column('agent_board', 'fleet_repo_scopes', 'repo_fingerprint', 'repo scopes store metadata-safe repo fingerprint');
+select has_column('agent_board', 'fleet_machine_agents', 'signing_key_id', 'machine-agent links can bind signing keys');
+select has_column('agent_board', 'fleet_receive_policies', 'require_signed_sender', 'receive policies can require signed senders');
+select has_column('agent_board', 'fleet_trust_sets', 'effect', 'trust sets expose policy effect');
+select has_column('agent_board', 'fleet_revocation_events', 'subject_kind', 'revocation events expose subject kind');
+
+select col_has_check('agent_board', 'fleet_trust_domains', 'domain_kind', 'domain kind is constrained');
+select col_has_check('agent_board', 'fleet_machines', 'lifecycle_state', 'machine lifecycle state is constrained');
+select col_has_check('agent_board', 'fleet_receive_policies', 'default_action', 'receive policy default action is constrained');
+select col_has_check('agent_board', 'fleet_trust_sets', 'effect', 'trust set effect is constrained');
+select col_has_check('agent_board', 'fleet_revocation_events', 'subject_kind', 'revocation subject kind is constrained');
+
+select has_index('agent_board', 'fleet_machines', 'idx_agent_board_fleet_machines_fingerprint_unique', 'machine fingerprint is unique');
+select has_index('agent_board', 'fleet_revocation_events', 'idx_agent_board_fleet_revocation_subject_unique', 'revocations are idempotent per subject');
+
+select fk_ok('agent_board', 'fleet_machines', 'trust_domain_id', 'agent_board', 'fleet_trust_domains', 'id', 'machines reference trust domains');
+select fk_ok('agent_board', 'fleet_machine_agents', 'agent_id', 'agent_board', 'agents', 'id', 'machine-agent links reference agents');
+select fk_ok('agent_board', 'fleet_machine_agents', 'signing_key_id', 'agent_board', 'agent_signing_keys', 'id', 'machine-agent links reference signing keys');
+select fk_ok('agent_board', 'fleet_receive_policies', 'recipient_agent_id', 'agent_board', 'agents', 'id', 'receive policies reference recipient agents');
+
+select ok(
+  exists (select 1 from agent_board.schema_version where version = 7),
+  'schema_version advanced to fleet store version 7'
+);
+
+select ok(
+  not exists (
+    select 1
+      from information_schema.columns
+     where table_schema = 'agent_board'
+       and table_name in (
+         'fleet_trust_domains',
+         'fleet_machines',
+         'fleet_harness_registrations',
+         'fleet_repo_scopes',
+         'fleet_machine_agents',
+         'fleet_receive_policies',
+         'fleet_trust_sets',
+         'fleet_revocation_events'
+       )
+       and column_name ~* '(private_key|service_role|secret|token|raw_signature|provider_payload|local_env|host_inventory)'
+  ),
+  'fleet registry tables do not expose secret or raw inventory columns'
+);
+
+do $$
+declare
+  v_owner uuid := gen_random_uuid();
+  v_domain uuid;
+  v_machine uuid;
+  v_harness uuid;
+  v_repo_scope uuid;
+  v_policy uuid;
+begin
+  insert into agent_board.agents(id, agent_type, handle, display_name)
+  values (v_owner, 'agent', 'fleet-registry-owner', 'Fleet Registry Owner');
+
+  insert into agent_board.fleet_trust_domains(slug, display_name, domain_kind, owner_agent_id, lifecycle_state, approved_at)
+  values ('fleet-registry-tailnet', 'Fleet Registry Tailnet', 'tailnet', v_owner, 'active', now())
+  returning id into v_domain;
+
+  insert into agent_board.fleet_machines(trust_domain_id, owner_agent_id, machine_label, machine_fingerprint, lifecycle_state, enrollment_source, enrolled_at)
+  values (v_domain, v_owner, 'claw', 'sha256:fleet-registry-machine', 'active', 'portal', now())
+  returning id into v_machine;
+
+  insert into agent_board.fleet_harness_registrations(machine_id, harness_kind, harness_label)
+  values (v_machine, 'codex', 'phase-loop command')
+  returning id into v_harness;
+
+  insert into agent_board.fleet_repo_scopes(harness_registration_id, repo_slug, repo_fingerprint, scope_role)
+  values (v_harness, 'consiliency-portal', 'sha256:fleet-registry-repo', 'worker')
+  returning id into v_repo_scope;
+
+  insert into agent_board.fleet_machine_agents(machine_id, agent_id, repo_scope_id, agent_role)
+  values (v_machine, v_owner, v_repo_scope, 'phase_worker');
+
+  insert into agent_board.fleet_receive_policies(recipient_agent_id, policy_name, default_action, require_signed_sender)
+  values (v_owner, 'registry smoke', 'deny', true)
+  returning id into v_policy;
+
+  insert into agent_board.fleet_trust_sets(receive_policy_id, subject_kind, trust_domain_id, effect)
+  values (v_policy, 'trust_domain', v_domain, 'allow');
+
+  insert into agent_board.fleet_revocation_events(subject_kind, subject_id, machine_id, revoked_by_agent_id, revocation_reason)
+  values ('machine', v_machine, v_machine, v_owner, 'registry smoke');
+end
+$$;
+
+select pass('fleet registry tables accept metadata-safe linked rows');
+
+select lives_ok(
+  $$
+    insert into agent_board.fleet_harness_registrations(machine_id, harness_kind, harness_label)
+    values (
+      (select id from agent_board.fleet_machines where machine_fingerprint = 'sha256:fleet-registry-machine'),
+      'pi',
+      'pi command'
+    )
+  $$,
+  'fleet harness registrations accept valid open harness descriptors'
+);
+
+select throws_ok(
+  $$
+    insert into agent_board.fleet_harness_registrations(machine_id, harness_kind, harness_label)
+    values (
+      (select id from agent_board.fleet_machines where machine_fingerprint = 'sha256:fleet-registry-machine'),
+      'Claude Code',
+      'malformed command'
+    )
+  $$,
+  '23514',
+  NULL,
+  'fleet harness registrations reject malformed harness descriptors'
+);
+
+select ok(
+  not exists (
+    select 1
+      from agent_board.fleet_machines
+     where metadata::text ~* '(private key|service-role|secret|raw signature|provider payload|local env)'
+  ),
+  'fleet registry metadata stays metadata-safe'
+);
+
+select finish();
+
+rollback;