@opengeni/db 3.5.2-canary.0 → 3.7.3-canary.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { type ChildLifecycleSystemUpdateKind, type ChildRequiresActionRespondedByKind, SessionGoalSnapshot } from "@opengeni/contracts";
-import type { AccessContext, AccessGrant, AccessPrincipalKind, ApiKey, AttemptToolResult, BillingBalance, CapabilityCatalogItem, CapabilityInstallation, CapabilityPack, CapabilitySource, ConnectionKind, ConnectionMetadata, ConnectionStatus, DocumentAuthorityKind, McpServerConnectionRef, FileAsset, FileUploadStatus, FirstPartyMcpToolName, HumanInputQuestion, HumanInputResponse, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemoryStatus, KnowledgeSourceRef, GitHubInstallationAuthorityKind, GitHubRepositoryScope, HostEventExportBatch, HostUsageExportBatch, ManagedAccount, ManagedOrganizationMembershipProjection, McpPersonalConnectionDelegation, ModelContextContributionSummary, Permission, PersonalResourceAttachmentIntent, PackInstallation, PackInstallationStatus, ResourceRef, SandboxBackend, SandboxOs, ScheduledTask, ScheduledTaskAction, ScheduledTaskActionKind, KnowledgeSourceSyncAction, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunAcceptedExecution as ScheduledTaskRunAcceptedExecutionType, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, SlackInstallationBinding, Session, SessionAuthorizationListScope, SessionListResponse, SessionEvent, SessionEventPayloadMode, SessionEventReadDirection, SessionEventSemanticClass, SessionEventType, SessionGoal, SessionGoalChangeKind, SessionGoalCreatedBy, SessionGoalMutationPolicy, SessionGoalRevision, SessionGoalStatus, SessionHumanInputRequest, LineageNode, SessionMcpApprovalPolicy, SessionSkill, SessionMcpServerMetadata, SessionStatus, SessionToolPolicy, SessionTurn, SessionQueueSnapshot, SessionSystemUpdate, SessionSystemUpdateKind, SystemUpdateClassification, SessionTurnSource, SessionTurnStatus, TurnInitiator, TurnInitiatorContext, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, ToolRef, ReasoningEffort, UsageEvent, Workspace, WorkspaceControlEvent, VariableSet, VariableSetSecret, VariableSetVariableMetadata, WorkspaceMember, WorkspaceMemoryPromptMode, WorkspaceRegisteredPack, Channel, Rig, RigProviderImage, RigProviderImages, RigVersion, RigVerificationHealth, RigChange, RigChangeKind, RigChangeStatus, RigCheck, NativeSnapshotDescriptor, TarWorkspaceArchiveDescriptor, WorkspaceArchiveDescriptor, ModalCheckpointProviderBinding, SandboxProviderContinuityRecovery } from "@opengeni/contracts";
+import type { AccessContext, AccessGrant, AccessPrincipalKind, ApiKey, AttemptToolResult, BillingBalance, CapabilityCatalogItem, CapabilityInstallation, CapabilityPack, CapabilitySource, ConnectionKind, ConnectionMetadata, ConnectionStatus, DocumentAuthorityKind, McpServerConnectionRef, FileAsset, FileUploadStatus, FirstPartyMcpToolName, HumanInputQuestion, HumanInputResponse, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemoryStatus, KnowledgeSourceRef, GitHubInstallationAuthorityKind, GitHubRepositoryScope, HostEventExportBatch, HostUsageExportBatch, ManagedAccount, ManagedOrganizationMembershipProjection, WorkspaceMemberCandidate, McpPersonalConnectionDelegation, ModelContextContributionSummary, Permission, PersonalResourceAttachmentIntent, PackInstallation, PackInstallationStatus, ResourceRef, SandboxBackend, SandboxOs, ScheduledTask, ScheduledTaskAction, ScheduledTaskActionKind, KnowledgeSourceSyncAction, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunAcceptedExecution as ScheduledTaskRunAcceptedExecutionType, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, SlackInstallationBinding, Session, SessionAuthorizationListScope, SessionListResponse, SessionEvent, SessionEventPayloadMode, SessionEventReadDirection, SessionEventSemanticClass, SessionEventType, SessionGoal, SessionGoalChangeKind, SessionGoalCreatedBy, SessionGoalMutationPolicy, SessionGoalRevision, SessionGoalStatus, SessionHumanInputRequest, LineageNode, SessionMcpApprovalPolicy, SessionSkill, SessionMcpServerMetadata, SessionStatus, SessionToolPolicy, SessionTurn, SessionQueueSnapshot, SessionSystemUpdate, SessionSystemUpdateKind, SystemUpdateClassification, SessionTurnSource, SessionTurnStatus, TurnInitiator, TurnInitiatorContext, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, ToolRef, ReasoningEffort, UsageEvent, Workspace, WorkspaceControlEvent, VariableSet, VariableSetSecret, VariableSetVariableMetadata, WorkspaceMember, WorkspaceMemoryPromptMode, WorkspaceRegisteredPack, Channel, Rig, RigProviderImage, RigProviderImages, RigVersion, RigVerificationHealth, RigChange, RigChangeKind, RigChangeStatus, RigCheck, NativeSnapshotDescriptor, TarWorkspaceArchiveDescriptor, WorkspaceArchiveDescriptor, ModalCheckpointProviderBinding, SandboxProviderContinuityRecovery, WorkClaimSubjectFilter, WorkDiscoveryProjection } from "@opengeni/contracts";
 import { type WorkspaceArchiveObjectRef, RequestHumanInteractionToolInput, XaiProviderAccountAuthoritySnapshotV1, type TimelineAnnotation } from "@opengeni/contracts";
 import { type LatencyMode, SessionSystemUpdatePayload, TurnExecutionPolicyV1 } from "@opengeni/contracts";
 import { type Settings } from "@opengeni/config";
