@opengeni/db 0.12.1 → 0.13.0

package/dist/provision-roles.d.ts

@@ -1,10 +1,10 @@
-import { TurnInitiatorContext, SessionMcpApprovalPolicy, TurnInitiator, ResourceRef, ToolRef, ReasoningEffort, TurnExecutionPolicyV1, NewSessionDraftOptions, KnowledgeMemoryKind, McpCredentialsRequest, McpCredentialAuthNeededReason, McpConnectionResourceScope, ConnectionCredentialsPort, SessionEvent, SessionStatus, SessionHumanInputRequest, SystemUpdateClassification, SessionSystemUpdateKind, SessionSystemUpdatePayload, SessionSystemUpdate, SessionEventType, SessionTurnStatus, HumanInputQuestion, Permission, SessionTurn, ConnectionKind, ConnectionStatus, KnowledgeMemory, CapabilityKind, CapabilitySource, KnowledgeMemoryStatus, KnowledgeSourceRef, ScheduledTaskStatus, ScheduledTaskScheduleSpec, ScheduledTaskRunMode, ScheduledTaskOverlapPolicy, ScheduledTaskAgentConfig, SessionGoalCreatedBy, McpServerConnectionRef as McpServerConnectionRef$1, SocialProvider, SocialConnectionStatus, Session, SessionTurnSource, SandboxBackend, SandboxOs, FileAsset, FileUploadStatus, GitHubRepositoryScope, SessionGoal, SessionEventReadDirection, SessionEventSemanticClass, SessionEventPayloadMode, SessionAuthorizationListScope, CapabilityPack, RigChangeKind, RigChangeStatus, RigCheck, SessionToolPolicy, SessionGoalStatus, LineageNode, SessionMcpServerMetadata, RigVersion, BillingBalance, RigChange, AccessContext, HostEventExportBatch, HostUsageExportBatch, ApiKey, ConnectionMetadata, Rig, ScheduledTask, ScheduledTaskTriggerType, ScheduledTaskRun, SocialConnection, SocialPost, VariableSet, Workspace, CapabilityInstallation, PackInstallation, CapabilityCatalogItem, HumanInputResponse, ManagedAccount, SessionQueueSnapshot, WorkspaceControlEvent, AccessGrant, WorkspaceRegisteredPack, SessionListResponse, UsageEvent, WorkspaceMember, VariableSetVariableMetadata, PackInstallationStatus, ScheduledTaskRunStatus } from '@opengeni/contracts';
+import { TurnInitiatorContext, SessionMcpApprovalPolicy, TurnInitiator, ResourceRef, ToolRef, ReasoningEffort, TurnExecutionPolicyV1, NewSessionDraftOptions, WorkspaceInstructionPolicyHead, WorkspaceInstructionPolicyActivationResponse, WorkspaceInstructionPolicyTarget, WorkspaceInstructionPolicyProvenanceSource, WorkspaceInstructionPolicyDraftProvenanceSource, WorkspaceInstructionPolicyRevision, WorkspaceInstructionPolicyDiffResponse, WorkspaceInstructionPolicyListQuery, WorkspaceInstructionPolicyListResponse, SecretForRedaction, KnowledgeMemoryKind, McpCredentialsRequest, McpCredentialAuthNeededReason, McpConnectionResourceScope, ConnectionCredentialsPort, SessionEvent, SessionStatus, SessionHumanInputRequest, SystemUpdateClassification, SessionSystemUpdateKind, SessionSystemUpdatePayload, SessionSystemUpdate, SessionEventType, SessionTurnStatus, HumanInputQuestion, Permission, SessionTurn, ConnectionKind, ConnectionStatus, ConnectionMetadata, KnowledgeMemory, CapabilityKind, CapabilitySource, KnowledgeMemoryStatus, KnowledgeSourceRef, ScheduledTaskStatus, ScheduledTaskScheduleSpec, ScheduledTaskRunMode, ScheduledTaskOverlapPolicy, ScheduledTaskAgentConfig, SessionGoalCreatedBy, McpServerConnectionRef as McpServerConnectionRef$1, SocialProvider, SocialConnectionStatus, Session, SessionTurnSource, SandboxBackend, SandboxOs, FileAsset, FileUploadStatus, GitHubRepositoryScope, GitHubInstallationAuthorityKind, SessionGoal, SessionEventReadDirection, SessionEventSemanticClass, SessionEventPayloadMode, SessionAuthorizationListScope, CapabilityPack, RigChangeKind, RigChangeStatus, RigCheck, SessionToolPolicy, SessionGoalStatus, LineageNode, SessionMcpServerMetadata, RigVersion, BillingBalance, RigChange, AccessContext, HostEventExportBatch, HostUsageExportBatch, ApiKey, Rig, ScheduledTask, ScheduledTaskTriggerType, ScheduledTaskRun, SocialConnection, SocialPost, VariableSet, Workspace, CapabilityInstallation, PackInstallation, CapabilityCatalogItem, HumanInputResponse, ManagedAccount, SessionQueueSnapshot, WorkspaceControlEvent, AccessGrant, WorkspaceRegisteredPack, SessionListResponse, UsageEvent, WorkspaceMember, VariableSetVariableMetadata, PackInstallationStatus, ScheduledTaskRunStatus } from '@opengeni/contracts';
 import { environmentsEncryptionKeyBytes, Settings, McpServerConnectionRef } from '@opengeni/config';
 import { refreshCodexToken, CodexRateLimitResetCreditsDetails, ResetCreditFetchFailureReason, CodexTokenSnapshot, CodexFetch, CodexUsagePayload } from '@opengeni/codex';
 import { SQL } from 'drizzle-orm';
 import { PgDatabase, PgTransactionConfig } from 'drizzle-orm/pg-core';
 import postgres from 'postgres';
-import { s as sessionCommandReceipts, w as workspaces, a as sessions, b as sessionTurns, c as sessionTurnAttempts, d as composerDrafts, n as newSessionDrafts, e as schema, f as enrollmentOsValues, g as enrollmentExposureValues, h as deviceEnrollmentStatusValues, i as enrollmentStatusValues, j as sandboxKindValues, k as sessionRecordingCodecValues, l as sessionRecordingModeValues, m as sessionRecordingStateValues } from './schema-BejThLcd.js';
+import { s as sessionCommandReceipts, w as workspaces, a as sessions, b as sessionTurns, c as sessionTurnAttempts, d as composerDrafts, n as newSessionDrafts, e as schema, f as enrollmentOsValues, g as enrollmentExposureValues, h as deviceEnrollmentStatusValues, i as enrollmentStatusValues, j as sandboxKindValues, k as sessionRecordingCodecValues, l as sessionRecordingModeValues, m as sessionRecordingStateValues } from './schema-Bh1Hr7xY.js';
 import './migrate.js';
 import { FetchLike, DnsLookup } from '@opengeni/network';
 
@@ -26,7 +26,7 @@ type SessionCommandActor = {
     turnId: string;
     executionGeneration: number;
 };
