@opengeni/db 0.7.2 → 0.9.3

package/dist/provision-roles.d.ts

@@ -1,9 +1,9 @@
-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 { TurnInitiatorContext, TurnInitiator, ResourceRef, ToolRef, ReasoningEffort, 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, 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, CodexTokenSnapshot, CodexUsagePayload } from '@opengeni/codex';
+import { SQL } from 'drizzle-orm';
 import { PgDatabase, PgTransactionConfig } from 'drizzle-orm/pg-core';
-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 { 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-CdPGTHlD.js';
 import './migrate.js';
 
 declare const SESSION_ANCESTRY_LIMIT = 10000;
@@ -12,6 +12,11 @@ type EffectiveControlState = "active" | "paused";
 type SessionCommandActor = {
     type: "human" | "operator";
     subjectId: string;
+} | {
+    type: "service";
+    subjectId: string;
+    subjectLabel?: string;
+    context?: TurnInitiatorContext;
 } | {
     type: "agent_attempt";
     attemptId: string;
@@ -52,8 +57,28 @@ type EffectiveSessionControl = {
     settlement: {
         state: "stopping";
         attemptCount: number;
+        interruptionPendingCount: number;
+        quiescencePendingCount: number;
     } | null;
 };
+declare const SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS = 200;
+declare const SESSION_DISCOVERY_CONTROL_TARGET_LIMIT = 100;
+/**
+ * Purpose-built control projection for session discovery. Full blocker evidence,
+ * actors/reasons, resume options, etags, and settlement state remain available
+ * from the ordinary session detail APIs; this shape is intentionally only what
+ * `sessions_list` renders.
+ */
+type SessionDiscoveryControl = {
+    state: EffectiveControlState;
+    primaryBlocker: {
+        kind: "session" | "workspace";
+        sessionId?: string;
+        displayName: string;
+        displayNameOriginalChars: number;
+    } | null;
+    additionalBlockerCount: number;
+};
 declare function serializeEffectiveSessionControl(control: EffectiveSessionControl): {
     primaryBlocker: (Omit<EffectiveControlBlocker, "changedAt"> & {
         changedAt: string | null;
@@ -82,6 +107,8 @@ declare function serializeEffectiveSessionControl(control: EffectiveSessionContr
     settlement: {
         state: "stopping";
         attemptCount: number;
+        interruptionPendingCount: number;
+        quiescencePendingCount: number;
     } | null;
 };
 type WorkspaceControlRow = {
@@ -121,6 +148,47 @@ declare function assertAgentCommandAuthorityInTransaction(db: Database, input: {
 }): Promise<void>;
 declare function canonicalSessionCommandHash(value: unknown): string;
 declare function lockWorkspaceInferenceControl(db: Database, workspaceId: string, mode: WorkspaceControlLockMode): Promise<WorkspaceControlRow>;
+type SessionEventWriteLockInput = {
+    workspaceId: string;
+    /**
+     * Control-aware writes take this lock first. Callers that already hold the
+     * workspace control row (for example a Pause mutation under FOR UPDATE) say
+     * `already_locked`; ordinary audit/title appends explicitly use `none`.
+     */
+    controlLock: WorkspaceControlLockMode | "already_locked" | "none";
+    /** Used only when a staged caller already established the workspace prefix. */
+    workspaceLock?: "key_share" | "already_locked";
+    sessionIds?: string[];
+    turnIds?: string[];
+    attemptIds?: string[];
+};
+type SessionEventWriteLocks = {
+    control: WorkspaceControlRow | null;
+    workspace: typeof workspaces.$inferSelect | null;
+    sessions: Array<typeof sessions.$inferSelect>;
+    turns: Array<typeof sessionTurns.$inferSelect>;
+    attempts: Array<typeof sessionTurnAttempts.$inferSelect>;
+};
+/**
+ * Establish the one canonical lock prefix for every `session_events` writer:
+ *
+ *   workspace_inference_controls (when control-aware)
+ *     -> actual workspaces row FOR KEY SHARE
+ *     -> session rows FOR UPDATE, UUID ordered
+ *     -> exact turn rows FOR UPDATE, UUID ordered
+ *     -> exact attempt rows FOR UPDATE, UUID ordered
+ *
+ * `FOR KEY SHARE` is deliberate. Event inserts need the workspace key to remain
+ * stable for their FK, but they do not mutate the workspace. The old generic
+ * `FOR UPDATE` lock serialized unrelated sessions and inverted the activity
+ * path's session -> implicit workspace-FK edge.
+ *
+ * Complex lifecycle transactions may acquire allocator/control locks before
+ * this helper and may discover exact turn IDs only after locking the session.
+ * They use the explicit `already_locked` stages, while retaining the same
+ * monotonic table order. New event writers should prefer one complete call.
+ */
+declare function lockSessionEventWriteRows(db: Database, input: SessionEventWriteLockInput): Promise<SessionEventWriteLocks>;
 declare function registerSessionTurnAttemptClaim(db: Database, input: {
     id: string;
     accountId: string;
@@ -153,9 +221,23 @@ declare function closeSessionTurnAttemptInTransaction(db: Database, input: {
 }>;
 declare function evaluateSessionControls(db: Database, workspaceId: string, sessionIds: string[], options?: {
     lock?: WorkspaceControlLockMode;
+    /** Reuse a control row already locked before workspace/session/turn rows. */
+    workspaceControl?: WorkspaceControlRow | undefined;
 }): Promise<Map<string, EffectiveSessionControl>>;
+/**
+ * Return one compact aggregate row per target for `sessions_list`.
+ *
+ * Unlike `evaluateSessionControls`, the database boundary never returns a row
+ * per blocker/ancestor, nor does application code construct blocker or resume
+ * option arrays. The recursive walk carries no growing visited-path array: a
+ * missing ancestor stops below the limit, while a cycle cannot reach a root and
+ * therefore runs into the hard `SESSION_ANCESTRY_LIMIT`. The externally
+ * supplied target set is capped by `SESSION_DISCOVERY_CONTROL_TARGET_LIMIT`.
+ */
+declare function evaluateSessionDiscoveryControls(db: Database, workspaceId: string, sessionIds: string[]): Promise<Map<string, SessionDiscoveryControl>>;
 declare function evaluateSessionControl(db: Database, workspaceId: string, sessionId: string, options?: {
     lock?: WorkspaceControlLockMode;
+    workspaceControl?: WorkspaceControlRow | undefined;
 }): Promise<EffectiveSessionControl>;
 declare function reserveSessionCommandReceipt(db: Database, input: {
     accountId: string;
@@ -224,7 +306,7 @@ declare function autoResumeSessionBranchInTransaction(db: Database, input: {
     workspaceId: string;
     sessionId: string;
     actor: string;
-    reason: "human_send" | "human_steer" | "agent_steer";
+    reason: "human_send" | "human_steer" | "service_send" | "service_steer" | "agent_steer";
     observedControlEtag?: string | null;
 }): Promise<{
     revision: number;
@@ -251,6 +333,12 @@ declare function mutateWorkspaceControlInTransaction(db: Database, input: {
     expectedRevision?: number | null;
 }): Promise<WorkspaceControlMutationResult>;
 
+type FrozenTurnInitiator = {
+    initiator: TurnInitiator;
+    context: TurnInitiatorContext;
+};
+declare function frozenInitiatorForCommandActor(db: Database, workspaceId: string, actor: SessionCommandActor, subjectLabel?: string): Promise<FrozenTurnInitiator>;
+
 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;
@@ -391,12 +479,14 @@ declare function submitHumanPromptInTransaction(db: Database, input: {
     workspaceId: string;
     sessionId: string;
     subjectId: string;
+    subjectLabel?: string;
     actor: SessionCommandActor;
     operationKey: string;
     delivery: "send" | "steer";
     controlEtag?: string | null;
     expectedDraftRevision?: number | null;
     text: string;
+    turnInstructions?: string | null;
     resources: ResourceRef[];
     tools: ToolRef[];
     model?: string | null;
@@ -449,23 +539,6 @@ declare function encryptEnvironmentValue(key: Uint8Array, plaintext: string): st
  */
 declare function decryptEnvironmentValue(key: Uint8Array, stored: string): string;
 
-/**
- * Last line of defense against a session event crashing a whole turn.
- *
- * Postgres `text`/`jsonb` cannot store a NUL byte (U+0000) nor lone UTF-16
- * surrogates. Raw exec output routinely carries both -- chrome/crashpad logs,
- * `cat` of a binary, random bytes -- and the worker persists that output verbatim
- * inside `agent.toolCall.output` / `sandbox.command.output` event payloads. When
- * such a payload reaches `INSERT INTO session_events`, the driver rejects it
- * ("Failed query: insert into session_events") and the turn dies.
- *
- * `sanitizeEventPayload` deep-walks any payload value (objects, arrays, nested)
- * and, for every string, strips NUL and rewrites invalid/lone UTF-16 surrogates
- * to the Unicode replacement char (U+FFFD), so the result is always valid UTF-8
- * that jsonb can store. It is cheap and total: only strings are touched, and only
- * the two disallowed classes of code unit -- no meaningful text is lost, no
- * truncation (truncation is handled elsewhere).
- */
 /**
  * Strip NUL and repair invalid/lone UTF-16 surrogates in a single string.
  * Returns the input unchanged (same reference) when it is already clean, so the
@@ -490,6 +563,76 @@ declare function sanitizeEventPayload<T>(payload: T): T;
  */
 declare function sanitizeModelPayload<T>(payload: T): T;
 
+type DatabaseFailureCode = "db_deadlock" | "db_serialization_failure" | "db_failure";
+type PersistenceRetryOutcome = "not_retryable" | "exhausted";
+type SafeDatabaseErrorFacts = {
+    severity?: string;
+    schema?: string;
+    table?: string;
+    column?: string;
+    dataType?: string;
+    constraint?: string;
+    routine?: string;
+};
+type PersistenceFailureDetails = {
+    code: DatabaseFailureCode;
+    sqlState: string | null;
+    stage: string;
+    eventTypes: string[];
+    correlationId: string;
+    attempts: number;
+    retryOutcome: PersistenceRetryOutcome;
+    database: SafeDatabaseErrorFacts;
+};
+/** Find the driver SQLSTATE even when Drizzle wrapped it under nested causes. */
+declare function nestedPostgresSqlState(error: unknown): string | null;
+declare function databaseFailureCode(sqlState: string | null): DatabaseFailureCode;
+declare function isRetryablePersistenceSqlState(sqlState: string | null): boolean;
+/**
+ * Distinguish database/ORM failures from expected domain exceptions when a
+ * driver omitted SQLSTATE. This checks shape only and never retains query text,
+ * bound parameters, or a raw driver cause.
+ */
+declare function isDatabasePersistenceFailure(error: unknown): boolean;
+/** Extract only PostgreSQL diagnostic identifiers; never query text/parameters. */
+declare function safeDatabaseErrorFacts(error: unknown): SafeDatabaseErrorFacts;
+/** Public-safe cause that preserves database classification without driver data. */
+declare class SanitizedDatabasePersistenceCause extends Error {
+    readonly sqlState: string | null;
+    readonly database: SafeDatabaseErrorFacts;
+    readonly name = "SanitizedDatabasePersistenceCause";
+    constructor(sqlState: string | null, database: SafeDatabaseErrorFacts);
+}
+/**
+ * Public-safe replacement for a raw Drizzle/postgres-js failure. Its `cause`
+ * is a newly constructed sanitized projection; the original driver cause can
+ * contain full SQL and bound parameters and is never retained.
+ */
+declare class SessionEventPersistenceError extends Error {
+    readonly details: PersistenceFailureDetails;
+    readonly name = "SessionEventPersistenceError";
+    readonly cause: SanitizedDatabasePersistenceCause;
+    constructor(details: PersistenceFailureDetails);
+    get code(): DatabaseFailureCode;
+}
+declare function isSessionEventPersistenceError(error: unknown): error is SessionEventPersistenceError;
+type IdempotentPersistenceTransactionOptions = {
+    stage: string;
+    eventTypes?: string[];
+    maxAttempts?: number;
+    correlationId?: string;
+    onRetry?: (input: {
+        attempt: number;
+        sqlState: "40P01" | "40001";
+    }) => void | Promise<void>;
+};
+/**
+ * Retry only the supplied idempotent database transaction/savepoint. Provider
+ * inference, tools, NATS, and all other external effects must remain outside
+ * this function. A single correlation ID follows every persistence attempt.
+ */
+declare function runIdempotentPersistenceTransaction<T>(options: IdempotentPersistenceTransactionOptions, transaction: (attempt: number) => Promise<T>): Promise<T>;
+
 /** Reject writes whose sanitized text exceeds this many characters. */
 declare const MEMORY_TEXT_MAX_CHARS = 4000;
 /** Per-workspace cap on agent-visible memory records (active ∪ approved). */
@@ -536,6 +679,7 @@ declare function renderWorkspaceMemoryBlock(records: readonly MemoryBlockRecord[
 
 type ProvisionResult = {
     appRole: string | null;
+    hostExportRole: string | null;
     temporalRole: string | null;
     temporalDatabases: string[];
     schema: string;
@@ -559,6 +703,16 @@ type ProvisionRolesOptions = {
     rlsStrategy?: RlsStrategy;
     appRole?: string;
     appPassword?: string;
+    /**
+     * Optional cross-workspace projection role. It receives schema USAGE and
+     * EXECUTE only on the host-export API; it receives no table privileges.
+     * Provision it after the first migration run so the schema exists. The
+     * provisioner also registers same-owner default privileges for future
+     * host-export functions; shipped migrations preserve existing exporter ACLs
+     * when a migration-only upgrade adds a function.
+     */
+    hostExportRole?: string;
+    hostExportPassword?: string;
     temporalRole?: string;
     temporalPassword?: string;
     temporalDatabases?: string[];
@@ -616,21 +770,50 @@ type ResolveConnectionCredentialResult = {
     expiresAt?: Date | null;
 } | {
     status: "auth_needed";
-    reason: "missing_connection" | "expired" | "insufficient_scope" | "refresh_failed";
+    reason: McpCredentialAuthNeededReason;
     providerDomain: string;
+    provider?: string;
     connectionId?: string;
     scopes?: string[];
     resource?: string;
+    selectedResources?: McpConnectionResourceScope[];
     authorizationUrl?: string;
 };
 type ResolveConnectionCredentialInput = {
     workspaceId: string;
     subjectId?: string;
     serverId: string;
+    toolName?: string;
+    /** @deprecated Use toolName. Retained for the API's pre-existing broker call shape. */
     toolId?: string;
     connectionRef: McpServerConnectionRef;
     forceRefresh?: boolean;
 };
+type HostMcpCredentialResolverContext = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    rootSessionId: string;
+    turnId: string;
+    attemptId: string | null;
+    executionGeneration: number;
+    initiator: TurnInitiator;
+    initiatorContext: TurnInitiatorContext;
+    surface: McpCredentialsRequest["surface"];
+};
+declare class HostMcpCredentialScopeError extends Error {
+    constructor(field: "accountId" | "workspaceId" | "sessionId");
+}
+declare class HostMcpCredentialBindingError extends Error {
+    constructor(field: "provider" | "providerDomain" | "connectionId" | "scopes" | "resource" | "selectedResources");
+}
+/**
+ * Adapts the public embedding credential port to the runtime's connection
+ * resolver contract. Scope echoes are checked before credential headers can
+ * reach a request; the returned object is a fresh copy so a host cannot mutate
+ * headers after resolution.
+ */
+declare function buildHostConnectionTokenResolver(resolve: NonNullable<ConnectionCredentialsPort["mcpCredentials"]>, context: HostMcpCredentialResolverContext): (input: ResolveConnectionCredentialInput) => Promise<ResolveConnectionCredentialResult>;
 type ConnectionBrokerDeps = {
     loadCredential: typeof loadConnectionCredentialForBroker;
     recordRefresh: typeof recordConnectionTokenRefresh;
@@ -710,7 +893,7 @@ type CreateDbOptions = {
      * it as a per-session startup parameter (the supported, query-param-free way;
      * URL `?search_path=` is IGNORED by postgres-js). Keep `public` LAST so the
      * `vector` type and `gen_random_uuid()` (which live in `public` on the
-     * pgvector image) still resolve — the SPIKE-1 live footgun.
+     * pgvector image) still resolve — the schema-isolation contract live footgun.
      */
     searchPath?: string;
     /** RLS posture; defaults to `"force"` (today's standalone). */
@@ -733,6 +916,115 @@ declare function registerDbBinding(db: Database, binding: {
     rlsStrategy?: RlsStrategy;
     userLookup?: UserLookup;
 }): void;
+type HostExportKind = "session_event" | "usage_event";
+/**
+ * A leased row did not satisfy this consumer build's export contract. Only
+ * bounded schema diagnostics are retained here; the source payload is never
+ * copied into the error. The lease can therefore be failed visibly, or an
+ * operator can re-claim it with a known token and explicitly dead-letter the
+ * reported head cursor.
+ */
+declare class HostExportPayloadError extends Error {
+    readonly kind: HostExportKind;
+    readonly consumerId: string;
+    readonly leaseToken: string;
+    readonly cursor: string;
+    readonly schemaIssues: string[];
+    readonly name = "HostExportPayloadError";
+    constructor(kind: HostExportKind, consumerId: string, leaseToken: string, cursor: string, schemaIssues: string[]);
+}
+type HostExportConsumerStatus = {
+    exportKind: HostExportKind;
+    consumerId: string;
+    checkpoint: string;
+    enabled: boolean;
+    consecutiveFailures: number;
+    nextAttemptAt: string;
+    lastError: string | null;
+    lastErrorAt: string | null;
+    blockedAt: string | null;
+    leaseExpiresAt: string | null;
+    maxCursor: string;
+    pendingCount: string;
+    unassignedCount: string;
+    prunedThrough: string;
+};
+/**
+ * Enable a named consumer. This call deliberately requires a database handle
+ * authenticated as the separately provisioned host-export role; the ordinary
+ * tenant-scoped app role cannot execute this cross-workspace API.
+ */
+declare function registerHostExportConsumer(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+}): Promise<void>;
+declare function disableHostExportConsumer(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+}): Promise<void>;
+/**
+ * Permanently remove a quiesced consumer and release its retention floor.
+ * Unlike disable, re-registering this name later starts at the retained floor.
+ */
+declare function retireHostExportConsumer(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+}): Promise<void>;
+declare function claimHostExportBatch(db: Database, input: {
+    kind: "session_event";
+    consumerId: string;
+    leaseToken: string;
+    leaseHolderId: string;
+    leaseSeconds?: number;
+    limit?: number;
+    maxBytes?: number;
+}): Promise<HostEventExportBatch | null>;
+declare function claimHostExportBatch(db: Database, input: {
+    kind: "usage_event";
+    consumerId: string;
+    leaseToken: string;
+    leaseHolderId: string;
+    leaseSeconds?: number;
+    limit?: number;
+    maxBytes?: number;
+}): Promise<HostUsageExportBatch | null>;
+declare function acknowledgeHostExportBatch(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+    leaseToken: string;
+}): Promise<string>;
+declare function failHostExportBatch(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+    leaseToken: string;
+    error: string;
+    maxFailures?: number;
+}): Promise<number>;
+declare function deadLetterHostExportHead(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+    leaseToken: string;
+    cursor: string;
+    reason: string;
+}): Promise<string>;
+declare function resumeHostExportConsumer(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+}): Promise<void>;
+declare function rewindHostExportConsumer(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+    checkpoint: string;
+}): Promise<void>;
+declare function pruneHostExportOutbox(db: Database, input: {
+    kind: HostExportKind;
+    graceSeconds?: number;
+    limit?: number;
+}): Promise<number>;
+declare function getHostExportConsumerStatus(db: Database, input: {
+    kind: HostExportKind;
+    consumerId: string;
+}): Promise<HostExportConsumerStatus | null>;
 declare function setRlsContext(db: Database, context: RlsContext): Promise<void>;
 declare function withRlsContext<T>(db: Database, context: RlsContext, fn: (db: Database) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
 declare function rlsContextForWorkspace(db: Database, workspaceId: string): Promise<RlsContext>;
@@ -835,18 +1127,40 @@ type GitHubInstallation = {
     installationId: number;
     accountLogin: string | null;
     accountType: string | null;
+    repositoryScope: GitHubRepositoryScope;
+    linkedBySubjectId: string | null;
     createdAt: string;
     updatedAt: string;
 };
+type GitHubInstallationAccess = GitHubInstallation & {
+    repositoryIds: number[];
+};
 declare function upsertGitHubInstallation(db: Database, input: {
     accountId: string;
     workspaceId: string;
     installationId: number;
     accountLogin?: string | null;
     accountType?: string | null;
+    linkedBySubjectId?: string | null;
 }): Promise<GitHubInstallation>;
+declare function bindGitHubInstallationRepositories(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    installationId: number;
+    accountLogin?: string | null;
+    accountType?: string | null;
+    linkedBySubjectId: string;
+    repositoryIds: number[];
+}): Promise<GitHubInstallationAccess>;
 declare function listGitHubInstallationsForWorkspace(db: Database, workspaceId: string): Promise<GitHubInstallation[]>;
 declare function listGitHubInstallationIdsForWorkspace(db: Database, workspaceId: string): Promise<number[]>;
+declare function listGitHubInstallationAccessForWorkspace(db: Database, workspaceId: string): Promise<GitHubInstallationAccess[]>;
+declare function areGitHubRepositoriesAllowedForWorkspace(db: Database, workspaceId: string, installationId: number, repositoryIds: number[]): Promise<boolean>;
+declare function deleteGitHubInstallationBinding(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    installationId: number;
+}): Promise<boolean>;
 declare function recordUsageEvent(db: Database, input: {
     accountId: string;
     workspaceId: string;
@@ -856,6 +1170,12 @@ declare function recordUsageEvent(db: Database, input: {
     unit: string;
     sourceResourceType?: string | null;
     sourceResourceId?: string | null;
+    sessionId?: string | null;
+    turnId?: string | null;
+    turnAttemptId?: string | null;
+    initiator?: TurnInitiator | null;
+    initiatorContext?: TurnInitiatorContext;
+    origin?: SessionTurnSource | null;
     idempotencyKey: string;
     occurredAt?: Date;
 }): Promise<UsageEvent>;
@@ -1215,6 +1535,7 @@ type CreateSessionMcpServerInput = {
     timeoutMs?: number | null;
     cacheToolsList?: boolean | null;
     requireApproval?: boolean | string[] | null;
+    connectionRef?: McpServerConnectionRef$1 | null;
     headersEncrypted?: Record<string, string>;
 };
 type UpdateSessionMcpServerCredentialsInput = {
@@ -1240,6 +1561,7 @@ type EnqueueSessionTurnInput = {
     temporalWorkflowId: string;
     source: SessionTurnSource;
     prompt: string;
+    turnInstructions?: string | null;
     resources: ResourceRef[];
     tools: ToolRef[];
     model: string;
@@ -1248,9 +1570,18 @@ type EnqueueSessionTurnInput = {
     sandboxOs?: SandboxOs | null;
     metadata: Record<string, unknown>;
     lineage?: Record<string, unknown>;
+    initiator: TurnInitiator;
+    initiatorContext?: TurnInitiatorContext;
     /** Steer inserts before all waiting prompts; Send appends after them. */
     placement?: "head" | "tail";
 };
+/**
+ * Worker-only turn projection. Host instructions are durable execution input,
+ * never part of the public SessionTurn/queue/HTTP contract.
+ */
+type SessionTurnForExecution = SessionTurn & {
+    turnInstructions: string | null;
+};
 declare function createFileUpload(db: Database, input: {
     accountId: string;
     workspaceId: string;
@@ -1595,6 +1926,28 @@ declare function createRigVersionForChangePromotion(db: Database, workspaceId: s
     change: RigChange;
 }>;
 declare function listRigVersions(db: Database, workspaceId: string, rigId: string): Promise<RigVersion[]>;
+type RigVersionMonitoringSummary = {
+    id: string;
+    rigId: string;
+    version: number;
+    active: boolean;
+    image: string | null;
+    imageOriginalChars: number | null;
+    setupScriptBytes: number;
+    checkCount: number;
+    credentialHookCount: number;
+    defaultVariableSetCount: number;
+    changelog: string | null;
+    changelogOriginalChars: number | null;
+    createdBy: string | null;
+    createdAt: string;
+};
+/** Compact-by-query historical rig versions for the model-facing MCP surface. */
+declare function listRigVersionMonitoringSummaries(db: Database, workspaceId: string, rigId: string, limit?: number): Promise<{
+    versions: RigVersionMonitoringSummary[];
+    hasMore: boolean;
+    total: number;
+}>;
 declare function getRigVersion(db: Database, workspaceId: string, rigId: string, versionId: string): Promise<RigVersion | null>;
 declare function getRigVersionById(db: Database, workspaceId: string, versionId: string): Promise<RigVersion | null>;
 declare function getRigName(db: Database, workspaceId: string, rigId: string): Promise<string | null>;
@@ -1609,6 +1962,31 @@ declare function createRigChange(db: Database, input: {
     proposedBy?: string | null;
 }): Promise<RigChange>;
 declare function listRigChanges(db: Database, workspaceId: string, rigId: string, limit?: number): Promise<RigChange[]>;
+type RigChangeMonitoringSummary = {
+    id: string;
+    rigId: string;
+    baseVersionId: string | null;
+    kind: RigChangeKind;
+    status: RigChangeStatus;
+    proposedBy: string | null;
+    resultVersionId: string | null;
+    commandPreview: string | null;
+    commandOriginalChars: number | null;
+    payloadBytes: number;
+    verificationBytes: number;
+    verificationLogBytes: number;
+    verificationStartedAt: string | null;
+    verificationFinishedAt: string | null;
+    verificationPassed: boolean | null;
+    createdAt: string;
+    updatedAt: string;
+};
+/** Compact-by-query recent rig changes for the model-facing MCP surface. */
+declare function listRigChangeMonitoringSummaries(db: Database, workspaceId: string, rigId: string, limit?: number): Promise<{
+    changes: RigChangeMonitoringSummary[];
+    hasMore: boolean;
+    total: number;
+}>;
 declare function getRigChange(db: Database, workspaceId: string, changeId: string): Promise<RigChange | null>;
 declare function updateRigChangeStatus(db: Database, workspaceId: string, changeId: string, input: {
     status: RigChangeStatus;
@@ -1880,8 +2258,8 @@ type CodexLeaseAccountStatus = CodexAccountStatus & {
 /**
  * Opaque accepted-turn policy scope resolved while the durable turn is locked.
  *
- * OPE-21 deliberately does not know the shape of named pools. A downstream
- * allocator policy (OPE-32) owns its private scope type and supplies a pure
+ * This API deliberately does not know the shape of named pools. A downstream
+ * allocator policy owns its private scope type and supplies a pure
  * metadata resolver. The resolved value is handed to the selector in the same
  * workspace rotation-row transaction as lease acquisition, so future pool
  * membership filtering cannot race the accepted turn's frozen policy.
@@ -1966,7 +2344,7 @@ declare function acquireCodexCredentialLease<T, TPolicyScope = never, TUnavailab
     /**
      * Optional downstream parser for private accepted-turn policy metadata.
      * It is pure, runs under the turn/rotation transaction, and must not query
-     * pool membership itself. OPE-21 stores or interprets no pool identifiers.
+     * pool membership itself. This module stores or interprets no pool identifiers.
      */
     resolvePolicyScope?: CodexCredentialLeasePolicyScopeResolver<TPolicyScope>;
     /**
@@ -2070,11 +2448,13 @@ declare const CODEX_CAPACITY_REFRESH_MAX_MS: number;
 declare function codexCapacityRefreshBackoffMs(attempt: number): number;
 /**
  * Atomically settle one all-unavailable turn and arm exactly one durable wait.
- * Lock order is allocator rotation row -> session -> goal -> blocked turn ->
- * live lease (when a reactive failure owns one) -> waiter. The failed turn,
- * idle/capacity-paused session, durable events, lease release, and waiter
- * generation commit together; a crash cannot leave only half of the boundary
- * visible.
+ * Lock order is allocator rotation row -> workspace control -> actual workspace
+ * -> session -> exact turn -> exact attempt -> goal -> live lease (when a
+ * reactive failure owns one) -> waiter. The control share lock and effective
+ * control recheck prevent a capacity boundary from closing an attempt after a
+ * committed Pause. The failed turn, idle/capacity-paused session, durable
+ * events, lease release, and waiter generation commit together; a crash cannot
+ * leave only half of the boundary visible.
  */
 declare function armCodexCapacityWait(db: Database, input: {
     accountId: string;
@@ -2100,8 +2480,8 @@ declare function armCodexCapacityWait(db: Database, input: {
 }): Promise<ArmCodexCapacityWaitResult>;
 declare function getCodexCapacityWaitForSession(db: Database, workspaceId: string, sessionId: string): Promise<CodexCapacityWait | null>;
 /**
- * Same-transaction capacity-mutation/outbox seam for OPE-24 eligibility and
- * OPE-32 membership/default changes. The allocator rotation row is always the
+ * Same-transaction capacity-mutation/outbox seam for account eligibility and
+ * policy-scope membership/default changes. The allocator rotation row is always the
  * first lock. Mutations report whether capacity truth changed; only then are
  * matching waiter wake revisions advanced and returned for best-effort signal.
  */
@@ -2343,19 +2723,48 @@ declare function createSessionMcpServers(db: Database, input: {
     servers: CreateSessionMcpServerInput[];
 }): Promise<SessionMcpServerMetadata[]>;
 declare function listSessionMcpServerMetadata(db: Database, workspaceId: string, sessionId: string): Promise<SessionMcpServerMetadata[]>;
+/**
+ * Returns the complete stored server configuration needed to snapshot an
+ * immediate parent's MCP context onto a child session. Credential values stay
+ * encrypted throughout this path: the core can copy the ciphertext into the
+ * child's rows, but it never receives plaintext headers.
+ *
+ * This is intentionally distinct from `listSessionMcpServersForRun`, whose
+ * worker-only responsibility is decrypting credentials at the execution
+ * boundary.
+ */
+declare function listSessionMcpServersForChildInheritance(db: Database, workspaceId: string, sessionId: string): Promise<CreateSessionMcpServerInput[]>;
 declare function updateSessionMcpServerCredentials(db: Database, input: {
     workspaceId: string;
     sessionId: string;
     updates: UpdateSessionMcpServerCredentialsInput[];
 }): Promise<UpdateSessionMcpServerCredentialsResult>;
-declare function listSessionMcpServersForRun(db: Database, workspaceId: string, sessionId: string, encryptionKey: Uint8Array): Promise<SessionMcpServerForRun[]>;
+declare function listSessionMcpServersForRun(db: Database, workspaceId: string, sessionId: string, encryptionKey: Uint8Array | null): Promise<SessionMcpServerForRun[]>;
+type AgentSessionCreationActor = Extract<SessionCommandActor, {
+    type: "agent_attempt";
+}>;
+/** A caller-preallocated session UUID is already owned by another session. */
+declare class SessionIdConflictError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
 declare function createSession(db: Database, input: {
+    requestedSessionId?: string;
     accountId: string;
     workspaceId: string;
     initialMessage: string;
+    initialTurnInstructions?: string | null;
     resources: ResourceRef[];
     tools?: ToolRef[];
     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;
     model: string;
     sandboxBackend: SandboxBackend;
     variableSetId?: string | null;
@@ -2380,12 +2789,17 @@ declare function createSession(db: Database, input: {
  * 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[];
     metadata: Record<string, unknown>;
+    createdBy?: TurnInitiator;
+    createdByContext?: TurnInitiatorContext;
+    createdByActor?: AgentSessionCreationActor | null;
     model: string;
     sandboxBackend: SandboxBackend;
     variableSetId?: string | null;
@@ -2441,6 +2855,7 @@ type ListSessionsForSubjectOptions = ListSessionsOptions & {
     subjectId: string;
     cursor?: SessionListCursor | undefined;
     search?: string | undefined;
+    authorizationScope?: SessionAuthorizationListScope | undefined;
 };
 declare class SessionPinVersionConflictError extends Error {
     readonly current: Pick<Session, "pinned" | "pinnedAt" | "pinVersion">;
@@ -2455,6 +2870,32 @@ declare class SessionListAccessError extends Error {
 declare class SessionPinAccessError extends Error {
     constructor(message?: string);
 }
+type SessionTreeStats = NonNullable<Session["treeStats"]>;
+/**
+ * Remove control metadata derived from sessions other than the exact target.
+ * Effective state and the opaque OCC etag remain usable without exposing
+ * ancestor ids/titles/actors/reasons or descendant settlement facts.
+ */
+declare function projectEffectiveControlForRelatedAccess(control: Session["effectiveControl"], sessionId: string, access: "target" | "root"): Session["effectiveControl"];
+/**
+ * Remove metadata derived from sessions other than the exact authorized
+ * target, including parent identity and descendant counts.
+ */
+declare function projectSessionForRelatedAccess(session: Session, access: "target" | "root"): Session;
+/**
+ * Return bounded descendant aggregates for the bounded set of rows being
+ * painted in the session rail. Each selected root receives an independent
+ * fixed node/depth budget. `truncated=true` makes every count an explicit lower
+ * bound when a deep, wide, overlapping, or cyclic graph reaches that budget.
+ */
+declare function sessionTreeStatsForSessions(db: Database, workspaceId: string, rootIds: string[]): Promise<Map<string, SessionTreeStats>>;
+/**
+ * Convert the embedding host's complete list scope into a workspace-bound SQL
+ * predicate. Root scopes include every descendant through the durable parent
+ * graph; exact ids never imply access to related sessions. `UNION` (rather than
+ * `UNION ALL`) makes legacy cycles terminate without a caller-sized path array.
+ */
+declare function sessionAuthorizationScopeFilter(scope: SessionAuthorizationListScope): SQL;
 /** 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. */
@@ -2471,7 +2912,7 @@ declare function reapExpiredSessionListSnapshots(db: Database, limit?: number):
  */
 declare function listSessionsForSubject(db: Database, workspaceId: string, options: ListSessionsForSubjectOptions): Promise<SessionListResponse>;
 /** Read a session with the caller subject's personal pin projection. */
-declare function getSessionForSubject(db: Database, workspaceId: string, sessionId: string, subjectId: string): Promise<Session | null>;
+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,
@@ -2486,11 +2927,83 @@ declare function setSessionPin(db: Database, input: {
 }): Promise<Session | null>;
 declare function listSessions(db: Database, workspaceId: string, limit?: number): Promise<Session[]>;
 declare function listSessions(db: Database, workspaceId: string, options?: ListSessionsOptions): Promise<Session[]>;
+type SessionDiscoveryOrderBy = "createdAt" | "updatedAt";
+type SessionDiscoveryCursor = {
+    orderBy: SessionDiscoveryOrderBy;
+    /** Decimal database activity revision; zero is the legacy/created-order bucket. */
+    sortRevision: string;
+    /** Exact PostgreSQL timestamp text (including microseconds), not a JS Date. */
+    sortAt: string;
+    id: string;
+    /** Created-order timestamp ceiling; retained as diagnostic context for updated order. */
+    snapshotAt: string;
+    /** First-page revision fence: later activity belongs to the next incremental scan. */
+    snapshotRevision: string;
+    /** Incremental revision scope is cursor-bound and cannot change on continuation. */
+    updatedAfter: string | null;
+};
+declare const SESSION_DISCOVERY_GOAL_MAX_CHARS = 600;
+declare const SESSION_DISCOVERY_MESSAGE_MAX_CHARS = 600;
+type SessionDiscoverySummary = {
+    id: string;
+    title: string | null;
+    titleOriginalChars: number | null;
+    parentSessionId: string | null;
+    status: SessionStatus;
+    effectiveControl: SessionDiscoveryControl;
+    goal: {
+        status: SessionGoalStatus;
+        text: string;
+        textOriginalChars: number;
+    } | null;
+    queuedPromptCount: number;
+    treeStats: NonNullable<Session["treeStats"]>;
+    latestMessage: {
+        type: SessionEventType;
+        preview: string | null;
+        previewOriginalChars: number | null;
+    } | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Internal exact revision key; omitted from the MCP row projection. */
+    sortRevision: string;
+    /** Internal exact keyset timestamp; omitted from the MCP row projection. */
+    sortAt: string;
+};
+/**
+ * Compact-by-construction discovery projection for the first-party
+ * `sessions_list` MCP tool. It never selects instructions, resources, tools,
+ * MCP metadata, repositories, settings, or full event/history bodies.
+ */
+declare function listSessionDiscoverySummaries(db: Database, workspaceId: string, options: {
+    limit: number;
+    cursor?: SessionDiscoveryCursor;
+    includeLastMessage?: boolean;
+    orderBy?: SessionDiscoveryOrderBy;
+    updatedAfter?: string;
+    authorizationScope?: SessionAuthorizationListScope;
+}): Promise<{
+    sessions: SessionDiscoverySummary[];
+    hasMore: boolean;
+    nextCursor: SessionDiscoveryCursor | null;
+    total: number;
+    orderBy: SessionDiscoveryOrderBy;
+    snapshotAt: string;
+    snapshotRevision: string;
+    updatedThrough: string | null;
+    updatedAfter: string | null;
+}>;
 type SessionLineage = {
     ancestors: Session[];
     children: LineageNode[];
     truncated: boolean;
 };
+/**
+ * Resolve a session tree to its root without materializing the full lineage.
+ * Every recursive hop stays workspace-scoped and invalid/cyclic/deep chains
+ * fail closed instead of returning an ambiguous credential authority.
+ */
+declare function getSessionRootId(db: Database, workspaceId: string, sessionId: string): Promise<string | null>;
 /**
  * Read the full lineage slice around a session. Every recursive step carries
  * workspace_id as a hard predicate; a foreign parent/child id is invisible even
@@ -2511,7 +3024,47 @@ type ListSessionEventsOptions = {
     after?: number;
     before?: number;
     limit?: number;
+    direction?: SessionEventReadDirection;
+    includeTypes?: readonly SessionEventType[];
+    excludeTypes?: readonly SessionEventType[];
+    includeClasses?: readonly SessionEventSemanticClass[];
+    excludeClasses?: readonly SessionEventSemanticClass[];
+    defaultExcludeTypes?: readonly SessionEventType[];
+    payloadMode?: SessionEventPayloadMode;
+};
+type ListSessionEventPageOptions = ListSessionEventsOptions & {
+    /** Exact UTF-8 JSON-array envelope budget for rows materialized by the app. */
+    maxBytes?: number;
+    /** Internal SQL fetch size. Batches never escape the surrounding RLS transaction. */
+    batchSize?: number;
+};
+type SessionEventPage = {
+    events: SessionEvent[];
+    hasMore: boolean;
+    bytes: number;
+    direction: SessionEventReadDirection;
+    coveredSequence: {
+        first: number;
+        last: number;
+    } | null;
+    nextAfter: number | null;
+    nextBefore: number | null;
+    truncatedBy: "count" | "bytes" | null;
 };
+declare const SESSION_EVENT_DB_PAGE_MAX_BYTES: number;
+/**
+ * Read one direction-aware session-event page without transferring legacy raw
+ * payloads or malformed free-form envelope strings out of PostgreSQL.
+ *
+ * Migration 0067 deliberately leaves historical rows untouched. This query
+ * invokes its immutable payload projector in SQL and mirrors the rolling
+ * envelope guard in SQL, then accumulates small batches under one RLS
+ * transaction. `bytes` is the exact UTF-8 size of `JSON.stringify(events)`;
+ * `hasMore` is true whenever count or byte selection stopped before the durable
+ * range ended. A nonempty durable range can therefore never become an empty,
+ * non-advancing HTTP page.
+ */
+declare function listSessionEventPage(db: Database, workspaceId: string, sessionId: string, options?: ListSessionEventPageOptions): Promise<SessionEventPage>;
 declare function listSessionEvents(db: Database, workspaceId: string, sessionId: string): Promise<SessionEvent[]>;
 declare function listSessionEvents(db: Database, workspaceId: string, sessionId: string, after: number, limit?: number): Promise<SessionEvent[]>;
 declare function listSessionEvents(db: Database, workspaceId: string, sessionId: string, options: ListSessionEventsOptions): Promise<SessionEvent[]>;
@@ -2548,6 +3101,57 @@ declare function getLatestRunState(db: Database, workspaceId: string, sessionId:
     pendingApprovals: unknown[];
     frozenCodexCredentialId: string | null;
 } | null>;
+declare class HumanInputResponseValidationError extends Error {
+    readonly code: "INVALID_RESPONSE" | "SKIP_NOT_ALLOWED";
+    readonly name = "HumanInputResponseValidationError";
+    constructor(code: "INVALID_RESPONSE" | "SKIP_NOT_ALLOWED", message: string);
+}
+declare function getSessionHumanInputRequest(db: Database, workspaceId: string, sessionId: string, requestId: string): Promise<SessionHumanInputRequest | null>;
+declare function listSessionHumanInputRequests(db: Database, workspaceId: string, sessionId: string, options?: {
+    status?: SessionHumanInputRequest["status"];
+    limit?: number;
+}): Promise<SessionHumanInputRequest[]>;
+declare function validateHumanInputResponse(request: Pick<SessionHumanInputRequest, "questions" | "allowSkip">, rawResponse: unknown): HumanInputResponse;
+type AcceptSessionHumanInputResponseResult = {
+    action: "accepted";
+    request: SessionHumanInputRequest;
+    event: SessionEvent;
+    events: SessionEvent[];
+    workflowWakeRevision: number;
+} | {
+    action: "conflict";
+    request: SessionHumanInputRequest;
+    events: SessionEvent[];
+    workflowWakeRevision: number | null;
+} | {
+    action: "not_found";
+};
+/**
+ * First-writer-wins settlement for one pending structured input boundary.
+ * Session + logical turn + current freeze generation are locked with the row;
+ * the creation attempt is provenance and is intentionally not the resume owner.
+ */
+declare function acceptSessionHumanInputResponse(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    requestId: string;
+    response: unknown;
+    respondedBy: string;
+    clientEventId?: string | null;
+    expireOnly?: boolean;
+}): Promise<AcceptSessionHumanInputResponseResult>;
+declare function expireSessionHumanInputRequest(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    requestId: string;
+}): Promise<AcceptSessionHumanInputResponseResult>;
+declare function getHumanInputResumeForEvent(db: Database, workspaceId: string, sessionId: string, event: Pick<SessionEvent, "type" | "payload">): Promise<{
+    requestId: string;
+    toolCallId: string;
+    response: HumanInputResponse;
+} | null>;
 type TurnAttemptFenceRejectReason = "workspace_paused" | "session_paused" | "pending_control" | "active_turn_changed" | "generation_changed" | "attempt_changed" | "turn_terminal" | "not_found";
 /**
  * Append conversation items (verbatim SDK AgentInputItems) to the session's
@@ -2563,6 +3167,7 @@ declare function appendSessionHistoryItems(db: Database, input: {
     expectedExecutionGeneration: number;
     expectedAttemptId: string;
     producerCodexCredentialId?: string | null;
+    modelToolOutputTruncationTokens?: number;
     items: Array<{
         position: number;
         item: Record<string, unknown>;
@@ -2596,14 +3201,15 @@ declare function recordPendingSessionToolCallResult(db: Database, input: Omit<Pe
 }): Promise<{
     accepted: boolean;
     recorded: boolean;
-    allResultsRecorded: boolean;
 }>;
 /**
  * Remove completed receipts only after the full SDK call/result batch is
  * durable. Until then every raw result remains available to an attempt-ending
  * transaction, including reverse-completing parallel calls.
  */
-declare function clearDurablePendingSessionToolCalls(db: Database, input: Omit<PendingSessionToolCallInput, "callId" | "callType" | "callItem">): Promise<{
+declare function clearDurablePendingSessionToolCalls(db: Database, input: Omit<PendingSessionToolCallInput, "callId" | "callType" | "callItem"> & {
+    callIds: string[];
+}): Promise<{
     accepted: boolean;
     cleared: number;
 }>;
@@ -2705,7 +3311,7 @@ declare function recordSkippedContextCompaction(db: Database, input: {
     turnId: string;
     expectedExecutionGeneration: number;
     expectedAttemptId: string;
-    reason: "no_history" | "replacement_not_smaller";
+    reason: "no_history" | "replacement_not_smaller" | "replacement_unchanged" | "summarization_failed";
 }): Promise<{
     recorded: true;
     events: SessionEvent[];
@@ -3183,6 +3789,9 @@ declare function persistDrainSnapshot(db: Database, input: {
 declare function persistWarmSnapshot(db: Database, input: {
     accountId: string;
     workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
     /** base64 of the provider snapshot-ref / tar archive from persistWorkspace(). */
@@ -3242,15 +3851,17 @@ type WorkspaceCaptureCommitResult = {
  * — can embed the same number). Writes ONLY when a warm lease with the expected
  * epoch still exists for the sandbox group (the same supersession guard
  * persistWarmSnapshot uses, expressed as an EXISTS on sandbox_leases). Returns
- * the assigned revision, or null when the fence rejected the write (superseded /
- * released lease). Captures for one session are serialized (one turn at a time),
- * so the explicit revision never races the unique (session_id, revision) index.
+ * the assigned revision, or null when the fence rejected the write (interrupted
+ * attempt, cancelled/superseded turn, or released/superseded lease). Captures for
+ * one session are serialized (one turn at a time), so the explicit revision never
+ * races the unique (session_id, revision) index.
  */
 declare function insertWorkspaceCapture(db: Database, input: {
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    turnId: string | null;
+    turnId: string;
+    attemptId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
     revision: number;
@@ -3274,7 +3885,8 @@ declare function insertFailedWorkspaceCapture(db: Database, input: {
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    turnId: string | null;
+    turnId: string;
+    attemptId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
     revision: number;
@@ -3877,7 +4489,7 @@ type ClaimSessionWorkForAttemptInput = {
 };
 type ClaimSessionWorkForAttemptResult = {
     action: "claimed";
-    turn: SessionTurn;
+    turn: SessionTurnForExecution;
 } | {
     action: "unclaimed";
     reason: "gate-closed" | "no-work" | "stale-approval" | "control-pending";
@@ -3896,6 +4508,33 @@ type SessionAttemptInterruptionSettlement = {
     turnId: string | null;
     outcome: SessionTurnAttemptOutcome | null;
 };
+/**
+ * Acknowledge that the exact cancelled attempt reached its final quiescence
+ * boundary: after this transaction it has no inference, user-visible output,
+ * or workspace-persistence authority. Fenced/idempotent cleanup and telemetry
+ * may still finish. This may race the workflow's logical settlement transaction
+ * in either order; both use the canonical control -> workspace -> session ->
+ * exact turn -> exact attempt lock order and require the durable interruption.
+ * Temporal activity cancellation/terminalization is transport state only. The
+ * workflow admits a replacement from this durable receipt, never from the
+ * activity promise.
+ */
+declare function markSessionAttemptQuiesced(db: Database, input: {
+    accountId?: string;
+    workspaceId: string;
+    sessionId: string;
+    attemptId: string;
+    temporalWorkflowId: string;
+    /** When supplied, both values bind an activity-owned recovery proof to the
+     * exact persisted Temporal dispatch. Legacy v1 replay callers omit them. */
+    temporalWorkflowRunId?: string;
+    temporalActivityId?: string;
+    /** The dying activity also reaches this boundary for non-control ownership
+     * fences. It may no-op when no Pause/Steer interruption exists; replacement
+     * admission remains strict because only a durable interruption needs this
+     * receipt. */
+    allowUninterrupted?: boolean;
+}): Promise<SessionEvent[]>;
 /**
  * Settle every durable interruption cause for one exact first-class attempt.
  * Steer wins the logical-turn fate when causes coexist; effective control after
@@ -3910,6 +4549,8 @@ type SessionWorkPeek = {
     triggerEventId: string;
 } | {
     kind: "approval-wait";
+    humanInputRequestId?: string;
+    expiresAt?: string;
 } | {
     kind: "capacity-wait";
     ref: {
@@ -3921,6 +4562,9 @@ type SessionWorkPeek = {
 } | {
     kind: "interruption-pending";
     attemptId: string;
+} | {
+    kind: "cancellation-wait";
+    attemptId: string;
 } | {
     kind: "idle";
 };
@@ -3930,7 +4574,7 @@ declare function peekSessionWork(db: Database, workspaceId: string, sessionId: s
  * 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.
+ * dedupe identity through notifyParentOfChildIdle.
  */
 declare function settleSessionIdleWithParentOutbox(db: Database, workspaceId: string, sessionId: string): Promise<{
     action: "settled";
@@ -3972,7 +4616,38 @@ type ApplySessionTurnSettlementInput = {
     sessionStatus: SessionStatus;
     activeTurnId: string | null;
     events: AppendEventInput[];
+    /**
+     * A mid-turn SDK freeze installed atomically with requires_action. Human
+     * input requests are public protocol rows; ordinary approvals remain only in
+     * pendingApprovals. No request can become visible without the exact frozen
+     * RunState needed to resume it, and no frozen request can miss its status
+     * transition/events because all writes share this transaction.
+     */
+    runState?: {
+        serializedRunState: string;
+        pendingApprovals: unknown[];
+        frozenCodexCredentialId?: string | null;
+        humanInputRequests?: Array<{
+            id: string;
+            toolCallId: string;
+            questions: HumanInputQuestion[];
+            allowSkip: boolean;
+            expiresAt?: Date | null;
+        }>;
+    };
     recording?: SessionTurnRecordingSettlement;
+    /**
+     * Atomically consume an operator /compact request and record why it could
+     * not install a replacement. This lives on the terminal turn settlement so
+     * a worker crash can never clear the request without also publishing the
+     * attempt-owned failure truth.
+     */
+    compactionRequestFailure?: {
+        reason: "summarization_failed";
+        producerId?: string | null;
+        producerSeq?: number | null;
+        occurredAt?: Date;
+    };
 };
 type ApplySessionTurnSettlementResult = {
     action: "settled";
@@ -4109,7 +4784,7 @@ type RecoverSessionDispatchResult = {
  */
 declare function recoverSessionDispatch(db: Database, workspaceId: string, input: RecoverSessionDispatchInput): Promise<RecoverSessionDispatchResult>;
 declare function getSessionTurn(db: Database, workspaceId: string, turnId: string): Promise<SessionTurn | null>;
-declare function getSessionTurnForAttempt(db: Database, workspaceId: string, sessionId: string, attemptId: string): Promise<SessionTurn | null>;
+declare function getSessionTurnForAttempt(db: Database, workspaceId: string, sessionId: string, attemptId: string): Promise<SessionTurnForExecution | null>;
 /**
  * Return the newest turn that reached agent execution for a session. A claimed
  * turn's `started_at` is set before worker admission, so it is not sufficient
@@ -4144,6 +4819,16 @@ type SessionSystemUpdateOutboxDelivery = {
     payload: ChildTerminalResultPayload;
     lineage: Record<string, unknown>;
 };
+/**
+ * Read the exact durable parent-update row created by terminal turn settlement.
+ * Failure delivery must never upsert this row: settlement owns its payload and
+ * turn provenance, while the activity layer only delivers the committed fact.
+ */
+declare function getSessionSystemUpdateOutboxByDedupeKey(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    dedupeKey: string;
+}): Promise<SessionSystemUpdateOutboxDelivery | null>;
 declare function claimPendingSessionSystemUpdateOutbox(db: Database, limit?: number): Promise<SessionSystemUpdateOutboxDelivery[]>;
 type SessionWorkflowWake = {
     accountId: string;
@@ -4301,4 +4986,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 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 };
+export { type CorrectWorkspaceMemoryInput as $, AGENT_VISIBLE_MEMORY_STATUSES as A, type BootstrapWorkspaceInput as B, CODEX_CAPACITY_REFRESH_MAX_MS as C, type CodexCapacityResetKind as D, type CodexCapacitySelectionContext as E, type CodexCapacityWait as F, type CodexCapacityWaitStatus as G, type CodexCapacityWakeTarget as H, type CodexCredentialForRun as I, type CodexCredentialLeaseCandidateFilter as J, type CodexCredentialLeaseCandidateFilterResult as K, type CodexCredentialLeasePolicyScopeResolver as L, type CodexCredentialLeaseQuarantine as M, type CodexCredentialLeaseResult as N, type CodexCredentialLeaseSelection as O, type CodexCredentialLeaseSelectionContext as P, type ProvisionResult, type ProvisionRolesOptions, type CodexCredentialStatus as Q, type CodexCredentialTokens as R, type CodexLeaseAccountStatus as S, type CodexPinSource as T, type CodexRotationSettings as U, type CodexRotationStrategy as V, type ComposerDraftRow as W, type ConnectionBrokerDeps as X, type ConnectionCredentialForBroker as Y, ConnectionRefreshHttpError as Z, type ConsumeOAuthStateNonceInput as _, type AcceptSessionApprovalDecisionResult as a, MEMORY_BLOCK_RECORD_LIMIT as a$, type CorrectWorkspaceMemoryResult as a0, type CreateCapabilityCatalogItemInput as a1, type CreateConnectionInput as a2, type CreateDbOptions as a3, type CreateImportBatchInput as a4, type CreateKnowledgeMemoryInput as a5, type CreatePackInstallationInput as a6, type CreateScheduledTaskInput as a7, type CreateSessionGoalInput as a8, type CreateSessionMcpServerInput as a9, type GoalContinuationDecision as aA, type HostExportConsumerStatus as aB, type HostExportKind as aC, HostExportPayloadError as aD, HostMcpCredentialBindingError as aE, type HostMcpCredentialResolverContext as aF, HostMcpCredentialScopeError as aG, HumanInputResponseValidationError as aH, type IdempotentPersistenceTransactionOptions as aI, type ImportBatch as aJ, type InitializeSessionStartInput as aK, type InitializeSessionStartResult as aL, type IntegrationOAuthClientForUse as aM, type LeaseHolderKind as aN, type LeaseSnapshot as aO, type ListKnowledgeMemoryOptions as aP, type ListSessionEventPageOptions as aQ, type ListSessionEventsOptions as aR, type ListSessionsForSubjectOptions as aS, type ListSessionsOptions as aT, type LiveModalSandboxLeaseAttribution as aU, MACHINE_METRICS_SERIES_INTERVAL_MS as aV, MAX_INTERNAL_UPDATE_BATCH_BYTES as aW, MAX_INTERNAL_UPDATE_BATCH_MEMBERS as aX, MAX_INTERNAL_UPDATE_BYTES as aY, MEMORY_ACTIVE_RECORD_CAP as aZ, MEMORY_BLOCK_KIND_ORDER as a_, type CreateSocialConnectionInput as aa, type CreateSocialPostInput as ab, type CreditBalanceByAccount as ac, type Database as ad, type DatabaseFailureCode as ae, type DbClient as af, type DeviceEnrollmentRequestRecord as ag, type DeviceEnrollmentStatus as ah, type EditQueueCommandResult as ai, type EffectiveControlBlocker as aj, type EffectiveControlResumeOption as ak, type EffectiveControlState as al, type EffectiveSessionControl as am, type EnableCapabilityInstallationInput as an, type EnabledMcpCapabilityServer as ao, type EnqueueSessionTurnInput as ap, type EnrollmentExposure as aq, type EnrollmentOs as ar, type EnrollmentRecord as as, type EnrollmentStatus as at, type ExpiredFileUploadCleanupClaim as au, type FileUploadCleanupClaimResult as av, type ForceDrainResult as aw, type FrozenTurnInitiator as ax, type GitHubInstallation as ay, type GitHubInstallationAccess as az, type AcceptSessionHumanInputResponseResult as b, type SessionCommandActor as b$, MEMORY_CORRECT_TOOL_DESCRIPTION as b0, MEMORY_KIND_SECTION_TITLES as b1, MEMORY_NEAR_DUP_COSINE_THRESHOLD as b2, MEMORY_NEAR_DUP_NEIGHBORS as b3, MEMORY_SAVE_TOOL_DESCRIPTION as b4, MEMORY_SEARCH_DEFAULT_LIMIT as b5, MEMORY_SEARCH_MAX_LIMIT as b6, MEMORY_SEARCH_TOOL_DESCRIPTION as b7, MEMORY_TEXT_MAX_CHARS as b8, MEMORY_VISIBLE_RECORD_CAP as b9, RigActiveVersionChangedError as bA, RigChangeAlreadyVerifyingError as bB, type RigChangeMonitoringSummary as bC, RigChangeTransitionError as bD, type RigVersionContentInput as bE, type RigVersionMonitoringSummary as bF, type RlsContext as bG, type RlsStrategy as bH, SESSION_ANCESTRY_LIMIT as bI, SESSION_DISCOVERY_CONTROL_TARGET_LIMIT as bJ, SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS as bK, SESSION_DISCOVERY_GOAL_MAX_CHARS as bL, SESSION_DISCOVERY_MESSAGE_MAX_CHARS as bM, SESSION_EVENT_DB_PAGE_MAX_BYTES as bN, type SafeDatabaseErrorFacts as bO, SandboxImageConflictError as bP, type SandboxKind as bQ, type SandboxLeaseLiveness as bR, SandboxLeaseSupersededError as bS, type SandboxPtySessionRow as bT, type SandboxRecord as bU, SandboxRigConflictError as bV, SanitizedDatabasePersistenceCause as bW, type SaveWorkspaceMemoryInput as bX, type SaveWorkspaceMemoryResult as bY, type SessionAttemptInterruptionSettlement as bZ, type SessionCodexState as b_, type MachineMetricsRow as ba, type MachineMetricsSample as bb, type MarkWarmLeaseInstanceLostResult as bc, type MemoryBlockRecord as bd, type MemoryEmbedder as be, type MemorySanitizeResult as bf, type MeterableWarmLease as bg, type PendingSessionToolCallInput as bh, type PersistenceFailureDetails as bi, type PersistenceRetryOutcome as bj, type QueueCommandConflictCode as bk, QueueCommandConflictError as bl, type QueueCommandResult as bm, type QueuedTurnRow as bn, type ReapDrainable as bo, type ReconcileCodexCapacityWaitResult as bp, type RecoverSessionDispatchInput as bq, type RecoverSessionDispatchResult as br, type RegisterWorkspacePackInput as bs, type RegistryCapabilityCatalogItemInput as bt, type RegistryCatalogSurfaceKey as bu, type ReplaceIntegrationOAuthClientInput as bv, type RequestSessionTurnRecoveryInput as bw, type RequestSessionTurnRecoveryResult as bx, type ResolveConnectionCredentialInput as by, type ResolveConnectionCredentialResult as bz, type AccrueWarmSecondsResult as c, type WorkspaceMemorySearchInput as c$, SessionCommandIdempotencyError as c0, type SessionCommandReceiptRow as c1, SessionContextBusyError as c2, SessionControlConflictError as c3, SessionControlInvariantError as c4, type SessionControlMutationResult as c5, type SessionDiscoveryControl as c6, type SessionDiscoveryCursor as c7, type SessionDiscoveryOrderBy as c8, type SessionDiscoverySummary as c9, type SteerQueueCommandResult as cA, type StoreIntegrationOAuthClientInput as cB, type StoredIntegrationOAuthClient as cC, type StreamAcknowledgment as cD, type SubmitHumanPromptResult as cE, type ToolspaceCallReservation as cF, type TurnAttemptFenceRejectReason as cG, type UpdateConnectionInput as cH, type UpdateImportBatchCountsInput as cI, type UpdateKnowledgeMemoryInput as cJ, type UpdateScheduledTaskInput as cK, type UpdateSessionMcpServerCredentialsInput as cL, type UpdateSessionMcpServerCredentialsResult as cM, type UserLookup as cN, type VariableSetForRun as cO, WORKSPACE_MEMORY_BLOCK_EMPTY as cP, WORKSPACE_MEMORY_BLOCK_HEADER_POPULATED as cQ, WORKSPACE_MEMORY_BLOCK_TOKEN_BUDGET as cR, type WorkspaceCaptureCommitResult as cS, type WorkspaceCaptureGcPlan as cT, type WorkspaceCaptureGcRow as cU, type WorkspaceCaptureRow as cV, type WorkspaceControlLockMode as cW, type WorkspaceControlMutationResult as cX, type WorkspaceControlRow as cY, type WorkspaceEnvironmentForRun as cZ, type WorkspaceMemoryOrigin as c_, type SessionEventPage as ca, SessionEventPersistenceError as cb, type SessionEventWriteLockInput as cc, type SessionEventWriteLocks as cd, SessionIdConflictError as ce, type SessionLineage as cf, SessionListAccessError as cg, type SessionListCursor as ch, SessionListCursorError as ci, type SessionMcpServerForRun as cj, SessionPinAccessError as ck, SessionPinVersionConflictError as cl, type SessionRecordingCodec as cm, type SessionRecordingMode as cn, type SessionRecordingRow as co, type SessionRecordingState as cp, type SessionSystemUpdateOutboxDelivery as cq, type SessionTurnAttemptOutcome as cr, type SessionTurnForExecution as cs, type SessionTurnRecordingSettlement as ct, type SessionWorkPeek as cu, type SessionWorkTrigger as cv, type SessionWorkflowWake as cw, type SetSessionCodexPinOptions as cx, type SettleCodexCredentialFailoverResult as cy, type SettleCodexCredentialLeaseLossResult as cz, type AcquireLeaseInput as d, countActiveSessionHistoryItems as d$, type WorkspaceMemorySearchMode as d0, type WorkspaceMemorySearchResult as d1, type WorkspaceModelPolicy as d2, abandonRecordingForTurnAttempt as d3, acceptSessionApprovalDecision as d4, acceptSessionHumanInputResponse as d5, accrueWarmSeconds as d6, acknowledgeHostExportBatch as d7, acquireCodexCredentialLease as d8, acquireLease as d9, buildConnectionTokenResolver as dA, buildHostConnectionTokenResolver as dB, canonicalSessionCommandHash as dC, claimExpiredFileUploadCleanup as dD, claimFileUploadCleanup as dE, claimHostExportBatch as dF, claimPendingSessionSystemUpdateOutbox as dG, claimPendingSessionWorkflowWakes as dH, claimSessionWorkForAttempt as dI, clearDurablePendingSessionToolCalls as dJ, clearEnrollmentWentOffline as dK, clearSessionContext as dL, clearSessionGoal as dM, clearedContextMarkerItem as dN, closePtySession as dO, closeSessionTurnAttemptInTransaction as dP, codexCapacityRefreshBackoffMs as dQ, commitWarmingToWarm as dR, completeExpiredFileUploadCleanup as dS, completeFileUpload as dT, completeFileUploadCleanup as dU, computeWorkspaceCaptureGcPlan as dV, confirmDrainCold as dW, consumeDeviceEnrollmentRequest as dX, consumeIntegrationOAuthStateNonce as dY, correctWorkspaceMemory as dZ, countActiveApiKeysForWorkspace as d_, activateRigVersion as da, addSessionSystemUpdate as db, addSessionSystemUpdateWithSourceMutation as dc, allAccountPermissions as dd, allWorkspacePermissions as de, appendSessionEventToSandboxGroup as df, appendSessionEvents as dg, appendSessionEventsAndUpdateSession as dh, appendSessionEventsForTurnAttempt as di, appendSessionEventsWithLockedSessionUpdate as dj, appendSessionHistoryItems as dk, applyContextCompaction as dl, applyCreditDebitUpToBalance as dm, applyCreditLedgerEntry as dn, applySessionTurnSettlement as dp, approveDeviceEnrollmentRequest as dq, areGitHubRepositoriesAllowedForWorkspace as dr, armCodexCapacityWait as ds, assertAgentCommandAuthorityInTransaction as dt, autoResumeSessionBranchInTransaction as du, beginRigChangeVerificationAttempt as dv, bindGitHubInstallationRepositories as dw, bootstrapWorkspace as dx, buildChildCompletionDigest as dy, buildCodexTokenResolver as dz, type AcquireLeaseResult as e, enableCapabilityInstallation as e$, countActiveSessionsForWorkspace as e0, countActiveSessionsUsingEnvironment as e1, countActiveSessionsUsingVariableSet as e2, countConsecutiveReactiveRotations as e3, countQueuedTurns as e4, countRigs as e5, countSandboxLeasesByLiveness as e6, countScheduledTasksForWorkspace as e7, countScheduledTasksUsingEnvironment as e8, countScheduledTasksUsingVariableSet as e9, createVariableSet as eA, createWorkspace as eB, createWorkspaceEnvironment as eC, databaseFailureCode as eD, deadLetterHostExportHead as eE, decodeSessionListCursor as eF, decryptEnvironmentValue as eG, decryptedCapabilityHeaders as eH, deleteGitHubInstallationBinding as eI, deleteRecording as eJ, deleteRig as eK, deleteRigIfNoActiveSessions as eL, deleteScheduledTask as eM, deleteSessionQueueItemInTransaction as eN, deleteVariableSet as eO, deleteVariableSetVariable as eP, deleteWorkspace as eQ, deleteWorkspaceCaptureRows as eR, deleteWorkspaceEnvironment as eS, deleteWorkspaceEnvironmentVariable as eT, deleteWorkspacePack as eU, denyDeviceEnrollmentRequest as eV, disableCapabilityInstallation as eW, disableHostExportConsumer as eX, disconnectAllCodexAccounts as eY, disconnectCodexAccount as eZ, editQueuedTurnInTransaction as e_, 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, type ActiveSandboxPointer as f, getSessionEvent as f$, enablePackInstallation as f0, encodeSessionListCursor as f1, encryptEnvironmentValue as f2, enqueueSessionTurn as f3, enqueueSessionWorkflowWake as f4, enqueueSessionWorkflowWakeIfRunnable as f5, enqueueSessionWorkflowWakeInTransaction as f6, ensureCodexRotationSettings as f7, ensureManagedAccessForUser as f8, estimateMemoryTokens as f9, getFileUpload as fA, getHostExportConsumerStatus as fB, getHumanInputResumeForEvent as fC, getKnowledgeMemory as fD, getLatestRunState as fE, getLatestStartedSessionTurn as fF, getManagedAccount as fG, getManagedUserByEmail as fH, getMaterializedSandboxFileResources as fI, getOpenPtySession as fJ, getOrCreateSessionSystemUpdateOutbox as fK, getPackInstallation as fL, getPendingDeviceEnrollmentRequestByUserCode as fM, getPendingDeviceEnrollmentRequestByUserCodeGlobal as fN, getRecording as fO, getRig as fP, getRigByName as fQ, getRigChange as fR, getRigName as fS, getRigVersion as fT, getRigVersionById as fU, getSandbox as fV, getSandboxSessionEnvelope as fW, getScheduledTask as fX, getSession as fY, getSessionByCreateIdempotencyKey as fZ, getSessionCodexState as f_, evaluateGoalContinuation as fa, evaluateSessionControl as fb, evaluateSessionControls as fc, evaluateSessionDiscoveryControls as fd, expireSessionHumanInputRequest as fe, failHostExportBatch as ff, failWarmingToCold as fg, fetchCodexUsageForAccount as fh, finalizeEnrollmentByToken as fi, findActiveApiKeyByHash as fj, forceDrainOverLimitViewerOnlyBoxes as fk, frozenInitiatorForCommandActor as fl, getActiveSessionHistoryItems as fm, getAnySessionInGroup as fn, getBillingBalance as fo, getBillingCustomer as fp, getCapabilityCatalogItem as fq, getCapabilityInstallation as fr, getCodexCapacityWaitForSession as fs, getCodexCredentialStatus as ft, getCodexRotationSettings as fu, getComposerDraftInTransaction as fv, getConnectionMetadata as fw, getDeviceEnrollmentRequestByDeviceCode as fx, getEnrollment as fy, getFile as fz, type AddSessionSystemUpdateInput as g, listLiveModalSandboxLeaseAttributions as g$, getSessionEventByClientEventId as g0, getSessionForSubject as g1, getSessionGoal as g2, getSessionHistoryItems as g3, getSessionHumanInputRequest as g4, getSessionLineage as g5, getSessionQueueSnapshot as g6, getSessionRootId as g7, getSessionSystemUpdateOutboxByDedupeKey as g8, getSessionTurn as g9, insertPtySession as gA, insertRecording as gB, insertWorkspaceCapture as gC, interruptedToolCallResult as gD, isCodexBilledTurn as gE, isDatabasePersistenceFailure as gF, isMemoryTextTooLong as gG, isPrivateAddress as gH, isRetryablePersistenceSqlState as gI, isSessionCompactionRequested as gJ, isSessionEventPersistenceError as gK, isStripeWebhookProcessed as gL, latestWorkspaceCapture as gM, listApiKeys as gN, listCapabilityCatalogItems as gO, listCapabilityInstallations as gP, listCodexAccountStatuses as gQ, listConnectionsMetadata as gR, listCreditBalancesByAccount as gS, listDistinctRigVersionIdsInGroup as gT, listDistinctVariableSetIdsInGroup as gU, listEnabledMcpCapabilityServers as gV, listEnrollments as gW, listGitHubInstallationAccessForWorkspace as gX, listGitHubInstallationIdsForWorkspace as gY, listGitHubInstallationsForWorkspace as gZ, listKnowledgeMemories as g_, getSessionTurnForAttempt as ga, getSocialConnection as gb, getStoredCapabilityHeaderCiphertext as gc, getStreamAcknowledgment as gd, getVariableSet as ge, getVariableSetByName as gf, getVariableSetValuesForRun as gg, getWorkspace as gh, getWorkspaceControlEvent as gi, getWorkspaceDefaultRigId as gj, getWorkspaceEnvironment as gk, getWorkspaceEnvironmentByName as gl, getWorkspaceEnvironmentValuesForRun as gm, getWorkspaceGrant as gn, getWorkspaceModelPolicy as go, getWorkspacePack as gp, grantWorkspaceAccess as gq, hasCreditLedgerEntry as gr, hashMemoryText as gs, heartbeatCodexCredentialLease as gt, heartbeatCodexCredentialLeaseUntil as gu, heartbeatLeaseHolder as gv, ingestMachineMetricsSample as gw, initializeSessionStartAtomically as gx, insertFailedWorkspaceCapture as gy, insertMachineMetricsSeries as gz, type AddSessionSystemUpdateResult as h, orphanedResultRowIndicesForRepair as h$, listMeterableWarmLeases as h0, listOpenPtySessions as h1, listOutstandingSessionSystemUpdates as h2, listPackInstallations as h3, listPendingCodexCapacityWakeTargets as h4, listPendingSessionTurns as h5, listRecordings as h6, listRegistryCatalogSurfaceKeys as h7, listRigChangeMonitoringSummaries as h8, listRigChanges as h9, listWorkspacesForSubject as hA, loadCodexCredentialForRun as hB, loadConnectionCredentialForBroker as hC, loadIntegrationOAuthClient as hD, loadVariableSetForRun as hE, loadWorkspaceEnvironmentForRun as hF, lockSessionEventWriteRows as hG, lockWorkspaceInferenceControl as hH, markFileUploadFailed as hI, markSandboxFileResourcesMaterialized as hJ, markScheduledTaskRunFailedIfQueued as hK, markSessionAttemptQuiesced as hL, markSessionSystemUpdateOutboxDeliveredInTransaction as hM, markSessionSystemUpdateOutboxFailed as hN, markSessionWorkflowWakeDelivered as hO, markSessionWorkflowWakeFailed as hP, markStaleRegistryCatalogItems as hQ, markStripeWebhookProcessed as hR, markWarmLeaseInstanceLost as hS, mcpServerIdForCapability as hT, moveQueuedTurnInTransaction as hU, mutateSessionControlInTransaction as hV, mutateWorkspaceControlInTransaction as hW, nestedPostgresSqlState as hX, nextSessionHistoryPosition as hY, normalizeBearerScheme as hZ, normalizeMemoryText as h_, listRigVersionMonitoringSummaries as ha, listRigVersions as hb, listRigs as hc, listSandboxes as hd, listScheduledTaskRuns as he, listScheduledTasks as hf, listSessionDiscoverySummaries as hg, listSessionEventPage as hh, listSessionEvents as hi, listSessionHumanInputRequests as hj, listSessionIdsInGroup as hk, listSessionMcpServerMetadata as hl, listSessionMcpServersForChildInheritance as hm, listSessionMcpServersForRun as hn, listSessionSystemUpdatesForTurn as ho, listSessionTurns as hp, listSessions as hq, listSessionsForSubject as hr, listSocialConnections as hs, listSocialPosts as ht, listUsageEvents as hu, listVariableSets as hv, listWorkspaceControlEvents as hw, listWorkspaceEnvironments as hx, listWorkspaceMembers as hy, listWorkspacePacks as hz, AgentCommandAuthorityError as i, revokeApiKey as i$, peekSessionWork as i0, persistDrainSnapshot as i1, persistWarmSnapshot as i2, planWorkspaceCaptureGc as i3, projectEffectiveControlForRelatedAccess as i4, projectSessionForRelatedAccess as i5, pruneHostExportOutbox as i6, quarantineCodexCredentialForLease as i7, reArmDrainingLease as i8, readActiveSandbox as i9, recoverSessionDispatch as iA, refreshOAuthConnectionCredential as iB, registerDbBinding as iC, registerHostExportConsumer as iD, registerInternalUpdateWakeInTransaction as iE, registerPendingSessionToolCall as iF, registerSessionTurnAttemptClaim as iG, registerSessionWorkflowWakeInTransaction as iH, registerWorkspacePack as iI, releaseCodexCredentialLease as iJ, releaseLeaseHolder as iK, removeWorkspaceMember as iL, renameCodexAccount as iM, renderWorkspaceMemoryBlock as iN, replaceIntegrationOAuthClient as iO, requestSessionCompaction as iP, requestSessionTurnRecovery as iQ, requireFile as iR, requireScheduledTask as iS, requireSession as iT, requireSocialConnection as iU, requireWorkspace as iV, reserveSessionCommandReceipt as iW, reserveToolspaceCallForTurn as iX, resolveWorkspaceMemoryBlock as iY, resumeHostExportConsumer as iZ, retireHostExportConsumer as i_, readLease as ia, readMachineMetricsLatest as ib, readMachineMetricsLatestForWorkspace as ic, readMachineMetricsSeries as id, reapExpiredSessionListSnapshots as ie, reapStaleLeaseHolders as ig, reapStaleLeaseHoldersGlobal as ih, reconcileCodexCapacityWait as ii, recordAuditEvent as ij, recordCodexAccountConnectors as ik, recordCodexAccountUsage as il, recordCodexAccountUsageWithWakeTargets as im, recordCodexTokenRefresh as io, recordConnectionTokenRefresh as ip, recordConnectionUsed as iq, recordLeaseDataPlaneUrl as ir, recordLeaseTerminalDataPlaneUrl as is, recordPendingSessionToolCallResult as it, recordSessionActiveCodexCredential as iu, recordSkippedContextCompaction as iv, recordStreamAcknowledgment as iw, recordStripeWebhookEvent as ix, recordUsageEvent as iy, recordWarmingSandboxCreated as iz, type AgentInternalUpdateCommandResult as j, updateRecording as j$, revokeConnection as j0, revokeEnrollment as j1, revokeViewer as j2, rewindHostExportConsumer as j3, rlsContextForWorkspace as j4, rlsStrategyFor as j5, runIdempotentPersistenceTransaction as j6, safeDatabaseErrorFacts as j7, sanitizeEventPayload as j8, sanitizeEventString as j9, setSessionGoalStatus as jA, setSessionLastInputTokensForTurnAttempt as jB, setSessionPin as jC, setTemporalWorkflowId as jD, setVariableSetVariable as jE, setWorkspaceDefaultRig as jF, setWorkspaceEnvironmentVariable as jG, settleCodexCredentialFailover as jH, settleCodexCredentialLeaseLoss as jI, settleScheduledTaskRunInTransaction as jJ, settleSessionAttemptInterruptions as jK, settleSessionIdleWithParentOutbox as jL, shortMemoryId as jM, steerAgentSessionInTransaction as jN, steerQueuedTurnInTransaction as jO, storeIntegrationOAuthClient as jP, submitHumanPromptInTransaction as jQ, sumUsageQuantity as jR, supersedeSessionCurrentDirectionInTransaction as jS, touchEnrollmentLastSeen as jT, touchLeaseHolder as jU, updateCodexRotationSettings as jV, updateConnection as jW, updateImportBatchCounts as jX, updateKnowledgeMemory as jY, updatePackInstallationStatus as jZ, updatePtySessionActivity as j_, sanitizeMemoryText as ja, sanitizeModelPayload as jb, saveComposerDraftInTransaction as jc, saveRunState as jd, saveWorkspaceMemory as je, searchWorkspaceMemories as jf, sendAgentMessageInTransaction as jg, serializeEffectiveSessionControl as jh, sessionAuthorizationScopeFilter as ji, sessionSubject as jj, sessionTreeStatsForSessions as jk, sessionsWithActiveOpOnEnrollment as jl, setActiveCodexCredential as jm, setActiveSandbox as jn, setCodexCredentialExhausted as jo, setCodexCredentialExhaustedWithWakeTargets as jp, setCodexCredentialStatus as jq, setCodexCredentialStatusById as jr, setConnectionStatus as js, setEnrollmentDisplayState as jt, setEnrollmentOpStreamState as ju, setEnrollmentWentOffline as jv, setInitialActiveCodexCredential as jw, setRlsContext as jx, setSessionCodexPin as jy, setSessionGoalLastContinuationTurn as jz, type AppendEventInput as k, updateRig as k0, updateRigChangeStatus as k1, updateScheduledTask as k2, updateScheduledTaskRun as k3, updateSessionCommandReceiptResult as k4, updateSessionGoal as k5, updateSessionMcpServerCredentials as k6, updateSessionTitle as k7, updateVariableSet as k8, updateWorkspace as k9, updateWorkspaceEnvironment as ka, updateWorkspaceSettings as kb, upsertBillingCustomer as kc, upsertCapabilityCatalogItem as kd, upsertCodexSubscriptionCredential as ke, upsertGitHubInstallation as kf, upsertMachineMetricsLatest as kg, upsertRegistryCapabilityCatalogItem as kh, upsertSandboxSessionEnvelope as ki, upsertSessionGoal as kj, upsertWorkspaceModelPolicy as kk, validateHumanInputResponse as kl, withAccountRls as km, withCodexCapacityMutation as kn, withCodexCredentialRefreshLock as ko, withRlsContext as kp, withWorkspaceRls as kq, withWorkspaceSubjectRls as kr, withWorkspaceUsageLock as ks, workspaceCaptureAtRevision as kt, workspaceCodexSubscriptionActive as ku, type ApplyContextCompactionResult as l, type ApplySessionTurnSettlementInput as m, type ApplySessionTurnSettlementResult as n, type ArmCodexCapacityWaitResult as o, CODEX_CAPACITY_REFRESH_MIN_MS as p, provisionRoles, CODEX_CREDENTIAL_LEASE_TTL_MS as q, CODEX_ROTATION_STRATEGIES as r, type ClaimSessionWorkForAttemptInput as s, type ClaimSessionWorkForAttemptResult as t, type ClearSessionContextResult as u, type CodexAccountStatus as v, type CodexAccountUsageSnapshot as w, type CodexAuthDeps as x, type CodexCapacityAvailabilityDecision as y, type CodexCapacityMutationResult as z };