@opengeni/db 1.0.1 → 3.2.0-canary.0

package/src/runtime-posture.ts

@@ -66,12 +66,216 @@ const KNOWLEDGE_SOURCE_SYNC_LOCK_AUTHORITY_TABLES = [
 ] as const;
 const MANAGED_HUMAN_PERSONAL_WORKSPACE_ROUTINE =
   "ensure_managed_human_personal_workspace(uuid, text, uuid)";
+const ORGANIZATION_MEMBERSHIP_LIFECYCLE_ROUTINES = [
+  "list_self_organization_memberships(text)",
+  "list_self_organization_invitations(text)",
+  "list_self_organization_invitations(text, uuid, integer)",
+  "get_self_organization_invitation(text, uuid)",
+  "list_organization_invitations(uuid, text, uuid, integer)",
+  "list_organization_members(uuid, text)",
+  "get_organization_administration_overview(uuid, text)",
+  "create_managed_organization(text, text, text, uuid)",
+  "assert_organization_shared_workspace_administrator(uuid, uuid, text)",
+  "open_organization_shared_workspace_administration_capability(uuid, uuid, text)",
+  "close_organization_shared_workspace_administration_capability(uuid)",
+  "create_organization_shared_workspace(uuid, text, text, text, text, uuid)",
+  "upsert_organization_shared_workspace_member(uuid, uuid, text, uuid, text, text, jsonb, boolean)",
+  "update_organization_name(uuid, text, text, timestamp with time zone, uuid)",
+  "create_organization_invitation_v2(jsonb)",
+  "bind_pending_organization_invitations_for_verified_email(text, text)",
+  "has_pending_organization_invitation_for_subject(text)",
+  "accept_organization_invitation_v2(jsonb)",
+  "organization_membership_command(jsonb)",
+  "prepare_organization_membership_protocol_settlements(jsonb)",
+  "assert_active_managed_human_organization_membership(uuid, text)",
+  "resolve_workspace_writer_grant_identity(uuid, text)",
+  "prepare_workspace_membership_removal_settlements(jsonb)",
+  "workspace_membership_removal_command(jsonb)",
+  "get_organization_retention_policy(uuid, text)",
+  "preview_organization_retention_deletions(uuid, integer)",
+  "claim_organization_retention_deletion(uuid, uuid, uuid[])",
+  "list_organization_retention_deletion_objects(uuid, uuid, uuid, text, integer)",
+  "record_organization_retention_object_deleted(uuid, uuid, uuid, text, text, text, text)",
+  "fail_organization_retention_deletion(uuid, uuid, uuid, text)",
+  "finalize_organization_retention_deletion(uuid, uuid, uuid, text)",
+  "complete_organization_retention_deletion(uuid, uuid, uuid, text)",
+] as const;
+const ORGANIZATION_MEMBERSHIP_LIFECYCLE_AUTHORITY_TABLES = [
+  "organization_invitation_binding_events",
+  "organization_membership_invitations",
+  "organization_membership_lifecycle_events",
+  "organization_membership_operation_receipts",
+  "organization_memberships",
+  "organization_profile_events",
+  "organization_shared_workspace_administration_capabilities",
+  "organization_user_resource_authorities",
+  "organization_user_resource_grants",
+  "organization_user_retention_deletion_events",
+  "organization_user_retention_deletions",
+  "organization_user_retention_object_deletion_receipts",
+  "organization_user_retention_object_obligations",
+  "organization_user_retention_policies",
+] as const;
+const PRIVATE_SESSION_CREATE_POLICY_ROUTINE = "get_private_session_create_policy(uuid, uuid, text)";
+const ORGANIZATION_PRIVATE_SESSION_SETTINGS_READ_ROUTINE =
+  "get_organization_private_session_settings(uuid, text)";
+const ORGANIZATION_PRIVATE_SESSION_SETTINGS_UPDATE_ROUTINE =
+  "update_organization_private_session_settings(uuid, text, boolean, bigint, uuid)";
+const ORGANIZATION_PRIVATE_SESSION_ROUTINE_AUTHORITY_TABLES = {
+  [PRIVATE_SESSION_CREATE_POLICY_ROUTINE]: [
+    "organization_memberships",
+    "organization_private_session_settings",
+    "session_tenancy_activations",
+    "workspace_memberships",
+    "workspaces",
+  ],
+  [ORGANIZATION_PRIVATE_SESSION_SETTINGS_READ_ROUTINE]: [
+    "managed_accounts",
+    "organization_memberships",
+    "organization_private_session_settings",
+    "session_tenancy_activations",
+  ],
+  [ORGANIZATION_PRIVATE_SESSION_SETTINGS_UPDATE_ROUTINE]: [
+    "managed_accounts",
+    "organization_memberships",
+    "organization_private_session_setting_events",
+    "organization_private_session_settings",
+    "session_tenancy_activations",
+  ],
+} as const;
+const ORGANIZATION_PRIVATE_SESSION_ROUTINES = Object.keys(
+  ORGANIZATION_PRIVATE_SESSION_ROUTINE_AUTHORITY_TABLES,
+);
+const ORGANIZATION_PRIVATE_SESSIONS_ENABLED_ROUTINE = "organization_private_sessions_enabled(uuid)";
+const PREFERENCE_KNOWLEDGE_PROPOSAL_ROUTINE =
+  "preference_registry_create_knowledge_proposal_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid, text, uuid, text, text, text, text, integer, text, jsonb, timestamp with time zone, text)";
+const PREFERENCE_KNOWLEDGE_PROPOSAL_AUTHORITY_TABLES = [
+  "company_brain_preference_proposal_receipts",
+  "knowledge_change_proposals",
+  "knowledge_claim_evidence",
+  "knowledge_claim_reviews",
+  "knowledge_claims",
+  "preference_registry_events",
+  "preference_registry_preferences",
+  "preference_registry_revisions",
+  "session_attempt_interruptions",
+  "session_turn_attempts",
+  "session_turns",
+  "sessions",
+  "workspaces",
+] as const;
 const MANAGED_HUMAN_PERSONAL_WORKSPACE_AUTHORITY_TABLES = [
   "organization_memberships",
   "organization_user_retention_policies",
   "organization_user_resource_authorities",
   "organization_user_resource_grants",
 ] as const;
