@opengeni/db 0.7.0 → 0.7.1

package/dist/provision-roles.d.ts

@@ -1,11 +1,442 @@
-import { KnowledgeMemoryKind, SessionEvent, SessionStatus, SessionSystemUpdateKind, SystemUpdateClassification, SessionSystemUpdate, SessionEventType, SessionTurnStatus, Permission, SessionTurn, ConnectionKind, ConnectionStatus, KnowledgeMemory, CapabilityKind, CapabilitySource, KnowledgeMemoryStatus, KnowledgeSourceRef, ScheduledTaskStatus, ScheduledTaskScheduleSpec, ScheduledTaskRunMode, ScheduledTaskOverlapPolicy, ScheduledTaskAgentConfig, SessionGoalCreatedBy, SocialProvider, SocialConnectionStatus, McpServerConnectionRef as McpServerConnectionRef$1, SessionTurnSource, ResourceRef, ToolRef, ReasoningEffort, SandboxBackend, SandboxOs, FileAsset, FileUploadStatus, SessionGoal, CapabilityPack, SessionControlState, RigCheck, Session, LineageNode, SessionMcpServerMetadata, RigVersion, BillingBalance, RigChange, AccessContext, SessionQueueMutationResponse, ApiKey, ConnectionMetadata, Rig, RigChangeKind, ScheduledTask, ScheduledTaskTriggerType, ScheduledTaskRun, SocialConnection, SocialPost, VariableSet, Workspace, CapabilityInstallation, PackInstallation, CapabilityCatalogItem, ManagedAccount, SessionQueueSnapshot, AccessGrant, WorkspaceRegisteredPack, SessionListResponse, UsageEvent, WorkspaceMember, SessionGoalStatus, VariableSetVariableMetadata, PackInstallationStatus, RigChangeStatus, ScheduledTaskRunStatus } from '@opengeni/contracts';
+import { ResourceRef, ToolRef, ReasoningEffort, KnowledgeMemoryKind, SessionEvent, SessionStatus, SystemUpdateClassification, SessionSystemUpdateKind, SessionSystemUpdatePayload, SessionSystemUpdate, SessionEventType, SessionTurnStatus, Permission, SessionTurn, ConnectionKind, ConnectionStatus, KnowledgeMemory, CapabilityKind, CapabilitySource, KnowledgeMemoryStatus, KnowledgeSourceRef, ScheduledTaskStatus, ScheduledTaskScheduleSpec, ScheduledTaskRunMode, ScheduledTaskOverlapPolicy, ScheduledTaskAgentConfig, SessionGoalCreatedBy, SocialProvider, SocialConnectionStatus, McpServerConnectionRef as McpServerConnectionRef$1, SessionTurnSource, SandboxBackend, SandboxOs, FileAsset, FileUploadStatus, SessionGoal, CapabilityPack, RigCheck, Session, LineageNode, SessionMcpServerMetadata, RigVersion, BillingBalance, RigChange, AccessContext, ApiKey, ConnectionMetadata, Rig, RigChangeKind, ScheduledTask, ScheduledTaskTriggerType, ScheduledTaskRun, SocialConnection, SocialPost, VariableSet, Workspace, CapabilityInstallation, PackInstallation, CapabilityCatalogItem, ManagedAccount, SessionQueueSnapshot, WorkspaceControlEvent, AccessGrant, WorkspaceRegisteredPack, SessionListResponse, UsageEvent, WorkspaceMember, SessionGoalStatus, VariableSetVariableMetadata, PackInstallationStatus, RigChangeStatus, ScheduledTaskRunStatus } from '@opengeni/contracts';
 import { environmentsEncryptionKeyBytes, Settings, McpServerConnectionRef } from '@opengeni/config';
 import { refreshCodexToken, CodexTokenSnapshot, CodexUsagePayload } from '@opengeni/codex';
 import { PgDatabase, PgTransactionConfig } from 'drizzle-orm/pg-core';
-import { s as schema, e as enrollmentOsValues, a as enrollmentExposureValues, d as deviceEnrollmentStatusValues, b as enrollmentStatusValues, c as sandboxKindValues, f as sessionRecordingCodecValues, g as sessionRecordingModeValues, h as sessionRecordingStateValues } from './schema-Dp2MbBxx.js';
+import { s as sessionCommandReceipts, a as sessionTurnAttempts, c as composerDrafts, b as sessionTurns, d as schema, e as enrollmentOsValues, f as enrollmentExposureValues, g as deviceEnrollmentStatusValues, h as enrollmentStatusValues, i as sandboxKindValues, j as sessionRecordingCodecValues, k as sessionRecordingModeValues, l as sessionRecordingStateValues } from './schema-BN5mB9xZ.js';
 import 'drizzle-orm';
 import './migrate.js';
 
