@opengeni/db 0.28.9 → 0.36.0

package/src/runtime-posture.ts

@@ -6,6 +6,130 @@ import {
   type RoleRelationshipCatalogRow,
 } from "./role-relationships";
 
+const ARTIFACT_OUTBOX_CAPABILITY_ROUTINES = [
+  "claim_editable_artifact_live_outbox(text, integer, integer, name)",
+  "mark_editable_artifact_live_outbox_published(text, text, integer, name)",
+  "renew_editable_artifact_live_outbox(text, text, integer, integer, name)",
+  "retry_editable_artifact_live_outbox(text, text, integer, integer, text, name)",
+  "dead_letter_editable_artifact_live_outbox(text, text, integer, text, name)",
+  "release_editable_artifact_live_outbox(text, text, integer, name)",
+] as const;
+
+const ARTIFACT_MATERIALIZER_CAPABILITY_ROUTINES = [
+  "claim_editable_artifact_materializations(text, integer, integer, name)",
+  "renew_editable_artifact_materialization(uuid, uuid, text, text, text, integer, integer, name)",
+  "succeed_editable_artifact_materialization(uuid, uuid, text, text, text, integer, text, text, text, bigint, text, text, timestamp with time zone, name)",
+  "fail_editable_artifact_materialization(uuid, uuid, text, text, text, integer, text, name)",
+] as const;
+
+const ARTIFACT_LIVE_TICKET_CAPABILITY_ROUTINES = [
+  "put_editable_artifact_live_ticket(text, uuid, uuid, text, text, text, text, text, text, text, text, integer, text, boolean, integer, timestamp with time zone, timestamp with time zone, name)",
+  "consume_editable_artifact_live_ticket(text, name)",
+  "cleanup_expired_editable_artifact_live_tickets(integer, name)",
+] as const;
+
+const ARTIFACT_LIVE_TICKET_INTERNAL_ROUTINES = [
+  "resolve_editable_artifact_ticket_data_schema(name)",
+] as const;
+
+const ARTIFACT_AUTHORIZATION_CAPABILITY_ROUTINES = [
+  "authorize_editable_artifact_actor(uuid, uuid, text, text, text, text, text, text, integer, text, text, name)",
+] as const;
+
+const DEDICATED_ARTIFACT_CAPABILITY_ROUTINES = new Set<string>([
+  ...ARTIFACT_OUTBOX_CAPABILITY_ROUTINES,
+  ...ARTIFACT_MATERIALIZER_CAPABILITY_ROUTINES,
+  ...ARTIFACT_LIVE_TICKET_INTERNAL_ROUTINES,
+]);
+
+const KNOWLEDGE_SOURCE_SYNC_LOCK_AUTHORITY_ROUTINE =
+  "knowledge_source_sync_lock_authority(uuid, uuid, uuid)";
+const KNOWLEDGE_SOURCE_SYNC_LOCK_AUTHORITY_TABLES = [
+  "knowledge_sources",
+  "knowledge_source_objects",
+] as const;
+const MANAGED_HUMAN_PERSONAL_WORKSPACE_ROUTINE =
+  "ensure_managed_human_personal_workspace(uuid, text, uuid)";
+const MANAGED_HUMAN_PERSONAL_WORKSPACE_AUTHORITY_TABLES = [
+  "organization_memberships",
+  "organization_user_retention_policies",
+  "organization_user_resource_authorities",
+  "organization_user_resource_grants",
+] as const;
+const CANONICAL_HUMAN_IDENTITY_ROUTINES = [
+  "ensure_canonical_human_identity(text, text)",
+  "validate_canonical_human_session(text, text, boolean)",
+  "get_canonical_human_identity_projection(text)",
+  "apply_canonical_human_identity_operation(uuid, text, bigint, text, uuid, text, text, text)",
+] as const;
+const CANONICAL_HUMAN_IDENTITY_AUTHORITY_TABLES = [
+  "canonical_human_identities",
+  "canonical_human_identity_subjects",
+  "canonical_human_login_bindings",
+  "canonical_human_identity_operations",
+] as const;
+const SESSION_PRIVATE_ACTOR_VISIBLE_ROUTINE =
+  "session_private_actor_visible(uuid, uuid, uuid, text)";
+const SESSION_REFERENCE_VISIBLE_ROUTINE = "session_reference_visible(uuid, uuid, uuid)";
+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)",
+] as const;
+const TRANSITION_SESSION_VISIBILITY_ROUTINE =
+  "transition_session_visibility(uuid, uuid, uuid, text, text, integer, text, text)";
+const FORK_SESSION_CONTENT_ROUTINE =
+  "fork_session_content(uuid, uuid, uuid, text, uuid, text, text, text)";
+const SESSION_AUTHORITY_ROUTINES = new Set<string>([
+  FORK_SESSION_CONTENT_ROUTINE,
+  SESSION_PRIVATE_ACTOR_VISIBLE_ROUTINE,
+  SESSION_REFERENCE_VISIBLE_ROUTINE,
+  TRANSITION_SESSION_VISIBILITY_ROUTINE,
+  ...TASK_NOTE_CAPABILITY_ROUTINES,
+]);
+const XAI_CREATE_CREDENTIAL_ROUTINE =
+  "create_xai_subscription_credential(uuid, uuid, text, text, text, text, text, text, text, timestamp with time zone)";
+const XAI_DISCONNECT_CREDENTIAL_ROUTINE =
+  "disconnect_xai_subscription_credential(uuid, uuid, text, uuid, jsonb)";
+const XAI_SNAPSHOT_VALIDATOR_ROUTINE = "xai_provider_account_authority_snapshot_v1_valid(jsonb)";
+const XAI_AUTHORITY_LIVE_ROUTINE =
+  "xai_subscription_authority_live(uuid, uuid, text, uuid, text, uuid, uuid, bigint)";
+const XAI_POOL_VISIBLE_ROUTINE = "xai_subscription_pool_visible(uuid, uuid, text, text, uuid)";
+const XAI_RESOLVE_POOL_ROUTINE = "resolve_xai_authority_pool(uuid, uuid, text, jsonb)";
+const XAI_REVALIDATE_CREDENTIAL_ROUTINE =
+  "revalidate_xai_subscription_authority(uuid, text, uuid, jsonb)";
+const XAI_AUTHORITY_TABLES = [
+  "organization_memberships",
+  "organization_user_resource_authorities",
+  "workspace_memberships",
+  "xai_subscription_credentials",
+] as const;
+
+export const RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES = [
+  FORK_SESSION_CONTENT_ROUTINE,
+  XAI_AUTHORITY_LIVE_ROUTINE,
+  XAI_CREATE_CREDENTIAL_ROUTINE,
+  XAI_DISCONNECT_CREDENTIAL_ROUTINE,
+  KNOWLEDGE_SOURCE_SYNC_LOCK_AUTHORITY_ROUTINE,
+  MANAGED_HUMAN_PERSONAL_WORKSPACE_ROUTINE,
+  ...CANONICAL_HUMAN_IDENTITY_ROUTINES,
+  SESSION_PRIVATE_ACTOR_VISIBLE_ROUTINE,
+  SESSION_REFERENCE_VISIBLE_ROUTINE,
+  TRANSITION_SESSION_VISIBILITY_ROUTINE,
+  XAI_POOL_VISIBLE_ROUTINE,
+  XAI_RESOLVE_POOL_ROUTINE,
+  XAI_REVALIDATE_CREDENTIAL_ROUTINE,
+  XAI_SNAPSHOT_VALIDATOR_ROUTINE,
+] as const;
+
+export const RUNTIME_TARGET_SCHEMA_INVOKER_ROUTINES = [
+  SESSION_REFERENCE_VISIBLE_ROUTINE,
+  XAI_SNAPSHOT_VALIDATOR_ROUTINE,
+] as const;
+const RUNTIME_TARGET_SCHEMA_INVOKER_ROUTINE_SET = new Set<string>(
+  RUNTIME_TARGET_SCHEMA_INVOKER_ROUTINES,
+);
+
 /**
  * The complete standalone tenant-table contract. Adding or removing a
  * FORCE-RLS table is an architectural change: update this list in the same
@@ -14,17 +138,50 @@ import {
 export const FORCE_RLS_TABLES = [
   "agent_run_states",
   "api_keys",
+  "attached_browser_devices",
+  "attached_browser_inventories",
   "audit_events",
+  "auth_runs",
   "billing_customers",
+  "browser_identities",
+  "browser_revision_components",
+  "browser_revisions",
+  "browser_session_associations",
+  "browser_sessions",
+  "browser_state_artifacts",
+  "browser_state_uploads",
+  "canonical_human_identities",
+  "canonical_human_identity_operations",
+  "canonical_human_identity_subjects",
+  "canonical_human_login_bindings",
+  "capability_api_facets",
   "capability_catalog_items",
+  "capability_component_owners",
+  "capability_facet_installations",
+  "capability_facets",
   "capability_installations",
+  "capability_integration_facets",
+  "capability_mcp_facets",
+  "capability_operations",
+  "capability_plugin_installations",
+  "capability_plugin_versions",
+  "capability_plugins",
+  "capability_skill_facets",
+  "capability_skill_files",
+  "channels",
   "codex_apps_settings",
   "codex_capacity_waiters",
   "codex_credential_leases",
   "codex_reset_redemption_attempts",
   "codex_rotation_settings",
   "codex_subscription_credentials",
+  "company_profile_activation_events",
+  "company_profile_heads",
+  "company_profile_revisions",
+  "company_profile_snapshots",
   "composer_drafts",
+  "computer_session_associations",
+  "computer_sessions",
   "connection_disconnect_operations",
   "connections",
   "connector_action_policies",
@@ -34,9 +191,27 @@ export const FORCE_RLS_TABLES = [
   "document_bases",
   "document_chunks",
   "documents",
+  "editable_artifact_blob_refs",
+  "editable_artifact_idempotency_receipts",
+  "editable_artifact_live_outbox",
+  "editable_artifact_live_tickets",
+  "editable_artifact_materialization_jobs",
+  "editable_artifact_materialization_results",
+  "editable_artifact_operations",
+  "editable_artifact_replica_leases",
+  "editable_artifact_scope_authorization_heads",
+  "editable_artifact_sequence_checkpoints",
+  "editable_artifact_session_links",
+  "editable_artifact_snapshots",
+  "editable_artifact_transactions",
+  "editable_artifact_undo_claims",
+  "editable_artifact_versions",
+  "editable_artifacts",
   "enrollments",
   "file_uploads",
   "files",
+  "generated_image_artifacts",
+  "generated_video_artifacts",
   "github_installation_repositories",
   "github_installations",
   "host_export_config",
@@ -44,8 +219,17 @@ export const FORCE_RLS_TABLES = [
   "host_export_cursor_state",
   "host_export_dead_letters",
   "host_export_outbox",
+  "image_generation_operations",
   "import_batches",
+  "integration_facet_binding_owners",
+  "integration_facet_bindings",
+  "integration_facet_definitions",
   "integration_oauth_state_nonces",
+  "integration_spec_revisions",
+  "integration_tools",
+  "interaction_interventions",
+  "interaction_operations",
+  "interaction_resource_operations",
   "knowledge_change_proposals",
   "knowledge_claim_evidence",
   "knowledge_claim_relations",
@@ -63,13 +247,27 @@ export const FORCE_RLS_TABLES = [
   "knowledge_providers",
   "knowledge_source_acl_versions",
   "knowledge_source_objects",
+  "knowledge_source_sync_index_obligations",
+  "knowledge_source_sync_item_outcomes",
+  "knowledge_source_sync_object_observations",
+  "knowledge_source_sync_states",
+  "knowledge_source_sync_wakes",
   "knowledge_sources",
   "knowledge_sync_runs",
   "machine_metrics_latest",
   "machine_metrics_series",
   "machine_removal_operations",
+  "memory_slack_publication_configurations",
+  "memory_slack_publication_receipts",
+  "memory_slack_publications",
   "model_call_facts",
+  "network_routes",
   "new_session_drafts",
+  "organization_memberships",
+  "organization_user_resource_authorities",
+  "organization_user_resource_grants",
+  "organization_user_retention_policies",
+  "pack_installation_components",
   "pack_installations",
   "preference_registry_events",
   "preference_registry_preferences",
@@ -89,9 +287,12 @@ export const FORCE_RLS_TABLES = [
   "sandboxes",
   "scheduled_task_runs",
   "scheduled_tasks",
+  "session_attempt_codemode_calls",
   "session_attempt_interruptions",
+  "session_attempt_tool_catalogs",
   "session_command_receipts",
   "session_events",
+  "session_goal_revisions",
   "session_goals",
   "session_history_items",
   "session_human_input_requests",
@@ -110,21 +311,38 @@ export const FORCE_RLS_TABLES = [
   "session_system_updates",
   "session_turn_attempts",
   "session_turns",
+  "session_visibility_write_capabilities",
   "session_workflow_wake_outbox",
   "sessions",
+  "site_auth_connections",
   "slack_bot_delete_operations",
   "slack_bot_post_operations",
+  "slack_bot_update_operations",
   "slack_bot_user_links",
+  "slack_installation_bindings",
+  "slack_interaction_action_handles",
   "slack_interaction_inbox",
   "slack_interaction_progress_deliveries",
   "slack_interactions",
+  "slack_shared_task_origins",
+  "slack_task_policy_activation_events",
+  "slack_task_policy_heads",
+  "slack_task_policy_revisions",
+  "slack_user_link_access_request_operations",
+  "slack_user_link_access_requests",
   "social_connections",
   "social_posts",
+  "task_note_events",
+  "task_note_write_capabilities",
+  "task_notes",
+  "temporal_schedule_cleanup_outbox",
   "transcription_recording_chunks",
   "transcription_recording_objects",
   "transcription_recording_segments",
   "transcription_recordings",
   "usage_events",
+  "video_generation_operations",
+  "video_generation_references",
   "workspace_artifact_events",
   "workspace_artifact_versions",
   "workspace_artifacts",
@@ -136,12 +354,24 @@ export const FORCE_RLS_TABLES = [
   "workspace_instruction_policy_onboarding_proposals",
   "workspace_instruction_policy_revisions",
   "workspace_instruction_policy_snapshots",
+  "workspace_interaction_revisions",
+  "workspace_learning_policy_activation_events",
+  "workspace_learning_policy_heads",
+  "workspace_learning_policy_revisions",
+  "workspace_learning_policy_snapshots",
   "workspace_model_policies",
   "workspace_packs",
   "workspace_screenshot_quotas",
   "workspace_session_activity_revisions",
   "workspace_variable_set_variables",
   "workspace_variable_sets",
+  "workspace_video_generation_policies",
+  "workspace_video_generation_quotas",
+  "xai_capacity_waiters",
+  "xai_credential_leases",
+  "xai_rotation_settings",
+  "xai_session_account_pins",
+  "xai_subscription_credentials",
 ] as const;
 
 /**
@@ -178,8 +408,14 @@ export const RUNTIME_FULL_DML_TABLES = [
   "auth_users",
   "auth_verifications",
   "billing_customers",
+  "browser_session_associations",
   "capability_catalog_items",
+  "capability_component_owners",
+  "capability_facet_installations",
   "capability_installations",
+  "capability_operations",
+  "capability_plugin_installations",
+  "channels",
   "codex_apps_settings",
   "codex_capacity_waiters",
   "codex_credential_leases",
@@ -187,6 +423,7 @@ export const RUNTIME_FULL_DML_TABLES = [
   "codex_rotation_settings",
   "codex_subscription_credentials",
   "composer_drafts",
+  "computer_session_associations",
   "connection_disconnect_operations",
   "connections",
   "connector_action_policies",
@@ -196,21 +433,36 @@ export const RUNTIME_FULL_DML_TABLES = [
   "document_bases",
   "document_chunks",
   "documents",
+  "editable_artifact_replica_leases",
   "enrollments",
   "file_uploads",
   "files",
+  "generated_image_artifacts",
+  "generated_video_artifacts",
   "github_installation_repositories",
   "github_installations",
+  "image_generation_operations",
   "import_batches",
+  "integration_facet_binding_owners",
+  "integration_facet_bindings",
   "integration_oauth_clients",
   "integration_oauth_state_nonces",
   "knowledge_memories",
+  "knowledge_source_sync_index_obligations",
+  "knowledge_source_sync_item_outcomes",
+  "knowledge_source_sync_object_observations",
+  "knowledge_source_sync_states",
+  "knowledge_source_sync_wakes",
   "machine_metrics_latest",
   "machine_metrics_series",
   "machine_removal_operations",
   "managed_accounts",
+  "memory_slack_publication_configurations",
+  "memory_slack_publication_receipts",
+  "memory_slack_publications",
   "model_call_facts",
   "new_session_drafts",
+  "pack_installation_components",
   "pack_installations",
   "retained_screenshot_artifacts",
   "rig_changes",
@@ -250,7 +502,9 @@ export const RUNTIME_FULL_DML_TABLES = [
   "sessions",
   "slack_bot_delete_operations",
   "slack_bot_post_operations",
+  "slack_bot_update_operations",
   "slack_bot_user_links",
+  "slack_interaction_action_handles",
   "slack_interaction_inbox",
   "slack_interaction_progress_deliveries",
   "slack_interactions",
@@ -262,6 +516,8 @@ export const RUNTIME_FULL_DML_TABLES = [
   "transcription_recording_segments",
   "transcription_recordings",
   "usage_events",
+  "video_generation_operations",
+  "video_generation_references",
   "workspace_artifacts",
   "workspace_captures",
   "workspace_control_events",
@@ -271,25 +527,58 @@ export const RUNTIME_FULL_DML_TABLES = [
   "workspace_model_policies",
   "workspace_packs",
   "workspace_screenshot_quotas",
-  "workspace_session_activity_revisions",
   "workspace_variable_set_variables",
   "workspace_variable_sets",
+  "workspace_video_generation_policies",
+  "workspace_video_generation_quotas",
   "workspaces",
+  "xai_capacity_waiters",
+  "xai_credential_leases",
+  "xai_rotation_settings",
+  "xai_session_account_pins",
+  "xai_subscription_credentials",
 ] as const;
 
 /** Configuration and lifecycle-owned audit rows are read-only at runtime. */
 export const RUNTIME_READ_ONLY_TABLES = [
+  "company_profile_activation_events",
+  "company_profile_heads",
+  "company_profile_snapshots",
   "knowledge_lifecycle_events",
   "knowledge_memory_lifecycle_events",
   "knowledge_memory_relationships",
   "nested_agent_depth_configuration",
   "preference_registry_events",
   "preference_registry_snapshots",
+  "slack_installation_bindings",
+  "slack_task_policy_activation_events",
+  "slack_task_policy_heads",
+  "slack_task_policy_revisions",
   "workspace_instruction_policy_snapshots",
+  "workspace_learning_policy_activation_events",
+  "workspace_learning_policy_heads",
+  "workspace_learning_policy_snapshots",
 ] as const;
 
