@opengeni/db 0.28.9 → 0.36.0

package/dist/index.d.ts

@@ -1,39 +1,55 @@
-import type { AccessContext, AccessGrant, AccessPrincipalKind, ApiKey, BillingBalance, CapabilityCatalogItem, CapabilityInstallation, CapabilityKind, CapabilityPack, CapabilitySource, ConnectionKind, ConnectionMetadata, ConnectionStatus, DocumentAuthorityKind, McpServerConnectionRef, FileAsset, FileUploadStatus, FirstPartyMcpToolName, HumanInputQuestion, HumanInputResponse, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemoryStatus, KnowledgeSourceRef, GitHubInstallationAuthorityKind, GitHubRepositoryScope, HostEventExportBatch, HostUsageExportBatch, ManagedAccount, McpPersonalConnectionDelegation, Permission, PackInstallation, PackInstallationStatus, ResourceRef, SandboxBackend, SandboxOs, ScheduledTask, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, Session, SessionAuthorizationListScope, SessionListResponse, SessionEvent, SessionEventPayloadMode, SessionEventReadDirection, SessionEventSemanticClass, SessionEventType, SessionGoal, SessionGoalCreatedBy, 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, WorkspaceRegisteredPack, Rig, RigVersion, RigChange, RigChangeKind, RigChangeStatus, RigCheck, NativeSnapshotDescriptor, TarWorkspaceArchiveDescriptor, WorkspaceArchiveDescriptor, ModalCheckpointProviderBinding } from "@opengeni/contracts";
+import { 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, Permission, PackInstallation, PackInstallationStatus, ResourceRef, SandboxBackend, SandboxOs, ScheduledTask, ScheduledTaskAction, ScheduledTaskActionKind, KnowledgeSourceSyncAction, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, 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, RigChange, RigChangeKind, RigChangeStatus, RigCheck, NativeSnapshotDescriptor, TarWorkspaceArchiveDescriptor, WorkspaceArchiveDescriptor, ModalCheckpointProviderBinding, SandboxProviderContinuityRecovery } from "@opengeni/contracts";
+import { RequestHumanInteractionToolInput, XaiProviderAccountAuthoritySnapshotV1, type TimelineAnnotation } from "@opengeni/contracts";
 import { type LatencyMode, SessionSystemUpdatePayload, TurnExecutionPolicyV1 } from "@opengeni/contracts";
 import { type Settings } from "@opengeni/config";
 import { type CodexFetch } from "@opengeni/codex";
 export { isCodexBilledModel } from "@opengeni/codex";
 import { type SQL } from "drizzle-orm";
-export { frozenInitiatorForCommandActor, type FrozenTurnInitiator } from "./turn-initiator";
-export { LOSSLESS_TEXT_PREFIX } from "./lossless-json";
-import { type SessionDiscoveryControl, type SessionCommandActor, type SessionTurnAttemptOutcome } from "./session-control";
-import { type SessionRealtimeContinuityEntry } from "./session-realtime-context";
-import * as schema from "./schema";
+export { frozenInitiatorForCommandActor, type FrozenTurnInitiator } from "./turn-initiator.js";
+export { LOSSLESS_TEXT_PREFIX } from "./lossless-json.js";
+import { type SessionDiscoveryControl, type SessionCommandActor, type SessionTurnAttemptOutcome } from "./session-control.js";
+import { type SessionRealtimeContinuityEntry } from "./session-realtime-context.js";
+import * as schema from "./schema.js";
 export { sql as dbSql } from "drizzle-orm";
