@opengeni/db 0.10.7 → 0.12.0

package/dist/provision-roles.d.ts

@@ -1,14 +1,15 @@
-import { TurnInitiatorContext, SessionMcpApprovalPolicy, TurnInitiator, ResourceRef, ToolRef, ReasoningEffort, TurnExecutionPolicyV1, 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, SessionTurnSource, SandboxBackend, SandboxOs, FileAsset, FileUploadStatus, GitHubRepositoryScope, SessionGoal, SessionEventReadDirection, SessionEventSemanticClass, SessionEventPayloadMode, SessionAuthorizationListScope, CapabilityPack, RigChangeKind, RigChangeStatus, RigCheck, SessionGoalStatus, Session, LineageNode, SessionMcpServerMetadata, RigVersion, BillingBalance, RigChange, AccessContext, HostEventExportBatch, HostUsageExportBatch, ApiKey, ConnectionMetadata, Rig, ScheduledTask, ScheduledTaskTriggerType, ScheduledTaskRun, SessionToolPolicy, 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, 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 { 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 { s as sessionCommandReceipts, w as workspaces, a as sessions, b as sessionTurns, c as sessionTurnAttempts, d as composerDrafts, 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-CqkzrBRS.js';
+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-CnpD6BcX.js';
 import './migrate.js';
 import { FetchLike, DnsLookup } from '@opengeni/network';
 
 declare const SESSION_ANCESTRY_LIMIT = 10000;
-type WorkspaceControlLockMode = "share" | "update";
+type WorkspaceControlLockMode = "none" | "share" | "update";
 type EffectiveControlState = "active" | "paused";
 type SessionCommandActor = {
     type: "human" | "operator";
@@ -145,7 +146,7 @@ declare function assertAgentCommandAuthorityInTransaction(db: Database, input: {
         type: "agent_attempt";
     }>;
     targetSessionId: string;
-    action: "pause" | "resume" | "steer" | "message";
+    action: "pause" | "resume" | "steer" | "message" | "goal";
 }): Promise<void>;
 declare function canonicalSessionCommandHash(value: unknown): string;
 declare function lockWorkspaceInferenceControl(db: Database, workspaceId: string, mode: WorkspaceControlLockMode): Promise<WorkspaceControlRow>;
@@ -250,6 +251,7 @@ declare function reserveSessionCommandReceipt(db: Database, input: {
     targetTurnId: string | null;
     operationKey: string;
     canonicalRequestHash: string;
+    identityScope?: "actor" | "goal_operation";
 }): Promise<{
     receipt: SessionCommandReceiptRow;
     replay: boolean;
@@ -525,6 +527,42 @@ declare function steerAgentSessionInTransaction(db: Database, input: {
     instruction: string;
 }): Promise<AgentInternalUpdateCommandResult>;
 
+type NewSessionDraftRow = typeof newSessionDrafts.$inferSelect;
+declare class NewSessionDraftConflictError extends Error {
+    readonly currentRevision: number;
+    readonly name = "NewSessionDraftConflictError";
+    constructor(currentRevision: number);
+}
+declare class NewSessionDraftAccessError extends Error {
+    readonly name = "NewSessionDraftAccessError";
+    constructor();
+}
+declare function getNewSessionDraftInTransaction(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    lock?: boolean;
+}): Promise<NewSessionDraftRow | null>;
+declare function saveNewSessionDraftInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    expectedRevision: number;
+    text: string;
+    resources: ResourceRef[];
+    tools: ToolRef[];
+    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: {
+    workspaceId: string;
+    subjectId: string;
+    expectedRevision: number;
+}): Promise<boolean>;
+
 /** Provider-valid result for a started call whose durable outcome is unknown. */
 declare function interruptedToolCallResult(input: {
     callType: string;
@@ -902,6 +940,54 @@ type RlsContext = {
     accountId: string;
     workspaceId?: string | null;
 };
+type NestedAgentDepthPolicySource = "session" | "workspace" | "deployment" | "default";
+type SessionDepthPolicy = {
+    rootSessionId: string;
+    nestedAgentDepth: number;
+    maxNestedAgentDepthOverride: number | null;
+    effectiveMaxNestedAgentDepth: number;
+    nestedAgentDepthPolicySource: NestedAgentDepthPolicySource;
+    nestedAgentDepthPolicySessionId: string | null;
+};
+type SessionSpawnDenialCode = "nested_agent_depth_exceeded" | "nested_agent_depth_override_forbidden";
+type SessionSpawnDenial = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    parentSessionId: string | null;
+    rootSessionId: string | null;
+    currentDepth: number;
+    attemptedDepth: number;
+    effectiveMaxNestedAgentDepth: number;
+    requestedMaxNestedAgentDepthOverride: number | null;
+    policySource: NestedAgentDepthPolicySource;
+    policySessionId: string | null;
+    subjectId: string | null;
+    code: SessionSpawnDenialCode;
+    idempotencyKey: string | null;
+    createdAt: string;
+};
+type NestedAgentDepthDeploymentPolicy = {
+    maxNestedAgentDepth: number;
+    policySource: "deployment" | "default";
+};
+type DbSession = Session & SessionDepthPolicy;
+type SessionCreateSuccessResult = {
+    denied: false;
+    session: DbSession;
+    created: boolean;
+};
+type SessionCreateDeniedResult = {
+    denied: true;
+    created: false;
+    denial: SessionSpawnDenial;
+};
+type SessionCreateResult = SessionCreateSuccessResult | SessionCreateDeniedResult;
+/** Thrown only after a denied create transaction has committed its evidence. */
+declare class SessionSpawnDeniedDbError extends Error {
+    readonly denial: SessionSpawnDenial;
+    constructor(denial: SessionSpawnDenial);
+}
 /**
  * RLS posture for the connection OpenGeni's query layer runs over (Step I, §7.7).
  *
@@ -952,6 +1038,13 @@ type CreateDbOptions = {
     userLookup?: UserLookup;
     /** postgres-js pool size; defaults to today's `10`. */
     max?: number;
+    /**
+     * Connection-local default transaction isolation sent in the postgres-js
+     * startup parameters. This is intentionally not a role/database default:
+     * tests and embedded callers can exercise a different ambient isolation
+     * without mutating a shared PostgreSQL role or affecting other connections.
+     */
+    isolationLevel?: postgres.ConnectionParameters["default_transaction_isolation"];
 };
 /** The strategy bound to a handle (or the `"force"` default). */
 declare function rlsStrategyFor(db: Database): RlsStrategy;
@@ -1085,6 +1178,8 @@ declare function withWorkspaceRls<T>(db: Database, workspaceId: string, fn: (db:
  * even if a future query accidentally omits its explicit subject predicate.
  */
 declare function withWorkspaceSubjectRls<T>(db: Database, workspaceId: string, subjectId: string, fn: (db: Database) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
+/** Apply and verify actor-private RLS on an already transaction-pinned handle. */
+declare function setSubjectRlsContext(db: Database, subjectId: string): Promise<void>;
 declare function withWorkspaceUsageLock<T>(db: Database, workspaceId: string, fn: (db: Database) => Promise<T>): Promise<T>;
 declare function withAccountRls<T>(db: Database, accountId: string, fn: (db: Database) => Promise<T>): Promise<T>;
 declare const allWorkspacePermissions: Permission[];
@@ -3020,6 +3115,8 @@ declare function updateSessionMcpApprovalPolicy(db: Database, input: {
     requireApproval: SessionMcpApprovalPolicy;
 }): Promise<UpdateSessionMcpApprovalPolicyResult>;
 declare function listSessionMcpServersForRun(db: Database, workspaceId: string, sessionId: string, attemptId: string, encryptionKey: Uint8Array | null): Promise<SessionMcpServerForRun[]>;
+/** Read the persisted deployment fallback; process configuration is not policy authority. */
+declare function getNestedAgentDepthDeploymentPolicy(db: Database): Promise<NestedAgentDepthDeploymentPolicy>;
 type AgentSessionCreationActor = Extract<SessionCommandActor, {
     type: "agent_attempt";
 }>;
@@ -3028,7 +3125,7 @@ declare class SessionIdConflictError extends Error {
     readonly sessionId: string;
     constructor(sessionId: string);
 }
-declare function createSession(db: Database, input: {
+type SessionCreateInput = {
     requestedSessionId?: string;
     accountId: string;
     workspaceId: string;
@@ -3038,11 +3135,6 @@ declare function createSession(db: Database, input: {
     tools?: ToolRef[];
     toolPolicy?: SessionToolPolicy | null;
     metadata: Record<string, unknown>;
-    /**
-     * Frozen creator authority. Legacy/test-only callers may omit this and get
-     * an explicit unattributed service sentinel; production producers must pass
-     * an authenticated subject or named service.
-     */
     createdBy?: TurnInitiator;
     createdByContext?: TurnInitiatorContext;
     createdByActor?: AgentSessionCreationActor | null;
@@ -3058,48 +3150,40 @@ declare function createSession(db: Database, input: {
     sandboxGroupId?: string | null;
     sandboxOs?: SandboxOs;
     mcpServers?: CreateSessionMcpServerInput[];
-}): Promise<Session>;
+    maxNestedAgentDepthOverride?: number | null;
+    allowNestedAgentDepthIncrease?: boolean;
+    subjectId?: string | null;
+};
+declare function createSession(db: Database, input: SessionCreateInput): Promise<DbSession>;
 /**
  * Inserts a session under a workspace-scoped CREATE idempotency key, collapsing
- * a concurrent race on the same key to a single row. On the unique-violation
- * the conflicting insert does nothing (`onConflictDoNothing` on the partial
- * unique index) and the now-existing winning row is fetched and returned, so
- * two near-simultaneous creates with the same key yield ONE session and both
- * callers see the same id. `created` distinguishes the winner (true: this call
- * inserted and must run the rest of the start flow) from the loser/dup (false:
- * the row already existed and must be returned as-is).
- */
-declare function createSessionWithIdempotencyKey(db: Database, input: {
-    requestedSessionId?: string;
-    accountId: string;
-    workspaceId: string;
-    initialMessage: string;
-    initialTurnInstructions?: string | null;
-    resources: ResourceRef[];
-    tools?: ToolRef[];
-    toolPolicy?: SessionToolPolicy | null;
-    metadata: Record<string, unknown>;
-    createdBy?: TurnInitiator;
-    createdByContext?: TurnInitiatorContext;
-    createdByActor?: AgentSessionCreationActor | null;
-    model: string;
-    sandboxBackend: SandboxBackend;
-    variableSetId?: string | null;
-    rigId?: string | null;
-    rigVersionId?: string | null;
-    firstPartyMcpPermissions?: Permission[] | null;
-    instructions?: string | null;
-    parentSessionId?: string | null;
+ * a concurrent race on the same key to a single row. A losing source insert
+ * is either handled by `onConflictDoNothing` on the partial unique index or
+ * suppressed by the database BEFORE guard, and the durable winner is fetched
+ * and returned. Two near-simultaneous creates with the same key therefore
+ * yield ONE session and both callers see the same id. `created` distinguishes
+ * the winner (true: this call inserted and must run the rest of the start flow)
+ * from the loser/dup (false: the row already existed and must be returned as-is).
+ */
+declare function createSessionWithIdempotencyKeyResult(db: Database, input: SessionCreateInput & {
     createIdempotencyKey: string;
-    sandboxGroupId?: string | null;
-    sandboxOs?: SandboxOs;
-    mcpServers?: CreateSessionMcpServerInput[];
-}): Promise<{
-    session: Session;
-    created: boolean;
-}>;
+}): Promise<SessionCreateResult>;
+/**
+ * Backward-compatible keyed create API. Denials are committed by the
+ * admission transaction and then surfaced as SessionSpawnDeniedDbError;
+ * callers that need a structured result use createSessionWithIdempotencyKeyResult.
+ */
+declare function createSessionWithIdempotencyKey(db: Database, input: SessionCreateInput & {
+    createIdempotencyKey: string;
+}): Promise<SessionCreateSuccessResult>;
 declare function getSessionByCreateIdempotencyKey(db: Database, workspaceId: string, createIdempotencyKey: string): Promise<Session | null>;
 declare function getSession(db: Database, workspaceId: string, sessionId: string): Promise<Session | null>;
+declare function getSessionSpawnDenial(db: Database, workspaceId: string, denialId: string): Promise<SessionSpawnDenial | null>;
+declare function getSessionSpawnDenialByIdempotencyKey(db: Database, workspaceId: string, createIdempotencyKey: string): Promise<SessionSpawnDenial | null>;
+declare function listSessionSpawnDenials(db: Database, workspaceId: string, options?: {
+    limit?: number;
+    parentSessionId?: string | null;
+}): Promise<SessionSpawnDenial[]>;
 /**
  * Resolve ANY session that belongs to a shared-sandbox group (addendum 05 §D.3,
  * stress (e)). Used by the create-session `sandbox:{groupId}` join path to (1)
@@ -3137,6 +3221,10 @@ type ListSessionsForSubjectOptions = ListSessionsOptions & {
     subjectId: string;
     cursor?: SessionListCursor | undefined;
     search?: string | undefined;
+    /** Return only the complete personal pin projection; never scan/snapshot ordinary rows. */
+    pinsOnly?: boolean | undefined;
+    /** Materialize a continuation snapshot. Disable for legacy one-page array reads. */
+    materializeSnapshot?: boolean | undefined;
     authorizationScope?: SessionAuthorizationListScope | undefined;
 };
 declare class SessionPinVersionConflictError extends Error {
@@ -3146,9 +3234,15 @@ declare class SessionPinVersionConflictError extends Error {
 declare class SessionListCursorError extends Error {
     constructor(message?: string);
 }
+declare class SessionListCursorExpiredError extends Error {
+    constructor(message?: string);
+}
 declare class SessionListAccessError extends Error {
     constructor(message?: string);
 }
+declare class SessionListSnapshotLimitError extends Error {
+    constructor(message?: string);
+}
 declare class SessionPinAccessError extends Error {
     constructor(message?: string);
 }
@@ -3178,6 +3272,8 @@ declare function sessionTreeStatsForSessions(db: Database, workspaceId: string,
  * `UNION ALL`) makes legacy cycles terminate without a caller-sized path array.
  */
 declare function sessionAuthorizationScopeFilter(scope: SessionAuthorizationListScope): SQL;
+declare const SESSION_LIST_SNAPSHOT_MAX_IDS = 5000;
+declare const SESSION_LIST_SNAPSHOT_MAX_ACTIVE_PER_SUBJECT = 32;
 /** Opaque, URL-safe cursor encoding for a server-owned activity snapshot. */
 declare function encodeSessionListCursor(cursor: SessionListCursor): string;
 /** Decode and validate a cursor before it reaches any SQL predicate. */
@@ -3197,8 +3293,9 @@ declare function listSessionsForSubject(db: Database, workspaceId: string, optio
 declare function getSessionForSubject(db: Database, workspaceId: string, sessionId: string, subjectId: string, relatedSessionAccess?: "target" | "root"): Promise<Session | null>;
 /**
  * Idempotently set a member's pin without mutating the session's lifecycle or
- * activity timestamps. A transaction advisory lock serializes same-subject,
- * same-session actions across API replicas; expectedVersion rejects stale tabs.
+ * activity timestamps. A subject-scoped transaction advisory lock serializes
+ * personal pin mutations across API replicas and fences list projections;
+ * expectedVersion rejects stale tabs.
  */
 declare function setSessionPin(db: Database, input: {
     workspaceId: string;
@@ -3523,6 +3620,7 @@ type PendingSessionToolCallInput = {
     callId: string;
     callType: string;
     callItem: Record<string, unknown>;
+    modelToolOutputTruncationTokens?: number;
 };
 /**
  * Durably capture the raw SDK call item at the exact attempt boundary. This is
@@ -3833,8 +3931,17 @@ type SandboxPtySessionRow = {
     accountId: string;
     workspaceId: string;
     sessionId: string;
+    leaseId: string | null;
+    sandboxGroupId: string | null;
+    retainedProcessId: string | null;
+    openAdmissionId: string | null;
     execSessionId: number | null;
     leaseEpoch: number;
+    providerBackend: string | null;
+    providerInstanceId: string | null;
+    routeKind: "home" | "active" | null;
+    routeTargetId: string | null;
+    routeEpoch: number | null;
     cols: number;
     rows: number;
     shell: string;
@@ -3845,41 +3952,108 @@ type SandboxPtySessionRow = {
     createdAt: string;
     closedAt: string | null;
 };
+type SandboxPtyProcessIdentity = {
+    leaseId: string;
+    sandboxGroupId: string;
+    retainedProcessId: string;
+    openAdmissionId: string;
+    execSessionId: number;
+    leaseEpoch: number;
+    providerBackend: string;
+    providerInstanceId: string;
+    routeKind: "home" | "active";
+    routeTargetId: string | null;
+    routeEpoch: number;
+};
+type SandboxOpenPtySessionRow = Omit<SandboxPtySessionRow, keyof SandboxPtyProcessIdentity | "status"> & SandboxPtyProcessIdentity & {
+    status: "open";
+};
 declare function insertPtySession(db: Database, input: {
     id: string;
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    execSessionId?: number | null;
-    leaseEpoch: number;
+    identity: SandboxPtyProcessIdentity;
     cols: number;
     rows: number;
     shell: string;
     cwd: string;
     openedBy: string;
-}): Promise<SandboxPtySessionRow>;
+}): Promise<SandboxOpenPtySessionRow>;
 /** Read an OPEN PTY row by ptyId. Returns null when absent or already closed. */
-declare function getOpenPtySession(db: Database, workspaceId: string, ptyId: string): Promise<SandboxPtySessionRow | null>;
-/** Stamp the SDK exec-session id (known only after the open exec yields a still-
- *  running process) + refresh the input-activity TTL. */
+declare function getOpenPtySession(db: Database, input: {
+    workspaceId: string;
+    sessionId: string;
+    ptyId: string;
+}): Promise<SandboxOpenPtySessionRow | null>;
+/** Refresh activity/geometry only when the full retained-process identity still
+ * matches. A numeric provider locator or PTY UUID alone is never authority. */
 declare function updatePtySessionActivity(db: Database, input: {
     accountId: string;
     workspaceId: string;
+    sessionId: string;
     ptyId: string;
-    execSessionId?: number | null;
+    identity: SandboxPtyProcessIdentity;
     cols?: number;
     rows?: number;
-}): Promise<SandboxPtySessionRow | null>;
+}): Promise<SandboxOpenPtySessionRow | null>;
 /** Mark a PTY closed (idempotent — a double close on a closed row is a no-op). */
 declare function closePtySession(db: Database, input: {
     accountId: string;
     workspaceId: string;
+    sessionId: string;
     ptyId: string;
+    identity: SandboxPtyProcessIdentity;
 }): Promise<SandboxPtySessionRow | null>;
 /** List a session's OPEN PTYs (reattach + reap). */
-declare function listOpenPtySessions(db: Database, workspaceId: string, sessionId: string): Promise<SandboxPtySessionRow[]>;
+declare function listOpenPtySessions(db: Database, workspaceId: string, sessionId: string): Promise<SandboxOpenPtySessionRow[]>;
 type SandboxLeaseLiveness = "cold" | "warming" | "warm" | "draining";
-type LeaseHolderKind = "turn" | "viewer";
+type LeaseHolderKind = "turn" | "viewer" | "direct" | "process";
+type SandboxProviderExistence = "not_created" | "creating" | "exists" | "missing" | "unknown";
+type SandboxArchiveAvailability = "none" | "available" | "unverified" | "invalid";
+type SandboxRestoreStatus = "not_required" | "pending" | "restoring" | "verifying" | "ready" | "degraded" | "unrecoverable";
+type SandboxWorkspaceReadiness = "unknown" | "not_ready" | "ready" | "degraded" | "unrecoverable";
+type SandboxArchiveRevision = {
+    version: 1;
+    revision: string;
+    archiveSha256: string;
+    archiveBytes: number;
+    capturedAt: string;
+    workspace: {
+        algorithm: "sha256";
+        sha256: string;
+        entryCount: number;
+        fileCount: number;
+        totalFileBytes: number;
+    };
+};
+type SandboxRecoveryState = {
+    provider: {
+        status: SandboxProviderExistence;
+        instanceId: string | null;
+        observedAt: string | null;
+        diagnostic?: string;
+    };
+    archive: {
+        status: SandboxArchiveAvailability;
+        current: SandboxArchiveRevision | null;
+        previous: SandboxArchiveRevision | null;
+    };
+    restore: {
+        status: SandboxRestoreStatus;
+        rematerializationId: string | null;
+        selectedRevision: string | null;
+        startedAt: string | null;
+        completedAt: string | null;
+        failureCode?: string;
+        retryable?: boolean;
+    };
+    workspace: {
+        status: SandboxWorkspaceReadiness;
+        verifiedRevision: string | null;
+        verifiedAt: string | null;
+    };
+};
 interface LeaseSnapshot {
     id: string;
     sandboxGroupId: string;
@@ -3895,8 +4069,20 @@ interface LeaseSnapshot {
     dataPlaneUrl: string | null;
     terminalDataPlaneUrl: string | null;
     leaseEpoch: number;
+    /** Monotonic filesystem mutation intent for the exact live workspace. */
+    workspaceGeneration: number;
+    /** Generation captured by the current verified archive, or null when no
+     * generation-complete archive exists. */
+    archiveGeneration: number | null;
+    /** True only when the current verified archive represents the exact current
+     * workspace generation. This is numeric/boolean truth, never archive content. */
+    archiveComplete: boolean;
     resumeBackendId: string | null;
     resumeState: Record<string, unknown> | null;
+    /** Provider/archive/restore/workspace truth, deliberately separate from the
+     * lease liveness and epoch fields above. Legacy envelopes project to
+     * conservative unknown/unverified values. */
+    recovery: SandboxRecoveryState;
     expiresAt: Date;
 }
 interface LiveModalSandboxLeaseAttribution {
@@ -3930,6 +4116,10 @@ type AcquireLeaseResult = {
 } | {
     role: "rearmed";
     lease: LeaseSnapshot;
+} | {
+    role: "blocked";
+    code: "restore_degraded" | "restore_unrecoverable";
+    lease: LeaseSnapshot;
 } | {
     role: "fenced";
     lease: LeaseSnapshot;
@@ -3939,6 +4129,14 @@ declare class SandboxLeaseSupersededError extends Error {
     readonly leaseEpoch: number;
     constructor(sandboxGroupId: string, leaseEpoch: number);
 }
+declare class SandboxLeaseRecoveryBlockedError extends Error {
+    readonly sandboxGroupId: string;
+    readonly leaseEpoch: number;
+    readonly code: "restore_degraded" | "restore_unrecoverable";
+    readonly recovery: SandboxRecoveryState;
+    readonly name = "SandboxLeaseRecoveryBlockedError";
+    constructor(sandboxGroupId: string, leaseEpoch: number, code: "restore_degraded" | "restore_unrecoverable", recovery: SandboxRecoveryState);
+}
 declare class SandboxImageConflictError extends Error {
     readonly sandboxGroupId: string;
     readonly currentImage: string;
@@ -3952,6 +4150,60 @@ declare class SandboxRigConflictError extends Error {
     constructor(sandboxGroupId: string, currentRigVersionId: string, requestedRigVersionId: string);
 }
 declare function acquireLease(db: Database, input: AcquireLeaseInput): Promise<AcquireLeaseResult>;
+type BeginSandboxRematerializationResult = {
+    status: "started";
+    lease: LeaseSnapshot;
+} | {
+    status: "blocked";
+    code: "archive_unavailable" | "archive_unverified" | "archive_generation_mismatch" | "attempt_conflict" | "stale_epoch";
+    lease: LeaseSnapshot | null;
+};
+/** Records the single cold->warming winner's exact restore attempt. The lease
+ * election remains the sole spawner guard; this adds durable selected-revision
+ * and progress truth under the same epoch. */
+declare function beginSandboxRematerialization(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    rematerializationId: string;
+    /** Optional durable per-session fallback envelope. When the lease has no
+     *  archive yet, its archive fields are imported under this same row lock so
+     *  restoration can never consume bytes that were not durably selected by
+     *  the lease attempt. Provider/session state is never imported here. */
+    archiveSource?: Record<string, unknown> | null;
+}): Promise<BeginSandboxRematerializationResult>;
+declare function markSandboxRestoreVerifying(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    rematerializationId: string;
+}): Promise<{
+    wrote: boolean;
+}>;
+declare function failSandboxRematerialization(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    rematerializationId: string;
+    failureCode: string;
+    retryable: boolean;
+}): Promise<{
+    failed: boolean;
+    lease: LeaseSnapshot | null;
+}>;
+declare function markSandboxProviderReady(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+}): Promise<{
+    wrote: boolean;
+    lease: LeaseSnapshot | null;
+}>;
 declare function commitWarmingToWarm(db: Database, input: {
     accountId: string;
     workspaceId: string;
@@ -3961,16 +4213,28 @@ declare function commitWarmingToWarm(db: Database, input: {
     dataPlaneUrl?: string | null;
     resumeBackendId?: string | null;
     resumeState?: Record<string, unknown> | null;
+    /** Required when the warming lease carries a selected durable archive.
+     *  The warm transition is rejected unless this exact attempt is in the
+     *  verifying state for this exact revision. */
+    rematerialization?: {
+        id: string;
+        verifiedRevision: string;
+    };
     leaseTtlMs: number;
 }): Promise<{
     committed: boolean;
     lease: LeaseSnapshot | null;
+    reason?: "stale_epoch" | "rematerialization_required" | "rematerialization_mismatch" | "archive_revision_mismatch" | "archive_generation_mismatch";
 }>;
 declare function recordWarmingSandboxCreated(db: Database, input: {
     accountId: string;
     workspaceId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
+    /** Exact restore attempt elected before provider create. Null for a fresh
+     *  archive-less create. Provider attribution is accepted only while the
+     *  warming row still carries this same attempt as well as this epoch. */
+    rematerializationId?: string | null;
     instanceId: string;
     resumeBackendId?: string | null;
     resumeState?: Record<string, unknown> | null;
@@ -4010,6 +4274,8 @@ declare function markWarmLeaseInstanceLost(db: Database, input: {
     sandboxGroupId: string;
     expectedEpoch: number;
     expectedInstanceId: string;
+    /** Bounded classifier output only; never raw provider error text. */
+    diagnostic?: string;
 }): Promise<MarkWarmLeaseInstanceLostResult>;
 declare function failWarmingToCold(db: Database, input: {
     accountId: string;
@@ -4069,6 +4335,7 @@ declare function reapStaleLeaseHolders(db: Database, input: {
     idleGraceMs: number;
 }): Promise<{
     reapedViewers: number;
+    reapedDirect: number;
     reapedTurns: number;
     warmingReset: number;
     drained: ReapDrainable[];
@@ -4109,22 +4376,284 @@ declare function confirmDrainCold(db: Database, input: {
     workspaceId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
+    /** Definitive provider NotFound before this drain could capture /workspace.
+     *  With no durable archive this must become typed unrecoverable, never a
+     *  clean cold lease that can expose an empty replacement. */
+    providerMissingBeforeCapture?: boolean;
 }): Promise<{
     wentCold: boolean;
 }>;
+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";
+    constructor(code: "attempt_fenced" | "holder_fenced" | "lease_fenced" | "route_fenced" | "process_fenced" | "admission_fenced" | "operation_invalid" | "generation_exhausted", message: string);
+}
+type SandboxWorkspaceMutationAdmission = {
+    id: string;
+    leaseId: string;
+    sandboxGroupId: string;
+    sessionId: string;
+    actorKind: "turn" | "direct" | "process";
+    actorId: string;
+    holderKind: "turn" | "direct" | "process";
+    holderId: string;
+    leaseEpoch: number;
+    providerBackend: string;
+    providerInstanceId: string;
+    routeKind: "home" | "active";
+    routeTargetId: string | null;
+    routeEpoch: number;
+    workspaceGeneration: number;
+};
+type SandboxWorkspaceMutationProviderOutcome = "resolved" | "rejected";
+type SandboxRetainedProcessState = "active" | "exited" | "lost";
+type SandboxRetainedProcess = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    leaseId: string;
+    sandboxGroupId: string;
+    parentAdmissionId: string;
+    holderId: string;
+    ownerActorKind: "turn" | "direct";
+    ownerActorId: string;
+    ownerTurnId: string | null;
+    ownerAttemptId: string | null;
+    ownerExecutionGeneration: number | null;
+    leaseEpoch: number;
+    providerBackend: string;
+    providerInstanceId: string;
+    routeKind: "home" | "active";
+    routeTargetId: string | null;
+    routeEpoch: number;
+    providerSessionId: number;
+    state: SandboxRetainedProcessState;
+    exitCode: number | null;
+    settlementReason: string | null;
+    startedAt: string;
+    settledAt: string | null;
+};
+/**
+ * Advance the live workspace's mutation generation before an acknowledged
+ * filesystem-writing operation reaches the provider. The normal activity write
+ * fence is acquired first (workspace control -> workspace -> session -> turn ->
+ * attempt), then the exact lease row is updated under its epoch + provider-id
+ * predicates. Any failed fence rejects the operation before external effects.
+ */
+declare function advanceWorkspaceGeneration(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+    attemptId: string;
+    holderId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    operation: string;
+    /** Active-routed mutations bind to the exact session pointer. Omitted means
+     * an intentional home-provider write outside the routing surface. */
+    routeKind?: "home" | "active";
+    routeTargetId?: string | null;
+    routeEpoch?: number;
+}): Promise<SandboxWorkspaceMutationAdmission>;
+/** Admit an API/direct mutation under an exact request holder and active route.
+ * Direct actors intentionally have no turn identity and can never inherit the
+ * attempt-quiescence archive fallback. */
+declare function advanceWorkspaceGenerationForDirectRequest(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    requestId: string;
+    holderId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    routeTargetId: string | null;
+    routeEpoch: number;
+    operation: string;
+}): Promise<SandboxWorkspaceMutationAdmission>;
+/** Admit one model/user-visible stdin write for an exact retained process. The
+ * process's original provider and route are authoritative even if the session's
+ * active pointer has since moved. */
+declare function advanceWorkspaceGenerationForRetainedProcess(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+    operation: string;
+}): Promise<SandboxWorkspaceMutationAdmission>;
+/** Physically settle one exact provider mutation admission after its promise
+ * resolves or rejects. Rejections need no output acceptance, but still clear
+ * the in-flight capture blocker. Resolved output is accepted only after the
+ * canonical attempt fence plus the exact live lease-holder/provider identity
+ * are revalidated. A failed acceptance fence is reported only AFTER the
+ * settlement transaction commits, so stale output can be rejected without
+ * resurrecting the physical blocker. */
+declare function verifyWorkspaceMutationSettlement(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+    attemptId: string;
+    holderId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    admission: SandboxWorkspaceMutationAdmission;
+    operation: string;
+    outcome: SandboxWorkspaceMutationProviderOutcome;
+    routeKind?: "home" | "active";
+    routeTargetId?: string | null;
+    routeEpoch?: number;
+}): Promise<void>;
+declare function verifyDirectWorkspaceMutationSettlement(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    requestId: string;
+    holderId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    routeTargetId: string | null;
+    routeEpoch: number;
+    admission: SandboxWorkspaceMutationAdmission;
+    operation: string;
+    outcome: SandboxWorkspaceMutationProviderOutcome;
+}): Promise<void>;
+declare function verifyRetainedProcessMutationSettlement(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+    admission: SandboxWorkspaceMutationAdmission;
+    operation: string;
+    outcome: SandboxWorkspaceMutationProviderOutcome;
+}): Promise<void>;
+/** Promote one yielded provider exec into durable process authority. The parent
+ * admission stays unsettled (`retained`) and a process holder is inserted in the
+ * same transaction, so ordinary request/turn cleanup cannot open archive capture. */
+declare function retainWorkspaceMutationProcess(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+    providerSessionId: number;
+    admissionId: string;
+    admittedWorkspaceGeneration: number;
+    operation: string;
+    owner: {
+        kind: "turn";
+        turnId: string;
+        executionGeneration: number;
+        attemptId: string;
+        holderId: string;
+        sandboxGroupId: string;
+        expectedEpoch: number;
+        expectedInstanceId: string;
+        routeKind?: "home" | "active";
+        routeTargetId?: string | null;
+        routeEpoch?: number;
+    } | {
+        kind: "direct";
+        requestId: string;
+        holderId: string;
+        sandboxGroupId: string;
+        expectedEpoch: number;
+        expectedInstanceId: string;
+        routeTargetId: string | null;
+        routeEpoch: number;
+    };
+}): Promise<SandboxRetainedProcess>;
+/** Read one retained process by durable UUID. Callers must use the copied route
+ * identity; a numeric provider session id alone is never sufficient authority. */
+declare function getRetainedProcess(db: Database, input: {
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+}): Promise<SandboxRetainedProcess | null>;
+/** 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
+ * fails closed. */
+declare function settleRetainedProcess(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    processId: string;
+    outcome: "exited" | "lost";
+    exitCode?: number | null;
+    reason: string;
+    idleGraceMs: number;
+}): Promise<{
+    settled: boolean;
+    process: SandboxRetainedProcess;
+}>;
+/** Read the exact generation a verified capture must later fold. This is a
+ * preflight only: persistWarmSnapshot/persistDrainSnapshot repeat the full
+ * epoch, provider, liveness, and generation CAS under the archive-fold lock. */
+declare function readWorkspaceArchiveCapturePreflight(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    liveness: "warm" | "draining";
+}): Promise<{
+    workspaceGeneration: number;
+    archiveGeneration: number | null;
+    archiveComplete: boolean;
+} | null>;
 declare function persistDrainSnapshot(db: Database, input: {
     accountId: string;
     workspaceId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
+    expectedInstanceId: string;
+    expectedWorkspaceGeneration: number;
     /** base64 of the provider snapshot-ref / tar archive from persistWorkspace().
-     *  Pass null to CAS-check without writing (for backends with no persistWorkspace). */
+     *  Pass null only to CAS-check without writing; this does not certify that
+     *  provider termination is lossless. */
     workspaceArchive: string | null;
+    /** Exact verified archive/tree descriptor produced by the runtime capture.
+     *  Omission is accepted only for legacy callers and remains unverified. */
+    workspaceArchiveMeta?: SandboxArchiveRevision;
 }): Promise<{
     wrote: boolean;
-    priorArchive: string | null;
-    priorArchivePrev: string | null;
+    priorArchiveForGc: string | null;
+    archiveRevision: string | null;
 }>;
+/**
+ * The ONE archive-fold write, shared by the drain seam (persistDrainSnapshot)
+ * and the mid-session seam (persistWarmSnapshot) — the two differ only in
+ * their CAS guard (draining@refcount0 vs warm) and their read-side semantics.
+ *
+ * Merges the NEW archive (+ its workspaceArchiveAt timestamp, the throttle
+ * baseline for mid-session snapshots) into resume_state.sessionState.
+ * jsonb_set's create_missing does NOT create intermediate objects, so a direct
+ * set of '{sessionState,workspaceArchive}' is a silent no-op when
+ * `sessionState` is absent (a null resume_state, or a legacy flat envelope).
+ * Instead: rebuild `sessionState` as (existing sessionState OR '{}') merged
+ * (||) with the fold — this CREATES sessionState if absent AND preserves its
+ * existing siblings (providerState/manifest/exposedPorts). The archive is
+ * bound as a jsonb string scalar (to_jsonb(text)). Re-asserting the caller's
+ * CAS guard keeps the write atomic with its FOR UPDATE lock. Archive-slot
+ * rotation is computed by rotateWorkspaceArchives before this writer is called,
+ * so the warm and drain seams use exactly the same retention policy.
+ */
+declare function rotateWorkspaceArchives(input: {
+    resumeState: Record<string, unknown> | null;
+    priorCurrentArchive: string | null;
+    priorPreviousArchive: string | null;
+}): {
+    previousArchive: string | null;
+    previousArchiveMeta: SandboxArchiveRevision | null;
+    priorArchiveForGc: string | null;
+};
 /**
  * MID-SESSION /workspace snapshot fold (sandbox-file-persistence). The WARM
  * sibling of persistDrainSnapshot: a turn that HOLDS the live box folds a fresh
@@ -4144,8 +4673,13 @@ declare function persistWarmSnapshot(db: Database, input: {
     attemptId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
+    expectedInstanceId: string;
+    expectedWorkspaceGeneration: number;
     /** base64 of the provider snapshot-ref / tar archive from persistWorkspace(). */
     workspaceArchive: string;
+    /** Exact verified archive/tree descriptor produced by the runtime capture.
+     *  Omission is accepted only for legacy callers and remains unverified. */
+    workspaceArchiveMeta?: SandboxArchiveRevision;
     /** Snapshots newer than this many ms are kept (throttle); 0 = always write. */
     minIntervalMs: number;
     /** Wall-clock (ms) this capture STARTED. Ordering is by capture-initiation,
@@ -4159,6 +4693,7 @@ declare function persistWarmSnapshot(db: Database, input: {
     throttled: boolean;
     superseded: boolean;
     priorArchiveForGc: string | null;
+    archiveRevision: string | null;
 }>;
 declare function getMaterializedSandboxFileResources(db: Database, input: {
     accountId: string;
@@ -4702,6 +5237,23 @@ type CreateSessionGoalInput = {
 };
 declare function createSessionGoal(db: Database, input: CreateSessionGoalInput): Promise<SessionGoal>;
 declare function getSessionGoal(db: Database, workspaceId: string, sessionId: string): Promise<SessionGoal | null>;
+type SessionGoalContinuationProjection = {
+    state: "inactive" | "scheduled" | "running" | "blocked" | "invariant_broken";
+    reason: "goal_inactive" | "wake_pending" | "continuation_pending" | "human_work_pending" | "goal_turn_running" | "human_turn_running" | "workstream_paused" | "approval_required" | "provider_backpressure" | "session_cancelled" | "system_work_pending" | "missing_obligation";
+    wakeRevision: number;
+    observedRevision: number;
+    nextAttemptAt: string | null;
+    lastError: string | null;
+};
+/**
+ * Read the goal and its autonomy state from one repeatable Postgres snapshot.
+ * The projection never infers liveness from the public session status alone:
+ * goal revisions, typed internal updates/turns, capacity waiters, admission
+ * control, and the workflow-wake delivery ledger each remain distinct truth.
+ */
+declare function getSessionGoalWithContinuation(db: Database, workspaceId: string, sessionId: string): Promise<(SessionGoal & {
+    continuation: SessionGoalContinuationProjection;
+}) | null>;
 declare function clearSessionGoal(db: Database, workspaceId: string, sessionId: string): Promise<{
     cleared: boolean;
     goal: SessionGoal | null;
@@ -4717,6 +5269,19 @@ declare function upsertSessionGoal(db: Database, input: CreateSessionGoalInput):
     goal: SessionGoal;
     replaced: boolean;
 }>;
+/**
+ * Agent/API goal_set: session sequence ownership, the create-or-replace
+ * mutation, and goal.set timeline fact commit together. The session-first lock
+ * order matches active-turn event writes; goal_set must never hold a goal row
+ * while waiting for the session sequence owner.
+ */
+declare function upsertSessionGoalWithEvent(db: Database, input: CreateSessionGoalInput & {
+    actor: "agent" | "api";
+}): Promise<{
+    goal: SessionGoal;
+    replaced: boolean;
+    events: SessionEvent[];
+}>;
 /**
  * goal_update semantics: revise text/criteria without changing status. The
  * version bump counts as progress for the no-progress detector.
@@ -4725,6 +5290,30 @@ declare function updateSessionGoal(db: Database, workspaceId: string, sessionId:
     text?: string;
     successCriteria?: string | null;
 }): Promise<SessionGoal>;
+/**
+ * Agent goal_update: session sequence ownership, goal mutation, and its audit
+ * event commit together. Locking the session before the goal also matches an
+ * active turn's event-write order and avoids the workspace->session inversion
+ * that previously self-locked root goal mutations.
+ */
+declare function updateSessionGoalWithEvent(db: Database, workspaceId: string, sessionId: string, input: {
+    text?: string;
+    successCriteria?: string | null;
+    progressNote?: string;
+    actor: "agent" | "api";
+    command?: {
+        accountId: string;
+        actor: Extract<SessionCommandActor, {
+            type: "agent_attempt";
+        }>;
+        operationKey: string;
+    };
+}): Promise<{
+    goal: SessionGoal;
+    events: SessionEvent[];
+    operationId: string | null;
+    replay: boolean;
+}>;
 /**
  * Sets a session's display title. The clobber guard lives entirely in this
  * single atomic UPDATE: a user-set title is permanent, so agent/auto writes
@@ -4762,6 +5351,31 @@ declare function setSessionGoalStatus(db: Database, workspaceId: string, session
     changed: boolean;
     workflowWakeRevision: number | null;
 }>;
+type SetSessionGoalStatusEvent = {
+    type: "goal.completed";
+    evidence: string;
+} | {
+    type: "goal.paused";
+    actor: "agent" | "api";
+    reason: string;
+    rationale?: string;
+} | {
+    type: "goal.resumed";
+    actor: "api";
+};
+/** Status mutation and its timeline fact share the same session-first commit. */
+declare function setSessionGoalStatusWithEvent(db: Database, workspaceId: string, sessionId: string, input: {
+    status: SessionGoalStatus;
+    evidence?: string;
+    rationale?: string;
+    pausedReason?: string;
+    event: SetSessionGoalStatusEvent;
+}): Promise<{
+    goal: SessionGoal;
+    changed: boolean;
+    workflowWakeRevision: number | null;
+    events: SessionEvent[];
+}>;
 declare function setSessionGoalLastContinuationTurn(db: Database, workspaceId: string, sessionId: string, turnId: string): Promise<void>;
 type GoalContinuationDecision = {
     decision: "none";
@@ -4792,6 +5406,45 @@ declare function evaluateGoalContinuation(db: Database, input: {
     noProgressLimit: number;
     budgetBlocked?: string | null;
 }): Promise<GoalContinuationDecision>;
+type MaterializeGoalContinuationResult = {
+    action: "none" | "queue";
+    events: [];
+} | {
+    action: "paused";
+    events: SessionEvent[];
+} | {
+    action: "continue";
+    events: SessionEvent[];
+    update: SessionSystemUpdate;
+    goalWakeRevision: number;
+    workflowWakeRevision: number;
+};
+/**
+ * Consume one durable goal-wake revision into one continuation obligation.
+ *
+ * This is deliberately one outer PostgreSQL transaction. The existing locked
+ * evaluator runs as a nested savepoint, so its no-progress/counter mutation is
+ * rolled back if prompt construction, update/event insertion, metering, or the
+ * workflow-wake outbox write fails. Retrying after a lost COMMIT response sees
+ * the same stable goal revision and the already-pending update; it never spends
+ * another continuation count or creates another usage row.
+ */
+declare function materializeGoalContinuation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    workflowId: string;
+    defaultMaxAutoContinuations?: number | null;
+    noProgressLimit: number;
+    budgetBlocked?: string | null;
+    policy: {
+        model: string;
+        reasoningEffort: ReasoningEffort;
+        tools: ToolRef[];
+        sandboxBackend: SandboxBackend;
+    };
+    prompt: (goal: SessionGoal, autoContinuation: number, cap: number | null) => string;
+}): Promise<MaterializeGoalContinuationResult>;
 type InitializeSessionStartInput = {
     accountId: string;
     workspaceId: string;
@@ -4806,6 +5459,10 @@ type InitializeSessionStartInput = {
         successCriteria?: string | null;
         maxAutoContinuations?: number | null;
     } | null;
+    consumeNewSessionDraft?: {
+        subjectId: string;
+        expectedRevision: number;
+    } | null;
 };
 type InitializeSessionStartResult = {
     events: SessionEvent[];
@@ -5360,4 +6017,4 @@ type LockedSessionUpdateResult = {
 declare function appendSessionEventsWithLockedSessionUpdate(db: Database, workspaceId: string, sessionId: string, build: (session: Session, context: LockedSessionUpdateContext) => LockedSessionUpdateResult | Promise<LockedSessionUpdateResult>): Promise<SessionEvent[]>;
 declare function sessionSubject(workspaceId: string, sessionId: string): string;
 
-export { type CodexResetRedemptionRecovery as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BootstrapWorkspaceInput as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type CodexAllocatorUpdateResult as D, type CodexAuthDeps as E, type CodexCapacityAvailabilityDecision as F, type CodexCapacityMutationResult as G, type CodexCapacityResetKind as H, type CodexCapacitySelectionContext as I, type CodexCapacityWait as J, type CodexCapacityWaitStatus as K, type CodexCapacityWakeTarget as L, type CodexCredentialForRun as M, type CodexCredentialLeaseCandidateFilter as N, type CodexCredentialLeaseCandidateFilterResult as O, type CodexCredentialLeasePolicyScopeResolver as P, type ProvisionResult, type ProvisionRolesOptions, type CodexCredentialLeaseQuarantine as Q, type CodexCredentialLeaseResult as R, type CodexCredentialLeaseSelection as S, type CodexCredentialLeaseSelectionContext as T, type CodexCredentialStatus as U, type CodexCredentialTokens as V, type CodexLeaseAccountStatus as W, type CodexPinSource as X, type CodexRateLimitResetCreditsAccountResult as Y, type CodexResetRedemptionAttempt as Z, type CodexResetRedemptionOutcome as _, type AcceptSessionApprovalDecisionResult as a, type LeaseHolderKind as a$, type CodexResetRedemptionSendNotReadyReason as a0, type CodexResetRedemptionStatus as a1, type CodexRotationSettings as a2, type CodexRotationStrategy as a3, type CodexTokenDeadlineClock as a4, type CodexTokenDeadlineOptions as a5, type ComposerDraftRow as a6, type ConnectionBrokerDeps as a7, type ConnectionCredentialForBroker as a8, ConnectionRefreshHttpError as a9, type EnabledMcpCapabilityServer as aA, type EnqueueSessionTurnInput as aB, type EnrollmentExposure as aC, type EnrollmentOs as aD, type EnrollmentRecord as aE, type EnrollmentStatus as aF, type ExpiredFileUploadCleanupClaim as aG, type FenceCodexResetRedemptionSendResult as aH, type FileUploadCleanupClaimResult as aI, type ForceDrainResult as aJ, type FrozenTurnInitiator as aK, type GitHubInstallation as aL, type GitHubInstallationAccess as aM, type GoalContinuationDecision as aN, type HostExportConsumerStatus as aO, type HostExportKind as aP, HostExportPayloadError as aQ, HostMcpCredentialBindingError as aR, type HostMcpCredentialResolverContext as aS, HostMcpCredentialScopeError as aT, HumanInputResponseValidationError as aU, type IdempotentPersistenceTransactionOptions as aV, type ImportBatch as aW, type InitializeSessionStartInput as aX, type InitializeSessionStartResult as aY, type InstallOrReadTurnExecutionPolicyForAttemptResult as aZ, type IntegrationOAuthClientForUse as a_, type ConsumeOAuthStateNonceInput as aa, type CorrectWorkspaceMemoryInput as ab, type CorrectWorkspaceMemoryResult as ac, type CreateCapabilityCatalogItemInput as ad, type CreateConnectionInput as ae, type CreateDbOptions as af, type CreateImportBatchInput as ag, type CreateKnowledgeMemoryInput as ah, type CreatePackInstallationInput as ai, type CreateScheduledTaskInput as aj, type CreateSessionGoalInput as ak, type CreateSessionMcpServerInput as al, type CreateSocialConnectionInput as am, type CreateSocialPostInput as an, type CreditBalanceByAccount as ao, type Database as ap, type DatabaseFailureCode as aq, type DbClient as ar, type DeviceEnrollmentRequestRecord as as, type DeviceEnrollmentStatus as at, type EditQueueCommandResult as au, type EffectiveControlBlocker as av, type EffectiveControlResumeOption as aw, type EffectiveControlState as ax, type EffectiveSessionControl as ay, type EnableCapabilityInstallationInput as az, type AcceptSessionHumanInputResponseResult as b, SESSION_DISCOVERY_GOAL_MAX_CHARS as b$, type LeaseSnapshot as b0, type ListKnowledgeMemoryOptions as b1, type ListSessionEventPageOptions as b2, type ListSessionEventsOptions as b3, type ListSessionsForSubjectOptions as b4, type ListSessionsOptions as b5, type LiveModalSandboxLeaseAttribution as b6, MACHINE_METRICS_SERIES_INTERVAL_MS as b7, MAX_INTERNAL_UPDATE_BATCH_BYTES as b8, MAX_INTERNAL_UPDATE_BATCH_MEMBERS as b9, type QueueCommandResult as bA, type QueuedTurnRow as bB, type ReapDrainable as bC, type ReconcileCodexCapacityWaitResult as bD, type RecoverSessionDispatchInput as bE, type RecoverSessionDispatchResult as bF, type RefreshTransportOptions as bG, type RegisterWorkspacePackInput as bH, type RegistryCapabilityCatalogItemInput as bI, type RegistryCatalogSurfaceKey as bJ, type ReplaceIntegrationOAuthClientInput as bK, type RequestSessionTurnRecoveryInput as bL, type RequestSessionTurnRecoveryResult as bM, type ResolveConnectionCredentialInput as bN, type ResolveConnectionCredentialResult as bO, type RetainedFileArtifact as bP, RigActiveVersionChangedError as bQ, RigChangeAlreadyVerifyingError as bR, type RigChangeMonitoringSummary as bS, RigChangeTransitionError as bT, type RigVersionContentInput as bU, type RigVersionMonitoringSummary as bV, type RlsContext as bW, type RlsStrategy as bX, SESSION_ANCESTRY_LIMIT as bY, SESSION_DISCOVERY_CONTROL_TARGET_LIMIT as bZ, SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS as b_, MAX_INTERNAL_UPDATE_BYTES as ba, MEMORY_ACTIVE_RECORD_CAP as bb, MEMORY_BLOCK_KIND_ORDER as bc, MEMORY_BLOCK_RECORD_LIMIT as bd, MEMORY_CORRECT_TOOL_DESCRIPTION as be, MEMORY_KIND_SECTION_TITLES as bf, MEMORY_NEAR_DUP_COSINE_THRESHOLD as bg, MEMORY_NEAR_DUP_NEIGHBORS as bh, MEMORY_SAVE_TOOL_DESCRIPTION as bi, MEMORY_SEARCH_DEFAULT_LIMIT as bj, MEMORY_SEARCH_MAX_LIMIT as bk, MEMORY_SEARCH_TOOL_DESCRIPTION as bl, MEMORY_TEXT_MAX_CHARS as bm, MEMORY_VISIBLE_RECORD_CAP as bn, type MachineMetricsRow as bo, type MachineMetricsSample as bp, type MarkWarmLeaseInstanceLostResult as bq, type MemoryBlockRecord as br, type MemoryEmbedder as bs, type MemorySanitizeResult as bt, type MeterableWarmLease as bu, type PendingSessionToolCallInput as bv, type PersistenceFailureDetails as bw, type PersistenceRetryOutcome as bx, type QueueCommandConflictCode as by, QueueCommandConflictError as bz, type AccrueWarmSecondsResult as c, type UpdateKnowledgeMemoryInput as c$, SESSION_DISCOVERY_MESSAGE_MAX_CHARS as c0, SESSION_EVENT_DB_PAGE_MAX_BYTES as c1, type SafeDatabaseErrorFacts as c2, SandboxImageConflictError as c3, type SandboxKind as c4, type SandboxLeaseLiveness as c5, SandboxLeaseSupersededError as c6, type SandboxPtySessionRow as c7, type SandboxRecord as c8, SandboxRigConflictError as c9, SessionPinAccessError as cA, SessionPinVersionConflictError as cB, type SessionRecordingCodec as cC, type SessionRecordingMode as cD, type SessionRecordingRow as cE, type SessionRecordingState as cF, type SessionSystemUpdateOutboxDelivery as cG, type SessionTurnAttemptOutcome as cH, type SessionTurnForExecution as cI, type SessionTurnRecordingSettlement as cJ, type SessionWorkPeek as cK, type SessionWorkTrigger as cL, type SessionWorkflowWake as cM, type SessionWorkflowWakeDeliveryResult as cN, type SetSessionCodexPinOptions as cO, type SettleCodexCredentialFailoverResult as cP, type SettleCodexCredentialLeaseLossResult as cQ, type SteerQueueCommandResult as cR, type StoreIntegrationOAuthClientInput as cS, type StoredIntegrationOAuthClient as cT, type StreamAcknowledgment as cU, type SubmitHumanPromptResult as cV, type ToolspaceCallReservation as cW, type ToolspaceTurnAttemptClaims as cX, type TurnAttemptFenceRejectReason as cY, type UpdateConnectionInput as cZ, type UpdateImportBatchCountsInput as c_, SanitizedDatabasePersistenceCause as ca, type SaveWorkspaceMemoryInput as cb, type SaveWorkspaceMemoryResult as cc, type SessionAttemptInterruptionSettlement as cd, type SessionCodexState as ce, type SessionCommandActor as cf, SessionCommandIdempotencyError as cg, type SessionCommandReceiptRow as ch, SessionContextBusyError as ci, SessionControlConflictError as cj, SessionControlInvariantError as ck, type SessionControlMutationResult as cl, type SessionDiscoveryControl as cm, type SessionDiscoveryCursor as cn, type SessionDiscoveryOrderBy as co, type SessionDiscoverySummary as cp, type SessionEventPage as cq, SessionEventPersistenceError as cr, type SessionEventWriteLockInput as cs, type SessionEventWriteLocks as ct, SessionIdConflictError as cu, type SessionLineage as cv, SessionListAccessError as cw, type SessionListCursor as cx, SessionListCursorError as cy, type SessionMcpServerForRun as cz, type AcquireLeaseInput as d, claimExpiredFileUploadCleanup as d$, type UpdateScheduledTaskInput as d0, type UpdateSessionMcpApprovalPolicyResult as d1, type UpdateSessionMcpServerCredentialsInput as d2, type UpdateSessionMcpServerCredentialsResult as d3, type UpsertCodexSubscriptionCredentialResult as d4, type UserLookup as d5, type VariableSetForRun as d6, WORKSPACE_MEMORY_BLOCK_EMPTY as d7, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as d8, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as d9, adoptCodexResetRedemptionAttempt as dA, allAccountPermissions as dB, allWorkspacePermissions as dC, appendSessionEventToSandboxGroup as dD, appendSessionEvents as dE, appendSessionEventsAndUpdateSession as dF, appendSessionEventsForTurnAttempt as dG, appendSessionEventsWithLockedSessionUpdate as dH, appendSessionHistoryItems as dI, applyContextCompaction as dJ, applyCreditDebitUpToBalance as dK, applyCreditLedgerEntry as dL, applySessionTurnSettlement as dM, approveDeviceEnrollmentRequest as dN, areGitHubRepositoriesAllowedForWorkspace as dO, armCodexCapacityWait as dP, assertAgentCommandAuthorityInTransaction as dQ, autoResumeSessionBranchInTransaction as dR, beginRigChangeVerificationAttempt as dS, bindGitHubInstallationRepositories as dT, bootstrapWorkspace as dU, buildChildCompletionDigest as dV, buildCodexTokenResolver as dW, buildConnectionTokenResolver as dX, buildHostConnectionTokenResolver as dY, canonicalSessionCommandHash as dZ, claimCodexResetRedemption as d_, type WorkspaceCaptureCommitResult as da, type WorkspaceCaptureGcPlan as db, type WorkspaceCaptureGcRow as dc, type WorkspaceCaptureRow as dd, type WorkspaceControlLockMode as de, type WorkspaceControlMutationResult as df, type WorkspaceControlRow as dg, type WorkspaceEnvironmentForRun as dh, type WorkspaceMemoryOrigin as di, type WorkspaceMemorySearchInput as dj, type WorkspaceMemorySearchMode as dk, type WorkspaceMemorySearchResult as dl, type WorkspaceModelPolicy as dm, abandonCodexResetRedemptionBeforeProvider as dn, abandonRecordingForTurnAttempt as dp, acceptSessionApprovalDecision as dq, acceptSessionHumanInputResponse as dr, accrueWarmSeconds as ds, acknowledgeHostExportBatch as dt, acquireCodexCredentialLease as du, acquireLease as dv, activateRigVersion as dw, addSessionSystemUpdate as dx, addSessionSystemUpdateWithSourceMutation as dy, admitToolspaceTurnAttempt as dz, type AcquireLeaseResult as e, createWorkspace as e$, claimFileUploadCleanup as e0, claimHostExportBatch as e1, claimPendingSessionSystemUpdateOutbox as e2, claimPendingSessionWorkflowWakes as e3, claimSessionWorkForAttempt as e4, clearDurablePendingSessionToolCalls as e5, clearEnrollmentWentOffline as e6, clearPendingSessionToolspaceCall as e7, clearSessionContext as e8, clearSessionGoal as e9, countSessionHistoryItems as eA, countSessionsUsingRig as eB, countVariableSets as eC, countWorkspaceEnvironments as eD, countWorkspacesForAccount as eE, createApiKey as eF, createConnection as eG, createDb as eH, createDeviceEnrollmentRequest as eI, createEnrollment as eJ, createFileUpload as eK, createImportBatch as eL, createKnowledgeMemory as eM, createRig as eN, createRigChange as eO, createRigVersion as eP, createRigVersionForChangePromotion as eQ, createSandbox as eR, createScheduledTask as eS, createScheduledTaskRun as eT, createSession as eU, createSessionGoal as eV, createSessionMcpServers as eW, createSessionWithIdempotencyKey as eX, createSocialConnection as eY, createSocialPost as eZ, createVariableSet as e_, clearedContextMarkerItem as ea, closePtySession as eb, closeSessionTurnAttemptInTransaction as ec, codexCapacityRefreshBackoffMs as ed, commitWarmingToWarm as ee, completeCodexResetRedemption as ef, completeExpiredFileUploadCleanup as eg, completeFileUpload as eh, completeFileUploadCleanup as ei, computeWorkspaceCaptureGcPlan as ej, confirmDrainCold as ek, consumeDeviceEnrollmentRequest as el, consumeIntegrationOAuthStateNonce as em, correctWorkspaceMemory as en, countActiveApiKeysForWorkspace as eo, countActiveSessionHistoryItems as ep, countActiveSessionsForWorkspace as eq, countActiveSessionsUsingEnvironment as er, countActiveSessionsUsingVariableSet as es, countConsecutiveReactiveRotations as et, countQueuedTurns as eu, countRigs as ev, countSandboxLeasesByLiveness as ew, countScheduledTasksForWorkspace as ex, countScheduledTasksUsingEnvironment as ey, countScheduledTasksUsingVariableSet as ez, type ActiveSandboxPointer as f, getDeviceEnrollmentRequestByDeviceCode as f$, createWorkspaceEnvironment as f0, databaseFailureCode as f1, deadLetterHostExportHead as f2, decodeSessionListCursor as f3, decryptEnvironmentValue as f4, decryptedCapabilityHeaders as f5, deleteGitHubInstallationBinding as f6, deleteRecording as f7, deleteRig as f8, deleteRigIfNoActiveSessions as f9, evaluateGoalContinuation as fA, evaluateSessionControl as fB, evaluateSessionControls as fC, evaluateSessionDiscoveryControls as fD, expireSessionHumanInputRequest as fE, failHostExportBatch as fF, failWarmingToCold as fG, fenceCodexResetRedemptionSend as fH, fetchCodexRateLimitResetCreditsForAccount as fI, fetchCodexUsageForAccount as fJ, finalizeEnrollmentByToken as fK, findActiveApiKeyByHash as fL, forceDrainOverLimitViewerOnlyBoxes as fM, frozenInitiatorForCommandActor as fN, getActiveSessionHistoryItems as fO, getActiveSessionTurnForExecution as fP, getAnySessionInGroup as fQ, getBillingBalance as fR, getBillingCustomer as fS, getCapabilityCatalogItem as fT, getCapabilityInstallation as fU, getCodexCapacityWaitForSession as fV, getCodexCredentialStatus as fW, getCodexResetRedemptionAttempt as fX, getCodexRotationSettings as fY, getComposerDraftInTransaction as fZ, getConnectionMetadata as f_, deleteScheduledTask as fa, deleteSessionQueueItemInTransaction as fb, deleteVariableSet as fc, deleteVariableSetVariable as fd, deleteWorkspace as fe, deleteWorkspaceCaptureRows as ff, deleteWorkspaceEnvironment as fg, deleteWorkspaceEnvironmentVariable as fh, deleteWorkspacePack as fi, denyDeviceEnrollmentRequest as fj, disableCapabilityInstallation as fk, disableHostExportConsumer as fl, disconnectAllCodexAccounts as fm, disconnectCodexAccount as fn, editQueuedTurnInTransaction as fo, enableCapabilityInstallation as fp, enablePackInstallation as fq, encodeSessionListCursor as fr, encryptEnvironmentValue as fs, enqueueSessionTurn as ft, enqueueSessionWorkflowWake as fu, enqueueSessionWorkflowWakeIfRunnable as fv, enqueueSessionWorkflowWakeInTransaction as fw, ensureCodexRotationSettings as fx, ensureManagedAccessForUser as fy, estimateMemoryTokens as fz, type AddSessionSystemUpdateInput as g, ingestMachineMetricsSample as g$, getEnrollment as g0, getFile as g1, getFileUpload as g2, getHostExportConsumerStatus as g3, getHumanInputResumeForEvent as g4, getKnowledgeMemory as g5, getLatestRunState as g6, getLatestStartedSessionTurn as g7, getManagedAccount as g8, getManagedUserByEmail as g9, getSessionLineage as gA, getSessionQueueSnapshot as gB, getSessionRootId as gC, getSessionSystemUpdateOutboxByDedupeKey as gD, getSessionTurn as gE, getSessionTurnForAttempt as gF, getSocialConnection as gG, getStoredCapabilityHeaderCiphertext as gH, getStreamAcknowledgment as gI, getVariableSet as gJ, getVariableSetByName as gK, getVariableSetValuesForRun as gL, getWorkspace as gM, getWorkspaceControlEvent as gN, getWorkspaceDefaultRigId as gO, getWorkspaceEnvironment as gP, getWorkspaceEnvironmentByName as gQ, getWorkspaceEnvironmentValuesForRun as gR, getWorkspaceGrant as gS, getWorkspaceModelPolicy as gT, getWorkspacePack as gU, grantWorkspaceAccess as gV, hasCreditLedgerEntry as gW, hashMemoryText as gX, heartbeatCodexCredentialLease as gY, heartbeatCodexCredentialLeaseUntil as gZ, heartbeatLeaseHolder as g_, getMaterializedSandboxFileResources as ga, getOpenPtySession as gb, getOrCreateSessionSystemUpdateOutbox as gc, getPackInstallation as gd, getPendingDeviceEnrollmentRequestByUserCode as ge, getPendingDeviceEnrollmentRequestByUserCodeGlobal as gf, getRecording as gg, getRetainedFileArtifact as gh, getRig as gi, getRigByName as gj, getRigChange as gk, getRigName as gl, getRigVersion as gm, getRigVersionById as gn, getSandbox as go, getSandboxSessionEnvelope as gp, getScheduledTask as gq, getSession as gr, getSessionByCreateIdempotencyKey as gs, getSessionCodexState as gt, getSessionEvent as gu, getSessionEventByClientEventId as gv, getSessionForSubject as gw, getSessionGoal as gx, getSessionHistoryItems as gy, getSessionHumanInputRequest as gz, type AddSessionSystemUpdateResult as h, listVariableSets as h$, initializeSessionStartAtomically as h0, insertFailedWorkspaceCapture as h1, insertMachineMetricsSeries as h2, insertPtySession as h3, insertRecording as h4, insertWorkspaceCapture as h5, installOrReadTurnExecutionPolicyForAttempt as h6, interruptedToolCallResult as h7, isCodexBilledTurn as h8, isDatabasePersistenceFailure as h9, listPendingCodexCapacityWakeTargets as hA, listPendingSessionTurns as hB, listRecordings as hC, listRegistryCatalogSurfaceKeys as hD, listRigChangeMonitoringSummaries as hE, listRigChanges as hF, listRigVersionMonitoringSummaries as hG, listRigVersions as hH, listRigs as hI, listSandboxes as hJ, listScheduledTaskRuns as hK, listScheduledTasks as hL, listSessionDiscoverySummaries as hM, listSessionEventPage as hN, listSessionEvents as hO, listSessionHumanInputRequests as hP, listSessionIdsInGroup as hQ, listSessionMcpServerMetadata as hR, listSessionMcpServersForChildInheritance as hS, listSessionMcpServersForRun as hT, listSessionSystemUpdatesForTurn as hU, listSessionTurns as hV, listSessions as hW, listSessionsForSubject as hX, listSocialConnections as hY, listSocialPosts as hZ, listUsageEvents as h_, isMemoryTextTooLong as ha, isRetryablePersistenceSqlState as hb, isSessionCompactionRequested as hc, isSessionEventPersistenceError as hd, isStripeWebhookProcessed as he, latestWorkspaceCapture as hf, listApiKeys as hg, listCapabilityCatalogItems as hh, listCapabilityInstallations as hi, listCodexAccountStatuses as hj, listCodexResetRedemptionRecoveries as hk, listConnectionsMetadata as hl, listCreditBalancesByAccount as hm, listDistinctRigVersionIdsInGroup as hn, listDistinctVariableSetIdsInGroup as ho, listEnabledMcpCapabilityServers as hp, listEnrollments as hq, listGitHubInstallationAccessForWorkspace as hr, listGitHubInstallationIdsForWorkspace as hs, listGitHubInstallationsForWorkspace as ht, listKnowledgeMemories as hu, listLiveModalSandboxLeaseAttributions as hv, listMeterableWarmLeases as hw, listOpenPtySessions as hx, listOutstandingSessionSystemUpdates as hy, listPackInstallations as hz, type AdoptCodexResetRedemptionResult as i, recordSkippedContextCompaction as i$, listWorkspaceControlEvents as i0, listWorkspaceEnvironments as i1, listWorkspaceMembers as i2, listWorkspacePacks as i3, listWorkspacesForSubject as i4, loadCodexCredentialForRun as i5, loadConnectionCredentialForBroker as i6, loadIntegrationOAuthClient as i7, loadVariableSetForRun as i8, loadWorkspaceEnvironmentForRun as i9, persistWarmSnapshot as iA, planWorkspaceCaptureGc as iB, projectEffectiveControlForRelatedAccess as iC, projectSessionForRelatedAccess as iD, pruneHostExportOutbox as iE, quarantineCodexCredentialForLease as iF, reArmDrainingLease as iG, readActiveSandbox as iH, readLease as iI, readMachineMetricsLatest as iJ, readMachineMetricsLatestForWorkspace as iK, readMachineMetricsSeries as iL, reapExpiredSessionListSnapshots as iM, reapStaleLeaseHolders as iN, reapStaleLeaseHoldersGlobal as iO, reconcileCodexCapacityWait as iP, recordAuditEvent as iQ, recordCodexAccountConnectors as iR, recordCodexAccountUsage as iS, recordCodexAccountUsageWithWakeTargets as iT, recordCodexTokenRefresh as iU, recordConnectionTokenRefresh as iV, recordConnectionUsed as iW, recordLeaseDataPlaneUrl as iX, recordLeaseTerminalDataPlaneUrl as iY, recordPendingSessionToolCallResult as iZ, recordSessionActiveCodexCredential as i_, lockSessionEventWriteRows as ia, lockWorkspaceInferenceControl as ib, markFileUploadFailed as ic, markSandboxFileResourcesMaterialized as id, markScheduledTaskRunFailedIfQueued as ie, markSessionAttemptQuiesced as ig, markSessionSystemUpdateOutboxDeliveredInTransaction as ih, markSessionSystemUpdateOutboxFailed as ii, markSessionWorkflowWakeDelivered as ij, markSessionWorkflowWakeFailed as ik, markStaleRegistryCatalogItems as il, markStripeWebhookProcessed as im, markWarmLeaseInstanceLost as io, mcpServerIdForCapability as ip, moveQueuedTurnInTransaction as iq, mutateSessionControlInTransaction as ir, mutateWorkspaceControlInTransaction as is, nestedPostgresSqlState as it, nextSessionHistoryPosition as iu, normalizeBearerScheme as iv, normalizeMemoryText as iw, orphanedResultRowIndicesForRepair as ix, peekSessionWork as iy, persistDrainSnapshot as iz, AgentCommandAuthorityError as j, setEnrollmentOpStreamState as j$, recordStreamAcknowledgment as j0, recordStripeWebhookEvent as j1, recordUsageEvent as j2, recordWarmingSandboxCreated as j3, recoverSessionDispatch as j4, refreshOAuthConnectionCredential as j5, registerDbBinding as j6, registerHostExportConsumer as j7, registerInternalUpdateWakeInTransaction as j8, registerPendingSessionToolCall as j9, rewindHostExportConsumer as jA, rlsContextForWorkspace as jB, rlsStrategyFor as jC, runIdempotentPersistenceTransaction as jD, safeDatabaseErrorFacts as jE, sanitizeEventPayload as jF, sanitizeEventString as jG, sanitizeMemoryText as jH, sanitizeModelPayload as jI, saveComposerDraftInTransaction as jJ, saveRunState as jK, saveWorkspaceMemory as jL, searchWorkspaceMemories as jM, sendAgentMessageInTransaction as jN, serializeEffectiveSessionControl as jO, sessionAuthorizationScopeFilter as jP, sessionSubject as jQ, sessionTreeStatsForSessions as jR, sessionsWithActiveOpOnEnrollment as jS, setActiveCodexCredential as jT, setActiveSandbox as jU, setCodexCredentialExhausted as jV, setCodexCredentialExhaustedWithWakeTargets as jW, setCodexCredentialStatus as jX, setCodexCredentialStatusById as jY, setConnectionStatus as jZ, setEnrollmentDisplayState as j_, registerSessionTurnAttemptClaim as ja, registerSessionWorkflowWakeInTransaction as jb, registerWorkspacePack as jc, releaseCodexCredentialLease as jd, releaseCodexResetRedemptionClaim as je, releaseLeaseHolder as jf, removeWorkspaceMember as jg, renameCodexAccount as jh, renderWorkspaceMemoryBlock as ji, replaceIntegrationOAuthClient as jj, requestSessionCompaction as jk, requestSessionTurnRecovery as jl, requireFile as jm, requireScheduledTask as jn, requireSession as jo, requireSocialConnection as jp, requireWorkspace as jq, reserveSessionCommandReceipt as jr, reserveToolspaceCallForAttempt as js, resolveWorkspaceMemoryBlock as jt, resumeHostExportConsumer as ju, retireHostExportConsumer as jv, revokeApiKey as jw, revokeConnection as jx, revokeEnrollment as jy, revokeViewer as jz, type AgentInternalUpdateCommandResult as k, withWorkspaceSubjectRls as k$, setEnrollmentWentOffline as k0, setInitialActiveCodexCredential as k1, setRlsContext as k2, setSessionCodexPin as k3, setSessionGoalLastContinuationTurn as k4, setSessionGoalStatus as k5, setSessionLastInputTokensForTurnAttempt as k6, setSessionPin as k7, setTemporalWorkflowId as k8, setVariableSetVariable as k9, updateScheduledTask as kA, updateScheduledTaskRun as kB, updateSessionCommandReceiptResult as kC, updateSessionGoal as kD, updateSessionMcpApprovalPolicy as kE, updateSessionMcpServerCredentials as kF, updateSessionTitle as kG, updateVariableSet as kH, updateWorkspace as kI, updateWorkspaceEnvironment as kJ, updateWorkspaceSettings as kK, upsertBillingCustomer as kL, upsertCapabilityCatalogItem as kM, upsertCodexSubscriptionCredential as kN, upsertGitHubInstallation as kO, upsertMachineMetricsLatest as kP, upsertRegistryCapabilityCatalogItem as kQ, upsertSandboxSessionEnvelope as kR, upsertSessionGoal as kS, upsertWorkspaceModelPolicy as kT, validateHumanInputResponse as kU, withAccountRls as kV, withCodexCapacityMutation as kW, withCodexCredentialRefreshLock as kX, withCodexTokenDeadline as kY, withRlsContext as kZ, withWorkspaceRls as k_, setWorkspaceDefaultRig as ka, setWorkspaceEnvironmentVariable as kb, settleCodexCredentialFailover as kc, settleCodexCredentialLeaseLoss as kd, settleScheduledTaskRunInTransaction as ke, settleSessionAttemptInterruptions as kf, settleSessionIdleWithParentOutbox as kg, shortMemoryId as kh, steerAgentSessionInTransaction as ki, steerQueuedTurnInTransaction as kj, storeIntegrationOAuthClient as kk, submitHumanPromptInTransaction as kl, sumUsageQuantity as km, supersedeSessionCurrentDirectionInTransaction as kn, touchEnrollmentLastSeen as ko, touchLeaseHolder as kp, updateCodexAllocatorEligibility as kq, updateCodexRotationSettings as kr, updateConnection as ks, updateImportBatchCounts as kt, updateKnowledgeMemory as ku, updatePackInstallationStatus as kv, updatePtySessionActivity as kw, updateRecording as kx, updateRig as ky, updateRigChangeStatus as kz, type AppendEventInput as l, withWorkspaceUsageLock as l0, workspaceCaptureAtRevision as l1, workspaceCodexSubscriptionActive as l2, type ApplyContextCompactionResult as m, type ApplySessionTurnSettlementInput as n, type ApplySessionTurnSettlementResult as o, type ArmCodexCapacityWaitResult as p, provisionRoles, CODEX_CAPACITY_REFRESH_MIN_MS as q, CODEX_CREDENTIAL_LEASE_TTL_MS as r, CODEX_RESET_REDEMPTION_OUTCOMES as s, CODEX_ROTATION_STRATEGIES as t, type ClaimCodexResetRedemptionResult as u, type ClaimSessionWorkForAttemptInput as v, type ClaimSessionWorkForAttemptResult as w, type ClearSessionContextResult as x, type CodexAccountStatus as y, type CodexAccountUsageSnapshot as z };
+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 };