@opengeni/db 0.27.3 → 0.27.8

package/dist/index.d.ts

@@ -276,6 +276,14 @@ export declare function getHostExportConsumerStatus(db: Database, input: {
 }): Promise<HostExportConsumerStatus | null>;
 export declare function setRlsContext(db: Database, context: RlsContext): Promise<void>;
 export declare function withRlsContext<T>(db: Database, context: RlsContext, fn: (db: Database) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
+/**
+ * Run one bounded database operation on a transaction-pinned backend.
+ *
+ * Callers that also have an application deadline should check their abort
+ * signal before returning from `fn`; throwing there rolls the transaction back
+ * even when the application deadline won a surrounding Promise race.
+ */
+export declare function withDatabaseStatementTimeout<T>(db: Database, timeoutMs: number, fn: (db: Database) => Promise<T>): Promise<T>;
 export declare function rlsContextForWorkspace(db: Database, workspaceId: string): Promise<RlsContext>;
 export declare function withWorkspaceRls<T>(db: Database, workspaceId: string, fn: (db: Database) => Promise<T>): Promise<T>;
 /**
@@ -900,6 +908,9 @@ export type StoreIntegrationOAuthClientInput = {
     metadata?: Record<string, unknown>;
 };
 export type ReplaceIntegrationOAuthClientInput = StoreIntegrationOAuthClientInput;
+export type ReplaceIntegrationOAuthClientIfCurrentInput = ReplaceIntegrationOAuthClientInput & {
+    expectedClientId: string;
+};
 export type ConsumeOAuthStateNonceInput = {
     accountId: string;
     workspaceId: string;
@@ -1588,6 +1599,7 @@ export declare function recordConnectionUsed(db: Database, workspaceId: string,
 export declare function loadIntegrationOAuthClient(db: Database, settings: Settings, issuer: string): Promise<IntegrationOAuthClientForUse | null>;
 export declare function storeIntegrationOAuthClient(db: Database, input: StoreIntegrationOAuthClientInput): Promise<StoredIntegrationOAuthClient>;
 export declare function replaceIntegrationOAuthClient(db: Database, input: ReplaceIntegrationOAuthClientInput): Promise<StoredIntegrationOAuthClient>;
+export declare function replaceIntegrationOAuthClientIfCurrent(db: Database, input: ReplaceIntegrationOAuthClientIfCurrentInput): Promise<StoredIntegrationOAuthClient | null>;
 export declare function consumeIntegrationOAuthStateNonce(db: Database, input: ConsumeOAuthStateNonceInput): Promise<boolean>;
 export declare function createKnowledgeMemory(db: Database, input: CreateKnowledgeMemoryInput): Promise<KnowledgeMemory>;
 export declare function updateKnowledgeMemory(db: Database, workspaceId: string, memoryId: string, input: UpdateKnowledgeMemoryInput, embedder?: MemoryEmbedder): Promise<KnowledgeMemory>;
@@ -6363,6 +6375,7 @@ export type RequestSessionTurnRecoveryInput = {
     attemptId: string;
     reason: string;
     detail?: Record<string, unknown>;
+    providerRecoveryCount?: number;
     fromStatuses?: SessionTurnStatus[];
     providerArtifactInvalidation?: {
         codexCredentialId: string;
@@ -6489,6 +6502,7 @@ export declare function enqueueSessionWorkflowWakeInTransaction(tx: Database, in
     temporalWorkflowId: string;
     reason: string;
     notBefore?: Date;
+    controlRequested?: boolean;
 }): Promise<number>;
 /** Standalone transactional producer for operations not already in a DB txn. */
 export declare function enqueueSessionWorkflowWake(db: Database, input: {
@@ -6498,6 +6512,7 @@ export declare function enqueueSessionWorkflowWake(db: Database, input: {
     temporalWorkflowId: string;
     reason: string;
     notBefore?: Date;
+    controlRequested?: boolean;
 }): Promise<number>;
 /**
  * Re-deliver already-committed session work only when admission currently
@@ -6511,6 +6526,7 @@ export declare function enqueueSessionWorkflowWakeIfRunnable(db: Database, input
     temporalWorkflowId: string;
     reason: string;
     notBefore?: Date;
+    controlRequested?: boolean;
 }): Promise<number | null>;
 /** Claim only explicit, undelivered wake revisions; never infer work by scan. */
 export declare function claimPendingSessionWorkflowWakes(db: Database, limit?: number): Promise<SessionWorkflowWake[]>;

package/dist/index.js

@@ -114,7 +114,7 @@ import {
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-EX7CDSGH.js";
+} from "./chunk-M6EOXYHK.js";
 import {
   migrate,
   runMigrations
@@ -2319,12 +2319,13 @@ async function registerContinuableWakes(db, input) {
       )
     ), upserted as (
       insert into ${sessionWorkflowWakeOutbox} (
-        session_id, account_id, workspace_id, temporal_workflow_id, reason
+        session_id, account_id, workspace_id, temporal_workflow_id, reason, control_revision
       )
-      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}
+      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}, 1
       from eligible
       on conflict (session_id) do update set
         wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        control_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
         temporal_workflow_id = excluded.temporal_workflow_id,
         reason = excluded.reason,
         attempts = 0,
@@ -2405,12 +2406,13 @@ async function registerCancellationWakes(db, input) {
         and session.id in (${sessionIds})
     ), upserted as (
       insert into ${sessionWorkflowWakeOutbox} (
-        session_id, account_id, workspace_id, temporal_workflow_id, reason
+        session_id, account_id, workspace_id, temporal_workflow_id, reason, control_revision
       )
-      select session_id, account_id, workspace_id, temporal_workflow_id, 'session_cancelled'
+      select session_id, account_id, workspace_id, temporal_workflow_id, 'session_cancelled', 1
       from eligible
       on conflict (session_id) do update set
         wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        control_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
         temporal_workflow_id = excluded.temporal_workflow_id,
         reason = excluded.reason,
         attempts = 0,
@@ -2429,12 +2431,14 @@ async function registerSessionWorkflowWakeInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: input.temporalWorkflowId,
+    controlRevision: input.controlRequested ? 1 : 0,
     reason: input.reason
   }).onConflictDoUpdate({
     target: sessionWorkflowWakeOutbox.sessionId,
     set: {
       temporalWorkflowId: input.temporalWorkflowId,
       wakeRevision: sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      controlRevision: input.controlRequested ? sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql3`${sessionWorkflowWakeOutbox.controlRevision}`,
       reason: input.reason,
       attempts: 0,
       nextAttemptAt: /* @__PURE__ */ new Date(),
@@ -4206,7 +4210,8 @@ async function steerQueuedTurnInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: session.temporalWorkflowId ?? `session-${input.sessionId}`,
-    reason: "queue_steer"
+    reason: "queue_steer",
+    controlRequested: true
   });
   const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
     controlRevision: resumed.revision,
@@ -4626,7 +4631,8 @@ async function submitHumanPromptInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: workflowId,
-    reason: input.delivery === "steer" ? "prompt_steer" : "prompt_send"
+    reason: input.delivery === "steer" ? "prompt_steer" : "prompt_send",
+    controlRequested: input.delivery === "steer"
   });
   await db.insert(auditEvents).values({
     accountId: input.accountId,
@@ -5011,7 +5017,8 @@ async function steerAgentSessionInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.targetSessionId,
     temporalWorkflowId: workflowId,
-    reason: "agent_steer"
+    reason: "agent_steer",
+    controlRequested: true
   });
   await db.update(sessions).set({
     activeTurnId: supersession.liveCurrentTurnId,
@@ -5065,7 +5072,7 @@ async function steerAgentSessionInTransaction(db, input) {
 // src/session-realtime-context.ts
 var SESSION_REALTIME_CONTEXT_MAX_BYTES = 65536;
 var SESSION_REALTIME_TAIL_SOURCE = "transcript_tail_flush";
-var SESSION_REALTIME_TAIL_INSTRUCTION = "The user just ended their realtime session. Here is the remaining handoff/transcript tail. You probably do not have to do anything; acknowledge the handoff unless the transcript itself asks for something.";
+var SESSION_REALTIME_TAIL_INSTRUCTION = "The user just ended the realtime voice session but remains reachable by text. Ending voice changes only the communication mode; it does not stop, pause, or complete existing work. Treat the remaining transcript tail as additional context. If work was already underway, continue it from the current state. Change or stop that work only if the user explicitly requested it. If nothing was underway and the transcript contains no unhandled request, acknowledge briefly; otherwise handle any unhandled request.";
 function deterministicUuid2(seed) {
   const bytes = createHash3("sha256").update(seed, "utf8").digest().subarray(0, 16);
   bytes[6] = (bytes[6] ?? 0) & 15 | 80;
@@ -14145,6 +14152,19 @@ async function withRlsContext(db, context, fn, transactionConfig) {
     return await fn(scoped);
   }, transactionConfig);
 }
+async function withDatabaseStatementTimeout(db, timeoutMs, fn) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("withDatabaseStatementTimeout requires a positive timeout");
+  }
+  const boundedTimeoutMs = Math.max(1, Math.floor(timeoutMs));
+  return await db.transaction(async (tx) => {
+    const scoped = tx;
+    await scoped.execute(
+      sql14`select set_config('statement_timeout', ${`${boundedTimeoutMs}ms`}, true)`
+    );
+    return await fn(scoped);
+  });
+}
 async function rlsContextForWorkspace(db, workspaceId) {
   const [row] = await db.select({ accountId: workspaces.accountId }).from(workspaces).where(eq17(workspaces.id, workspaceId)).limit(1);
   if (!row) {
@@ -17998,6 +18018,22 @@ async function replaceIntegrationOAuthClient(db, input) {
   }
   return mapStoredIntegrationOAuthClient(row);
 }
+async function replaceIntegrationOAuthClientIfCurrent(db, input) {
+  const [row] = await db.update(integrationOauthClients).set({
+    authorizationServer: input.authorizationServer,
+    clientId: input.clientId,
+    clientSecretEncrypted: input.clientSecretEncrypted ?? null,
+    tokenEndpointAuthMethod: input.tokenEndpointAuthMethod ?? "none",
+    metadata: input.metadata ?? {},
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and17(
+      eq17(integrationOauthClients.issuer, input.issuer),
+      eq17(integrationOauthClients.clientId, input.expectedClientId)
+    )
+  ).returning();
+  return row ? mapStoredIntegrationOAuthClient(row) : null;
+}
 function mapStoredIntegrationOAuthClient(row) {
   return {
     id: row.id,
@@ -35612,7 +35648,8 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
             "pending",
             "delivered",
             "acknowledged",
-            "settled"
+            "settled",
+            "rejected_stale"
           ]),
           isNull6(sessionTurnAttempts.quiescedAt)
         )
@@ -36305,24 +36342,6 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           turn: mapSessionTurnForExecution(internalTurn)
         };
       }