@@ -23,6 +23,7 @@ export * from "./session-realtime-ledger.js";
 export * from "./new-session-drafts.js";
 export * from "./workspace-instruction-policies.js";
 export * from "./company-profile.js";
+export * from "./company-profile-agent-policy.js";
 export * from "./company-profile-agent-admin.js";
 export * from "./workspace-learning-policy.js";
 export * from "./governed-learning-evaluator.js";
@@ -36,6 +37,7 @@ export * from "./company-brain-governed-writes.js";
 export * from "./company-brain-context-selection.js";
 export * from "./knowledge-source-sync.js";
 export * from "./task-notes.js";
+export * from "./work-claims.js";
 export * from "./managed-human-provisioning.js";
 export * from "./managed-user-setup.js";
 export * from "./organization-membership-backfill.js";
@@ -69,7 +71,7 @@ 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 ManagedUserProfile, type UserLookup, type UserProfileLookup, } from "./database.js";
 export { withSessionRlsActorContext } from "./database.js";
-import { buildCodexTokenResolver as buildCodexTokenResolverCore, fetchCodexRateLimitResetCreditsForAccount as fetchCodexRateLimitResetCreditsForAccountCore, fetchCodexUsageForAccount as fetchCodexUsageForAccountCore, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialForRun } from "./codex-token-resolver.js";
+import { buildCodexTokenResolver as buildCodexTokenResolverCore, fetchCodexRateLimitResetCreditsForAccount as fetchCodexRateLimitResetCreditsForAccountCore, fetchCodexUsageForAccount as fetchCodexUsageForAccountCore, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialCooldownKind, type CodexCredentialForRun } from "./codex-token-resolver.js";
 import { buildConnectionTokenResolver as buildConnectionTokenResolverCore, type ConnectionBrokerDeps, type ConnectionCredentialForBroker, type ConnectionTokenResolverOptions } from "./connection-token-resolver.js";
 /** Raised when a durable session tool-policy write lost its version fence. */
 export declare class SessionToolPolicyVersionConflictError extends Error {
@@ -261,6 +263,18 @@ export declare const allWorkspacePermissions: Permission[];
  * with ambient access to the private workspace.
  */
 export declare const managedPersonalWorkspacePermissions: Permission[];
+/**
+ * Resolve the synthetic personal-workspace grant for a subject whose human
+ * identity was authenticated out of band (for example, in HMAC-signed OAuth
+ * state). This is intentionally narrower than ordinary access resolution:
+ * the requested workspace must still be the subject's current personal
+ * workspace pointer and its organization membership must remain active.
+ */
+export declare function resolveNamedManagedPersonalWorkspaceGrant(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+}): Promise<AccessGrant | null>;
 export declare const allAccountPermissions: Permission[];
 export type BootstrapWorkspaceInput = {
     accountExternalSource: string;
@@ -299,6 +313,14 @@ export declare function getWorkspace(db: Database, workspaceId: string): Promise
 export declare function getManagedAccount(db: Database, accountId: string): Promise<ManagedAccount | null>;
 export declare function requireWorkspace(db: Database, workspaceId: string): Promise<Workspace>;
 export declare function listWorkspacesForSubject(db: Database, subjectId: string, limit?: number): Promise<Workspace[]>;
+/**
+ * Complete organization-workspace inventory for an account-scoped caller.
+ * Personal workspaces are excluded by the canonical organization-membership
+ * pointer through one narrowly granted set-based database capability; the
+ * public projection is therefore safely emitted as the current wire value
+ * `kind: "shared"`.
+ */
+export declare function listSharedWorkspacesForAccount(db: Database, accountId: string): Promise<Workspace[]>;
 export declare function countWorkspacesForAccount(db: Database, accountId: string): Promise<number>;
 export declare function createWorkspace(db: Database, input: {
     accountId: string;
@@ -307,7 +329,36 @@ export declare function createWorkspace(db: Database, input: {
     externalSource?: string | null;
     externalId?: string | null;
     agentInstructions?: string | null;
+    maxWorkspacesPerAccount?: number | null;
 }): Promise<Workspace>;
+export declare class WorkspaceExternalIdentityConflictError extends Error {
+    constructor();
+}
+export declare function findWorkspaceByExternalIdentity(db: Database, input: {
+    externalSource: string;
+    externalId: string;
+}): Promise<Workspace | null>;
+export declare class WorkspaceLimitExceededError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
+/**
+ * Create an organization workspace exactly once for a stable external tenant
+ * identity. The global unique index is the concurrency arbiter. A replay never
+ * mutates presentation fields supplied by the original create.
+ */
+export declare function ensureWorkspaceByExternalIdentity(db: Database, input: {
+    accountId: string;
+    externalSource: string;
+    externalId: string;
+    name: string;
+    slug?: string | null;
+    agentInstructions?: string | null;
+    maxWorkspacesPerAccount?: number | null;
+}): Promise<{
+    workspace: Workspace;
+    created: boolean;
+}>;
 /**
  * Create one shared workspace through the direct managed-human organization
  * control plane. Organization authority is rechecked inside the lifecycle
@@ -330,6 +381,40 @@ export declare function grantWorkspaceAccess(db: Database, input: {
     role?: string;
     permissions: Permission[];
 }): Promise<void>;
+export declare class WorkspaceMemberManagementError extends Error {
+    readonly code: "WORKSPACE_MEMBER_ALREADY_EXISTS" | "WORKSPACE_MEMBER_NOT_FOUND" | "WORKSPACE_MEMBER_SELF_UPDATE" | "WORKSPACE_MEMBER_LAST_ADMIN";
+    constructor(code: "WORKSPACE_MEMBER_ALREADY_EXISTS" | "WORKSPACE_MEMBER_NOT_FOUND" | "WORKSPACE_MEMBER_SELF_UPDATE" | "WORKSPACE_MEMBER_LAST_ADMIN");
+}
+/**
+ * Add or update one human workspace member under the same organization fence
+ * used by suspension, offboarding, organization-level grants, and removals.
+ * The SECURITY DEFINER candidate check runs after the fence is held, so a
+ * concurrent lifecycle transition cannot invalidate authority between the
+ * check and the membership write.
+ */
+export declare function upsertWorkspaceMemberAsWorkspaceManager(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+    targetSubjectId: string;
+    mode: "add" | "update";
+    subjectLabel?: string;
+    role: string;
+    permissions: Permission[];
+}): Promise<void>;
+/** Prove workspace-scoped management and same-organization active membership. */
+export declare function assertWorkspaceMemberManagementCandidate(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+    targetSubjectId: string;
+}): Promise<void>;
+/** List active same-organization humans who do not already have workspace access. */
+export declare function listWorkspaceMemberManagementCandidates(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+}): Promise<WorkspaceMemberCandidate[]>;
 /**
  * Organization control-plane metadata update for one shared workspace. This
  * capability never creates a workspace membership or an operational grant for
@@ -426,6 +511,18 @@ export type DeleteWorkspaceIfQuiescentResult = {
 } | {
     status: "not_found" | "only_workspace" | "active_sessions" | "active_video_generations" | "active_background_commands" | "live_sandboxes";
 };
+export type WorkspaceDeletePhase = "transaction" | "lifecycle_lock" | "account_workspace_lock" | "session_fence" | "runtime_ownership" | "external_cleanup" | "variable_set_detach" | "cascade";
+export type WorkspaceDeleteOutcome = DeleteWorkspaceIfQuiescentResult["status"] | "ok" | "error";
+export type WorkspaceDeleteInventoryKind = "workspaces" | "sessions" | "live_attempts" | "active_video_generations" | "active_background_commands" | "sandbox_leases" | "sandbox_holders" | "unsettled_sandbox_admissions" | "active_retained_processes" | "open_ptys" | "temporal_schedules";
+export type WorkspaceDeleteObservation = {
+    phase: WorkspaceDeletePhase;
+    outcome: WorkspaceDeleteOutcome;
+    durationSeconds: number;
+    inventory?: Partial<Record<WorkspaceDeleteInventoryKind, number>>;
+};
+export type WorkspaceDeleteObserver = {
+    onPhase?: (observation: WorkspaceDeleteObservation) => void;
+};
 /**
  * Atomically prove a workspace has no live runtime ownership and delete it.
  *
@@ -438,6 +535,7 @@ export type DeleteWorkspaceIfQuiescentResult = {
 export declare function deleteWorkspaceIfQuiescent(db: Database, input: {
     accountId: string;
     workspaceId: string;
+    observer?: WorkspaceDeleteObserver;
 }): Promise<DeleteWorkspaceIfQuiescentResult>;
 /** Claim a bounded cross-workspace batch after abandoned claims expire. */
 export declare function claimTemporalScheduleCleanups(db: Database, input: {
@@ -469,11 +567,37 @@ export declare function createApiKey(db: Database, input: {
     keyHash: string;
     permissions: Permission[];
     expiresAt?: Date | null;
+    credentialKind?: schema.ApiKeyCredentialKind;
+}): Promise<ApiKey>;
+export declare class OrganizationApiKeyLimitExceededError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
+/**
+ * Create an explicitly proven organization key under one account-scoped lock.
+ * An authenticating organization key may open exactly one temporary overlap
+ * slot at the configured cap so it can create a replacement before revocation.
+ */
+export declare function createOrganizationApiKey(db: Database, input: {
+    accountId: string;
+    name: string;
+    description?: string | null;
+    prefix: string;
+    keyHash: string;
+    permissions: Permission[];
+    expiresAt?: Date | null;
+    maxActiveKeys?: number | null;
+    rotationSourceApiKeyId?: string | null;
 }): Promise<ApiKey>;
 export declare function listApiKeys(db: Database, workspaceId: string): Promise<ApiKey[]>;
+export declare function listOrganizationApiKeys(db: Database, accountId: string): Promise<ApiKey[]>;
 export declare function countActiveApiKeysForWorkspace(db: Database, workspaceId: string): Promise<number>;
+export declare function countActiveOrganizationApiKeysForAccount(db: Database, accountId: string): Promise<number>;
 export declare function revokeApiKey(db: Database, workspaceId: string, apiKeyId: string): Promise<ApiKey>;
-export declare function findActiveApiKeyByHash(db: Database, keyHash: string): Promise<ApiKey | null>;
+export declare function revokeOrganizationApiKey(db: Database, accountId: string, apiKeyId: string): Promise<ApiKey | null>;
+export declare function findActiveApiKeyByHash(db: Database, keyHash: string): Promise<(ApiKey & {
+    credentialKind: schema.ApiKeyCredentialKind;
+}) | null>;
 export type GitHubInstallation = {
     id: string;
     accountId: string;
@@ -2478,6 +2602,7 @@ export type CorrectWorkspaceMemoryInput = {
     reason?: string | undefined;
     replacementText?: string | undefined;
     sessionId?: string | null | undefined;
+    origin?: WorkspaceMemoryOrigin | undefined;
 };
 export type CorrectWorkspaceMemoryResult = {
     action: "archived" | "superseded" | "updated";
@@ -2700,6 +2825,43 @@ export declare function getScheduledTaskRevisionAuthority(db: Database, input: {
 } | null>;
 /** Failure settlement must not rewrite a source already committed as dispatched. */
 export declare function markScheduledTaskRunFailedIfQueued(db: Database, workspaceId: string, runId: string, error: string): Promise<void>;
+export type FailScheduledGeneratedSessionRouteResult = {
+    action: "failed";
+    events: SessionEvent[];
+    sessionReclaimed: boolean;
+    error: string;
+} | {
+    action: "terminal";
+    events: [];
+    sessionReclaimed: false;
+    status: "failed" | "skipped";
+    error: string | null;
+} | {
+    action: "advanced";
+    events: [];
+    sessionReclaimed: false;
+    status: "dispatched" | "succeeded";
+};
+/**
+ * Fail a queued scheduled run after its selected Connected Machine could not be
+ * established. If the exact scheduler-created session has not acquired any
+ * turn, fail that otherwise-orphaned session in the same transaction. A user
+ * cancellation wins for the session row, but the machine failure still owns
+ * the run settlement in this one durable boundary.
+ *
+ * The external liveness probe and sandbox CAS must happen before this DB-only
+ * seam. This transaction serializes the resulting failure with initialization,
+ * cancellation, and a concurrent dispatcher under the canonical
+ * control -> workspace -> session -> scheduled-run lock order.
+ */
+export declare function failScheduledGeneratedSessionRoute(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    taskId: string;
+    runId: string;
+    sessionId: string;
+    error: string;
+}): Promise<FailScheduledGeneratedSessionRouteResult>;
 export declare function markScheduledTaskRunSkippedIfQueued(db: Database, input: {
     workspaceId: string;
     runId: string;
@@ -3435,6 +3597,30 @@ export declare function loadVariableSetForRun(db: Database, settings: Settings,
 export declare const loadWorkspaceEnvironmentForRun: typeof loadVariableSetForRun;
 /** @deprecated use VariableSetForRun */
 export type WorkspaceEnvironmentForRun = VariableSetForRun;
+export type WorkspaceCodexSubscriptionMode = "automatic" | "workspace" | "organization" | "disabled";
+export type EffectiveCodexSubscriptionSource = "workspace" | "organization" | "disabled";
+export type WorkspaceCodexSubscriptionSource = {
+    accountId: string;
+    workspaceId: string;
+    workspaceKind: "personal" | "shared";
+    mode: WorkspaceCodexSubscriptionMode;
+    effectiveSource: EffectiveCodexSubscriptionSource;
+    workspaceAvailable: boolean;
+    organizationAvailable: boolean;
+};
+export declare function getWorkspaceCodexSubscriptionSource(db: Database, workspaceId: string): Promise<WorkspaceCodexSubscriptionSource>;
+export declare function setWorkspaceCodexSubscriptionModeInTransaction(scopedDb: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    mode: WorkspaceCodexSubscriptionMode;
+}): Promise<WorkspaceCodexSubscriptionSource>;
+export declare function setWorkspaceCodexSubscriptionMode(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    mode: WorkspaceCodexSubscriptionMode;
+}): Promise<WorkspaceCodexSubscriptionSource>;
 /**
  * Login / rotation write (multi-account P1). Caller passes the PRE-encrypted
  * credential blob. Keyed on the composite partial index (workspace, chatgpt
@@ -3468,6 +3654,65 @@ export declare function upsertCodexSubscriptionCredential(db: Database, input: {
     /** Direct managed-cookie human who most recently connected this row. */
     connectedBySubjectId?: string | null;
 }): Promise<UpsertCodexSubscriptionCredentialResult>;
+export declare function ensureOrganizationCodexRotationSettings(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+}): Promise<void>;
+export declare function upsertOrganizationCodexSubscriptionCredential(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialEncrypted: string;
+    chatgptAccountId: string | null;
+    scopes: string | null;
+    planType: string | null;
+    isFedramp: boolean;
+    expiresAt: Date | null;
+    lastRefreshAt: Date | null;
+    accountEmail?: string | null;
+    label?: string | null;
+}): Promise<{
+    id: string;
+    isNew: boolean;
+    wakeTargets: CodexCapacityWakeTarget[];
+}>;
+export declare function listOrganizationCodexAccountStatuses(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+}): Promise<CodexAccountStatus[]>;
+export declare function getOrganizationCodexRotationSettings(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+}): Promise<CodexRotationSettings | null>;
+export declare function setActiveOrganizationCodexCredential(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialId: string;
+}): Promise<{
+    activated: boolean;
+    wakeTargets: CodexCapacityWakeTarget[];
+}>;
+export declare function updateOrganizationCodexRotationSettings(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    rotationEnabled: boolean;
+}): Promise<(CodexRotationSettings & {
+    wakeTargets: CodexCapacityWakeTarget[];
+}) | null>;
+export declare function renameOrganizationCodexAccount(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialId: string;
+    label: string | null;
+}): Promise<boolean>;
+export declare function disconnectOrganizationCodexAccount(db: Database, input: {
+    organizationId: string;
+    actorSubjectId: string;
+    credentialId: string;
+}): Promise<{
+    removed: boolean;
+    newActiveCredentialId: string | null;
+    wakeTargets: CodexCapacityWakeTarget[];
+}>;
 export type CodexAppsSettings = {
     credentialId: string | null;
     version: number;
@@ -3644,6 +3889,7 @@ export declare function isCodexBilledTurn(input: {
 }): Promise<boolean>;
 export type CodexAccountStatus = {
     id: string;
+    source: Exclude<EffectiveCodexSubscriptionSource, "disabled">;
     chatgptAccountId: string | null;
     label: string | null;
     accountEmail: string | null;
@@ -3667,6 +3913,8 @@ export type CodexAccountStatus = {
     secondaryResetAt: Date | null;
     usageCheckedAt: Date | null;
     exhaustedUntil: Date | null;
+    /** Typed provider-refusal provenance; null for legacy/cleared cooldowns. */
+    exhaustedKind: CodexCredentialCooldownKind | null;
 };
 /**
  * A metadata-only scheduling candidate observed while the workspace's rotation
@@ -3674,7 +3922,7 @@ export type CodexAccountStatus = {
  * the selection cursor gives deterministic fairness after those holders drain.
  * None of these fields contains credential material.
  */
-export type CodexLeaseAccountStatus = Omit<CodexAccountStatus, "allocatorVersion" | "allocatorUpdatedBySubjectId" | "allocatorUpdatedAt" | "resetCreditAvailableCount" | "resetCreditsCheckedAt" | "connectedBySubjectId"> & {
+export type CodexLeaseAccountStatus = Omit<CodexAccountStatus, "allocatorVersion" | "allocatorUpdatedBySubjectId" | "allocatorUpdatedAt" | "resetCreditAvailableCount" | "resetCreditsCheckedAt" | "connectedBySubjectId" | "source"> & {
     activeLeaseCount: number;
     selectionCount: number;
     lastSelectedAt: Date | null;
@@ -4058,6 +4306,7 @@ export type CodexCredentialLeaseQuarantine = {
 } | {
     kind: "cooldown";
     until: Date;
+    cooldownKind: CodexCredentialCooldownKind;
 };
 /**
  * Quarantine the credential served by one exact live holder. The lease row is
@@ -4263,7 +4512,7 @@ export declare function completeCodexResetRedemption(db: Database, input: {
 }): Promise<CodexCapacityMutationResult<CodexResetRedemptionAttempt | null>>;
 /** The P2 usage-cache snapshot written by the refreshing usage wrapper. */
 /**
- * Cache-write for P2 quota bars: persist the five plaintext usage columns on a
+ * Cache-write for P2 quota bars and revision-fenced quota cooldown repair on a
  * SPECIFIC credential row. NEVER touches credential_encrypted. RLS-scoped, guarded
  * by (id, workspace_id) so it can only write a row the workspace owns. Returns true
  * iff a row was updated (false ⇒ the credential was disconnected under us — the
@@ -4327,9 +4576,9 @@ export declare function setInitialActiveCodexCredential(db: Database, workspaceI
  * never race the (id, version) token-refresh CAS in recordCodexTokenRefresh / setCodexCredentialStatus.
  * Returns true iff a row was updated (false ⇒ the credential was disconnected under us).
  */
-export declare function setCodexCredentialExhausted(db: Database, workspaceId: string, credentialId: string, until: Date | null): Promise<boolean>;
+export declare function setCodexCredentialExhausted(db: Database, workspaceId: string, credentialId: string, until: Date | null, cooldownKind: CodexCredentialCooldownKind | null): Promise<boolean>;
 /** Cooldown mutation plus its committed durable capacity-wake outbox. */
-export declare function setCodexCredentialExhaustedWithWakeTargets(db: Database, workspaceId: string, credentialId: string, until: Date | null): Promise<CodexCapacityMutationResult<boolean>>;
+export declare function setCodexCredentialExhaustedWithWakeTargets(db: Database, workspaceId: string, credentialId: string, until: Date | null, cooldownKind: CodexCredentialCooldownKind | null): Promise<CodexCapacityMutationResult<boolean>>;
 /**
  * P3 reactive-rotation boundedness (Finding 1b): the number of CONSECUTIVE rotated
  * 429-failover turns since the session last had a SUCCESSFUL turn. Counts
@@ -4906,9 +5155,11 @@ export declare function listSessions(db: Database, workspaceId: string, options?
  * result. The workspace filter remains authoritative under FORCE RLS.
  */
 export declare function getLatestSessionModelForSubject(db: Database, workspaceId: string, subjectId: string): Promise<string | null>;
-export type SessionDiscoveryOrderBy = "createdAt" | "updatedAt";
+export type SessionDiscoveryOrderBy = "createdAt" | "updatedAt" | "relevance";
 export type SessionDiscoveryCursor = {
     orderBy: SessionDiscoveryOrderBy;
+    /** Stable rank class for relevance order; null for chronological order. */
+    sortRank: number | null;
     /** Decimal database activity revision; zero is the legacy/created-order bucket. */
     sortRevision: string;
     /** Exact PostgreSQL timestamp text (including microseconds), not a JS Date. */
@@ -4920,6 +5171,8 @@ export type SessionDiscoveryCursor = {
     snapshotRevision: string;
     /** Incremental revision scope is cursor-bound and cannot change on continuation. */
     updatedAfter: string | null;
+    /** SHA-256 of normalized relevance filters; null for chronological order. */
+    filterHash: string | null;
 };
 export declare const SESSION_DISCOVERY_GOAL_MAX_CHARS = 600;
 export declare const SESSION_DISCOVERY_MESSAGE_MAX_CHARS = 600;
@@ -4944,12 +5197,15 @@ export type SessionDiscoverySummary = {
         preview: string | null;
         previewOriginalChars: number | null;
     } | null;
+    workDiscovery: WorkDiscoveryProjection;
     createdAt: string;
     updatedAt: string;
     /** Internal exact revision key; omitted from the MCP row projection. */
     sortRevision: string;
     /** Internal exact keyset timestamp; omitted from the MCP row projection. */
     sortAt: string;
+    /** Internal stable relevance class; omitted from public row projections. */
+    sortRank: number | null;
 };
 /**
  * Compact-by-construction discovery projection for the first-party
@@ -4963,7 +5219,17 @@ export declare function listSessionDiscoverySummaries(db: Database, workspaceId:
     orderBy?: SessionDiscoveryOrderBy;
     updatedAfter?: string;
     parentSessionId?: string | null;
+    rootSessionId?: string;
+    query?: string;
+    /** @deprecated use query; retained for the existing topology route. */
     search?: string;
+    statuses?: SessionStatus[];
+    activeOnly?: boolean;
+    recentHours?: number;
+    subject?: WorkClaimSubjectFilter;
+    claimLimit?: number;
+    /** Skip advisory claim reads for an operator-disabled discovery rollout. */
+    includeWorkDiscovery?: boolean;
     subjectId?: string;
     authorizationScope?: SessionAuthorizationListScope;
 }): Promise<{
@@ -4976,6 +5242,8 @@ export declare function listSessionDiscoverySummaries(db: Database, workspaceId:
     snapshotRevision: string;
     updatedThrough: string | null;
     updatedAfter: string | null;
+    /** Internal relevance cursor binding; omitted from row projections. */
+    filterHash: string | null;
 }>;
 export type SessionDiscoveryAncestor = {
     id: string;
@@ -4987,7 +5255,7 @@ export type SessionDiscoveryAncestor = {
  * 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 declare function listSessionDiscoveryAncestorPaths(db: Database, workspaceId: string, sessionIds: string[], authorizationScope?: SessionAuthorizationListScope, subjectId?: string): Promise<Map<string, SessionDiscoveryAncestor[]>>;
 export type SessionLineage = {
     ancestors: Session[];
     children: LineageNode[];
@@ -5508,6 +5776,25 @@ export declare function recordSkippedContextCompaction(db: Database, input: {
     recorded: false;
     reason: TurnAttemptFenceRejectReason | "request_not_pending";
 }>;
+/**
+ * Read the durable handoff condition immediately after one exact compaction
+ * landmark settles. Steer admission deliberately leaves the active attempt
+ * unfenced while its latest compaction event is `started`; the worker calls
+ * this at the first safe boundary after `compacted`/`skipped` and supersedes
+ * the ordinary turn before another model request can begin.
+ *
+ * The later terminal settlement remains the authority fence. This read only
+ * decides whether that settlement is needed, so a concurrent Pause/Cancel or a
+ * Steer admitted after the landmark can still win and make the caller stale.
+ */
+export declare function hasPendingSteerAfterContextCompaction(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    executionGeneration: number;
+    attemptId: string;
+}): Promise<boolean>;
 /**
  * The next free WHOLE-NUMBER history position for a session: one past the
  * largest existing position (active or superseded), floored so the synthetic
@@ -5922,6 +6209,54 @@ export type AcquireLeaseResult = {
     reason: "superseded" | "capture_in_progress" | "rotation_in_progress" | "provider_recovery_in_progress";
     lease: LeaseSnapshot;
 };
+export type SandboxSharedPreparationSnapshot = {
+    status: "running" | "completed" | "failed";
+    leaseEpoch: number;
+    instanceId: string;
+    specHash: string;
+    claimId: string;
+    ownerAttemptId: string;
+    attempt: number;
+    revision: number;
+    startedAt: Date;
+    deadlineAt: Date;
+    settledAt: Date | null;
+};
+export type ClaimSandboxSharedPreparationInput = {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    expectedLeaseEpoch: number;
+    expectedInstanceId: string;
+    specHash: string;
+    holderId: string;
+    claimId: string;
+    ownerAttemptId: string;
+    timeoutMs: number;
+};
+export type ClaimSandboxSharedPreparationResult = {
+    role: "owner" | "joined" | "reused";
+    preparation: SandboxSharedPreparationSnapshot;
+} | {
+    role: "fenced";
+    lease: LeaseSnapshot | null;
+};
+/**
+ * Claim, join, or reuse immutable setup for one exact physical sandbox. The
+ * provider operation remains outside the transaction; the claim deadline and
+ * box-local idempotency marker make a lost owner recoverable without sharing
+ * any turn-private credential or file material.
+ */
+export declare function claimSandboxSharedPreparation(db: Database, input: ClaimSandboxSharedPreparationInput): Promise<ClaimSandboxSharedPreparationResult>;
+export declare function readSandboxSharedPreparation(db: Database, input: Omit<ClaimSandboxSharedPreparationInput, "claimId" | "ownerAttemptId" | "timeoutMs">): Promise<{
+    status: "available";
+    preparation: SandboxSharedPreparationSnapshot;
+} | {
+    status: "fenced";
+}>;
+export declare function settleSandboxSharedPreparation(db: Database, input: Omit<ClaimSandboxSharedPreparationInput, "ownerAttemptId" | "timeoutMs"> & {
+    outcome: "completed" | "failed";
+}): Promise<boolean>;
 export declare class SandboxLeaseSupersededError extends Error {
     readonly sandboxGroupId: string;
     readonly leaseEpoch: number;
@@ -6628,6 +6963,8 @@ export declare function listMeterableWarmLeases(db: Database): Promise<Meterable
  * even after every affected sandbox lease has become cold. */
 export declare function listSandboxViewerForceDrainWorkspaceIds(db: Database): Promise<string[]>;
 export declare function countQueuedTurns(db: Database): Promise<number>;
+export type SessionRecoveryBacklogState = "quiescence_missing" | "projection_stale";
+export declare function countSessionRecoveryBacklog(db: Database): Promise<Record<SessionRecoveryBacklogState, number>>;
 export declare function countSandboxLeasesByLiveness(db: Database): Promise<Record<SandboxLeaseLiveness, number>>;
 export type CreditBalanceByAccount = {
     accountId: string;
@@ -6663,6 +7000,18 @@ export declare class SandboxWorkspaceMutationFencedError extends Error {
     readonly name: string;
     constructor(code: "attempt_fenced" | "holder_fenced" | "lease_fenced" | "rotation_in_progress" | "route_fenced" | "process_fenced" | "capture_in_progress" | "admission_fenced" | "operation_invalid" | "generation_exhausted" | "authority_unattributed" | "authority_revoked", message: string);
 }
+/** An operation named a durable retained process that has already reached a
+ * terminal state. This remains a fence—the provider must not be called again
+ * and contradictory proof must not overwrite durable truth—but carries the
+ * existing terminal result so routing can reconcile a concurrent settlement
+ * or report completion/loss instead of presenting a retryable platform failure
+ * for a handle that can never become active again. */
+export declare class SandboxRetainedProcessTerminalError extends SandboxWorkspaceMutationFencedError {
+    readonly state: "exited" | "lost";
+    readonly exitCode: number | null;
+    readonly name = "SandboxRetainedProcessTerminalError";
+    constructor(state: "exited" | "lost", exitCode: number | null);
+}
 export type SandboxWorkspaceMutationAdmission = {
     id: string;
     leaseId: string;
@@ -6984,7 +7333,8 @@ export declare function countActiveRetainedProcessesByOwnerState(db: Database):
 export declare function countExpiredDrainingSandboxLeases(db: Database): Promise<ExpiredDrainingSandboxLeaseCount[]>;
 /** Settle an exact retained process only after exit or definitive loss proof.
  * The process row, parent admission, non-TTL holder, and lease count transition
- * commit atomically. Duplicate identical proof is idempotent; conflicting proof
+ * commit atomically. A duplicate terminal state + exit code is idempotent and
+ * preserves the first durable evidence reason; contradictory physical truth
  * fails closed. */
 export declare function settleRetainedProcess(db: Database, input: {
     accountId: string;
@@ -8608,6 +8958,9 @@ export type InitializeSessionStartInput = {
     /** Trusted create-session policy. Omitted only by legacy low-level callers. */
     turnExecutionPolicy?: TurnExecutionPolicyV1;
     createdEventPayload: Record<string, unknown>;
+    /** Sensitive-safe semantic title supplied by the trusted agent-child create
+     * path. It is committed with the initial timeline, never as a bare row edit. */
+    initialAutomaticTitle?: string | null;
     goal?: {
         text: string;
         successCriteria?: string | null;
@@ -8684,6 +9037,16 @@ export type ClaimSessionWorkForAttemptInput = {
         action: "reject";
         reason: string;
     }>;
+    /**
+     * A requires-action resume first persists its open tool-call result, then
+     * re-enters this exact attempt to attach machine input that arrived while the
+     * session was blocked. The dispatch metadata freezes the session's durable
+     * pending-event sequence at attempt claim; timestamps cannot own this fence
+     * because a producer transaction may wait on the session lock. Keeping this
+     * opt-in prevents an ordinary activity retry from inserting a system message
+     * ahead of the required call/result pair in canonical history.
+     */
+    attachPendingUpdatesToRunningAttempt?: boolean;
 };
 export type ClaimSessionWorkForAttemptResult = {
     action: "claimed";
@@ -9244,21 +9607,24 @@ export declare function claimPendingSessionWorkflowWakes(db: Database, limit?: n
  * accepted direction or an interrupted attempt awaiting writer-set proof.
  * Temporal accepting a signal is transport evidence, not proof that a closing
  * workflow observed Postgres. While active control still has an actionable
- * Agent Steer or pending quiescence, retain the revision so the bounded outbox
- * dispatcher retries signalWithStart. The attempt-fenced claim consumes an
- * Agent Steer once; a real Pause is the typed blocker and may acknowledge this
+ * Agent Steer, a current wake still owns an accepted queued human/API turn, or
+ * an attempt awaits quiescence, retain the revision so the bounded outbox
+ * dispatcher retries signalWithStart. The attempt-fenced claim consumes each
+ * direction once; a real Pause is the typed blocker and may acknowledge this
  * revision because Resume commits a new one.
  *
  * An older sender may advance only its own revision; it cannot clear a claim or
- * failure state belonging to a newer revision. The control -> workspace ->
- * session lock prefix serializes this decision with Steer, Pause/Resume, and
- * claim without weakening physical-quiescence admission.
+ * failure state belonging to a newer revision. Therefore queued prompt work
+ * blocks acknowledgement only for the current coalesced revision: a stale
+ * acknowledgement still leaves the newer revision outstanding. The control ->
+ * workspace -> session lock prefix serializes this decision with Send, Steer,
+ * Pause/Resume, and claim without weakening physical-quiescence admission.
  */
 export type SessionWorkflowWakeDeliveryResult = {
     action: "acknowledged";
 } | {
     action: "pending_admission";
-    blocker: "pending_agent_steer" | "pending_quiescence";
+    blocker: "pending_agent_steer" | "pending_prompt_turn" | "pending_quiescence";
 };
 export declare function markSessionWorkflowWakeDelivered(db: Database, input: Omit<SessionWorkflowWake, "interruptionRequested">): Promise<SessionWorkflowWakeDeliveryResult>;
 /** Record delivery failure; the claim already scheduled the bounded retry. */
@@ -9344,6 +9710,7 @@ export declare function childRequiresActionResolutionExists(db: Database, worksp
 export declare function listOutstandingSessionSystemUpdates(db: Database, workspaceId: string, sessionId: string): Promise<SessionSystemUpdate[]>;
 /** Internal updates atomically attached when this inference was claimed. */
 export declare function listSessionSystemUpdatesForTurn(db: Database, workspaceId: string, sessionId: string, turnId: string): Promise<SessionSystemUpdate[]>;
+export declare function sessionEventRawLaneEnabled(value?: string | undefined): boolean;
 export declare function appendSessionEvents(db: Database, workspaceId: string, sessionId: string, inputs: AppendEventInput[]): Promise<SessionEvent[]>;
 export type AcceptSessionApprovalDecisionResult = {
     action: "accepted";
@@ -9397,17 +9764,34 @@ export declare function expireSessionInteractionIntervention(db: Database, input
  * events remain associated with their producer in logs but are not admitted to
  * the current durable timeline once the turn row moved generation or terminal.
  */
-export declare function appendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[]): Promise<{
+export declare function appendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[], observer?: SessionEventAppendObserver): Promise<{
     events: SessionEvent[];
     accepted: boolean;
     canonicalStartupMilestones: CanonicalTurnStartupMilestoneReceipt[];
 }>;
+export type SessionEventAppendClass = "raw" | "semantic" | "mixed";
+export type SessionEventAppendPhase = "transaction" | "mutation" | "turn_attempt_fence" | "idempotency" | "event_insert" | "projection" | "sequence_update";
+export type SessionEventAppendPhaseOutcome = "ok" | "rejected" | "mutation_skipped" | "projection_skipped" | "escalated" | "error";
+export type SessionEventAppendPhaseObservation = {
+    phase: SessionEventAppendPhase;
+    eventClass: SessionEventAppendClass;
+    eventCount: number;
+    outcome: SessionEventAppendPhaseOutcome;
+    durationSeconds: number;
+};
+export type SessionEventAppendObserver = {
+    onPhase?: (observation: SessionEventAppendPhaseObservation) => void;
+};
+export declare function sessionEventAppendClass(inputs: ReadonlyArray<{
+    type: string;
+}>): SessionEventAppendClass;
+export declare function observeSessionEventAppendPhase(observer: SessionEventAppendObserver | undefined, observation: SessionEventAppendPhaseObservation): void;
 /**
  * Commit one exact-attempt mutation and its timeline projection together. The
  * mutation runs first so Codemode's operation-row lock order remains stable;
  * returning false leaves both the mutation and projection absent.
  */
-export declare function mutateAndAppendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[], mutate: (tx: Database) => Promise<boolean>): Promise<{
+export declare function mutateAndAppendSessionEventsForTurnAttempt(db: Database, workspaceId: string, sessionId: string, turnId: string, executionGeneration: number, attemptId: string, inputs: AppendEventInput[], mutate: (tx: Database) => Promise<boolean>, observer?: SessionEventAppendObserver): Promise<{
     events: SessionEvent[];
     accepted: boolean;
     mutationApplied: boolean;
@@ -9488,7 +9872,7 @@ export declare function buildCodexTokenResolver(db: Database, settings: Settings
 export declare function fetchCodexUsageForAccount(db: Database, settings: Settings, workspaceId: string, credentialId: string, fetchImpl?: CodexFetch): ReturnType<typeof fetchCodexUsageForAccountCore>;
 export declare function fetchCodexRateLimitResetCreditsForAccount(db: Database, settings: Settings, workspaceId: string, credentialId: string, fetchImpl?: CodexFetch): ReturnType<typeof fetchCodexRateLimitResetCreditsForAccountCore>;
 export declare function buildConnectionTokenResolver(db: Database, settings: Settings, deps?: ConnectionBrokerDeps, options?: ConnectionTokenResolverOptions): ReturnType<typeof buildConnectionTokenResolverCore>;
-export { withCodexTokenDeadline, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialForRun, type CodexCredentialTokens, type CodexRateLimitResetCreditsAccountResult, type CodexTokenDeadlineClock, type CodexTokenDeadlineOptions, } from "./codex-token-resolver.js";
+export { withCodexTokenDeadline, type CodexAccountUsageSnapshot, type CodexAuthDeps, type CodexCredentialCooldownKind, type CodexCredentialForRun, type CodexCredentialTokens, type CodexRateLimitResetCreditsAccountResult, type CodexTokenDeadlineClock, type CodexTokenDeadlineOptions, } from "./codex-token-resolver.js";
 export { buildHostConnectionTokenResolver, ConnectionRefreshHttpError, HostMcpCredentialBindingError, HostMcpCredentialScopeError, isPrivateAddress, normalizeBearerScheme, refreshOAuthConnectionCredential, type ConnectionBrokerDeps, type ConnectionCredentialForBroker, type ConnectionCredentialLookupInput, type ConnectionStatusGuard, type ConnectionTokenRefreshInput, type ConnectionTokenResolverOptions, type HostMcpCredentialResolverContext, type PermanentConnectionRefreshFailure, type RefreshTransportOptions, type ResolveConnectionCredentialInput, type ResolveConnectionCredentialResult, } from "./connection-token-resolver.js";
 export { CapabilityComponentVersionConflictError, cleanupOrphanedCapabilityComponents, effectiveCapabilityOwnerSql, type CapabilityComponentOwnerIdentity, } from "./capability-components.js";
 export { adoptPackComponentReferences, finalizePackComponentOwnership, listPackInstallationComponents, PackComponentResolutionError, previewPackComponentRelease, recordPackInlineSkillComponent, releasePackComponents, resolvePackComponentReferences, resolvePackInlineSkillReferences, type PackInlineSkillRequirement, type StoredPackInstallationComponent, } from "./pack-components.js";