-export * from "./session-control";
-export * from "./session-queue-commands";
-export * from "./session-realtime";
-export * from "./session-realtime-context";
-export * from "./session-realtime-ledger";
-export * from "./new-session-drafts";
-export * from "./workspace-instruction-policies";
-export * from "./preference-registry";
-export * from "./memory-governance";
-export * from "./scoped-knowledge";
-export { interruptedToolCallResult } from "./session-tool-call-settlement";
-export { decryptEnvironmentValue, encryptEnvironmentValue } from "./environment-crypto";
-export { decryptEnvironmentValue as decryptVariableSetValue, encryptEnvironmentValue as encryptVariableSetValue, } from "./environment-crypto";
-export * from "./persistence-errors";
-export * from "./runtime-posture";
-export * from "./insights";
-export { memoryTextForStorage } from "./memory-domain";
-export { migrate, runMigrations } from "./migrate";
-export { provisionRoles, type ProvisionResult, type ProvisionRolesOptions, } from "./provision-roles";
-export * from "./memory-domain";
-import { type Database } from "./database";
-export { createDb, registerDbBinding, rlsContextForWorkspace, rlsStrategyFor, setRlsContext, setSubjectRlsContext, withAccountRls, withDatabaseStatementTimeout, withRlsContext, withWorkspaceRls, withWorkspaceSubjectRls, withWorkspaceUsageLock, type CreateDbOptions, type Database, type DbClient, type RlsContext, type RlsStrategy, type UserLookup, } from "./database";
-import { buildCodexTokenResolver as buildCodexTokenResolverCore, fetchCodexRateLimitResetCreditsForAccount as fetchCodexRateLimitResetCreditsForAccountCore, fetchCodexUsageForAccount as fetchCodexUsageForAccountCore, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialForRun } from "./codex-token-resolver";
-import { buildConnectionTokenResolver as buildConnectionTokenResolverCore, type ConnectionBrokerDeps, type ConnectionCredentialForBroker, type ConnectionTokenResolverOptions } from "./connection-token-resolver";
+export * from "./session-control.js";
+export * from "./session-queue-commands.js";
+export * from "./session-realtime.js";
+export * from "./session-realtime-context.js";
+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 "./workspace-learning-policy.js";
+export * from "./slack-task-policy.js";
+export * from "./preference-registry.js";
+export * from "./memory-governance.js";
+export * from "./memory-slack-delivery.js";
+export * from "./scoped-knowledge.js";
+export * from "./knowledge-source-sync.js";
+export * from "./task-notes.js";
+export * from "./generated-images.js";
+export * from "./slack-user-link-access.js";
+export * from "./video-generation.js";
+export * from "./xai-subscription.js";
+export { interruptedToolCallResult } from "./session-tool-call-settlement.js";
+export { decryptEnvironmentValue, encryptEnvironmentValue } from "./environment-crypto.js";
+export { decryptEnvironmentValue as decryptVariableSetValue, encryptEnvironmentValue as encryptVariableSetValue, } from "./environment-crypto.js";
+export * from "./persistence-errors.js";
+export * from "./runtime-posture.js";
+export * from "./capability-integrations.js";
+export * from "./integration-bindings.js";
+export * from "./integration-facets.js";
+export * from "./insights.js";
+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";
+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 UserLookup, } 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 { 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 {
     readonly currentVersion: number;
@@ -235,6 +251,15 @@ export declare function ensureManagedAccessForUser(db: Database, input: {
     email: string;
     name: string;
 }): Promise<AccessContext>;
+export type ManagedAccessProvisioningResult = {
+    accessContext: AccessContext;
+    organizationMemberships: ManagedOrganizationMembershipProjection[];
+};
+export declare function ensureManagedAccessForUserWithOrganizationMemberships(db: Database, input: {
+    userId: string;
+    email: string;
+    name: string;
+}): Promise<ManagedAccessProvisioningResult>;
 export declare function getWorkspace(db: Database, workspaceId: string): Promise<Workspace | null>;
 export declare function getManagedAccount(db: Database, accountId: string): Promise<ManagedAccount | null>;
 export declare function requireWorkspace(db: Database, workspaceId: string): Promise<Workspace>;
@@ -287,6 +312,49 @@ export declare function removeWorkspaceMember(db: Database, workspaceId: string,
  */
 export declare function getManagedUserByEmail(db: Database, email: string): Promise<string | null>;
 export declare function deleteWorkspace(db: Database, workspaceId: string): Promise<void>;
+export type TemporalScheduleCleanupClaim = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    temporalScheduleId: string;
+    claimId: string;
+    attemptCount: number;
+};
+export type DeleteWorkspaceIfQuiescentResult = {
+    status: "deleted";
+    temporalScheduleCleanups: TemporalScheduleCleanupClaim[];
+} | {
+    status: "not_found" | "only_workspace" | "active_sessions" | "active_video_generations" | "live_sandboxes";
+};
+/**
+ * Atomically prove a workspace has no live runtime ownership and delete it.
+ *
+ * The account/workspace parent locks block concurrent child inserts through
+ * their foreign-key key-share locks. Existing session and lease rows are then
+ * locked before their state is inspected, so a cold lease cannot become live
+ * between a preflight count and the cascade. Schedule ids are copied under the
+ * same fence and returned for post-commit Temporal cleanup.
+ */
+export declare function deleteWorkspaceIfQuiescent(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+}): Promise<DeleteWorkspaceIfQuiescentResult>;
+/** Claim a bounded cross-workspace batch after abandoned claims expire. */
+export declare function claimTemporalScheduleCleanups(db: Database, input: {
+    claimId: string;
+    limit?: number;
+    claimSeconds?: number;
+}): Promise<TemporalScheduleCleanupClaim[]>;
+/**
+ * Settle only the exact claimed cleanup. A null error acknowledges the
+ * idempotent external deletion and removes the durable receipt; an error
+ * releases it with bounded exponential backoff.
+ */
+export declare function settleTemporalScheduleCleanup(db: Database, input: {
+    id: string;
+    claimId: string;
+    error?: string | null;
+}): Promise<boolean>;
 export declare function createApiKey(db: Database, input: {
     accountId: string;
     workspaceId?: string | null;
@@ -419,6 +487,8 @@ export type ModelCallFact = {
     reasoningTokens: number | null;
     totalTokens: number | null;
     pricedCostMicros: number;
+    estimatedProviderCostMicros: number | null;
+    pricingSource: "configured_list_price" | "gateway_reported" | null;
     occurredAt: Date;
     recordedAt: Date;
 };
@@ -438,6 +508,8 @@ export declare function recordModelCallFact(db: Database, input: {
     model: string;
     billingPath: ModelCallBillingPath;
     pricedCostMicros: number;
+    estimatedProviderCostMicros?: number | null;
+    pricingSource?: "configured_list_price" | "gateway_reported" | null;
     inputTokens?: number | null;
     outputTokens?: number | null;
     cachedTokens?: number | null;
@@ -534,11 +606,13 @@ export type CreateScheduledTaskInput = {
     temporalScheduleId: string;
     runMode: ScheduledTaskRunMode;
     overlapPolicy: ScheduledTaskOverlapPolicy;
+    action?: ScheduledTaskAction;
     agentConfig: ScheduledTaskAgentConfig;
     createdBy?: TurnInitiator;
     createdByContext?: TurnInitiatorContext;
     createdByActor?: AgentSessionCreationActor | null;
     personalConnectionDelegations?: McpPersonalConnectionDelegation[];
+    xaiProviderAccountAuthoritySnapshot?: XaiProviderAccountAuthoritySnapshotV1;
     targetSessionId?: string | null;
     variableSetId?: string | null;
     rigId?: string | null;
@@ -550,6 +624,7 @@ export type UpdateScheduledTaskInput = Partial<{
     schedule: ScheduledTaskScheduleSpec;
     runMode: ScheduledTaskRunMode;
     overlapPolicy: ScheduledTaskOverlapPolicy;
+    action: ScheduledTaskAction;
     agentConfig: ScheduledTaskAgentConfig;
     personalConnectionDelegations: McpPersonalConnectionDelegation[];
     reusableSessionId: string | null;
@@ -562,6 +637,11 @@ export type CreatePackInstallationInput = {
     accountId: string;
     workspaceId: string;
     packId: string;
+    status?: PackInstallationStatus;
+    manifestSnapshot?: CapabilityPack | null;
+    manifestDigest?: string | null;
+    selectedRigId?: string | null;
+    installedBySubjectId?: string | null;
     metadata?: Record<string, unknown>;
 };
 export type RegisterWorkspacePackInput = {
@@ -691,6 +771,14 @@ export type UpdateConnectionInput = {
     metadata?: Record<string, unknown>;
     updatedBySubjectId?: string | null;
 };
+export type PersistProviderOAuthConnectionInput = CreateConnectionInput & {
+    visibleToSubjectId: string;
+    credentialRole: string;
+    providerFamily: string;
+    providerPrincipalId: string;
+    requestedConnectionId?: string;
+    requestedConnectionVersion?: number;
+};
 export type UpdateSlackBotDocumentDestinationInput = {
     accountId: string;
     workspaceId: string;
@@ -744,9 +832,10 @@ export type SlackBotPostOperation = {
     targetKind: "channel" | "user";
     targetId: string;
     requestDigest: string;
-    status: "provider_started" | "completed";
+    status: "pending" | "provider_started" | "outcome_unknown" | "completed";
     claimHolderId: string | null;
     claimExpiresAt: Date | null;
+    claimMode: "send" | "reconcile" | null;
     attemptCount: number;
     lastFailureCode: string | null;
     slackChannelId: string | null;
@@ -755,6 +844,24 @@ export type SlackBotPostOperation = {
     createdAt: Date;
     updatedAt: Date;
 };
+export type SlackBotUpdateOperation = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    slackChannelId: string;
+    slackMessageTimestamp: string;
+    requestDigest: string;
+    status: "provider_started" | "completed";
+    claimHolderId: string | null;
+    claimExpiresAt: Date | null;
+    attemptCount: number;
+    lastFailureCode: string | null;
+    completedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+};
 export type SlackBotDeleteOperation = {
     id: string;
     accountId: string;
@@ -824,7 +931,7 @@ export type CreateCapabilityCatalogItemInput = {
     accountId: string;
     workspaceId: string;
     id: string;
-    kind: Exclude<CapabilityKind, "pack">;
+    kind: "mcp";
     source: CapabilitySource;
     name: string;
     description?: string | null;
@@ -899,10 +1006,122 @@ export type EnableCapabilityInstallationInput = {
     accountId: string;
     workspaceId: string;
     capabilityId: string;
-    kind: CapabilityKind;
+    kind: "mcp";
     config?: Record<string, unknown>;
     metadata?: Record<string, unknown>;
 };
+export type InstallPortableSkillInput = {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    capabilityId: string;
+    pluginKey: string;
+    source: "library" | "github" | "skills_sh" | "pack";
+    sourceUrl: string;
+    repositoryUrl: string;
+    version?: string;
+    sourceCommit: string;
+    sourcePath: string;
+    name: string;
+    description: string;
+    category?: string;
+    tags?: string[];
+    provenance?: "platform" | "deployment" | "registry" | "workspace";
+    sourceProvenance?: string;
+    contentSha256: string;
+    totalBytes: number;
+    license?: string | null;
+    files: Array<{
+        path: string;
+        content: string;
+        byteSize: number;
+        contentSha256: string;
+    }>;
+    owner?: PortableSkillOwner;
+    expectedInstallationVersion?: number;
+};
+export type InstalledPortableSkill = {
+    created: boolean;
+    capabilityId: string;
+    pluginId: string;
+    pluginVersionId: string;
+    facetId: string;
+    pluginInstallationId: string;
+    facetInstallationId: string;
+    installationVersion: number;
+    source: "library" | "github" | "skills_sh" | "pack";
+    version: string;
+    sourceUrl: string;
+    sourceCommit: string;
+    contentSha256: string;
+    name: string;
+};
+export type PortableSkillRuntime = {
+    capabilityId: string;
+    source: "library" | "github" | "skills_sh" | "pack";
+    version: string;
+    name: string;
+    description: string;
+    sourceUrl: string;
+    sourceCommit: string;
+    sourcePath: string;
+    contentSha256: string;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+};
+export type InstalledSkillSummary = {
+    capabilityId: string;
+    pluginKey: string;
+    installationVersion: number;
+    name: string;
+    description: string;
+    category: string;
+    tags: string[];
+    provenance: string;
+    source: "library" | "github" | "skills_sh" | "pack";
+    version: string;
+    sourceUrl: string;
+    repositoryUrl: string;
+    sourceCommit: string;
+    sourcePath: string;
+    contentSha256: string;
+    fileCount: number;
+    totalBytes: number;
+    license: string | null;
+    installedAt: string;
+    updatedAt: string;
+    owners: PortableSkillOwner[];
+};
+export type PortableSkillOwner = {
+    kind: "direct" | "plugin" | "pack" | "migration";
+    id: string;
+    removable: boolean;
+};
+export type PortableSkillUninstallPreview = {
+    capabilityId: string;
+    installed: boolean;
+    installationVersion: number | null;
+    directOwner: PortableSkillOwner | null;
+    remainingOwners: PortableSkillOwner[];
+    removesRuntimeSkill: boolean;
+};
+export type UninstallPortableSkillResult = {
+    capabilityId: string;
+    status: "not_installed" | "uninstalled" | "retained_by_other_owners";
+    remainingOwners: PortableSkillOwner[];
+};
+export declare class PortableSkillInstallationVersionConflictError extends Error {
+    readonly capabilityId: string;
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    readonly name = "PortableSkillInstallationVersionConflictError";
+    constructor(capabilityId: string, expectedVersion: number, actualVersion: number);
+}
+export declare class PortableSkillInstallationVersionRequiredError extends Error {
+    readonly name = "PortableSkillInstallationVersionRequiredError";
+}
 export type EnabledMcpCapabilityServer = {
     capabilityId: string;
     id: string;
@@ -911,6 +1130,7 @@ export type EnabledMcpCapabilityServer = {
     allowedTools?: string[];
     timeoutMs?: number;
     cacheToolsList?: boolean;
+    requireApproval?: SessionMcpApprovalPolicy;
     /**
      * Credential request headers stored encrypted at enable time
      * (AES-256-GCM under the workspace-variableSets key). Decrypted only at
@@ -972,6 +1192,7 @@ export type EnqueueSessionTurnInput = {
     initiator: TurnInitiator;
     initiatorContext?: TurnInitiatorContext;
     personalConnectionDelegations?: McpPersonalConnectionDelegation[];
+    xaiProviderAccountAuthoritySnapshot?: XaiProviderAccountAuthoritySnapshotV1;
     /** Steer inserts before all waiting prompts; Send appends after them. */
     placement?: "head" | "tail";
 };
@@ -982,6 +1203,10 @@ export type EnqueueSessionTurnInput = {
 export type SessionTurnForExecution = SessionTurn & {
     turnInstructions: string | null;
     personalConnectionDelegations: McpPersonalConnectionDelegation[];
+    /** Worker-only causal authority; never inferred from the current worker. */
+    initiatingHumanSubjectId: string | null;
+    xaiProviderAccountAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1;
+    goalSnapshot: SessionGoalSnapshot;
 };
 export declare function createFileUpload(db: Database, input: {
     accountId: string;
@@ -1000,12 +1225,36 @@ export declare function createFileUpload(db: Database, input: {
     uploadId: string;
     expiresAt: string;
 }>;
+export type PrepareGeneratedWorkspaceFileInput = {
+    accountId: string;
+    workspaceId: string;
+    fileId: string;
+    uploadId: string;
+    filename: string;
+    safeFilename: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string;
+    bucket: string;
+    objectKey: string;
+    expiresAt: Date;
+};
+/**
+ * Prepare one deterministic upload intent for a generated workspace file.
+ * Retries return the same pending/ready file only when every immutable byte and
+ * storage fact matches; identity reuse with different content fails closed.
+ */
+export declare function prepareGeneratedWorkspaceFile(db: Database, input: PrepareGeneratedWorkspaceFileInput): Promise<{
+    file: FileAsset;
+    uploadId: string;
+    created: boolean;
+}>;
 export declare function getFile(db: Database, workspaceId: string, fileId: string): Promise<FileAsset | null>;
 export declare function requireFile(db: Database, workspaceId: string, fileId: string): Promise<FileAsset>;
 /** One RLS-scoped query for all attachment metadata needed by a model turn. */
 export declare function getFiles(db: Database, workspaceId: string, fileIds: readonly string[]): Promise<FileAsset[]>;
 /** Build the canonical user row with stable attachment refs, never inline bytes. */
-export declare function durableUserHistoryItem(prompt: string, resources: readonly ResourceRef[]): Record<string, unknown>;
+export declare function durableUserHistoryItem(prompt: string, resources: readonly ResourceRef[], annotations?: readonly TimelineAnnotation[]): Record<string, unknown>;
 export type RetainedFileArtifact = {
     file: FileAsset;
     uploadStatus: FileUploadStatus | null;
@@ -1063,7 +1312,7 @@ export type PrepareRetainedScreenshotArtifactInput = {
     settlementKey: string;
     toolCallId: string;
     toolOutputId: string;
-    mediaType: "image/png";
+    mediaType: "image/png" | "image/jpeg" | "image/webp";
     sizeBytes: number;
     sha256: string;
     width: number;
@@ -1237,6 +1486,24 @@ export declare function markStaleRegistryCatalogItems(db: Database, activeKeys:
 export declare function upsertCapabilityCatalogItem(db: Database, input: CreateCapabilityCatalogItemInput): Promise<CapabilityCatalogItem>;
 export declare function listCapabilityCatalogItems(db: Database, workspaceId: string): Promise<CapabilityCatalogItem[]>;
 export declare function getCapabilityCatalogItem(db: Database, workspaceId: string, capabilityId: string): Promise<CapabilityCatalogItem | null>;
+/**
+ * Install one immutable, already-validated Skill through the authoritative
+ * Plugin/Skill-Facet ownership model. Repeating the same exact source is
+ * idempotent; changing a commit's content fails instead of silently rewriting
+ * immutable history.
+ */
+export declare function installPortableSkill(db: Database, input: InstallPortableSkillInput): Promise<InstalledPortableSkill>;
+/** Return exact text artifacts for active authoritative Skill installations. */
+export declare function listInstalledPortableSkills(db: Database, workspaceId: string): Promise<PortableSkillRuntime[]>;
+/** Return secret-free lifecycle summaries from the authoritative Skill ledger. */
+export declare function listInstalledSkills(db: Database, workspaceId: string): Promise<InstalledSkillSummary[]>;
+export declare function getPortableSkillUninstallPreview(db: Database, workspaceId: string, capabilityId: string): Promise<PortableSkillUninstallPreview>;
+export declare function uninstallPortableSkill(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    capabilityId: string;
+    expectedInstallationVersion: number;
+}): Promise<UninstallPortableSkillResult>;
 export declare function enableCapabilityInstallation(db: Database, input: EnableCapabilityInstallationInput): Promise<CapabilityInstallation>;
 export declare function disableCapabilityInstallation(db: Database, workspaceId: string, capabilityId: string): Promise<CapabilityInstallation>;
 export declare function listCapabilityInstallations(db: Database, workspaceId: string): Promise<CapabilityInstallation[]>;
@@ -1258,6 +1525,12 @@ 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>;
+/**
+ * Serialize one provider-principal/owner connection generation. Distinct OAuth
+ * starts for the same principal converge on one row, while an explicit
+ * reconnect remains fenced to the exact Connection version captured in state.
+ */
+export declare function persistProviderOAuthConnection(db: Database, input: PersistProviderOAuthConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
 export declare function listConnectionsMetadata(db: Database, workspaceId: string, subjectId?: string | null): Promise<ConnectionMetadataWithVerification[]>;
 export declare function getConnectionMetadata(db: Database, workspaceId: string, connectionId: string, subjectId?: string | null): Promise<ConnectionMetadataWithVerification | null>;
 export declare function updateConnection(db: Database, input: UpdateConnectionInput): Promise<ConnectionMetadataWithVerification | null>;
@@ -1290,6 +1563,14 @@ export type SlackInstallationRoute = {
     botId: string;
     botUserId: string;
 };
+export declare class SlackInstallationBindingConflictError extends Error {
+    readonly reason: "conflicting_workspace" | "conflicting_principal" | "legacy_quarantine" | "stale_reinstall";
+    constructor(reason: "conflicting_workspace" | "conflicting_principal" | "legacy_quarantine" | "stale_reinstall");
+}
+export declare function listSlackInstallationBindings(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+}): Promise<SlackInstallationBinding[]>;
 export type SlackBotUserLink = {
     id: string;
     accountId: string;
@@ -1302,7 +1583,7 @@ export type SlackBotUserLink = {
     createdAt: Date;
     updatedAt: Date;
 };
-export type SlackInteractionTriggerKind = "app_mention" | "dm" | "reaction" | "slash_command" | "message_shortcut" | "thread_reply";
+export type SlackInteractionTriggerKind = "app_mention" | "dm" | "reaction" | "slash_command" | "message_shortcut" | "thread_reply" | "block_action";
 export type SlackInteractionInboxEntry = {
     id: string;
     accountId: string;
@@ -1317,6 +1598,7 @@ export type SlackInteractionInboxEntry = {
     slackThreadTs: string | null;
     triggerKind: SlackInteractionTriggerKind;
     text: string;
+    hasFiles: boolean;
     status: "pending" | "processing" | "processed" | "failed";
     claimHolderId: string | null;
     claimExpiresAt: Date | null;
@@ -1338,6 +1620,7 @@ export type SlackInteraction = {
     slackThreadTs: string;
     routeKey: string;
     triggeringProviderEventId: string;
+    initiatingSlackUserId: string | null;
     owningSubjectId: string;
     visibility: "private" | "workspace";
     sessionReservationId: string;
@@ -1364,6 +1647,29 @@ export type SlackInteractionProgressDelivery = {
     operationId: string;
     createdAt: Date;
 };
+export type SlackInteractionActionKind = "approval_approve" | "approval_reject" | "human_input_select" | "human_input_skip" | "session_status" | "session_pause" | "session_resume" | "shared_result_publish";
+export type SlackInteractionActionHandle = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    interactionId: string;
+    sessionId: string;
+    sessionEventSequence: number;
+    actionKind: SlackInteractionActionKind;
+    actionKey: string;
+    targetId: string | null;
+    targetValue: string | null;
+    authorizedSubjectId: string;
+    authorizedSlackUserId: string;
+    messageOperationId: string;
+    status: "pending" | "completed" | "stale";
+    result: string | null;
+    expiresAt: Date;
+    completedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+};
 export declare function resolveSlackInstallationRoute(db: Database, slackTeamId: string): Promise<SlackInstallationRoute | null>;
 export declare function saveSlackBotUserLink(db: Database, input: Omit<SlackBotUserLink, "id" | "createdAt" | "updatedAt">): Promise<SlackBotUserLink>;
 export declare function getSlackBotUserLink(db: Database, workspaceId: string, connectionId: string, slackUserId: string): Promise<SlackBotUserLink | null>;
@@ -1390,11 +1696,42 @@ export declare function releaseSlackInteractionInbox(db: Database, input: {
     errorCode: string;
     retryAt: Date;
 }): Promise<boolean>;
-export declare function getOrCreateSlackInteraction(db: Database, input: Omit<SlackInteraction, "id" | "sessionReservationId" | "sessionId" | "lastDeliveredSessionEventSequence" | "deliveryClaimHolderId" | "deliveryClaimExpiresAt" | "deliveryAttemptCount" | "deliveryRetryAt" | "deliveryLastErrorCode" | "ackSlackMessageTs" | "progressCount" | "terminalDeliveryState" | "createdAt" | "updatedAt">): Promise<{
+export declare function getOrCreateSlackInteraction(db: Database, input: Omit<SlackInteraction, "id" | "initiatingSlackUserId" | "sessionReservationId" | "sessionId" | "lastDeliveredSessionEventSequence" | "deliveryClaimHolderId" | "deliveryClaimExpiresAt" | "deliveryAttemptCount" | "deliveryRetryAt" | "deliveryLastErrorCode" | "ackSlackMessageTs" | "progressCount" | "terminalDeliveryState" | "createdAt" | "updatedAt"> & {
+    initiatingSlackUserId?: string | null;
+}): Promise<{
     created: boolean;
     interaction: SlackInteraction;
 }>;
 export declare function getSlackInteractionByRoute(db: Database, workspaceId: string, connectionId: string, routeKey: string): Promise<SlackInteraction | null>;
+export declare function getSlackInteractionById(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    interactionId: string;
+}): Promise<SlackInteraction | null>;
+export declare function reserveSlackInteractionActionHandles(db: Database, input: {
+    interaction: Pick<SlackInteraction, "id" | "accountId" | "workspaceId" | "connectionId" | "sessionId" | "owningSubjectId" | "initiatingSlackUserId">;
+    sessionEventSequence: number;
+    messageOperationId: string;
+    expiresAt: Date;
+    actions: Array<{
+        actionKind: SlackInteractionActionKind;
+        actionKey: string;
+        targetId?: string | null;
+        targetValue?: string | null;
+    }>;
+}): Promise<SlackInteractionActionHandle[]>;
+export declare function getSlackInteractionActionHandle(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    handleId: string;
+}): Promise<SlackInteractionActionHandle | null>;
+export declare function settleSlackInteractionActionHandles(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    handleId: string;
+    result: string;
+    stale?: boolean;
+}): Promise<SlackInteractionActionHandle | null>;
 /**
  * Resolve an already-durable Slack task to its canonical interaction.
  *
@@ -1431,6 +1768,24 @@ export type SlackInteractionProgressClaim = {
 } | {
     kind: "not_owned";
 };
+export type SlackInteractionProgressDeliveryEvidence = {
+    sessionEventSequence: number;
+    operationId: string;
+    text: string;
+    turnId: string | null;
+};
+/**
+ * Read the at-most-three durable progress identities for terminal-delivery
+ * reconciliation. A reserved operation may still be provider-started after a
+ * response loss, so callers must retry the same operation id rather than
+ * inventing a second final post.
+ */
+export declare function listSlackInteractionProgressDeliveryEvidence(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    interactionId: string;
+    sessionId: string;
+}): Promise<SlackInteractionProgressDeliveryEvidence[]>;
 /**
  * Reserve one globally bounded progress slot before any Slack provider call.
  * The interaction row lock serializes replicas and expired delivery claim
@@ -1483,6 +1838,20 @@ type SlackBotLifecycleSuccessAuditInput = {
     credentialLabel: string;
     slackTeamId: string;
 };
+export type PersistSlackBotInstallationInput = SlackBotLifecycleSuccessAuditInput & {
+    requestedConnectionId?: string;
+    requestedConnectionVersion?: number;
+    credentialEncrypted: string;
+    grantedScopes: string[];
+    verifiedInstallAt: Date;
+    metadata: Record<string, unknown> & {
+        slackTeamId: string;
+        slackTeamName: string;
+        botId: string;
+        botUserId: string;
+    };
+};
+export declare function persistSlackBotInstallationWithSuccessAudit(db: Database, input: PersistSlackBotInstallationInput): Promise<ConnectionMetadataWithVerification>;
 export declare function createConnectionWithSlackBotSuccessAudit(db: Database, input: SlackBotLifecycleSuccessAuditInput & {
     connection: CreateConnectionInput;
 }): Promise<ConnectionMetadataWithVerification>;
@@ -1505,7 +1874,7 @@ export declare function recordSlackBotInstallCallbackFailure(db: Database, input
     reason: SlackBotInstallCallbackFailureReason;
 }): Promise<boolean>;
 export type ClaimSlackBotPostOperationResult = {
-    kind: "claimed" | "in_progress" | "completed";
+    kind: "claimed" | "reconcile" | "in_progress" | "completed";
     operation: SlackBotPostOperation;
 } | {
     kind: "conflict" | "connection_not_found";
@@ -1513,8 +1882,8 @@ export type ClaimSlackBotPostOperationResult = {
 /**
  * Claims one durable Slack post identity. The insert occurs before any provider
  * call; retries retain the original client_msg_id and immutable request digest.
- * A live claim suppresses concurrent sends, while a released/expired claim can
- * be reclaimed after response loss or process death.
+ * A live claim suppresses concurrent work. An expired provider_started claim is
+ * conservatively converted to outcome_unknown and may only be reconciled.
  */
 export declare function claimSlackBotPostOperation(db: Database, input: {
     accountId: string;
@@ -1527,12 +1896,20 @@ export declare function claimSlackBotPostOperation(db: Database, input: {
     claimHolderId: string;
     claimLeaseMs: number;
 }): Promise<ClaimSlackBotPostOperationResult>;
+export declare function markSlackBotPostOperationProviderStarted(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+}): Promise<boolean>;
 export declare function releaseSlackBotPostOperationClaim(db: Database, input: {
     accountId: string;
     workspaceId: string;
     connectionId: string;
     operationId: string;
     claimHolderId: string;
+    outcomeUnknown: boolean;
     failureCode: string;
 }): Promise<boolean>;
 export type CompleteSlackBotPostOperationResult = {
@@ -1555,6 +1932,40 @@ export declare function completeSlackBotPostOperation(db: Database, input: {
     auditMetadata: Record<string, unknown>;
 }): Promise<CompleteSlackBotPostOperationResult>;
 export declare function getSlackBotPostOperation(db: Database, workspaceId: string, connectionId: string, operationId: string): Promise<SlackBotPostOperation | null>;
+export type ClaimSlackBotUpdateOperationResult = {
+    kind: "claimed" | "in_progress" | "completed";
+    operation: SlackBotUpdateOperation;
+} | {
+    kind: "conflict" | "connection_not_found";
+};
+export declare function claimSlackBotUpdateOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    slackChannelId: string;
+    slackMessageTimestamp: string;
+    requestDigest: string;
+    claimHolderId: string;
+    claimLeaseMs: number;
+}): Promise<ClaimSlackBotUpdateOperationResult>;
+export declare function releaseSlackBotUpdateOperationClaim(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+    failureCode: string;
+}): Promise<boolean>;
+export declare function completeSlackBotUpdateOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+    subjectId?: string | null;
+    auditMetadata: Record<string, unknown>;
+}): Promise<"completed" | "not_found" | "not_owned">;
 export type ClaimSlackBotDeleteOperationResult = {
     kind: "claimed" | "reconcile" | "in_progress" | "completed";
     operation: SlackBotDeleteOperation;
@@ -1619,8 +2030,25 @@ export declare function loadConnectionCredentialForBroker(db: Database, settings
     allowSubjectOwned?: boolean;
 }): 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>;
 /** Resolve only the reviewed workspace-shared AI Gateway credential shape. */
 export declare function loadWorkspaceVercelAiGatewayApiKey(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
+ * accepted receipt commits, so a later workspace disconnect cannot strand a
+ * paid provider job. Never expose this return value from an API route.
+ */
+export declare function loadWorkspaceVercelAiGatewayCredentialLease(db: Database, settings: Settings, workspaceId: string): Promise<{
+    connectionId: string;
+    version: number;
+    credentialEncrypted: string;
+    apiKey: string;
+} | null>;
 export declare function recordConnectionTokenRefresh(db: Database, input: {
     id: string;
     version: number;
@@ -1697,6 +2125,8 @@ export type WorkspaceMemorySearchInput = {
     kind?: KnowledgeMemoryKind | undefined;
     limit?: number | undefined;
     mode?: WorkspaceMemorySearchMode | undefined;
+    /** Agent-only containment. Human audit/search callers omit this. */
+    agentPromptMode?: WorkspaceMemoryPromptMode | undefined;
 };
 export type WorkspaceMemorySearchResult = {
     memory: KnowledgeMemory;
@@ -1764,6 +2194,7 @@ export declare function createScheduledTask(db: Database, input: CreateScheduled
 export declare function updateScheduledTask(db: Database, workspaceId: string, taskId: string, input: UpdateScheduledTaskInput): Promise<ScheduledTask>;
 export declare function getScheduledTask(db: Database, workspaceId: string, taskId: string): Promise<ScheduledTask | null>;
 export declare function getScheduledTaskPersonalConnectionDelegations(db: Database, workspaceId: string, taskId: string): Promise<McpPersonalConnectionDelegation[]>;
+export declare function getScheduledTaskXaiProviderAccountAuthoritySnapshot(db: Database, workspaceId: string, taskId: string): Promise<XaiProviderAccountAuthoritySnapshotV1>;
 export declare function requireScheduledTask(db: Database, workspaceId: string, taskId: string): Promise<ScheduledTask>;
 export declare class ScheduledTaskTargetConflictError extends Error {
     constructor();
@@ -1780,6 +2211,14 @@ export declare function requireScheduledTaskTargetInTransaction(tx: Database, in
     targetSessionId: string;
 }): Promise<void>;
 export declare function listScheduledTasks(db: Database, workspaceId: string, limit?: number, offset?: number): Promise<ScheduledTask[]>;
+/**
+ * Internal connector-control traversal. Keep the whole keyset walk on one
+ * repeatable-read snapshot so task creation/update performed after discovery
+ * cannot make an older row move between offset pages or hide a matching task.
+ */
+export declare function listKnowledgeSourceSyncTasksForConnection(db: Database, workspaceId: string, connectionId: string, pageSize?: number): Promise<Array<ScheduledTask & {
+    action: KnowledgeSourceSyncAction;
+}>>;
 export declare function deleteScheduledTask(db: Database, workspaceId: string, taskId: string): Promise<void>;
 export declare function createScheduledTaskRun(db: Database, input: {
     workspaceId: string;
@@ -1796,6 +2235,10 @@ export declare function updateScheduledTaskRun(db: Database, workspaceId: string
     status: ScheduledTaskRunStatus;
     sessionId: string | null;
     triggerEventId: string | null;
+    actionKind: ScheduledTaskActionKind;
+    knowledgeSyncRunId: string | null;
+    knowledgeSummary: Record<string, unknown> | null;
+    completedAt: Date | null;
     error: string | null;
 }>): Promise<ScheduledTaskRun>;
 /** DB-only source mutation callback for durable scheduled delivery. */
@@ -1912,6 +2355,31 @@ export declare function deleteRigIfNoActiveSessions(db: Database, workspaceId: s
     deleted: boolean;
     activeSessionCount: number;
 }>;
+export declare class ChannelNameConflictError extends Error {
+    constructor(name: string);
+}
+export declare class ChannelNotFoundError extends Error {
+    constructor(channelId: string);
+}
+export declare function createChannel(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    description?: string | null;
+    createdBy?: string | null;
+}): Promise<Channel>;
+export declare function listChannels(db: Database, workspaceId: string): Promise<Channel[]>;
+export declare function getChannel(db: Database, workspaceId: string, channelId: string): Promise<Channel | null>;
+export declare function updateChannel(db: Database, workspaceId: string, channelId: string, input: {
+    name?: string | undefined;
+    description?: string | null | undefined;
+}): Promise<Channel | null>;
+export declare function deleteChannel(db: Database, workspaceId: string, channelId: string): Promise<boolean>;
+export declare function setSessionChannel(db: Database, input: {
+    workspaceId: string;
+    sessionId: string;
+    channelId: string | null;
+}): Promise<boolean>;
 export declare function countRigs(db: Database, workspaceId: string): Promise<number>;
 export declare function countSessionsUsingRig(db: Database, workspaceId: string, rigId: string): Promise<number>;
 export declare function createRigVersion(db: Database, workspaceId: string, rigId: string, input: RigVersionContentInput, options?: {
@@ -1919,6 +2387,7 @@ export declare function createRigVersion(db: Database, workspaceId: string, rigI
 }): Promise<RigVersion>;
 export declare function createRigVersionForChangePromotion(db: Database, workspaceId: string, rigId: string, changeId: string, input: RigVersionContentInput & {
     expectedActiveVersionId: string;
+    providerImages?: RigProviderImages;
 }): Promise<{
     version: RigVersion;
     change: RigChange;
@@ -1948,6 +2417,33 @@ export declare function listRigVersionMonitoringSummaries(db: Database, workspac
 }>;
 export declare function getRigVersion(db: Database, workspaceId: string, rigId: string, versionId: string): Promise<RigVersion | null>;
 export declare function getRigVersionById(db: Database, workspaceId: string, versionId: string): Promise<RigVersion | null>;
+export type RigProviderImageBuildClaim = {
+    status: "claimed";
+    image: RigProviderImage;
+} | {
+    status: "ready" | "in_progress" | "unsupported" | "conflict";
+    image: RigProviderImage;
+};
+/**
+ * Claim the one provider-image build slot for an existing immutable rig
+ * version. A finalized ready image is never overwritten in place: if the
+ * effective base/content identity changed, callers must mint/verify a new rig
+ * version and runtime setup remains the truthful fallback for this one.
+ */
+export declare function claimRigVersionProviderImageBuild(db: Database, input: {
+    workspaceId: string;
+    versionId: string;
+    image: RigProviderImage;
+    staleAfterMs: number;
+    /** Retry a same-content unsupported record only after runtime support exists. */
+    retryUnsupported?: boolean;
+}): Promise<RigProviderImageBuildClaim>;
+/** Finalize only the exact claimed build request; late callbacks are fenced. */
+export declare function finalizeRigVersionProviderImageBuild(db: Database, input: {
+    workspaceId: string;
+    versionId: string;
+    image: RigProviderImage;
+}): Promise<boolean>;
 export declare function getRigName(db: Database, workspaceId: string, rigId: string): Promise<string | null>;
 export declare function activateRigVersion(db: Database, workspaceId: string, rigId: string, versionId: string): Promise<RigVersion>;
 export declare function createRigChange(db: Database, input: {
@@ -2526,17 +3022,23 @@ export declare function armCodexCapacityWait(db: Database, input: {
     now?: Date;
 }): Promise<ArmCodexCapacityWaitResult>;
 export declare function getCodexCapacityWaitForSession(db: Database, workspaceId: string, sessionId: string): Promise<CodexCapacityWait | null>;
+type CodexCapacityMutationInput = {
+    workspaceId: string;
+    reason: string;
+    policyHash?: string | null;
+};
 /**
  * Same-transaction capacity-mutation/outbox seam for eligibility and
  * membership/default changes. The allocator rotation row is always the
  * first lock. Mutations report whether capacity truth changed; only then are
  * matching waiter wake revisions advanced and returned for best-effort signal.
  */
-export declare function withCodexCapacityMutation<T>(db: Database, input: {
-    workspaceId: string;
-    reason: string;
-    policyHash?: string | null;
-}, mutate: (tx: Database) => Promise<{
+export declare function withCodexCapacityMutation<T>(db: Database, input: CodexCapacityMutationInput, mutate: (tx: Database) => Promise<{
+    result: T;
+    changed: boolean;
+}>): Promise<CodexCapacityMutationResult<T>>;
+/** Capacity mutation whose atomic callback also changes session activity. */
+export declare function withSessionCodexCapacityMutation<T>(db: Database, input: CodexCapacityMutationInput, mutate: (tx: SessionActivityDatabase) => Promise<{
     result: T;
     changed: boolean;
 }>): Promise<CodexCapacityMutationResult<T>>;
@@ -2561,6 +3063,101 @@ export declare function reconcileCodexCapacityWait<TPolicyScope = never, TUnavai
     resolvePolicyScope?: CodexCredentialLeasePolicyScopeResolver<TPolicyScope>;
     filterNewAllocationCandidates?: CodexCredentialLeaseCandidateFilter<TPolicyScope, TUnavailableDiagnostic>;
 }): Promise<ReconcileCodexCapacityWaitResult>;
+export type XaiCapacityWait = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    goalId: string | null;
+    goalVersion: number | null;
+    blockedTurnId: string;
+    blockedTurnGeneration: number;
+    workflowId: string;
+    authorityScope: "workspace" | "user";
+    ownerOrganizationMembershipId: string | null;
+    status: CodexCapacityWaitStatus;
+    generation: number;
+    earliestResetAt: Date | null;
+    nextCheckAt: Date;
+    wakeRevision: number;
+    observedWakeRevision: number;
+    lastWakeReason: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type XaiCredentialLeaseQuarantine = {
+    kind: "status";
+    status: "needs_relogin" | "error";
+    lastError: string;
+} | {
+    kind: "cooldown";
+    until: Date;
+};
+export type ArmXaiCapacityWaitResult = {
+    action: "waiting";
+    waiter: XaiCapacityWait;
+    events: SessionEvent[];
+} | {
+    action: "stale";
+    waiter: XaiCapacityWait | null;
+    events: SessionEvent[];
+};
+export type ReconcileXaiCapacityWaitResult = {
+    action: "waiting";
+    waiter: XaiCapacityWait;
+    events: SessionEvent[];
+} | {
+    action: "resumed";
+    waiter: XaiCapacityWait;
+    events: SessionEvent[];
+} | {
+    action: "paused";
+    waiter: XaiCapacityWait;
+    events: SessionEvent[];
+} | {
+    action: "superseded";
+    waiter: XaiCapacityWait;
+    events: SessionEvent[];
+} | {
+    action: "stale";
+    waiter: XaiCapacityWait | null;
+    events: SessionEvent[];
+};
+/**
+ * Atomically close one exact xAI attempt and preserve its logical turn behind a
+ * durable provider-capacity waiter. The immutable authority snapshot and, for
+ * private pools, exact initiating human are revalidated under FORCE RLS before
+ * any session/turn projection changes.
+ */
+export declare function armXaiCapacityWait(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    workflowId: string;
+    authoritySnapshot: XaiProviderAccountAuthoritySnapshotV1;
+    goalId?: string | null;
+    goalVersion?: number | null;
+    earliestResetAt: Date | null;
+    failurePayload: Record<string, unknown>;
+    leaseFence?: {
+        holderId: string;
+        generation: number;
+    };
+    credentialQuarantine?: XaiCredentialLeaseQuarantine;
+    now?: Date;
+}): Promise<ArmXaiCapacityWaitResult>;
+export declare function getXaiCapacityWaitForSession(db: Database, workspaceId: string, sessionId: string): Promise<XaiCapacityWait | null>;
+export declare function reconcileXaiCapacityWait(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    waiterId: string;
+    generation: number;
+    now?: Date;
+}): Promise<ReconcileXaiCapacityWaitResult>;
 /**
  * Extend a live holder and return the database-confirmed expiry. A
  * missing/expired/released row returns null. A successful result lets the worker
@@ -2901,6 +3498,7 @@ export declare function getSessionCodexState(db: Database, workspaceId: string,
  * Validates the id belongs to the workspace when non-null. Returns false if the
  * session is unknown or the id is invalid.
  */
+export declare function setSessionCodexPinInTransaction(db: SessionActivityDatabase, workspaceId: string, sessionId: string, pinnedCredentialId: string | null, source?: CodexPinSource, options?: SetSessionCodexPinOptions): Promise<boolean>;
 export declare function setSessionCodexPin(db: Database, workspaceId: string, sessionId: string, pinnedCredentialId: string | null, source?: CodexPinSource, options?: SetSessionCodexPinOptions): Promise<boolean>;
 /** Written by the worker at the turn boundary; drives the in-session indicator. */
 export declare function recordSessionActiveCodexCredential(db: Database, workspaceId: string, sessionId: string, credentialId: string): Promise<void>;
@@ -2976,6 +3574,8 @@ export type ConnectorActionInvocation = {
     serverId: string;
     toolName: string;
     arguments: unknown;
+    /** Explicit per-session MCP approval, rather than a connector-policy decision. */
+    approvalMode?: "session_mcp";
 };
 export type PrepareConnectorActionApprovalResult = {
     managed: false;
@@ -3007,6 +3607,12 @@ type ResolvedConnectorActionPolicy = {
     managed: true;
     source: "explicit";
     entry: ConnectorActionPolicySnapshotEntry;
+} | {
+    managed: true;
+    source: "explicit";
+    entry: null;
+    decision: "ask";
+    actionName: string;
 } | {
     managed: true;
     source: "ambiguous";
@@ -3071,6 +3677,7 @@ export type SessionCreateInput = {
     variableSetId?: string | null;
     rigId?: string | null;
     rigVersionId?: string | null;
+    channelId?: string | null;
     firstPartyMcpPermissions?: Permission[] | null;
     firstPartyMcpTools?: FirstPartyMcpToolName[];
     instructions?: string | null;
@@ -3081,9 +3688,14 @@ export type SessionCreateInput = {
     sandboxOs?: SandboxOs;
     mcpServers?: CreateSessionMcpServerInput[];
     personalConnectionDelegations?: McpPersonalConnectionDelegation[];
+    initialXaiProviderAccountAuthoritySnapshot?: XaiProviderAccountAuthoritySnapshotV1;
     maxNestedAgentDepthOverride?: number | null;
     allowNestedAgentDepthIncrease?: boolean;
     subjectId?: string | null;
+    /** 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>;
 };
 export declare function createSession(db: Database, input: SessionCreateInput): Promise<DbSession>;
 /**
@@ -3109,8 +3721,17 @@ export declare function createSessionWithIdempotencyKey(db: Database, input: Ses
 }): Promise<SessionCreateSuccessResult>;
 export declare function getSessionByCreateIdempotencyKey(db: Database, workspaceId: string, createIdempotencyKey: string): Promise<Session | null>;
 export declare function getSession(db: Database, workspaceId: string, sessionId: string): Promise<Session | null>;
+export type SessionAuthorityProjection = {
+    sessionId: string;
+    rootSessionId: string;
+    visibility: "user_private" | "workspace_shared";
+    ownerSubjectId: string | null;
+};
+export declare function getSessionAuthorityProjection(db: Database, workspaceId: string, sessionId: string): Promise<SessionAuthorityProjection | null>;
+export declare function getSessionTurnXaiProviderAccountAuthoritySnapshot(db: Database, workspaceId: string, sessionId: string, turnId: string): Promise<XaiProviderAccountAuthoritySnapshotV1>;
 export declare function getSessionTurnPersonalConnectionDelegations(db: Database, workspaceId: string, sessionId: string, turnId: string): Promise<McpPersonalConnectionDelegation[]>;
 export declare function getSessionParentPersonalConnectionDelegations(db: Database, workspaceId: string, childSessionId: string): Promise<McpPersonalConnectionDelegation[]>;
+export declare function getSessionParentXaiProviderAccountAuthority(db: Database, workspaceId: string, childSessionId: string): Promise<FrozenXaiExecutionAuthority>;
 export declare function getSessionSpawnDenial(db: Database, workspaceId: string, denialId: string): Promise<SessionSpawnDenial | null>;
 export declare function getSessionSpawnDenialByIdempotencyKey(db: Database, workspaceId: string, createIdempotencyKey: string): Promise<SessionSpawnDenial | null>;
 export declare function listSessionSpawnDenials(db: Database, workspaceId: string, options?: {
@@ -3270,6 +3891,8 @@ export type SessionDiscoverySummary = {
     title: string | null;
     titleOriginalChars: number | null;
     parentSessionId: string | null;
+    rootSessionId: string;
+    nestedAgentDepth: number;
     status: SessionStatus;
     effectiveControl: SessionDiscoveryControl;
     goal: {
@@ -3302,6 +3925,9 @@ export declare function listSessionDiscoverySummaries(db: Database, workspaceId:
     includeLastMessage?: boolean;
     orderBy?: SessionDiscoveryOrderBy;
     updatedAfter?: string;
+    parentSessionId?: string | null;
+    search?: string;
+    subjectId?: string;
     authorizationScope?: SessionAuthorizationListScope;
 }): Promise<{
     sessions: SessionDiscoverySummary[];
@@ -3314,6 +3940,17 @@ export declare function listSessionDiscoverySummaries(db: Database, workspaceId:
     updatedThrough: string | null;
     updatedAfter: string | null;
 }>;
+export type SessionDiscoveryAncestor = {
+    id: string;
+    title: string | null;
+    titleOriginalChars: number | null;
+};
+/**
+ * Return bounded root-to-parent paths for a bounded discovery result page.
+ * Authorization is re-applied to every ancestor so exact-session grants never
+ * acquire parent metadata merely by searching for their target.
+ */
+export declare function listSessionDiscoveryAncestorPaths(db: Database, workspaceId: string, sessionIds: string[], authorizationScope?: SessionAuthorizationListScope): Promise<Map<string, SessionDiscoveryAncestor[]>>;
 export type SessionLineage = {
     ancestors: Session[];
     children: LineageNode[];
@@ -3394,49 +4031,6 @@ export declare function listSessionEventPage(db: Database, workspaceId: string,
 export declare function listSessionEvents(db: Database, workspaceId: string, sessionId: string): Promise<SessionEvent[]>;
 export declare function listSessionEvents(db: Database, workspaceId: string, sessionId: string, after: number, limit?: number): Promise<SessionEvent[]>;
 export declare function listSessionEvents(db: Database, workspaceId: string, sessionId: string, options: ListSessionEventsOptions): Promise<SessionEvent[]>;
-export type ToolspaceCallReservation = {
-    reserved: true;
-    count: number;
-    turn: SessionTurnForExecution;
-} | {
-    reserved: false;
-    reason: TurnAttemptFenceRejectReason | "budget_exhausted";
-};
-export type ToolspaceTurnAttemptClaims = {
-    sessionId: string;
-    turnId: string;
-    attemptId: string;
-    executionGeneration: number;
-};
-/**
- * Admit one exact Toolspace bearer before any session credential is decrypted or
- * any upstream schema is enumerated. This intentionally reuses the canonical
- * activity write fence so Pause/Steer, attempt replacement, generation changes,
- * and terminal settlement revoke a copied token at the same linearization point
- * as other attempt-owned writes.
- */
-export declare function admitToolspaceTurnAttempt(db: Database, workspaceId: string, claims: ToolspaceTurnAttemptClaims): Promise<boolean>;
-/**
- * Atomically reserve one toolspace call against a turn's per-turn budget.
- *
- * A single conditional UPDATE increments `toolspace_call_count` only while it is
- * below `limit` and returns the post-increment value. Concurrent reservations
- * for the same turn serialize on the row lock, so exactly `limit` of N
- * simultaneous callers observe `reserved: true` — closing the read-then-append
- * TOCTOU the event-count approach had. The returned attempt id is captured by
- * that same UPDATE, so callers cannot accidentally execute under a successor
- * attempt. `reserved: false` means the turn is not executable, at/over budget,
- * or no longer exists.
- */
-export declare function reserveToolspaceCallForAttempt(db: Database, input: {
-    accountId: string;
-    workspaceId: string;
-    sessionId: string;
-    turnId: string;
-    executionGeneration: number;
-    attemptId: string;
-    limit: number;
-}): Promise<ToolspaceCallReservation>;
 export declare function getSessionEvent(db: Database, workspaceId: string, eventId: string): Promise<SessionEvent | null>;
 export declare function listWorkspaceControlEvents(db: Database, workspaceId: string, after?: number, limit?: number): Promise<WorkspaceControlEvent[]>;
 export declare function getWorkspaceControlEvent(db: Database, workspaceId: string, eventId: string): Promise<WorkspaceControlEvent | null>;
@@ -3446,7 +4040,31 @@ export declare function getWorkspaceControlEvent(db: Database, workspaceId: stri
  * a session, while the workspace predicate remains the tenancy boundary.
  */
 export declare function getSessionEventByClientEventId(db: Database, workspaceId: string, sessionId: string, clientEventId: string): Promise<SessionEvent | null>;
-export declare function getLatestRunState(db: Database, workspaceId: string, sessionId: string): Promise<{
+export declare const APPROVAL_RUN_STATE_MAX_JSON_BYTES: number;
+export declare const APPROVAL_RUN_STATE_MAX_JSON_NODES = 65536;
+export declare const APPROVAL_RUN_STATE_MAX_JSON_PROPERTIES = 32768;
+export declare const APPROVAL_PENDING_MAX_JSON_BYTES: number;
+export declare const APPROVAL_PENDING_MAX_ITEMS = 256;
+export type ApprovalRunStateMaterializationLimits = {
+    maximumJsonBytes: number;
+    maximumJsonNodes: number;
+    maximumJsonProperties: number;
+    maximumPendingApprovalBytes: number;
+    maximumPendingApprovalItems: number;
+};
+export type ApprovalRunStateLimitKind = "json_bytes" | "json_nodes" | "json_properties" | "invalid_json" | "pending_approval_bytes" | "pending_approval_items";
+export declare class ApprovalRunStateLimitExceededError extends Error {
+    readonly limitKind: ApprovalRunStateLimitKind;
+    readonly actual: number;
+    readonly maximum: number;
+    readonly code = "approval_run_state_too_large";
+    constructor(limitKind: ApprovalRunStateLimitKind, actual: number, maximum: number);
+}
+/**
+ * Read the one approval/human-input RunState through a server-measured envelope.
+ * Ordinary turns never call this path; they use canonical history items only.
+ */
+export declare function getLatestRunState(db: Database, workspaceId: string, sessionId: string, limitOverrides?: Partial<ApprovalRunStateMaterializationLimits>): Promise<{
     id: string;
     turnId: string | null;
     serializedRunState: string;
@@ -3571,19 +4189,16 @@ export declare function registerPendingSessionToolCall(db: Database, input: Pend
     accepted: boolean;
     registered: boolean;
 }>;
-/**
- * Clear one completed Toolspace receipt after its attempt-fenced output event is
- * durable. If control already replaced the attempt, its settlement transaction
- * owns the receipt and will retain an explicit outcome-unknown or the durable
- * output event instead.
- */
-export declare function clearPendingSessionToolspaceCall(db: Database, input: Omit<PendingSessionToolCallInput, "callType" | "callItem">): Promise<{
-    accepted: boolean;
-    cleared: boolean;
-}>;
 /** Record the raw SDK result without dropping the call receipt. */
 export declare function recordPendingSessionToolCallResult(db: Database, input: Omit<PendingSessionToolCallInput, "callType" | "callItem"> & {
     resultItem: Record<string, unknown>;
+    /** Exact agent.toolCall.output value, separate from model-facing history. */
+    eventOutput?: unknown;
+    /** Commit a durable async-video acceptance fence with this exact result. */
+    videoGenerationAcceptance?: {
+        operationId: string;
+        requestDigest: string;
+    };
 }): Promise<{
     accepted: boolean;
     recorded: boolean;
@@ -3617,6 +4232,40 @@ export declare function getActiveSessionHistoryItems(db: Database, workspaceId:
     item: Record<string, unknown>;
     providerArtifactInvalidatedAt: Date | null;
 }>>;
+/**
+ * Profiled upper envelope for one session's complete active, model-facing
+ * transcript. Bytes alone do not bound the decoded object graph, so rows, JSON
+ * nodes, and object properties are independently limited. Normal token-driven
+ * compaction keeps active history far below these boundaries. The limits are a
+ * final materialization guard: a corrupt/imported/pathological transcript fails
+ * deterministically before a Postgres driver decodes it instead of using the
+ * pod OOM killer as admission.
+ */
+export declare const ACTIVE_SESSION_HISTORY_MAX_JSON_BYTES: number;
+export declare const ACTIVE_SESSION_HISTORY_MAX_ROWS = 8192;
+export declare const ACTIVE_SESSION_HISTORY_MAX_JSON_NODES = 131072;
+export declare const ACTIVE_SESSION_HISTORY_MAX_JSON_PROPERTIES = 65536;
+export type ActiveSessionHistoryLimitKind = "json_bytes" | "rows" | "json_nodes" | "json_properties";
+export declare class ActiveSessionHistoryLimitExceededError extends Error {
+    readonly actualBytes: number;
+    readonly maximumBytes: number;
+    readonly limitKind: ActiveSessionHistoryLimitKind;
+    readonly actual: number;
+    readonly maximum: number;
+    readonly code = "active_history_too_large";
+    constructor(actualBytes: number, maximumBytes: number, limitKind?: ActiveSessionHistoryLimitKind, actual?: number, maximum?: number);
+}
+/**
+ * Memory-bounded active-history read for model input and compaction. PostgreSQL
+ * first measures the complete logical window without returning any JSONB item,
+ * then keyset-pages the admitted rows on the same repeatable-read snapshot.
+ */
+export declare function getActiveSessionHistoryItemsPaged(db: Database, workspaceId: string, sessionId: string, pageSize?: number, maximumJsonBytes?: number, maximumRows?: number, maximumJsonNodes?: number, maximumJsonProperties?: number): Promise<Array<{
+    id: string;
+    position: number;
+    item: Record<string, unknown>;
+    providerArtifactInvalidatedAt: Date | null;
+}>>;
 /** Bounded finalized voice turns used only to resume a later realtime call. */
 export declare function getSessionRealtimeContinuityEntries(db: Database, workspaceId: string, sessionId: string, maximumEntries?: number): Promise<SessionRealtimeContinuityEntry[]>;
 /**
@@ -3979,7 +4628,7 @@ export declare function closePtySession(db: Database, input: {
 /** List a session's OPEN PTYs (reattach + reap). */
 export declare function listOpenPtySessions(db: Database, workspaceId: string, sessionId: string): Promise<SandboxOpenPtySessionRow[]>;
 export type SandboxLeaseLiveness = "cold" | "warming" | "warm" | "draining";
-export type LeaseHolderKind = "turn" | "viewer" | "direct" | "process";
+export type LeaseHolderKind = "turn" | "viewer" | "direct" | "process" | "interaction";
 export type SandboxProviderExistence = "not_created" | "creating" | "exists" | "missing" | "unknown";
 export type SandboxArchiveAvailability = "none" | "available" | "unverified" | "invalid";
 export type SandboxRestoreStatus = "not_required" | "pending" | "restoring" | "verifying" | "ready" | "degraded" | "unrecoverable";
@@ -4013,6 +4662,22 @@ export type SandboxRecoveryState = {
         verifiedRevision: string | null;
         verifiedAt: string | null;
     };
+    /** Provider-specific proof that an elected recovery owner may replace only
+     * the disposable execution wrapper while retaining the same workspace. */
+    continuity?: SandboxProviderContinuityRecovery;
+    /** A provider disappeared while a non-cancellable capture response could
+     * still settle. The cold lease retains this exact source/lineage receipt so a
+     * late verified archive can repair recovery without reopening the old box. */
+    lateArchiveCapture?: {
+        version: 1;
+        captureId: string;
+        providerRequestId: string;
+        sourceLeaseId: string;
+        sourceLeaseEpoch: number;
+        sourceInstanceId: string;
+        sourceWorkspaceGeneration: number;
+        recordedAt: string;
+    };
 };
 export interface LeaseSnapshot {
     id: string;
@@ -4028,6 +4693,9 @@ export interface LeaseSnapshot {
     rigVersionId: string | null;
     dataPlaneUrl: string | null;
     terminalDataPlaneUrl: string | null;
+    /** Cached browserd controller tunnel (7682), fenced to this lease epoch and
+     * provider instance. Null until the first controller provisioning/resolution. */
+    controllerDataPlaneUrl: string | null;
     leaseEpoch: number;
     /** Monotonic filesystem mutation intent for the exact live workspace. */
     workspaceGeneration: number;
@@ -4040,9 +4708,24 @@ export interface LeaseSnapshot {
     /** Exact provider capture currently holding the lease-local admission gate. */
     archiveCapture: {
         id: string;
+        operationId: string;
+        providerRequestId: string;
+        providerReplaySafe: boolean;
+        takeoverSafe: boolean;
+        attempt: number;
         workspaceGeneration: number;
         startedAt: Date;
         deadlineAt: Date;
+        /** Durable proof that this exact draining capture already published a
+         * verified current-generation archive. Null while capture is outstanding. */
+        publishedAt: Date | null;
+    } | null;
+    /** Bounded exact operator hold. Active holds stop reaper capture/teardown but
+     * deliberately do not stop a user from re-arming a resumable drain. */
+    reaperHold: {
+        id: string;
+        until: Date;
+        reason: string;
     } | null;
     resumeBackendId: string | null;
     resumeState: Record<string, unknown> | null;
@@ -4058,7 +4741,7 @@ export interface LeaseSnapshot {
     /** Once set, new holders and new filesystem mutations are fenced while the
      * current holders quiesce and the reaper creates a successor. */
     rotationRequestedAt: Date | null;
-    rotationReason: "provider_deadline" | "operator" | null;
+    rotationReason: "provider_deadline" | "operator" | "teardown_claim" | null;
     currentCheckpointArtifactId: string | null;
     previousCheckpointArtifactId: string | null;
     expiresAt: Date;
@@ -4085,8 +4768,13 @@ export interface AcquireLeaseInput {
     warmingLeaseTtlMs?: number;
     expectedEpoch?: number;
     /** Bounded wait for an exact provider-native capture claim to settle. The
-     * transaction is released between retries; every retry re-reads the lease. */
+     * transaction is released between retries; every retry re-reads the lease.
+     * The same wait also covers a requested provider rotation. The legacy field
+     * name is retained at the API boundary so rolling workers remain compatible. */
     captureWaitMs?: number;
+    /** Optional owner cancellation for the transition wait. No holder exists
+     * while a capture/rotation fence is observed, so cancellation is leak-free. */
+    waitSignal?: AbortSignal;
 }
 export type AcquireLeaseResult = {
     role: "spawner";
@@ -4103,12 +4791,32 @@ export type AcquireLeaseResult = {
     lease: LeaseSnapshot;
 } | {
     role: "fenced";
+    reason: "superseded" | "capture_in_progress" | "rotation_in_progress" | "provider_recovery_in_progress";
     lease: LeaseSnapshot;
 };
 export declare class SandboxLeaseSupersededError extends Error {
     readonly sandboxGroupId: string;
     readonly leaseEpoch: number;
-    constructor(sandboxGroupId: string, leaseEpoch: number);
+    readonly diagnostic?: {
+        backend: string;
+        instanceId: string | null;
+        liveness: SandboxLeaseLiveness;
+    } | undefined;
+    constructor(sandboxGroupId: string, leaseEpoch: number, diagnostic?: {
+        backend: string;
+        instanceId: string | null;
+        liveness: SandboxLeaseLiveness;
+    } | undefined);
+}
+export declare class SandboxLeaseTransitionError extends Error {
+    readonly sandboxGroupId: string;
+    readonly leaseEpoch: number;
+    readonly reason: "capture_in_progress" | "rotation_in_progress" | "provider_recovery_in_progress";
+    readonly backend: string;
+    readonly instanceId: string | null;
+    readonly liveness: SandboxLeaseLiveness;
+    readonly name = "SandboxLeaseTransitionError";
+    constructor(sandboxGroupId: string, leaseEpoch: number, reason: "capture_in_progress" | "rotation_in_progress" | "provider_recovery_in_progress", backend: string, instanceId: string | null, liveness: SandboxLeaseLiveness);
 }
 export type SandboxViewerForceDrainReason = "balance" | "warm_cap";
 export declare class SandboxViewerAdmissionBlockedError extends Error {
@@ -4201,6 +4909,7 @@ export declare function failSandboxRematerialization(db: Database, input: {
     rematerializationId: string;
     failureCode: string;
     retryable: boolean;
+    discardContinuity?: boolean;
 }): Promise<{
     failed: boolean;
     lease: LeaseSnapshot | null;
@@ -4231,11 +4940,14 @@ export declare function commitWarmingToWarm(db: Database, input: {
         id: string;
         verifiedRevision: string;
     };
+    /** Exact durable same-workspace receipt returned by the elected provider
+     * continuity recovery. Mutually exclusive with archive hydration. */
+    continuityRecovery?: SandboxProviderContinuityRecovery;
     leaseTtlMs: number;
 }): Promise<{
     committed: boolean;
     lease: LeaseSnapshot | null;
-    reason?: "stale_epoch" | "rematerialization_required" | "rematerialization_mismatch" | "archive_revision_mismatch" | "archive_generation_mismatch";
+    reason?: "stale_epoch" | "rematerialization_required" | "rematerialization_mismatch" | "recovery_mode_conflict" | "continuity_mismatch" | "archive_revision_mismatch" | "archive_generation_mismatch";
 }>;
 export declare function recordWarmingSandboxCreated(db: Database, input: {
     accountId: string;
@@ -4246,6 +4958,7 @@ export declare function recordWarmingSandboxCreated(db: Database, input: {
      *  archive-less create. Provider attribution is accepted only while the
      *  warming row still carries this same attempt as well as this epoch. */
     rematerializationId?: string | null;
+    continuityRecovery?: SandboxProviderContinuityRecovery;
     instanceId: string;
     resumeBackendId?: string | null;
     resumeState?: Record<string, unknown> | null;
@@ -4643,6 +5356,7 @@ export declare function failWarmingToCold(db: Database, input: {
     workspaceId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
+    discardContinuity?: boolean;
 }): Promise<void>;
 export declare function releaseLeaseHolder(db: Database, input: {
     accountId: string;
@@ -4651,6 +5365,11 @@ export declare function releaseLeaseHolder(db: Database, input: {
     kind: LeaseHolderKind;
     holderId: string;
     idleGraceMs: number;
+    /** The caller has crossed the non-detachable physical boundary for this
+     * exact turn holder: every admitted attempt-owned workspace writer has
+     * resolved, rejected, or been physically quiesced. A cancellation listener
+     * that merely prevents a holder leak must leave this false. */
+    workspaceWritersQuiesced?: boolean;
 }): Promise<{
     liveness: SandboxLeaseLiveness;
     refcount: number;
@@ -4694,11 +5413,16 @@ export declare function reapStaleLeaseHolders(db: Database, input: {
      *  10s turn heartbeat, so only a DEAD worker's holder ever crosses it). 0/absent
      *  = legacy never-reap. */
     turnHolderTtlMs?: number;
+    /** Delete placement-controller holders after their BrowserSession or
+     *  ComputerSession heartbeat dies. Active controllers refresh both the
+     *  resource and holder in one API heartbeat; zero disables only for tests. */
+    interactionHolderTtlMs?: number;
     idleGraceMs: number;
 }): Promise<{
     reapedViewers: number;
     reapedDirect: number;
     reapedTurns: number;
+    reapedInteractions: number;
     warmingReset: number;
     drained: ReapDrainable[];
 }>;
@@ -4707,6 +5431,7 @@ export declare function reapStaleLeaseHoldersGlobal(db: Database, input: {
     /** Reap DEAD-WORKER turn holders staler than this (the lease TTL; see
      *  reapStaleLeaseHolders). 0/absent = never (legacy). */
     turnHolderTtlMs?: number;
+    interactionHolderTtlMs?: number;
     idleGraceMs: number;
 }): Promise<ReapDrainable[]>;
 export interface MeterableWarmLease {
@@ -4741,6 +5466,9 @@ export declare function confirmDrainCold(db: Database, input: {
     workspaceId: string;
     sandboxGroupId: string;
     expectedEpoch: number;
+    /** Exact durable teardown ownership. Omission asserts that no claim exists;
+     *  a replaced, newly installed, or expired claim always fences this commit. */
+    expectedCaptureId?: string;
     /** Definitive provider NotFound before this drain could capture /workspace.
      *  With no durable archive this must become typed unrecoverable, never a
      *  clean cold lease that can expose an empty replacement. */
@@ -4869,6 +5597,8 @@ export declare function advanceWorkspaceGeneration(db: Database, input: {
     /** Wait before provider admission while an exact archive capture owns this
      * lease. The attempt/route fences are re-read on every bounded retry. */
     captureWaitMs?: number;
+    /** Cancel the bounded transition wait without creating an admission. */
+    waitSignal?: AbortSignal;
     /** Active-routed mutations bind to the exact session pointer. Omitted means
      * an intentional home-provider write outside the routing surface. */
     routeKind?: "home" | "active";
@@ -4891,6 +5621,7 @@ export declare function advanceWorkspaceGenerationForDirectRequest(db: Database,
     routeEpoch: number;
     operation: string;
     captureWaitMs?: number;
+    waitSignal?: AbortSignal;
 }): Promise<SandboxWorkspaceMutationAdmission>;
 /** Admit one model/user-visible stdin write for an exact retained process. The
  * process's original provider and route are authoritative even if the session's
@@ -4902,6 +5633,7 @@ export declare function advanceWorkspaceGenerationForRetainedProcess(db: Databas
     processId: string;
     operation: string;
     captureWaitMs?: number;
+    waitSignal?: AbortSignal;
 }): Promise<SandboxWorkspaceMutationAdmission>;
 /** Physically settle one exact provider mutation admission after its promise
  * resolves or rejects. Rejections need no output acceptance, but still clear
@@ -5086,8 +5818,58 @@ export declare function readWorkspaceArchiveCapturePreflight(db: Database, input
     archiveGeneration: number | null;
     archiveComplete: boolean;
 } | null>;
+export declare const SANDBOX_REAPER_HOLD_MAX_TTL_MS: number;
+/** Read the exact operator-hold target without exposing it across an
+ * account/workspace mismatch. The operator CLI projects only non-secret fields
+ * from this snapshot; resumeState remains an internal DB contract. */
+export declare function readSandboxLeaseReaperHoldTarget(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+}): Promise<LeaseSnapshot | null>;
+export type SandboxLeaseReaperHoldResult = {
+    status: "held";
+    renewed: boolean;
+    lease: LeaseSnapshot;
+} | {
+    status: "lease_fenced" | "not_live" | "held_by_other" | "teardown_in_progress" | "rotation_in_progress" | "provider_deadline_conflict" | "reason_conflict";
+    lease: LeaseSnapshot | null;
+};
+/**
+ * Install or renew a bounded operator preservation gate on one exact physical
+ * lease. The row lock serializes this decision with reaper claim acquisition.
+ * A hold never creates/resumes a provider and never overrides teardown already
+ * issued: callers must receive a positive receipt before relying on it.
+ */
+export declare function acquireSandboxLeaseReaperHold(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    holdId: string;
+    ttlMs: number;
+    /** Preserve this much configured rotation headroom after the hold expires.
+     *  Callers should pass the deployment's sandboxRotationLeadMs. */
+    providerDeadlineHeadroomMs: number;
+    reason: string;
+}): Promise<SandboxLeaseReaperHoldResult>;
+/** Release only the exact operator receipt on the exact physical lease. */
+export declare function releaseSandboxLeaseReaperHold(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    holdId: string;
+}): Promise<boolean>;
 export type WorkspaceArchiveCaptureClaim = {
     id: string;
+    operationId: string;
+    providerRequestId: string;
+    providerReplaySafe: boolean;
+    takeoverSafe: boolean;
+    attempt: number;
     leaseId: string;
     leaseEpoch: number;
     instanceId: string;
@@ -5096,13 +5878,29 @@ export type WorkspaceArchiveCaptureClaim = {
     archiveComplete: boolean;
     startedAt: Date;
     deadlineAt: Date;
+    /** Non-null only after a verified drain archive was atomically published
+     * under this exact capture. Such a claim may finish teardown, never recapture
+     * or release/re-arm. */
+    publishedAt: Date | null;
 };
+/** Read the authoritative takeover clock for one exact unpublished capture.
+ * Provider recovery must never compare a Postgres deadline with an application
+ * wall clock: clock skew could otherwise fence a still-accepted provider
+ * request early. The eventual replacement remains a separate exact CAS. */
+export declare function workspaceArchiveCaptureDeadlineElapsed(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    captureId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+}): Promise<boolean>;
 export type ClaimWorkspaceArchiveCaptureResult = {
     status: "claimed";
     claim: WorkspaceArchiveCaptureClaim;
     lease: LeaseSnapshot;
 } | {
-    status: "lease_fenced" | "attempt_fenced" | "capture_in_progress" | "holder_in_progress" | "mutation_in_progress" | "throttled";
+    status: "lease_fenced" | "attempt_fenced" | "reaper_held" | "capture_in_progress" | "holder_in_progress" | "mutation_in_progress" | "throttled";
 };
 /**
  * Atomically reserve one live provider for archive capture. Modal pauses a box
@@ -5115,11 +5913,19 @@ export declare function claimWorkspaceArchiveCapture(db: Database, input: {
     workspaceId: string;
     sandboxGroupId: string;
     captureId: string;
+    /** Stable logical request across retries. Old callers default to the exact
+     * capture id and are normalized the same way by migration 0184's trigger. */
+    operationId?: string;
+    attempt?: number;
     expectedEpoch: number;
     expectedInstanceId: string;
     liveness: "warm" | "draining";
     captureTimeoutMs: number;
     minIntervalMs: number;
+    /** Explicit provider-registry proof. Optional false defaults preserve safe
+     * rolling behavior for pre-policy callers. */
+    providerReplaySafe?: boolean;
+    takeoverSafe?: boolean;
     warmAttempt?: {
         sessionId: string;
         turnId: string;
@@ -5138,17 +5944,21 @@ export declare function releaseWorkspaceArchiveCapture(db: Database, input: {
     expectedInstanceId: string;
 }): Promise<boolean>;
 /**
- * Replace an expired capture claim without ever opening the admission gate.
- * This is reserved for the zero-holder drain reaper after it has independently
- * proved the exact provider is command-ready (and therefore no longer paused by
- * the dead owner's capture). The old claim remains authoritative on every miss.
+ * Replace a capture attempt without ever opening the admission gate. A generic
+ * provider remains deadline-gated. A provider registration explicitly recorded
+ * as takeover-safe may retry immediately, using either same-request idempotency
+ * or an independently repeatable read-only capture.
+ * captureId changes to fence teardown ownership; providerRequestId deliberately
+ * does not, so a predecessor success remains adoptable by its successor.
  */
-export declare function replaceExpiredWorkspaceArchiveCapture(db: Database, input: {
+export declare function replaceWorkspaceArchiveCaptureAfterProof(db: Database, input: {
     accountId: string;
     workspaceId: string;
     sandboxGroupId: string;
     priorCaptureId: string;
     captureId: string;
+    operationId: string;
+    attempt: number;
     expectedEpoch: number;
     expectedInstanceId: string;
     captureTimeoutMs: number;
@@ -5179,6 +5989,15 @@ export declare function registerSandboxCheckpointArtifact(db: Database, input: {
     providerBinding: Record<string, unknown>;
     workspaceArchive: string;
     workspaceArchiveMeta: SandboxArchiveRevision;
+    /**
+     * Workspace checkpoints are identified by their exact capture source.
+     * Provider-image builds instead use a provider-owned idempotency key: a
+     * retry may run from a successor verifier lease but must converge on the
+     * same exact immutable object. The first source remains immutable
+     * provenance; only a byte-identical object in the same tenant/group may be
+     * reused.
+     */
+    registrationIdentity?: "capture" | "provider_object";
 }): Promise<SandboxCheckpointArtifactRegistration>;
 /** Hand an unpublished candidate to asynchronous GC. Referenced artifacts are
  * protected both here and by the global claim function. */
@@ -5254,10 +6073,14 @@ export declare function persistDrainSnapshot(db: Database, input: {
     accountId: string;
     workspaceId: string;
     sandboxGroupId: string;
+    /** Exact source lease identity. Required for cold late-result adoption. */
+    expectedLeaseId?: string;
     expectedEpoch: number;
     expectedInstanceId: string;
     expectedWorkspaceGeneration: number;
     captureId: string;
+    /** Stable provider-operation lineage across atomic claim replacements. */
+    providerRequestId?: string;
 } & ({
     /** Null performs only the epoch/instance/generation CAS check. */
     workspaceArchive: null;
@@ -5496,6 +6319,17 @@ export declare function recordLeaseTerminalDataPlaneUrl(db: Database, input: {
     expectedEpoch: number;
     terminalDataPlaneUrl: string | null;
 }): Promise<LeaseSnapshot | null>;
+/** Record the browserd controller tunnel for one exact warm provider instance.
+ * Unlike desktop/terminal viewer URLs, this endpoint is an internal transport
+ * cache: controller bearer tokens still enforce per-resource authority. */
+export declare function recordLeaseControllerDataPlaneUrl(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedEpoch: number;
+    expectedInstanceId: string;
+    controllerDataPlaneUrl: string | null;
+}): Promise<LeaseSnapshot | null>;
 export type SandboxKind = (typeof schema.sandboxKindValues)[number];
 export type EnrollmentExposure = (typeof schema.enrollmentExposureValues)[number];
 export type EnrollmentStatus = (typeof schema.enrollmentStatusValues)[number];
@@ -5552,7 +6386,7 @@ export declare function listEnrollments(db: Database, workspaceId: string, optio
     status?: EnrollmentStatus;
 }): Promise<EnrollmentRecord[]>;
 export type MachineRemovalOutcome = (typeof schema.machineRemovalOperationOutcomeValues)[number];
-export type MachineRemovalBlockCode = "active_route" | "active_commands" | "active_lease" | "recovery_pending" | "not_selfhosted";
+export type MachineRemovalBlockCode = "active_route" | "active_commands" | "machine_home" | "active_lease" | "recovery_pending" | "not_selfhosted";
 export type MachineRemovalResult = {
     enrollmentId: string;
     outcome: MachineRemovalOutcome;
@@ -5563,6 +6397,10 @@ export type MachineRemovalResult = {
     code: MachineRemovalBlockCode | null;
     message: string;
     action: string;
+    dependentSessions: Array<{
+        id: string;
+        title: string | null;
+    }>;
 };
 export declare class MachineRemovalIdempotencyError extends Error {
     readonly name = "MachineRemovalIdempotencyError";
@@ -5573,11 +6411,12 @@ export declare class MachineRemovalRevisionConflictError extends Error {
     constructor(message: string, currentUpdatedAt: string);
 }
 /**
- * Remove one connected-machine enrollment without touching the durable identity
- * or any session/route/archive evidence. The enrollment row is the lifecycle
- * truth: status -> revoked rejects future auth-callout/heartbeat/reconnect
- * attempts, while a fresh device-flow re-enrollment can reactivate the same
- * public-key identity with a new credential family.
+ * Remove one connected-machine enrollment without deleting durable identity,
+ * conversation, or audit evidence. Idle sessions using the machine are detached
+ * to `none`; active work and recovery fences still block removal. The enrollment
+ * row is the lifecycle truth: status -> revoked rejects future auth-callout/
+ * heartbeat/reconnect attempts, while a fresh device-flow re-enrollment can
+ * reactivate the same public-key identity with a new credential family.
  *
  * The operation key is scoped to the workspace and is receipt-backed. A retry
  * with the same key and request fingerprint replays the exact committed result;
@@ -5942,6 +6781,12 @@ export type CreateSessionGoalInput = {
     text: string;
     successCriteria?: string | null;
     maxAutoContinuations?: number | null;
+    mutationPolicy?: SessionGoalMutationPolicy;
+    expectedObjectiveRevision?: number;
+    expectedGoalId?: string;
+    changeKind?: SessionGoalChangeKind;
+    changeRationale?: string;
+    sourceProposalId?: string;
     createdBy: SessionGoalCreatedBy;
 };
 export declare function createSessionGoal(db: Database, input: CreateSessionGoalInput): Promise<SessionGoal>;
@@ -5989,15 +6834,21 @@ export declare function upsertSessionGoalWithEvent(db: Database, input: CreateSe
 }): Promise<{
     goal: SessionGoal;
     replaced: boolean;
+    workflowWakeRevision: number | null;
     events: SessionEvent[];
 }>;
+export declare function listSessionGoalRevisions(db: Database, workspaceId: string, sessionId: string): Promise<SessionGoalRevision[]>;
+export declare function getSessionGoalRevision(db: Database, workspaceId: string, sessionId: string, revisionId: string): Promise<SessionGoalRevision | null>;
 /**
- * goal_update semantics: revise text/criteria without changing status. The
- * version bump counts as progress for the no-progress detector.
+ * Low-level semantic goal revision. The established lifecycle version still
+ * advances so stale continuation updates are cancelled, while the migration
+ * trigger advances the separate objective revision. A semantic rewrite is not
+ * execution progress and therefore never resets the no-progress streak.
  */
 export declare function updateSessionGoal(db: Database, workspaceId: string, sessionId: string, input: {
     text?: string;
     successCriteria?: string | null;
+    mutationPolicy?: SessionGoalMutationPolicy;
 }): Promise<SessionGoal>;
 /**
  * Agent goal_update: session sequence ownership, goal mutation, and its audit
@@ -6008,7 +6859,12 @@ export declare function updateSessionGoal(db: Database, workspaceId: string, ses
 export declare function updateSessionGoalWithEvent(db: Database, workspaceId: string, sessionId: string, input: {
     text?: string;
     successCriteria?: string | null;
+    mutationPolicy?: SessionGoalMutationPolicy;
+    /** @deprecated A semantic rewrite never counts as progress; use goal_progress. */
     progressNote?: string;
+    changeKind?: SessionGoalChangeKind;
+    rationale?: string;
+    expectedObjectiveRevision?: number;
     actor: "agent" | "api";
     command?: {
         accountId: string;
@@ -6022,6 +6878,28 @@ export declare function updateSessionGoalWithEvent(db: Database, workspaceId: st
     events: SessionEvent[];
     operationId: string | null;
     replay: boolean;
+    outcome: "applied" | "proposed";
+    proposalId: string | null;
+}>;
+/**
+ * Record execution progress without changing goal semantics or either goal
+ * revision. The attempt-fenced operation receipt makes a recovered tool call
+ * converge on the original event instead of manufacturing progress twice.
+ */
+export declare function recordSessionGoalProgressWithEvent(db: Database, workspaceId: string, sessionId: string, input: {
+    progressNote: string;
+    command: {
+        accountId: string;
+        actor: Extract<SessionCommandActor, {
+            type: "agent_attempt";
+        }>;
+        operationKey: string;
+    };
+}): Promise<{
+    goal: SessionGoal;
+    events: SessionEvent[];
+    operationId: string;
+    replay: boolean;
 }>;
 /**
  * Sets a session's display title. The clobber guard lives entirely in this
@@ -6168,6 +7046,7 @@ export type InitializeSessionStartInput = {
         text: string;
         successCriteria?: string | null;
         maxAutoContinuations?: number | null;
+        mutationPolicy?: SessionGoalMutationPolicy;
     } | null;
     consumeNewSessionDraft?: {
         subjectId: string;
@@ -6202,6 +7081,10 @@ export type SessionWorkTrigger = {
 export declare const MAX_INTERNAL_UPDATE_BYTES: number;
 export declare const MAX_INTERNAL_UPDATE_BATCH_MEMBERS = 100;
 export declare const MAX_INTERNAL_UPDATE_BATCH_BYTES: number;
+export type FrozenXaiExecutionAuthority = {
+    snapshot: XaiProviderAccountAuthoritySnapshotV1;
+    subjectId: string | null;
+};
 export type ClaimSessionWorkForAttemptInput = {
     sessionId: string;
     workflowId: string;
@@ -6217,6 +7100,11 @@ export type ClaimSessionWorkForAttemptResult = {
     action: "unclaimed";
     reason: "gate-closed" | "no-work" | "stale-approval" | "control-pending";
 };
+/**
+ * Bound legacy exact goal content only at the immutable model-context snapshot
+ * boundary. The canonical goal/revision remains byte-for-byte unchanged.
+ */
+export declare function projectSessionGoalPromptField(value: string, maxBytes: number): string;
 /**
  * Claim and register one inference attempt after a turn worker has accepted the
  * Temporal activity. This is the only transition into `running`: queue choice,
@@ -6245,7 +7133,7 @@ export type SessionAttemptInterruptionSettlement = {
  * that recovery event is the logical settlement cause in place of a
  * Pause/Steer interruption row.
  */
-export declare function markSessionAttemptQuiesced(db: Database, input: {
+export type MarkSessionAttemptQuiescedInput = {
     accountId?: string;
     workspaceId: string;
     sessionId: string;
@@ -6260,7 +7148,19 @@ export declare function markSessionAttemptQuiesced(db: Database, input: {
      * admission remains strict because only a durable interruption needs this
      * receipt. */
     allowUninterrupted?: boolean;
-}): Promise<SessionEvent[]>;
+};
+export type SessionAttemptQuiescenceCommit = {
+    events: SessionEvent[];
+    /** The exact still-undelivered outbox fact created by this commit, or found
+     * on an idempotent replay after a post-commit caller failure. Postgres remains
+     * the durable fallback; callers may deliver this fact immediately. */
+    workflowWake: SessionWorkflowWake | null;
+};
+export declare function commitSessionAttemptQuiescence(db: Database, input: MarkSessionAttemptQuiescedInput): Promise<SessionAttemptQuiescenceCommit>;
+/** Compatibility projection for callers that only publish the committed
+ * events. The turn activity uses `commitSessionAttemptQuiescence` so it can
+ * immediately deliver the returned durable wake without waiting for repair. */
+export declare function markSessionAttemptQuiesced(db: Database, input: MarkSessionAttemptQuiescedInput): Promise<SessionEvent[]>;
 export type ReconcileSessionAttemptQuiescenceResult = {
     action: "quiesced";
     events: SessionEvent[];
@@ -6318,6 +7218,7 @@ export type SessionWorkPeek = {
 } | {
     kind: "approval-wait";
     humanInputRequestId?: string;
+    interactionInterventionId?: string;
     expiresAt?: string;
 } | {
     kind: "capacity-wait";
@@ -6401,6 +7302,12 @@ export type ApplySessionTurnSettlementInput = {
             allowSkip: boolean;
             expiresAt?: Date | null;
         }>;
+        interactionInterventionRequests?: Array<{
+            id: string;
+            operationId: string;
+            toolCallId: string;
+            input: RequestHumanInteractionToolInput;
+        }>;
     };
     recording?: SessionTurnRecordingSettlement;
     /**
@@ -6610,6 +7517,7 @@ export type SessionSystemUpdateOutboxDelivery = {
     payload: ChildTerminalResultPayload;
     lineage: Record<string, unknown>;
     personalConnectionDelegations: McpPersonalConnectionDelegation[];
+    xaiProviderAccountAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1;
 };
 /**
  * Read the exact durable parent-update row created by terminal turn settlement.
@@ -6716,6 +7624,7 @@ export type AddSessionSystemUpdateInput = {
     summary: string;
     lineage?: Record<string, unknown>;
     personalConnectionDelegations?: McpPersonalConnectionDelegation[];
+    xaiProviderAccountAuthoritySnapshot?: XaiProviderAccountAuthoritySnapshotV1;
 } & SessionSystemUpdateInputVariant;
 export type AddSessionSystemUpdateResult = {
     added: false;
@@ -6735,7 +7644,7 @@ export declare function addSessionSystemUpdate(db: Database, input: AddSessionSy
  * Persist one internal update without fabricating a user prompt or queue row.
  * Dedupe and any producer/outbox mutation commit in the same transaction.
  */
-export declare function addSessionSystemUpdateWithSourceMutation(db: Database, input: AddSessionSystemUpdateInput, mutateSource: (tx: Database, wakeEventId: string | null) => Promise<void>): Promise<AddSessionSystemUpdateResult>;
+export declare function addSessionSystemUpdateWithSourceMutation(db: Database, input: AddSessionSystemUpdateInput, mutateSource: (tx: Database, wakeEventId: string | null, updateId: string | null) => Promise<void>): Promise<AddSessionSystemUpdateResult>;
 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[]>;
@@ -6761,7 +7670,29 @@ export declare function acceptSessionApprovalDecision(db: Database, input: {
     subjectId: string;
     payload: Record<string, unknown>;
     clientEventId?: string | null;
+    interactionIntervention?: {
+        interventionId: string;
+        operationId: string;
+        expectedVersion: number;
+        outcome: "completed" | "dismissed";
+    };
 }): Promise<AcceptSessionApprovalDecisionResult>;
+export type ExpireSessionInteractionInterventionResult = {
+    action: "expired" | "stale" | "not_found";
+    events: SessionEvent[];
+};
+/**
+ * Expire one model-owned intervention through the same exact approval boundary
+ * as a human rejection. The resource settlement and rejection event commit
+ * together inside acceptSessionApprovalDecision; a race with a human response
+ * becomes an event-free stale result.
+ */
+export declare function expireSessionInteractionIntervention(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    interventionId: string;
+}): Promise<ExpireSessionInteractionInterventionResult>;
 /**
  * Durable attempt fence for activity-produced events. A cancelled or replaced
  * attempt may still flush SDK callbacks after Temporal cancellation; those late
@@ -6772,6 +7703,46 @@ export declare function appendSessionEventsForTurnAttempt(db: Database, workspac
     events: SessionEvent[];
     accepted: boolean;
 }>;
+/**
+ * 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<{
+    events: SessionEvent[];
+    accepted: boolean;
+    mutationApplied: boolean;
+}>;
+export type SettleCodemodeOperationWithOutputInput = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+    operationId: string;
+    claimId: string;
+    producerId: string;
+    settlement: {
+        state: "completed";
+        result: AttemptToolResult;
+    } | {
+        state: "failed" | "outcome_unknown";
+        errorCode: string;
+        errorMessage: string;
+    };
+};
+/**
+ * The Codemode terminal journal row and its visible tool-call output are one
+ * PostgreSQL commit. A worker crash can lose only live NATS fanout, which the
+ * ordinary durable event replay repairs; it cannot leave a completed call
+ * permanently spinning in the timeline.
+ */
+export declare function settleCodemodeOperationWithOutput(db: Database, input: SettleCodemodeOperationWithOutputInput): Promise<{
+    committed: boolean;
+    events: SessionEvent[];
+    accepted: boolean;
+}>;
 export declare function appendSessionEventToSandboxGroup(db: Database, workspaceId: string, sandboxGroupId: string, input: AppendEventInput): Promise<SessionEvent[]>;
 export declare function appendSessionEventsAndUpdateSession(db: Database, workspaceId: string, sessionId: string, inputs: AppendEventInput[], update: {
     resources?: ResourceRef[];
@@ -6802,7 +7773,14 @@ type LockedSessionUpdateResult = {
         activeTurnId?: string | null;
     };
 };
-export declare function appendSessionEventsWithLockedSessionUpdate(db: Database, workspaceId: string, sessionId: string, build: (session: Session, context: LockedSessionUpdateContext) => LockedSessionUpdateResult | Promise<LockedSessionUpdateResult>, options?: {
+/**
+ * Serialize a callback with the session/event lock prefix and append its result.
+ * Callers must declare whether the callback can produce semantic activity. A
+ * raw-only declaration skips the commit gate and is verified before any event
+ * or session-row write; conditional semantic callbacks may legitimately no-op.
+ */
+export declare function appendSessionEventsWithLockedSessionUpdate(db: Database, workspaceId: string, sessionId: string, build: (session: Session, context: LockedSessionUpdateContext) => LockedSessionUpdateResult | Promise<LockedSessionUpdateResult>, options: {
+    activity: "raw-only" | "semantic";
     lockParentSession?: boolean;
 }): Promise<SessionEvent[]>;
 export declare function sessionSubject(workspaceId: string, sessionId: string): string;
@@ -6810,7 +7788,25 @@ 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";
-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";
-export * from "./workspace-artifacts";
-export * from "./transcription-recordings";
+export { withCodexTokenDeadline, type CodexAccountUsageSnapshot, type CodexAuthDeps, 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";
+export { deferPackInstallationOperation, finalizePackInstallationOperation, finalizePackUninstallOperation, PackManifestChangedError, PackOperationClaimLostError, PackOperationInProgressError, PackInstallationVersionConflictError, PackInstallationVersionRequiredError, PackOperationIdempotencyError, preparePackInstallationOperation, preparePackUninstallOperation, touchPackInstallationOperation, type PreparedPackInstallation, } from "./pack-installations.js";
+export { checkpointPluginPackageOperation, deferPluginPackageOperation, finalizePluginPackageInstall, getInstalledPluginPackage, getPluginPackageUninstallPreview, installPluginMcpReference, listInstalledPluginPackages, PluginInstallationVersionConflictError, PluginInstallationVersionRequiredError, PluginOperationIdempotencyError, preparePluginPackageInstall, uninstallPluginPackage, type InstalledPluginPackage, type InstalledPluginPackageSummary, type PluginBomComponent, type PreparedPluginPackage, } from "./plugin-packages.js";
+export * from "./workspace-artifacts.js";
+export * from "./transcription-recordings.js";
+export * from "./editable-artifacts.js";
+export * from "./editable-artifact-materialization.js";
+export * from "./attempt-tool-catalogs.js";
+export * from "./codemode-operations.js";
+export * from "./browser-sessions.js";
+export * from "./computer-sessions.js";
+export * from "./browser-identities.js";
+export * from "./browser-state-artifacts.js";
+export * from "./browser-auth.js";
+export * from "./browser-downloads.js";
+export * from "./attached-browser-devices.js";
+export * from "./interaction-revisions.js";
+export * from "./canonical-human-identities.js";
+export * from "./session-tenancy.js";