@opengeni/db 0.12.1 → 0.12.6

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, SecretForRedaction, 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, GitHubInstallationAuthorityKind, 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 { 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-CeXWlYcG.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,26 @@ 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;
 
 /** Provider-valid result for a started call whose durable outcome is unknown. */
 declare function interruptedToolCallResult(input: {
@@ -601,18 +611,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 +695,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", "social_connections", "social_posts", "usage_events", "workspace_captures", "workspace_control_events", "workspace_inference_controls", "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", "social_connections", "social_posts", "stripe_webhook_events", "usage_events", "workspace_captures", "workspace_control_events", "workspace_inference_controls", "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"];
+/** Spawn-denial evidence is append-only to the runtime, but remains queryable. */
+declare const RUNTIME_READ_INSERT_TABLES: readonly ["session_spawn_denials"];
+/**
+ * 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 +1045,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 +1389,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 +1436,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[]>;
@@ -2542,12 +2697,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 +2763,10 @@ type ReconcileCodexCapacityWaitResult = {
 } | {
     action: "resumed";
     waiter: CodexCapacityWait;
-    update: SessionSystemUpdate;
+    events: SessionEvent[];
+} | {
+    action: "paused";
+    waiter: CodexCapacityWait;
     events: SessionEvent[];
 } | {
     action: "superseded";
@@ -2627,14 +2786,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 +2801,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 +2818,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 +2835,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 +4408,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 +4429,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 +4444,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 +4579,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 +4627,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 +4816,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 +4863,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 +6282,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 CodexResetRedemptionAttempt as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BeginSandboxRematerializationResult as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type CodexAccountStatus as D, type CodexAccountUsageSnapshot as E, type CodexAllocatorUpdateResult as F, type CodexAuthDeps as G, type CodexCapacityAvailabilityDecision as H, type CodexCapacityMutationResult as I, type CodexCapacityResetKind as J, type CodexCapacitySelectionContext as K, type CodexCapacityWait as L, type CodexCapacityWaitStatus as M, type CodexCapacityWakeTarget as N, type CodexCredentialForRun as O, type CodexCredentialLeaseCandidateFilter as P, type ProvisionResult, type ProvisionRolesOptions, type CodexCredentialLeaseCandidateFilterResult as Q, type CodexCredentialLeasePolicyScopeResolver as R, type CodexCredentialLeaseQuarantine as S, type CodexCredentialLeaseResult as T, type CodexCredentialLeaseSelection as U, type CodexCredentialLeaseSelectionContext as V, type CodexCredentialStatus as W, type CodexCredentialTokens as X, type CodexLeaseAccountStatus as Y, type CodexPinSource as Z, type CodexRateLimitResetCreditsAccountResult as _, type AcceptSessionApprovalDecisionResult as a, type IdempotentPersistenceTransactionOptions as a$, type CodexResetRedemptionOutcome as a0, type CodexResetRedemptionRecovery as a1, type CodexResetRedemptionSendNotReadyReason as a2, type CodexResetRedemptionStatus as a3, type CodexRotationSettings as a4, type CodexRotationStrategy as a5, type CodexTokenDeadlineClock as a6, type CodexTokenDeadlineOptions as a7, type ComposerDraftRow as a8, type ConnectionBrokerDeps as a9, type EffectiveControlState as aA, type EffectiveSessionControl as aB, type EnableCapabilityInstallationInput as aC, type EnabledMcpCapabilityServer as aD, type EnqueueSessionTurnInput as aE, type EnrollmentExposure as aF, type EnrollmentOs as aG, type EnrollmentRecord as aH, type EnrollmentStatus as aI, type ExpiredDrainingSandboxLeaseCount as aJ, type ExpiredFileUploadCleanupClaim as aK, FORCE_RLS_TABLES as aL, type FenceCodexResetRedemptionSendResult as aM, type FileUploadCleanupClaimResult as aN, type ForceDrainResult as aO, type FrozenTurnInitiator as aP, type GitHubInstallation as aQ, type GitHubInstallationAccess as aR, GitHubInstallationAuthorityCommitError as aS, type GoalContinuationDecision as aT, type HostExportConsumerStatus as aU, type HostExportKind as aV, HostExportPayloadError as aW, HostMcpCredentialBindingError as aX, type HostMcpCredentialResolverContext as aY, HostMcpCredentialScopeError as aZ, HumanInputResponseValidationError as a_, type ConnectionCredentialForBroker as aa, ConnectionRefreshHttpError as ab, type ConsumeOAuthStateNonceInput as ac, type CorrectWorkspaceMemoryInput as ad, type CorrectWorkspaceMemoryResult as ae, type CreateCapabilityCatalogItemInput as af, type CreateConnectionInput as ag, type CreateDbOptions as ah, type CreateImportBatchInput as ai, type CreateKnowledgeMemoryInput as aj, type CreatePackInstallationInput as ak, type CreateScheduledTaskInput as al, type CreateSessionGoalInput as am, type CreateSessionMcpServerInput as an, type CreateSocialConnectionInput as ao, type CreateSocialPostInput as ap, type CreditBalanceByAccount as aq, type Database as ar, type DatabaseFailureCode as as, type DbClient as at, type DbSession as au, type DeviceEnrollmentRequestRecord as av, type DeviceEnrollmentStatus as aw, type EditQueueCommandResult as ax, type EffectiveControlBlocker as ay, type EffectiveControlResumeOption as az, type AcceptSessionHumanInputResponseResult as b, type RefreshTransportOptions as b$, type ImportBatch as b0, type InitializeSessionStartInput as b1, type InitializeSessionStartResult as b2, type InstallOrReadTurnExecutionPolicyForAttemptResult as b3, type IntegrationOAuthClientForUse as b4, type LeaseHolderKind as b5, type LeaseSnapshot as b6, type ListKnowledgeMemoryOptions as b7, type ListSessionEventPageOptions as b8, type ListSessionEventsOptions as b9, type MemoryEmbedder as bA, type MemorySanitizeResult as bB, type MeterableWarmLease as bC, NON_RLS_RUNTIME_TABLES as bD, type NestedAgentDepthDeploymentPolicy as bE, type NestedAgentDepthPolicySource as bF, NewSessionDraftAccessError as bG, NewSessionDraftConflictError as bH, type NewSessionDraftRow as bI, PROTECTED_NO_DIRECT_DML_TABLES as bJ, type PendingSessionToolCallInput as bK, type PersistenceFailureDetails as bL, type PersistenceRetryOutcome as bM, type QueueCommandConflictCode as bN, QueueCommandConflictError as bO, type QueueCommandResult as bP, type QueuedTurnRow as bQ, RUNTIME_DML_TABLES as bR, RUNTIME_FULL_DML_TABLES as bS, RUNTIME_READ_INSERT_TABLES as bT, RUNTIME_READ_ONLY_TABLES as bU, RUNTIME_TABLE_PRIVILEGES as bV, type ReapDrainable as bW, type ReconcileCodexCapacityWaitResult as bX, type ReconcileColdLostLeaseInstanceBlockersResult as bY, type RecoverSessionDispatchInput as bZ, type RecoverSessionDispatchResult as b_, type ListSessionsForSubjectOptions as ba, type ListSessionsOptions as bb, type LiveModalSandboxLeaseAttribution as bc, type LostProviderWorkspaceSettlement as bd, MACHINE_METRICS_SERIES_INTERVAL_MS as be, MAX_INTERNAL_UPDATE_BATCH_BYTES as bf, MAX_INTERNAL_UPDATE_BATCH_MEMBERS as bg, MAX_INTERNAL_UPDATE_BYTES as bh, MEMORY_ACTIVE_RECORD_CAP as bi, MEMORY_BLOCK_KIND_ORDER as bj, MEMORY_BLOCK_RECORD_LIMIT as bk, MEMORY_CORRECT_TOOL_DESCRIPTION as bl, MEMORY_KIND_SECTION_TITLES as bm, MEMORY_NEAR_DUP_COSINE_THRESHOLD as bn, MEMORY_NEAR_DUP_NEIGHBORS as bo, MEMORY_SAVE_TOOL_DESCRIPTION as bp, MEMORY_SEARCH_DEFAULT_LIMIT as bq, MEMORY_SEARCH_MAX_LIMIT as br, MEMORY_SEARCH_TOOL_DESCRIPTION as bs, MEMORY_TEXT_MAX_CHARS as bt, MEMORY_VISIBLE_RECORD_CAP as bu, type MachineMetricsRow as bv, type MachineMetricsSample as bw, type MarkWarmLeaseInstanceLostResult as bx, type MaterializeGoalContinuationResult as by, type MemoryBlockRecord as bz, type AccrueWarmSecondsResult as c, type SessionAttemptInterruptionSettlement as c$, type RegisterWorkspacePackInput as c0, type RegistryCapabilityCatalogItemInput as c1, type RegistryCatalogSurfaceKey as c2, type ReplaceIntegrationOAuthClientInput as c3, type RequestSessionTurnRecoveryInput as c4, type RequestSessionTurnRecoveryResult as c5, type ResolveConnectionCredentialInput as c6, type ResolveConnectionCredentialResult as c7, type RetainedFileArtifact as c8, type RetainedProcessProviderProof as c9, type SandboxArchiveAvailability as cA, type SandboxArchiveRevision as cB, SandboxImageConflictError as cC, type SandboxKind as cD, type SandboxLeaseLiveness as cE, SandboxLeaseRecoveryBlockedError as cF, SandboxLeaseSupersededError as cG, type SandboxOpenPtySessionRow as cH, type SandboxProviderExistence as cI, type SandboxPtyProcessIdentity as cJ, type SandboxPtySessionRow as cK, type SandboxRecord as cL, type SandboxRecoveryState as cM, type SandboxRestoreStatus as cN, type SandboxRetainedProcess as cO, type SandboxRetainedProcessIdentity as cP, SandboxRetainedProcessPromotionFencedError as cQ, type SandboxRetainedProcessReconciliationClaim 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 SaveWorkspaceMemoryResult as c_, RigActiveVersionChangedError as ca, RigChangeAlreadyVerifyingError as cb, type RigChangeMonitoringSummary as cc, RigChangeTransitionError as cd, type RigVersionContentInput as ce, type RigVersionMonitoringSummary as cf, type RlsContext as cg, type RlsStrategy as ch, type RuntimeDatabaseIdentity as ci, type RuntimeDatabasePosture as cj, RuntimeDatabasePostureError as ck, type RuntimeDatabasePostureOptions as cl, type RuntimeRoutinePosture as cm, type RuntimeSchemaPosture as cn, type RuntimeTableDmlPrivilege as co, type RuntimeTablePosture as cp, type RuntimeTablePrivilegeContract as cq, SESSION_ANCESTRY_LIMIT as cr, SESSION_DISCOVERY_CONTROL_TARGET_LIMIT as cs, SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS as ct, SESSION_DISCOVERY_GOAL_MAX_CHARS as cu, SESSION_DISCOVERY_MESSAGE_MAX_CHARS as cv, SESSION_EVENT_DB_PAGE_MAX_BYTES as cw, SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT as cx, SESSION_LIST_SNAPSHOT_MAX_IDS as cy, type SafeDatabaseErrorFacts as cz, type AcquireLeaseInput as d, type UpdateKnowledgeMemoryInput as d$, type SessionCodexState as d0, type SessionCommandActor as d1, SessionCommandIdempotencyError as d2, type SessionCommandReceiptRow as d3, SessionContextBusyError as d4, SessionControlConflictError as d5, SessionControlInvariantError as d6, type SessionControlMutationResult as d7, type SessionCreateDeniedResult as d8, type SessionCreateInput as d9, type SessionRecordingState as dA, type SessionSpawnDenial as dB, type SessionSpawnDenialCode as dC, SessionSpawnDeniedDbError as dD, type SessionSystemUpdateOutboxDelivery as dE, SessionToolPolicyVersionConflictError as dF, type SessionTurnAttemptOutcome as dG, type SessionTurnForExecution as dH, type SessionTurnRecordingSettlement as dI, type SessionWorkPeek as dJ, type SessionWorkTrigger as dK, type SessionWorkflowWake as dL, type SessionWorkflowWakeDeliveryResult as dM, type SetSessionCodexPinOptions as dN, type SetSessionGoalStatusEvent as dO, type SettleCodexCredentialFailoverResult as dP, type SettleCodexCredentialLeaseLossResult as dQ, type SteerQueueCommandResult as dR, type StoreIntegrationOAuthClientInput as dS, type StoredIntegrationOAuthClient as dT, type StreamAcknowledgment as dU, type SubmitHumanPromptResult as dV, type ToolspaceCallReservation as dW, type ToolspaceTurnAttemptClaims as dX, type TurnAttemptFenceRejectReason as dY, type UpdateConnectionInput as dZ, type UpdateImportBatchCountsInput as d_, type SessionCreateResult as da, type SessionCreateSuccessResult as db, type SessionDepthPolicy as dc, type SessionDiscoveryControl as dd, type SessionDiscoveryCursor as de, type SessionDiscoveryOrderBy as df, type SessionDiscoverySummary as dg, type SessionEventPage as dh, SessionEventPersistenceError as di, type SessionEventWriteLockInput as dj, type SessionEventWriteLocks as dk, type SessionGoalContinuationProjection as dl, SessionIdConflictError as dm, type SessionLineage as dn, SessionListAccessError as dp, type SessionListCursor as dq, SessionListCursorError as dr, SessionListCursorExpiredError as ds, SessionListSnapshotLimitError as dt, type SessionMcpServerForRun as du, SessionPinAccessError as dv, SessionPinVersionConflictError as dw, type SessionRecordingCodec as dx, type SessionRecordingMode as dy, type SessionRecordingRow as dz, type AcquireLeaseResult as e, buildCodexTokenResolver as e$, type UpdateScheduledTaskInput as e0, type UpdateSessionMcpApprovalPolicyResult as e1, type UpdateSessionMcpServerCredentialsInput as e2, type UpdateSessionMcpServerCredentialsResult as e3, type UpsertCodexSubscriptionCredentialResult as e4, type UserLookup as e5, type VariableSetForRun as e6, WORKSPACE_MEMORY_BLOCK_EMPTY as e7, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as e8, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as e9, advanceWorkspaceGeneration as eA, advanceWorkspaceGenerationForDirectRequest as eB, advanceWorkspaceGenerationForRetainedProcess as eC, allAccountPermissions as eD, allWorkspacePermissions as eE, appendSessionEventToSandboxGroup as eF, appendSessionEvents as eG, appendSessionEventsAndUpdateSession as eH, appendSessionEventsForTurnAttempt as eI, appendSessionEventsWithLockedSessionUpdate as eJ, appendSessionHistoryItems as eK, applyContextCompaction as eL, applyCreditDebitUpToBalance as eM, applyCreditLedgerEntry as eN, applySessionTurnSettlement as eO, approveDeviceEnrollmentRequest as eP, areGitHubRepositoriesAllowedForWorkspace as eQ, armCodexCapacityWait as eR, assertAgentCommandAuthorityInTransaction as eS, assertRuntimeDatabasePosture as eT, autoResumeSessionBranchInTransaction as eU, beginRigChangeVerificationAttempt as eV, beginSandboxRematerialization as eW, bindAuthorizedGitHubInstallationRepositories as eX, bindGitHubInstallationRepositories as eY, bootstrapWorkspace as eZ, buildChildCompletionDigest as e_, type WorkspaceCaptureCommitResult as ea, type WorkspaceCaptureGcPlan as eb, type WorkspaceCaptureGcRow as ec, type WorkspaceCaptureRow as ed, type WorkspaceControlLockMode as ee, type WorkspaceControlMutationResult as ef, type WorkspaceControlRow as eg, type WorkspaceEnvironmentForRun as eh, type WorkspaceMemoryOrigin as ei, type WorkspaceMemorySearchInput as ej, type WorkspaceMemorySearchMode as ek, type WorkspaceMemorySearchResult as el, type WorkspaceModelPolicy as em, abandonCodexResetRedemptionBeforeProvider as en, abandonRecordingForTurnAttempt as eo, acceptSessionApprovalDecision as ep, acceptSessionHumanInputResponse as eq, accrueWarmSeconds as er, acknowledgeHostExportBatch as es, acquireCodexCredentialLease as et, acquireLease as eu, activateRigVersion as ev, addSessionSystemUpdate as ew, addSessionSystemUpdateWithSourceMutation as ex, admitToolspaceTurnAttempt as ey, adoptCodexResetRedemptionAttempt as ez, type ActiveRetainedProcessOwnerCount as f, createScheduledTask as f$, buildConnectionTokenResolver as f0, buildHostConnectionTokenResolver as f1, canonicalSessionCommandHash as f2, claimCodexResetRedemption as f3, claimExpiredFileUploadCleanup as f4, claimFileUploadCleanup as f5, claimHostExportBatch as f6, claimPendingSessionSystemUpdateOutbox as f7, claimPendingSessionWorkflowWakes as f8, claimSessionWorkForAttempt as f9, countActiveSessionsUsingVariableSet as fA, countConsecutiveReactiveRotations as fB, countExpiredDrainingSandboxLeases as fC, countQueuedTurns as fD, countRigs as fE, countSandboxLeasesByLiveness as fF, countScheduledTasksForWorkspace as fG, countScheduledTasksUsingEnvironment as fH, countScheduledTasksUsingVariableSet as fI, countSessionHistoryItems as fJ, countSessionsUsingRig as fK, countVariableSets as fL, countWorkspaceEnvironments as fM, countWorkspacesForAccount as fN, createApiKey as fO, createConnection as fP, createDb as fQ, createDeviceEnrollmentRequest as fR, createEnrollment as fS, createFileUpload as fT, createImportBatch as fU, createKnowledgeMemory as fV, createRig as fW, createRigChange as fX, createRigVersion as fY, createRigVersionForChangePromotion as fZ, createSandbox as f_, claimTerminalRetainedProcesses as fa, clearDurablePendingSessionToolCalls as fb, clearEnrollmentWentOffline as fc, clearPendingSessionToolspaceCall as fd, clearSessionContext as fe, clearSessionGoal as ff, clearedContextMarkerItem as fg, closePtySession as fh, closeSessionTurnAttemptInTransaction as fi, codexCapacityRefreshBackoffMs as fj, commitWarmingToWarm as fk, completeCodexResetRedemption as fl, completeExpiredFileUploadCleanup as fm, completeFileUpload as fn, completeFileUploadCleanup as fo, computeWorkspaceCaptureGcPlan as fp, confirmDrainCold as fq, consumeDeviceEnrollmentRequest as fr, consumeIntegrationOAuthStateNonce as fs, consumeNewSessionDraftInTransaction as ft, correctWorkspaceMemory as fu, countActiveApiKeysForWorkspace as fv, countActiveRetainedProcessesByOwnerState as fw, countActiveSessionHistoryItems as fx, countActiveSessionsForWorkspace as fy, countActiveSessionsUsingEnvironment as fz, type ActiveSandboxPointer as g, getActiveSessionHistoryItems as g$, createScheduledTaskRun as g0, createSession as g1, createSessionGoal as g2, createSessionMcpServers as g3, createSessionWithIdempotencyKey as g4, createSessionWithIdempotencyKeyResult as g5, createSocialConnection as g6, createSocialPost as g7, createVariableSet as g8, createWorkspace as g9, enableCapabilityInstallation as gA, enablePackInstallation as gB, encodeSessionListCursor as gC, encryptEnvironmentValue as gD, enqueueSessionTurn as gE, enqueueSessionWorkflowWake as gF, enqueueSessionWorkflowWakeIfRunnable as gG, enqueueSessionWorkflowWakeInTransaction as gH, ensureCodexRotationSettings as gI, ensureManagedAccessForUser as gJ, estimateMemoryTokens as gK, evaluateGoalContinuation as gL, evaluateRuntimeDatabasePosture as gM, evaluateSessionControl as gN, evaluateSessionControls as gO, evaluateSessionDiscoveryControls as gP, expireSessionHumanInputRequest as gQ, failHostExportBatch as gR, failSandboxRematerialization as gS, failWarmingToCold as gT, fenceCodexResetRedemptionSend as gU, fetchCodexRateLimitResetCreditsForAccount as gV, fetchCodexUsageForAccount as gW, finalizeEnrollmentByToken as gX, findActiveApiKeyByHash as gY, forceDrainOverLimitViewerOnlyBoxes as gZ, frozenInitiatorForCommandActor as g_, createWorkspaceEnvironment as ga, databaseFailureCode as gb, deadLetterHostExportHead as gc, decodeSessionListCursor as gd, decryptEnvironmentValue as ge, decryptedCapabilityHeaders as gf, deferRetainedProcessReconciliation as gg, deleteGitHubInstallationBinding as gh, deleteRecording as gi, deleteRig as gj, deleteRigIfNoActiveSessions as gk, deleteScheduledTask as gl, deleteSessionQueueItemInTransaction as gm, deleteVariableSet as gn, deleteVariableSetVariable as go, deleteWorkspace as gp, deleteWorkspaceCaptureRows as gq, deleteWorkspaceEnvironment as gr, deleteWorkspaceEnvironmentVariable as gs, deleteWorkspacePack as gt, denyDeviceEnrollmentRequest as gu, disableCapabilityInstallation as gv, disableHostExportConsumer as gw, disconnectAllCodexAccounts as gx, disconnectCodexAccount as gy, editQueuedTurnInTransaction as gz, type AddSessionSystemUpdateInput as h, getStreamAcknowledgment as h$, getActiveSessionTurnForExecution as h0, getAnySessionInGroup as h1, getBillingBalance as h2, getBillingCustomer as h3, getCapabilityCatalogItem as h4, getCapabilityInstallation as h5, getCodexCapacityWaitForSession as h6, getCodexCredentialStatus as h7, getCodexResetRedemptionAttempt as h8, getCodexRotationSettings as h9, getRigChange as hA, getRigName as hB, getRigVersion as hC, getRigVersionById as hD, getSandbox as hE, getSandboxSessionEnvelope as hF, getScheduledTask as hG, getSession as hH, getSessionByCreateIdempotencyKey as hI, getSessionCodexState as hJ, getSessionEvent as hK, getSessionEventByClientEventId as hL, getSessionForSubject as hM, getSessionGoal as hN, getSessionGoalWithContinuation as hO, getSessionHistoryItems as hP, getSessionHumanInputRequest as hQ, getSessionLineage as hR, getSessionQueueSnapshot as hS, getSessionRootId as hT, getSessionSpawnDenial as hU, getSessionSpawnDenialByIdempotencyKey as hV, getSessionSystemUpdateOutboxByDedupeKey as hW, getSessionTurn as hX, getSessionTurnForAttempt as hY, getSocialConnection as hZ, getStoredCapabilityHeaderCiphertext as h_, getComposerDraftInTransaction as ha, getConnectionMetadata as hb, getDeviceEnrollmentRequestByDeviceCode as hc, getEnrollment as hd, getFile as he, getFileUpload as hf, getHostExportConsumerStatus as hg, getHumanInputResumeForEvent as hh, getKnowledgeMemory as hi, getLatestRunState as hj, getLatestStartedSessionTurn as hk, getManagedAccount as hl, getManagedUserByEmail as hm, getMaterializedSandboxFileResources as hn, getNestedAgentDepthDeploymentPolicy as ho, getNewSessionDraftInTransaction as hp, getOpenPtySession as hq, getOrCreateSessionSystemUpdateOutbox as hr, getPackInstallation as hs, getPendingDeviceEnrollmentRequestByUserCode as ht, getPendingDeviceEnrollmentRequestByUserCodeGlobal as hu, getRecording as hv, getRetainedFileArtifact as hw, getRetainedProcess as hx, getRig as hy, getRigByName as hz, type AddSessionSystemUpdateResult as i, listRigChangeMonitoringSummaries as i$, getVariableSet as i0, getVariableSetByName as i1, getVariableSetValuesForRun as i2, getWorkspace as i3, getWorkspaceControlEvent as i4, getWorkspaceDefaultRigId as i5, getWorkspaceEnvironment as i6, getWorkspaceEnvironmentByName as i7, getWorkspaceEnvironmentValuesForRun as i8, getWorkspaceGrant as i9, isSessionEventPersistenceError as iA, isStripeWebhookProcessed as iB, latestWorkspaceCapture as iC, listApiKeys as iD, listCapabilityCatalogItems as iE, listCapabilityInstallations as iF, listCodexAccountStatuses as iG, listCodexResetRedemptionRecoveries as iH, listConnectionsMetadata as iI, listCreditBalancesByAccount as iJ, listDistinctRigVersionIdsInGroup as iK, listDistinctVariableSetIdsInGroup as iL, listEnabledMcpCapabilityServers as iM, listEnrollments as iN, listGitHubInstallationAccessForWorkspace as iO, listGitHubInstallationIdsForWorkspace as iP, listGitHubInstallationsForWorkspace as iQ, listKnowledgeMemories as iR, listLiveModalSandboxLeaseAttributions as iS, listMeterableWarmLeases as iT, listOpenPtySessions as iU, listOutstandingSessionSystemUpdates as iV, listPackInstallations as iW, listPendingCodexCapacityWakeTargets as iX, listPendingSessionTurns as iY, listRecordings as iZ, listRegistryCatalogSurfaceKeys as i_, getWorkspaceModelPolicy as ia, getWorkspacePack as ib, grantWorkspaceAccess as ic, hasAuditableGitHubInstallationAuthority as id, hasCreditLedgerEntry as ie, hashMemoryText as ig, heartbeatCodexCredentialLease as ih, heartbeatCodexCredentialLeaseUntil as ii, heartbeatLeaseHolder as ij, ingestMachineMetricsSample as ik, initializeSessionStartAtomically as il, insertFailedWorkspaceCapture as im, insertMachineMetricsSeries as io, insertPtySession as ip, insertRecording as iq, insertWorkspaceCapture as ir, inspectRuntimeDatabasePosture as is, installOrReadTurnExecutionPolicyForAttempt as it, interruptedToolCallResult as iu, isCodexBilledTurn as iv, isDatabasePersistenceFailure as iw, isMemoryTextTooLong as ix, isRetryablePersistenceSqlState as iy, isSessionCompactionRequested as iz, type AdoptCodexResetRedemptionResult as j, planWorkspaceCaptureGc as j$, listRigChanges as j0, listRigVersionMonitoringSummaries as j1, listRigVersions as j2, listRigs as j3, listSandboxes as j4, listScheduledTaskRuns as j5, listScheduledTasks as j6, listSessionDiscoverySummaries as j7, listSessionEventPage as j8, listSessionEvents as j9, markFileUploadFailed as jA, markSandboxFileResourcesMaterialized as jB, markSandboxProviderReady as jC, markSandboxRestoreVerifying as jD, markScheduledTaskRunFailedIfQueued as jE, markSessionAttemptQuiesced as jF, markSessionSystemUpdateOutboxDeliveredInTransaction as jG, markSessionSystemUpdateOutboxFailed as jH, markSessionWorkflowWakeDelivered as jI, markSessionWorkflowWakeFailed as jJ, markStaleRegistryCatalogItems as jK, markStripeWebhookProcessed as jL, markWarmLeaseInstanceLost as jM, materializeGoalContinuation as jN, mcpServerIdForCapability as jO, moveQueuedTurnInTransaction as jP, mutateSessionControlInTransaction as jQ, mutateWorkspaceControlInTransaction as jR, nestedPostgresSqlState as jS, newSessionDraftToolsProvided as jT, nextSessionHistoryPosition as jU, normalizeBearerScheme as jV, normalizeMemoryText as jW, orphanedResultRowIndicesForRepair as jX, peekSessionWork as jY, persistDrainSnapshot as jZ, persistWarmSnapshot as j_, listSessionHumanInputRequests as ja, listSessionIdsInGroup as jb, listSessionMcpServerMetadata as jc, listSessionMcpServersForChildInheritance as jd, listSessionMcpServersForRun as je, listSessionSpawnDenials as jf, listSessionSystemUpdatesForTurn as jg, listSessionTurns as jh, listSessions as ji, listSessionsForSubject as jj, listSocialConnections as jk, listSocialPosts as jl, listUsageEvents as jm, listVariableSets as jn, listWorkspaceControlEvents as jo, listWorkspaceEnvironments as jp, listWorkspaceMembers as jq, listWorkspacePacks as jr, listWorkspacesForSubject as js, loadCodexCredentialForRun as jt, loadConnectionCredentialForBroker as ju, loadIntegrationOAuthClient as jv, loadVariableSetForRun as jw, loadWorkspaceEnvironmentForRun as jx, lockSessionEventWriteRows as jy, lockWorkspaceInferenceControl as jz, AgentCommandAuthorityError as k, retainedProcessSettlementIdentity as k$, projectEffectiveControlForRelatedAccess as k0, projectSessionForRelatedAccess as k1, pruneHostExportOutbox as k2, publicNewSessionDraftOptions as k3, quarantineCodexCredentialForLease as k4, reArmDrainingLease as k5, readActiveSandbox as k6, readLease as k7, readMachineMetricsLatest as k8, readMachineMetricsLatestForWorkspace as k9, registerDbBinding as kA, registerHostExportConsumer as kB, registerInternalUpdateWakeInTransaction as kC, registerPendingSessionToolCall as kD, registerSessionTurnAttemptClaim as kE, registerSessionWorkflowWakeInTransaction as kF, registerWorkspacePack as kG, releaseCodexCredentialLease as kH, releaseCodexResetRedemptionClaim as kI, releaseLeaseHolder as kJ, removeWorkspaceMember as kK, renameCodexAccount as kL, renderWorkspaceMemoryBlock as kM, replaceIntegrationOAuthClient as kN, requestSessionCompaction as kO, requestSessionTurnRecovery as kP, requireFile as kQ, requireScheduledTask as kR, requireSession as kS, requireSocialConnection as kT, requireWorkspace as kU, reserveSessionCommandReceipt as kV, reserveToolspaceCallForAttempt as kW, resolveWorkspaceMemoryBlock as kX, resumeHostExportConsumer as kY, retainWorkspaceMutationProcess as kZ, retainedProcessReconciliationProof as k_, readMachineMetricsSeries as ka, readWorkspaceArchiveCapturePreflight as kb, reapExpiredSessionListSnapshots as kc, reapStaleLeaseHolders as kd, reapStaleLeaseHoldersGlobal as ke, reconcileCodexCapacityWait as kf, reconcileColdLostLeaseInstanceBlockers as kg, recordAuditEvent as kh, recordCodexAccountConnectors as ki, recordCodexAccountUsage as kj, recordCodexAccountUsageWithWakeTargets as kk, recordCodexTokenRefresh as kl, recordConnectionTokenRefresh as km, recordConnectionUsed as kn, recordLeaseDataPlaneUrl as ko, recordLeaseTerminalDataPlaneUrl as kp, recordPendingSessionToolCallResult as kq, recordRetainedProcessReconciliationProof as kr, recordSessionActiveCodexCredential as ks, recordSkippedContextCompaction as kt, recordStreamAcknowledgment as ku, recordStripeWebhookEvent as kv, recordUsageEvent as kw, recordWarmingSandboxCreated as kx, recoverSessionDispatch as ky, refreshOAuthConnectionCredential as kz, type AgentInternalUpdateCommandResult as l, supersedeSessionCurrentDirectionInTransaction as l$, retireHostExportConsumer as l0, revokeApiKey as l1, revokeConnection as l2, revokeEnrollment as l3, revokeViewer as l4, rewindHostExportConsumer as l5, rlsContextForWorkspace as l6, rlsStrategyFor as l7, rotateWorkspaceArchives as l8, runIdempotentPersistenceTransaction as l9, setEnrollmentOpStreamState as lA, setEnrollmentWentOffline as lB, setInitialActiveCodexCredential as lC, setRlsContext as lD, setSessionCodexPin as lE, setSessionGoalLastContinuationTurn as lF, setSessionGoalStatus as lG, setSessionGoalStatusWithEvent as lH, setSessionLastInputTokensForTurnAttempt as lI, setSessionPin as lJ, setSubjectRlsContext as lK, setTemporalWorkflowId as lL, setVariableSetVariable as lM, setWorkspaceDefaultRig as lN, setWorkspaceEnvironmentVariable as lO, settleCodexCredentialFailover as lP, settleCodexCredentialLeaseLoss as lQ, settleRetainedProcess as lR, settleScheduledTaskRunInTransaction as lS, settleSessionAttemptInterruptions as lT, settleSessionIdleWithParentOutbox as lU, shortMemoryId as lV, steerAgentSessionInTransaction as lW, steerQueuedTurnInTransaction as lX, storeIntegrationOAuthClient as lY, submitHumanPromptInTransaction as lZ, sumUsageQuantity as l_, runtimeDatabaseReadyCheck as la, safeDatabaseErrorFacts as lb, sanitizeEventPayload as lc, sanitizeEventString as ld, sanitizeMemoryText as le, sanitizeModelPayload as lf, saveComposerDraftInTransaction as lg, saveNewSessionDraftInTransaction as lh, saveRunState as li, saveWorkspaceMemory as lj, searchWorkspaceMemories as lk, seedNewSessionDraftInTransaction as ll, sendAgentMessageInTransaction as lm, serializeEffectiveSessionControl as ln, sessionAuthorizationScopeFilter as lo, sessionSubject as lp, sessionTreeStatsForSessions as lq, sessionsWithActiveOpOnEnrollment as lr, setActiveCodexCredential as ls, setActiveSandbox as lt, setCodexCredentialExhausted as lu, setCodexCredentialExhaustedWithWakeTargets as lv, setCodexCredentialStatus as lw, setCodexCredentialStatusById as lx, setConnectionStatus as ly, setEnrollmentDisplayState as lz, type AppendEventInput as m, touchEnrollmentLastSeen as m0, touchLeaseHolder as m1, updateCodexAllocatorEligibility as m2, updateCodexRotationSettings as m3, updateConnection as m4, updateImportBatchCounts as m5, updateKnowledgeMemory as m6, updatePackInstallationStatus as m7, updatePtySessionActivity as m8, updateRecording as m9, verifyRetainedProcessMutationSettlement as mA, verifyWorkspaceMutationSettlement as mB, withAccountRls as mC, withCodexCapacityMutation as mD, withCodexCredentialRefreshLock as mE, withCodexTokenDeadline as mF, withRlsContext as mG, withWorkspaceRls as mH, withWorkspaceSubjectRls as mI, withWorkspaceUsageLock as mJ, workspaceCaptureAtRevision as mK, workspaceCodexSubscriptionActive as mL, updateRig as ma, updateRigChangeStatus as mb, updateScheduledTask as mc, updateScheduledTaskRun as md, updateSessionCommandReceiptResult as me, updateSessionGoal as mf, updateSessionGoalWithEvent as mg, updateSessionMcpApprovalPolicy as mh, updateSessionMcpServerCredentials as mi, updateSessionTitle as mj, updateVariableSet as mk, updateWorkspace as ml, updateWorkspaceEnvironment as mm, updateWorkspaceSettings as mn, upsertBillingCustomer as mo, upsertCapabilityCatalogItem as mp, upsertCodexSubscriptionCredential as mq, upsertGitHubInstallation as mr, upsertMachineMetricsLatest as ms, upsertRegistryCapabilityCatalogItem as mt, upsertSandboxSessionEnvelope as mu, upsertSessionGoal as mv, upsertSessionGoalWithEvent as mw, upsertWorkspaceModelPolicy as mx, validateHumanInputResponse as my, verifyDirectWorkspaceMutationSettlement as mz, type ApplyContextCompactionResult as n, 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 ClearSessionContextResult as z };