-      const predecessorAttemptId = queuedSteerReplacementAttemptId(queuedTurn.metadata);
-      if (predecessorAttemptId) {
-        const [predecessor] = await tx.select({ quiescedAt: sessionTurnAttempts.quiescedAt }).from(sessionTurnAttempts).where(
-          and17(
-            eq17(sessionTurnAttempts.workspaceId, workspaceId),
-            eq17(sessionTurnAttempts.sessionId, sessionId),
-            eq17(sessionTurnAttempts.id, predecessorAttemptId)
-          )
-        ).limit(1);
-        if (!predecessor) {
-          throw new SessionControlInvariantError(
-            `Queued Steer ${id} points to missing predecessor attempt ${predecessorAttemptId}`
-          );
-        }
-        if (!predecessor.quiescedAt) {
-          return { action: "unclaimed", reason: "control-pending" };
-        }
-      }
       const now = /* @__PURE__ */ new Date();
       const queuedDispatch = readTurnDispatchMetadata(queuedTurn?.metadata);
       if (queuedDispatch.kind === "malformed") {
@@ -36747,6 +36766,14 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
             interruptions.map((interruption) => interruption.id)
           )
         );
+        await enqueueSessionWorkflowWakeInTransaction(tx, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId,
+          temporalWorkflowId: session.temporalWorkflowId ?? `session-${sessionId}`,
+          reason: "attempt_interruption_rejected_stale",
+          controlRequested: true
+        });
         return {
           action: effectiveControl.state === "paused" ? "paused" : "continue",
           events: [],
@@ -36897,6 +36924,14 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
           interruptions.map((interruption) => interruption.id)
         )
       );