-type SessionTurnAttemptOutcome = "completed" | "failed" | "cancelled" | "superseded" | "requires_action" | "interrupted_recoverable" | "lease_lost_recoverable" | "pre_cutover_closed";
+type SessionTurnAttemptOutcome = "completed" | "failed" | "cancelled" | "superseded" | "requires_action" | "waiting_capacity" | "interrupted_recoverable" | "lease_lost_recoverable" | "pre_cutover_closed";
 type EffectiveControlBlocker = {
     kind: "session" | "workspace";
     sessionId?: string;
@@ -537,6 +537,8 @@ declare class NewSessionDraftAccessError extends Error {
     readonly name = "NewSessionDraftAccessError";
     constructor();
 }
+declare function newSessionDraftToolsProvided(row: NewSessionDraftRow): boolean;
+declare function publicNewSessionDraftOptions(row: NewSessionDraftRow): NewSessionDraftOptions;
 declare function getNewSessionDraftInTransaction(db: Database, input: {
     workspaceId: string;
     subjectId: string;
@@ -550,18 +552,88 @@ declare function saveNewSessionDraftInTransaction(db: Database, input: {
     text: string;
     resources: ResourceRef[];
     tools: ToolRef[];
+    toolsProvided: boolean;
     model: string;
     reasoningEffort: ReasoningEffort;
     options: NewSessionDraftOptions;
     /** API-key and delegated service subjects have no workspace-membership row. */
     requireWorkspaceMembership?: boolean;
 }): Promise<NewSessionDraftRow>;
-/** Delete only the submitted revision; a newer sibling-tab revision survives. */
-declare function consumeNewSessionDraftInTransaction(db: Database, input: {
+/**
+ * Replace one exact accepted draft with the next-create safe seed. The row is
+ * locked before the revision check so a concurrent save either commits first
+ * and wins (this returns false), or observes the incremented seed revision and
+ * reports a typed OCC conflict. A missing row is an idempotent no-op.
+ */
+declare function seedNewSessionDraftInTransaction(db: Database, input: {
     workspaceId: string;
     subjectId: string;
     expectedRevision: number;
 }): Promise<boolean>;
+/** @deprecated Kept as a compatibility name for low-level callers. */
+declare const consumeNewSessionDraftInTransaction: typeof seedNewSessionDraftInTransaction;
+
+type DraftInput = WorkspaceInstructionPolicyTarget & {
+    accountId: string;
+    workspaceId: string;
+    content: string;
+    provenanceSource: WorkspaceInstructionPolicyProvenanceSource;
+    provenanceSourceId: string | null;
+    supersedesRevisionId: string | null;
+    createdBySubjectId: string;
+};
+type CallerDraftInput = Omit<DraftInput, "provenanceSource"> & {
+    provenanceSource: WorkspaceInstructionPolicyDraftProvenanceSource;
+};
+declare class WorkspaceInstructionPolicyConflictError extends Error {
+    readonly currentHead: WorkspaceInstructionPolicyHead | null;
+    readonly name = "WorkspaceInstructionPolicyConflictError";
+    readonly code = "WORKSPACE_INSTRUCTION_POLICY_CONFLICT";
+    constructor(currentHead: WorkspaceInstructionPolicyHead | null);
+}
+declare class WorkspaceInstructionPolicyNotFoundError extends Error {
+    readonly name = "WorkspaceInstructionPolicyNotFoundError";
+    constructor(message?: string);
+}
+declare class WorkspaceInstructionPolicyInvalidOperationError extends Error {
+    readonly name = "WorkspaceInstructionPolicyInvalidOperationError";
+}
+declare class WorkspaceInstructionPolicyLegacyUnavailableError extends Error {
+    readonly name = "WorkspaceInstructionPolicyLegacyUnavailableError";
+    constructor();
+}
+declare function createWorkspaceInstructionPolicyDraft(db: Database, input: CallerDraftInput): Promise<WorkspaceInstructionPolicyRevision>;
+/** Import only the stored legacy override; never materialize a deployment default or activate it. */
+declare function importLegacyWorkspaceInstructionPolicyDraft(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    createdBySubjectId: string;
+    supersedesRevisionId: string | null;
+}): Promise<WorkspaceInstructionPolicyRevision>;
+declare function listWorkspaceInstructionPolicyRevisions(db: Database, workspaceId: string, query: WorkspaceInstructionPolicyListQuery): Promise<WorkspaceInstructionPolicyListResponse>;
+declare function getWorkspaceInstructionPolicyRevision(db: Database, workspaceId: string, revisionId: string): Promise<WorkspaceInstructionPolicyRevision>;
+/** Deterministic, dependency-free unified line diff; large inputs degrade to a full replacement. */
+declare function diffWorkspaceInstructionPolicyContent(from: WorkspaceInstructionPolicyRevision, to: WorkspaceInstructionPolicyRevision): string;
+declare function diffWorkspaceInstructionPolicyRevisions(db: Database, workspaceId: string, input: {
+    fromRevisionId: string;
+    toRevisionId: string;
+}): Promise<WorkspaceInstructionPolicyDiffResponse>;
+declare function activateWorkspaceInstructionPolicyRevision(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    revisionId: string;
+    expectedCurrentRevisionId: string | null;
+    actorSubjectId: string;
+    reason: string;
+}): Promise<WorkspaceInstructionPolicyActivationResponse>;
+declare function rollbackWorkspaceInstructionPolicyRevision(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    targetRevisionId: string;
+    expectedCurrentRevisionId: string;
+    actorSubjectId: string;
+    reason: string;
+}): Promise<WorkspaceInstructionPolicyActivationResponse>;
 
 /** Provider-valid result for a started call whose durable outcome is unknown. */
 declare function interruptedToolCallResult(input: {
@@ -601,18 +673,19 @@ type SanitizeEventPayloadOptions = {
      * this from a producer-controlled payload field.
      */
     fullEvidence?: unknown;
+    /** Exact runtime credential provenance to remove from keys and values. */
+    knownSecrets?: readonly SecretForRedaction[];
 };
 declare function sanitizeEventPayload<T>(payload: T, options?: SanitizeEventPayloadOptions): T;
 /**
- * Make model-facing conversation data safe for Postgres without redacting it.
+ * Make model-facing conversation data safe for Postgres and secret-redacted.
  *
- * Session events are an audit/UI projection and deliberately redact fields such
- * as `token` and `authorization`. Conversation history is the replay source for
- * the model, so applying event redaction there silently changes tool arguments
- * and can make recovery diverge from the call that actually ran. This walker
- * performs only the database-safety repair (NUL removal and UTF-16 repair).
+ * Conversation history is the replay source for the model, so this boundary
+ * retains protocol structure and non-sensitive diagnostics while removing
+ * credential-bearing fields and text before durable storage. It also performs
+ * the database-safety repair (NUL removal and UTF-16 repair).
  */
-declare function sanitizeModelPayload<T>(payload: T): T;
+declare function sanitizeModelPayload<T>(payload: T, knownSecrets?: readonly SecretForRedaction[]): T;
 
 type DatabaseFailureCode = "db_deadlock" | "db_serialization_failure" | "db_failure";
 type PersistenceRetryOutcome = "not_retryable" | "exhausted";
@@ -684,6 +757,108 @@ type IdempotentPersistenceTransactionOptions = {
  */
 declare function runIdempotentPersistenceTransaction<T>(options: IdempotentPersistenceTransactionOptions, transaction: (attempt: number) => Promise<T>): Promise<T>;
 
+/**
+ * The complete standalone tenant-table contract. Adding or removing a
+ * FORCE-RLS table is an architectural change: update this list in the same
+ * commit as the migration so startup cannot silently accept an unreviewed gap.
+ */
+declare const FORCE_RLS_TABLES: readonly ["agent_run_states", "api_keys", "audit_events", "billing_customers", "capability_catalog_items", "capability_installations", "codex_capacity_waiters", "codex_credential_leases", "codex_reset_redemption_attempts", "codex_rotation_settings", "codex_subscription_credentials", "composer_drafts", "connections", "credit_ledger_entries", "device_enrollment_requests", "document_bases", "document_chunks", "documents", "enrollments", "file_uploads", "files", "github_installation_repositories", "github_installations", "host_export_config", "host_export_consumers", "host_export_cursor_state", "host_export_dead_letters", "host_export_outbox", "import_batches", "integration_oauth_state_nonces", "knowledge_memories", "machine_metrics_latest", "machine_metrics_series", "new_session_drafts", "pack_installations", "rig_changes", "rig_versions", "rigs", "sandbox_lease_holders", "sandbox_leases", "sandbox_pty_sessions", "sandbox_retained_processes", "sandbox_session_envelopes", "sandbox_workspace_mutation_admissions", "sandboxes", "scheduled_task_runs", "scheduled_tasks", "session_attempt_interruptions", "session_command_receipts", "session_events", "session_goals", "session_history_items", "session_human_input_requests", "session_list_snapshots", "session_mcp_servers", "session_pending_tool_calls", "session_pins", "session_recordings", "session_spawn_denials", "session_stream_acknowledgments", "session_system_update_outbox", "session_system_updates", "session_turn_attempts", "session_turns", "session_workflow_wake_outbox", "sessions", "slack_bot_post_operations", "social_connections", "social_posts", "usage_events", "workspace_captures", "workspace_control_events", "workspace_inference_controls", "workspace_instruction_policy_activation_events", "workspace_instruction_policy_heads", "workspace_instruction_policy_revisions", "workspace_model_policies", "workspace_packs", "workspace_session_activity_revisions", "workspace_variable_set_variables", "workspace_variable_sets"];
+/**
+ * Deployment-global and authentication tables used by ordinary API/worker
+ * traffic. They intentionally do not carry workspace RLS: their access model
+ * is implemented by the authentication/access layer or by exact global keys.
+ */
+declare const NON_RLS_RUNTIME_TABLES: readonly ["auth_identities", "auth_rate_limits", "auth_sessions", "auth_users", "auth_verifications", "integration_oauth_clients", "managed_accounts", "nested_agent_depth_configuration", "stripe_webhook_events", "workspace_memberships", "workspaces"];
+/**
+ * Exact full-CRUD class for the standalone runtime role. This is deliberately
+ * explicit instead of being derived from FORCE_RLS_TABLES: adding a protected
+ * table must not silently grant it broader DML than its migration intended.
+ */
+declare const RUNTIME_FULL_DML_TABLES: readonly ["agent_run_states", "api_keys", "audit_events", "auth_identities", "auth_rate_limits", "auth_sessions", "auth_users", "auth_verifications", "billing_customers", "capability_catalog_items", "capability_installations", "codex_capacity_waiters", "codex_credential_leases", "codex_reset_redemption_attempts", "codex_rotation_settings", "codex_subscription_credentials", "composer_drafts", "connections", "credit_ledger_entries", "device_enrollment_requests", "document_bases", "document_chunks", "documents", "enrollments", "file_uploads", "files", "github_installation_repositories", "github_installations", "import_batches", "integration_oauth_clients", "integration_oauth_state_nonces", "knowledge_memories", "machine_metrics_latest", "machine_metrics_series", "managed_accounts", "new_session_drafts", "pack_installations", "rig_changes", "rig_versions", "rigs", "sandbox_lease_holders", "sandbox_leases", "sandbox_pty_sessions", "sandbox_retained_processes", "sandbox_session_envelopes", "sandbox_workspace_mutation_admissions", "sandboxes", "scheduled_task_runs", "scheduled_tasks", "session_attempt_interruptions", "session_command_receipts", "session_events", "session_goals", "session_history_items", "session_human_input_requests", "session_list_snapshots", "session_mcp_servers", "session_pending_tool_calls", "session_pins", "session_recordings", "session_stream_acknowledgments", "session_system_update_outbox", "session_system_updates", "session_turn_attempts", "session_turns", "session_workflow_wake_outbox", "sessions", "slack_bot_post_operations", "social_connections", "social_posts", "stripe_webhook_events", "usage_events", "workspace_captures", "workspace_control_events", "workspace_inference_controls", "workspace_instruction_policy_heads", "workspace_memberships", "workspace_model_policies", "workspace_packs", "workspace_session_activity_revisions", "workspace_variable_set_variables", "workspace_variable_sets", "workspaces"];
+/** Configuration is deployment-global and intentionally read-only at runtime. */
+declare const RUNTIME_READ_ONLY_TABLES: readonly ["nested_agent_depth_configuration"];
+/** Append-only evidence/revision tables are insertable and queryable, never mutable. */
+declare const RUNTIME_READ_INSERT_TABLES: readonly ["session_spawn_denials", "workspace_instruction_policy_activation_events", "workspace_instruction_policy_revisions"];
+/**
+ * These FORCE-RLS tables are owned by security-definer host-export routines.
+ * The ordinary application role must have no direct table privileges on them.
+ */
+declare const PROTECTED_NO_DIRECT_DML_TABLES: readonly ["host_export_config", "host_export_consumers", "host_export_cursor_state", "host_export_dead_letters", "host_export_outbox"];
+type RuntimeTableDmlPrivilege = "SELECT" | "INSERT" | "UPDATE" | "DELETE";
+type RuntimeTablePrivilegeContract = Readonly<Record<string, readonly RuntimeTableDmlPrivilege[]>>;
+/** Exact per-table DML contract. Absence means no direct table privileges. */
+declare const RUNTIME_TABLE_PRIVILEGES: RuntimeTablePrivilegeContract;
+/** All tables with any direct runtime DML; retained as the aggregate public contract. */
+declare const RUNTIME_DML_TABLES: readonly string[];
+type RuntimeDatabasePostureOptions = {
+    rlsStrategy: RlsStrategy;
+    expectedRole?: string;
+    targetSchema?: string;
+    protectedTables?: readonly string[];
+    tablePrivileges?: RuntimeTablePrivilegeContract;
+    protectedNoDirectDmlTables?: readonly string[];
+};
+type RuntimeDatabaseIdentity = {
+    currentUser: string;
+    sessionUser: string;
+    databaseOwner: string;
+    canConnectDatabase: boolean;
+    canCreateInDatabase: boolean;
+    rowSecurity: string;
+    canLogin: boolean;
+    superuser: boolean;
+    inherit: boolean;
+    createRole: boolean;
+    createDatabase: boolean;
+    replication: boolean;
+    bypassRls: boolean;
+};
+type RuntimeSchemaPosture = {
+    name: string;
+    owner: string;
+    usage: boolean;
+    create: boolean;
+};
+type RuntimeTablePosture = {
+    name: string;
+    owner: string;
+    rlsEnabled: boolean;
+    rlsForced: boolean;
+    rlsActive: boolean;
+    policyCount: number;
+    select: boolean;
+    insert: boolean;
+    update: boolean;
+    delete: boolean;
+    truncate: boolean;
+    references: boolean;
+    trigger: boolean;
+};
+type RuntimeRoutinePosture = {
+    name: string;
+    owner: string;
+    execute: boolean;
+};
+type RuntimeDatabasePosture = {
+    identity: RuntimeDatabaseIdentity;
+    memberships: string[];
+    schemas: RuntimeSchemaPosture[];
+    ownedSchemas: string[];
+    ownedRelations: string[];
+    tables: RuntimeTablePosture[];
+    privateRoutines: RuntimeRoutinePosture[];
+};
+declare class RuntimeDatabasePostureError extends Error {
+    readonly violations: readonly string[];
+    constructor(violations: readonly string[]);
+}
+/** Inspect only PostgreSQL catalogs and privilege functions; no tenant rows. */
+declare function inspectRuntimeDatabasePosture(db: Database, options: RuntimeDatabasePostureOptions): Promise<RuntimeDatabasePosture>;
+/** Pure deterministic evaluator used by startup/readiness and unit tests. */
+declare function evaluateRuntimeDatabasePosture(posture: RuntimeDatabasePosture, options: RuntimeDatabasePostureOptions): string[];
+declare function assertRuntimeDatabasePosture(db: Database, options: RuntimeDatabasePostureOptions): Promise<RuntimeDatabasePosture>;
+declare function runtimeDatabaseReadyCheck(db: Database, options: RuntimeDatabasePostureOptions): () => Promise<void>;
+
 /** Reject writes whose sanitized text exceeds this many characters. */
 declare const MEMORY_TEXT_MAX_CHARS = 4000;
 /** Per-workspace cap on agent-visible memory records (active ∪ approved). */
@@ -932,6 +1107,12 @@ declare function refreshOAuthConnectionCredential(cred: ConnectionCredentialForB
 }>;
 
 type Database = PgDatabase<any, typeof schema>;
+/** Raised when a durable session tool-policy write lost its version fence. */
+declare class SessionToolPolicyVersionConflictError extends Error {
+    readonly currentVersion: number;
+    readonly code = "SESSION_TOOL_POLICY_CONFLICT";
+    constructor(currentVersion: number);
+}
 type DbClient = {
     db: Database;
     close: () => Promise<void>;
@@ -1270,16 +1451,36 @@ type GitHubInstallation = {
     accountId: string;
     workspaceId: string;
     installationId: number;
+    githubAccountId: number | null;
     accountLogin: string | null;
     accountType: string | null;
     repositoryScope: GitHubRepositoryScope;
     linkedBySubjectId: string | null;
+    githubActorId: number | null;
+    githubActorLogin: string | null;
+    authorityKind: GitHubInstallationAuthorityKind | null;
+    authorityCheckedAt: string | null;
+    authorityExpiresAt: string | null;
+    authorityNonce: string | null;
     createdAt: string;
     updatedAt: string;
 };
 type GitHubInstallationAccess = GitHubInstallation & {
     repositoryIds: number[];
 };
+declare class GitHubInstallationAuthorityCommitError extends Error {
+    constructor();
+}
+/**
+ * True only for a binding created by the owner-authority transaction. Legacy
+ * installation rows remain visible for audit/unlink, but can never make a
+ * workspace healthy, enumerate repositories, or authorize a token mint.
+ *
+ * `authorityExpiresAt` is the expiry of the consumed proof, not of the durable
+ * delegation. A binding remains delegated after that instant; GitHub's live
+ * installation/repository checks govern its ongoing usability.
+ */
+declare function hasAuditableGitHubInstallationAuthority(installation: GitHubInstallationAccess): boolean;
 declare function upsertGitHubInstallation(db: Database, input: {
     accountId: string;
     workspaceId: string;
@@ -1297,6 +1498,22 @@ declare function bindGitHubInstallationRepositories(db: Database, input: {
     linkedBySubjectId: string;
     repositoryIds: number[];
 }): Promise<GitHubInstallationAccess>;
+declare function bindAuthorizedGitHubInstallationRepositories(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    installationId: number;
+    githubAccountId: number;
+    accountLogin: string | null;
+    accountType: string | null;
+    linkedBySubjectId: string;
+    githubActorId: number;
+    githubActorLogin: string;
+    authorityKind: GitHubInstallationAuthorityKind;
+    authorityCheckedAt: Date;
+    authorityExpiresAt: Date;
+    authorityNonce: string;
+    repositoryIds: number[];
+}): Promise<GitHubInstallationAccess | null>;
 declare function listGitHubInstallationsForWorkspace(db: Database, workspaceId: string): Promise<GitHubInstallation[]>;
 declare function listGitHubInstallationIdsForWorkspace(db: Database, workspaceId: string): Promise<number[]>;
 declare function listGitHubInstallationAccessForWorkspace(db: Database, workspaceId: string): Promise<GitHubInstallationAccess[]>;
@@ -1505,6 +1722,8 @@ type CreateConnectionInput = {
     credentialEncrypted: string;
     grantedScopes?: string[];
     expiresAt?: Date | null;
+    verifiedInstallAt?: Date | null;
+    verifiedInstallVersion?: number | null;
     metadata?: Record<string, unknown>;
     createdBySubjectId?: string | null;
     updatedBySubjectId?: string | null;
@@ -1521,9 +1740,37 @@ type UpdateConnectionInput = {
     credentialEncrypted?: string;
     grantedScopes?: string[];
     expiresAt?: Date | null;
+    verifiedInstallAt?: Date | null;
+    verifiedInstallVersion?: number | null;
     metadata?: Record<string, unknown>;
     updatedBySubjectId?: string | null;
 };
+/** Server-owned verification facts; public schemas expose them read-only and nullable. */
+type ConnectionMetadataWithVerification = ConnectionMetadata & {
+    verifiedInstallAt: string | null;
+    verifiedInstallVersion: number | null;
+};
+type SlackBotPostOperation = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    clientMessageId: string;
+    targetKind: "channel" | "user";
+    targetId: string;
+    requestDigest: string;
+    status: "provider_started" | "completed";
+    claimHolderId: string | null;
+    claimExpiresAt: Date | null;
+    attemptCount: number;
+    lastFailureCode: string | null;
+    slackChannelId: string | null;
+    slackMessageTimestamp: string | null;
+    completedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+};
 type ConnectionCredentialForBroker = {
     id: string;
     accountId: string;
@@ -1870,11 +2117,62 @@ declare function decryptedCapabilityHeaders(server: EnabledMcpCapabilityServer,
  */
 declare function getStoredCapabilityHeaderCiphertext(db: Database, workspaceId: string, capabilityId: string): Promise<Record<string, string> | null>;
 declare function mcpServerIdForCapability(capabilityId: string, metadata?: Record<string, unknown>): string;
-declare function createConnection(db: Database, input: CreateConnectionInput): Promise<ConnectionMetadata>;
-declare function listConnectionsMetadata(db: Database, workspaceId: string, subjectId?: string | null): Promise<ConnectionMetadata[]>;
-declare function getConnectionMetadata(db: Database, workspaceId: string, connectionId: string, subjectId?: string | null): Promise<ConnectionMetadata | null>;
-declare function updateConnection(db: Database, input: UpdateConnectionInput): Promise<ConnectionMetadata | null>;
-declare function revokeConnection(db: Database, workspaceId: string, connectionId: string, updatedBySubjectId?: string | null): Promise<ConnectionMetadata | null>;
+declare function createConnection(db: Database, input: CreateConnectionInput): Promise<ConnectionMetadataWithVerification>;
+declare function listConnectionsMetadata(db: Database, workspaceId: string, subjectId?: string | null): Promise<ConnectionMetadataWithVerification[]>;
+declare function getConnectionMetadata(db: Database, workspaceId: string, connectionId: string, subjectId?: string | null): Promise<ConnectionMetadataWithVerification | null>;
+declare function updateConnection(db: Database, input: UpdateConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
+declare function revokeConnection(db: Database, workspaceId: string, connectionId: string, updatedBySubjectId?: string | null): Promise<ConnectionMetadataWithVerification | null>;
+type ClaimSlackBotPostOperationResult = {
+    kind: "claimed" | "in_progress" | "completed";
+    operation: SlackBotPostOperation;
+} | {
+    kind: "conflict" | "connection_not_found";
+};
+/**
+ * Claims one durable Slack post identity. The insert occurs before any provider
+ * call; retries retain the original client_msg_id and immutable request digest.
+ * A live claim suppresses concurrent sends, while a released/expired claim can
+ * be reclaimed after response loss or process death.
+ */
+declare function claimSlackBotPostOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    targetKind: "channel" | "user";
+    targetId: string;
+    requestDigest: string;
+    claimHolderId: string;
+    claimLeaseMs: number;
+}): Promise<ClaimSlackBotPostOperationResult>;
+declare function releaseSlackBotPostOperationClaim(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+    failureCode: string;
+}): Promise<boolean>;
+type CompleteSlackBotPostOperationResult = {
+    kind: "completed";
+    operation: SlackBotPostOperation;
+    newlyCompleted: boolean;
+} | {
+    kind: "not_found" | "not_owned";
+};
+/** Completion and the single success audit receipt commit atomically. */
+declare function completeSlackBotPostOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+    slackChannelId: string;
+    slackMessageTimestamp: string;
+    subjectId?: string | null;
+    auditMetadata: Record<string, unknown>;
+}): Promise<CompleteSlackBotPostOperationResult>;
+declare function getSlackBotPostOperation(db: Database, workspaceId: string, connectionId: string, operationId: string): Promise<SlackBotPostOperation | null>;
 declare function loadConnectionCredentialForBroker(db: Database, settings: Settings, input: {
     workspaceId: string;
     connectionId?: string;
@@ -2542,12 +2840,13 @@ type CodexCapacityWait = {
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    goalId: string;
+    goalId: string | null;
     blockedTurnId: string;
+    blockedTurnGeneration: number;
     workflowId: string;
     generation: number;
     status: CodexCapacityWaitStatus;
-    goalVersion: number;
+    goalVersion: number | null;
     policyHash: string | null;
     earliestResetAt: Date | null;
     nextCheckAt: Date;
@@ -2607,7 +2906,10 @@ type ReconcileCodexCapacityWaitResult = {
 } | {
     action: "resumed";
     waiter: CodexCapacityWait;
-    update: SessionSystemUpdate;
+    events: SessionEvent[];
+} | {
+    action: "paused";
+    waiter: CodexCapacityWait;
     events: SessionEvent[];
 } | {
     action: "superseded";
@@ -2627,14 +2929,13 @@ declare const CODEX_CAPACITY_REFRESH_MAX_MS: number;
  */
 declare function codexCapacityRefreshBackoffMs(attempt: number): number;
 /**
- * Atomically settle one all-unavailable turn and arm exactly one durable wait.
- * Lock order is allocator rotation row -> workspace control -> actual workspace
- * -> session -> exact turn -> exact attempt -> goal -> live lease (when a
- * reactive failure owns one) -> waiter. The control share lock and effective
- * control recheck prevent a capacity boundary from closing an attempt after a
- * committed Pause. The failed turn, idle/capacity-paused session, durable
- * events, lease release, and waiter generation commit together; a crash cannot
- * leave only half of the boundary visible.
+ * Atomically close one all-unavailable attempt and arm exactly one durable wait
+ * for the same logical turn. Lock order is allocator rotation row -> workspace
+ * control -> actual workspace -> session -> exact turn -> exact attempt ->
+ * optional goal -> live lease (when a reactive failure owns one) -> waiter.
+ * The waiting turn/session pointer, durable events, exact lease release, and
+ * waiter generation commit together; a crash cannot leave only half of the
+ * boundary visible.
  */
 declare function armCodexCapacityWait(db: Database, input: {
     accountId: string;
@@ -2643,8 +2944,8 @@ declare function armCodexCapacityWait(db: Database, input: {
     turnId: string;
     attemptId: string;
     workflowId: string;
-    goalId: string;
-    goalVersion: number;
+    goalId?: string | null;
+    goalVersion?: number | null;
     policyHash?: string | null;
     earliestResetAt: Date | null;
     resetKind: CodexCapacityResetKind;
@@ -2660,8 +2961,8 @@ declare function armCodexCapacityWait(db: Database, input: {
 }): Promise<ArmCodexCapacityWaitResult>;
 declare function getCodexCapacityWaitForSession(db: Database, workspaceId: string, sessionId: string): Promise<CodexCapacityWait | null>;
 /**
- * Same-transaction capacity-mutation/outbox seam for account eligibility and
- * policy-scope membership/default changes. The allocator rotation row is always the
+ * Same-transaction capacity-mutation/outbox seam for eligibility and
+ * membership/default changes. The allocator rotation row is always the
  * first lock. Mutations report whether capacity truth changed; only then are
  * matching waiter wake revisions advanced and returned for best-effort signal.
  */
@@ -2677,10 +2978,11 @@ declare function listPendingCodexCapacityWakeTargets(db: Database, workspaceId:
 /**
  * Row-lock and re-evaluate one waiter. Availability is decided by a pure
  * caller supplied policy over the same rotation-row transaction as normal
- * acquisition. If available, one system goal-continuation event and one turn
- * are committed; duplicate timers/signals observe status=resumed and do no
- * work. If any goal/control/policy/turn/queue fence changed, the waiter is
- * superseded without inference.
+ * acquisition. If available, the exact blocked turn becomes `recovering`;
+ * duplicate timers/signals observe status=resumed and do no work. Effective
+ * Pause leaves the waiter untouched, ordinary queued prompts remain behind the
+ * current inference, and only an explicit semantic fence change supersedes the
+ * waiter/blocked turn without inference.
  */
 declare function reconcileCodexCapacityWait<TPolicyScope = never, TUnavailableDiagnostic = never>(db: Database, input: {
     accountId: string;
@@ -4249,9 +4551,16 @@ declare function recordWarmingSandboxCreated(db: Database, input: {
     recorded: boolean;
     lease: LeaseSnapshot | null;
 }>;
+type LostProviderWorkspaceSettlement = {
+    processesLost: number;
+    admissionsRejected: number;
+    ptysClosed: number;
+    processHoldersDeleted: number;
+};
 type MarkWarmLeaseInstanceLostResult = {
     status: "marked";
     lease: LeaseSnapshot;
+    settlement: LostProviderWorkspaceSettlement;
 } | {
     status: "stale";
     lease: LeaseSnapshot | null;
@@ -4263,10 +4572,11 @@ type MarkWarmLeaseInstanceLostResult = {
  * box, but only the first one transitions the lease to cold and advances its
  * epoch. The next ordinary acquire elects one cold->warming spawner.
  *
- * Holders remain intact because their logical work/viewer interest still exists.
- * Only live provider identity is cleared. A persisted workspace archive is
- * reduced to the same minimal cold envelope used by the drain/failure paths, so
- * the elected replacement can hydrate it without carrying the dead box id.
+ * Logical turn/viewer interest remains intact, while holders for active
+ * processes that physically belonged to the lost provider are removed with
+ * their terminal loss proof. A persisted workspace archive is reduced to the
+ * same minimal cold envelope used by the drain/failure paths, so the elected
+ * replacement can hydrate it without carrying the dead box id.
  */
 declare function markWarmLeaseInstanceLost(db: Database, input: {
     accountId: string;
@@ -4277,6 +4587,33 @@ declare function markWarmLeaseInstanceLost(db: Database, input: {
     /** Bounded classifier output only; never raw provider error text. */
     diagnostic?: string;
 }): Promise<MarkWarmLeaseInstanceLostResult>;
+type ReconcileColdLostLeaseInstanceBlockersResult = {
+    status: "reconciled";
+    lease: LeaseSnapshot;
+    settlement: LostProviderWorkspaceSettlement;
+} | {
+    status: "stale";
+    lease: LeaseSnapshot | null;
+};
+/**
+ * Settle blockers left by a provider-loss transition that predates exact loss
+ * cleanup. This is deliberately narrower than markWarmLeaseInstanceLost: it
+ * requires the already-cold lease to match the full operator-observed
+ * generation/archive tuple, the current epoch to be exactly lostEpoch + 1, and
+ * recovery truth to name the same missing provider. It never advances an epoch,
+ * rematerializes a provider, or changes archive/recovery completeness.
+ */
+declare function reconcileColdLostLeaseInstanceBlockers(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedCurrentEpoch: number;
+    expectedLostEpoch: number;
+    expectedLostInstanceId: string;
+    expectedWorkspaceGeneration: number;
+    expectedArchiveGeneration: number | null;
+    expectedArchiveComplete: boolean;
+}): Promise<ReconcileColdLostLeaseInstanceBlockersResult>;
 declare function failWarmingToCold(db: Database, input: {
     accountId: string;
     workspaceId: string;
@@ -4385,7 +4722,7 @@ declare function confirmDrainCold(db: Database, input: {
 }>;
 declare class SandboxWorkspaceMutationFencedError extends Error {
     readonly code: "attempt_fenced" | "holder_fenced" | "lease_fenced" | "route_fenced" | "process_fenced" | "admission_fenced" | "operation_invalid" | "generation_exhausted";
-    readonly name = "SandboxWorkspaceMutationFencedError";
+    readonly name: string;
     constructor(code: "attempt_fenced" | "holder_fenced" | "lease_fenced" | "route_fenced" | "process_fenced" | "admission_fenced" | "operation_invalid" | "generation_exhausted", message: string);
 }
 type SandboxWorkspaceMutationAdmission = {
@@ -4433,7 +4770,53 @@ type SandboxRetainedProcess = {
     settlementReason: string | null;
     startedAt: string;
     settledAt: string | null;
+    reconcileAfter: string;
+    reconcileClaimId: string | null;
+    reconcileClaimedAt: string | null;
+    reconcileAttempts: number;
+    lastReconcileOutcome: string | null;
+    reconcileProofOutcome: "exited" | "lost" | null;
+    reconcileProofExitCode: number | null;
+    reconcileProofReason: "provider_exit_banner" | "provider_session_lost_banner" | "provider_instance_not_found" | null;
+    reconcileProofObservedAt: string | null;
+};
+type RetainedProcessProviderProof = {
+    outcome: "exited";
+    exitCode: number;
+    reason: "provider_exit_banner";
+} | {
+    outcome: "lost";
+    exitCode: null;
+    reason: "provider_session_lost_banner" | "provider_instance_not_found";
+};
+type SandboxRetainedProcessIdentity = Pick<SandboxRetainedProcess, "leaseId" | "sandboxGroupId" | "parentAdmissionId" | "holderId" | "leaseEpoch" | "providerBackend" | "providerInstanceId" | "routeKind" | "routeTargetId" | "routeEpoch" | "providerSessionId">;
+type SandboxRetainedProcessReconciliationClaim = {
+    process: SandboxRetainedProcess;
+    claimId: string;
+    ownerState: string;
+    ownerAttemptOutcome: string | null;
+};
+type ActiveRetainedProcessOwnerCount = {
+    ownerState: string;
+    activeCount: number;
+    terminalOwnerCount: number;
+};
+type ExpiredDrainingSandboxLeaseCount = {
+    backend: string;
+    ageBucket: "lt_5m" | "5m_1h" | "1h_1d" | "gte_1d";
+    count: number;
 };
+declare function retainedProcessSettlementIdentity(process: SandboxRetainedProcess): SandboxRetainedProcessIdentity;
+declare function retainedProcessReconciliationProof(process: SandboxRetainedProcess): RetainedProcessProviderProof | null;
+/** Durable promotion committed before a mutable route/turn authority check
+ * rejected the provider output. The process identity is safe to hand to the
+ * exact-backend cancellation path; callers must still reject the output and
+ * must never replay the provider mutation. */
+declare class SandboxRetainedProcessPromotionFencedError extends SandboxWorkspaceMutationFencedError {
+    readonly process: SandboxRetainedProcess;
+    readonly name = "SandboxRetainedProcessPromotionFencedError";
+    constructor(code: "attempt_fenced" | "holder_fenced" | "lease_fenced" | "route_fenced" | "process_fenced" | "admission_fenced", message: string, process: SandboxRetainedProcess);
+}
 /**
  * Advance the live workspace's mutation generation before an acknowledged
  * filesystem-writing operation reaches the provider. The normal activity write
@@ -4576,6 +4959,44 @@ declare function getRetainedProcess(db: Database, input: {
     sessionId: string;
     processId: string;
 }): Promise<SandboxRetainedProcess | null>;
+/** Claim a bounded, oldest-due batch of active retained processes whose exact
+ * owner attempt is closed (or whose direct request already returned). Claim
+ * expiry only recovers coordination after worker death; it is never provider
+ * exit proof. Rows that settle between the global claim and scoped read are
+ * deliberately omitted. */
+declare function claimTerminalRetainedProcesses(db: Database, input: {
+    claimId: string;
+    limit: number;
+    claimTtlMs: number;
+}): Promise<SandboxRetainedProcessReconciliationClaim[]>;
+/** Durably checkpoint exact provider exit/loss proof before canonical
+ * settlement. This closes the worker-death window between provider observation
+ * and settlement without converting owner state, age, timeout, or claim expiry
+ * into physical proof. */
+declare function recordRetainedProcessReconciliationProof(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+    expected: SandboxRetainedProcessIdentity;
+    claimId: string;
+    proof: RetainedProcessProviderProof;
+}): Promise<SandboxRetainedProcess>;
+/** Release one exact reconciliation claim after an ambiguous/running provider
+ * observation. This schedules a bounded retry but never changes process,
+ * admission, holder, lease, archive, snapshot, or workspace state. */
+declare function deferRetainedProcessReconciliation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+    expected: SandboxRetainedProcessIdentity;
+    claimId: string;
+    outcome: string;
+    retryAfterMs: number;
+}): Promise<boolean>;
+declare function countActiveRetainedProcessesByOwnerState(db: Database): Promise<ActiveRetainedProcessOwnerCount[]>;
+declare function countExpiredDrainingSandboxLeases(db: Database): Promise<ExpiredDrainingSandboxLeaseCount[]>;
 /** Settle an exact retained process only after exit or definitive loss proof.
  * The process row, parent admission, non-TTL holder, and lease count transition
  * commit atomically. Duplicate identical proof is idempotent; conflicting proof
@@ -4585,6 +5006,8 @@ declare function settleRetainedProcess(db: Database, input: {
     workspaceId: string;
     sessionId: string;
     processId: string;
+    expected: SandboxRetainedProcessIdentity;
+    reconciliationClaimId?: string;
     outcome: "exited" | "lost";
     exitCode?: number | null;
     reason: string;
@@ -6002,19 +6425,25 @@ type LockedSessionUpdateContext = {
     updateSessionMcpServerCredentials: (updates: UpdateSessionMcpServerCredentialsInput[]) => Promise<UpdateSessionMcpServerCredentialsResult>;
     updateSessionMcpApprovalPolicy: (serverId: string, requireApproval: SessionMcpApprovalPolicy) => Promise<UpdateSessionMcpApprovalPolicyResult>;
     listPendingSessionTurns: () => Promise<SessionTurn[]>;
+    getLockedSession: (sessionId: string) => Promise<Session | null>;
 };
 type LockedSessionUpdateResult = {
     events: AppendEventInput[];
     update?: {
         resources?: ResourceRef[];
         tools?: ToolRef[];
+        toolPolicy?: SessionToolPolicy;
+        toolPolicyVersion?: number;
+        expectedToolPolicyVersion?: number;
         model?: string;
         metadata?: Record<string, unknown>;
         status?: SessionStatus;
         activeTurnId?: string | null;
     };
 };
-declare function appendSessionEventsWithLockedSessionUpdate(db: Database, workspaceId: string, sessionId: string, build: (session: Session, context: LockedSessionUpdateContext) => LockedSessionUpdateResult | Promise<LockedSessionUpdateResult>): Promise<SessionEvent[]>;
+declare function appendSessionEventsWithLockedSessionUpdate(db: Database, workspaceId: string, sessionId: string, build: (session: Session, context: LockedSessionUpdateContext) => LockedSessionUpdateResult | Promise<LockedSessionUpdateResult>, options?: {
+    lockParentSession?: boolean;
+}): Promise<SessionEvent[]>;
 declare function sessionSubject(workspaceId: string, sessionId: string): string;
 
-export { type CodexResetRedemptionOutcome as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BeginSandboxRematerializationResult as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type CodexAccountUsageSnapshot as D, type CodexAllocatorUpdateResult as E, type CodexAuthDeps as F, type CodexCapacityAvailabilityDecision as G, type CodexCapacityMutationResult as H, type CodexCapacityResetKind as I, type CodexCapacitySelectionContext as J, type CodexCapacityWait as K, type CodexCapacityWaitStatus as L, type CodexCapacityWakeTarget as M, type CodexCredentialForRun as N, type CodexCredentialLeaseCandidateFilter as O, type CodexCredentialLeaseCandidateFilterResult as P, type ProvisionResult, type ProvisionRolesOptions, type CodexCredentialLeasePolicyScopeResolver as Q, type CodexCredentialLeaseQuarantine as R, type CodexCredentialLeaseResult as S, type CodexCredentialLeaseSelection as T, type CodexCredentialLeaseSelectionContext as U, type CodexCredentialStatus as V, type CodexCredentialTokens as W, type CodexLeaseAccountStatus as X, type CodexPinSource as Y, type CodexRateLimitResetCreditsAccountResult as Z, type CodexResetRedemptionAttempt as _, type AcceptSessionApprovalDecisionResult as a, type InstallOrReadTurnExecutionPolicyForAttemptResult as a$, type CodexResetRedemptionRecovery as a0, type CodexResetRedemptionSendNotReadyReason as a1, type CodexResetRedemptionStatus as a2, type CodexRotationSettings as a3, type CodexRotationStrategy as a4, type CodexTokenDeadlineClock as a5, type CodexTokenDeadlineOptions as a6, type ComposerDraftRow as a7, type ConnectionBrokerDeps as a8, type ConnectionCredentialForBroker as a9, type EffectiveSessionControl as aA, type EnableCapabilityInstallationInput as aB, type EnabledMcpCapabilityServer as aC, type EnqueueSessionTurnInput as aD, type EnrollmentExposure as aE, type EnrollmentOs as aF, type EnrollmentRecord as aG, type EnrollmentStatus as aH, type ExpiredFileUploadCleanupClaim as aI, type FenceCodexResetRedemptionSendResult as aJ, type FileUploadCleanupClaimResult as aK, type ForceDrainResult as aL, type FrozenTurnInitiator as aM, type GitHubInstallation as aN, type GitHubInstallationAccess as aO, type GoalContinuationDecision as aP, type HostExportConsumerStatus as aQ, type HostExportKind as aR, HostExportPayloadError as aS, HostMcpCredentialBindingError as aT, type HostMcpCredentialResolverContext as aU, HostMcpCredentialScopeError as aV, HumanInputResponseValidationError as aW, type IdempotentPersistenceTransactionOptions as aX, type ImportBatch as aY, type InitializeSessionStartInput as aZ, type InitializeSessionStartResult as a_, ConnectionRefreshHttpError as aa, type ConsumeOAuthStateNonceInput as ab, type CorrectWorkspaceMemoryInput as ac, type CorrectWorkspaceMemoryResult as ad, type CreateCapabilityCatalogItemInput as ae, type CreateConnectionInput as af, type CreateDbOptions as ag, type CreateImportBatchInput as ah, type CreateKnowledgeMemoryInput as ai, type CreatePackInstallationInput as aj, type CreateScheduledTaskInput as ak, type CreateSessionGoalInput as al, type CreateSessionMcpServerInput as am, type CreateSocialConnectionInput as an, type CreateSocialPostInput as ao, type CreditBalanceByAccount as ap, type Database as aq, type DatabaseFailureCode as ar, type DbClient as as, type DbSession as at, type DeviceEnrollmentRequestRecord as au, type DeviceEnrollmentStatus as av, type EditQueueCommandResult as aw, type EffectiveControlBlocker as ax, type EffectiveControlResumeOption as ay, type EffectiveControlState as az, type AcceptSessionHumanInputResponseResult as b, RigChangeTransitionError as b$, type IntegrationOAuthClientForUse as b0, type LeaseHolderKind as b1, type LeaseSnapshot as b2, type ListKnowledgeMemoryOptions as b3, type ListSessionEventPageOptions as b4, type ListSessionEventsOptions as b5, type ListSessionsForSubjectOptions as b6, type ListSessionsOptions as b7, type LiveModalSandboxLeaseAttribution as b8, MACHINE_METRICS_SERIES_INTERVAL_MS as b9, NewSessionDraftAccessError as bA, NewSessionDraftConflictError as bB, type NewSessionDraftRow as bC, type PendingSessionToolCallInput as bD, type PersistenceFailureDetails as bE, type PersistenceRetryOutcome as bF, type QueueCommandConflictCode as bG, QueueCommandConflictError as bH, type QueueCommandResult as bI, type QueuedTurnRow as bJ, type ReapDrainable as bK, type ReconcileCodexCapacityWaitResult as bL, type RecoverSessionDispatchInput as bM, type RecoverSessionDispatchResult as bN, type RefreshTransportOptions as bO, type RegisterWorkspacePackInput as bP, type RegistryCapabilityCatalogItemInput as bQ, type RegistryCatalogSurfaceKey as bR, type ReplaceIntegrationOAuthClientInput as bS, type RequestSessionTurnRecoveryInput as bT, type RequestSessionTurnRecoveryResult as bU, type ResolveConnectionCredentialInput as bV, type ResolveConnectionCredentialResult as bW, type RetainedFileArtifact as bX, RigActiveVersionChangedError as bY, RigChangeAlreadyVerifyingError as bZ, type RigChangeMonitoringSummary as b_, MAX_INTERNAL_UPDATE_BATCH_BYTES as ba, MAX_INTERNAL_UPDATE_BATCH_MEMBERS as bb, MAX_INTERNAL_UPDATE_BYTES as bc, MEMORY_ACTIVE_RECORD_CAP as bd, MEMORY_BLOCK_KIND_ORDER as be, MEMORY_BLOCK_RECORD_LIMIT as bf, MEMORY_CORRECT_TOOL_DESCRIPTION as bg, MEMORY_KIND_SECTION_TITLES as bh, MEMORY_NEAR_DUP_COSINE_THRESHOLD as bi, MEMORY_NEAR_DUP_NEIGHBORS as bj, MEMORY_SAVE_TOOL_DESCRIPTION as bk, MEMORY_SEARCH_DEFAULT_LIMIT as bl, MEMORY_SEARCH_MAX_LIMIT as bm, MEMORY_SEARCH_TOOL_DESCRIPTION as bn, MEMORY_TEXT_MAX_CHARS as bo, MEMORY_VISIBLE_RECORD_CAP as bp, type MachineMetricsRow as bq, type MachineMetricsSample as br, type MarkWarmLeaseInstanceLostResult as bs, type MaterializeGoalContinuationResult as bt, type MemoryBlockRecord as bu, type MemoryEmbedder as bv, type MemorySanitizeResult as bw, type MeterableWarmLease as bx, type NestedAgentDepthDeploymentPolicy as by, type NestedAgentDepthPolicySource as bz, type AccrueWarmSecondsResult as c, type SessionListCursor as c$, type RigVersionContentInput as c0, type RigVersionMonitoringSummary as c1, type RlsContext as c2, type RlsStrategy as c3, SESSION_ANCESTRY_LIMIT as c4, SESSION_DISCOVERY_CONTROL_TARGET_LIMIT as c5, SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS as c6, SESSION_DISCOVERY_GOAL_MAX_CHARS as c7, SESSION_DISCOVERY_MESSAGE_MAX_CHARS as c8, SESSION_EVENT_DB_PAGE_MAX_BYTES as c9, type SaveWorkspaceMemoryResult as cA, type SessionAttemptInterruptionSettlement as cB, type SessionCodexState as cC, type SessionCommandActor as cD, SessionCommandIdempotencyError as cE, type SessionCommandReceiptRow as cF, SessionContextBusyError as cG, SessionControlConflictError as cH, SessionControlInvariantError as cI, type SessionControlMutationResult as cJ, type SessionCreateDeniedResult as cK, type SessionCreateInput as cL, type SessionCreateResult as cM, type SessionCreateSuccessResult as cN, type SessionDepthPolicy as cO, type SessionDiscoveryControl as cP, type SessionDiscoveryCursor as cQ, type SessionDiscoveryOrderBy as cR, type SessionDiscoverySummary as cS, type SessionEventPage as cT, SessionEventPersistenceError as cU, type SessionEventWriteLockInput as cV, type SessionEventWriteLocks as cW, type SessionGoalContinuationProjection as cX, SessionIdConflictError as cY, type SessionLineage as cZ, SessionListAccessError as c_, SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT as ca, SESSION_LIST_SNAPSHOT_MAX_IDS as cb, type SafeDatabaseErrorFacts as cc, type SandboxArchiveAvailability as cd, type SandboxArchiveRevision as ce, SandboxImageConflictError as cf, type SandboxKind as cg, type SandboxLeaseLiveness as ch, SandboxLeaseRecoveryBlockedError as ci, SandboxLeaseSupersededError as cj, type SandboxOpenPtySessionRow as ck, type SandboxProviderExistence as cl, type SandboxPtyProcessIdentity as cm, type SandboxPtySessionRow as cn, type SandboxRecord as co, type SandboxRecoveryState as cp, type SandboxRestoreStatus as cq, type SandboxRetainedProcess as cr, type SandboxRetainedProcessState as cs, SandboxRigConflictError as ct, type SandboxWorkspaceMutationAdmission as cu, SandboxWorkspaceMutationFencedError as cv, type SandboxWorkspaceMutationProviderOutcome as cw, type SandboxWorkspaceReadiness as cx, SanitizedDatabasePersistenceCause as cy, type SaveWorkspaceMemoryInput as cz, type AcquireLeaseInput as d, acceptSessionHumanInputResponse as d$, SessionListCursorError as d0, SessionListCursorExpiredError as d1, SessionListSnapshotLimitError as d2, type SessionMcpServerForRun as d3, SessionPinAccessError as d4, SessionPinVersionConflictError as d5, type SessionRecordingCodec as d6, type SessionRecordingMode as d7, type SessionRecordingRow as d8, type SessionRecordingState as d9, type UpdateKnowledgeMemoryInput as dA, type UpdateScheduledTaskInput as dB, type UpdateSessionMcpApprovalPolicyResult as dC, type UpdateSessionMcpServerCredentialsInput as dD, type UpdateSessionMcpServerCredentialsResult as dE, type UpsertCodexSubscriptionCredentialResult as dF, type UserLookup as dG, type VariableSetForRun as dH, WORKSPACE_MEMORY_BLOCK_EMPTY as dI, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as dJ, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as dK, type WorkspaceCaptureCommitResult as dL, type WorkspaceCaptureGcPlan as dM, type WorkspaceCaptureGcRow as dN, type WorkspaceCaptureRow as dO, type WorkspaceControlLockMode as dP, type WorkspaceControlMutationResult as dQ, type WorkspaceControlRow as dR, type WorkspaceEnvironmentForRun as dS, type WorkspaceMemoryOrigin as dT, type WorkspaceMemorySearchInput as dU, type WorkspaceMemorySearchMode as dV, type WorkspaceMemorySearchResult as dW, type WorkspaceModelPolicy as dX, abandonCodexResetRedemptionBeforeProvider as dY, abandonRecordingForTurnAttempt as dZ, acceptSessionApprovalDecision as d_, type SessionSpawnDenial as da, type SessionSpawnDenialCode as db, SessionSpawnDeniedDbError as dc, type SessionSystemUpdateOutboxDelivery as dd, type SessionTurnAttemptOutcome as de, type SessionTurnForExecution as df, type SessionTurnRecordingSettlement as dg, type SessionWorkPeek as dh, type SessionWorkTrigger as di, type SessionWorkflowWake as dj, type SessionWorkflowWakeDeliveryResult as dk, type SetSessionCodexPinOptions as dl, type SetSessionGoalStatusEvent as dm, type SettleCodexCredentialFailoverResult as dn, type SettleCodexCredentialLeaseLossResult as dp, type SteerQueueCommandResult as dq, type StoreIntegrationOAuthClientInput as dr, type StoredIntegrationOAuthClient as ds, type StreamAcknowledgment as dt, type SubmitHumanPromptResult as du, type ToolspaceCallReservation as dv, type ToolspaceTurnAttemptClaims as dw, type TurnAttemptFenceRejectReason as dx, type UpdateConnectionInput as dy, type UpdateImportBatchCountsInput as dz, type AcquireLeaseResult as e, consumeNewSessionDraftInTransaction as e$, accrueWarmSeconds as e0, acknowledgeHostExportBatch as e1, acquireCodexCredentialLease as e2, acquireLease as e3, activateRigVersion as e4, addSessionSystemUpdate as e5, addSessionSystemUpdateWithSourceMutation as e6, admitToolspaceTurnAttempt as e7, adoptCodexResetRedemptionAttempt as e8, advanceWorkspaceGeneration as e9, buildHostConnectionTokenResolver as eA, canonicalSessionCommandHash as eB, claimCodexResetRedemption as eC, claimExpiredFileUploadCleanup as eD, claimFileUploadCleanup as eE, claimHostExportBatch as eF, claimPendingSessionSystemUpdateOutbox as eG, claimPendingSessionWorkflowWakes as eH, claimSessionWorkForAttempt as eI, clearDurablePendingSessionToolCalls as eJ, clearEnrollmentWentOffline as eK, clearPendingSessionToolspaceCall as eL, clearSessionContext as eM, clearSessionGoal as eN, clearedContextMarkerItem as eO, closePtySession as eP, closeSessionTurnAttemptInTransaction as eQ, codexCapacityRefreshBackoffMs as eR, commitWarmingToWarm as eS, completeCodexResetRedemption as eT, completeExpiredFileUploadCleanup as eU, completeFileUpload as eV, completeFileUploadCleanup as eW, computeWorkspaceCaptureGcPlan as eX, confirmDrainCold as eY, consumeDeviceEnrollmentRequest as eZ, consumeIntegrationOAuthStateNonce as e_, advanceWorkspaceGenerationForDirectRequest as ea, advanceWorkspaceGenerationForRetainedProcess as eb, allAccountPermissions as ec, allWorkspacePermissions as ed, appendSessionEventToSandboxGroup as ee, appendSessionEvents as ef, appendSessionEventsAndUpdateSession as eg, appendSessionEventsForTurnAttempt as eh, appendSessionEventsWithLockedSessionUpdate as ei, appendSessionHistoryItems as ej, applyContextCompaction as ek, applyCreditDebitUpToBalance as el, applyCreditLedgerEntry as em, applySessionTurnSettlement as en, approveDeviceEnrollmentRequest as eo, areGitHubRepositoriesAllowedForWorkspace as ep, armCodexCapacityWait as eq, assertAgentCommandAuthorityInTransaction as er, autoResumeSessionBranchInTransaction as es, beginRigChangeVerificationAttempt as et, beginSandboxRematerialization as eu, bindGitHubInstallationRepositories as ev, bootstrapWorkspace as ew, buildChildCompletionDigest as ex, buildCodexTokenResolver as ey, buildConnectionTokenResolver as ez, type ActiveSandboxPointer as f, disableHostExportConsumer as f$, correctWorkspaceMemory as f0, countActiveApiKeysForWorkspace as f1, countActiveSessionHistoryItems as f2, countActiveSessionsForWorkspace as f3, countActiveSessionsUsingEnvironment as f4, countActiveSessionsUsingVariableSet as f5, countConsecutiveReactiveRotations as f6, countQueuedTurns as f7, countRigs as f8, countSandboxLeasesByLiveness as f9, createSessionWithIdempotencyKey as fA, createSessionWithIdempotencyKeyResult as fB, createSocialConnection as fC, createSocialPost as fD, createVariableSet as fE, createWorkspace as fF, createWorkspaceEnvironment as fG, databaseFailureCode as fH, deadLetterHostExportHead as fI, decodeSessionListCursor as fJ, decryptEnvironmentValue as fK, decryptedCapabilityHeaders as fL, deleteGitHubInstallationBinding as fM, deleteRecording as fN, deleteRig as fO, deleteRigIfNoActiveSessions as fP, deleteScheduledTask as fQ, deleteSessionQueueItemInTransaction as fR, deleteVariableSet as fS, deleteVariableSetVariable as fT, deleteWorkspace as fU, deleteWorkspaceCaptureRows as fV, deleteWorkspaceEnvironment as fW, deleteWorkspaceEnvironmentVariable as fX, deleteWorkspacePack as fY, denyDeviceEnrollmentRequest as fZ, disableCapabilityInstallation as f_, countScheduledTasksForWorkspace as fa, countScheduledTasksUsingEnvironment as fb, countScheduledTasksUsingVariableSet as fc, countSessionHistoryItems as fd, countSessionsUsingRig as fe, countVariableSets as ff, countWorkspaceEnvironments as fg, countWorkspacesForAccount as fh, createApiKey as fi, createConnection as fj, createDb as fk, createDeviceEnrollmentRequest as fl, createEnrollment as fm, createFileUpload as fn, createImportBatch as fo, createKnowledgeMemory as fp, createRig as fq, createRigChange as fr, createRigVersion as fs, createRigVersionForChangePromotion as ft, createSandbox as fu, createScheduledTask as fv, createScheduledTaskRun as fw, createSession as fx, createSessionGoal as fy, createSessionMcpServers as fz, type AddSessionSystemUpdateInput as g, getRetainedProcess as g$, disconnectAllCodexAccounts as g0, disconnectCodexAccount as g1, editQueuedTurnInTransaction as g2, enableCapabilityInstallation as g3, enablePackInstallation as g4, encodeSessionListCursor as g5, encryptEnvironmentValue as g6, enqueueSessionTurn as g7, enqueueSessionWorkflowWake as g8, enqueueSessionWorkflowWakeIfRunnable as g9, getCodexCapacityWaitForSession as gA, getCodexCredentialStatus as gB, getCodexResetRedemptionAttempt as gC, getCodexRotationSettings as gD, getComposerDraftInTransaction as gE, getConnectionMetadata as gF, getDeviceEnrollmentRequestByDeviceCode as gG, getEnrollment as gH, getFile as gI, getFileUpload as gJ, getHostExportConsumerStatus as gK, getHumanInputResumeForEvent as gL, getKnowledgeMemory as gM, getLatestRunState as gN, getLatestStartedSessionTurn as gO, getManagedAccount as gP, getManagedUserByEmail as gQ, getMaterializedSandboxFileResources as gR, getNestedAgentDepthDeploymentPolicy as gS, getNewSessionDraftInTransaction as gT, getOpenPtySession as gU, getOrCreateSessionSystemUpdateOutbox as gV, getPackInstallation as gW, getPendingDeviceEnrollmentRequestByUserCode as gX, getPendingDeviceEnrollmentRequestByUserCodeGlobal as gY, getRecording as gZ, getRetainedFileArtifact as g_, enqueueSessionWorkflowWakeInTransaction as ga, ensureCodexRotationSettings as gb, ensureManagedAccessForUser as gc, estimateMemoryTokens as gd, evaluateGoalContinuation as ge, evaluateSessionControl as gf, evaluateSessionControls as gg, evaluateSessionDiscoveryControls as gh, expireSessionHumanInputRequest as gi, failHostExportBatch as gj, failSandboxRematerialization as gk, failWarmingToCold as gl, fenceCodexResetRedemptionSend as gm, fetchCodexRateLimitResetCreditsForAccount as gn, fetchCodexUsageForAccount as go, finalizeEnrollmentByToken as gp, findActiveApiKeyByHash as gq, forceDrainOverLimitViewerOnlyBoxes as gr, frozenInitiatorForCommandActor as gs, getActiveSessionHistoryItems as gt, getActiveSessionTurnForExecution as gu, getAnySessionInGroup as gv, getBillingBalance as gw, getBillingCustomer as gx, getCapabilityCatalogItem as gy, getCapabilityInstallation as gz, type AddSessionSystemUpdateResult as h, isStripeWebhookProcessed as h$, getRig as h0, getRigByName as h1, getRigChange as h2, getRigName as h3, getRigVersion as h4, getRigVersionById as h5, getSandbox as h6, getSandboxSessionEnvelope as h7, getScheduledTask as h8, getSession as h9, getWorkspaceEnvironment as hA, getWorkspaceEnvironmentByName as hB, getWorkspaceEnvironmentValuesForRun as hC, getWorkspaceGrant as hD, getWorkspaceModelPolicy as hE, getWorkspacePack as hF, grantWorkspaceAccess as hG, hasCreditLedgerEntry as hH, hashMemoryText as hI, heartbeatCodexCredentialLease as hJ, heartbeatCodexCredentialLeaseUntil as hK, heartbeatLeaseHolder as hL, ingestMachineMetricsSample as hM, initializeSessionStartAtomically as hN, insertFailedWorkspaceCapture as hO, insertMachineMetricsSeries as hP, insertPtySession as hQ, insertRecording as hR, insertWorkspaceCapture as hS, installOrReadTurnExecutionPolicyForAttempt as hT, interruptedToolCallResult as hU, isCodexBilledTurn as hV, isDatabasePersistenceFailure as hW, isMemoryTextTooLong as hX, isRetryablePersistenceSqlState as hY, isSessionCompactionRequested as hZ, isSessionEventPersistenceError as h_, getSessionByCreateIdempotencyKey as ha, getSessionCodexState as hb, getSessionEvent as hc, getSessionEventByClientEventId as hd, getSessionForSubject as he, getSessionGoal as hf, getSessionGoalWithContinuation as hg, getSessionHistoryItems as hh, getSessionHumanInputRequest as hi, getSessionLineage as hj, getSessionQueueSnapshot as hk, getSessionRootId as hl, getSessionSpawnDenial as hm, getSessionSpawnDenialByIdempotencyKey as hn, getSessionSystemUpdateOutboxByDedupeKey as ho, getSessionTurn as hp, getSessionTurnForAttempt as hq, getSocialConnection as hr, getStoredCapabilityHeaderCiphertext as hs, getStreamAcknowledgment as ht, getVariableSet as hu, getVariableSetByName as hv, getVariableSetValuesForRun as hw, getWorkspace as hx, getWorkspaceControlEvent as hy, getWorkspaceDefaultRigId as hz, type AdoptCodexResetRedemptionResult as i, lockWorkspaceInferenceControl as i$, latestWorkspaceCapture as i0, listApiKeys as i1, listCapabilityCatalogItems as i2, listCapabilityInstallations as i3, listCodexAccountStatuses as i4, listCodexResetRedemptionRecoveries as i5, listConnectionsMetadata as i6, listCreditBalancesByAccount as i7, listDistinctRigVersionIdsInGroup as i8, listDistinctVariableSetIdsInGroup as i9, listSessionEventPage as iA, listSessionEvents as iB, listSessionHumanInputRequests as iC, listSessionIdsInGroup as iD, listSessionMcpServerMetadata as iE, listSessionMcpServersForChildInheritance as iF, listSessionMcpServersForRun as iG, listSessionSpawnDenials as iH, listSessionSystemUpdatesForTurn as iI, listSessionTurns as iJ, listSessions as iK, listSessionsForSubject as iL, listSocialConnections as iM, listSocialPosts as iN, listUsageEvents as iO, listVariableSets as iP, listWorkspaceControlEvents as iQ, listWorkspaceEnvironments as iR, listWorkspaceMembers as iS, listWorkspacePacks as iT, listWorkspacesForSubject as iU, loadCodexCredentialForRun as iV, loadConnectionCredentialForBroker as iW, loadIntegrationOAuthClient as iX, loadVariableSetForRun as iY, loadWorkspaceEnvironmentForRun as iZ, lockSessionEventWriteRows as i_, listEnabledMcpCapabilityServers as ia, listEnrollments as ib, listGitHubInstallationAccessForWorkspace as ic, listGitHubInstallationIdsForWorkspace as id, listGitHubInstallationsForWorkspace as ie, listKnowledgeMemories as ig, listLiveModalSandboxLeaseAttributions as ih, listMeterableWarmLeases as ii, listOpenPtySessions as ij, listOutstandingSessionSystemUpdates as ik, listPackInstallations as il, listPendingCodexCapacityWakeTargets as im, listPendingSessionTurns as io, listRecordings as ip, listRegistryCatalogSurfaceKeys as iq, listRigChangeMonitoringSummaries as ir, listRigChanges as is, listRigVersionMonitoringSummaries as it, listRigVersions as iu, listRigs as iv, listSandboxes as iw, listScheduledTaskRuns as ix, listScheduledTasks as iy, listSessionDiscoverySummaries as iz, AgentCommandAuthorityError as j, registerPendingSessionToolCall as j$, markFileUploadFailed as j0, markSandboxFileResourcesMaterialized as j1, markSandboxProviderReady as j2, markSandboxRestoreVerifying as j3, markScheduledTaskRunFailedIfQueued as j4, markSessionAttemptQuiesced as j5, markSessionSystemUpdateOutboxDeliveredInTransaction as j6, markSessionSystemUpdateOutboxFailed as j7, markSessionWorkflowWakeDelivered as j8, markSessionWorkflowWakeFailed as j9, readMachineMetricsSeries as jA, readWorkspaceArchiveCapturePreflight as jB, reapExpiredSessionListSnapshots as jC, reapStaleLeaseHolders as jD, reapStaleLeaseHoldersGlobal as jE, reconcileCodexCapacityWait as jF, recordAuditEvent as jG, recordCodexAccountConnectors as jH, recordCodexAccountUsage as jI, recordCodexAccountUsageWithWakeTargets as jJ, recordCodexTokenRefresh as jK, recordConnectionTokenRefresh as jL, recordConnectionUsed as jM, recordLeaseDataPlaneUrl as jN, recordLeaseTerminalDataPlaneUrl as jO, recordPendingSessionToolCallResult as jP, recordSessionActiveCodexCredential as jQ, recordSkippedContextCompaction as jR, recordStreamAcknowledgment as jS, recordStripeWebhookEvent as jT, recordUsageEvent as jU, recordWarmingSandboxCreated as jV, recoverSessionDispatch as jW, refreshOAuthConnectionCredential as jX, registerDbBinding as jY, registerHostExportConsumer as jZ, registerInternalUpdateWakeInTransaction as j_, markStaleRegistryCatalogItems as ja, markStripeWebhookProcessed as jb, markWarmLeaseInstanceLost as jc, materializeGoalContinuation as jd, mcpServerIdForCapability as je, moveQueuedTurnInTransaction as jf, mutateSessionControlInTransaction as jg, mutateWorkspaceControlInTransaction as jh, nestedPostgresSqlState as ji, nextSessionHistoryPosition as jj, normalizeBearerScheme as jk, normalizeMemoryText as jl, orphanedResultRowIndicesForRepair as jm, peekSessionWork as jn, persistDrainSnapshot as jo, persistWarmSnapshot as jp, planWorkspaceCaptureGc as jq, projectEffectiveControlForRelatedAccess as jr, projectSessionForRelatedAccess as js, pruneHostExportOutbox as jt, quarantineCodexCredentialForLease as ju, reArmDrainingLease as jv, readActiveSandbox as jw, readLease as jx, readMachineMetricsLatest as jy, readMachineMetricsLatestForWorkspace as jz, type AgentInternalUpdateCommandResult as k, setSessionGoalStatusWithEvent as k$, registerSessionTurnAttemptClaim as k0, registerSessionWorkflowWakeInTransaction as k1, registerWorkspacePack as k2, releaseCodexCredentialLease as k3, releaseCodexResetRedemptionClaim as k4, releaseLeaseHolder as k5, removeWorkspaceMember as k6, renameCodexAccount as k7, renderWorkspaceMemoryBlock as k8, replaceIntegrationOAuthClient as k9, sanitizeModelPayload as kA, saveComposerDraftInTransaction as kB, saveNewSessionDraftInTransaction as kC, saveRunState as kD, saveWorkspaceMemory as kE, searchWorkspaceMemories as kF, sendAgentMessageInTransaction as kG, serializeEffectiveSessionControl as kH, sessionAuthorizationScopeFilter as kI, sessionSubject as kJ, sessionTreeStatsForSessions as kK, sessionsWithActiveOpOnEnrollment as kL, setActiveCodexCredential as kM, setActiveSandbox as kN, setCodexCredentialExhausted as kO, setCodexCredentialExhaustedWithWakeTargets as kP, setCodexCredentialStatus as kQ, setCodexCredentialStatusById as kR, setConnectionStatus as kS, setEnrollmentDisplayState as kT, setEnrollmentOpStreamState as kU, setEnrollmentWentOffline as kV, setInitialActiveCodexCredential as kW, setRlsContext as kX, setSessionCodexPin as kY, setSessionGoalLastContinuationTurn as kZ, setSessionGoalStatus as k_, requestSessionCompaction as ka, requestSessionTurnRecovery as kb, requireFile as kc, requireScheduledTask as kd, requireSession as ke, requireSocialConnection as kf, requireWorkspace as kg, reserveSessionCommandReceipt as kh, reserveToolspaceCallForAttempt as ki, resolveWorkspaceMemoryBlock as kj, resumeHostExportConsumer as kk, retainWorkspaceMutationProcess as kl, retireHostExportConsumer as km, revokeApiKey as kn, revokeConnection as ko, revokeEnrollment as kp, revokeViewer as kq, rewindHostExportConsumer as kr, rlsContextForWorkspace as ks, rlsStrategyFor as kt, rotateWorkspaceArchives as ku, runIdempotentPersistenceTransaction as kv, safeDatabaseErrorFacts as kw, sanitizeEventPayload as kx, sanitizeEventString as ky, sanitizeMemoryText as kz, type AppendEventInput as l, withWorkspaceRls as l$, setSessionLastInputTokensForTurnAttempt as l0, setSessionPin as l1, setSubjectRlsContext as l2, setTemporalWorkflowId as l3, setVariableSetVariable as l4, setWorkspaceDefaultRig as l5, setWorkspaceEnvironmentVariable as l6, settleCodexCredentialFailover as l7, settleCodexCredentialLeaseLoss as l8, settleRetainedProcess as l9, updateSessionGoalWithEvent as lA, updateSessionMcpApprovalPolicy as lB, updateSessionMcpServerCredentials as lC, updateSessionTitle as lD, updateVariableSet as lE, updateWorkspace as lF, updateWorkspaceEnvironment as lG, updateWorkspaceSettings as lH, upsertBillingCustomer as lI, upsertCapabilityCatalogItem as lJ, upsertCodexSubscriptionCredential as lK, upsertGitHubInstallation as lL, upsertMachineMetricsLatest as lM, upsertRegistryCapabilityCatalogItem as lN, upsertSandboxSessionEnvelope as lO, upsertSessionGoal as lP, upsertSessionGoalWithEvent as lQ, upsertWorkspaceModelPolicy as lR, validateHumanInputResponse as lS, verifyDirectWorkspaceMutationSettlement as lT, verifyRetainedProcessMutationSettlement as lU, verifyWorkspaceMutationSettlement as lV, withAccountRls as lW, withCodexCapacityMutation as lX, withCodexCredentialRefreshLock as lY, withCodexTokenDeadline as lZ, withRlsContext as l_, settleScheduledTaskRunInTransaction as la, settleSessionAttemptInterruptions as lb, settleSessionIdleWithParentOutbox as lc, shortMemoryId as ld, steerAgentSessionInTransaction as le, steerQueuedTurnInTransaction as lf, storeIntegrationOAuthClient as lg, submitHumanPromptInTransaction as lh, sumUsageQuantity as li, supersedeSessionCurrentDirectionInTransaction as lj, touchEnrollmentLastSeen as lk, touchLeaseHolder as ll, updateCodexAllocatorEligibility as lm, updateCodexRotationSettings as ln, updateConnection as lo, updateImportBatchCounts as lp, updateKnowledgeMemory as lq, updatePackInstallationStatus as lr, updatePtySessionActivity as ls, updateRecording as lt, updateRig as lu, updateRigChangeStatus as lv, updateScheduledTask as lw, updateScheduledTaskRun as lx, updateSessionCommandReceiptResult as ly, updateSessionGoal as lz, type ApplyContextCompactionResult as m, withWorkspaceSubjectRls as m0, withWorkspaceUsageLock as m1, workspaceCaptureAtRevision as m2, workspaceCodexSubscriptionActive as m3, type ApplySessionTurnSettlementInput as n, type ApplySessionTurnSettlementResult as o, type ArmCodexCapacityWaitResult as p, provisionRoles, type BootstrapWorkspaceInput as q, CODEX_CAPACITY_REFRESH_MIN_MS as r, CODEX_CREDENTIAL_LEASE_TTL_MS as s, CODEX_RESET_REDEMPTION_OUTCOMES as t, CODEX_ROTATION_STRATEGIES as u, type ClaimCodexResetRedemptionResult as v, type ClaimSessionWorkForAttemptInput as w, type ClaimSessionWorkForAttemptResult as x, type ClearSessionContextResult as y, type CodexAccountStatus as z };
+export { type CodexRateLimitResetCreditsAccountResult as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BeginSandboxRematerializationResult as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type ClearSessionContextResult as D, type CodexAccountStatus as E, type CodexAccountUsageSnapshot as F, type CodexAllocatorUpdateResult as G, type CodexAuthDeps as H, type CodexCapacityAvailabilityDecision as I, type CodexCapacityMutationResult as J, type CodexCapacityResetKind as K, type CodexCapacitySelectionContext as L, type CodexCapacityWait as M, type CodexCapacityWaitStatus as N, type CodexCapacityWakeTarget as O, type CodexCredentialForRun as P, type ProvisionResult, type ProvisionRolesOptions, type CodexCredentialLeaseCandidateFilter as Q, type CodexCredentialLeaseCandidateFilterResult as R, type CodexCredentialLeasePolicyScopeResolver as S, type CodexCredentialLeaseQuarantine as T, type CodexCredentialLeaseResult as U, type CodexCredentialLeaseSelection as V, type CodexCredentialLeaseSelectionContext as W, type CodexCredentialStatus as X, type CodexCredentialTokens as Y, type CodexLeaseAccountStatus as Z, type CodexPinSource as _, type AcceptSessionApprovalDecisionResult as a, type HostMcpCredentialResolverContext as a$, type CodexResetRedemptionAttempt as a0, type CodexResetRedemptionOutcome as a1, type CodexResetRedemptionRecovery as a2, type CodexResetRedemptionSendNotReadyReason as a3, type CodexResetRedemptionStatus as a4, type CodexRotationSettings as a5, type CodexRotationStrategy as a6, type CodexTokenDeadlineClock as a7, type CodexTokenDeadlineOptions as a8, type CompleteSlackBotPostOperationResult as a9, type EditQueueCommandResult as aA, type EffectiveControlBlocker as aB, type EffectiveControlResumeOption as aC, type EffectiveControlState as aD, type EffectiveSessionControl as aE, type EnableCapabilityInstallationInput as aF, type EnabledMcpCapabilityServer as aG, type EnqueueSessionTurnInput as aH, type EnrollmentExposure as aI, type EnrollmentOs as aJ, type EnrollmentRecord as aK, type EnrollmentStatus as aL, type ExpiredDrainingSandboxLeaseCount as aM, type ExpiredFileUploadCleanupClaim as aN, FORCE_RLS_TABLES as aO, type FenceCodexResetRedemptionSendResult as aP, type FileUploadCleanupClaimResult as aQ, type ForceDrainResult as aR, type FrozenTurnInitiator as aS, type GitHubInstallation as aT, type GitHubInstallationAccess as aU, GitHubInstallationAuthorityCommitError as aV, type GoalContinuationDecision as aW, type HostExportConsumerStatus as aX, type HostExportKind as aY, HostExportPayloadError as aZ, HostMcpCredentialBindingError as a_, type ComposerDraftRow as aa, type ConnectionBrokerDeps as ab, type ConnectionCredentialForBroker as ac, type ConnectionMetadataWithVerification as ad, ConnectionRefreshHttpError as ae, type ConsumeOAuthStateNonceInput as af, type CorrectWorkspaceMemoryInput as ag, type CorrectWorkspaceMemoryResult as ah, type CreateCapabilityCatalogItemInput as ai, type CreateConnectionInput as aj, type CreateDbOptions as ak, type CreateImportBatchInput as al, type CreateKnowledgeMemoryInput as am, type CreatePackInstallationInput as an, type CreateScheduledTaskInput as ao, type CreateSessionGoalInput as ap, type CreateSessionMcpServerInput as aq, type CreateSocialConnectionInput as ar, type CreateSocialPostInput as as, type CreditBalanceByAccount as at, type Database as au, type DatabaseFailureCode as av, type DbClient as aw, type DbSession as ax, type DeviceEnrollmentRequestRecord as ay, type DeviceEnrollmentStatus as az, type AcceptSessionHumanInputResponseResult as b, type ReconcileColdLostLeaseInstanceBlockersResult as b$, HostMcpCredentialScopeError as b0, HumanInputResponseValidationError as b1, type IdempotentPersistenceTransactionOptions as b2, type ImportBatch as b3, type InitializeSessionStartInput as b4, type InitializeSessionStartResult as b5, type InstallOrReadTurnExecutionPolicyForAttemptResult as b6, type IntegrationOAuthClientForUse as b7, type LeaseHolderKind as b8, type LeaseSnapshot as b9, type MarkWarmLeaseInstanceLostResult as bA, type MaterializeGoalContinuationResult as bB, type MemoryBlockRecord as bC, type MemoryEmbedder as bD, type MemorySanitizeResult as bE, type MeterableWarmLease as bF, NON_RLS_RUNTIME_TABLES as bG, type NestedAgentDepthDeploymentPolicy as bH, type NestedAgentDepthPolicySource as bI, NewSessionDraftAccessError as bJ, NewSessionDraftConflictError as bK, type NewSessionDraftRow as bL, PROTECTED_NO_DIRECT_DML_TABLES as bM, type PendingSessionToolCallInput as bN, type PersistenceFailureDetails as bO, type PersistenceRetryOutcome as bP, type QueueCommandConflictCode as bQ, QueueCommandConflictError as bR, type QueueCommandResult as bS, type QueuedTurnRow as bT, RUNTIME_DML_TABLES as bU, RUNTIME_FULL_DML_TABLES as bV, RUNTIME_READ_INSERT_TABLES as bW, RUNTIME_READ_ONLY_TABLES as bX, RUNTIME_TABLE_PRIVILEGES as bY, type ReapDrainable as bZ, type ReconcileCodexCapacityWaitResult as b_, type ListKnowledgeMemoryOptions as ba, type ListSessionEventPageOptions as bb, type ListSessionEventsOptions as bc, type ListSessionsForSubjectOptions as bd, type ListSessionsOptions as be, type LiveModalSandboxLeaseAttribution as bf, type LostProviderWorkspaceSettlement as bg, MACHINE_METRICS_SERIES_INTERVAL_MS as bh, MAX_INTERNAL_UPDATE_BATCH_BYTES as bi, MAX_INTERNAL_UPDATE_BATCH_MEMBERS as bj, MAX_INTERNAL_UPDATE_BYTES as bk, MEMORY_ACTIVE_RECORD_CAP as bl, MEMORY_BLOCK_KIND_ORDER as bm, MEMORY_BLOCK_RECORD_LIMIT as bn, MEMORY_CORRECT_TOOL_DESCRIPTION as bo, MEMORY_KIND_SECTION_TITLES as bp, MEMORY_NEAR_DUP_COSINE_THRESHOLD as bq, MEMORY_NEAR_DUP_NEIGHBORS as br, MEMORY_SAVE_TOOL_DESCRIPTION as bs, MEMORY_SEARCH_DEFAULT_LIMIT as bt, MEMORY_SEARCH_MAX_LIMIT as bu, MEMORY_SEARCH_TOOL_DESCRIPTION as bv, MEMORY_TEXT_MAX_CHARS as bw, MEMORY_VISIBLE_RECORD_CAP as bx, type MachineMetricsRow as by, type MachineMetricsSample as bz, type AccrueWarmSecondsResult as c, SanitizedDatabasePersistenceCause as c$, type RecoverSessionDispatchInput as c0, type RecoverSessionDispatchResult as c1, type RefreshTransportOptions as c2, type RegisterWorkspacePackInput as c3, type RegistryCapabilityCatalogItemInput as c4, type RegistryCatalogSurfaceKey as c5, type ReplaceIntegrationOAuthClientInput as c6, type RequestSessionTurnRecoveryInput as c7, type RequestSessionTurnRecoveryResult as c8, type ResolveConnectionCredentialInput as c9, SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT as cA, SESSION_LIST_SNAPSHOT_MAX_IDS as cB, type SafeDatabaseErrorFacts as cC, type SandboxArchiveAvailability as cD, type SandboxArchiveRevision as cE, SandboxImageConflictError as cF, type SandboxKind as cG, type SandboxLeaseLiveness as cH, SandboxLeaseRecoveryBlockedError as cI, SandboxLeaseSupersededError as cJ, type SandboxOpenPtySessionRow as cK, type SandboxProviderExistence as cL, type SandboxPtyProcessIdentity as cM, type SandboxPtySessionRow as cN, type SandboxRecord as cO, type SandboxRecoveryState as cP, type SandboxRestoreStatus as cQ, type SandboxRetainedProcess as cR, type SandboxRetainedProcessIdentity as cS, SandboxRetainedProcessPromotionFencedError as cT, type SandboxRetainedProcessReconciliationClaim as cU, type SandboxRetainedProcessState as cV, SandboxRigConflictError as cW, type SandboxWorkspaceMutationAdmission as cX, SandboxWorkspaceMutationFencedError as cY, type SandboxWorkspaceMutationProviderOutcome as cZ, type SandboxWorkspaceReadiness as c_, type ResolveConnectionCredentialResult as ca, type RetainedFileArtifact as cb, type RetainedProcessProviderProof as cc, RigActiveVersionChangedError as cd, RigChangeAlreadyVerifyingError as ce, type RigChangeMonitoringSummary as cf, RigChangeTransitionError as cg, type RigVersionContentInput as ch, type RigVersionMonitoringSummary as ci, type RlsContext as cj, type RlsStrategy as ck, type RuntimeDatabaseIdentity as cl, type RuntimeDatabasePosture as cm, RuntimeDatabasePostureError as cn, type RuntimeDatabasePostureOptions as co, type RuntimeRoutinePosture as cp, type RuntimeSchemaPosture as cq, type RuntimeTableDmlPrivilege as cr, type RuntimeTablePosture as cs, type RuntimeTablePrivilegeContract as ct, SESSION_ANCESTRY_LIMIT as cu, SESSION_DISCOVERY_CONTROL_TARGET_LIMIT as cv, SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS as cw, SESSION_DISCOVERY_GOAL_MAX_CHARS as cx, SESSION_DISCOVERY_MESSAGE_MAX_CHARS as cy, SESSION_EVENT_DB_PAGE_MAX_BYTES as cz, type AcquireLeaseInput as d, type ToolspaceTurnAttemptClaims as d$, type SaveWorkspaceMemoryInput as d0, type SaveWorkspaceMemoryResult as d1, type SessionAttemptInterruptionSettlement as d2, type SessionCodexState as d3, type SessionCommandActor as d4, SessionCommandIdempotencyError as d5, type SessionCommandReceiptRow as d6, SessionContextBusyError as d7, SessionControlConflictError as d8, SessionControlInvariantError as d9, type SessionRecordingCodec as dA, type SessionRecordingMode as dB, type SessionRecordingRow as dC, type SessionRecordingState as dD, type SessionSpawnDenial as dE, type SessionSpawnDenialCode as dF, SessionSpawnDeniedDbError as dG, type SessionSystemUpdateOutboxDelivery as dH, SessionToolPolicyVersionConflictError as dI, type SessionTurnAttemptOutcome as dJ, type SessionTurnForExecution as dK, type SessionTurnRecordingSettlement as dL, type SessionWorkPeek as dM, type SessionWorkTrigger as dN, type SessionWorkflowWake as dO, type SessionWorkflowWakeDeliveryResult as dP, type SetSessionCodexPinOptions as dQ, type SetSessionGoalStatusEvent as dR, type SettleCodexCredentialFailoverResult as dS, type SettleCodexCredentialLeaseLossResult as dT, type SlackBotPostOperation as dU, type SteerQueueCommandResult as dV, type StoreIntegrationOAuthClientInput as dW, type StoredIntegrationOAuthClient as dX, type StreamAcknowledgment as dY, type SubmitHumanPromptResult as dZ, type ToolspaceCallReservation as d_, type SessionControlMutationResult as da, type SessionCreateDeniedResult as db, type SessionCreateInput as dc, type SessionCreateResult as dd, type SessionCreateSuccessResult as de, type SessionDepthPolicy as df, type SessionDiscoveryControl as dg, type SessionDiscoveryCursor as dh, type SessionDiscoveryOrderBy as di, type SessionDiscoverySummary as dj, type SessionEventPage as dk, SessionEventPersistenceError as dl, type SessionEventWriteLockInput as dm, type SessionEventWriteLocks as dn, type SessionGoalContinuationProjection as dp, SessionIdConflictError as dq, type SessionLineage as dr, SessionListAccessError as ds, type SessionListCursor as dt, SessionListCursorError as du, SessionListCursorExpiredError as dv, SessionListSnapshotLimitError as dw, type SessionMcpServerForRun as dx, SessionPinAccessError as dy, SessionPinVersionConflictError as dz, type AcquireLeaseResult as e, assertAgentCommandAuthorityInTransaction as e$, type TurnAttemptFenceRejectReason as e0, type UpdateConnectionInput as e1, type UpdateImportBatchCountsInput as e2, type UpdateKnowledgeMemoryInput as e3, type UpdateScheduledTaskInput as e4, type UpdateSessionMcpApprovalPolicyResult as e5, type UpdateSessionMcpServerCredentialsInput as e6, type UpdateSessionMcpServerCredentialsResult as e7, type UpsertCodexSubscriptionCredentialResult as e8, type UserLookup as e9, acknowledgeHostExportBatch as eA, acquireCodexCredentialLease as eB, acquireLease as eC, activateRigVersion as eD, activateWorkspaceInstructionPolicyRevision as eE, addSessionSystemUpdate as eF, addSessionSystemUpdateWithSourceMutation as eG, admitToolspaceTurnAttempt as eH, adoptCodexResetRedemptionAttempt as eI, advanceWorkspaceGeneration as eJ, advanceWorkspaceGenerationForDirectRequest as eK, advanceWorkspaceGenerationForRetainedProcess as eL, allAccountPermissions as eM, allWorkspacePermissions as eN, appendSessionEventToSandboxGroup as eO, appendSessionEvents as eP, appendSessionEventsAndUpdateSession as eQ, appendSessionEventsForTurnAttempt as eR, appendSessionEventsWithLockedSessionUpdate as eS, appendSessionHistoryItems as eT, applyContextCompaction as eU, applyCreditDebitUpToBalance as eV, applyCreditLedgerEntry as eW, applySessionTurnSettlement as eX, approveDeviceEnrollmentRequest as eY, areGitHubRepositoriesAllowedForWorkspace as eZ, armCodexCapacityWait as e_, type VariableSetForRun as ea, WORKSPACE_MEMORY_BLOCK_EMPTY as eb, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as ec, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as ed, type WorkspaceCaptureCommitResult as ee, type WorkspaceCaptureGcPlan as ef, type WorkspaceCaptureGcRow as eg, type WorkspaceCaptureRow as eh, type WorkspaceControlLockMode as ei, type WorkspaceControlMutationResult as ej, type WorkspaceControlRow as ek, type WorkspaceEnvironmentForRun as el, WorkspaceInstructionPolicyConflictError as em, WorkspaceInstructionPolicyInvalidOperationError as en, WorkspaceInstructionPolicyLegacyUnavailableError as eo, WorkspaceInstructionPolicyNotFoundError as ep, type WorkspaceMemoryOrigin as eq, type WorkspaceMemorySearchInput as er, type WorkspaceMemorySearchMode as es, type WorkspaceMemorySearchResult as et, type WorkspaceModelPolicy as eu, abandonCodexResetRedemptionBeforeProvider as ev, abandonRecordingForTurnAttempt as ew, acceptSessionApprovalDecision as ex, acceptSessionHumanInputResponse as ey, accrueWarmSeconds as ez, type ActiveRetainedProcessOwnerCount as f, createDb as f$, assertRuntimeDatabasePosture as f0, autoResumeSessionBranchInTransaction as f1, beginRigChangeVerificationAttempt as f2, beginSandboxRematerialization as f3, bindAuthorizedGitHubInstallationRepositories as f4, bindGitHubInstallationRepositories as f5, bootstrapWorkspace as f6, buildChildCompletionDigest as f7, buildCodexTokenResolver as f8, buildConnectionTokenResolver as f9, computeWorkspaceCaptureGcPlan as fA, confirmDrainCold as fB, consumeDeviceEnrollmentRequest as fC, consumeIntegrationOAuthStateNonce as fD, consumeNewSessionDraftInTransaction as fE, correctWorkspaceMemory as fF, countActiveApiKeysForWorkspace as fG, countActiveRetainedProcessesByOwnerState as fH, countActiveSessionHistoryItems as fI, countActiveSessionsForWorkspace as fJ, countActiveSessionsUsingEnvironment as fK, countActiveSessionsUsingVariableSet as fL, countConsecutiveReactiveRotations as fM, countExpiredDrainingSandboxLeases as fN, countQueuedTurns as fO, countRigs as fP, countSandboxLeasesByLiveness as fQ, countScheduledTasksForWorkspace as fR, countScheduledTasksUsingEnvironment as fS, countScheduledTasksUsingVariableSet as fT, countSessionHistoryItems as fU, countSessionsUsingRig as fV, countVariableSets as fW, countWorkspaceEnvironments as fX, countWorkspacesForAccount as fY, createApiKey as fZ, createConnection as f_, buildHostConnectionTokenResolver as fa, canonicalSessionCommandHash as fb, claimCodexResetRedemption as fc, claimExpiredFileUploadCleanup as fd, claimFileUploadCleanup as fe, claimHostExportBatch as ff, claimPendingSessionSystemUpdateOutbox as fg, claimPendingSessionWorkflowWakes as fh, claimSessionWorkForAttempt as fi, claimSlackBotPostOperation as fj, claimTerminalRetainedProcesses as fk, clearDurablePendingSessionToolCalls as fl, clearEnrollmentWentOffline as fm, clearPendingSessionToolspaceCall as fn, clearSessionContext as fo, clearSessionGoal as fp, clearedContextMarkerItem as fq, closePtySession as fr, closeSessionTurnAttemptInTransaction as fs, codexCapacityRefreshBackoffMs as ft, commitWarmingToWarm as fu, completeCodexResetRedemption as fv, completeExpiredFileUploadCleanup as fw, completeFileUpload as fx, completeFileUploadCleanup as fy, completeSlackBotPostOperation as fz, type ActiveSandboxPointer as g, evaluateSessionControl as g$, createDeviceEnrollmentRequest as g0, createEnrollment as g1, createFileUpload as g2, createImportBatch as g3, createKnowledgeMemory as g4, createRig as g5, createRigChange as g6, createRigVersion as g7, createRigVersionForChangePromotion as g8, createSandbox as g9, deleteVariableSetVariable as gA, deleteWorkspace as gB, deleteWorkspaceCaptureRows as gC, deleteWorkspaceEnvironment as gD, deleteWorkspaceEnvironmentVariable as gE, deleteWorkspacePack as gF, denyDeviceEnrollmentRequest as gG, diffWorkspaceInstructionPolicyContent as gH, diffWorkspaceInstructionPolicyRevisions as gI, disableCapabilityInstallation as gJ, disableHostExportConsumer as gK, disconnectAllCodexAccounts as gL, disconnectCodexAccount as gM, editQueuedTurnInTransaction as gN, enableCapabilityInstallation as gO, enablePackInstallation as gP, encodeSessionListCursor as gQ, encryptEnvironmentValue as gR, enqueueSessionTurn as gS, enqueueSessionWorkflowWake as gT, enqueueSessionWorkflowWakeIfRunnable as gU, enqueueSessionWorkflowWakeInTransaction as gV, ensureCodexRotationSettings as gW, ensureManagedAccessForUser as gX, estimateMemoryTokens as gY, evaluateGoalContinuation as gZ, evaluateRuntimeDatabasePosture as g_, createScheduledTask as ga, createScheduledTaskRun as gb, createSession as gc, createSessionGoal as gd, createSessionMcpServers as ge, createSessionWithIdempotencyKey as gf, createSessionWithIdempotencyKeyResult as gg, createSocialConnection as gh, createSocialPost as gi, createVariableSet as gj, createWorkspace as gk, createWorkspaceEnvironment as gl, createWorkspaceInstructionPolicyDraft as gm, databaseFailureCode as gn, deadLetterHostExportHead as go, decodeSessionListCursor as gp, decryptEnvironmentValue as gq, decryptedCapabilityHeaders as gr, deferRetainedProcessReconciliation as gs, deleteGitHubInstallationBinding as gt, deleteRecording as gu, deleteRig as gv, deleteRigIfNoActiveSessions as gw, deleteScheduledTask as gx, deleteSessionQueueItemInTransaction as gy, deleteVariableSet as gz, type AddSessionSystemUpdateInput as h, getSessionGoal as h$, evaluateSessionControls as h0, evaluateSessionDiscoveryControls as h1, expireSessionHumanInputRequest as h2, failHostExportBatch as h3, failSandboxRematerialization as h4, failWarmingToCold as h5, fenceCodexResetRedemptionSend as h6, fetchCodexRateLimitResetCreditsForAccount as h7, fetchCodexUsageForAccount as h8, finalizeEnrollmentByToken as h9, getManagedUserByEmail as hA, getMaterializedSandboxFileResources as hB, getNestedAgentDepthDeploymentPolicy as hC, getNewSessionDraftInTransaction as hD, getOpenPtySession as hE, getOrCreateSessionSystemUpdateOutbox as hF, getPackInstallation as hG, getPendingDeviceEnrollmentRequestByUserCode as hH, getPendingDeviceEnrollmentRequestByUserCodeGlobal as hI, getRecording as hJ, getRetainedFileArtifact as hK, getRetainedProcess as hL, getRig as hM, getRigByName as hN, getRigChange as hO, getRigName as hP, getRigVersion as hQ, getRigVersionById as hR, getSandbox as hS, getSandboxSessionEnvelope as hT, getScheduledTask as hU, getSession as hV, getSessionByCreateIdempotencyKey as hW, getSessionCodexState as hX, getSessionEvent as hY, getSessionEventByClientEventId as hZ, getSessionForSubject as h_, findActiveApiKeyByHash as ha, forceDrainOverLimitViewerOnlyBoxes as hb, frozenInitiatorForCommandActor as hc, getActiveSessionHistoryItems as hd, getActiveSessionTurnForExecution as he, getAnySessionInGroup as hf, getBillingBalance as hg, getBillingCustomer as hh, getCapabilityCatalogItem as hi, getCapabilityInstallation as hj, getCodexCapacityWaitForSession as hk, getCodexCredentialStatus as hl, getCodexResetRedemptionAttempt as hm, getCodexRotationSettings as hn, getComposerDraftInTransaction as ho, getConnectionMetadata as hp, getDeviceEnrollmentRequestByDeviceCode as hq, getEnrollment as hr, getFile as hs, getFileUpload as ht, getHostExportConsumerStatus as hu, getHumanInputResumeForEvent as hv, getKnowledgeMemory as hw, getLatestRunState as hx, getLatestStartedSessionTurn as hy, getManagedAccount as hz, type AddSessionSystemUpdateResult as i, listDistinctRigVersionIdsInGroup as i$, getSessionGoalWithContinuation as i0, getSessionHistoryItems as i1, getSessionHumanInputRequest as i2, getSessionLineage as i3, getSessionQueueSnapshot as i4, getSessionRootId as i5, getSessionSpawnDenial as i6, getSessionSpawnDenialByIdempotencyKey as i7, getSessionSystemUpdateOutboxByDedupeKey as i8, getSessionTurn as i9, heartbeatLeaseHolder as iA, importLegacyWorkspaceInstructionPolicyDraft as iB, ingestMachineMetricsSample as iC, initializeSessionStartAtomically as iD, insertFailedWorkspaceCapture as iE, insertMachineMetricsSeries as iF, insertPtySession as iG, insertRecording as iH, insertWorkspaceCapture as iI, inspectRuntimeDatabasePosture as iJ, installOrReadTurnExecutionPolicyForAttempt as iK, interruptedToolCallResult as iL, isCodexBilledTurn as iM, isDatabasePersistenceFailure as iN, isMemoryTextTooLong as iO, isRetryablePersistenceSqlState as iP, isSessionCompactionRequested as iQ, isSessionEventPersistenceError as iR, isStripeWebhookProcessed as iS, latestWorkspaceCapture as iT, listApiKeys as iU, listCapabilityCatalogItems as iV, listCapabilityInstallations as iW, listCodexAccountStatuses as iX, listCodexResetRedemptionRecoveries as iY, listConnectionsMetadata as iZ, listCreditBalancesByAccount as i_, getSessionTurnForAttempt as ia, getSlackBotPostOperation as ib, getSocialConnection as ic, getStoredCapabilityHeaderCiphertext as id, getStreamAcknowledgment as ie, getVariableSet as ig, getVariableSetByName as ih, getVariableSetValuesForRun as ii, getWorkspace as ij, getWorkspaceControlEvent as ik, getWorkspaceDefaultRigId as il, getWorkspaceEnvironment as im, getWorkspaceEnvironmentByName as io, getWorkspaceEnvironmentValuesForRun as ip, getWorkspaceGrant as iq, getWorkspaceInstructionPolicyRevision as ir, getWorkspaceModelPolicy as is, getWorkspacePack as it, grantWorkspaceAccess as iu, hasAuditableGitHubInstallationAuthority as iv, hasCreditLedgerEntry as iw, hashMemoryText as ix, heartbeatCodexCredentialLease as iy, heartbeatCodexCredentialLeaseUntil as iz, type AdoptCodexResetRedemptionResult as j, markSessionWorkflowWakeFailed as j$, listDistinctVariableSetIdsInGroup as j0, listEnabledMcpCapabilityServers as j1, listEnrollments as j2, listGitHubInstallationAccessForWorkspace as j3, listGitHubInstallationIdsForWorkspace as j4, listGitHubInstallationsForWorkspace as j5, listKnowledgeMemories as j6, listLiveModalSandboxLeaseAttributions as j7, listMeterableWarmLeases as j8, listOpenPtySessions as j9, listSessionsForSubject as jA, listSocialConnections as jB, listSocialPosts as jC, listUsageEvents as jD, listVariableSets as jE, listWorkspaceControlEvents as jF, listWorkspaceEnvironments as jG, listWorkspaceInstructionPolicyRevisions as jH, listWorkspaceMembers as jI, listWorkspacePacks as jJ, listWorkspacesForSubject as jK, loadCodexCredentialForRun as jL, loadConnectionCredentialForBroker as jM, loadIntegrationOAuthClient as jN, loadVariableSetForRun as jO, loadWorkspaceEnvironmentForRun as jP, lockSessionEventWriteRows as jQ, lockWorkspaceInferenceControl as jR, markFileUploadFailed as jS, markSandboxFileResourcesMaterialized as jT, markSandboxProviderReady as jU, markSandboxRestoreVerifying as jV, markScheduledTaskRunFailedIfQueued as jW, markSessionAttemptQuiesced as jX, markSessionSystemUpdateOutboxDeliveredInTransaction as jY, markSessionSystemUpdateOutboxFailed as jZ, markSessionWorkflowWakeDelivered as j_, listOutstandingSessionSystemUpdates as ja, listPackInstallations as jb, listPendingCodexCapacityWakeTargets as jc, listPendingSessionTurns as jd, listRecordings as je, listRegistryCatalogSurfaceKeys as jf, listRigChangeMonitoringSummaries as jg, listRigChanges as jh, listRigVersionMonitoringSummaries as ji, listRigVersions as jj, listRigs as jk, listSandboxes as jl, listScheduledTaskRuns as jm, listScheduledTasks as jn, listSessionDiscoverySummaries as jo, listSessionEventPage as jp, listSessionEvents as jq, listSessionHumanInputRequests as jr, listSessionIdsInGroup as js, listSessionMcpServerMetadata as jt, listSessionMcpServersForChildInheritance as ju, listSessionMcpServersForRun as jv, listSessionSpawnDenials as jw, listSessionSystemUpdatesForTurn as jx, listSessionTurns as jy, listSessions as jz, AgentCommandAuthorityError as k, releaseLeaseHolder as k$, markStaleRegistryCatalogItems as k0, markStripeWebhookProcessed as k1, markWarmLeaseInstanceLost as k2, materializeGoalContinuation as k3, mcpServerIdForCapability as k4, moveQueuedTurnInTransaction as k5, mutateSessionControlInTransaction as k6, mutateWorkspaceControlInTransaction as k7, nestedPostgresSqlState as k8, newSessionDraftToolsProvided as k9, recordCodexAccountConnectors as kA, recordCodexAccountUsage as kB, recordCodexAccountUsageWithWakeTargets as kC, recordCodexTokenRefresh as kD, recordConnectionTokenRefresh as kE, recordConnectionUsed as kF, recordLeaseDataPlaneUrl as kG, recordLeaseTerminalDataPlaneUrl as kH, recordPendingSessionToolCallResult as kI, recordRetainedProcessReconciliationProof as kJ, recordSessionActiveCodexCredential as kK, recordSkippedContextCompaction as kL, recordStreamAcknowledgment as kM, recordStripeWebhookEvent as kN, recordUsageEvent as kO, recordWarmingSandboxCreated as kP, recoverSessionDispatch as kQ, refreshOAuthConnectionCredential as kR, registerDbBinding as kS, registerHostExportConsumer as kT, registerInternalUpdateWakeInTransaction as kU, registerPendingSessionToolCall as kV, registerSessionTurnAttemptClaim as kW, registerSessionWorkflowWakeInTransaction as kX, registerWorkspacePack as kY, releaseCodexCredentialLease as kZ, releaseCodexResetRedemptionClaim as k_, nextSessionHistoryPosition as ka, normalizeBearerScheme as kb, normalizeMemoryText as kc, orphanedResultRowIndicesForRepair as kd, peekSessionWork as ke, persistDrainSnapshot as kf, persistWarmSnapshot as kg, planWorkspaceCaptureGc as kh, projectEffectiveControlForRelatedAccess as ki, projectSessionForRelatedAccess as kj, pruneHostExportOutbox as kk, publicNewSessionDraftOptions as kl, quarantineCodexCredentialForLease as km, reArmDrainingLease as kn, readActiveSandbox as ko, readLease as kp, readMachineMetricsLatest as kq, readMachineMetricsLatestForWorkspace as kr, readMachineMetricsSeries as ks, readWorkspaceArchiveCapturePreflight as kt, reapExpiredSessionListSnapshots as ku, reapStaleLeaseHolders as kv, reapStaleLeaseHoldersGlobal as kw, reconcileCodexCapacityWait as kx, reconcileColdLostLeaseInstanceBlockers as ky, recordAuditEvent as kz, type AgentInternalUpdateCommandResult as l, setSessionGoalStatusWithEvent as l$, releaseSlackBotPostOperationClaim as l0, removeWorkspaceMember as l1, renameCodexAccount as l2, renderWorkspaceMemoryBlock as l3, replaceIntegrationOAuthClient as l4, requestSessionCompaction as l5, requestSessionTurnRecovery as l6, requireFile as l7, requireScheduledTask as l8, requireSession as l9, saveComposerDraftInTransaction as lA, saveNewSessionDraftInTransaction as lB, saveRunState as lC, saveWorkspaceMemory as lD, searchWorkspaceMemories as lE, seedNewSessionDraftInTransaction as lF, sendAgentMessageInTransaction as lG, serializeEffectiveSessionControl as lH, sessionAuthorizationScopeFilter as lI, sessionSubject as lJ, sessionTreeStatsForSessions as lK, sessionsWithActiveOpOnEnrollment as lL, setActiveCodexCredential as lM, setActiveSandbox as lN, setCodexCredentialExhausted as lO, setCodexCredentialExhaustedWithWakeTargets as lP, setCodexCredentialStatus as lQ, setCodexCredentialStatusById as lR, setConnectionStatus as lS, setEnrollmentDisplayState as lT, setEnrollmentOpStreamState as lU, setEnrollmentWentOffline as lV, setInitialActiveCodexCredential as lW, setRlsContext as lX, setSessionCodexPin as lY, setSessionGoalLastContinuationTurn as lZ, setSessionGoalStatus as l_, requireSocialConnection as la, requireWorkspace as lb, reserveSessionCommandReceipt as lc, reserveToolspaceCallForAttempt as ld, resolveWorkspaceMemoryBlock as le, resumeHostExportConsumer as lf, retainWorkspaceMutationProcess as lg, retainedProcessReconciliationProof as lh, retainedProcessSettlementIdentity as li, retireHostExportConsumer as lj, revokeApiKey as lk, revokeConnection as ll, revokeEnrollment as lm, revokeViewer as ln, rewindHostExportConsumer as lo, rlsContextForWorkspace as lp, rlsStrategyFor as lq, rollbackWorkspaceInstructionPolicyRevision as lr, rotateWorkspaceArchives as ls, runIdempotentPersistenceTransaction as lt, runtimeDatabaseReadyCheck as lu, safeDatabaseErrorFacts as lv, sanitizeEventPayload as lw, sanitizeEventString as lx, sanitizeMemoryText as ly, sanitizeModelPayload as lz, type AppendEventInput as m, withWorkspaceRls as m$, setSessionLastInputTokensForTurnAttempt as m0, setSessionPin as m1, setSubjectRlsContext as m2, setTemporalWorkflowId as m3, setVariableSetVariable as m4, setWorkspaceDefaultRig as m5, setWorkspaceEnvironmentVariable as m6, settleCodexCredentialFailover as m7, settleCodexCredentialLeaseLoss as m8, settleRetainedProcess as m9, updateSessionGoalWithEvent as mA, updateSessionMcpApprovalPolicy as mB, updateSessionMcpServerCredentials as mC, updateSessionTitle as mD, updateVariableSet as mE, updateWorkspace as mF, updateWorkspaceEnvironment as mG, updateWorkspaceSettings as mH, upsertBillingCustomer as mI, upsertCapabilityCatalogItem as mJ, upsertCodexSubscriptionCredential as mK, upsertGitHubInstallation as mL, upsertMachineMetricsLatest as mM, upsertRegistryCapabilityCatalogItem as mN, upsertSandboxSessionEnvelope as mO, upsertSessionGoal as mP, upsertSessionGoalWithEvent as mQ, upsertWorkspaceModelPolicy as mR, validateHumanInputResponse as mS, verifyDirectWorkspaceMutationSettlement as mT, verifyRetainedProcessMutationSettlement as mU, verifyWorkspaceMutationSettlement as mV, withAccountRls as mW, withCodexCapacityMutation as mX, withCodexCredentialRefreshLock as mY, withCodexTokenDeadline as mZ, withRlsContext as m_, settleScheduledTaskRunInTransaction as ma, settleSessionAttemptInterruptions as mb, settleSessionIdleWithParentOutbox as mc, shortMemoryId as md, steerAgentSessionInTransaction as me, steerQueuedTurnInTransaction as mf, storeIntegrationOAuthClient as mg, submitHumanPromptInTransaction as mh, sumUsageQuantity as mi, supersedeSessionCurrentDirectionInTransaction as mj, touchEnrollmentLastSeen as mk, touchLeaseHolder as ml, updateCodexAllocatorEligibility as mm, updateCodexRotationSettings as mn, updateConnection as mo, updateImportBatchCounts as mp, updateKnowledgeMemory as mq, updatePackInstallationStatus as mr, updatePtySessionActivity as ms, updateRecording as mt, updateRig as mu, updateRigChangeStatus as mv, updateScheduledTask as mw, updateScheduledTaskRun as mx, updateSessionCommandReceiptResult as my, updateSessionGoal as mz, type ApplyContextCompactionResult as n, withWorkspaceSubjectRls as n0, withWorkspaceUsageLock as n1, workspaceCaptureAtRevision as n2, workspaceCodexSubscriptionActive as n3, type ApplySessionTurnSettlementInput as o, type ApplySessionTurnSettlementResult as p, provisionRoles, type ArmCodexCapacityWaitResult as q, type BootstrapWorkspaceInput as r, CODEX_CAPACITY_REFRESH_MIN_MS as s, CODEX_CREDENTIAL_LEASE_TTL_MS as t, CODEX_RESET_REDEMPTION_OUTCOMES as u, CODEX_ROTATION_STRATEGIES as v, type ClaimCodexResetRedemptionResult as w, type ClaimSessionWorkForAttemptInput as x, type ClaimSessionWorkForAttemptResult as y, type ClaimSlackBotPostOperationResult as z };