+declare const SESSION_ANCESTRY_LIMIT = 10000;
+type WorkspaceControlLockMode = "share" | "update";
+type EffectiveControlState = "active" | "paused";
+type SessionCommandActor = {
+    type: "human" | "operator";
+    subjectId: string;
+} | {
+    type: "agent_attempt";
+    attemptId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+};
+type SessionTurnAttemptOutcome = "completed" | "failed" | "cancelled" | "superseded" | "requires_action" | "interrupted_recoverable" | "lease_lost_recoverable" | "pre_cutover_closed";
+type EffectiveControlBlocker = {
+    kind: "session" | "workspace";
+    sessionId?: string;
+    displayName: string;
+    actor: string | null;
+    reason: string | null;
+    changedAt: Date | null;
+    revision: number;
+};
+type EffectiveControlResumeOption = {
+    scope: "selected" | "session" | "workspace";
+    targetId?: string;
+    selectedStateAfter: EffectiveControlState;
+    remainingPrimaryBlocker?: EffectiveControlBlocker;
+    impactCopy: string;
+};
+type EffectiveSessionControl = {
+    state: EffectiveControlState;
+    controlVersion: number;
+    controlEtag: string;
+    directState: EffectiveControlState;
+    primaryBlocker: EffectiveControlBlocker | null;
+    additionalBlockerCount: number;
+    blockers: EffectiveControlBlocker[];
+    resumeOptions: EffectiveControlResumeOption[];
+    override: {
+        rootSessionId: string;
+        revision: number;
+    } | null;
+    settlement: {
+        state: "stopping";
+        attemptCount: number;
+    } | null;
+};
+declare function serializeEffectiveSessionControl(control: EffectiveSessionControl): {
+    primaryBlocker: (Omit<EffectiveControlBlocker, "changedAt"> & {
+        changedAt: string | null;
+    }) | null;
+    blockers: (Omit<EffectiveControlBlocker, "changedAt"> & {
+        changedAt: string | null;
+    })[];
+    resumeOptions: {
+        remainingPrimaryBlocker?: Omit<EffectiveControlBlocker, "changedAt"> & {
+            changedAt: string | null;
+        };
+        scope: "selected" | "session" | "workspace";
+        targetId?: string;
+        selectedStateAfter: EffectiveControlState;
+        impactCopy: string;
+    }[];
+    state: EffectiveControlState;
+    controlVersion: number;
+    controlEtag: string;
+    directState: EffectiveControlState;
+    additionalBlockerCount: number;
+    override: {
+        rootSessionId: string;
+        revision: number;
+    } | null;
+    settlement: {
+        state: "stopping";
+        attemptCount: number;
+    } | null;
+};
+type WorkspaceControlRow = {
+    workspaceId: string;
+    accountId: string;
+    revision: number | string;
+    workspaceState: string;
+    workspacePauseRevision: number | string | null;
+    reason: string | null;
+    changedBy: string | null;
+    changedAt: Date | string | null;
+};
+type SessionCommandReceiptRow = typeof sessionCommandReceipts.$inferSelect;
+declare class SessionControlInvariantError extends Error {
+    readonly code = "SESSION_CONTROL_INVARIANT";
+    constructor(message: string);
+}
+declare class SessionControlConflictError extends Error {
+    readonly code = "CONTROL_CHANGED";
+    constructor(message?: string);
+}
+declare class SessionCommandIdempotencyError extends Error {
+    readonly code = "IDEMPOTENCY_KEY_REUSED";
+    constructor();
+}
+declare class AgentCommandAuthorityError extends Error {
+    readonly code: "CALLER_STALE" | "CALLER_INTERRUPTED" | "SELF_OR_ANCESTOR_PAUSE" | "SELF_STEER";
+    constructor(code: "CALLER_STALE" | "CALLER_INTERRUPTED" | "SELF_OR_ANCESTOR_PAUSE" | "SELF_STEER", message: string);
+}
+declare function assertAgentCommandAuthorityInTransaction(db: Database, input: {
+    workspaceId: string;
+    actor: Extract<SessionCommandActor, {
+        type: "agent_attempt";
+    }>;
+    targetSessionId: string;
+    action: "pause" | "resume" | "steer" | "message";
+}): Promise<void>;
+declare function canonicalSessionCommandHash(value: unknown): string;
+declare function lockWorkspaceInferenceControl(db: Database, workspaceId: string, mode: WorkspaceControlLockMode): Promise<WorkspaceControlRow>;
+declare function registerSessionTurnAttemptClaim(db: Database, input: {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+    temporalWorkflowId: string;
+    temporalWorkflowRunId: string;
+    temporalActivityId: string;
+    verifiedControlRevision: number;
+}): Promise<typeof sessionTurnAttempts.$inferSelect>;
+/**
+ * Close the exact first-class owner while the caller still holds the owning
+ * session/turn locks. Every path that clears `session_turns.active_attempt_id`
+ * must call this in the same transaction; otherwise a later claim would either
+ * collide with a zombie live owner or have to weaken the ownership fence.
+ */
+declare function closeSessionTurnAttemptInTransaction(db: Database, input: {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+    outcome: SessionTurnAttemptOutcome;
+    closedAt?: Date;
+}): Promise<{
+    action: "closed" | "already_closed";
+}>;
+declare function evaluateSessionControls(db: Database, workspaceId: string, sessionIds: string[], options?: {
+    lock?: WorkspaceControlLockMode;
+}): Promise<Map<string, EffectiveSessionControl>>;
+declare function evaluateSessionControl(db: Database, workspaceId: string, sessionId: string, options?: {
+    lock?: WorkspaceControlLockMode;
+}): Promise<EffectiveSessionControl>;
+declare function reserveSessionCommandReceipt(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actor: SessionCommandActor;
+    action: string;
+    targetSessionId: string | null;
+    targetTurnId: string | null;
+    operationKey: string;
+    canonicalRequestHash: string;
+}): Promise<{
+    receipt: SessionCommandReceiptRow;
+    replay: boolean;
+}>;
+/** Register one exact post-commit Temporal nudge without encoding eligibility in
+ * the transport. The workflow re-reads canonical Postgres state; coalescing is
+ * revisioned so a lost or stale delivery cannot hide a later mutation. */
+declare function registerSessionWorkflowWakeInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    temporalWorkflowId: string;
+    reason: string;
+}): Promise<number>;
+/**
+ * Internal producers share one outstanding session-level receipt. While a wake
+ * remains undelivered, another update makes that same batch richer instead of
+ * manufacturing another transport revision or sequential model turn.
+ */
+declare function registerInternalUpdateWakeInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    temporalWorkflowId: string;
+}): Promise<{
+    wakeRevision: number;
+    shouldSignal: boolean;
+}>;
+declare function updateSessionCommandReceiptResult(db: Database, receiptId: string, input: {
+    controlRevision?: number | null;
+    queueVersion?: number | null;
+    turnVersion?: number | null;
+    draftRevision?: number | null;
+    result: Record<string, unknown>;
+}): Promise<SessionCommandReceiptRow>;
+type SessionControlMutationResult = {
+    receipt: SessionCommandReceiptRow;
+    control: EffectiveSessionControl;
+    sessionControlEventId: string;
+    workspaceControlEventId: string;
+    interruptionCount: number;
+    wakeCount: number;
+    replay: boolean;
+};
+declare function mutateSessionControlInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    actor: SessionCommandActor;
+    operationKey: string;
+    action: "pause" | "resume";
+    reason?: string | null;
+    expectedControlEtag?: string | null;
+}): Promise<SessionControlMutationResult>;
+declare function autoResumeSessionBranchInTransaction(db: Database, input: {
+    workspaceId: string;
+    sessionId: string;
+    actor: string;
+    reason: "human_send" | "human_steer" | "agent_steer";
+    observedControlEtag?: string | null;
+}): Promise<{
+    revision: number;
+    control: EffectiveSessionControl;
+    changed: boolean;
+    workspaceControlEventId: string | null;
+}>;
+type WorkspaceControlMutationResult = {
+    receipt: SessionCommandReceiptRow;
+    revision: number;
+    workspaceControlEventId: string;
+    workspaceState: EffectiveControlState;
+    interruptionCount: number;
+    wakeCount: number;
+    replay: boolean;
+};
+declare function mutateWorkspaceControlInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actor: SessionCommandActor;
+    operationKey: string;
+    action: "pause" | "resume";
+    reason?: string | null;
+    expectedRevision?: number | null;
+}): Promise<WorkspaceControlMutationResult>;
+
+type QueueCommandConflictCode = "QUEUE_VERSION_CHANGED" | "QUEUE_PROMPT_STARTED" | "QUEUE_ANCHOR_CHANGED" | "PROMPT_CHANGED" | "DRAFT_CHANGED" | "DRAFT_NOT_EMPTY";
+declare class QueueCommandConflictError extends Error {
+    readonly code: QueueCommandConflictCode;
+    readonly current: {
+        queueVersion: number;
+        turnVersion?: number;
+        draftRevision?: number;
+    };
+    readonly name = "QueueCommandConflictError";
+    constructor(code: QueueCommandConflictCode, message: string, current: {
+        queueVersion: number;
+        turnVersion?: number;
+        draftRevision?: number;
+    });
+}
+type ComposerDraftRow = typeof composerDrafts.$inferSelect;
+type QueuedTurnRow = typeof sessionTurns.$inferSelect;
+type QueueCommandResult = {
+    receipt: SessionCommandReceiptRow;
+    queueVersion: number;
+    items: QueuedTurnRow[];
+    eventIds: string[];
+    replay: boolean;
+};
+type EditQueueCommandResult = QueueCommandResult & {
+    draft: ComposerDraftRow;
+};
+type SteerQueueCommandResult = QueueCommandResult & {
+    interruptionCount: number;
+    workspaceControlEventId: string | null;
+};
+type SubmitHumanPromptResult = {
+    receipt: SessionCommandReceiptRow;
+    queueVersion: number;
+    acceptedEventId: string;
+    eventIds: string[];
+    turnId: string;
+    wakeRevision: number;
+    interruptionCount: number;
+    workspaceControlEventId: string | null;
+    replay: boolean;
+};
+type AgentInternalUpdateCommandResult = {
+    receipt: SessionCommandReceiptRow;
+    updateId: string;
+    eventIds: string[];
+    wakeRevision: number | null;
+    shouldSignal: boolean;
+    workflowId: string;
+    effectiveState: "active" | "paused";
+    interruptionCount: number;
+    workspaceControlEventId: string | null;
+    replay: boolean;
+};
+type SteerSupersessionResult = {
+    interruptionCount: number;
+    replacedTurn: typeof sessionTurns.$inferSelect | null;
+    liveCurrentTurnId: string | null;
+    lastSequence: number;
+};
+/**
+ * One canonical replacement transition shared by human row/new-prompt Steer
+ * and Agent Steer. A live owner is interrupted and remains current until exact
+ * settlement; an ownerless approval/recovery/capacity turn is superseded now.
+ */
+declare function supersedeSessionCurrentDirectionInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    activeTurnId: string | null;
+    actor: SessionCommandActor;
+    operationId: string;
+    controlRevision: number;
+    lastSequence: number;
+}): Promise<SteerSupersessionResult>;
+declare function getComposerDraftInTransaction(db: Database, input: {
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    lock?: boolean;
+}): Promise<ComposerDraftRow | null>;
+declare function saveComposerDraftInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    expectedRevision: number;
+    text: string;
+    resources: ResourceRef[];
+    tools: ToolRef[];
+    model: string;
+    reasoningEffort: ReasoningEffort;
+}): Promise<ComposerDraftRow>;
+declare function moveQueuedTurnInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    beforeTurnId: string | null;
+    expectedQueueVersion: number;
+    actor: SessionCommandActor;
+    operationKey: string;
+}): Promise<QueueCommandResult>;
+declare function deleteSessionQueueItemInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    expectedTurnVersion: number;
+    actor: SessionCommandActor;
+    operationKey: string;
+    reason?: string | null;
+}): Promise<QueueCommandResult>;
+declare function editQueuedTurnInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    subjectId: string;
+    expectedTurnVersion: number;
+    expectedDraftRevision: number;
+    replaceDraft: boolean;
+    actor: SessionCommandActor;
+    operationKey: string;
+}): Promise<EditQueueCommandResult>;
+declare function steerQueuedTurnInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    expectedTurnVersion: number;
+    controlEtag?: string | null;
+    actor: SessionCommandActor;
+    operationKey: string;
+}): Promise<SteerQueueCommandResult>;
+declare function submitHumanPromptInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    actor: SessionCommandActor;
+    operationKey: string;
+    delivery: "send" | "steer";
+    controlEtag?: string | null;
+    expectedDraftRevision?: number | null;
+    text: string;
+    resources: ResourceRef[];
+    tools: ToolRef[];
+    model?: string | null;
+    reasoningEffort?: ReasoningEffort | null;
+    reasoningEffortFallback: ReasoningEffort;
+    source: "user" | "api";
+    mcpCredentialUpdates?: Array<{
+        id: string;
+        headersEncrypted: Record<string, string>;
+    }>;
+}): Promise<SubmitHumanPromptResult>;
+declare function sendAgentMessageInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    targetSessionId: string;
+    actor: Extract<SessionCommandActor, {
+        type: "agent_attempt";
+    }>;
+    operationKey: string;
+    text: string;
+}): Promise<AgentInternalUpdateCommandResult>;
+declare function steerAgentSessionInTransaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    targetSessionId: string;
+    actor: Extract<SessionCommandActor, {
+        type: "agent_attempt";
+    }>;
+    operationKey: string;
+    instruction: string;
+}): Promise<AgentInternalUpdateCommandResult>;
+
+/** Provider-valid result for a started call whose durable outcome is unknown. */
+declare function interruptedToolCallResult(input: {
+    callType: string;
+    callId: string;
+    callItem: Record<string, unknown>;
+    reason: string;
+}): Record<string, unknown> | null;
+
 /**
  * Encrypts one workspace environment variable value with AES-256-GCM under an
  * operator key held outside Postgres. Output format: `v1:<b64 iv>:<b64 ciphertext||tag>`.
@@ -1559,7 +1990,6 @@ type CodexCapacityWait = {
     generation: number;
     status: CodexCapacityWaitStatus;
     goalVersion: number;
-    controlGeneration: number;
     policyHash: string | null;
     earliestResetAt: Date | null;
     nextCheckAt: Date;
@@ -1655,7 +2085,6 @@ declare function armCodexCapacityWait(db: Database, input: {
     workflowId: string;
     goalId: string;
     goalVersion: number;
-    controlGeneration?: number;
     policyHash?: string | null;
     earliestResetAt: Date | null;
     resetKind: CodexCapacityResetKind;
@@ -2104,6 +2533,8 @@ type ToolspaceCallReservation = {
  */
 declare function reserveToolspaceCallForTurn(db: Database, workspaceId: string, sessionId: string, turnId: string, limit: number): Promise<ToolspaceCallReservation>;
 declare function getSessionEvent(db: Database, workspaceId: string, eventId: string): Promise<SessionEvent | null>;