+const PERSONAL_RESOURCE_ATTEMPT_RESOLVER_ROUTINE =
+  "resolve_session_attempt_personal_resources(uuid, uuid, uuid)";
+const USER_RESOURCE_LIFECYCLE_ROUTINES = [
+  "accept_turn_personal_resource_attachment(uuid, uuid, uuid, uuid, text, integer, boolean, integer)",
+  "list_self_user_resource_authorities(uuid, uuid, text, uuid, integer)",
+  "issue_self_user_resource_grant(uuid, uuid, uuid, text, text, text, uuid, integer, boolean)",
+  "revoke_self_user_resource_grant(uuid, uuid, uuid)",
+  "authorize_session_attempt_personal_resource_reads(uuid, uuid, uuid)",
+] as const;
+const CONNECTION_CONVERGENCE_AUDIT_CAPABILITY_ROUTINE =
+  "connection_authority_convergence_audit_capability_active(uuid)";
+const CONNECTION_AUTHORITY_ROUTINES = [
+  CONNECTION_CONVERGENCE_AUDIT_CAPABILITY_ROUTINE,
+  "resolve_personal_connection_authority_selection(uuid, uuid, text, uuid, jsonb)",
+  "resolve_accepted_connection_use(uuid, uuid, uuid, uuid, uuid, integer, uuid, text, text, uuid, text, text, text, text)",
+  "resolve_connection_use_authority(uuid, uuid, uuid, jsonb)",
+  "inspect_organization_connection_authority_convergence(uuid, integer, uuid)",
+] as const;
+const PERSONAL_GITHUB_REPOSITORY_AUTHORITY_ROUTINES = [
+  "get_self_personal_github_repository_selection(uuid, uuid, text, uuid)",
+  "mutate_self_personal_github_repository_selection(uuid, uuid, text, uuid, bigint, bigint, text, jsonb, boolean)",
+] as const;
+const PERSONAL_GITHUB_REPOSITORY_AUTHORITY_TABLES = [
+  "personal_github_repository_selection_heads",
+  "personal_github_repository_selection_operations",
+  "personal_github_repository_selections",
+] as const;
+const SCHEDULED_PERSONAL_RESOURCE_ROUTINES = [
+  "freeze_scheduled_task_personal_resources(uuid, uuid, uuid, bigint)",
+  "clone_scheduled_task_personal_resource_authority(uuid, uuid, uuid, bigint, bigint)",
+  "refresh_scheduled_task_personal_resources_clone_connections(uuid, uuid, uuid, bigint, bigint)",
+  "create_scheduled_agent_run_with_admission(uuid, uuid, uuid, uuid, bigint, text, text, text, timestamp with time zone, timestamp with time zone, jsonb)",
+  "materialize_scheduled_task_reusable_session_from_run(uuid, uuid, uuid, uuid, uuid, bigint, text)",
+  "scheduled_task_run_personal_resource_authority(uuid, uuid, uuid)",
+  "scheduled_task_run_connection_authority_subject(uuid, uuid, uuid)",
+  "scheduled_task_personal_resource_authority_subject(uuid, uuid, uuid, bigint)",
+  "record_scheduled_task_revision_authority(uuid, uuid, uuid, bigint)",
+  "clone_scheduled_task_revision_authority(uuid, uuid, uuid, bigint, bigint)",
+  "scheduled_task_revision_authority_subject(uuid, uuid, uuid, bigint)",
+  "scheduled_task_revision_authority_snapshot(uuid, uuid, uuid, bigint)",
+  "validate_scheduled_agent_run_live_authority(uuid, uuid, uuid)",
+  "scheduled_scoped_rig_version_metadata(uuid, uuid, text, uuid, uuid)",
+  "scheduled_variable_set_expected_generation_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid)",
+  "bind_scheduled_task_run_session(uuid, uuid, uuid, uuid)",
+  "transition_scheduled_agent_run(uuid, uuid, uuid, uuid, uuid, text, text)",
+] as const;
+const PERSONAL_RESOURCE_CAPABILITY_PREDICATE_ROUTINE =
+  "personal_resource_delegation_capability_active(text)";
+const PERSONAL_RESOURCE_CAPABILITY_TABLE = "personal_resource_delegation_capabilities";
+const SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_PREDICATE_ROUTINE =
+  "scheduled_personal_resource_capability_active(text)";
+const SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_TABLE = "scheduled_personal_resource_capabilities";
+const VARIABLE_SET_CAPABILITY_PREDICATE_ROUTINE = "variable_set_authority_capability_active(text)";
+const VARIABLE_SET_CAPABILITY_TABLE = "variable_set_authority_capabilities";
+const PERSONAL_DOCUMENT_CAPABILITY_PREDICATE_ROUTINE =
+  "personal_document_authority_capability_active(text)";
+const PERSONAL_DOCUMENT_CAPABILITY_TABLE = "personal_document_authority_capabilities";
+const PERSONAL_DOCUMENT_AUTHORITY_ROUTINES = [
+  "create_personal_document_authority(uuid, uuid, uuid)",
+  "resolve_document_original_file(uuid, uuid, text, uuid)",
+  "resolve_session_attempt_personal_document_reads(uuid, uuid, uuid, uuid)",
+] as const;
+const DOCUMENT_MIGRATION_CAPABILITY_PREDICATE_ROUTINE =
+  "document_migration_capability_active(text)";
+const DOCUMENT_MIGRATION_CAPABILITY_TABLE = "document_migration_capabilities";
+const DOCUMENT_MIGRATION_AUTHORITY_ROUTINES = [
+  "list_document_authority_reclassifications(uuid, uuid, text, uuid, integer, timestamp with time zone, uuid)",
+  "reclassify_document_authority(jsonb)",
+  "run_document_default_collection_backfill(jsonb)",
+  "list_document_default_collection_backfill_runs(jsonb)",
+  "get_document_default_collection_backfill_audit(jsonb)",
+  "list_organization_document_authority_reclassifications(jsonb)",
+] as const;
+const DOCUMENT_MIGRATION_AUDIT_INTERNAL_ROUTINES = [
+  "document_migration_audit_capability_active(text)",
+  "assert_document_migration_audit_authority(jsonb)",
+] as const;
+const VARIABLE_SET_AUTHORITY_ROUTINES = [
+  "create_scoped_variable_set(uuid, uuid, text, text, text, jsonb, boolean)",
+  "list_scoped_variable_sets(uuid, uuid, uuid, text, text)",
+  "count_scoped_variable_sets(uuid, uuid, text)",
+  "mutate_scoped_variable_set(uuid, uuid, uuid, text, text, boolean, text, boolean, text, text, boolean)",
+  "read_scoped_variable_set_secret(uuid, uuid, uuid, text, text, text, uuid, uuid, uuid, integer)",
+  "materialize_scoped_variable_set_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid)",
+  "materialize_scoped_variable_set_for_session(uuid, uuid, uuid, uuid)",
+] as const;
+const SCOPED_COMPUTE_CAPABILITY_PREDICATE_ROUTINE = "scoped_compute_capability_active(text)";
+const SCOPED_COMPUTE_CAPABILITY_TABLE = "scoped_compute_capabilities";
+const CONNECTION_TENANCY_BACKFILL_CAPABILITY_TABLE = "connection_tenancy_backfill_capabilities";
+const CONNECTION_TENANCY_BACKFILL_CAPABILITY_PREDICATE_ROUTINE =
+  "connection_tenancy_backfill_capability_active(uuid)";
+const SCOPED_COMPUTE_AUTHORITY_ROUTINES = [
+  "create_scoped_rig(uuid, uuid, text, text, text, text, jsonb, boolean)",
+  "list_scoped_rigs(uuid, uuid, uuid, text, text)",
+  "count_scoped_rigs(uuid, uuid, text)",
+  "mutate_scoped_rig(uuid, uuid, uuid, text, text, boolean, text, boolean, boolean)",
+  "finalize_scoped_enrollment(uuid, uuid, text, text, boolean, boolean, text, text, text, boolean)",
+  "list_scoped_enrollments(uuid, uuid, uuid, text)",
+  "get_scoped_sandbox(uuid, uuid, uuid)",
+  "authorize_scoped_sandbox_attach(uuid, uuid, uuid)",
+  "materialize_scoped_rig_version_for_attempt(uuid, uuid, uuid, uuid, uuid, integer)",
+  "authorize_session_attempt_personal_machine(uuid, uuid, uuid, uuid, uuid, integer, uuid)",
+  "assert_session_attempt_personal_machine(uuid, uuid, uuid, uuid, uuid, integer, uuid, boolean)",
+  "list_scoped_machine_dependent_sessions(uuid, uuid, uuid)",
+  "detach_scoped_machine_dependent_sessions(uuid, uuid, uuid)",
+] as const;
 const CANONICAL_HUMAN_IDENTITY_ROUTINES = [
   "ensure_canonical_human_identity(text, text)",
   "validate_canonical_human_session(text, text, boolean)",
@@ -91,17 +295,130 @@ const TASK_NOTE_CAPABILITY_ROUTINES = [
   "create_task_note_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid, text, text, integer)",
   "archive_task_note_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid, uuid, integer, text)",
   "list_task_notes_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, boolean, integer)",
+  "replace_task_note_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid, uuid, uuid, uuid, integer, text, text, integer, text)",
+  "resolve_task_note_knowledge_promotion_source(uuid, uuid, uuid, uuid, uuid, integer, uuid, integer, text, text, text)",
+] as const;
+const COMPANY_BRAIN_CONTEXT_SELECTION_ROUTINE =
+  "company_brain_context_get_or_create_selection(uuid, uuid, uuid, uuid, uuid, integer)";
+const COMPANY_BRAIN_CONTEXT_INSPECTION_ROUTINE =
+  "company_brain_inspect_context_receipts(uuid, uuid, text, uuid, timestamp with time zone, uuid, integer)";
+const GOVERNED_LEARNING_EVALUATION_ROUTINE =
+  "evaluate_governed_learning_proposal(uuid, uuid, uuid, uuid, uuid, integer, uuid, uuid, uuid, uuid, uuid)";
+const GOVERNED_LEARNING_ACTIVATION_ROUTINES = [
+  "activate_governed_learning_decision(uuid, uuid, uuid, uuid)",
+  "activate_human_confirmed_learning_decision(uuid, uuid, uuid, uuid, uuid)",
+  "confirm_remember_knowledge_claim(uuid, uuid, uuid, uuid, integer, uuid, uuid, uuid)",
+  "undo_governed_learning_activation(uuid, uuid, uuid, uuid)",
+] as const;
+const GOVERNED_LEARNING_INSPECTION_ROUTINES = [
+  "inspect_governed_learning_decisions(uuid, uuid, text, integer)",
+  "inspect_governed_learning_activations(uuid, uuid, text, integer)",
+  "inspect_governed_learning_activation_undos(uuid, uuid, text, integer)",
+] as const;
+const GOVERNED_LEARNING_INSPECTION_AUTHORITY_TABLES = [
+  "governed_learning_decision_receipts",
+  "governed_learning_activation_receipts",
+  "governed_learning_activation_undo_receipts",
+  "sessions",
+] as const;
+const COMPANY_PROFILE_AGENT_ADMIN_ROUTINES = [
+  "propose_company_profile_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid, text, text, text)",
+  "confirm_company_profile_for_attempt(uuid, uuid, uuid, uuid, uuid, integer, uuid, uuid, uuid)",
+] as const;
+const COMPANY_PROFILE_AGENT_ADMIN_AUTHORITY_TABLES = [
+  "company_profile_activation_events",
+  "company_profile_agent_confirmation_receipts",
+  "company_profile_agent_proposal_receipts",
+  "company_profile_heads",
+  "company_profile_revisions",
+  "managed_accounts",
+  "organization_memberships",
+  "session_human_input_requests",
+  "session_turn_attempts",
+  "session_turns",
+  "sessions",
+  "workspaces",
+] as const;
+const GOVERNED_LEARNING_EVALUATION_AUTHORITY_TABLES = [
+  "document_chunks",
+  "documents",
+  "governed_learning_decision_receipts",
+  "knowledge_change_proposals",
+  "knowledge_claim_evidence",
+  "knowledge_claim_relations",
+  "knowledge_claim_reviews",
+  "knowledge_claims",
+  "knowledge_document_versions",
+  "knowledge_providers",
+  "knowledge_source_acl_versions",
+  "knowledge_source_objects",
+  "knowledge_sources",
+  "session_attempt_interruptions",
+  "session_turn_attempts",
+  "session_turns",
+  "sessions",
+  "task_notes",
+  "workspace_learning_policy_snapshots",
+  "workspaces",
+] as const;
+const GOVERNED_LEARNING_ACTIVATION_AUTHORITY_TABLES = [
+  ...GOVERNED_LEARNING_EVALUATION_AUTHORITY_TABLES,
+  "company_brain_preference_proposal_receipts",
+  "governed_learning_activation_receipts",
+  "governed_learning_activation_undo_receipts",
+  "preference_registry_events",
+  "preference_registry_preferences",
+  "preference_registry_revisions",
+  "remember_knowledge_confirmation_receipts",
+  "session_human_input_requests",
+  "workspace_instruction_policy_activation_events",
+  "workspace_instruction_policy_deactivation_events",
+  "workspace_instruction_policy_heads",
+  "workspace_instruction_policy_onboarding_proposals",
+  "workspace_instruction_policy_revisions",
+  "workspace_learning_policy_heads",
+  "workspace_learning_policy_revisions",
 ] as const;
 const TRANSITION_SESSION_VISIBILITY_ROUTINE =
-  "transition_session_visibility(uuid, uuid, uuid, text, text, integer, text, text)";
+  "transition_session_visibility(uuid, uuid, uuid, text, text, integer, text, text, integer)";
+const LEGACY_FORK_SESSION_CONTENT_ROUTINE =
+  "fork_session_content(uuid, uuid, uuid, text, uuid, text, text, text, integer)";
 const FORK_SESSION_CONTENT_ROUTINE =
-  "fork_session_content(uuid, uuid, uuid, text, uuid, text, text, text)";
+  "fork_session_content(uuid, uuid, uuid, text, uuid, text, boolean, text, text, integer)";
+const REPLAY_APPLIED_SESSION_FORK_ROUTINE =
+  "replay_applied_session_fork(uuid, uuid, uuid, text, uuid, text, boolean, text, text, integer)";
+const SESSION_TENANCY_ACTIVATED_ROUTINE = "session_tenancy_product_activated(uuid, integer)";
+const SESSION_TENANCY_ANY_ACTIVATION_ROUTINE = "session_tenancy_any_product_activation()";
+const SESSION_TENANCY_QUIESCENCE_ROUTINE =
+  "assert_session_tenancy_quiescent(uuid, uuid, uuid, boolean)";
+const TENANCY_BACKFILL_ACTIVATION_EVIDENCE_ROUTINE =
+  "check_tenancy_backfill_activation_evidence(uuid)";
+const SESSION_VISIBILITY_LIFECYCLE_CAPABILITY_ROUTINE =
+  "session_visibility_lifecycle_capability_held()";
+const PRIVATE_SESSION_CREATE_CAPABILITY_ROUTINES = [
+  "open_private_session_create_capability(uuid, uuid, uuid, text)",
+  "open_private_child_session_create_capability(uuid, uuid, uuid, uuid, uuid, uuid, integer)",
+  "close_private_session_create_capability(uuid)",
+] as const;
 const SESSION_AUTHORITY_ROUTINES = new Set<string>([
+  LEGACY_FORK_SESSION_CONTENT_ROUTINE,
   FORK_SESSION_CONTENT_ROUTINE,
+  REPLAY_APPLIED_SESSION_FORK_ROUTINE,
+  SESSION_TENANCY_ACTIVATED_ROUTINE,
+  SESSION_TENANCY_ANY_ACTIVATION_ROUTINE,
+  SESSION_TENANCY_QUIESCENCE_ROUTINE,
+  PERSONAL_RESOURCE_ATTEMPT_RESOLVER_ROUTINE,
+  ...USER_RESOURCE_LIFECYCLE_ROUTINES,
+  ...CONNECTION_AUTHORITY_ROUTINES,
+  ...SCHEDULED_PERSONAL_RESOURCE_ROUTINES,
   SESSION_PRIVATE_ACTOR_VISIBLE_ROUTINE,
   SESSION_REFERENCE_VISIBLE_ROUTINE,
+  SESSION_VISIBILITY_LIFECYCLE_CAPABILITY_ROUTINE,
+  ...PRIVATE_SESSION_CREATE_CAPABILITY_ROUTINES,
   TRANSITION_SESSION_VISIBILITY_ROUTINE,
   ...TASK_NOTE_CAPABILITY_ROUTINES,
+  COMPANY_BRAIN_CONTEXT_SELECTION_ROUTINE,
+  COMPANY_BRAIN_CONTEXT_INSPECTION_ROUTINE,
 ]);
 const XAI_CREATE_CREDENTIAL_ROUTINE =
   "create_xai_subscription_credential(uuid, uuid, text, text, text, text, text, text, text, timestamp with time zone)";
@@ -122,7 +439,17 @@ const XAI_AUTHORITY_TABLES = [
 ] as const;
 
 export const RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES = [
+  COMPANY_BRAIN_CONTEXT_INSPECTION_ROUTINE,
+  COMPANY_BRAIN_CONTEXT_SELECTION_ROUTINE,
+  ...COMPANY_PROFILE_AGENT_ADMIN_ROUTINES,
+  GOVERNED_LEARNING_EVALUATION_ROUTINE,
+  ...GOVERNED_LEARNING_ACTIVATION_ROUTINES,
+  ...GOVERNED_LEARNING_INSPECTION_ROUTINES,
   FORK_SESSION_CONTENT_ROUTINE,
+  LEGACY_FORK_SESSION_CONTENT_ROUTINE,
+  REPLAY_APPLIED_SESSION_FORK_ROUTINE,
+  SESSION_TENANCY_ACTIVATED_ROUTINE,
+  SESSION_TENANCY_ANY_ACTIVATION_ROUTINE,
   XAI_AUTHORITY_LIVE_ROUTINE,
   XAI_CREATE_CREDENTIAL_ROUTINE,
   XAI_DISCONNECT_CREDENTIAL_ROUTINE,
@@ -130,9 +457,24 @@ export const RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES = [
   GOOGLE_DRIVE_FILE_AUTHORIZATION_ROUTINE,
   KNOWLEDGE_SOURCE_SYNC_LOCK_AUTHORITY_ROUTINE,
   MANAGED_HUMAN_PERSONAL_WORKSPACE_ROUTINE,
+  ...ORGANIZATION_MEMBERSHIP_LIFECYCLE_ROUTINES,
+  ...ORGANIZATION_PRIVATE_SESSION_ROUTINES,
+  ...PRIVATE_SESSION_CREATE_CAPABILITY_ROUTINES,
+  PERSONAL_RESOURCE_ATTEMPT_RESOLVER_ROUTINE,
+  ...USER_RESOURCE_LIFECYCLE_ROUTINES,
+  PREFERENCE_KNOWLEDGE_PROPOSAL_ROUTINE,
+  ...VARIABLE_SET_AUTHORITY_ROUTINES,
+  ...CONNECTION_AUTHORITY_ROUTINES,
+  ...PERSONAL_GITHUB_REPOSITORY_AUTHORITY_ROUTINES,
+  ...PERSONAL_DOCUMENT_AUTHORITY_ROUTINES,
+  ...DOCUMENT_MIGRATION_AUTHORITY_ROUTINES,
+  ...SCOPED_COMPUTE_AUTHORITY_ROUTINES,
+  ...SCHEDULED_PERSONAL_RESOURCE_ROUTINES,
   ...CANONICAL_HUMAN_IDENTITY_ROUTINES,
+  ...TASK_NOTE_CAPABILITY_ROUTINES,
   SESSION_PRIVATE_ACTOR_VISIBLE_ROUTINE,
   SESSION_REFERENCE_VISIBLE_ROUTINE,
+  SESSION_VISIBILITY_LIFECYCLE_CAPABILITY_ROUTINE,
   TRANSITION_SESSION_VISIBILITY_ROUTINE,
   XAI_POOL_VISIBLE_ROUTINE,
   XAI_RESOLVE_POOL_ROUTINE,
@@ -140,6 +482,27 @@ export const RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES = [
   XAI_SNAPSHOT_VALIDATOR_ROUTINE,
 ] as const;
 
+/**
+ * Boolean-only predicates that shared-table RLS policies must be able to
+ * evaluate under table owners and SECURITY DEFINER roles unknown at migration
+ * time. The capability ledger and the routine that mints its opaque token stay
+ * private; only these exact policy predicates may be PUBLIC-executable.
+ */
+export const RUNTIME_TARGET_SCHEMA_PUBLIC_POLICY_PREDICATE_ROUTINES = [
+  CONNECTION_CONVERGENCE_AUDIT_CAPABILITY_ROUTINE,
+] as const;
+const RUNTIME_TARGET_SCHEMA_PUBLIC_POLICY_PREDICATE_ROUTINE_SET = new Set<string>(
+  RUNTIME_TARGET_SCHEMA_PUBLIC_POLICY_PREDICATE_ROUTINES,
+);
+
+/** Owner-internal helpers that must exist but must never be callable by the runtime role. */
+export const RUNTIME_TARGET_SCHEMA_FORBIDDEN_ROUTINES = [
+  ORGANIZATION_PRIVATE_SESSIONS_ENABLED_ROUTINE,
+  SESSION_TENANCY_QUIESCENCE_ROUTINE,
+  TENANCY_BACKFILL_ACTIVATION_EVIDENCE_ROUTINE,
+  ...DOCUMENT_MIGRATION_AUDIT_INTERNAL_ROUTINES,
+] as const;
+
 export const RUNTIME_TARGET_SCHEMA_INVOKER_ROUTINES = [
   SESSION_REFERENCE_VISIBLE_ROUTINE,
   XAI_SNAPSHOT_VALIDATOR_ROUTINE,
@@ -160,6 +523,12 @@ export const FORCE_RLS_TABLES = [
   "attached_browser_inventories",
   "audit_events",
   "auth_runs",
+  "automation_run_event_links",
+  "automation_runs",
+  "automation_sources",
+  "automation_trigger_events",
+  "automation_trigger_revisions",
+  "automation_triggers",
   "billing_customers",
   "browser_identities",
   "browser_revision_components",
@@ -193,7 +562,12 @@ export const FORCE_RLS_TABLES = [
   "codex_reset_redemption_attempts",
   "codex_rotation_settings",
   "codex_subscription_credentials",
+  "company_brain_context_selection_receipts",
+  "company_brain_preference_proposal_receipts",
+  "company_brain_turn_context_snapshots",
   "company_profile_activation_events",
+  "company_profile_agent_confirmation_receipts",
+  "company_profile_agent_proposal_receipts",
   "company_profile_heads",
   "company_profile_revisions",
   "company_profile_snapshots",
@@ -201,13 +575,19 @@ export const FORCE_RLS_TABLES = [
   "computer_session_associations",
   "computer_sessions",
   "connection_disconnect_operations",
+  "connection_use_audit_facts",
+  "connection_use_once_consumption_receipts",
   "connections",
   "connector_action_policies",
   "connector_action_requests",
   "credit_ledger_entries",
   "device_enrollment_requests",
+  "document_authority_reclassifications",
   "document_bases",
   "document_chunks",
+  "document_default_collection_backfill_operations",
+  "document_default_collection_backfill_receipts",
+  "document_default_collection_backfill_runs",
   "documents",
   "editable_artifact_blob_refs",
   "editable_artifact_idempotency_receipts",
@@ -234,6 +614,9 @@ export const FORCE_RLS_TABLES = [
   "github_installations",
   "google_drive_object_acl_evidence",
   "google_drive_object_acl_principals",
+  "governed_learning_activation_receipts",
+  "governed_learning_activation_undo_receipts",
+  "governed_learning_decision_receipts",
   "host_export_config",
   "host_export_consumers",
   "host_export_cursor_state",
@@ -283,16 +666,37 @@ export const FORCE_RLS_TABLES = [
   "model_call_facts",
   "network_routes",
   "new_session_drafts",
+  "organization_invitation_binding_events",
+  "organization_membership_invitations",
+  "organization_membership_lifecycle_events",
+  "organization_membership_operation_receipts",
   "organization_memberships",
+  "organization_private_session_setting_events",
+  "organization_private_session_settings",
+  "organization_profile_events",
+  "organization_shared_workspace_administration_capabilities",
   "organization_user_resource_authorities",
   "organization_user_resource_grants",
+  "organization_user_retention_deletion_events",
+  "organization_user_retention_deletions",
+  "organization_user_retention_object_deletion_receipts",
+  "organization_user_retention_object_obligations",
   "organization_user_retention_policies",
   "pack_installation_components",
   "pack_installations",
+  "personal_document_once_consumption_receipts",
+  "personal_github_repository_selection_heads",
+  "personal_github_repository_selection_operations",
+  "personal_github_repository_selections",
+  "personal_resource_once_consumption_receipts",
+  "pr_review_app_registrations",
+  "pr_review_repository_bindings",
   "preference_registry_events",
   "preference_registry_preferences",
   "preference_registry_revisions",
   "preference_registry_snapshots",
+  "private_session_create_capabilities",
+  "remember_knowledge_confirmation_receipts",
   "retained_screenshot_artifacts",
   "rig_changes",
   "rig_versions",
@@ -305,11 +709,26 @@ export const FORCE_RLS_TABLES = [
   "sandbox_session_envelopes",
   "sandbox_workspace_mutation_admissions",
   "sandboxes",
+  "scheduled_task_connection_authority_snapshots",
+  "scheduled_task_personal_resource_authorities",
+  "scheduled_task_personal_resource_snapshots",
+  "scheduled_task_reusable_connection_materializations",
+  "scheduled_task_revision_authorities",
+  "scheduled_task_run_connection_authority_snapshots",
+  "scheduled_task_run_personal_resource_admissions",
+  "scheduled_task_run_personal_resource_once_receipts",
+  "scheduled_task_run_personal_resource_snapshots",
   "scheduled_task_runs",
   "scheduled_tasks",
   "session_attempt_codemode_calls",
+  "session_attempt_connected_machine_authorizations",
   "session_attempt_interruptions",
+  "session_attempt_personal_document_admissions",
+  "session_attempt_personal_document_snapshots",
+  "session_attempt_personal_resource_admissions",
+  "session_attempt_personal_resource_snapshots",
   "session_attempt_tool_catalogs",
+  "session_background_commands",
   "session_command_receipts",
   "session_events",
   "session_goal_revisions",
@@ -329,37 +748,52 @@ export const FORCE_RLS_TABLES = [
   "session_stream_acknowledgments",
   "session_system_update_outbox",
   "session_system_updates",
+  "session_tenancy_activations",
   "session_turn_attempts",
+  "session_turn_startup_milestones",
   "session_turns",
   "session_visibility_write_capabilities",
   "session_workflow_wake_outbox",
   "sessions",
   "site_auth_connections",
+  "slack_app_home_refreshes",
   "slack_bot_delete_operations",
   "slack_bot_post_operations",
   "slack_bot_update_operations",
   "slack_bot_user_links",
+  "slack_channel_routes",
   "slack_installation_bindings",
   "slack_interaction_action_handles",
   "slack_interaction_inbox",
   "slack_interaction_progress_deliveries",
   "slack_interactions",
+  "slack_route_prompt_options",
+  "slack_route_prompts",
   "slack_shared_task_origins",
   "slack_task_policy_activation_events",
   "slack_task_policy_heads",
   "slack_task_policy_revisions",
+  "slack_user_dm_routes",
   "slack_user_link_access_request_operations",
   "slack_user_link_access_requests",
   "social_connections",
   "social_posts",
   "task_note_events",
+  "task_note_knowledge_promotion_capabilities",
+  "task_note_replacement_receipts",
   "task_note_write_capabilities",
   "task_notes",
   "temporal_schedule_cleanup_outbox",
+  "tenancy_backfill_receipts",
+  "tenancy_backfill_unresolved_rows",
   "transcription_recording_chunks",
   "transcription_recording_objects",
   "transcription_recording_segments",
   "transcription_recordings",
+  "turn_connection_authority_snapshots",
+  "turn_personal_resource_attachment_receipts",
+  "turn_personal_resource_once_receipts",
+  "turn_personal_resource_snapshots",
   "usage_events",
   "video_generation_operations",
   "video_generation_references",
@@ -370,6 +804,7 @@ export const FORCE_RLS_TABLES = [
   "workspace_control_events",
   "workspace_inference_controls",
   "workspace_instruction_policy_activation_events",
+  "workspace_instruction_policy_deactivation_events",
   "workspace_instruction_policy_heads",
   "workspace_instruction_policy_onboarding_proposals",
   "workspace_instruction_policy_revisions",
@@ -405,6 +840,7 @@ export const NON_RLS_RUNTIME_TABLES = [
   "auth_sessions",
   "auth_users",
   "auth_verifications",
+  "automation_webhook_endpoints",
   "integration_oauth_clients",
   "managed_accounts",
   "nested_agent_depth_configuration",
@@ -427,6 +863,13 @@ export const RUNTIME_FULL_DML_TABLES = [
   "auth_sessions",
   "auth_users",
   "auth_verifications",
+  "automation_run_event_links",
+  "automation_runs",
+  "automation_sources",
+  "automation_trigger_events",
+  "automation_trigger_revisions",
+  "automation_triggers",
+  "automation_webhook_endpoints",
   "billing_customers",
   "browser_session_associations",
   "capability_catalog_items",
@@ -484,6 +927,8 @@ export const RUNTIME_FULL_DML_TABLES = [
   "new_session_drafts",
   "pack_installation_components",
   "pack_installations",
+  "pr_review_app_registrations",
+  "pr_review_repository_bindings",
   "retained_screenshot_artifacts",
   "rig_changes",
   "rig_versions",
@@ -496,9 +941,8 @@ export const RUNTIME_FULL_DML_TABLES = [
   "sandbox_session_envelopes",
   "sandbox_workspace_mutation_admissions",
   "sandboxes",
-  "scheduled_task_runs",
-  "scheduled_tasks",
   "session_attempt_interruptions",
+  "session_background_commands",
   "session_command_receipts",
   "session_events",
   "session_goals",
@@ -520,14 +964,19 @@ export const RUNTIME_FULL_DML_TABLES = [
   "session_turns",
   "session_workflow_wake_outbox",
   "sessions",
+  "slack_app_home_refreshes",
   "slack_bot_delete_operations",
   "slack_bot_post_operations",
   "slack_bot_update_operations",
   "slack_bot_user_links",
+  "slack_channel_routes",
   "slack_interaction_action_handles",
   "slack_interaction_inbox",
   "slack_interaction_progress_deliveries",
   "slack_interactions",
+  "slack_route_prompt_options",
+  "slack_route_prompts",
+  "slack_user_dm_routes",
   "social_connections",
   "social_posts",
   "stripe_webhook_events",
@@ -547,8 +996,6 @@ export const RUNTIME_FULL_DML_TABLES = [
   "workspace_model_policies",
   "workspace_packs",
   "workspace_screenshot_quotas",
-  "workspace_variable_set_variables",
-  "workspace_variable_sets",
   "workspace_video_generation_policies",
   "workspace_video_generation_quotas",
   "workspaces",
@@ -564,16 +1011,19 @@ export const RUNTIME_READ_ONLY_TABLES = [
   "company_profile_activation_events",
   "company_profile_heads",
   "company_profile_snapshots",
+  "document_authority_reclassifications",
   "knowledge_lifecycle_events",
   "knowledge_memory_lifecycle_events",
   "knowledge_memory_relationships",
   "nested_agent_depth_configuration",
   "preference_registry_events",
   "preference_registry_snapshots",
+  "session_tenancy_activations",
   "slack_installation_bindings",
   "slack_task_policy_activation_events",
   "slack_task_policy_heads",
   "slack_task_policy_revisions",
+  "workspace_instruction_policy_deactivation_events",
   "workspace_instruction_policy_snapshots",
   "workspace_learning_policy_activation_events",
   "workspace_learning_policy_heads",
@@ -659,7 +1109,10 @@ export const RUNTIME_READ_INSERT_UPDATE_TABLES = [
   "interaction_operations",
   "interaction_resource_operations",
   "network_routes",
+  "scheduled_task_runs",
+  "scheduled_tasks",
   "session_attempt_codemode_calls",
+  "session_turn_startup_milestones",
   "site_auth_connections",
   "slack_user_link_access_requests",
   "workspace_interaction_revisions",
@@ -674,21 +1127,77 @@ export const PROTECTED_NO_DIRECT_DML_TABLES = [
   "canonical_human_identity_operations",
   "canonical_human_identity_subjects",
   "canonical_human_login_bindings",
+  "company_brain_context_selection_receipts",
+  "company_brain_preference_proposal_receipts",
+  "company_brain_turn_context_snapshots",
+  "company_profile_agent_confirmation_receipts",
+  "company_profile_agent_proposal_receipts",
+  "connection_use_audit_facts",
+  "connection_use_once_consumption_receipts",
+  "document_default_collection_backfill_operations",
+  "document_default_collection_backfill_receipts",
+  "document_default_collection_backfill_runs",
   "editable_artifact_live_tickets",
   "editable_artifact_scope_authorization_heads",
+  "governed_learning_activation_receipts",
+  "governed_learning_activation_undo_receipts",
+  "governed_learning_decision_receipts",
   "host_export_config",
   "host_export_consumers",
   "host_export_cursor_state",
   "host_export_dead_letters",
   "host_export_outbox",
+  "organization_invitation_binding_events",
+  "organization_membership_invitations",
+  "organization_membership_lifecycle_events",
+  "organization_membership_operation_receipts",
   "organization_memberships",
+  "organization_private_session_setting_events",
+  "organization_private_session_settings",
+  "organization_profile_events",
+  "organization_shared_workspace_administration_capabilities",
   "organization_user_resource_authorities",
   "organization_user_resource_grants",
+  "organization_user_retention_deletion_events",
+  "organization_user_retention_deletions",
+  "organization_user_retention_object_deletion_receipts",
+  "organization_user_retention_object_obligations",
   "organization_user_retention_policies",
+  "personal_document_once_consumption_receipts",
+  "personal_github_repository_selection_heads",
+  "personal_github_repository_selection_operations",
+  "personal_github_repository_selections",
+  "personal_resource_once_consumption_receipts",
+  "private_session_create_capabilities",
+  "remember_knowledge_confirmation_receipts",
+  "scheduled_task_connection_authority_snapshots",
+  "scheduled_task_personal_resource_authorities",
+  "scheduled_task_personal_resource_snapshots",
+  "scheduled_task_reusable_connection_materializations",
+  "scheduled_task_revision_authorities",
+  "scheduled_task_run_connection_authority_snapshots",
+  "scheduled_task_run_personal_resource_admissions",
+  "scheduled_task_run_personal_resource_once_receipts",
+  "scheduled_task_run_personal_resource_snapshots",
+  "session_attempt_connected_machine_authorizations",
+  "session_attempt_personal_document_admissions",
+  "session_attempt_personal_document_snapshots",
+  "session_attempt_personal_resource_admissions",
+  "session_attempt_personal_resource_snapshots",
   "session_visibility_write_capabilities",
   "task_note_events",
+  "task_note_knowledge_promotion_capabilities",
+  "task_note_replacement_receipts",
   "task_note_write_capabilities",
   "task_notes",
+  "tenancy_backfill_receipts",
+  "tenancy_backfill_unresolved_rows",
+  "turn_connection_authority_snapshots",
+  "turn_personal_resource_attachment_receipts",
+  "turn_personal_resource_once_receipts",
+  "turn_personal_resource_snapshots",
+  "workspace_variable_set_variables",
+  "workspace_variable_sets",
 ] as const;
 
 export type RuntimeTableDmlPrivilege = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
@@ -728,6 +1237,7 @@ export type RuntimeDatabasePostureOptions = {
   protectedTables?: readonly string[];
   tablePrivileges?: RuntimeTablePrivilegeContract;
   protectedNoDirectDmlTables?: readonly string[];
+  organizationTenancyCanonicalActivationEnabled?: boolean;
 };
 
 export type RuntimeDatabaseIdentity = {
@@ -775,6 +1285,7 @@ export type RuntimeRoutinePosture = {
   name: string;
   owner: string;
   execute: boolean;
+  publicExecute?: boolean;
   securityDefiner: boolean;
 };
 
@@ -782,6 +1293,15 @@ export type RuntimeTargetRoutinePosture = RuntimeRoutinePosture & {
   publicExecute: boolean;
 };
 
+export type RuntimePrivateTablePosture = {
+  name: string;
+  owner: string;
+  select: boolean;
+  insert: boolean;
+  update: boolean;
+  delete: boolean;
+};
+
 export type RuntimeDatabasePosture = {
   identity: RuntimeDatabaseIdentity;
   /** Privilege-bearing role relationships; exact PG16+ management-only grants are excluded. */
@@ -790,8 +1310,10 @@ export type RuntimeDatabasePosture = {
   ownedSchemas: string[];
   ownedRelations: string[];
   tables: RuntimeTablePosture[];
+  privateTables: RuntimePrivateTablePosture[];
   targetRoutines: RuntimeTargetRoutinePosture[];
   privateRoutines: RuntimeRoutinePosture[];
+  sessionTenancyProductActivationPresent: boolean;
 };
 
 export class RuntimeDatabasePostureError extends Error {
@@ -839,7 +1361,7 @@ function difference(left: ReadonlySet<string>, right: ReadonlySet<string>): stri
   return sorted([...left].filter((value) => !right.has(value)));
 }
 
-/** Inspect only PostgreSQL catalogs and privilege functions; no tenant rows. */
+/** Inspect PostgreSQL catalogs plus one value-free global activation predicate; no tenant content. */
 export async function inspectRuntimeDatabasePosture(
   db: Database,
   options: RuntimeDatabasePostureOptions,
@@ -890,6 +1412,15 @@ export async function inspectRuntimeDatabasePosture(
         bypassRls: identity.rolbypassrls,
       };
 
+      // The forward-only activation receipt outlives topology. Embedded/scoped
+      // deployments must enforce the same environment interlock as standalone
+      // FORCE-RLS deployments, so inspect the value-free predicate before the
+      // scoped catalog fast-path.
+      const activationRows = resultRows<{ activated: boolean }>(
+        await tx.execute(sql`select session_tenancy_any_product_activation() as activated`),
+      );
+      const sessionTenancyProductActivationPresent = activationRows[0]?.activated === true;
+
       // Scoped/embedded topology deliberately leaves ownership and isolation to
       // the host. Prove the connection identity is coherent, but do not impose
       // the standalone opengeni_app object/grant contract on the host's role.
@@ -901,8 +1432,10 @@ export async function inspectRuntimeDatabasePosture(
           ownedSchemas: [],
           ownedRelations: [],
           tables: [],
+          privateTables: [],
           targetRoutines: [],
           privateRoutines: [],
+          sessionTenancyProductActivationPresent,
         };
       }
 
@@ -1021,6 +1554,45 @@ export async function inspectRuntimeDatabasePosture(
         trigger: row.can_trigger,
       }));
 
+      const privateTables = resultRows<{
+        name: string;
+        owner: string;
+        can_select: boolean;
+        can_insert: boolean;
+        can_update: boolean;
+        can_delete: boolean;
+      }>(
+        await tx.execute(sql`
+          select
+            c.relname::text as name,
+            pg_get_userbyid(c.relowner)::text as owner,
+            has_table_privilege(current_user, c.oid, 'SELECT') as can_select,
+            has_table_privilege(current_user, c.oid, 'INSERT') as can_insert,
+            has_table_privilege(current_user, c.oid, 'UPDATE') as can_update,
+            has_table_privilege(current_user, c.oid, 'DELETE') as can_delete
+          from pg_class c
+          join pg_namespace n on n.oid = c.relnamespace
+          where n.nspname = 'opengeni_private'
+            and c.relkind in ('r', 'p')
+            and c.relname in (
+              ${PERSONAL_RESOURCE_CAPABILITY_TABLE},
+              ${SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_TABLE},
+              ${VARIABLE_SET_CAPABILITY_TABLE},
+              ${PERSONAL_DOCUMENT_CAPABILITY_TABLE},
+              ${DOCUMENT_MIGRATION_CAPABILITY_TABLE},
+              ${SCOPED_COMPUTE_CAPABILITY_TABLE},
+              ${CONNECTION_TENANCY_BACKFILL_CAPABILITY_TABLE}
+            )
+        `),
+      ).map((row) => ({
+        name: row.name,
+        owner: row.owner,
+        select: row.can_select,
+        insert: row.can_insert,
+        update: row.can_update,
+        delete: row.can_delete,
+      }));
+
       const targetRoutines = resultRows<{
         name: string;
         owner: string;
@@ -1046,25 +1618,31 @@ export async function inspectRuntimeDatabasePosture(
             and (p.proname || '(' || pg_catalog.oidvectortypes(p.proargtypes) || ')') = any(
               array[
                 ${sql.join(
-                  RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES.map((name) => sql`${name}`),
+                  [
+                    ...RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES,
+                    ...RUNTIME_TARGET_SCHEMA_FORBIDDEN_ROUTINES,
+                  ].map((name) => sql`${name}`),
                   sql`, `,
                 )}
               ]::text[]
             )
           order by p.proname, pg_catalog.oidvectortypes(p.proargtypes)
         `),
-      ).map((row) => ({
-        name: row.name,
-        owner: row.owner,
-        execute: row.can_execute,
-        publicExecute: row.public_execute,
-        securityDefiner: row.security_definer,
-      }));
+      )
+        .map((row) => ({
+          name: row.name,
+          owner: row.owner,
+          execute: row.can_execute,
+          publicExecute: row.public_execute,
+          securityDefiner: row.security_definer,
+        }))
+        .sort((left, right) => left.name.localeCompare(right.name));
 
       const privateRoutines = resultRows<{
         name: string;
         owner: string;
         can_execute: boolean;
+        public_execute: boolean;
         security_definer: boolean;
       }>(
         await tx.execute(sql`
@@ -1072,6 +1650,11 @@ export async function inspectRuntimeDatabasePosture(
             (p.proname || '(' || pg_catalog.oidvectortypes(p.proargtypes) || ')')::text as name,
             pg_get_userbyid(p.proowner)::text as owner,
             has_function_privilege(current_user, p.oid, 'EXECUTE') as can_execute,
+            exists (
+              select 1
+              from aclexplode(coalesce(p.proacl, acldefault('f', p.proowner))) acl
+              where acl.grantee = 0 and acl.privilege_type = 'EXECUTE'
+            ) as public_execute,
             p.prosecdef as security_definer
           from pg_proc p
           join pg_namespace n on n.oid = p.pronamespace
@@ -1083,6 +1666,7 @@ export async function inspectRuntimeDatabasePosture(
         name: row.name,
         owner: row.owner,
         execute: row.can_execute,
+        publicExecute: row.public_execute,
         securityDefiner: row.security_definer,
       }));
 
@@ -1093,8 +1677,10 @@ export async function inspectRuntimeDatabasePosture(
         ownedSchemas,
         ownedRelations,
         tables,
+        privateTables,
         targetRoutines,
         privateRoutines,
+        sessionTenancyProductActivationPresent,
       };
     },
     { isolationLevel: "repeatable read", accessMode: "read only" },
@@ -1109,6 +1695,15 @@ export function evaluateRuntimeDatabasePosture(
   const violations: string[] = [];
   const identity = posture.identity;
 
+  if (
+    posture.sessionTenancyProductActivationPresent &&
+    options.organizationTenancyCanonicalActivationEnabled !== true
+  ) {
+    violations.push(
+      "session-tenancy product activation is durable but OPENGENI_ORGANIZATION_TENANCY_CANONICAL_ACTIVATION_ENABLED is not true",
+    );
+  }
+
   if (!identity.currentUser || !identity.sessionUser) {
     violations.push("database identity is empty");
   }
@@ -1264,6 +1859,33 @@ export function evaluateRuntimeDatabasePosture(
   }
 
   const targetSchemaOwner = posture.schemas.find((schema) => schema.name === targetSchema)?.owner;
+  for (const forbiddenRoutine of RUNTIME_TARGET_SCHEMA_FORBIDDEN_ROUTINES) {
+    const matches = posture.targetRoutines.filter((routine) => routine.name === forbiddenRoutine);
+    if (matches.length !== 1) {
+      violations.push(
+        `owner-internal target-schema helper ${forbiddenRoutine} is missing or ambiguous`,
+      );
+      continue;
+    }
+    const routine = matches[0]!;
+    if (!routine.securityDefiner) {
+      violations.push(
+        `owner-internal target-schema helper ${routine.name} is not SECURITY DEFINER`,
+      );
+    }
+    const authorityOwner = tableByName.get("sessions")?.owner ?? targetSchemaOwner;
+    if (authorityOwner && routine.owner !== authorityOwner) {
+      violations.push(
+        `owner-internal target-schema helper ${routine.name} owner ${routine.owner} does not match session authority owner ${authorityOwner}`,
+      );
+    }
+    if (routine.execute) {
+      violations.push(`runtime role has forbidden owner-internal helper ${routine.name}`);
+    }
+    if (routine.publicExecute) {
+      violations.push(`PUBLIC has forbidden owner-internal helper ${routine.name}`);
+    }
+  }
   for (const expectedRoutine of RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES) {
     const matches = posture.targetRoutines.filter((routine) => routine.name === expectedRoutine);
     if (matches.length !== 1) {
@@ -1345,47 +1967,65 @@ export function evaluateRuntimeDatabasePosture(
           `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0].owner}`,
         );
       }
-    } else if ((CANONICAL_HUMAN_IDENTITY_ROUTINES as readonly string[]).includes(routine.name)) {
-      const authorityTables = CANONICAL_HUMAN_IDENTITY_AUTHORITY_TABLES.filter((tableName) =>
-        tableByName.has(tableName),
-      ).map((tableName) => tableByName.get(tableName)!);
-      const authorityOwners = new Set(authorityTables.map((table) => table.owner));
-      if (authorityTables.length !== CANONICAL_HUMAN_IDENTITY_AUTHORITY_TABLES.length) {
-        violations.push(
-          `target-schema runtime capability ${routine.name} canonical identity authority tables are missing`,
-        );
-      } else if (authorityOwners.size !== 1) {
+    } else if (routine.name === GOVERNED_LEARNING_EVALUATION_ROUTINE) {
+      if (!tableByName.has("governed_learning_decision_receipts")) {
+        continue;
+      }
+      const missingAuthorityTables = GOVERNED_LEARNING_EVALUATION_AUTHORITY_TABLES.filter(
+        (tableName) => !tableByName.has(tableName),
+      );
+      if (missingAuthorityTables.length > 0) {
         violations.push(
-          `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
         );
-      } else if (routine.owner !== authorityTables[0]!.owner) {
-        violations.push(
-          `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+      } else {
+        const authorityTables = GOVERNED_LEARNING_EVALUATION_AUTHORITY_TABLES.map(
+          (tableName) => tableByName.get(tableName)!,
         );
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          );
+        } else if (routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+          );
+        }
       }
-    } else if (SESSION_AUTHORITY_ROUTINES.has(routine.name)) {
-      const authorityOwner = tableByName.get("sessions")?.owner ?? targetSchemaOwner;
-      if (authorityOwner && routine.owner !== authorityOwner) {
+    } else if (
+      GOVERNED_LEARNING_INSPECTION_ROUTINES.includes(
+        routine.name as (typeof GOVERNED_LEARNING_INSPECTION_ROUTINES)[number],
+      )
+    ) {
+      if (!tableByName.has("governed_learning_decision_receipts")) continue;
+      const missingAuthorityTables = GOVERNED_LEARNING_INSPECTION_AUTHORITY_TABLES.filter(
+        (name) => !tableByName.has(name),
+      );
+      if (missingAuthorityTables.length > 0) {
         violations.push(
-          `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match session authority owner ${authorityOwner}`,
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
         );
+      } else {
+        const authorityTables = GOVERNED_LEARNING_INSPECTION_AUTHORITY_TABLES.map(
+          (name) => tableByName.get(name)!,
+        );
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1 || routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner does not match governed-learning inspection authority`,
+          );
+        }
       }
-    } else if (routine.name === XAI_SNAPSHOT_VALIDATOR_ROUTINE) {
-      // The immutable SQL validator is invoker-rights and reads no table. Its
-      // exact ACL is posture-checked above; it does not participate in the
-      // SECURITY DEFINER same-owner authority graph.
     } else if (
-      routine.name === XAI_CREATE_CREDENTIAL_ROUTINE ||
-      routine.name === XAI_DISCONNECT_CREDENTIAL_ROUTINE ||
-      routine.name === XAI_AUTHORITY_LIVE_ROUTINE ||
-      routine.name === XAI_POOL_VISIBLE_ROUTINE ||
-      routine.name === XAI_RESOLVE_POOL_ROUTINE ||
-      routine.name === XAI_REVALIDATE_CREDENTIAL_ROUTINE
+      GOVERNED_LEARNING_ACTIVATION_ROUTINES.includes(
+        routine.name as (typeof GOVERNED_LEARNING_ACTIVATION_ROUTINES)[number],
+      )
     ) {
-      if (!tableByName.has("xai_subscription_credentials")) {
+      if (!tableByName.has("governed_learning_activation_receipts")) {
         continue;
       }
-      const missingAuthorityTables = XAI_AUTHORITY_TABLES.filter(
+      const missingAuthorityTables = GOVERNED_LEARNING_ACTIVATION_AUTHORITY_TABLES.filter(
         (tableName) => !tableByName.has(tableName),
       );
       if (missingAuthorityTables.length > 0) {
@@ -1393,7 +2033,7 @@ export function evaluateRuntimeDatabasePosture(
           `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
         );
       } else {
-        const authorityTables = XAI_AUTHORITY_TABLES.map(
+        const authorityTables = GOVERNED_LEARNING_ACTIVATION_AUTHORITY_TABLES.map(
           (tableName) => tableByName.get(tableName)!,
         );
         const authorityOwners = new Set(authorityTables.map((table) => table.owner));
@@ -1407,33 +2047,271 @@ export function evaluateRuntimeDatabasePosture(
           );
         }
       }
-    } else if (targetSchemaOwner && routine.owner !== targetSchemaOwner) {
-      violations.push(
-        `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match schema owner ${targetSchemaOwner}`,
+    } else if (
+      COMPANY_PROFILE_AGENT_ADMIN_ROUTINES.includes(
+        routine.name as (typeof COMPANY_PROFILE_AGENT_ADMIN_ROUTINES)[number],
+      )
+    ) {
+      const missingAuthorityTables = COMPANY_PROFILE_AGENT_ADMIN_AUTHORITY_TABLES.filter(
+        (tableName) => !tableByName.has(tableName),
       );
-    }
-    if (!routine.execute) {
-      violations.push(`runtime role lacks target-schema capability ${routine.name}`);
-    }
-    if (routine.publicExecute) {
-      violations.push(`PUBLIC has forbidden target-schema capability ${routine.name}`);
-    }
-  }
-
-  const artifactOutbox = tableByName.get("editable_artifact_live_outbox");
-  if (artifactOutbox) {
-    if (!artifactOutbox.artifactOutboxDispatcherPolicy) {
-      violations.push("table editable_artifact_live_outbox lacks its owner dispatcher RLS policy");
-    }
-    for (const expectedRoutine of ARTIFACT_OUTBOX_CAPABILITY_ROUTINES) {
-      const matches = posture.privateRoutines.filter((routine) => routine.name === expectedRoutine);
-      if (matches.length !== 1) {
-        violations.push(`artifact outbox capability ${expectedRoutine} is missing or ambiguous`);
-        continue;
-      }
-      const routine = matches[0]!;
-      if (!routine.securityDefiner) {
-        violations.push(`artifact outbox capability ${routine.name} is not SECURITY DEFINER`);
+      if (missingAuthorityTables.length > 0) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
+        );
+      } else {
+        const authorityTables = COMPANY_PROFILE_AGENT_ADMIN_AUTHORITY_TABLES.map(
+          (tableName) => tableByName.get(tableName)!,
+        );
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          );
+        } else if (routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+          );
+        }
+      }
+    } else if (
+      (ORGANIZATION_MEMBERSHIP_LIFECYCLE_ROUTINES as readonly string[]).includes(routine.name)
+    ) {
+      const missingAuthorityTables = ORGANIZATION_MEMBERSHIP_LIFECYCLE_AUTHORITY_TABLES.filter(
+        (tableName) => !tableByName.has(tableName),
+      );
+      if (missingAuthorityTables.length > 0) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
+        );
+      } else {
+        const authorityTables = ORGANIZATION_MEMBERSHIP_LIFECYCLE_AUTHORITY_TABLES.map(
+          (tableName) => tableByName.get(tableName)!,
+        );
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          );
+        } else if (routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+          );
+        }
+      }
+    } else if (
+      (ORGANIZATION_PRIVATE_SESSION_ROUTINES as readonly string[]).includes(routine.name)
+    ) {
+      if (!tableByName.has("organization_private_session_settings")) {
+        continue;
+      }
+      const authorityTableNames =
+        ORGANIZATION_PRIVATE_SESSION_ROUTINE_AUTHORITY_TABLES[
+          routine.name as keyof typeof ORGANIZATION_PRIVATE_SESSION_ROUTINE_AUTHORITY_TABLES
+        ];
+      const missingAuthorityTables = authorityTableNames.filter(
+        (tableName) => !tableByName.has(tableName),
+      );
+      if (missingAuthorityTables.length > 0) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
+        );
+      } else {
+        const authorityTables = authorityTableNames.map((tableName) => tableByName.get(tableName)!);
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          );
+        } else if (routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+          );
+        }
+      }
+    } else if (routine.name === PREFERENCE_KNOWLEDGE_PROPOSAL_ROUTINE) {
+      if (!tableByName.has("company_brain_preference_proposal_receipts")) {
+        continue;
+      }
+      const missingAuthorityTables = PREFERENCE_KNOWLEDGE_PROPOSAL_AUTHORITY_TABLES.filter(
+        (tableName) => !tableByName.has(tableName),
+      );
+      if (missingAuthorityTables.length > 0) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
+        );
+      } else {
+        const authorityTables = PREFERENCE_KNOWLEDGE_PROPOSAL_AUTHORITY_TABLES.map(
+          (tableName) => tableByName.get(tableName)!,
+        );
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          );
+        } else if (routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+          );
+        }
+      }
+    } else if ((CANONICAL_HUMAN_IDENTITY_ROUTINES as readonly string[]).includes(routine.name)) {
+      const authorityTables = CANONICAL_HUMAN_IDENTITY_AUTHORITY_TABLES.filter((tableName) =>
+        tableByName.has(tableName),
+      ).map((tableName) => tableByName.get(tableName)!);
+      const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+      if (authorityTables.length !== CANONICAL_HUMAN_IDENTITY_AUTHORITY_TABLES.length) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} canonical identity authority tables are missing`,
+        );
+      } else if (authorityOwners.size !== 1) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+        );
+      } else if (routine.owner !== authorityTables[0]!.owner) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+        );
+      }
+    } else if (
+      (PERSONAL_GITHUB_REPOSITORY_AUTHORITY_ROUTINES as readonly string[]).includes(routine.name)
+    ) {
+      const authorityTables = PERSONAL_GITHUB_REPOSITORY_AUTHORITY_TABLES.map((tableName) =>
+        tableByName.get(tableName),
+      ).filter((table): table is RuntimeTablePosture => table !== undefined);
+      const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+      if (authorityOwners.size > 1) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} personal GitHub repository authority table owners do not match`,
+        );
+      } else {
+        const authorityOwner = authorityTables[0]?.owner ?? targetSchemaOwner;
+        if (authorityOwner && routine.owner !== authorityOwner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match personal GitHub repository authority owner ${authorityOwner}`,
+          );
+        }
+      }
+    } else if (
+      (PERSONAL_DOCUMENT_AUTHORITY_ROUTINES as readonly string[]).includes(routine.name) ||
+      (DOCUMENT_MIGRATION_AUTHORITY_ROUTINES as readonly string[]).includes(routine.name)
+    ) {
+      const authorityOwner = tableByName.get("documents")?.owner ?? targetSchemaOwner;
+      if (authorityOwner && routine.owner !== authorityOwner) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match document authority owner ${authorityOwner}`,
+        );
+      }
+    } else if ((VARIABLE_SET_AUTHORITY_ROUTINES as readonly string[]).includes(routine.name)) {
+      const authorityTables = ["workspace_variable_sets", "workspace_variable_set_variables"]
+        .map((tableName) => tableByName.get(tableName))
+        .filter((table): table is RuntimeTablePosture => table !== undefined);
+      const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+      if (authorityOwners.size > 1) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} variable-set table owners do not match`,
+        );
+      } else {
+        const authorityOwner = authorityTables[0]?.owner ?? targetSchemaOwner;
+        if (authorityOwner && routine.owner !== authorityOwner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match variable-set authority owner ${authorityOwner}`,
+          );
+        }
+      }
+    } else if ((SCOPED_COMPUTE_AUTHORITY_ROUTINES as readonly string[]).includes(routine.name)) {
+      const authorityTables = ["rigs", "rig_versions", "enrollments", "sandboxes"]
+        .map((tableName) => tableByName.get(tableName))
+        .filter((table): table is RuntimeTablePosture => table !== undefined);
+      const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+      if (authorityOwners.size > 1) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} scoped-compute table owners do not match`,
+        );
+      } else {
+        const authorityOwner = authorityTables[0]?.owner ?? targetSchemaOwner;
+        if (authorityOwner && routine.owner !== authorityOwner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match scoped-compute authority owner ${authorityOwner}`,
+          );
+        }
+      }
+    } else if (SESSION_AUTHORITY_ROUTINES.has(routine.name)) {
+      const authorityOwner = tableByName.get("sessions")?.owner ?? targetSchemaOwner;
+      if (authorityOwner && routine.owner !== authorityOwner) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match session authority owner ${authorityOwner}`,
+        );
+      }
+    } else if (routine.name === XAI_SNAPSHOT_VALIDATOR_ROUTINE) {
+      // The immutable SQL validator is invoker-rights and reads no table. Its
+      // exact ACL is posture-checked above; it does not participate in the
+      // SECURITY DEFINER same-owner authority graph.
+    } else if (
+      routine.name === XAI_CREATE_CREDENTIAL_ROUTINE ||
+      routine.name === XAI_DISCONNECT_CREDENTIAL_ROUTINE ||
+      routine.name === XAI_AUTHORITY_LIVE_ROUTINE ||
+      routine.name === XAI_POOL_VISIBLE_ROUTINE ||
+      routine.name === XAI_RESOLVE_POOL_ROUTINE ||
+      routine.name === XAI_REVALIDATE_CREDENTIAL_ROUTINE
+    ) {
+      if (!tableByName.has("xai_subscription_credentials")) {
+        continue;
+      }
+      const missingAuthorityTables = XAI_AUTHORITY_TABLES.filter(
+        (tableName) => !tableByName.has(tableName),
+      );
+      if (missingAuthorityTables.length > 0) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} authority tables are missing: ${missingAuthorityTables.join(", ")}`,
+        );
+      } else {
+        const authorityTables = XAI_AUTHORITY_TABLES.map(
+          (tableName) => tableByName.get(tableName)!,
+        );
+        const authorityOwners = new Set(authorityTables.map((table) => table.owner));
+        if (authorityOwners.size !== 1) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} authority table owners do not match: ${authorityTables.map((table) => `${table.name}=${table.owner}`).join(", ")}`,
+          );
+        } else if (routine.owner !== authorityTables[0]!.owner) {
+          violations.push(
+            `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match authority table owner ${authorityTables[0]!.owner}`,
+          );
+        }
+      }
+    } else if (targetSchemaOwner && routine.owner !== targetSchemaOwner) {
+      violations.push(
+        `target-schema runtime capability ${routine.name} owner ${routine.owner} does not match schema owner ${targetSchemaOwner}`,
+      );
+    }
+    if (!routine.execute) {
+      violations.push(`runtime role lacks target-schema capability ${routine.name}`);
+    }
+    const publicPolicyPredicate = RUNTIME_TARGET_SCHEMA_PUBLIC_POLICY_PREDICATE_ROUTINE_SET.has(
+      routine.name,
+    );
+    if (publicPolicyPredicate && !routine.publicExecute) {
+      violations.push(`PUBLIC lacks required shared-policy predicate ${routine.name}`);
+    } else if (!publicPolicyPredicate && routine.publicExecute) {
+      violations.push(`PUBLIC has forbidden target-schema capability ${routine.name}`);
+    }
+  }
+
+  const artifactOutbox = tableByName.get("editable_artifact_live_outbox");
+  if (artifactOutbox) {
+    if (!artifactOutbox.artifactOutboxDispatcherPolicy) {
+      violations.push("table editable_artifact_live_outbox lacks its owner dispatcher RLS policy");
+    }
+    for (const expectedRoutine of ARTIFACT_OUTBOX_CAPABILITY_ROUTINES) {
+      const matches = posture.privateRoutines.filter((routine) => routine.name === expectedRoutine);
+      if (matches.length !== 1) {
+        violations.push(`artifact outbox capability ${expectedRoutine} is missing or ambiguous`);
+        continue;
+      }
+      const routine = matches[0]!;
+      if (!routine.securityDefiner) {
+        violations.push(`artifact outbox capability ${routine.name} is not SECURITY DEFINER`);
       }
       if (routine.owner !== artifactOutbox.owner) {
         violations.push(
@@ -1586,9 +2464,376 @@ export function evaluateRuntimeDatabasePosture(
     }
   }
 
+  const personalResourceCapabilityTables = posture.privateTables.filter(
+    (table) => table.name === PERSONAL_RESOURCE_CAPABILITY_TABLE,
+  );
+  const personalResourceCapabilityRoutines = posture.privateRoutines.filter(
+    (routine) => routine.name === PERSONAL_RESOURCE_CAPABILITY_PREDICATE_ROUTINE,
+  );
+  if (personalResourceCapabilityTables.length !== 1) {
+    violations.push(
+      `personal-resource capability table ${PERSONAL_RESOURCE_CAPABILITY_TABLE} is missing or ambiguous`,
+    );
+  }
+  if (personalResourceCapabilityRoutines.length !== 1) {
+    violations.push(
+      `personal-resource capability predicate ${PERSONAL_RESOURCE_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+    );
+  }
+  if (
+    personalResourceCapabilityTables.length === 1 &&
+    personalResourceCapabilityRoutines.length === 1
+  ) {
+    const table = personalResourceCapabilityTables[0]!;
+    const routine = personalResourceCapabilityRoutines[0]!;
+    if (routine.owner !== table.owner) {
+      violations.push(
+        `personal-resource capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+      );
+    }
+    if (!routine.securityDefiner) {
+      violations.push(
+        `personal-resource capability predicate ${routine.name} is not SECURITY DEFINER`,
+      );
+    }
+    if (!routine.execute) {
+      violations.push(`runtime role lacks personal-resource capability predicate ${routine.name}`);
+    }
+    if (routine.publicExecute) {
+      violations.push(
+        `PUBLIC has forbidden personal-resource capability predicate ${routine.name}`,
+      );
+    }
+    const directPrivileges = [
+      ["SELECT", table.select],
+      ["INSERT", table.insert],
+      ["UPDATE", table.update],
+      ["DELETE", table.delete],
+    ].filter(([, granted]) => granted);
+    if (directPrivileges.length > 0) {
+      violations.push(
+        `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+      );
+    }
+  }
+
+  const personalDocumentCapabilityTables = posture.privateTables.filter(
+    (table) => table.name === PERSONAL_DOCUMENT_CAPABILITY_TABLE,
+  );
+  const personalDocumentCapabilityRoutines = posture.privateRoutines.filter(
+    (routine) => routine.name === PERSONAL_DOCUMENT_CAPABILITY_PREDICATE_ROUTINE,
+  );
+  if (personalDocumentCapabilityTables.length !== 1) {
+    violations.push(
+      `personal-document capability table ${PERSONAL_DOCUMENT_CAPABILITY_TABLE} is missing or ambiguous`,
+    );
+  }
+  if (personalDocumentCapabilityRoutines.length !== 1) {
+    violations.push(
+      `personal-document capability predicate ${PERSONAL_DOCUMENT_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+    );
+  }
+  if (
+    personalDocumentCapabilityTables.length === 1 &&
+    personalDocumentCapabilityRoutines.length === 1
+  ) {
+    const table = personalDocumentCapabilityTables[0]!;
+    const routine = personalDocumentCapabilityRoutines[0]!;
+    if (routine.owner !== table.owner) {
+      violations.push(
+        `personal-document capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+      );
+    }
+    if (!routine.securityDefiner) {
+      violations.push(
+        `personal-document capability predicate ${routine.name} is not SECURITY DEFINER`,
+      );
+    }
+    if (!routine.execute) {
+      violations.push(`runtime role lacks personal-document capability predicate ${routine.name}`);
+    }
+    if (routine.publicExecute) {
+      violations.push(
+        `PUBLIC has forbidden personal-document capability predicate ${routine.name}`,
+      );
+    }
+    const directPrivileges = [
+      ["SELECT", table.select],
+      ["INSERT", table.insert],
+      ["UPDATE", table.update],
+      ["DELETE", table.delete],
+    ].filter(([, granted]) => granted);
+    if (directPrivileges.length > 0) {
+      violations.push(
+        `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+      );
+    }
+  }
+
+  const documentMigrationCapabilityTables = posture.privateTables.filter(
+    (table) => table.name === DOCUMENT_MIGRATION_CAPABILITY_TABLE,
+  );
+  const documentMigrationCapabilityRoutines = posture.privateRoutines.filter(
+    (routine) => routine.name === DOCUMENT_MIGRATION_CAPABILITY_PREDICATE_ROUTINE,
+  );
+  if (documentMigrationCapabilityTables.length !== 1) {
+    violations.push(
+      `document-migration capability table ${DOCUMENT_MIGRATION_CAPABILITY_TABLE} is missing or ambiguous`,
+    );
+  }
+  if (documentMigrationCapabilityRoutines.length !== 1) {
+    violations.push(
+      `document-migration capability predicate ${DOCUMENT_MIGRATION_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+    );
+  }
+  if (
+    documentMigrationCapabilityTables.length === 1 &&
+    documentMigrationCapabilityRoutines.length === 1
+  ) {
+    const table = documentMigrationCapabilityTables[0]!;
+    const routine = documentMigrationCapabilityRoutines[0]!;
+    if (routine.owner !== table.owner) {
+      violations.push(
+        `document-migration capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+      );
+    }
+    if (!routine.securityDefiner) {
+      violations.push(
+        `document-migration capability predicate ${routine.name} is not SECURITY DEFINER`,
+      );
+    }
+    if (!routine.execute) {
+      violations.push(`runtime role lacks document-migration capability predicate ${routine.name}`);
+    }
+    if (routine.publicExecute) {
+      violations.push(
+        `PUBLIC has forbidden document-migration capability predicate ${routine.name}`,
+      );
+    }
+    const directPrivileges = [
+      ["SELECT", table.select],
+      ["INSERT", table.insert],
+      ["UPDATE", table.update],
+      ["DELETE", table.delete],
+    ].filter(([, granted]) => granted);
+    if (directPrivileges.length > 0) {
+      violations.push(
+        `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+      );
+    }
+  }
+
+  const scheduledCapabilityTables = posture.privateTables.filter(
+    (table) => table.name === SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_TABLE,
+  );
+  const scheduledCapabilityRoutines = posture.privateRoutines.filter(
+    (routine) => routine.name === SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_PREDICATE_ROUTINE,
+  );
+  if (scheduledCapabilityTables.length !== 1) {
+    violations.push(
+      `scheduled personal-resource capability table ${SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_TABLE} is missing or ambiguous`,
+    );
+  }
+  if (scheduledCapabilityRoutines.length !== 1) {
+    violations.push(
+      `scheduled personal-resource capability predicate ${SCHEDULED_PERSONAL_RESOURCE_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+    );
+  }
+  if (scheduledCapabilityTables.length === 1 && scheduledCapabilityRoutines.length === 1) {
+    const table = scheduledCapabilityTables[0]!;
+    const routine = scheduledCapabilityRoutines[0]!;
+    if (routine.owner !== table.owner) {
+      violations.push(
+        `scheduled personal-resource capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+      );
+    }
+    if (!routine.securityDefiner) {
+      violations.push(
+        `scheduled personal-resource capability predicate ${routine.name} is not SECURITY DEFINER`,
+      );
+    }
+    if (!routine.execute) {
+      violations.push(
+        `runtime role lacks scheduled personal-resource capability predicate ${routine.name}`,
+      );
+    }
+    if (routine.publicExecute) {
+      violations.push(
+        `PUBLIC has forbidden scheduled personal-resource capability predicate ${routine.name}`,
+      );
+    }
+    const directPrivileges = [
+      ["SELECT", table.select],
+      ["INSERT", table.insert],
+      ["UPDATE", table.update],
+      ["DELETE", table.delete],
+    ].filter(([, granted]) => granted);
+    if (directPrivileges.length > 0) {
+      violations.push(
+        `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+      );
+    }
+  }
+
+  if (options.protectedTables === undefined) {
+    const variableSetCapabilityTables = posture.privateTables.filter(
+      (table) => table.name === VARIABLE_SET_CAPABILITY_TABLE,
+    );
+    const variableSetCapabilityRoutines = posture.privateRoutines.filter(
+      (routine) => routine.name === VARIABLE_SET_CAPABILITY_PREDICATE_ROUTINE,
+    );
+    if (variableSetCapabilityTables.length !== 1) {
+      violations.push(
+        `variable-set capability table ${VARIABLE_SET_CAPABILITY_TABLE} is missing or ambiguous`,
+      );
+    }
+    if (variableSetCapabilityRoutines.length !== 1) {
+      violations.push(
+        `variable-set capability predicate ${VARIABLE_SET_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+      );
+    }
+    if (variableSetCapabilityTables.length === 1 && variableSetCapabilityRoutines.length === 1) {
+      const table = variableSetCapabilityTables[0]!;
+      const routine = variableSetCapabilityRoutines[0]!;
+      if (routine.owner !== table.owner) {
+        violations.push(
+          `variable-set capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+        );
+      }
+      if (!routine.securityDefiner) {
+        violations.push(
+          `variable-set capability predicate ${routine.name} is not SECURITY DEFINER`,
+        );
+      }
+      if (!routine.execute) {
+        violations.push(`runtime role lacks variable-set capability predicate ${routine.name}`);
+      }
+      if (routine.publicExecute) {
+        violations.push(`PUBLIC has forbidden variable-set capability predicate ${routine.name}`);
+      }
+      const directPrivileges = [
+        ["SELECT", table.select],
+        ["INSERT", table.insert],
+        ["UPDATE", table.update],
+        ["DELETE", table.delete],
+      ].filter(([, granted]) => granted);
+      if (directPrivileges.length > 0) {
+        violations.push(
+          `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+        );
+      }
+    }
+    const scopedComputeCapabilityTables = posture.privateTables.filter(
+      (table) => table.name === SCOPED_COMPUTE_CAPABILITY_TABLE,
+    );
+    const scopedComputeCapabilityRoutines = posture.privateRoutines.filter(
+      (routine) => routine.name === SCOPED_COMPUTE_CAPABILITY_PREDICATE_ROUTINE,
+    );
+    if (scopedComputeCapabilityTables.length !== 1) {
+      violations.push(
+        `scoped-compute capability table ${SCOPED_COMPUTE_CAPABILITY_TABLE} is missing or ambiguous`,
+      );
+    }
+    if (scopedComputeCapabilityRoutines.length !== 1) {
+      violations.push(
+        `scoped-compute capability predicate ${SCOPED_COMPUTE_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+      );
+    }
+    if (
+      scopedComputeCapabilityTables.length === 1 &&
+      scopedComputeCapabilityRoutines.length === 1
+    ) {
+      const table = scopedComputeCapabilityTables[0]!;
+      const routine = scopedComputeCapabilityRoutines[0]!;
+      if (routine.owner !== table.owner) {
+        violations.push(
+          `scoped-compute capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+        );
+      }
+      if (!routine.securityDefiner) {
+        violations.push(
+          `scoped-compute capability predicate ${routine.name} is not SECURITY DEFINER`,
+        );
+      }
+      if (!routine.execute) {
+        violations.push(`runtime role lacks scoped-compute capability predicate ${routine.name}`);
+      }
+      if (routine.publicExecute) {
+        violations.push(`PUBLIC has forbidden scoped-compute capability predicate ${routine.name}`);
+      }
+      const directPrivileges = [
+        ["SELECT", table.select],
+        ["INSERT", table.insert],
+        ["UPDATE", table.update],
+        ["DELETE", table.delete],
+      ].filter(([, granted]) => granted);
+      if (directPrivileges.length > 0) {
+        violations.push(
+          `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+        );
+      }
+    }
+  }
+
   if (posture.privateRoutines.length === 0) {
     violations.push("opengeni_private has no helper routines");
   }
+
+  const connectionBackfillCapabilityTables = posture.privateTables.filter(
+    (table) => table.name === CONNECTION_TENANCY_BACKFILL_CAPABILITY_TABLE,
+  );
+  const connectionBackfillCapabilityRoutines = posture.privateRoutines.filter(
+    (routine) => routine.name === CONNECTION_TENANCY_BACKFILL_CAPABILITY_PREDICATE_ROUTINE,
+  );
+  if (connectionBackfillCapabilityTables.length !== 1) {
+    violations.push(
+      `connection-tenancy backfill capability table ${CONNECTION_TENANCY_BACKFILL_CAPABILITY_TABLE} is missing or ambiguous`,
+    );
+  }
+  if (connectionBackfillCapabilityRoutines.length !== 1) {
+    violations.push(
+      `connection-tenancy backfill capability predicate ${CONNECTION_TENANCY_BACKFILL_CAPABILITY_PREDICATE_ROUTINE} is missing or ambiguous`,
+    );
+  }
+  if (
+    connectionBackfillCapabilityTables.length === 1 &&
+    connectionBackfillCapabilityRoutines.length === 1
+  ) {
+    const table = connectionBackfillCapabilityTables[0]!;
+    const routine = connectionBackfillCapabilityRoutines[0]!;
+    if (routine.owner !== table.owner) {
+      violations.push(
+        `connection-tenancy backfill capability predicate ${routine.name} owner ${routine.owner} does not match table owner ${table.owner}`,
+      );
+    }
+    if (!routine.securityDefiner) {
+      violations.push(
+        `connection-tenancy backfill capability predicate ${routine.name} is not SECURITY DEFINER`,
+      );
+    }
+    if (!routine.execute) {
+      violations.push(
+        `runtime role lacks connection-tenancy backfill capability predicate ${routine.name}`,
+      );
+    }
+    if (routine.publicExecute) {
+      violations.push(
+        `PUBLIC has forbidden connection-tenancy backfill capability predicate ${routine.name}`,
+      );
+    }
+    const directPrivileges = [
+      ["SELECT", table.select],
+      ["INSERT", table.insert],
+      ["UPDATE", table.update],
+      ["DELETE", table.delete],
+    ].filter(([, granted]) => granted);
+    if (directPrivileges.length > 0) {
+      violations.push(
+        `runtime role has forbidden direct privileges on private table ${table.name}: ${directPrivileges.map(([privilege]) => privilege).join(", ")}`,
+      );
+    }
+  }
+
   for (const routine of posture.privateRoutines) {
     if (routine.owner === expectedRole) {
       violations.push(`runtime role owns private routine ${routine.name}`);