+      await enqueueSessionWorkflowWakeInTransaction(tx, {
+        accountId: session.accountId,
+        workspaceId,
+        sessionId,
+        temporalWorkflowId: session.temporalWorkflowId ?? `session-${sessionId}`,
+        reason: "attempt_interruption_settled",
+        controlRequested: true
+      });
       return {
         action: effectiveControl.state === "paused" ? "paused" : "continue",
         events: [...closedTools.events, ...eventRows.map(mapEvent2)],
@@ -36907,6 +36942,30 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
     })
   );
 }
+async function nextSessionAttemptAwaitingQuiescence(db, workspaceId, sessionId) {
+  const [row] = await db.select({
+    attemptId: sessionTurnAttempts.id
+  }).from(sessionTurnAttempts).innerJoin(
+    sessionAttemptInterruptions,
+    and17(
+      eq17(sessionAttemptInterruptions.workspaceId, sessionTurnAttempts.workspaceId),
+      eq17(sessionAttemptInterruptions.sessionId, sessionTurnAttempts.sessionId),
+      eq17(sessionAttemptInterruptions.attemptId, sessionTurnAttempts.id)
+    )
+  ).where(
+    and17(
+      eq17(sessionTurnAttempts.workspaceId, workspaceId),
+      eq17(sessionTurnAttempts.sessionId, sessionId),
+      eq17(sessionTurnAttempts.state, "closed"),
+      isNull6(sessionTurnAttempts.quiescedAt),
+      inArray11(sessionAttemptInterruptions.state, ["settled", "rejected_stale"])
+    )
+  ).orderBy(
+    asc8(sessionAttemptInterruptions.requestedAt),
+    asc8(sessionAttemptInterruptions.id)
+  ).limit(1);
+  return row ?? null;
+}
 async function latestSessionAttemptInterruption(db, workspaceId, sessionId) {
   const [latestAttempt] = await db.select({
     attemptId: sessionTurnAttempts.id,
@@ -36933,6 +36992,32 @@ async function latestSessionAttemptInterruption(db, workspaceId, sessionId) {
     interruptionState: interruption.state
   } : null;
 }
+async function queuedSteerHasUnquiescedPredecessor(db, workspaceId, sessionId, predecessorAttemptIds) {
+  if (predecessorAttemptIds.length === 0) return false;
+  const [row] = await db.select({ attemptId: sessionTurnAttempts.id }).from(sessionTurnAttempts).innerJoin(
+    sessionAttemptInterruptions,
+    and17(
+      eq17(sessionAttemptInterruptions.workspaceId, sessionTurnAttempts.workspaceId),
+      eq17(sessionAttemptInterruptions.sessionId, sessionTurnAttempts.sessionId),
+      eq17(sessionAttemptInterruptions.attemptId, sessionTurnAttempts.id)
+    )
+  ).where(
+    and17(
+      eq17(sessionTurnAttempts.workspaceId, workspaceId),
+      eq17(sessionTurnAttempts.sessionId, sessionId),
+      inArray11(sessionTurnAttempts.id, predecessorAttemptIds),
+      isNull6(sessionTurnAttempts.quiescedAt),
+      inArray11(sessionAttemptInterruptions.state, [
+        "pending",
+        "delivered",
+        "acknowledged",
+        "settled",
+        "rejected_stale"
+      ])
+    )
+  ).limit(1);
+  return row !== void 0;
+}
 async function peekSessionWork(db, workspaceId, sessionId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const effectiveControl = await evaluateSessionControl(scopedDb, workspaceId, sessionId, {
@@ -36961,15 +37046,15 @@ async function peekSessionWork(db, workspaceId, sessionId) {
       };
     }
     if (effectiveControl.state !== "active") return { kind: "idle" };
-    const latestInterruption = await latestSessionAttemptInterruption(
+    const awaitingQuiescence = await nextSessionAttemptAwaitingQuiescence(
       scopedDb,
       workspaceId,
       sessionId
     );
-    if (latestInterruption && latestInterruption.quiescedAt === null && latestInterruption.interruptionState === "settled") {
+    if (awaitingQuiescence) {
       return {
         kind: "cancellation-wait",
-        attemptId: latestInterruption.attemptId
+        attemptId: awaitingQuiescence.attemptId
       };
     }
     const [capacityWait] = await scopedDb.select().from(codexCapacityWaiters).where(
@@ -38296,7 +38381,19 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         { workspaceControl: locks.control ?? void 0 }
       );
       const turnStatus = turn?.status ?? null;
-      if (!locks.workspace || !turn || !attempt || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId || attempt.accountId !== session.accountId || attempt.sessionId !== input.sessionId || attempt.turnId !== input.turnId || attempt.executionGeneration !== turn.executionGeneration || effectiveControl.state !== "active" || session.activeTurnId !== input.turnId || !fromStatuses.includes(turnStatus) || turn.activeAttemptId !== input.attemptId) {
+      const [pendingInterruption] = attempt ? await tx.select({ id: sessionAttemptInterruptions.id }).from(sessionAttemptInterruptions).where(
+        and17(
+          eq17(sessionAttemptInterruptions.workspaceId, workspaceId),
+          eq17(sessionAttemptInterruptions.sessionId, input.sessionId),
+          eq17(sessionAttemptInterruptions.attemptId, input.attemptId),
+          inArray11(sessionAttemptInterruptions.state, [
+            "pending",
+            "delivered",
+            "acknowledged"
+          ])
+        )
+      ).limit(1).for("update") : [];
+      if (!locks.workspace || !turn || !attempt || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId || attempt.accountId !== session.accountId || attempt.sessionId !== input.sessionId || attempt.turnId !== input.turnId || attempt.executionGeneration !== turn.executionGeneration || effectiveControl.state !== "active" || session.activeTurnId !== input.turnId || !fromStatuses.includes(turnStatus) || turn.activeAttemptId !== input.attemptId || pendingInterruption !== void 0) {
         return {
           action: "stale",
           events: [],
@@ -38305,6 +38402,9 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         };
       }
       const now = /* @__PURE__ */ new Date();
+      if (input.providerRecoveryCount !== void 0 && (!Number.isSafeInteger(input.providerRecoveryCount) || input.providerRecoveryCount <= 0)) {
+        throw new Error("providerRecoveryCount must be a positive safe integer");
+      }
       let providerArtifactsInvalidated = 0;
       if (input.providerArtifactInvalidation) {
         const invalidatedHistory = await tx.update(sessionHistoryItems).set({
@@ -38422,7 +38522,10 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         cancelledBy: null,
         cancelReason: null,
         version: turn.version + 1,
-        metadata: metadataWithoutTurnDispatchAttempt(turn.metadata),
+        metadata: {
+          ...metadataWithoutTurnDispatchAttempt(turn.metadata),
+          ...input.providerRecoveryCount !== void 0 ? { providerRecoveryCount: input.providerRecoveryCount } : {}
+        },
         updatedAt: now
       }).where(
         and17(
@@ -38851,12 +38954,19 @@ async function getSessionQueueSnapshot(db, workspaceId, sessionId) {
       asc8(sessionSystemUpdates.createdAt),
       asc8(sessionSystemUpdates.id)
     );
+    const items = rows.map(mapSessionTurn);
     const latestInterruption = await latestSessionAttemptInterruption(
       scopedDb,
       workspaceId,
       sessionId
     );
-    const items = rows.map(mapSessionTurn);
+    const queuedSteerPredecessorIds = items.map((turn) => queuedSteerReplacementAttemptId(turn.metadata)).filter((attemptId) => attemptId !== null);
+    const stoppingPreviousAttempt = latestInterruption !== null && latestInterruption.interruptionState !== "rejected_stale" && latestInterruption.quiescedAt === null || await queuedSteerHasUnquiescedPredecessor(
+      scopedDb,
+      workspaceId,
+      sessionId,
+      queuedSteerPredecessorIds
+    );
     const nextInputBatch = selectBoundedSystemUpdateBatch(pendingInputs);
     const hasPendingAgentSteer = pendingInputs.some(
       (update) => update.kind === "agent_steer_instruction"
@@ -38866,7 +38976,7 @@ async function getSessionQueueSnapshot(db, workspaceId, sessionId) {
       version: session.queueVersion,
       effectiveControl: serializeEffectiveSessionControl(effectiveControl),
       activePersonalConnections,
-      stoppingPreviousAttempt: latestInterruption !== null && latestInterruption.interruptionState !== "rejected_stale" && latestInterruption.quiescedAt === null,
+      stoppingPreviousAttempt,
       items,
       pendingInputs: pendingInputs.map((update) => {
         const canonical = mapSessionSystemUpdate(update);
@@ -38895,7 +39005,7 @@ function queuedSteerReplacementAttemptId(metadata) {
   if (typeof attemptId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(attemptId) && typeof interruptionCount === "number" && Number.isSafeInteger(interruptionCount) && interruptionCount > 0) {
     return attemptId;
   }
-  throw new SessionControlInvariantError("Queued Steer has malformed predecessor metadata");
+  return null;
 }
 async function enqueueFailedChildOutboxForTurnTx(tx, workspaceId, session, turn) {
   if (!session.parentSessionId) return;
@@ -39016,6 +39126,7 @@ async function enqueueSessionWorkflowWakeInTransaction(tx, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: input.temporalWorkflowId,
+    controlRevision: input.controlRequested ? 1 : 0,
     reason: input.reason,
     nextAttemptAt
   }).onConflictDoUpdate({
@@ -39023,6 +39134,7 @@ async function enqueueSessionWorkflowWakeInTransaction(tx, input) {
     set: {
       temporalWorkflowId: input.temporalWorkflowId,
       wakeRevision: sql14`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      controlRevision: input.controlRequested ? sql14`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql14`${sessionWorkflowWakeOutbox.controlRevision}`,
       reason: input.reason,
       attempts: 0,
       // Coalescing a delayed retry must never postpone an already-due wake
@@ -40148,6 +40260,7 @@ function mapSession(row, effectiveControl, mcpServers = [], pin = mapSessionPin(
     // the fence exact even if the column type ever drifts (the lease-epoch lesson).
     activeSandboxId: row.activeSandboxId ?? null,
     activeEpoch: Number(row.activeEpoch),
+    workingDir: row.workingDir ?? null,
     variableSetId: row.variableSetId,
     environmentId: row.variableSetId,
     // The rig + frozen rig version the session rides (M3). Both null for a
@@ -41528,6 +41641,7 @@ export {
   reopenSlackInteractionDelivery,
   replaceExpiredWorkspaceArchiveCapture,
   replaceIntegrationOAuthClient,
+  replaceIntegrationOAuthClientIfCurrent,
   requestDueSandboxRotationsGlobal,
   requestSessionCompaction,
   requestSessionTurnRecovery,
@@ -41682,6 +41796,7 @@ export {
   withCodexCapacityMutation,
   withCodexCredentialRefreshLock,
   withCodexTokenDeadline,
+  withDatabaseStatementTimeout,
   withRlsContext,
   withWorkspaceRls,
   withWorkspaceSubjectRls,