@opengeni/db 3.6.0 → 3.7.4-canary.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { type ChildLifecycleSystemUpdateKind, type ChildRequiresActionRespondedByKind, SessionGoalSnapshot } from "@opengeni/contracts";
-import type { AccessContext, AccessGrant, AccessPrincipalKind, ApiKey, AttemptToolResult, BillingBalance, CapabilityCatalogItem, CapabilityInstallation, CapabilityPack, CapabilitySource, ConnectionKind, ConnectionMetadata, ConnectionStatus, DocumentAuthorityKind, McpServerConnectionRef, FileAsset, FileUploadStatus, FirstPartyMcpToolName, HumanInputQuestion, HumanInputResponse, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemoryStatus, KnowledgeSourceRef, GitHubInstallationAuthorityKind, GitHubRepositoryScope, HostEventExportBatch, HostUsageExportBatch, ManagedAccount, ManagedOrganizationMembershipProjection, McpPersonalConnectionDelegation, ModelContextContributionSummary, Permission, PersonalResourceAttachmentIntent, PackInstallation, PackInstallationStatus, ResourceRef, SandboxBackend, SandboxOs, ScheduledTask, ScheduledTaskAction, ScheduledTaskActionKind, KnowledgeSourceSyncAction, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunAcceptedExecution as ScheduledTaskRunAcceptedExecutionType, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, SlackInstallationBinding, Session, SessionAuthorizationListScope, SessionListResponse, SessionEvent, SessionEventPayloadMode, SessionEventReadDirection, SessionEventSemanticClass, SessionEventType, SessionGoal, SessionGoalChangeKind, SessionGoalCreatedBy, SessionGoalMutationPolicy, SessionGoalRevision, SessionGoalStatus, SessionHumanInputRequest, LineageNode, SessionMcpApprovalPolicy, SessionSkill, SessionMcpServerMetadata, SessionStatus, SessionToolPolicy, SessionTurn, SessionQueueSnapshot, SessionSystemUpdate, SessionSystemUpdateKind, SystemUpdateClassification, SessionTurnSource, SessionTurnStatus, TurnInitiator, TurnInitiatorContext, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, ToolRef, ReasoningEffort, UsageEvent, Workspace, WorkspaceControlEvent, VariableSet, VariableSetSecret, VariableSetVariableMetadata, WorkspaceMember, WorkspaceMemoryPromptMode, WorkspaceRegisteredPack, Channel, Rig, RigProviderImage, RigProviderImages, RigVersion, RigVerificationHealth, RigChange, RigChangeKind, RigChangeStatus, RigCheck, NativeSnapshotDescriptor, TarWorkspaceArchiveDescriptor, WorkspaceArchiveDescriptor, ModalCheckpointProviderBinding, SandboxProviderContinuityRecovery, WorkClaimSubjectFilter, WorkDiscoveryProjection } from "@opengeni/contracts";
+import type { AccessContext, AccessGrant, AccessPrincipalKind, ApiKey, AttemptToolResult, BillingBalance, CapabilityCatalogItem, CapabilityInstallation, CapabilityPack, CapabilitySource, ConnectionKind, ConnectionMetadata, ConnectionStatus, DocumentAuthorityKind, McpServerConnectionRef, FileAsset, FileUploadStatus, FirstPartyMcpToolName, HumanInputQuestion, HumanInputResponse, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemoryStatus, KnowledgeSourceRef, GitHubInstallationAuthorityKind, GitHubRepositoryScope, HostEventExportBatch, HostUsageExportBatch, ManagedAccount, ManagedOrganizationMembershipProjection, WorkspaceMemberCandidate, McpPersonalConnectionDelegation, ModelContextContributionSummary, Permission, PersonalResourceAttachmentIntent, PackInstallation, PackInstallationStatus, ResourceRef, SandboxBackend, SandboxOs, ScheduledTask, ScheduledTaskAction, ScheduledTaskActionKind, KnowledgeSourceSyncAction, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunAcceptedExecution as ScheduledTaskRunAcceptedExecutionType, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, SlackInstallationBinding, Session, SessionAuthorizationListScope, SessionListResponse, SessionEvent, SessionEventPayloadMode, SessionEventReadDirection, SessionEventSemanticClass, SessionEventType, SessionGoal, SessionGoalChangeKind, SessionGoalCreatedBy, SessionGoalMutationPolicy, SessionGoalRevision, SessionGoalStatus, SessionHumanInputRequest, LineageNode, SessionMcpApprovalPolicy, SessionSkill, SessionMcpServerMetadata, SessionStatus, SessionToolPolicy, SessionTurn, SessionQueueSnapshot, SessionSystemUpdate, SessionSystemUpdateKind, SystemUpdateClassification, SessionTurnSource, SessionTurnStatus, TurnInitiator, TurnInitiatorContext, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, ToolRef, ReasoningEffort, UsageEvent, Workspace, WorkspaceControlEvent, VariableSet, VariableSetSecret, VariableSetVariableMetadata, WorkspaceMember, WorkspaceMemoryPromptMode, WorkspaceRegisteredPack, Channel, Rig, RigProviderImage, RigProviderImages, RigVersion, RigVerificationHealth, RigChange, RigChangeKind, RigChangeStatus, RigCheck, NativeSnapshotDescriptor, TarWorkspaceArchiveDescriptor, WorkspaceArchiveDescriptor, ModalCheckpointProviderBinding, SandboxProviderContinuityRecovery, WorkClaimSubjectFilter, WorkDiscoveryProjection } from "@opengeni/contracts";
 import { type WorkspaceArchiveObjectRef, RequestHumanInteractionToolInput, XaiProviderAccountAuthoritySnapshotV1, type TimelineAnnotation } from "@opengeni/contracts";
 import { type LatencyMode, SessionSystemUpdatePayload, TurnExecutionPolicyV1 } from "@opengeni/contracts";
 import { type Settings } from "@opengeni/config";
@@ -23,6 +23,7 @@ export * from "./session-realtime-ledger.js";
 export * from "./new-session-drafts.js";
 export * from "./workspace-instruction-policies.js";
 export * from "./company-profile.js";
+export * from "./company-profile-agent-policy.js";
 export * from "./company-profile-agent-admin.js";
 export * from "./workspace-learning-policy.js";
 export * from "./governed-learning-evaluator.js";
@@ -67,10 +68,11 @@ export { memoryTextForStorage } from "./memory-domain.js";
 export { migrate, runMigrations } from "./migrate.js";
 export { provisionRoles, type ProvisionResult, type ProvisionRolesOptions, } from "./provision-roles.js";
 export * from "./memory-domain.js";