+/** Existing runtime authorities that may be observed and advanced, never created or deleted. */
+export const RUNTIME_READ_UPDATE_TABLES = ["workspace_session_activity_revisions"] as const;
+
 /** Append-only evidence/revision tables are insertable and queryable, never mutable. */
 export const RUNTIME_READ_INSERT_TABLES = [
+  "browser_revision_components",
+  "browser_revisions",
+  "company_profile_revisions",
+  "editable_artifact_blob_refs",
+  "editable_artifact_idempotency_receipts",
+  "editable_artifact_live_outbox",
+  "editable_artifact_materialization_jobs",
+  "editable_artifact_materialization_results",
+  "editable_artifact_operations",
+  "editable_artifact_sequence_checkpoints",
+  "editable_artifact_snapshots",
+  "editable_artifact_transactions",
+  "editable_artifact_undo_claims",
+  "editable_artifact_versions",
   "knowledge_change_proposals",
   "knowledge_claim_evidence",
   "knowledge_claim_relations",
@@ -307,12 +596,51 @@ export const RUNTIME_READ_INSERT_TABLES = [
   "knowledge_sync_runs",
   "preference_registry_preferences",
   "preference_registry_revisions",
+  "session_attempt_tool_catalogs",
+  "session_goal_revisions",
   "session_spawn_denials",
+  "slack_shared_task_origins",
+  "slack_user_link_access_request_operations",
+  "temporal_schedule_cleanup_outbox",
   "workspace_artifact_events",
   "workspace_artifact_versions",
   "workspace_instruction_policy_activation_events",
   "workspace_instruction_policy_onboarding_proposals",
   "workspace_instruction_policy_revisions",
+  "workspace_learning_policy_revisions",
+] as const;
+
+/** Durable operation journals are append/read plus claim/settle updates, never deletes. */
+export const RUNTIME_READ_INSERT_UPDATE_TABLES = [
+  "attached_browser_devices",
+  "attached_browser_inventories",
+  "auth_runs",
+  "browser_identities",
+  "browser_sessions",
+  "browser_state_artifacts",
+  "browser_state_uploads",
+  "capability_api_facets",
+  "capability_facets",
+  "capability_integration_facets",
+  "capability_mcp_facets",
+  "capability_plugin_versions",
+  "capability_plugins",
+  "capability_skill_facets",
+  "capability_skill_files",
+  "computer_sessions",
+  "editable_artifact_session_links",
+  "editable_artifacts",
+  "integration_facet_definitions",
+  "integration_spec_revisions",
+  "integration_tools",
+  "interaction_interventions",
+  "interaction_operations",
+  "interaction_resource_operations",
+  "network_routes",
+  "session_attempt_codemode_calls",
+  "site_auth_connections",
+  "slack_user_link_access_requests",
+  "workspace_interaction_revisions",
 ] as const;
 
 /**
@@ -320,11 +648,25 @@ export const RUNTIME_READ_INSERT_TABLES = [
  * The ordinary application role must have no direct table privileges on them.
  */
 export const PROTECTED_NO_DIRECT_DML_TABLES = [
+  "canonical_human_identities",
+  "canonical_human_identity_operations",
+  "canonical_human_identity_subjects",
+  "canonical_human_login_bindings",
+  "editable_artifact_live_tickets",
+  "editable_artifact_scope_authorization_heads",
   "host_export_config",
   "host_export_consumers",
   "host_export_cursor_state",
   "host_export_dead_letters",
   "host_export_outbox",
+  "organization_memberships",
+  "organization_user_resource_authorities",
+  "organization_user_resource_grants",
+  "organization_user_retention_policies",
+  "session_visibility_write_capabilities",
+  "task_note_events",
+  "task_note_write_capabilities",
+  "task_notes",
 ] as const;
 
 export type RuntimeTableDmlPrivilege = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
@@ -338,9 +680,18 @@ const FULL_DML_PRIVILEGES = ["SELECT", "INSERT", "UPDATE", "DELETE"] as const;
 export const RUNTIME_TABLE_PRIVILEGES: RuntimeTablePrivilegeContract = Object.freeze({
   ...Object.fromEntries(RUNTIME_FULL_DML_TABLES.map((table) => [table, FULL_DML_PRIVILEGES])),
   ...Object.fromEntries(RUNTIME_READ_ONLY_TABLES.map((table) => [table, ["SELECT"] as const])),
+  ...Object.fromEntries(
+    RUNTIME_READ_UPDATE_TABLES.map((table) => [table, ["SELECT", "UPDATE"] as const]),
+  ),
   ...Object.fromEntries(
     RUNTIME_READ_INSERT_TABLES.map((table) => [table, ["SELECT", "INSERT"] as const]),
   ),
+  ...Object.fromEntries(
+    RUNTIME_READ_INSERT_UPDATE_TABLES.map((table) => [
+      table,
+      ["SELECT", "INSERT", "UPDATE"] as const,
+    ]),
+  ),
 });
 
 /** All tables with any direct runtime DML; retained as the aggregate public contract. */
@@ -387,6 +738,8 @@ export type RuntimeTablePosture = {
   rlsForced: boolean;
   rlsActive: boolean;
   policyCount: number;
+  artifactOutboxDispatcherPolicy: boolean;
+  artifactMaterializerPolicy: boolean;
   select: boolean;
   insert: boolean;
   update: boolean;
@@ -400,6 +753,11 @@ export type RuntimeRoutinePosture = {
   name: string;
   owner: string;
   execute: boolean;
+  securityDefiner: boolean;
+};
+
+export type RuntimeTargetRoutinePosture = RuntimeRoutinePosture & {
+  publicExecute: boolean;
 };
 
 export type RuntimeDatabasePosture = {
@@ -410,6 +768,7 @@ export type RuntimeDatabasePosture = {
   ownedSchemas: string[];
   ownedRelations: string[];
   tables: RuntimeTablePosture[];
+  targetRoutines: RuntimeTargetRoutinePosture[];
   privateRoutines: RuntimeRoutinePosture[];
 };
 
@@ -520,6 +879,7 @@ export async function inspectRuntimeDatabasePosture(
           ownedSchemas: [],
           ownedRelations: [],
           tables: [],
+          targetRoutines: [],
           privateRoutines: [],
         };
       }
@@ -580,6 +940,8 @@ export async function inspectRuntimeDatabasePosture(
         rls_forced: boolean;
         rls_active: boolean;
         policy_count: number;
+        artifact_outbox_dispatcher_policy: boolean;
+        artifact_materializer_policy: boolean;
         can_select: boolean;
         can_insert: boolean;
         can_update: boolean;
@@ -596,6 +958,16 @@ export async function inspectRuntimeDatabasePosture(
             c.relforcerowsecurity as rls_forced,
             row_security_active(c.oid) as rls_active,
             (select count(*)::int from pg_policy policy where policy.polrelid = c.oid) as policy_count,
+            exists(
+              select 1 from pg_policy policy
+              where policy.polrelid = c.oid
+                and policy.polname = 'editable_artifact_outbox_dispatcher'
+            ) as artifact_outbox_dispatcher_policy,
+            exists(
+              select 1 from pg_policy policy
+              where policy.polrelid = c.oid
+                and policy.polname = 'editable_artifact_materializer_owner'
+            ) as artifact_materializer_policy,
             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,
@@ -616,6 +988,8 @@ export async function inspectRuntimeDatabasePosture(
         rlsForced: row.rls_forced,
         rlsActive: row.rls_active,
         policyCount: row.policy_count,
+        artifactOutboxDispatcherPolicy: row.artifact_outbox_dispatcher_policy,
+        artifactMaterializerPolicy: row.artifact_materializer_policy,
         select: row.can_select,
         insert: row.can_insert,
         update: row.can_update,
@@ -625,26 +999,69 @@ export async function inspectRuntimeDatabasePosture(
         trigger: row.can_trigger,
       }));
 
+      const targetRoutines = resultRows<{
+        name: string;
+        owner: string;
+        can_execute: boolean;
+        public_execute: boolean;
+        security_definer: boolean;
+      }>(
+        await tx.execute(sql`
+          select
+            (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
+          where n.nspname = ${targetSchema}
+            and p.prokind in ('f', 'p')
+            and (p.proname || '(' || pg_catalog.oidvectortypes(p.proargtypes) || ')') = any(
+              array[
+                ${sql.join(
+                  RUNTIME_TARGET_SCHEMA_CAPABILITY_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,
+      }));
+
       const privateRoutines = resultRows<{
         name: string;
         owner: string;
         can_execute: boolean;
+        security_definer: boolean;
       }>(
         await tx.execute(sql`
           select
-            (p.proname || '(' || pg_get_function_identity_arguments(p.oid) || ')')::text as name,
+            (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
+            has_function_privilege(current_user, p.oid, 'EXECUTE') as can_execute,
+            p.prosecdef as security_definer
           from pg_proc p
           join pg_namespace n on n.oid = p.pronamespace
           where n.nspname = 'opengeni_private'
             and p.prokind in ('f', 'p')
-          order by p.proname, pg_get_function_identity_arguments(p.oid)
+          order by p.proname, pg_catalog.oidvectortypes(p.proargtypes)
         `),
       ).map((row) => ({
         name: row.name,
         owner: row.owner,
         execute: row.can_execute,
+        securityDefiner: row.security_definer,
       }));
 
       return {
@@ -654,6 +1071,7 @@ export async function inspectRuntimeDatabasePosture(
         ownedSchemas,
         ownedRelations,
         tables,
+        targetRoutines,
         privateRoutines,
       };
     },
@@ -823,6 +1241,303 @@ export function evaluateRuntimeDatabasePosture(
     if (table.policyCount < 1) violations.push(`table ${tableName} has no RLS policy`);
   }
 
+  const targetSchemaOwner = posture.schemas.find((schema) => schema.name === targetSchema)?.owner;
+  for (const expectedRoutine of RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES) {
+    const matches = posture.targetRoutines.filter((routine) => routine.name === expectedRoutine);
+    if (matches.length !== 1) {
+      violations.push(
+        `target-schema runtime capability ${expectedRoutine} is missing or ambiguous`,
+      );
+      continue;
+    }
+    const routine = matches[0]!;
+    if (RUNTIME_TARGET_SCHEMA_INVOKER_ROUTINE_SET.has(routine.name)) {
+      if (routine.securityDefiner) {
+        violations.push(
+          `target-schema runtime capability ${routine.name} must be SECURITY INVOKER`,
+        );
+      }
+    } else if (!routine.securityDefiner) {
+      violations.push(`target-schema runtime capability ${routine.name} is not SECURITY DEFINER`);
+    }
+    if (routine.name === KNOWLEDGE_SOURCE_SYNC_LOCK_AUTHORITY_ROUTINE) {
+      const missingAuthorityTables = KNOWLEDGE_SOURCE_SYNC_LOCK_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 = KNOWLEDGE_SOURCE_SYNC_LOCK_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 (routine.name === MANAGED_HUMAN_PERSONAL_WORKSPACE_ROUTINE) {
+      const authorityTables = MANAGED_HUMAN_PERSONAL_WORKSPACE_AUTHORITY_TABLES.filter(
+        (tableName) => tableByName.has(tableName),
+      ).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 (authorityTables[0] && 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 (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}`);
+    }
+    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 (routine.owner !== artifactOutbox.owner) {
+        violations.push(
+          `artifact outbox capability ${routine.name} owner ${routine.owner} does not match table owner ${artifactOutbox.owner}`,
+        );
+      }
+      if (routine.execute) {
+        violations.push(
+          `generic runtime role has forbidden global artifact outbox capability ${routine.name}`,
+        );
+      }
+    }
+  }
+
+  const artifactMaterializationJobs = tableByName.get("editable_artifact_materialization_jobs");
+  if (artifactMaterializationJobs) {
+    for (const tableName of [
+      "editable_artifact_materialization_jobs",
+      "editable_artifact_materialization_results",
+      "editable_artifact_blob_refs",
+      "editable_artifact_sequence_checkpoints",
+      "editable_artifact_versions",
+      "editable_artifact_idempotency_receipts",
+    ]) {
+      const table = tableByName.get(tableName);
+      if (table && !table.artifactMaterializerPolicy) {
+        violations.push(`table ${tableName} lacks its owner materializer RLS policy`);
+      }
+    }
+    for (const expectedRoutine of ARTIFACT_MATERIALIZER_CAPABILITY_ROUTINES) {
+      const matches = posture.privateRoutines.filter((routine) => routine.name === expectedRoutine);
+      if (matches.length !== 1) {
+        violations.push(
+          `artifact materializer capability ${expectedRoutine} is missing or ambiguous`,
+        );
+        continue;
+      }
+      const routine = matches[0]!;
+      if (!routine.securityDefiner) {
+        violations.push(`artifact materializer capability ${routine.name} is not SECURITY DEFINER`);
+      }
+      if (routine.owner !== artifactMaterializationJobs.owner) {
+        violations.push(
+          `artifact materializer capability ${routine.name} owner ${routine.owner} does not match table owner ${artifactMaterializationJobs.owner}`,
+        );
+      }
+      if (routine.execute) {
+        violations.push(
+          `generic runtime role has forbidden global artifact materializer capability ${routine.name}`,
+        );
+      }
+    }
+  }
+  const artifactAuthority = tableByName.get("editable_artifacts");
+  if (artifactAuthority) {
+    const matches = posture.privateRoutines.filter((routine) =>
+      routine.name.startsWith("advance_editable_artifact_authorization_revision("),
+    );
+    if (matches.length !== 1) {
+      violations.push(
+        "editable artifact authorization revision capability is missing or ambiguous",
+      );
+    } else {
+      const routine = matches[0]!;
+      if (!routine.securityDefiner) {
+        violations.push(
+          `editable artifact authorization revision capability ${routine.name} is not SECURITY DEFINER`,
+        );
+      }
+      if (routine.owner !== artifactAuthority.owner) {
+        violations.push(
+          `editable artifact authorization revision capability ${routine.name} owner ${routine.owner} does not match table owner ${artifactAuthority.owner}`,
+        );
+      }
+    }
+    for (const expectedRoutine of ARTIFACT_AUTHORIZATION_CAPABILITY_ROUTINES) {
+      const capabilityMatches = posture.privateRoutines.filter(
+        (routine) => routine.name === expectedRoutine,
+      );
+      if (capabilityMatches.length !== 1) {
+        violations.push(
+          `editable artifact authorization capability ${expectedRoutine} is missing or ambiguous`,
+        );
+        continue;
+      }
+      const routine = capabilityMatches[0]!;
+      if (!routine.securityDefiner) {
+        violations.push(
+          `editable artifact authorization capability ${routine.name} is not SECURITY DEFINER`,
+        );
+      }
+      if (routine.owner !== artifactAuthority.owner) {
+        violations.push(
+          `editable artifact authorization capability ${routine.name} owner ${routine.owner} does not match table owner ${artifactAuthority.owner}`,
+        );
+      }
+      if (!routine.execute) {
+        violations.push(
+          `runtime role lacks editable artifact authorization capability ${routine.name}`,
+        );
+      }
+    }
+  }
+
+  const artifactLiveTickets = tableByName.get("editable_artifact_live_tickets");
+  if (artifactLiveTickets) {
+    for (const expectedRoutine of ARTIFACT_LIVE_TICKET_CAPABILITY_ROUTINES) {
+      const matches = posture.privateRoutines.filter((routine) => routine.name === expectedRoutine);
+      if (matches.length !== 1) {
+        violations.push(
+          `artifact live ticket capability ${expectedRoutine} is missing or ambiguous`,
+        );
+        continue;
+      }
+      const routine = matches[0]!;
+      if (!routine.securityDefiner) {
+        violations.push(`artifact live ticket capability ${routine.name} is not SECURITY DEFINER`);
+      }
+      if (routine.owner !== artifactLiveTickets.owner) {
+        violations.push(
+          `artifact live ticket capability ${routine.name} owner ${routine.owner} does not match table owner ${artifactLiveTickets.owner}`,
+        );
+      }
+      if (!routine.execute) {
+        violations.push(`runtime role lacks artifact live ticket capability ${routine.name}`);
+      }
+    }
+    for (const internalRoutine of ARTIFACT_LIVE_TICKET_INTERNAL_ROUTINES) {
+      const matches = posture.privateRoutines.filter((routine) => routine.name === internalRoutine);
+      if (matches.length !== 1) {
+        violations.push(
+          `artifact live ticket internal routine ${internalRoutine} is missing or ambiguous`,
+        );
+        continue;
+      }
+      const routine = matches[0]!;
+      if (!routine.securityDefiner) {
+        violations.push(
+          `artifact live ticket internal routine ${routine.name} is not SECURITY DEFINER`,
+        );
+      }
+      if (routine.owner !== artifactLiveTickets.owner) {
+        violations.push(
+          `artifact live ticket internal routine ${routine.name} owner ${routine.owner} does not match table owner ${artifactLiveTickets.owner}`,
+        );
+      }
+      if (routine.execute) {
+        violations.push(`runtime role has forbidden ticket schema resolver ${routine.name}`);
+      }
+    }
+  }
+
   if (posture.privateRoutines.length === 0) {
     violations.push("opengeni_private has no helper routines");
   }
@@ -830,7 +1545,8 @@ export function evaluateRuntimeDatabasePosture(
     if (routine.owner === expectedRole) {
       violations.push(`runtime role owns private routine ${routine.name}`);
     }
-    if (!routine.execute) {
+    const dedicatedArtifactCapability = DEDICATED_ARTIFACT_CAPABILITY_ROUTINES.has(routine.name);
+    if (!routine.execute && !dedicatedArtifactCapability) {
       violations.push(`runtime role lacks EXECUTE on private routine ${routine.name}`);
     }
   }