+declare function listWorkspaceControlEvents(db: Database, workspaceId: string, after?: number, limit?: number): Promise<WorkspaceControlEvent[]>;
+declare function getWorkspaceControlEvent(db: Database, workspaceId: string, eventId: string): Promise<WorkspaceControlEvent | null>;
 /**
  * Resolve a client-idempotent event inside one exact workspace/session scope.
  * The three predicates are deliberate: a client event id is unique only within
@@ -2159,18 +2590,6 @@ declare function registerPendingSessionToolCall(db: Database, input: PendingSess
     accepted: boolean;
     registered: boolean;
 }>;
-/**
- * A provider-valid result that tells the resumed model exactly what is known:
- * the call started, its durable result was not observed, and the side-effect
- * outcome is unknown. Unknown call types return null and are kept out of model
- * history rather than guessed into an invalid protocol shape.
- */
-declare function interruptedToolCallResult(input: {
-    callType: string;
-    callId: string;
-    callItem: Record<string, unknown>;
-    reason: string;
-}): Record<string, unknown> | null;
 /** Record the raw SDK result without dropping the call receipt. */
 declare function recordPendingSessionToolCallResult(db: Database, input: Omit<PendingSessionToolCallInput, "callType" | "callItem"> & {
     resultItem: Record<string, unknown>;
@@ -3364,15 +3783,6 @@ declare function updateSessionTitle(db: Database, input: {
     updated: boolean;
     title: string | null;
 }>;
-type ChildNotificationsMode = "digest" | "passive";
-/**
- * Set how a manager session receives spawned-worker completion notifications:
- * `digest` (default) enqueues a coalesced turn the manager processes; `passive`
- * lands each completion as a timeline card only, never a queued turn / model run
- * (the "don't bring spawned sessions back into my chat" opt-in). Merges the one
- * key into `metadata` (jsonb `||`) so nothing else on the row is clobbered.
- */
-declare function setSessionChildNotificationsMode(db: Database, workspaceId: string, sessionId: string, mode: ChildNotificationsMode): Promise<boolean>;
 /**
  * Status transition helper. Idempotent: requesting the current status returns
  * `changed: false` so callers can skip emitting a duplicate event. `completed`
@@ -3454,9 +3864,13 @@ type SessionWorkTrigger = {
     kind: "approval";
     triggerEventId: string;
 };
+declare const MAX_INTERNAL_UPDATE_BYTES: number;
+declare const MAX_INTERNAL_UPDATE_BATCH_MEMBERS = 100;
+declare const MAX_INTERNAL_UPDATE_BATCH_BYTES: number;
 type ClaimSessionWorkForAttemptInput = {
     sessionId: string;
     workflowId: string;
+    workflowRunId: string;
     attemptId: string;
     dispatchId: string;
     trigger: SessionWorkTrigger;
@@ -3475,6 +3889,20 @@ type ClaimSessionWorkForAttemptResult = {
  * session's public state commit atomically under the workspace/session lock.
  */
 declare function claimSessionWorkForAttempt(db: Database, workspaceId: string, input: ClaimSessionWorkForAttemptInput): Promise<ClaimSessionWorkForAttemptResult>;
+type SessionAttemptInterruptionSettlement = {
+    action: "paused" | "continue" | "stale";
+    events: SessionEvent[];
+    attemptId: string;
+    turnId: string | null;
+    outcome: SessionTurnAttemptOutcome | null;
+};
+/**
+ * Settle every durable interruption cause for one exact first-class attempt.
+ * Steer wins the logical-turn fate when causes coexist; effective control after
+ * settlement independently decides whether the workflow holds or continues.
+ * The attempt remains the sole write owner until this transaction closes it.
+ */
+declare function settleSessionAttemptInterruptions(db: Database, workspaceId: string, sessionId: string, attemptId: string): Promise<SessionAttemptInterruptionSettlement>;
 type SessionWorkPeek = {
     kind: "runnable";
 } | {
@@ -3491,21 +3919,20 @@ type SessionWorkPeek = {
         wakeRevision: number;
     };
 } | {
-    kind: "fence-settle";
-    controlEventId: string;
+    kind: "interruption-pending";
+    attemptId: string;
 } | {
     kind: "idle";
 };
 /** Read durable session state without reserving a turn-worker slot or mutating it. */
 declare function peekSessionWork(db: Database, workspaceId: string, sessionId: string): Promise<SessionWorkPeek>;
 /**
- * Commit the workflow's terminal-for-now idle decision and, when child
- * completion parent wakes are enabled, its parent delivery source in one
- * transaction. A crash after an enabled commit leaves a pending outbox row for
+ * Commit the workflow's terminal-for-now idle decision and its parent delivery
+ * source in one transaction. A crash after commit leaves a pending outbox row for
  * the global reconciler; a normal caller immediately enriches/delivers the same
  * dedupe identity through notifyParentOfChildTerminal.
  */
-declare function settleSessionIdleWithParentOutbox(db: Database, workspaceId: string, sessionId: string, childCompletionParentWakeEnabled: boolean): Promise<{
+declare function settleSessionIdleWithParentOutbox(db: Database, workspaceId: string, sessionId: string): Promise<{
     action: "settled";
     changed: boolean;
     episodeKey: string;
@@ -3540,7 +3967,6 @@ type ApplySessionTurnSettlementInput = {
     turnId: string;
     triggerEventId: string;
     attemptId: string;
-    childCompletionParentWakeEnabled: boolean;
     fromStatuses?: SessionTurnStatus[];
     turnStatus: SessionTurnStatus;
     sessionStatus: SessionStatus;
@@ -3638,6 +4064,7 @@ type RequestSessionTurnRecoveryInput = {
     triggerEventId: string;
     attemptId: string;
     reason: string;
+    detail?: Record<string, unknown>;
     fromStatuses?: SessionTurnStatus[];
 };
 type RequestSessionTurnRecoveryResult = {
@@ -3649,71 +4076,12 @@ type RequestSessionTurnRecoveryResult = {
     turnStatus: SessionTurnStatus | null;
     activeTurnId: string | null;
 };
-/**
- * Suspend the exact current attempt as the same recovering inference. Recovery
- * is never queue work: the original trigger and active-turn pointer stay put.
- */
 declare function requestSessionTurnRecovery(db: Database, workspaceId: string, input: RequestSessionTurnRecoveryInput): Promise<RequestSessionTurnRecoveryResult>;
-type ReparkOrphanedSessionTurnInput = {
-    sessionId: string;
-    turnId: string;
-    attemptId: string | null;
-    reason: string;
-};
-type RepairDetachedCodexCapacityAttemptInput = {
-    sessionId: string;
-    turnId: string;
-    attemptId: string;
-    reason: string;
-};
-type RepairDetachedCodexCapacityAttemptResult = {
-    action: "repaired";
-    closedToolCalls: number;
-    events: SessionEvent[];
-} | {
-    action: "stale";
-    events: [];
-    turnStatus: SessionTurnStatus | null;
-    activeTurnId: string | null;
-    activeAttemptId: string | null;
-};
-/**
- * Repair the exact historical residue left by the pre-cutover Codex-capacity
- * settlement: the turn is already terminal and detached, but still carries its
- * former attempt owner. This is deliberately an operator-only transition. It
- * refuses any live pointer, lease, pending control owner, non-capacity failure,
- * or changed attempt and truthfully closes unresolved tool receipts before
- * clearing the stale owner.
- */
-declare function repairDetachedCodexCapacityAttempt(db: Database, workspaceId: string, input: RepairDetachedCodexCapacityAttemptInput): Promise<RepairDetachedCodexCapacityAttemptResult>;
-type ReparkOrphanedSessionTurnResult = {
-    action: "recovering";
-    sessionStatus: "recovering" | "paused";
-    closedToolCalls: number;
-    events: SessionEvent[];
-} | {
-    action: "stale";
-    events: [];
-    turnStatus: SessionTurnStatus | null;
-    activeTurnId: string | null;
-    activeAttemptId: string | null;
-};
-/**
- * Repark one current inference after the production cutover has drained every
- * worker and terminated every session workflow. This is an evidence-writing
- * ownership transition, not queue admission: the same turn and active-turn
- * pointer are preserved and unresolved tool calls are closed truthfully. A
- * registered attempt is matched exactly. The null case is also matched exactly
- * so a partially applied 0057 cutover can recover a turn that an old worker
- * moved back to `running` without ever registering first-class attempt identity.
- */
-declare function reparkOrphanedSessionTurn(db: Database, workspaceId: string, input: ReparkOrphanedSessionTurnInput): Promise<ReparkOrphanedSessionTurnResult>;
 type RecoverSessionDispatchInput = {
     sessionId: string;
     attemptId: string;
     timeoutType: "HEARTBEAT" | "SCHEDULE_TO_START";
     maxRedispatches: number;
-    childCompletionParentWakeEnabled: boolean;
 };
 type RecoverSessionDispatchResult = {
     action: "unclaimed";
@@ -3757,14 +4125,9 @@ declare function getSessionTurnForAttempt(db: Database, workspaceId: string, ses
 declare function getLatestStartedSessionTurn(db: Database, workspaceId: string, sessionId: string): Promise<SessionTurn | null>;
 declare function listSessionTurns(db: Database, workspaceId: string, sessionId: string, limit?: number): Promise<SessionTurn[]>;
 declare function listPendingSessionTurns(db: Database, workspaceId: string, sessionId: string): Promise<SessionTurn[]>;
-declare class SessionQueueConflictError extends Error {
-    readonly currentQueueVersion: number;
-    readonly currentItemVersion?: number | undefined;
-    constructor(message: string, currentQueueVersion: number, currentItemVersion?: number | undefined);
-}
 declare function getSessionQueueSnapshot(db: Database, workspaceId: string, sessionId: string): Promise<SessionQueueSnapshot | null>;
-declare function cancelQueuedSessionTurnWithVersion(db: Database, workspaceId: string, sessionId: string, turnId: string, expectedQueueVersion: number, expectedItemVersion: number, actor: string, reason?: string | null): Promise<SessionQueueMutationResponse & {
-    workflowWakeRevision: number | null;
+type ChildTerminalResultPayload = Extract<SessionSystemUpdatePayload, {
+    type: "child_terminal_result";
 }>;
 type SessionSystemUpdateOutboxDelivery = {
     id: string;
@@ -3774,11 +4137,11 @@ type SessionSystemUpdateOutboxDelivery = {
     sourceSessionId: string;
     targetSessionId: string;
     dedupeKey: string;
-    kind: SessionSystemUpdateKind;
+    kind: "child_terminal_result";
     classification: SystemUpdateClassification;
     sourceId: string;
     summary: string;
-    payload: Record<string, unknown>;
+    payload: ChildTerminalResultPayload;
     lineage: Record<string, unknown>;
 };
 declare function claimPendingSessionSystemUpdateOutbox(db: Database, limit?: number): Promise<SessionSystemUpdateOutboxDelivery[]>;
@@ -3788,7 +4151,7 @@ type SessionWorkflowWake = {
     sessionId: string;
     temporalWorkflowId: string;
     wakeRevision: number;
-    controlEventId: string | null;
+    interruptionRequested: boolean;
 };
 /**
  * Record a new workflow nudge in the same transaction as the state mutation
@@ -3832,25 +4195,31 @@ declare function claimPendingSessionWorkflowWakes(db: Database, limit?: number):
  * its own revision; it cannot clear a claim or failure state belonging to a
  * newer revision.
  */
-declare function markSessionWorkflowWakeDelivered(db: Database, input: Omit<SessionWorkflowWake, "controlEventId">): Promise<void>;
+declare function markSessionWorkflowWakeDelivered(db: Database, input: Omit<SessionWorkflowWake, "interruptionRequested">): Promise<void>;
 /** Record delivery failure; the claim already scheduled the bounded retry. */
 declare function markSessionWorkflowWakeFailed(db: Database, input: SessionWorkflowWake, error: string): Promise<boolean>;
 declare function getOrCreateSessionSystemUpdateOutbox(db: Database, input: Omit<SessionSystemUpdateOutboxDelivery, "id" | "status">): Promise<SessionSystemUpdateOutboxDelivery>;
 declare function markSessionSystemUpdateOutboxFailed(db: Database, input: Pick<SessionSystemUpdateOutboxDelivery, "accountId" | "workspaceId" | "id">, error: string): Promise<void>;
 /** DB-only callback for addSessionSystemUpdateWithSourceMutation. */
 declare function markSessionSystemUpdateOutboxDeliveredInTransaction(tx: Database, input: Pick<SessionSystemUpdateOutboxDelivery, "workspaceId" | "id">): Promise<void>;
+type SessionSystemUpdateInputVariant = {
+    [Kind in SessionSystemUpdateKind]: {
+        kind: Kind;
+        payload: Extract<SessionSystemUpdatePayload, {
+            type: Kind;
+        }>;
+    };
+}[SessionSystemUpdateKind];
 type AddSessionSystemUpdateInput = {
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    kind: SessionSystemUpdateKind;
     classification: SystemUpdateClassification;
     sourceId: string;
     dedupeKey: string;
     summary: string;
-    payload: Record<string, unknown>;
     lineage?: Record<string, unknown>;
-};
+} & SessionSystemUpdateInputVariant;
 type AddSessionSystemUpdateResult = {
     added: false;
     reason: "session_cancelled";
@@ -3873,111 +4242,6 @@ declare function addSessionSystemUpdateWithSourceMutation(db: Database, input: A
 declare function listOutstandingSessionSystemUpdates(db: Database, workspaceId: string, sessionId: string): Promise<SessionSystemUpdate[]>;
 /** Internal updates atomically attached when this inference was claimed. */
 declare function listSessionSystemUpdatesForTurn(db: Database, workspaceId: string, sessionId: string, turnId: string): Promise<SessionSystemUpdate[]>;
-type SessionControlMode = "pause" | "resume";
-type RequestSessionControlResult = {
-    operationId: string;
-    event: SessionEvent;
-    events: SessionEvent[];
-    controlState: SessionControlState;
-    controlGeneration: number;
-    expectedActiveTurnId: string | null;
-    expectedExecutionGeneration: number | null;
-    expectedAttemptId: string | null;
-    deliveryEventId: string | null;
-    shouldSignalControl: boolean;
-    shouldWake: boolean;
-    workflowWakeRevision: number | null;
-};
-declare function requestSessionControl(db: Database, input: {
-    accountId: string;
-    workspaceId: string;
-    sessionId: string;
-    actor: string;
-    mode: SessionControlMode;
-    reason?: string | null;
-    clientEventId?: string | null;
-    expectedControlState?: SessionControlState;
-    expectedControlGeneration?: number;
-    expectedWorkspaceInferenceGeneration?: number;
-}): Promise<RequestSessionControlResult>;
-/**
- * Settle the exact control fence created by Pause or Steer. Pause keeps the
- * current turn recoverable; Steer has already superseded it atomically and
- * only needs the old attempt to stop before the head prompt may run.
- */
-declare function settlePendingSessionControl(db: Database, workspaceId: string, sessionId: string, controlEventId: string): Promise<{
-    action: "paused" | "continue" | "stale";
-    events: SessionEvent[];
-    recoveringTurnId: string | null;
-}>;
-type DurableSessionControlRequest = {
-    accountId: string;
-    workspaceId: string;
-    sessionId: string;
-    workflowId: string;
-    eventId: string;
-    events: SessionEvent[];
-    workflowWakeRevision: number;
-};
-type DurableSessionWakeRequest = {
-    accountId: string;
-    workspaceId: string;
-    sessionId: string;
-    workflowId: string;
-    workflowWakeRevision: number;
-};
-declare function setWorkspaceInferenceControl(db: Database, input: {
-    accountId: string;
-    workspaceId: string;
-    actor: string;
-    state: "active" | "paused";
-    reason: string;
-    clientEventId: string;
-    expectedState: "active" | "paused";
-    expectedGeneration: number;
-    exceptSessionIds?: string[];
-}): Promise<{
-    operationId: string;
-    state: "active" | "paused";
-    generation: number;
-    affectedSessionIds: string[];
-    exceptionSessionIds: string[];
-    controls: DurableSessionControlRequest[];
-    wakeSessions: DurableSessionWakeRequest[];
-    broadcasts: Array<{
-        sessionId: string;
-        events: SessionEvent[];
-    }>;
-}>;
-type EnqueueSessionMessageResult = {
-    accepted: SessionEvent;
-    turn: SessionTurn;
-    events: SessionEvent[];
-    controlEvent: SessionEvent | null;
-    shouldSignalControl: boolean;
-    shouldWake: boolean;
-    workflowWakeRevision: number | null;
-    temporalWorkflowId: string;
-    missingMcpServerIds: string[];
-};
-declare function enqueueSessionMessageAtomically(db: Database, input: {
-    accountId: string;
-    workspaceId: string;
-    sessionId: string;
-    actor: string;
-    origin: "human" | "operator";
-    text: string;
-    resources: ResourceRef[];
-    tools: ToolRef[];
-    model?: string | null;
-    reasoningEffort?: ReasoningEffort | null;
-    clientEventId?: string | null;
-    mcpCredentialUpdates?: UpdateSessionMcpServerCredentialsInput[];
-    delivery: "queue" | "steer";
-    expectedControlGeneration?: number;
-    expectedWorkspaceInferenceGeneration?: number;
-    reasoningEffortFallback: ReasoningEffort;
-}): Promise<EnqueueSessionMessageResult>;
 declare function appendSessionEvents(db: Database, workspaceId: string, sessionId: string, inputs: AppendEventInput[]): Promise<SessionEvent[]>;
 type AcceptSessionApprovalDecisionResult = {
     action: "accepted";
@@ -4037,4 +4301,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 CreateConnectionInput as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BootstrapWorkspaceInput as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type CodexCapacityWait as D, type CodexCapacityWaitStatus as E, type CodexCapacityWakeTarget as F, type CodexCredentialForRun as G, type CodexCredentialLeaseCandidateFilter as H, type CodexCredentialLeaseCandidateFilterResult as I, type CodexCredentialLeasePolicyScopeResolver as J, type CodexCredentialLeaseQuarantine as K, type CodexCredentialLeaseResult as L, type CodexCredentialLeaseSelection as M, type CodexCredentialLeaseSelectionContext as N, type CodexCredentialStatus as O, type CodexCredentialTokens as P, type ProvisionResult, type ProvisionRolesOptions, type CodexLeaseAccountStatus as Q, type CodexPinSource as R, type CodexRotationSettings as S, type CodexRotationStrategy as T, type ConnectionBrokerDeps as U, type ConnectionCredentialForBroker as V, ConnectionRefreshHttpError as W, type ConsumeOAuthStateNonceInput as X, type CorrectWorkspaceMemoryInput as Y, type CorrectWorkspaceMemoryResult as Z, type CreateCapabilityCatalogItemInput as _, type AcceptSessionApprovalDecisionResult as a, type ReconcileCodexCapacityWaitResult as a$, type CreateDbOptions as a0, type CreateImportBatchInput as a1, type CreateKnowledgeMemoryInput as a2, type CreatePackInstallationInput as a3, type CreateScheduledTaskInput as a4, type CreateSessionGoalInput as a5, type CreateSessionMcpServerInput as a6, type CreateSocialConnectionInput as a7, type CreateSocialPostInput as a8, type CreditBalanceByAccount as a9, type ListSessionEventsOptions as aA, type ListSessionsForSubjectOptions as aB, type ListSessionsOptions as aC, type LiveModalSandboxLeaseAttribution as aD, MACHINE_METRICS_SERIES_INTERVAL_MS as aE, MEMORY_ACTIVE_RECORD_CAP as aF, MEMORY_BLOCK_KIND_ORDER as aG, MEMORY_BLOCK_RECORD_LIMIT as aH, MEMORY_CORRECT_TOOL_DESCRIPTION as aI, MEMORY_KIND_SECTION_TITLES as aJ, MEMORY_NEAR_DUP_COSINE_THRESHOLD as aK, MEMORY_NEAR_DUP_NEIGHBORS as aL, MEMORY_SAVE_TOOL_DESCRIPTION as aM, MEMORY_SEARCH_DEFAULT_LIMIT as aN, MEMORY_SEARCH_MAX_LIMIT as aO, MEMORY_SEARCH_TOOL_DESCRIPTION as aP, MEMORY_TEXT_MAX_CHARS as aQ, MEMORY_VISIBLE_RECORD_CAP as aR, type MachineMetricsRow as aS, type MachineMetricsSample as aT, type MarkWarmLeaseInstanceLostResult as aU, type MemoryBlockRecord as aV, type MemoryEmbedder as aW, type MemorySanitizeResult as aX, type MeterableWarmLease as aY, type PendingSessionToolCallInput as aZ, type ReapDrainable as a_, type Database as aa, type DbClient as ab, type DeviceEnrollmentRequestRecord as ac, type DeviceEnrollmentStatus as ad, type DurableSessionControlRequest as ae, type DurableSessionWakeRequest as af, type EnableCapabilityInstallationInput as ag, type EnabledMcpCapabilityServer as ah, type EnqueueSessionMessageResult as ai, type EnqueueSessionTurnInput as aj, type EnrollmentExposure as ak, type EnrollmentOs as al, type EnrollmentRecord as am, type EnrollmentStatus as an, type ExpiredFileUploadCleanupClaim as ao, type FileUploadCleanupClaimResult as ap, type ForceDrainResult as aq, type GitHubInstallation as ar, type GoalContinuationDecision as as, type ImportBatch as at, type InitializeSessionStartInput as au, type InitializeSessionStartResult as av, type IntegrationOAuthClientForUse as aw, type LeaseHolderKind as ax, type LeaseSnapshot as ay, type ListKnowledgeMemoryOptions as az, type AccrueWarmSecondsResult as b, type UpdateSessionMcpServerCredentialsResult as b$, type RecoverSessionDispatchInput as b0, type RecoverSessionDispatchResult as b1, type RegisterWorkspacePackInput as b2, type RegistryCapabilityCatalogItemInput as b3, type RegistryCatalogSurfaceKey as b4, type RepairDetachedCodexCapacityAttemptInput as b5, type RepairDetachedCodexCapacityAttemptResult as b6, type ReparkOrphanedSessionTurnInput as b7, type ReparkOrphanedSessionTurnResult as b8, type ReplaceIntegrationOAuthClientInput as b9, SessionListCursorError as bA, type SessionMcpServerForRun as bB, SessionPinAccessError as bC, SessionPinVersionConflictError as bD, SessionQueueConflictError as bE, type SessionRecordingCodec as bF, type SessionRecordingMode as bG, type SessionRecordingRow as bH, type SessionRecordingState as bI, type SessionSystemUpdateOutboxDelivery as bJ, type SessionTurnRecordingSettlement as bK, type SessionWorkPeek as bL, type SessionWorkTrigger as bM, type SessionWorkflowWake as bN, type SetSessionCodexPinOptions as bO, type SettleCodexCredentialFailoverResult as bP, type SettleCodexCredentialLeaseLossResult as bQ, type StoreIntegrationOAuthClientInput as bR, type StoredIntegrationOAuthClient as bS, type StreamAcknowledgment as bT, type ToolspaceCallReservation as bU, type TurnAttemptFenceRejectReason as bV, type UpdateConnectionInput as bW, type UpdateImportBatchCountsInput as bX, type UpdateKnowledgeMemoryInput as bY, type UpdateScheduledTaskInput as bZ, type UpdateSessionMcpServerCredentialsInput as b_, type RequestSessionControlResult as ba, type RequestSessionTurnRecoveryInput as bb, type RequestSessionTurnRecoveryResult as bc, type ResolveConnectionCredentialInput as bd, type ResolveConnectionCredentialResult as be, RigActiveVersionChangedError as bf, RigChangeAlreadyVerifyingError as bg, RigChangeTransitionError as bh, type RigVersionContentInput as bi, type RlsContext as bj, type RlsStrategy as bk, SandboxImageConflictError as bl, type SandboxKind as bm, type SandboxLeaseLiveness as bn, SandboxLeaseSupersededError as bo, type SandboxPtySessionRow as bp, type SandboxRecord as bq, SandboxRigConflictError as br, type SaveWorkspaceMemoryInput as bs, type SaveWorkspaceMemoryResult as bt, type SessionCodexState as bu, SessionContextBusyError as bv, type SessionControlMode as bw, type SessionLineage as bx, SessionListAccessError as by, type SessionListCursor as bz, type AcquireLeaseInput as c, correctWorkspaceMemory as c$, type UserLookup as c0, type VariableSetForRun as c1, WORKSPACE_MEMORY_BLOCK_EMPTY as c2, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as c3, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as c4, type WorkspaceCaptureCommitResult as c5, type WorkspaceCaptureGcPlan as c6, type WorkspaceCaptureGcRow as c7, type WorkspaceCaptureRow as c8, type WorkspaceEnvironmentForRun as c9, armCodexCapacityWait as cA, beginRigChangeVerificationAttempt as cB, bootstrapWorkspace as cC, buildChildCompletionDigest as cD, buildCodexTokenResolver as cE, buildConnectionTokenResolver as cF, cancelQueuedSessionTurnWithVersion as cG, claimExpiredFileUploadCleanup as cH, claimFileUploadCleanup as cI, claimPendingSessionSystemUpdateOutbox as cJ, claimPendingSessionWorkflowWakes as cK, claimSessionWorkForAttempt as cL, clearDurablePendingSessionToolCalls as cM, clearEnrollmentWentOffline as cN, clearSessionContext as cO, clearSessionGoal as cP, clearedContextMarkerItem as cQ, closePtySession as cR, codexCapacityRefreshBackoffMs as cS, commitWarmingToWarm as cT, completeExpiredFileUploadCleanup as cU, completeFileUpload as cV, completeFileUploadCleanup as cW, computeWorkspaceCaptureGcPlan as cX, confirmDrainCold as cY, consumeDeviceEnrollmentRequest as cZ, consumeIntegrationOAuthStateNonce as c_, type WorkspaceMemoryOrigin as ca, type WorkspaceMemorySearchInput as cb, type WorkspaceMemorySearchMode as cc, type WorkspaceMemorySearchResult as cd, type WorkspaceModelPolicy as ce, abandonRecordingForTurnAttempt as cf, acceptSessionApprovalDecision as cg, accrueWarmSeconds as ch, acquireCodexCredentialLease as ci, acquireLease as cj, activateRigVersion as ck, addSessionSystemUpdate as cl, addSessionSystemUpdateWithSourceMutation as cm, allAccountPermissions as cn, allWorkspacePermissions as co, appendSessionEventToSandboxGroup as cp, appendSessionEvents as cq, appendSessionEventsAndUpdateSession as cr, appendSessionEventsForTurnAttempt as cs, appendSessionEventsWithLockedSessionUpdate as ct, appendSessionHistoryItems as cu, applyContextCompaction as cv, applyCreditDebitUpToBalance as cw, applyCreditLedgerEntry as cx, applySessionTurnSettlement as cy, approveDeviceEnrollmentRequest as cz, type AcquireLeaseResult as d, encryptEnvironmentValue as d$, countActiveApiKeysForWorkspace as d0, countActiveSessionHistoryItems as d1, countActiveSessionsForWorkspace as d2, countActiveSessionsUsingEnvironment as d3, countActiveSessionsUsingVariableSet as d4, countConsecutiveReactiveRotations as d5, countQueuedTurns as d6, countRigs as d7, countSandboxLeasesByLiveness as d8, countScheduledTasksForWorkspace as d9, createSessionWithIdempotencyKey as dA, createSocialConnection as dB, createSocialPost as dC, createVariableSet as dD, createWorkspace as dE, createWorkspaceEnvironment as dF, decodeSessionListCursor as dG, decryptEnvironmentValue as dH, decryptedCapabilityHeaders as dI, deleteRecording as dJ, deleteRig as dK, deleteRigIfNoActiveSessions as dL, deleteScheduledTask as dM, deleteVariableSet as dN, deleteVariableSetVariable as dO, deleteWorkspace as dP, deleteWorkspaceCaptureRows as dQ, deleteWorkspaceEnvironment as dR, deleteWorkspaceEnvironmentVariable as dS, deleteWorkspacePack as dT, denyDeviceEnrollmentRequest as dU, disableCapabilityInstallation as dV, disconnectAllCodexAccounts as dW, disconnectCodexAccount as dX, enableCapabilityInstallation as dY, enablePackInstallation as dZ, encodeSessionListCursor as d_, countScheduledTasksUsingEnvironment as da, countScheduledTasksUsingVariableSet as db, countSessionHistoryItems as dc, countSessionsUsingRig as dd, countVariableSets as de, countWorkspaceEnvironments as df, countWorkspacesForAccount as dg, createApiKey as dh, createConnection as di, createDb as dj, createDeviceEnrollmentRequest as dk, createEnrollment as dl, createFileUpload as dm, createImportBatch as dn, createKnowledgeMemory as dp, createRig as dq, createRigChange as dr, createRigVersion as ds, createRigVersionForChangePromotion as dt, createSandbox as du, createScheduledTask as dv, createScheduledTaskRun as dw, createSession as dx, createSessionGoal as dy, createSessionMcpServers as dz, type ActiveSandboxPointer as e, getStreamAcknowledgment as e$, enqueueSessionMessageAtomically as e0, enqueueSessionTurn as e1, enqueueSessionWorkflowWake as e2, enqueueSessionWorkflowWakeIfRunnable as e3, enqueueSessionWorkflowWakeInTransaction as e4, ensureCodexRotationSettings as e5, ensureManagedAccessForUser as e6, estimateMemoryTokens as e7, evaluateGoalContinuation as e8, failWarmingToCold as e9, getPackInstallation as eA, getPendingDeviceEnrollmentRequestByUserCode as eB, getPendingDeviceEnrollmentRequestByUserCodeGlobal as eC, getRecording as eD, getRig as eE, getRigByName as eF, getRigChange as eG, getRigName as eH, getRigVersion as eI, getRigVersionById as eJ, getSandbox as eK, getSandboxSessionEnvelope as eL, getScheduledTask as eM, getSession as eN, getSessionByCreateIdempotencyKey as eO, getSessionCodexState as eP, getSessionEvent as eQ, getSessionEventByClientEventId as eR, getSessionForSubject as eS, getSessionGoal as eT, getSessionHistoryItems as eU, getSessionLineage as eV, getSessionQueueSnapshot as eW, getSessionTurn as eX, getSessionTurnForAttempt as eY, getSocialConnection as eZ, getStoredCapabilityHeaderCiphertext as e_, fetchCodexUsageForAccount as ea, finalizeEnrollmentByToken as eb, findActiveApiKeyByHash as ec, forceDrainOverLimitViewerOnlyBoxes as ed, getActiveSessionHistoryItems as ee, getAnySessionInGroup as ef, getBillingBalance as eg, getBillingCustomer as eh, getCapabilityCatalogItem as ei, getCapabilityInstallation as ej, getCodexCapacityWaitForSession as ek, getCodexCredentialStatus as el, getCodexRotationSettings as em, getConnectionMetadata as en, getDeviceEnrollmentRequestByDeviceCode as eo, getEnrollment as ep, getFile as eq, getFileUpload as er, getKnowledgeMemory as es, getLatestRunState as et, getLatestStartedSessionTurn as eu, getManagedAccount as ev, getManagedUserByEmail as ew, getMaterializedSandboxFileResources as ex, getOpenPtySession as ey, getOrCreateSessionSystemUpdateOutbox as ez, type AddSessionSystemUpdateInput as f, listSessionSystemUpdatesForTurn as f$, getVariableSet as f0, getVariableSetByName as f1, getVariableSetValuesForRun as f2, getWorkspace as f3, getWorkspaceDefaultRigId as f4, getWorkspaceEnvironment as f5, getWorkspaceEnvironmentByName as f6, getWorkspaceEnvironmentValuesForRun as f7, getWorkspaceGrant as f8, getWorkspaceModelPolicy as f9, listCreditBalancesByAccount as fA, listDistinctRigVersionIdsInGroup as fB, listDistinctVariableSetIdsInGroup as fC, listEnabledMcpCapabilityServers as fD, listEnrollments as fE, listGitHubInstallationIdsForWorkspace as fF, listGitHubInstallationsForWorkspace as fG, listKnowledgeMemories as fH, listLiveModalSandboxLeaseAttributions as fI, listMeterableWarmLeases as fJ, listOpenPtySessions as fK, listOutstandingSessionSystemUpdates as fL, listPackInstallations as fM, listPendingCodexCapacityWakeTargets as fN, listPendingSessionTurns as fO, listRecordings as fP, listRegistryCatalogSurfaceKeys as fQ, listRigChanges as fR, listRigVersions as fS, listRigs as fT, listSandboxes as fU, listScheduledTaskRuns as fV, listScheduledTasks as fW, listSessionEvents as fX, listSessionIdsInGroup as fY, listSessionMcpServerMetadata as fZ, listSessionMcpServersForRun as f_, getWorkspacePack as fa, grantWorkspaceAccess as fb, hasCreditLedgerEntry as fc, hashMemoryText as fd, heartbeatCodexCredentialLease as fe, heartbeatCodexCredentialLeaseUntil as ff, heartbeatLeaseHolder as fg, ingestMachineMetricsSample as fh, initializeSessionStartAtomically as fi, insertFailedWorkspaceCapture as fj, insertMachineMetricsSeries as fk, insertPtySession as fl, insertRecording as fm, insertWorkspaceCapture as fn, interruptedToolCallResult as fo, isCodexBilledTurn as fp, isMemoryTextTooLong as fq, isPrivateAddress as fr, isSessionCompactionRequested as fs, isStripeWebhookProcessed as ft, latestWorkspaceCapture as fu, listApiKeys as fv, listCapabilityCatalogItems as fw, listCapabilityInstallations as fx, listCodexAccountStatuses as fy, listConnectionsMetadata as fz, type AddSessionSystemUpdateResult as g, refreshOAuthConnectionCredential as g$, listSessionTurns as g0, listSessions as g1, listSessionsForSubject as g2, listSocialConnections as g3, listSocialPosts as g4, listUsageEvents as g5, listVariableSets as g6, listWorkspaceEnvironments as g7, listWorkspaceMembers as g8, listWorkspacePacks as g9, reArmDrainingLease as gA, readActiveSandbox as gB, readLease as gC, readMachineMetricsLatest as gD, readMachineMetricsLatestForWorkspace as gE, readMachineMetricsSeries as gF, reapExpiredSessionListSnapshots as gG, reapStaleLeaseHolders as gH, reapStaleLeaseHoldersGlobal as gI, reconcileCodexCapacityWait as gJ, recordAuditEvent as gK, recordCodexAccountConnectors as gL, recordCodexAccountUsage as gM, recordCodexAccountUsageWithWakeTargets as gN, recordCodexTokenRefresh as gO, recordConnectionTokenRefresh as gP, recordConnectionUsed as gQ, recordLeaseDataPlaneUrl as gR, recordLeaseTerminalDataPlaneUrl as gS, recordPendingSessionToolCallResult as gT, recordSessionActiveCodexCredential as gU, recordSkippedContextCompaction as gV, recordStreamAcknowledgment as gW, recordStripeWebhookEvent as gX, recordUsageEvent as gY, recordWarmingSandboxCreated as gZ, recoverSessionDispatch as g_, listWorkspacesForSubject as ga, loadCodexCredentialForRun as gb, loadConnectionCredentialForBroker as gc, loadIntegrationOAuthClient as gd, loadVariableSetForRun as ge, loadWorkspaceEnvironmentForRun as gf, markFileUploadFailed as gg, markSandboxFileResourcesMaterialized as gh, markScheduledTaskRunFailedIfQueued as gi, markSessionSystemUpdateOutboxDeliveredInTransaction as gj, markSessionSystemUpdateOutboxFailed as gk, markSessionWorkflowWakeDelivered as gl, markSessionWorkflowWakeFailed as gm, markStaleRegistryCatalogItems as gn, markStripeWebhookProcessed as go, markWarmLeaseInstanceLost as gp, mcpServerIdForCapability as gq, nextSessionHistoryPosition as gr, normalizeBearerScheme as gs, normalizeMemoryText as gt, orphanedResultRowIndicesForRepair as gu, peekSessionWork as gv, persistDrainSnapshot as gw, persistWarmSnapshot as gx, planWorkspaceCaptureGc as gy, quarantineCodexCredentialForLease as gz, type AppendEventInput as h, settleSessionIdleWithParentOutbox as h$, registerDbBinding as h0, registerPendingSessionToolCall as h1, registerWorkspacePack as h2, releaseCodexCredentialLease as h3, releaseLeaseHolder as h4, removeWorkspaceMember as h5, renameCodexAccount as h6, renderWorkspaceMemoryBlock as h7, repairDetachedCodexCapacityAttempt as h8, reparkOrphanedSessionTurn as h9, setActiveCodexCredential as hA, setActiveSandbox as hB, setCodexCredentialExhausted as hC, setCodexCredentialExhaustedWithWakeTargets as hD, setCodexCredentialStatus as hE, setCodexCredentialStatusById as hF, setConnectionStatus as hG, setEnrollmentDisplayState as hH, setEnrollmentOpStreamState as hI, setEnrollmentWentOffline as hJ, setInitialActiveCodexCredential as hK, setRlsContext as hL, setSessionChildNotificationsMode as hM, setSessionCodexPin as hN, setSessionGoalLastContinuationTurn as hO, setSessionGoalStatus as hP, setSessionLastInputTokensForTurnAttempt as hQ, setSessionPin as hR, setTemporalWorkflowId as hS, setVariableSetVariable as hT, setWorkspaceDefaultRig as hU, setWorkspaceEnvironmentVariable as hV, setWorkspaceInferenceControl as hW, settleCodexCredentialFailover as hX, settleCodexCredentialLeaseLoss as hY, settlePendingSessionControl as hZ, settleScheduledTaskRunInTransaction as h_, replaceIntegrationOAuthClient as ha, requestSessionCompaction as hb, requestSessionControl as hc, requestSessionTurnRecovery as hd, requireFile as he, requireScheduledTask as hf, requireSession as hg, requireSocialConnection as hh, requireWorkspace as hi, reserveToolspaceCallForTurn as hj, resolveWorkspaceMemoryBlock as hk, revokeApiKey as hl, revokeConnection as hm, revokeEnrollment as hn, revokeViewer as ho, rlsContextForWorkspace as hp, rlsStrategyFor as hq, sanitizeEventPayload as hr, sanitizeEventString as hs, sanitizeMemoryText as ht, sanitizeModelPayload as hu, saveRunState as hv, saveWorkspaceMemory as hw, searchWorkspaceMemories as hx, sessionSubject as hy, sessionsWithActiveOpOnEnrollment as hz, type ApplyContextCompactionResult as i, shortMemoryId as i0, storeIntegrationOAuthClient as i1, sumUsageQuantity as i2, touchEnrollmentLastSeen as i3, touchLeaseHolder as i4, updateCodexRotationSettings as i5, updateConnection as i6, updateImportBatchCounts as i7, updateKnowledgeMemory as i8, updatePackInstallationStatus as i9, withCodexCredentialRefreshLock as iA, withRlsContext as iB, withWorkspaceRls as iC, withWorkspaceSubjectRls as iD, withWorkspaceUsageLock as iE, workspaceCaptureAtRevision as iF, workspaceCodexSubscriptionActive as iG, updatePtySessionActivity as ia, updateRecording as ib, updateRig as ic, updateRigChangeStatus as id, updateScheduledTask as ie, updateScheduledTaskRun as ig, updateSessionGoal as ih, updateSessionMcpServerCredentials as ii, updateSessionTitle as ij, updateVariableSet as ik, updateWorkspace as il, updateWorkspaceEnvironment as im, updateWorkspaceSettings as io, upsertBillingCustomer as ip, upsertCapabilityCatalogItem as iq, upsertCodexSubscriptionCredential as ir, upsertGitHubInstallation as is, upsertMachineMetricsLatest as it, upsertRegistryCapabilityCatalogItem as iu, upsertSandboxSessionEnvelope as iv, upsertSessionGoal as iw, upsertWorkspaceModelPolicy as ix, withAccountRls as iy, withCodexCapacityMutation as iz, type ApplySessionTurnSettlementInput as j, type ApplySessionTurnSettlementResult as k, type ArmCodexCapacityWaitResult as l, CODEX_CAPACITY_REFRESH_MIN_MS as m, CODEX_CREDENTIAL_LEASE_TTL_MS as n, CODEX_ROTATION_STRATEGIES as o, type ChildNotificationsMode as p, provisionRoles, type ClaimSessionWorkForAttemptInput as q, type ClaimSessionWorkForAttemptResult as r, type ClearSessionContextResult as s, type CodexAccountStatus as t, type CodexAccountUsageSnapshot as u, type CodexAuthDeps as v, type CodexCapacityAvailabilityDecision as w, type CodexCapacityMutationResult as x, type CodexCapacityResetKind as y, type CodexCapacitySelectionContext as z };
+export { type CorrectWorkspaceMemoryResult as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BootstrapWorkspaceInput as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type CodexCapacitySelectionContext as D, type CodexCapacityWait as E, type CodexCapacityWaitStatus as F, type CodexCapacityWakeTarget as G, type CodexCredentialForRun as H, type CodexCredentialLeaseCandidateFilter as I, type CodexCredentialLeaseCandidateFilterResult as J, type CodexCredentialLeasePolicyScopeResolver as K, type CodexCredentialLeaseQuarantine as L, type CodexCredentialLeaseResult as M, type CodexCredentialLeaseSelection as N, type CodexCredentialLeaseSelectionContext as O, type CodexCredentialStatus as P, type ProvisionResult, type ProvisionRolesOptions, type CodexCredentialTokens as Q, type CodexLeaseAccountStatus as R, type CodexPinSource as S, type CodexRotationSettings as T, type CodexRotationStrategy as U, type ComposerDraftRow as V, type ConnectionBrokerDeps as W, type ConnectionCredentialForBroker as X, ConnectionRefreshHttpError as Y, type ConsumeOAuthStateNonceInput as Z, type CorrectWorkspaceMemoryInput as _, type AcceptSessionApprovalDecisionResult as a, type MarkWarmLeaseInstanceLostResult as a$, type CreateCapabilityCatalogItemInput as a0, type CreateConnectionInput as a1, type CreateDbOptions as a2, type CreateImportBatchInput as a3, type CreateKnowledgeMemoryInput as a4, type CreatePackInstallationInput as a5, type CreateScheduledTaskInput as a6, type CreateSessionGoalInput as a7, type CreateSessionMcpServerInput as a8, type CreateSocialConnectionInput as a9, type IntegrationOAuthClientForUse as aA, type LeaseHolderKind as aB, type LeaseSnapshot as aC, type ListKnowledgeMemoryOptions as aD, type ListSessionEventsOptions as aE, type ListSessionsForSubjectOptions as aF, type ListSessionsOptions as aG, type LiveModalSandboxLeaseAttribution as aH, MACHINE_METRICS_SERIES_INTERVAL_MS as aI, MAX_INTERNAL_UPDATE_BATCH_BYTES as aJ, MAX_INTERNAL_UPDATE_BATCH_MEMBERS as aK, MAX_INTERNAL_UPDATE_BYTES as aL, MEMORY_ACTIVE_RECORD_CAP as aM, MEMORY_BLOCK_KIND_ORDER as aN, MEMORY_BLOCK_RECORD_LIMIT as aO, MEMORY_CORRECT_TOOL_DESCRIPTION as aP, MEMORY_KIND_SECTION_TITLES as aQ, MEMORY_NEAR_DUP_COSINE_THRESHOLD as aR, MEMORY_NEAR_DUP_NEIGHBORS as aS, MEMORY_SAVE_TOOL_DESCRIPTION as aT, MEMORY_SEARCH_DEFAULT_LIMIT as aU, MEMORY_SEARCH_MAX_LIMIT as aV, MEMORY_SEARCH_TOOL_DESCRIPTION as aW, MEMORY_TEXT_MAX_CHARS as aX, MEMORY_VISIBLE_RECORD_CAP as aY, type MachineMetricsRow as aZ, type MachineMetricsSample as a_, type CreateSocialPostInput as aa, type CreditBalanceByAccount as ab, type Database as ac, type DbClient as ad, type DeviceEnrollmentRequestRecord as ae, type DeviceEnrollmentStatus as af, type EditQueueCommandResult as ag, type EffectiveControlBlocker as ah, type EffectiveControlResumeOption as ai, type EffectiveControlState as aj, type EffectiveSessionControl as ak, type EnableCapabilityInstallationInput as al, type EnabledMcpCapabilityServer as am, type EnqueueSessionTurnInput as an, type EnrollmentExposure as ao, type EnrollmentOs as ap, type EnrollmentRecord as aq, type EnrollmentStatus as ar, type ExpiredFileUploadCleanupClaim as as, type FileUploadCleanupClaimResult as at, type ForceDrainResult as au, type GitHubInstallation as av, type GoalContinuationDecision as aw, type ImportBatch as ax, type InitializeSessionStartInput as ay, type InitializeSessionStartResult as az, type AccrueWarmSecondsResult as b, type SetSessionCodexPinOptions as b$, type MemoryBlockRecord as b0, type MemoryEmbedder as b1, type MemorySanitizeResult as b2, type MeterableWarmLease as b3, type PendingSessionToolCallInput as b4, type QueueCommandConflictCode as b5, QueueCommandConflictError as b6, type QueueCommandResult as b7, type QueuedTurnRow as b8, type ReapDrainable as b9, type SaveWorkspaceMemoryResult as bA, type SessionAttemptInterruptionSettlement as bB, type SessionCodexState as bC, type SessionCommandActor as bD, SessionCommandIdempotencyError as bE, type SessionCommandReceiptRow as bF, SessionContextBusyError as bG, SessionControlConflictError as bH, SessionControlInvariantError as bI, type SessionControlMutationResult as bJ, type SessionLineage as bK, SessionListAccessError as bL, type SessionListCursor as bM, SessionListCursorError as bN, type SessionMcpServerForRun as bO, SessionPinAccessError as bP, SessionPinVersionConflictError as bQ, type SessionRecordingCodec as bR, type SessionRecordingMode as bS, type SessionRecordingRow as bT, type SessionRecordingState as bU, type SessionSystemUpdateOutboxDelivery as bV, type SessionTurnAttemptOutcome as bW, type SessionTurnRecordingSettlement as bX, type SessionWorkPeek as bY, type SessionWorkTrigger as bZ, type SessionWorkflowWake as b_, type ReconcileCodexCapacityWaitResult as ba, type RecoverSessionDispatchInput as bb, type RecoverSessionDispatchResult as bc, type RegisterWorkspacePackInput as bd, type RegistryCapabilityCatalogItemInput as be, type RegistryCatalogSurfaceKey as bf, type ReplaceIntegrationOAuthClientInput as bg, type RequestSessionTurnRecoveryInput as bh, type RequestSessionTurnRecoveryResult as bi, type ResolveConnectionCredentialInput as bj, type ResolveConnectionCredentialResult as bk, RigActiveVersionChangedError as bl, RigChangeAlreadyVerifyingError as bm, RigChangeTransitionError as bn, type RigVersionContentInput as bo, type RlsContext as bp, type RlsStrategy as bq, SESSION_ANCESTRY_LIMIT as br, SandboxImageConflictError as bs, type SandboxKind as bt, type SandboxLeaseLiveness as bu, SandboxLeaseSupersededError as bv, type SandboxPtySessionRow as bw, type SandboxRecord as bx, SandboxRigConflictError as by, type SaveWorkspaceMemoryInput as bz, type AcquireLeaseInput as c, claimFileUploadCleanup as c$, type SettleCodexCredentialFailoverResult as c0, type SettleCodexCredentialLeaseLossResult as c1, type SteerQueueCommandResult as c2, type StoreIntegrationOAuthClientInput as c3, type StoredIntegrationOAuthClient as c4, type StreamAcknowledgment as c5, type SubmitHumanPromptResult as c6, type ToolspaceCallReservation as c7, type TurnAttemptFenceRejectReason as c8, type UpdateConnectionInput as c9, acquireLease as cA, activateRigVersion as cB, addSessionSystemUpdate as cC, addSessionSystemUpdateWithSourceMutation as cD, allAccountPermissions as cE, allWorkspacePermissions as cF, appendSessionEventToSandboxGroup as cG, appendSessionEvents as cH, appendSessionEventsAndUpdateSession as cI, appendSessionEventsForTurnAttempt as cJ, appendSessionEventsWithLockedSessionUpdate as cK, appendSessionHistoryItems as cL, applyContextCompaction as cM, applyCreditDebitUpToBalance as cN, applyCreditLedgerEntry as cO, applySessionTurnSettlement as cP, approveDeviceEnrollmentRequest as cQ, armCodexCapacityWait as cR, assertAgentCommandAuthorityInTransaction as cS, autoResumeSessionBranchInTransaction as cT, beginRigChangeVerificationAttempt as cU, bootstrapWorkspace as cV, buildChildCompletionDigest as cW, buildCodexTokenResolver as cX, buildConnectionTokenResolver as cY, canonicalSessionCommandHash as cZ, claimExpiredFileUploadCleanup as c_, type UpdateImportBatchCountsInput as ca, type UpdateKnowledgeMemoryInput as cb, type UpdateScheduledTaskInput as cc, type UpdateSessionMcpServerCredentialsInput as cd, type UpdateSessionMcpServerCredentialsResult as ce, type UserLookup as cf, type VariableSetForRun as cg, WORKSPACE_MEMORY_BLOCK_EMPTY as ch, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as ci, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as cj, type WorkspaceCaptureCommitResult as ck, type WorkspaceCaptureGcPlan as cl, type WorkspaceCaptureGcRow as cm, type WorkspaceCaptureRow as cn, type WorkspaceControlLockMode as co, type WorkspaceControlMutationResult as cp, type WorkspaceEnvironmentForRun as cq, type WorkspaceMemoryOrigin as cr, type WorkspaceMemorySearchInput as cs, type WorkspaceMemorySearchMode as ct, type WorkspaceMemorySearchResult as cu, type WorkspaceModelPolicy as cv, abandonRecordingForTurnAttempt as cw, acceptSessionApprovalDecision as cx, accrueWarmSeconds as cy, acquireCodexCredentialLease as cz, type AcquireLeaseResult as d, decryptEnvironmentValue as d$, claimPendingSessionSystemUpdateOutbox as d0, claimPendingSessionWorkflowWakes as d1, claimSessionWorkForAttempt as d2, clearDurablePendingSessionToolCalls as d3, clearEnrollmentWentOffline as d4, clearSessionContext as d5, clearSessionGoal as d6, clearedContextMarkerItem as d7, closePtySession as d8, closeSessionTurnAttemptInTransaction as d9, countWorkspaceEnvironments as dA, countWorkspacesForAccount as dB, createApiKey as dC, createConnection as dD, createDb as dE, createDeviceEnrollmentRequest as dF, createEnrollment as dG, createFileUpload as dH, createImportBatch as dI, createKnowledgeMemory as dJ, createRig as dK, createRigChange as dL, createRigVersion as dM, createRigVersionForChangePromotion as dN, createSandbox as dO, createScheduledTask as dP, createScheduledTaskRun as dQ, createSession as dR, createSessionGoal as dS, createSessionMcpServers as dT, createSessionWithIdempotencyKey as dU, createSocialConnection as dV, createSocialPost as dW, createVariableSet as dX, createWorkspace as dY, createWorkspaceEnvironment as dZ, decodeSessionListCursor as d_, codexCapacityRefreshBackoffMs as da, commitWarmingToWarm as db, completeExpiredFileUploadCleanup as dc, completeFileUpload as dd, completeFileUploadCleanup as de, computeWorkspaceCaptureGcPlan as df, confirmDrainCold as dg, consumeDeviceEnrollmentRequest as dh, consumeIntegrationOAuthStateNonce as di, correctWorkspaceMemory as dj, countActiveApiKeysForWorkspace as dk, countActiveSessionHistoryItems as dl, countActiveSessionsForWorkspace as dm, countActiveSessionsUsingEnvironment as dn, countActiveSessionsUsingVariableSet as dp, countConsecutiveReactiveRotations as dq, countQueuedTurns as dr, countRigs as ds, countSandboxLeasesByLiveness as dt, countScheduledTasksForWorkspace as du, countScheduledTasksUsingEnvironment as dv, countScheduledTasksUsingVariableSet as dw, countSessionHistoryItems as dx, countSessionsUsingRig as dy, countVariableSets as dz, type ActiveSandboxPointer as e, getRecording as e$, decryptedCapabilityHeaders as e0, deleteRecording as e1, deleteRig as e2, deleteRigIfNoActiveSessions as e3, deleteScheduledTask as e4, deleteSessionQueueItemInTransaction as e5, deleteVariableSet as e6, deleteVariableSetVariable as e7, deleteWorkspace as e8, deleteWorkspaceCaptureRows as e9, forceDrainOverLimitViewerOnlyBoxes as eA, getActiveSessionHistoryItems as eB, getAnySessionInGroup as eC, getBillingBalance as eD, getBillingCustomer as eE, getCapabilityCatalogItem as eF, getCapabilityInstallation as eG, getCodexCapacityWaitForSession as eH, getCodexCredentialStatus as eI, getCodexRotationSettings as eJ, getComposerDraftInTransaction as eK, getConnectionMetadata as eL, getDeviceEnrollmentRequestByDeviceCode as eM, getEnrollment as eN, getFile as eO, getFileUpload as eP, getKnowledgeMemory as eQ, getLatestRunState as eR, getLatestStartedSessionTurn as eS, getManagedAccount as eT, getManagedUserByEmail as eU, getMaterializedSandboxFileResources as eV, getOpenPtySession as eW, getOrCreateSessionSystemUpdateOutbox as eX, getPackInstallation as eY, getPendingDeviceEnrollmentRequestByUserCode as eZ, getPendingDeviceEnrollmentRequestByUserCodeGlobal as e_, deleteWorkspaceEnvironment as ea, deleteWorkspaceEnvironmentVariable as eb, deleteWorkspacePack as ec, denyDeviceEnrollmentRequest as ed, disableCapabilityInstallation as ee, disconnectAllCodexAccounts as ef, disconnectCodexAccount as eg, editQueuedTurnInTransaction as eh, enableCapabilityInstallation as ei, enablePackInstallation as ej, encodeSessionListCursor as ek, encryptEnvironmentValue as el, enqueueSessionTurn as em, enqueueSessionWorkflowWake as en, enqueueSessionWorkflowWakeIfRunnable as eo, enqueueSessionWorkflowWakeInTransaction as ep, ensureCodexRotationSettings as eq, ensureManagedAccessForUser as er, estimateMemoryTokens as es, evaluateGoalContinuation as et, evaluateSessionControl as eu, evaluateSessionControls as ev, failWarmingToCold as ew, fetchCodexUsageForAccount as ex, finalizeEnrollmentByToken as ey, findActiveApiKeyByHash as ez, type AddSessionSystemUpdateInput as f, listDistinctVariableSetIdsInGroup as f$, getRig as f0, getRigByName as f1, getRigChange as f2, getRigName as f3, getRigVersion as f4, getRigVersionById as f5, getSandbox as f6, getSandboxSessionEnvelope as f7, getScheduledTask as f8, getSession as f9, grantWorkspaceAccess as fA, hasCreditLedgerEntry as fB, hashMemoryText as fC, heartbeatCodexCredentialLease as fD, heartbeatCodexCredentialLeaseUntil as fE, heartbeatLeaseHolder as fF, ingestMachineMetricsSample as fG, initializeSessionStartAtomically as fH, insertFailedWorkspaceCapture as fI, insertMachineMetricsSeries as fJ, insertPtySession as fK, insertRecording as fL, insertWorkspaceCapture as fM, interruptedToolCallResult as fN, isCodexBilledTurn as fO, isMemoryTextTooLong as fP, isPrivateAddress as fQ, isSessionCompactionRequested as fR, isStripeWebhookProcessed as fS, latestWorkspaceCapture as fT, listApiKeys as fU, listCapabilityCatalogItems as fV, listCapabilityInstallations as fW, listCodexAccountStatuses as fX, listConnectionsMetadata as fY, listCreditBalancesByAccount as fZ, listDistinctRigVersionIdsInGroup as f_, getSessionByCreateIdempotencyKey as fa, getSessionCodexState as fb, getSessionEvent as fc, getSessionEventByClientEventId as fd, getSessionForSubject as fe, getSessionGoal as ff, getSessionHistoryItems as fg, getSessionLineage as fh, getSessionQueueSnapshot as fi, getSessionTurn as fj, getSessionTurnForAttempt as fk, getSocialConnection as fl, getStoredCapabilityHeaderCiphertext as fm, getStreamAcknowledgment as fn, getVariableSet as fo, getVariableSetByName as fp, getVariableSetValuesForRun as fq, getWorkspace as fr, getWorkspaceControlEvent as fs, getWorkspaceDefaultRigId as ft, getWorkspaceEnvironment as fu, getWorkspaceEnvironmentByName as fv, getWorkspaceEnvironmentValuesForRun as fw, getWorkspaceGrant as fx, getWorkspaceModelPolicy as fy, getWorkspacePack as fz, type AddSessionSystemUpdateResult as g, persistWarmSnapshot as g$, listEnabledMcpCapabilityServers as g0, listEnrollments as g1, listGitHubInstallationIdsForWorkspace as g2, listGitHubInstallationsForWorkspace as g3, listKnowledgeMemories as g4, listLiveModalSandboxLeaseAttributions as g5, listMeterableWarmLeases as g6, listOpenPtySessions as g7, listOutstandingSessionSystemUpdates as g8, listPackInstallations as g9, listWorkspacesForSubject as gA, loadCodexCredentialForRun as gB, loadConnectionCredentialForBroker as gC, loadIntegrationOAuthClient as gD, loadVariableSetForRun as gE, loadWorkspaceEnvironmentForRun as gF, lockWorkspaceInferenceControl as gG, markFileUploadFailed as gH, markSandboxFileResourcesMaterialized as gI, markScheduledTaskRunFailedIfQueued as gJ, markSessionSystemUpdateOutboxDeliveredInTransaction as gK, markSessionSystemUpdateOutboxFailed as gL, markSessionWorkflowWakeDelivered as gM, markSessionWorkflowWakeFailed as gN, markStaleRegistryCatalogItems as gO, markStripeWebhookProcessed as gP, markWarmLeaseInstanceLost as gQ, mcpServerIdForCapability as gR, moveQueuedTurnInTransaction as gS, mutateSessionControlInTransaction as gT, mutateWorkspaceControlInTransaction as gU, nextSessionHistoryPosition as gV, normalizeBearerScheme as gW, normalizeMemoryText as gX, orphanedResultRowIndicesForRepair as gY, peekSessionWork as gZ, persistDrainSnapshot as g_, listPendingCodexCapacityWakeTargets as ga, listPendingSessionTurns as gb, listRecordings as gc, listRegistryCatalogSurfaceKeys as gd, listRigChanges as ge, listRigVersions as gf, listRigs as gg, listSandboxes as gh, listScheduledTaskRuns as gi, listScheduledTasks as gj, listSessionEvents as gk, listSessionIdsInGroup as gl, listSessionMcpServerMetadata as gm, listSessionMcpServersForRun as gn, listSessionSystemUpdatesForTurn as go, listSessionTurns as gp, listSessions as gq, listSessionsForSubject as gr, listSocialConnections as gs, listSocialPosts as gt, listUsageEvents as gu, listVariableSets as gv, listWorkspaceControlEvents as gw, listWorkspaceEnvironments as gx, listWorkspaceMembers as gy, listWorkspacePacks as gz, AgentCommandAuthorityError as h, saveRunState as h$, planWorkspaceCaptureGc as h0, quarantineCodexCredentialForLease as h1, reArmDrainingLease as h2, readActiveSandbox as h3, readLease as h4, readMachineMetricsLatest as h5, readMachineMetricsLatestForWorkspace as h6, readMachineMetricsSeries as h7, reapExpiredSessionListSnapshots as h8, reapStaleLeaseHolders as h9, releaseCodexCredentialLease as hA, releaseLeaseHolder as hB, removeWorkspaceMember as hC, renameCodexAccount as hD, renderWorkspaceMemoryBlock as hE, replaceIntegrationOAuthClient as hF, requestSessionCompaction as hG, requestSessionTurnRecovery as hH, requireFile as hI, requireScheduledTask as hJ, requireSession as hK, requireSocialConnection as hL, requireWorkspace as hM, reserveSessionCommandReceipt as hN, reserveToolspaceCallForTurn as hO, resolveWorkspaceMemoryBlock as hP, revokeApiKey as hQ, revokeConnection as hR, revokeEnrollment as hS, revokeViewer as hT, rlsContextForWorkspace as hU, rlsStrategyFor as hV, sanitizeEventPayload as hW, sanitizeEventString as hX, sanitizeMemoryText as hY, sanitizeModelPayload as hZ, saveComposerDraftInTransaction as h_, reapStaleLeaseHoldersGlobal as ha, reconcileCodexCapacityWait as hb, recordAuditEvent as hc, recordCodexAccountConnectors as hd, recordCodexAccountUsage as he, recordCodexAccountUsageWithWakeTargets as hf, recordCodexTokenRefresh as hg, recordConnectionTokenRefresh as hh, recordConnectionUsed as hi, recordLeaseDataPlaneUrl as hj, recordLeaseTerminalDataPlaneUrl as hk, recordPendingSessionToolCallResult as hl, recordSessionActiveCodexCredential as hm, recordSkippedContextCompaction as hn, recordStreamAcknowledgment as ho, recordStripeWebhookEvent as hp, recordUsageEvent as hq, recordWarmingSandboxCreated as hr, recoverSessionDispatch as hs, refreshOAuthConnectionCredential as ht, registerDbBinding as hu, registerInternalUpdateWakeInTransaction as hv, registerPendingSessionToolCall as hw, registerSessionTurnAttemptClaim as hx, registerSessionWorkflowWakeInTransaction as hy, registerWorkspacePack as hz, type AgentInternalUpdateCommandResult as i, upsertCapabilityCatalogItem as i$, saveWorkspaceMemory as i0, searchWorkspaceMemories as i1, sendAgentMessageInTransaction as i2, serializeEffectiveSessionControl as i3, sessionSubject as i4, sessionsWithActiveOpOnEnrollment as i5, setActiveCodexCredential as i6, setActiveSandbox as i7, setCodexCredentialExhausted as i8, setCodexCredentialExhaustedWithWakeTargets as i9, steerQueuedTurnInTransaction as iA, storeIntegrationOAuthClient as iB, submitHumanPromptInTransaction as iC, sumUsageQuantity as iD, supersedeSessionCurrentDirectionInTransaction as iE, touchEnrollmentLastSeen as iF, touchLeaseHolder as iG, updateCodexRotationSettings as iH, updateConnection as iI, updateImportBatchCounts as iJ, updateKnowledgeMemory as iK, updatePackInstallationStatus as iL, updatePtySessionActivity as iM, updateRecording as iN, updateRig as iO, updateRigChangeStatus as iP, updateScheduledTask as iQ, updateScheduledTaskRun as iR, updateSessionCommandReceiptResult as iS, updateSessionGoal as iT, updateSessionMcpServerCredentials as iU, updateSessionTitle as iV, updateVariableSet as iW, updateWorkspace as iX, updateWorkspaceEnvironment as iY, updateWorkspaceSettings as iZ, upsertBillingCustomer as i_, setCodexCredentialStatus as ia, setCodexCredentialStatusById as ib, setConnectionStatus as ic, setEnrollmentDisplayState as id, setEnrollmentOpStreamState as ie, setEnrollmentWentOffline as ig, setInitialActiveCodexCredential as ih, setRlsContext as ii, setSessionCodexPin as ij, setSessionGoalLastContinuationTurn as ik, setSessionGoalStatus as il, setSessionLastInputTokensForTurnAttempt as im, setSessionPin as io, setTemporalWorkflowId as ip, setVariableSetVariable as iq, setWorkspaceDefaultRig as ir, setWorkspaceEnvironmentVariable as is, settleCodexCredentialFailover as it, settleCodexCredentialLeaseLoss as iu, settleScheduledTaskRunInTransaction as iv, settleSessionAttemptInterruptions as iw, settleSessionIdleWithParentOutbox as ix, shortMemoryId as iy, steerAgentSessionInTransaction as iz, type AppendEventInput as j, upsertCodexSubscriptionCredential as j0, upsertGitHubInstallation as j1, upsertMachineMetricsLatest as j2, upsertRegistryCapabilityCatalogItem as j3, upsertSandboxSessionEnvelope as j4, upsertSessionGoal as j5, upsertWorkspaceModelPolicy as j6, withAccountRls as j7, withCodexCapacityMutation as j8, withCodexCredentialRefreshLock as j9, withRlsContext as ja, withWorkspaceRls as jb, withWorkspaceSubjectRls as jc, withWorkspaceUsageLock as jd, workspaceCaptureAtRevision as je, workspaceCodexSubscriptionActive as jf, type ApplyContextCompactionResult as k, type ApplySessionTurnSettlementInput as l, type ApplySessionTurnSettlementResult as m, type ArmCodexCapacityWaitResult as n, CODEX_CAPACITY_REFRESH_MIN_MS as o, CODEX_CREDENTIAL_LEASE_TTL_MS as p, provisionRoles, CODEX_ROTATION_STRATEGIES as q, type ClaimSessionWorkForAttemptInput as r, type ClaimSessionWorkForAttemptResult as s, type ClearSessionContextResult as t, type CodexAccountStatus as u, type CodexAccountUsageSnapshot as v, type CodexAuthDeps as w, type CodexCapacityAvailabilityDecision as x, type CodexCapacityMutationResult as y, type CodexCapacityResetKind as z };