+export * from "./model-catalog.js";
 import { type Database, type SessionActivityDatabase } from "./database.js";
 export { createDb, registerDbBinding, retrySessionActivityRls, rlsContextForWorkspace, rlsStrategyFor, setRlsContext, setSubjectRlsContext, withAccountRls, withDatabaseStatementTimeout, withRlsContext, withSessionActivityRlsContext, withSessionActivitySavepoint, withWorkspaceRls, withWorkspaceSessionActivityRls, withWorkspaceSubjectRls, withWorkspaceSubjectSessionActivityRls, withWorkspaceUsageLock, withSandboxProviderReadLock, SandboxProviderReadLockUnavailableError, type CreateDbOptions, type Database, type DbClient, type SessionActivityDatabase, type RlsContext, type SessionRlsActorContext, type RlsStrategy, type SandboxProviderReadLockIdentity, type ManagedUserProfile, type UserLookup, type UserProfileLookup, } from "./database.js";
 export { withSessionRlsActorContext } from "./database.js";
-import { buildCodexTokenResolver as buildCodexTokenResolverCore, fetchCodexRateLimitResetCreditsForAccount as fetchCodexRateLimitResetCreditsForAccountCore, fetchCodexUsageForAccount as fetchCodexUsageForAccountCore, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialForRun } from "./codex-token-resolver.js";
+import { buildCodexTokenResolver as buildCodexTokenResolverCore, fetchCodexRateLimitResetCreditsForAccount as fetchCodexRateLimitResetCreditsForAccountCore, fetchCodexUsageForAccount as fetchCodexUsageForAccountCore, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialCooldownKind, type CodexCredentialForRun } from "./codex-token-resolver.js";
 import { buildConnectionTokenResolver as buildConnectionTokenResolverCore, type ConnectionBrokerDeps, type ConnectionCredentialForBroker, type ConnectionTokenResolverOptions } from "./connection-token-resolver.js";
 /** Raised when a durable session tool-policy write lost its version fence. */
 export declare class SessionToolPolicyVersionConflictError extends Error {
@@ -262,6 +264,18 @@ export declare const allWorkspacePermissions: Permission[];
  * with ambient access to the private workspace.
  */
 export declare const managedPersonalWorkspacePermissions: Permission[];
+/**
+ * Resolve the synthetic personal-workspace grant for a subject whose human
+ * identity was authenticated out of band (for example, in HMAC-signed OAuth
+ * state). This is intentionally narrower than ordinary access resolution:
+ * the requested workspace must still be the subject's current personal
+ * workspace pointer and its organization membership must remain active.
+ */
+export declare function resolveNamedManagedPersonalWorkspaceGrant(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+}): Promise<AccessGrant | null>;
 export declare const allAccountPermissions: Permission[];
 export type BootstrapWorkspaceInput = {
     accountExternalSource: string;
@@ -300,6 +314,14 @@ export declare function getWorkspace(db: Database, workspaceId: string): Promise
 export declare function getManagedAccount(db: Database, accountId: string): Promise<ManagedAccount | null>;
 export declare function requireWorkspace(db: Database, workspaceId: string): Promise<Workspace>;
 export declare function listWorkspacesForSubject(db: Database, subjectId: string, limit?: number): Promise<Workspace[]>;
+/**
+ * Complete organization-workspace inventory for an account-scoped caller.
+ * Personal workspaces are excluded by the canonical organization-membership
+ * pointer through one narrowly granted set-based database capability; the
+ * public projection is therefore safely emitted as the current wire value
+ * `kind: "shared"`.
+ */
+export declare function listSharedWorkspacesForAccount(db: Database, accountId: string): Promise<Workspace[]>;
 export declare function countWorkspacesForAccount(db: Database, accountId: string): Promise<number>;
 export declare function createWorkspace(db: Database, input: {
     accountId: string;
@@ -308,7 +330,36 @@ export declare function createWorkspace(db: Database, input: {
     externalSource?: string | null;
     externalId?: string | null;
     agentInstructions?: string | null;
+    maxWorkspacesPerAccount?: number | null;
 }): Promise<Workspace>;
+export declare class WorkspaceExternalIdentityConflictError extends Error {
+    constructor();
+}
+export declare function findWorkspaceByExternalIdentity(db: Database, input: {
+    externalSource: string;
+    externalId: string;
+}): Promise<Workspace | null>;
+export declare class WorkspaceLimitExceededError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
+/**
+ * Create an organization workspace exactly once for a stable external tenant
+ * identity. The global unique index is the concurrency arbiter. A replay never
+ * mutates presentation fields supplied by the original create.
+ */
+export declare function ensureWorkspaceByExternalIdentity(db: Database, input: {
+    accountId: string;
+    externalSource: string;
+    externalId: string;
+    name: string;
+    slug?: string | null;
+    agentInstructions?: string | null;
+    maxWorkspacesPerAccount?: number | null;
+}): Promise<{
+    workspace: Workspace;
+    created: boolean;
+}>;
 /**
  * Create one shared workspace through the direct managed-human organization
  * control plane. Organization authority is rechecked inside the lifecycle
@@ -331,6 +382,40 @@ export declare function grantWorkspaceAccess(db: Database, input: {
     role?: string;
     permissions: Permission[];
 }): Promise<void>;
+export declare class WorkspaceMemberManagementError extends Error {
+    readonly code: "WORKSPACE_MEMBER_ALREADY_EXISTS" | "WORKSPACE_MEMBER_NOT_FOUND" | "WORKSPACE_MEMBER_SELF_UPDATE" | "WORKSPACE_MEMBER_LAST_ADMIN";
+    constructor(code: "WORKSPACE_MEMBER_ALREADY_EXISTS" | "WORKSPACE_MEMBER_NOT_FOUND" | "WORKSPACE_MEMBER_SELF_UPDATE" | "WORKSPACE_MEMBER_LAST_ADMIN");
+}
+/**
+ * Add or update one human workspace member under the same organization fence
+ * used by suspension, offboarding, organization-level grants, and removals.
+ * The SECURITY DEFINER candidate check runs after the fence is held, so a
+ * concurrent lifecycle transition cannot invalidate authority between the
+ * check and the membership write.
+ */
+export declare function upsertWorkspaceMemberAsWorkspaceManager(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+    targetSubjectId: string;
+    mode: "add" | "update";
+    subjectLabel?: string;
+    role: string;
+    permissions: Permission[];
+}): Promise<void>;
+/** Prove workspace-scoped management and same-organization active membership. */
+export declare function assertWorkspaceMemberManagementCandidate(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+    targetSubjectId: string;
+}): Promise<void>;
+/** List active same-organization humans who do not already have workspace access. */
+export declare function listWorkspaceMemberManagementCandidates(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+}): Promise<WorkspaceMemberCandidate[]>;
 /**
  * Organization control-plane metadata update for one shared workspace. This
  * capability never creates a workspace membership or an operational grant for
@@ -427,6 +512,18 @@ export type DeleteWorkspaceIfQuiescentResult = {
 } | {
     status: "not_found" | "only_workspace" | "active_sessions" | "active_video_generations" | "active_background_commands" | "live_sandboxes";
 };
+export type WorkspaceDeletePhase = "transaction" | "lifecycle_lock" | "account_workspace_lock" | "session_fence" | "runtime_ownership" | "external_cleanup" | "variable_set_detach" | "cascade";
+export type WorkspaceDeleteOutcome = DeleteWorkspaceIfQuiescentResult["status"] | "ok" | "error";
+export type WorkspaceDeleteInventoryKind = "workspaces" | "sessions" | "live_attempts" | "active_video_generations" | "active_background_commands" | "sandbox_leases" | "sandbox_holders" | "unsettled_sandbox_admissions" | "active_retained_processes" | "open_ptys" | "temporal_schedules";
+export type WorkspaceDeleteObservation = {
+    phase: WorkspaceDeletePhase;
+    outcome: WorkspaceDeleteOutcome;
+    durationSeconds: number;
+    inventory?: Partial<Record<WorkspaceDeleteInventoryKind, number>>;
+};
+export type WorkspaceDeleteObserver = {
+    onPhase?: (observation: WorkspaceDeleteObservation) => void;
+};
 /**
  * Atomically prove a workspace has no live runtime ownership and delete it.
  *
@@ -439,6 +536,7 @@ export type DeleteWorkspaceIfQuiescentResult = {
 export declare function deleteWorkspaceIfQuiescent(db: Database, input: {
     accountId: string;
     workspaceId: string;
+    observer?: WorkspaceDeleteObserver;
 }): Promise<DeleteWorkspaceIfQuiescentResult>;
 /** Claim a bounded cross-workspace batch after abandoned claims expire. */
 export declare function claimTemporalScheduleCleanups(db: Database, input: {
@@ -470,11 +568,37 @@ export declare function createApiKey(db: Database, input: {
     keyHash: string;
     permissions: Permission[];
     expiresAt?: Date | null;
+    credentialKind?: schema.ApiKeyCredentialKind;
+}): Promise<ApiKey>;
+export declare class OrganizationApiKeyLimitExceededError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
+/**
+ * Create an explicitly proven organization key under one account-scoped lock.
+ * An authenticating organization key may open exactly one temporary overlap
+ * slot at the configured cap so it can create a replacement before revocation.
+ */
+export declare function createOrganizationApiKey(db: Database, input: {
+    accountId: string;
+    name: string;
+    description?: string | null;
+    prefix: string;
+    keyHash: string;
+    permissions: Permission[];
+    expiresAt?: Date | null;
+    maxActiveKeys?: number | null;
+    rotationSourceApiKeyId?: string | null;
 }): Promise<ApiKey>;
 export declare function listApiKeys(db: Database, workspaceId: string): Promise<ApiKey[]>;
+export declare function listOrganizationApiKeys(db: Database, accountId: string): Promise<ApiKey[]>;
 export declare function countActiveApiKeysForWorkspace(db: Database, workspaceId: string): Promise<number>;
+export declare function countActiveOrganizationApiKeysForAccount(db: Database, accountId: string): Promise<number>;
 export declare function revokeApiKey(db: Database, workspaceId: string, apiKeyId: string): Promise<ApiKey>;
-export declare function findActiveApiKeyByHash(db: Database, keyHash: string): Promise<ApiKey | null>;
+export declare function revokeOrganizationApiKey(db: Database, accountId: string, apiKeyId: string): Promise<ApiKey | null>;
+export declare function findActiveApiKeyByHash(db: Database, keyHash: string): Promise<(ApiKey & {
+    credentialKind: schema.ApiKeyCredentialKind;
+}) | null>;
 export type GitHubInstallation = {
     id: string;
     accountId: string;
@@ -726,6 +850,8 @@ export type CreateScheduledTaskInput = {
     variableSetId?: string | null;
     rigId?: string | null;
     metadata: Record<string, unknown>;
+    /** Trusted database-only admission seam. Throwing rolls the task creation back. */
+    beforeCreateCommit?: (tx: Database) => Promise<void>;
 };
 export type UpdateScheduledTaskInput = Partial<{
     name: string;
@@ -747,6 +873,8 @@ export type UpdateScheduledTaskInput = Partial<{
     authorityUpdatedBy: TurnInitiator;
     authorityUpdatedByContext: TurnInitiatorContext;
     authorityUpdatedByActor: AgentSessionCreationActor | null;
+    /** Trusted database-only admission seam. Throwing rolls the task update back. */
+    beforeUpdateCommit: (tx: Database) => Promise<void>;
 }>;
 export type CreatePackInstallationInput = {
     accountId: string;
@@ -869,6 +997,43 @@ export type CreateConnectionInput = {
     createdBySubjectId?: string | null;
     updatedBySubjectId?: string | null;
 };
+type UpsertWorkspaceProviderApiKeyConnectionInput = {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    requestDigest: string;
+    credentialEncrypted: string;
+    grantedScopes?: string[];
+    expiresAt?: Date | null;
+    metadata?: Record<string, unknown>;
+    updatedBySubjectId: string;
+};
+type RotateWorkspaceProviderApiKeyConnectionInput = {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    expectedVersion: number;
+    operationId: string;
+    requestDigest: string;
+    credentialEncrypted: string;
+    grantedScopes?: string[];
+    expiresAt?: Date | null;
+    metadata?: Record<string, unknown>;
+    updatedBySubjectId: string;
+};
+type RevokeWorkspaceProviderApiKeyConnectionsInput = {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    expectedVersion: number;
+    updatedBySubjectId: string;
+};
+export type UpsertWorkspaceVercelAiGatewayConnectionInput = UpsertWorkspaceProviderApiKeyConnectionInput;
+export type RotateWorkspaceVercelAiGatewayConnectionInput = RotateWorkspaceProviderApiKeyConnectionInput;
+export type RevokeWorkspaceVercelAiGatewayConnectionsInput = RevokeWorkspaceProviderApiKeyConnectionsInput;
+export type UpsertWorkspaceOpenRouterConnectionInput = UpsertWorkspaceProviderApiKeyConnectionInput;
+export type RotateWorkspaceOpenRouterConnectionInput = RotateWorkspaceProviderApiKeyConnectionInput;
+export type RevokeWorkspaceOpenRouterConnectionsInput = RevokeWorkspaceProviderApiKeyConnectionsInput;
 export type UpdateConnectionInput = {
     workspaceId: string;
     connectionId: string;
@@ -1763,6 +1928,15 @@ export declare function decryptedCapabilityHeaders(server: EnabledMcpCapabilityS
 export declare function getStoredCapabilityHeaderCiphertext(db: Database, workspaceId: string, capabilityId: string): Promise<Record<string, string> | null>;
 export declare function mcpServerIdForCapability(capabilityId: string, metadata?: Record<string, unknown>): string;
 export declare function createConnection(db: Database, input: CreateConnectionInput): Promise<ConnectionMetadataWithVerification>;
+/** Compatibility wrapper for the existing Vercel AI Gateway create/replay contract. */
+export declare function upsertWorkspaceVercelAiGatewayConnection(db: Database, input: UpsertWorkspaceVercelAiGatewayConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
+export declare function upsertWorkspaceOpenRouterConnection(db: Database, input: UpsertWorkspaceOpenRouterConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
+/** Compatibility wrapper for the existing Vercel AI Gateway rotation contract. */
+export declare function rotateWorkspaceVercelAiGatewayConnection(db: Database, input: RotateWorkspaceVercelAiGatewayConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
+export declare function rotateWorkspaceOpenRouterConnection(db: Database, input: RotateWorkspaceOpenRouterConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
+/** Compatibility wrapper for the existing Vercel AI Gateway revoke contract. */
+export declare function revokeWorkspaceVercelAiGatewayConnections(db: Database, input: RevokeWorkspaceVercelAiGatewayConnectionsInput): Promise<ConnectionMetadataWithVerification | null>;
+export declare function revokeWorkspaceOpenRouterConnections(db: Database, input: RevokeWorkspaceOpenRouterConnectionsInput): Promise<ConnectionMetadataWithVerification | null>;
 /**
  * Serialize one provider-principal/owner connection generation. Distinct OAuth
  * starts for the same principal converge on one row, while an explicit
@@ -2394,14 +2568,21 @@ export declare function loadConnectionCredentialForBroker(db: Database, settings
     allowSubjectOwned?: boolean;
     expectedAuthorityGeneration?: number;
 }): Promise<ConnectionCredentialForBroker | null>;
-export declare function workspaceVercelAiGatewayConnectionActive(db: Database, workspaceId: string): Promise<boolean>;
 /** Metadata-only capability revision input; never selects/decrypts the API key. */
 export declare function getWorkspaceVercelAiGatewayConnectionMetadata(db: Database, workspaceId: string): Promise<{
     connectionId: string;
     version: number;
 } | null>;
+export declare function getWorkspaceOpenRouterConnectionMetadata(db: Database, workspaceId: string): Promise<{
+    connectionId: string;
+    version: number;
+} | null>;
+export declare function workspaceVercelAiGatewayConnectionActive(db: Database, workspaceId: string): Promise<boolean>;
+export declare function workspaceOpenRouterConnectionActive(db: Database, workspaceId: string): Promise<boolean>;
 /** Resolve only the reviewed workspace-shared AI Gateway credential shape. */
 export declare function loadWorkspaceVercelAiGatewayApiKey(db: Database, settings: Settings, workspaceId: string): Promise<string | null>;
+/** Resolve only the reviewed workspace-shared OpenRouter credential shape. */
+export declare function loadWorkspaceOpenRouterApiKey(db: Database, settings: Settings, workspaceId: string): Promise<string | null>;
 /**
  * Worker-only immutable credential lease for an asynchronous video operation.
  * The operation copies the already-encrypted credential envelope before its
@@ -2479,6 +2660,7 @@ export type CorrectWorkspaceMemoryInput = {
     reason?: string | undefined;
     replacementText?: string | undefined;
     sessionId?: string | null | undefined;
+    origin?: WorkspaceMemoryOrigin | undefined;
 };
 export type CorrectWorkspaceMemoryResult = {
     action: "archived" | "superseded" | "updated";
@@ -2629,6 +2811,11 @@ export declare function createScheduledTaskRun(db: Database, input: {
     scheduledAt?: Date | null;
     firedAt?: Date;
     acceptedExecutionSnapshot?: ScheduledTaskRunAcceptedExecutionType | null;
+    /**
+     * Trusted database-only admission seam for a fresh agent occurrence.
+     * Throwing rolls back the run insert; exact producer replay skips it.
+     */
+    beforeFreshAgentRunCommit?: (tx: Database) => Promise<void>;
 }): Promise<ScheduledTaskRun>;
 export declare function getScheduledTaskRunAcceptedExecution(db: Database, input: {
     workspaceId: string;
@@ -2701,6 +2888,43 @@ export declare function getScheduledTaskRevisionAuthority(db: Database, input: {
 } | null>;
 /** Failure settlement must not rewrite a source already committed as dispatched. */
 export declare function markScheduledTaskRunFailedIfQueued(db: Database, workspaceId: string, runId: string, error: string): Promise<void>;
+export type FailScheduledGeneratedSessionRouteResult = {
+    action: "failed";
+    events: SessionEvent[];
+    sessionReclaimed: boolean;
+    error: string;
+} | {
+    action: "terminal";
+    events: [];
+    sessionReclaimed: false;
+    status: "failed" | "skipped";
+    error: string | null;
+} | {
+    action: "advanced";
+    events: [];
+    sessionReclaimed: false;
+    status: "dispatched" | "succeeded";
+};
+/**
+ * Fail a queued scheduled run after its selected Connected Machine could not be
+ * established. If the exact scheduler-created session has not acquired any
+ * turn, fail that otherwise-orphaned session in the same transaction. A user
+ * cancellation wins for the session row, but the machine failure still owns
+ * the run settlement in this one durable boundary.
+ *
+ * The external liveness probe and sandbox CAS must happen before this DB-only
+ * seam. This transaction serializes the resulting failure with initialization,
+ * cancellation, and a concurrent dispatcher under the canonical
+ * control -> workspace -> session -> scheduled-run lock order.
+ */
+export declare function failScheduledGeneratedSessionRoute(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    taskId: string;
+    runId: string;
+    sessionId: string;
+    error: string;
+}): Promise<FailScheduledGeneratedSessionRouteResult>;
 export declare function markScheduledTaskRunSkippedIfQueued(db: Database, input: {
     workspaceId: string;
     runId: string;
@@ -3436,6 +3660,30 @@ export declare function loadVariableSetForRun(db: Database, settings: Settings,
 export declare const loadWorkspaceEnvironmentForRun: typeof loadVariableSetForRun;
 /** @deprecated use VariableSetForRun */
 export type WorkspaceEnvironmentForRun = VariableSetForRun;
+export type WorkspaceCodexSubscriptionMode = "automatic" | "workspace" | "organization" | "disabled";
+export type EffectiveCodexSubscriptionSource = "workspace" | "organization" | "disabled";
+export type WorkspaceCodexSubscriptionSource = {
+    accountId: string;
+    workspaceId: string;
+    workspaceKind: "personal" | "shared";
+    mode: WorkspaceCodexSubscriptionMode;
+    effectiveSource: EffectiveCodexSubscriptionSource;
+    workspaceAvailable: boolean;
+    organizationAvailable: boolean;
+};
+export declare function getWorkspaceCodexSubscriptionSource(db: Database, workspaceId: string): Promise<WorkspaceCodexSubscriptionSource>;
+export declare function setWorkspaceCodexSubscriptionModeInTransaction(scopedDb: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    mode: WorkspaceCodexSubscriptionMode;
+}): Promise<WorkspaceCodexSubscriptionSource>;
+export declare function setWorkspaceCodexSubscriptionMode(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    mode: WorkspaceCodexSubscriptionMode;
+}): Promise<WorkspaceCodexSubscriptionSource>;
 /**
  * Login / rotation write (multi-account P1). Caller passes the PRE-encrypted
  * credential blob. Keyed on the composite partial index (workspace, chatgpt
@@ -3469,6 +3717,65 @@ export declare function upsertCodexSubscriptionCredential(db: Database, input: {
     /** Direct managed-cookie human who most recently connected this row. */
     connectedBySubjectId?: string | null;
 }): Promise<UpsertCodexSubscriptionCredentialResult>;
+export declare function ensureOrganizationCodexRotationSettings(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+}): Promise<void>;
+export declare function upsertOrganizationCodexSubscriptionCredential(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialEncrypted: string;
+    chatgptAccountId: string | null;
+    scopes: string | null;
+    planType: string | null;
+    isFedramp: boolean;
+    expiresAt: Date | null;
+    lastRefreshAt: Date | null;
+    accountEmail?: string | null;
+    label?: string | null;
+}): Promise<{
+    id: string;
+    isNew: boolean;
+    wakeTargets: CodexCapacityWakeTarget[];
+}>;
+export declare function listOrganizationCodexAccountStatuses(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+}): Promise<CodexAccountStatus[]>;
+export declare function getOrganizationCodexRotationSettings(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+}): Promise<CodexRotationSettings | null>;
+export declare function setActiveOrganizationCodexCredential(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialId: string;
+}): Promise<{
+    activated: boolean;
+    wakeTargets: CodexCapacityWakeTarget[];
+}>;
+export declare function updateOrganizationCodexRotationSettings(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    rotationEnabled: boolean;
+}): Promise<(CodexRotationSettings & {
+    wakeTargets: CodexCapacityWakeTarget[];
+}) | null>;
+export declare function renameOrganizationCodexAccount(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialId: string;
+    label: string | null;
+}): Promise<boolean>;
+export declare function disconnectOrganizationCodexAccount(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialId: string;
+}): Promise<{
+    removed: boolean;
+    newActiveCredentialId: string | null;
+    wakeTargets: CodexCapacityWakeTarget[];
+}>;
 export type CodexAppsSettings = {
     credentialId: string | null;
     version: number;
@@ -3645,6 +3952,7 @@ export declare function isCodexBilledTurn(input: {
 }): Promise<boolean>;
 export type CodexAccountStatus = {
     id: string;
+    source: Exclude<EffectiveCodexSubscriptionSource, "disabled">;
     chatgptAccountId: string | null;
     label: string | null;
     accountEmail: string | null;
@@ -3668,6 +3976,8 @@ export type CodexAccountStatus = {
     secondaryResetAt: Date | null;
     usageCheckedAt: Date | null;
     exhaustedUntil: Date | null;
+    /** Typed provider-refusal provenance; null for legacy/cleared cooldowns. */
+    exhaustedKind: CodexCredentialCooldownKind | null;
 };
 /**
  * A metadata-only scheduling candidate observed while the workspace's rotation
@@ -3675,7 +3985,7 @@ export type CodexAccountStatus = {
  * the selection cursor gives deterministic fairness after those holders drain.
  * None of these fields contains credential material.
  */
-export type CodexLeaseAccountStatus = Omit<CodexAccountStatus, "allocatorVersion" | "allocatorUpdatedBySubjectId" | "allocatorUpdatedAt" | "resetCreditAvailableCount" | "resetCreditsCheckedAt" | "connectedBySubjectId"> & {
+export type CodexLeaseAccountStatus = Omit<CodexAccountStatus, "allocatorVersion" | "allocatorUpdatedBySubjectId" | "allocatorUpdatedAt" | "resetCreditAvailableCount" | "resetCreditsCheckedAt" | "connectedBySubjectId" | "source"> & {
     activeLeaseCount: number;
     selectionCount: number;
     lastSelectedAt: Date | null;
@@ -4059,6 +4369,7 @@ export type CodexCredentialLeaseQuarantine = {
 } | {
     kind: "cooldown";
     until: Date;
+    cooldownKind: CodexCredentialCooldownKind;
 };
 /**
  * Quarantine the credential served by one exact live holder. The lease row is
@@ -4264,7 +4575,7 @@ export declare function completeCodexResetRedemption(db: Database, input: {
 }): Promise<CodexCapacityMutationResult<CodexResetRedemptionAttempt | null>>;
 /** The P2 usage-cache snapshot written by the refreshing usage wrapper. */
 /**
- * Cache-write for P2 quota bars: persist the five plaintext usage columns on a
+ * Cache-write for P2 quota bars and revision-fenced quota cooldown repair on a
  * SPECIFIC credential row. NEVER touches credential_encrypted. RLS-scoped, guarded
  * by (id, workspace_id) so it can only write a row the workspace owns. Returns true
  * iff a row was updated (false ⇒ the credential was disconnected under us — the
@@ -4328,9 +4639,9 @@ export declare function setInitialActiveCodexCredential(db: Database, workspaceI
  * never race the (id, version) token-refresh CAS in recordCodexTokenRefresh / setCodexCredentialStatus.
  * Returns true iff a row was updated (false ⇒ the credential was disconnected under us).
  */
-export declare function setCodexCredentialExhausted(db: Database, workspaceId: string, credentialId: string, until: Date | null): Promise<boolean>;
+export declare function setCodexCredentialExhausted(db: Database, workspaceId: string, credentialId: string, until: Date | null, cooldownKind: CodexCredentialCooldownKind | null): Promise<boolean>;
 /** Cooldown mutation plus its committed durable capacity-wake outbox. */
-export declare function setCodexCredentialExhaustedWithWakeTargets(db: Database, workspaceId: string, credentialId: string, until: Date | null): Promise<CodexCapacityMutationResult<boolean>>;
+export declare function setCodexCredentialExhaustedWithWakeTargets(db: Database, workspaceId: string, credentialId: string, until: Date | null, cooldownKind: CodexCredentialCooldownKind | null): Promise<CodexCapacityMutationResult<boolean>>;
 /**
  * P3 reactive-rotation boundedness (Finding 1b): the number of CONSECUTIVE rotated
  * 429-failover turns since the session last had a SUCCESSFUL turn. Counts
@@ -4610,7 +4921,9 @@ export type SessionCreateInput = {
     /** Trusted, transaction-local linkage run after the exact session row and
      * MCP metadata exist but before either can commit. It must perform database
      * work only; throwing rolls the complete create/replay transaction back. */
-    beforeCreateCommit?: (tx: Database, sessionId: string) => Promise<void>;
+    beforeCreateCommit?: (tx: Database, sessionId: string, context?: {
+        created: boolean;
+    }) => Promise<void>;
 };
 export declare function createSession(db: Database, input: SessionCreateInput): Promise<DbSession>;
 /**
@@ -4635,6 +4948,42 @@ export declare function createSessionWithIdempotencyKey(db: Database, input: Ses
     createIdempotencyKey: string;
 }): Promise<SessionCreateSuccessResult>;
 export declare function getSessionByCreateIdempotencyKey(db: Database, workspaceId: string, createIdempotencyKey: string): Promise<Session | null>;
+/**
+ * Recover a keyed create before mutable create dependencies (notably the
+ * current model catalog) are consulted. A fully initialized queued turn gets a
+ * fresh durable wake revision from persisted state only; an uninitialized shell
+ * returns its persisted model so the caller can reopen it strictly as retained
+ * while the canonical keyed transaction repairs initialization. The same
+ * request-identity checks as transactional create replay run before any session
+ * or committed denial is returned.
+ */
+export type InitializedSessionCreateReplay = {
+    outcome: "session";
+    session: Session & {
+        initialTurnId: string | null;
+    };
+    temporalWorkflowId: string;
+    workflowWakeRevision: number | null;
+    changed: boolean;
+} | {
+    outcome: "pending";
+    session: Session;
+} | {
+    outcome: "denied";
+    denial: SessionSpawnDenial;
+};
+export declare function getInitializedSessionCreateReplay(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    activeManagedHumanSubjectId?: string;
+    createIdempotencyKey: string;
+    requestedSessionId?: string;
+    visibility?: "user_private" | "workspace_shared";
+    variableSetIds: string[];
+    initialPersonalResourceAttachmentIntent?: PersonalResourceAttachmentIntent | null;
+    deferInitialTurn?: boolean;
+}): Promise<InitializedSessionCreateReplay | null>;
 export declare function getSession(db: Database, workspaceId: string, sessionId: string): Promise<Session | null>;
 export type DeleteSessionTreeIfQuiescentResult = {
     status: "deleted";
@@ -5528,6 +5877,25 @@ export declare function recordSkippedContextCompaction(db: Database, input: {
     recorded: false;
     reason: TurnAttemptFenceRejectReason | "request_not_pending";
 }>;
+/**
+ * Read the durable handoff condition immediately after one exact compaction
+ * landmark settles. Steer admission deliberately leaves the active attempt
+ * unfenced while its latest compaction event is `started`; the worker calls
+ * this at the first safe boundary after `compacted`/`skipped` and supersedes
+ * the ordinary turn before another model request can begin.
+ *
+ * The later terminal settlement remains the authority fence. This read only
+ * decides whether that settlement is needed, so a concurrent Pause/Cancel or a
+ * Steer admitted after the landmark can still win and make the caller stale.
+ */
+export declare function hasPendingSteerAfterContextCompaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+    attemptId: string;
+}): Promise<boolean>;
 /**
  * The next free WHOLE-NUMBER history position for a session: one past the
  * largest existing position (active or superseded), floored so the synthetic
@@ -5942,6 +6310,54 @@ export type AcquireLeaseResult = {
     reason: "superseded" | "capture_in_progress" | "rotation_in_progress" | "provider_recovery_in_progress";
     lease: LeaseSnapshot;
 };
+export type SandboxSharedPreparationSnapshot = {
+    status: "running" | "completed" | "failed";
+    leaseEpoch: number;
+    instanceId: string;
+    specHash: string;
+    claimId: string;
+    ownerAttemptId: string;
+    attempt: number;
+    revision: number;
+    startedAt: Date;
+    deadlineAt: Date;
+    settledAt: Date | null;
+};
+export type ClaimSandboxSharedPreparationInput = {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedLeaseEpoch: number;
+    expectedInstanceId: string;
+    specHash: string;
+    holderId: string;
+    claimId: string;
+    ownerAttemptId: string;
+    timeoutMs: number;
+};
+export type ClaimSandboxSharedPreparationResult = {
+    role: "owner" | "joined" | "reused";
+    preparation: SandboxSharedPreparationSnapshot;
+} | {
+    role: "fenced";
+    lease: LeaseSnapshot | null;
+};
+/**
+ * Claim, join, or reuse immutable setup for one exact physical sandbox. The
+ * provider operation remains outside the transaction; the claim deadline and
+ * box-local idempotency marker make a lost owner recoverable without sharing
+ * any turn-private credential or file material.
+ */
+export declare function claimSandboxSharedPreparation(db: Database, input: ClaimSandboxSharedPreparationInput): Promise<ClaimSandboxSharedPreparationResult>;
+export declare function readSandboxSharedPreparation(db: Database, input: Omit<ClaimSandboxSharedPreparationInput, "claimId" | "ownerAttemptId" | "timeoutMs">): Promise<{
+    status: "available";
+    preparation: SandboxSharedPreparationSnapshot;
+} | {
+    status: "fenced";
+}>;
+export declare function settleSandboxSharedPreparation(db: Database, input: Omit<ClaimSandboxSharedPreparationInput, "ownerAttemptId" | "timeoutMs"> & {
+    outcome: "completed" | "failed";
+}): Promise<boolean>;
 export declare class SandboxLeaseSupersededError extends Error {
     readonly sandboxGroupId: string;
     readonly leaseEpoch: number;
@@ -6648,6 +7064,8 @@ export declare function listMeterableWarmLeases(db: Database): Promise<Meterable
  * even after every affected sandbox lease has become cold. */
 export declare function listSandboxViewerForceDrainWorkspaceIds(db: Database): Promise<string[]>;
 export declare function countQueuedTurns(db: Database): Promise<number>;
+export type SessionRecoveryBacklogState = "quiescence_missing" | "projection_stale";
+export declare function countSessionRecoveryBacklog(db: Database): Promise<Record<SessionRecoveryBacklogState, number>>;
 export declare function countSandboxLeasesByLiveness(db: Database): Promise<Record<SandboxLeaseLiveness, number>>;
 export type CreditBalanceByAccount = {
     accountId: string;
@@ -6683,6 +7101,18 @@ export declare class SandboxWorkspaceMutationFencedError extends Error {
     readonly name: string;
     constructor(code: "attempt_fenced" | "holder_fenced" | "lease_fenced" | "rotation_in_progress" | "route_fenced" | "process_fenced" | "capture_in_progress" | "admission_fenced" | "operation_invalid" | "generation_exhausted" | "authority_unattributed" | "authority_revoked", message: string);
 }
+/** An operation named a durable retained process that has already reached a
+ * terminal state. This remains a fence—the provider must not be called again
+ * and contradictory proof must not overwrite durable truth—but carries the
+ * existing terminal result so routing can reconcile a concurrent settlement
+ * or report completion/loss instead of presenting a retryable platform failure
+ * for a handle that can never become active again. */
+export declare class SandboxRetainedProcessTerminalError extends SandboxWorkspaceMutationFencedError {
+    readonly state: "exited" | "lost";
+    readonly exitCode: number | null;
+    readonly name = "SandboxRetainedProcessTerminalError";
+    constructor(state: "exited" | "lost", exitCode: number | null);
+}
 export type SandboxWorkspaceMutationAdmission = {
     id: string;
     leaseId: string;
@@ -7004,7 +7434,8 @@ export declare function countActiveRetainedProcessesByOwnerState(db: Database):
 export declare function countExpiredDrainingSandboxLeases(db: Database): Promise<ExpiredDrainingSandboxLeaseCount[]>;
 /** Settle an exact retained process only after exit or definitive loss proof.
  * The process row, parent admission, non-TTL holder, and lease count transition
- * commit atomically. Duplicate identical proof is idempotent; conflicting proof
+ * commit atomically. A duplicate terminal state + exit code is idempotent and
+ * preserves the first durable evidence reason; contradictory physical truth
  * fails closed. */
 export declare function settleRetainedProcess(db: Database, input: {
     accountId: string;
@@ -7256,6 +7687,7 @@ export type SandboxRotationBacklog = {
     turnBlocked: number;
     directBlocked: number;
     processBlocked: number;
+    interactionBlocked: number;
 };
 export declare function readSandboxRotationBacklog(db: Database): Promise<SandboxRotationBacklog>;
 export type LegacyModalCheckpointSlot = {
@@ -8614,6 +9046,7 @@ export declare function materializeGoalContinuation(db: Database, input: {
         model: string;
         reasoningEffort: ReasoningEffort;
         latencyMode: LatencyMode;
+        turnExecutionPolicy?: TurnExecutionPolicyV1;
         tools: ToolRef[];
         sandboxBackend: SandboxBackend;
     };
@@ -8628,6 +9061,9 @@ export type InitializeSessionStartInput = {
     /** Trusted create-session policy. Omitted only by legacy low-level callers. */
     turnExecutionPolicy?: TurnExecutionPolicyV1;
     createdEventPayload: Record<string, unknown>;
+    /** Sensitive-safe semantic title supplied by the trusted agent-child create
+     * path. It is committed with the initial timeline, never as a bare row edit. */
+    initialAutomaticTitle?: string | null;
     goal?: {
         text: string;
         successCriteria?: string | null;
@@ -8704,6 +9140,16 @@ export type ClaimSessionWorkForAttemptInput = {
         action: "reject";
         reason: string;
     }>;
+    /**
+     * A requires-action resume first persists its open tool-call result, then
+     * re-enters this exact attempt to attach machine input that arrived while the
+     * session was blocked. The dispatch metadata freezes the session's durable
+     * pending-event sequence at attempt claim; timestamps cannot own this fence
+     * because a producer transaction may wait on the session lock. Keeping this
+     * opt-in prevents an ordinary activity retry from inserting a system message
+     * ahead of the required call/result pair in canonical history.
+     */
+    attachPendingUpdatesToRunningAttempt?: boolean;
 };
 export type ClaimSessionWorkForAttemptResult = {
     action: "claimed";
@@ -9264,21 +9710,24 @@ export declare function claimPendingSessionWorkflowWakes(db: Database, limit?: n
  * accepted direction or an interrupted attempt awaiting writer-set proof.
  * Temporal accepting a signal is transport evidence, not proof that a closing
  * workflow observed Postgres. While active control still has an actionable
- * Agent Steer or pending quiescence, retain the revision so the bounded outbox
- * dispatcher retries signalWithStart. The attempt-fenced claim consumes an
- * Agent Steer once; a real Pause is the typed blocker and may acknowledge this
+ * Agent Steer, a current wake still owns an accepted queued human/API turn, or
+ * an attempt awaits quiescence, retain the revision so the bounded outbox
+ * dispatcher retries signalWithStart. The attempt-fenced claim consumes each
+ * direction once; a real Pause is the typed blocker and may acknowledge this
  * revision because Resume commits a new one.
  *
  * An older sender may advance only its own revision; it cannot clear a claim or
- * failure state belonging to a newer revision. The control -> workspace ->
- * session lock prefix serializes this decision with Steer, Pause/Resume, and
- * claim without weakening physical-quiescence admission.
+ * failure state belonging to a newer revision. Therefore queued prompt work
+ * blocks acknowledgement only for the current coalesced revision: a stale
+ * acknowledgement still leaves the newer revision outstanding. The control ->
+ * workspace -> session lock prefix serializes this decision with Send, Steer,
+ * Pause/Resume, and claim without weakening physical-quiescence admission.
  */
 export type SessionWorkflowWakeDeliveryResult = {
     action: "acknowledged";
 } | {
     action: "pending_admission";
-    blocker: "pending_agent_steer" | "pending_quiescence";
+    blocker: "pending_agent_steer" | "pending_prompt_turn" | "pending_quiescence";
 };
 export declare function markSessionWorkflowWakeDelivered(db: Database, input: Omit<SessionWorkflowWake, "interruptionRequested">): Promise<SessionWorkflowWakeDeliveryResult>;
 /** Record delivery failure; the claim already scheduled the bounded retry. */
@@ -9364,6 +9813,7 @@ export declare function childRequiresActionResolutionExists(db: Database, worksp
 export declare function listOutstandingSessionSystemUpdates(db: Database, workspaceId: string, sessionId: string): Promise<SessionSystemUpdate[]>;
 /** Internal updates atomically attached when this inference was claimed. */
 export declare function listSessionSystemUpdatesForTurn(db: Database, workspaceId: string, sessionId: string, turnId: string): Promise<SessionSystemUpdate[]>;
+export declare function sessionEventRawLaneEnabled(value?: string | undefined): boolean;
 export declare function appendSessionEvents(db: Database, workspaceId: string, sessionId: string, inputs: AppendEventInput[]): Promise<SessionEvent[]>;
 export type AcceptSessionApprovalDecisionResult = {
     action: "accepted";
@@ -9417,17 +9867,34 @@ export declare function expireSessionInteractionIntervention(db: Database, input
  * events remain associated with their producer in logs but are not admitted to
  * the current durable timeline once the turn row moved generation or terminal.
  */
-export declare function appendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[]): Promise<{
+export declare function appendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[], observer?: SessionEventAppendObserver): Promise<{
     events: SessionEvent[];
     accepted: boolean;
     canonicalStartupMilestones: CanonicalTurnStartupMilestoneReceipt[];
 }>;
+export type SessionEventAppendClass = "raw" | "semantic" | "mixed";
+export type SessionEventAppendPhase = "transaction" | "mutation" | "turn_attempt_fence" | "idempotency" | "event_insert" | "projection" | "sequence_update";
+export type SessionEventAppendPhaseOutcome = "ok" | "rejected" | "mutation_skipped" | "projection_skipped" | "escalated" | "error";
+export type SessionEventAppendPhaseObservation = {
+    phase: SessionEventAppendPhase;
+    eventClass: SessionEventAppendClass;
+    eventCount: number;
+    outcome: SessionEventAppendPhaseOutcome;
+    durationSeconds: number;
+};
+export type SessionEventAppendObserver = {
+    onPhase?: (observation: SessionEventAppendPhaseObservation) => void;
+};
+export declare function sessionEventAppendClass(inputs: ReadonlyArray<{
+    type: string;
+}>): SessionEventAppendClass;
+export declare function observeSessionEventAppendPhase(observer: SessionEventAppendObserver | undefined, observation: SessionEventAppendPhaseObservation): void;
 /**
  * Commit one exact-attempt mutation and its timeline projection together. The
  * mutation runs first so Codemode's operation-row lock order remains stable;
  * returning false leaves both the mutation and projection absent.
  */
-export declare function mutateAndAppendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[], mutate: (tx: Database) => Promise<boolean>): Promise<{
+export declare function mutateAndAppendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[], mutate: (tx: Database) => Promise<boolean>, observer?: SessionEventAppendObserver): Promise<{
     events: SessionEvent[];
     accepted: boolean;
     mutationApplied: boolean;
@@ -9508,7 +9975,7 @@ export declare function buildCodexTokenResolver(db: Database, settings: Settings
 export declare function fetchCodexUsageForAccount(db: Database, settings: Settings, workspaceId: string, credentialId: string, fetchImpl?: CodexFetch): ReturnType<typeof fetchCodexUsageForAccountCore>;
 export declare function fetchCodexRateLimitResetCreditsForAccount(db: Database, settings: Settings, workspaceId: string, credentialId: string, fetchImpl?: CodexFetch): ReturnType<typeof fetchCodexRateLimitResetCreditsForAccountCore>;
 export declare function buildConnectionTokenResolver(db: Database, settings: Settings, deps?: ConnectionBrokerDeps, options?: ConnectionTokenResolverOptions): ReturnType<typeof buildConnectionTokenResolverCore>;
-export { withCodexTokenDeadline, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialForRun, type CodexCredentialTokens, type CodexRateLimitResetCreditsAccountResult, type CodexTokenDeadlineClock, type CodexTokenDeadlineOptions, } from "./codex-token-resolver.js";
+export { withCodexTokenDeadline, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialCooldownKind, type CodexCredentialForRun, type CodexCredentialTokens, type CodexRateLimitResetCreditsAccountResult, type CodexTokenDeadlineClock, type CodexTokenDeadlineOptions, } from "./codex-token-resolver.js";
 export { buildHostConnectionTokenResolver, ConnectionRefreshHttpError, HostMcpCredentialBindingError, HostMcpCredentialScopeError, isPrivateAddress, normalizeBearerScheme, refreshOAuthConnectionCredential, type ConnectionBrokerDeps, type ConnectionCredentialForBroker, type ConnectionCredentialLookupInput, type ConnectionStatusGuard, type ConnectionTokenRefreshInput, type ConnectionTokenResolverOptions, type HostMcpCredentialResolverContext, type PermanentConnectionRefreshFailure, type RefreshTransportOptions, type ResolveConnectionCredentialInput, type ResolveConnectionCredentialResult, } from "./connection-token-resolver.js";
 export { CapabilityComponentVersionConflictError, cleanupOrphanedCapabilityComponents, effectiveCapabilityOwnerSql, type CapabilityComponentOwnerIdentity, } from "./capability-components.js";
 export { adoptPackComponentReferences, finalizePackComponentOwnership, listPackInstallationComponents, PackComponentResolutionError, previewPackComponentRelease, recordPackInlineSkillComponent, releasePackComponents, resolvePackComponentReferences, resolvePackInlineSkillReferences, type PackInlineSkillRequirement, type StoredPackInstallationComponent, } from "./pack-components.js";