@opengeni/worker-bundle 2.3.1-canary.37073905159001 → 2.3.1

package/dist/activities/agent-turn/claude-usage-observer.d.ts

@@ -1,17 +1,6 @@
 import { type parseModelProvidersJson, type ClaudeUsageObservation } from "@opengeni/config";
 type Scope = "workspace" | "organization";
-type ClaudeRequestCredential = {
-    token: string;
-    connectionId: string;
-    credentialVersion: number;
-};
-export declare class ClaudeSubscriptionConnectionUnavailable extends Error {
-    readonly status = 409;
-    readonly code = "claude_subscription_connection_changed";
-    constructor();
-}
 export type CapturedClaudeUsage = {
-    scope: Scope;
     token: string;
     expectedConnectionId: string;
     expectedCredentialVersion: number;
@@ -22,29 +11,16 @@ export type CapturedClaudeUsage = {
     };
 };
 /** Capture the exact credential before requests; replacement fences late responses. */
-export declare function createClaudeUsageObserver(providers: ReturnType<typeof parseModelProvidersJson>, latest: Map<string, CapturedClaudeUsage>, readCredential: (scope: Scope) => Promise<{
+export declare function createClaudeUsageObserver(providers: ReturnType<typeof parseModelProvidersJson>, latest: Map<Scope, CapturedClaudeUsage>, readCredential: (scope: Scope) => Promise<{
     token: string;
     connectionId: string;
     credentialVersion: number;
-} | null>): Promise<((providerId: string, response: Response, upstreamModelId?: string, requestToken?: string | null) => void) & {
-    prepareRequestWithObserver: (providerId: string, headers: Headers, resolve: (binding: {
-        scope: Scope;
-        expectedConnectionId: string;
-        expectedCredentialVersion: number;
-    }) => Promise<ClaudeRequestCredential | null>) => Promise<{
-        headers: Headers;
-        observe: (providerId: string, response: Response, upstreamModelId?: string, requestToken?: string | null) => void;
-    }>;
-    prepareRequest(providerId: string, headers: Headers, resolve: (binding: {
-        scope: Scope;
-        expectedConnectionId: string;
-        expectedCredentialVersion: number;
-    }) => Promise<ClaudeRequestCredential | null>): Promise<Headers>;
+} | null>): Promise<((providerId: string, response: Response) => void) & {
     binding(providerId: string): {
-        scope: Scope;
-        token: string;
-        expectedConnectionId: string;
-        expectedCredentialVersion: number;
+        readonly scope: Scope;
+        readonly token: string;
+        readonly expectedConnectionId: string;
+        readonly expectedCredentialVersion: number;
     } | undefined;
     renew(providerId: string, credential: {
         token: string;

package/dist/activities/agent-turn/credential-leases.d.ts

@@ -1,6 +1,6 @@
 import type { SharedActivityServices } from "../types.js";
-import { SubscriptionTurnLease, type LeaseRenewReason, type LeaseLossReason } from "./subscription-lease.js";
-export type { LeaseRenewReason, LeaseLossReason } from "./subscription-lease.js";
+export type LeaseRenewReason = "timer" | "runtime_event" | "model_usage";
+export type LeaseLossReason = "deadline" | "not_found";
 export declare class CodexCredentialLeaseLostError extends Error {
     readonly reason: LeaseLossReason;
     readonly code = "codex_credential_lease_lost";
@@ -19,13 +19,40 @@ export type TurnCredentialLeaseDeps = {
  * cross-replica fairness primitive; the heartbeat here only extends its short
  * TTL. A killed worker stops heartbeating and the holder self-expires.
  */
-export declare class CodexTurnLease extends SubscriptionTurnLease {
+export declare class CodexTurnLease {
+    private readonly deps;
+    held: boolean;
+    lost: boolean;
+    lossReason: LeaseLossReason | null;
+    holderId: string | null;
+    generation: number | null;
+    confirmedUntilMs: number | null;
+    private heartbeatInFlight;
+    private heartbeatTimer;
     constructor(deps: TurnCredentialLeaseDeps);
+    markLost: (reason: LeaseLossReason) => void;
+    /** Fail closed at the last worker-confirmed lease deadline before dispatch. */
+    assertUsable: () => void;
+    renew: (reason: LeaseRenewReason) => Promise<void>;
+    startHeartbeat: () => void;
+    stopHeartbeat: () => void;
 }
-/** SuperGrok uses the same deadline and holder fences as Codex. */
-export declare class XaiTurnLease extends SubscriptionTurnLease {
+/** The xAI/SuperGrok credential holder for one running turn; same shape. */
+export declare class XaiTurnLease {
+    private readonly deps;
+    held: boolean;
+    lost: boolean;
     subjectId: string | null;
+    holderId: string | null;
+    generation: number | null;
+    confirmedUntilMs: number | null;
+    private heartbeatInFlight;
+    private heartbeatTimer;
     constructor(deps: TurnCredentialLeaseDeps);
+    markLost: (reason: LeaseLossReason) => void;
+    renew: () => Promise<void>;
+    startHeartbeat: () => void;
+    stopHeartbeat: () => void;
 }
 /** Both serving-credential leases for one turn attempt plus their composite views. */
 export type TurnCredentialLeases = {

package/dist/activities/agent-turn/errors.d.ts

@@ -90,7 +90,6 @@ export declare function postClaimDatabaseRecoveryFailure(input: {
     triggerEventId: string;
     executionGeneration: number;
     sandboxSetupOutcomeUnknown?: true;
-    sandboxSetupRecoveryExhausted?: true;
     providerRecovery?: {
         failureCode: string;
         providerRecoveryCount: number;
@@ -267,8 +266,6 @@ export declare function classifyXaiCredentialFailure(error: unknown): XaiCredent
 export declare function agentRunFailurePayload(error: unknown, options?: {
     isCodexTurn?: boolean;
 }): ReturnType<typeof baseAgentRunFailurePayload>;
-/** Keep Anthropic provider text on terminal failures, never recovery events. */
-export declare function agentRunRecoveryFailurePayload(error: unknown, failure: ReturnType<typeof agentRunFailurePayload>): ReturnType<typeof agentRunFailurePayload>;
 declare function baseAgentRunFailurePayload(error: unknown, options?: {
     isCodexTurn?: boolean;
 }): {

package/dist/activities/agent-turn/finalization-monitor.d.ts

@@ -8,7 +8,7 @@ export declare function startTurnFinalizationMonitor(input: {
     observability: Observability;
     details: TurnHeartbeatDetails;
     heartbeat: (details: TurnHeartbeatDetails) => void;
-    requestWorkerDrain: () => void;
+    terminateWorker: () => void;
     timeoutMs?: number;
     slowAfterMs?: number;
 }): {

package/dist/activities/agent-turn/finalization.d.ts

@@ -16,8 +16,6 @@ export type TurnFinalizationDeps = {
     wakeSessionWorkflow: ActivityServices["wakeSessionWorkflow"];
     signalSessionAttemptQuiesced: ActivityServices["signalSessionAttemptQuiesced"];
     signalCodexCapacityWorkflow: ActivityServices["signalCodexCapacityWorkflow"];
-    requestWorkerDrain: ActivityServices["requestWorkerDrain"];
-    turnFinalizationTimeoutMs: ActivityServices["turnFinalizationTimeoutMs"];
     cancellationSignal: AbortSignal | undefined;
     sandboxResumeController: AbortController;
     activityContext: ReturnType<typeof currentActivityContext>;

package/dist/activities/agent-turn/quiescence.d.ts

@@ -49,9 +49,10 @@ export declare const QUIESCENCE_PROOF_SIGNAL_INITIAL_RETRY_MS = 250;
 export declare const QUIESCENCE_PROOF_SIGNAL_MAX_RETRY_MS = 5000;
 export declare const TURN_QUIESCENCE_WATCHDOG_MS: number;
 export declare const TURN_FINALIZER_STEP_TIMEOUT_MS = 30000;
-/** A fenced activity must never heartbeat forever while physical cleanup is
- * stuck. The callback requests host-owned containment, which drains peer turns
- * before applying its final exit policy. A timeout is never quiescence proof. */
+/** A fenced activity must never heartbeat forever while its physical writer
+ * drain is stuck. The last-resort worker exit stops every in-process writer;
+ * Kubernetes replaces the pod and the workflow's heartbeat-lease reconciler
+ * then commits the exact quiescence receipt. */
 export declare function armTurnQuiescenceWatchdog(input: {
     enabled: boolean;
     timeoutMs?: number;

package/dist/activities/agent-turn/turn-context.d.ts

@@ -146,7 +146,7 @@ export type ProviderTurnState = {
     xaiCredentialQuarantined: boolean;
     priorSessionCodexCredentialId: string | null;
     latestCodexUsage: CodexUsageHeaderSnapshot | null;
-    latestClaudeUsage: Map<string, import("./claude-usage-observer.js").CapturedClaudeUsage>;
+    latestClaudeUsage: Map<"workspace" | "organization", import("./claude-usage-observer.js").CapturedClaudeUsage>;
     lastCodexRequestOpaqueArtifacts: readonly string[];
 };
 export type TurnContext = {

package/dist/activities/session-state.d.ts

@@ -53,8 +53,8 @@ export declare function createSessionStateActivities(services: () => Promise<Con
         admissionFence?: import("@opengeni/db").SessionAdmissionFence;
     } | {
         kind: "admission-blocked";
-        reason?: "sandbox_setup_outcome_unknown" | "sandbox_setup_recovery_exhausted";
-        ref?: import("@opengeni/db").SandboxSetupOutcomeUnknown | import("@opengeni/db").SandboxSetupRecoveryExhausted;
+        reason?: "sandbox_setup_outcome_unknown";
+        ref?: import("@opengeni/db").SandboxSetupOutcomeUnknown;
     } | {
         kind: "sandbox-lifecycle-wait";
         ref: import("@opengeni/db").SandboxLifecycleWait;

package/dist/activities/types.d.ts

@@ -87,11 +87,6 @@ export type SharedActivityServices = {
 export type ControlActivityServices = SharedActivityServices;
 /** Turn workers own the model loop and never construct document parsers. */
 export type TurnActivityServices = SharedActivityServices & {
-    /** Host-owned containment: stop polling and checkpoint peer turns before exit.
-     * Bare activity embedders must provide their own worker lifecycle edge. */
-    requestWorkerDrain: () => void;
-    /** Deterministic test clock for the cleanup-only monitor. */
-    turnFinalizationTimeoutMs?: number | undefined;
     runtime: OpenGeniRuntime;
     /** Provider-free test/profiling seam; production injects the real runtime summarizer. */
     summarizeContextForCompaction: typeof import("@opengeni/runtime").summarizeForCompaction;
@@ -242,8 +237,6 @@ export type PostClaimDatabaseRecoveryDetail = {
     providerFailureCode?: string;
     /** Persist the no-replay setup marker, not a new provider/setup attempt. */
     sandboxSetupOutcomeUnknown?: true;
-    /** Preserve the exhausted budget for a command proven not dispatched. */
-    sandboxSetupRecoveryExhausted?: true;
 };
 export declare const POST_CLAIM_DATABASE_RECOVERY_FAILURE_TYPE = "OpenGeniPostClaimDatabaseRecovery";
 export declare const POST_CLAIM_DATABASE_RECOVERY_FAILURE_MESSAGE = "Agent turn database recovery required after attempt claim.";

package/dist/{activities-control-TTGQGLCJ.js → activities-control-3HAH4FMG.js}

@@ -24,7 +24,6 @@ import {
   notifyParentOfChildIdle,
   persistWorkspaceArchiveCandidate,
   providerRecoveryCountFromMetadata,
-  publishDurableSessionEvents,
   putVersion1TarArchiveOrInline,
   reconcileAutomaticSessionTitleFanout,
   reconcilePendingParentSystemUpdates,
@@ -35,7 +34,7 @@ import {
   warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-PA7Z55P4.js";
+} from "./chunk-3K3ULWEE.js";
 import {
   inspectOpenSandboxKubernetesInventory,
   recordActiveUserGauges,
@@ -48,7 +47,6 @@ import {
   recordRetainedProcessReconciliation,
   recordSandboxCheckpointArtifactGauges,
   recordSandboxCheckpointArtifactOutcome,
-  recordSandboxCommandContainment,
   recordSandboxDeadlineRotationsRequested,
   recordSandboxInventoryProjectionFailure,
   recordSandboxInventoryProjectionSuccess,
@@ -62,7 +60,7 @@ import {
   recordVerifiedSignupTrialSwitchGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-YOI3Z3GF.js";
+} from "./chunk-YG27NEMX.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
@@ -2723,7 +2721,6 @@ import {
   workspaceArchiveCaptureDeadlineElapsed,
   retainedProcessReconciliationProof,
   retainedProcessSettlementIdentity,
-  recoverManagedSessionBackgroundCommand,
   settleClaimedConnectedMachineBackgroundCommand,
   settleSandboxCheckpointArtifactGc,
   rlsContextForWorkspace,
@@ -2890,18 +2887,14 @@ function createSandboxLeaseActivities(services, options = {}) {
     try {
       const { db, settings, observability } = await services();
       const timing = sandboxDrainTiming(settings);
-      const commandContainment = {
-        idleCommandContainmentMs: settings.sandboxIdleCommandContainmentMs,
-        onCommandContainment: (outcome) => recordSandboxCommandContainment(observability, outcome),
-        onCommandContainmentError: (error) => {
-          observability.warn("sandbox reaper: retained command containment inspection failed", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
+      const onUnobservableCommandDrainError = (error) => {
+        observability.warn("sandbox reaper: unobservable command drain inspection failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       };
       if (!settings.sandboxOwnershipEnabled) {
         const drainableInventory2 = await reapStaleLeaseHoldersGlobal(db, {
-          ...commandContainment,
+          onUnobservableCommandDrainError,
           viewerHolderTtlMs: settings.sandboxViewerHolderTtlMs,
           turnHolderTtlMs: settings.sandboxLeaseTtlMs,
           interactionHolderTtlMs: settings.sandboxInteractionHolderTtlMs,
@@ -2928,7 +2921,7 @@ function createSandboxLeaseActivities(services, options = {}) {
       });
       recordSandboxDeadlineRotationsRequested(observability, rotationsRequested);
       const drainableInventory = await reapStaleLeaseHoldersGlobal(db, {
-        ...commandContainment,
+        onUnobservableCommandDrainError,
         viewerHolderTtlMs: settings.sandboxViewerHolderTtlMs,
         // Dead-worker turn holders: a live holder is touched every 10s from the
         // moment it is registered (resumeBoxForTurn's holder-liveness loop covers
@@ -2969,7 +2962,7 @@ function createSandboxLeaseActivities(services, options = {}) {
       instanceId: input.target.instanceId
     });
     try {
-      const { db, settings, observability, objectStorage, bus } = await services();
+      const { db, settings, observability, objectStorage } = await services();
       assertSandboxDrainInputTiming(input);
       const drainSettings = settings.sandboxSnapshotTimeoutMs === input.snapshotTimeoutMs ? settings : { ...settings, sandboxSnapshotTimeoutMs: input.snapshotTimeoutMs };
       const row = input.target;
@@ -2989,8 +2982,7 @@ function createSandboxLeaseActivities(services, options = {}) {
           terminateBox,
           probeDrainableProvider,
           captureAttempt,
-          objectStorage,
-          bus
+          objectStorage
         );
         return { status: drainedCold ? "terminated" : "skipped" };
       } catch (error) {
@@ -3625,24 +3617,6 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
       sessionId: process.sessionId,
       processId: process.id
     };
-    if (process.ownerActorKind === "turn" && process.providerBackend === "modal" && !proof && !claim.ownerState.startsWith("background_")) {
-      try {
-        const command = await recoverManagedSessionBackgroundCommand(db, {
-          ...processScope,
-          expected,
-          reconciliationClaimId: claim.claimId
-        });
-        if (command) {
-          claim.ownerState = `background_${command.state}`;
-          recordRetainedProcessReconciliation(observability, "background_recovered");
-        }
-      } catch (error) {
-        observability.warn("sandbox reaper: retained-command background recovery failed", {
-          processId: process.id,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
     const storedCommandPersistence = retainedProviderCommandPersistence(
       db,
       processScope,
@@ -4634,7 +4608,7 @@ function sandboxDrainReason(lease) {
   if (lease.rotationRequestedAt === null) return "idle";
   return lease.rotationReason ?? "rotation_requested";
 }
-async function terminateDrainableBox(db, settings, row, observability, terminateBox, probeDrainableProvider, attempt, objectStorage, bus = null) {
+async function terminateDrainableBox(db, settings, row, observability, terminateBox, probeDrainableProvider, attempt, objectStorage) {
   const { accountId } = await rlsContextForWorkspace(db, row.workspaceId);
   const lease = await readLease2(db, row.workspaceId, row.sandboxGroupId);
   if (!lease) {
@@ -4948,31 +4922,18 @@ async function terminateDrainableBox(db, settings, row, observability, terminate
     }
   }
   const providerMissing = providerMissingBeforeCapture || (typeof termination === "boolean" ? false : termination.providerMissingBeforeCapture);
-  const { wentCold, backgroundCommandEvents } = await confirmDrainCold(db, {
+  const { wentCold } = await confirmDrainCold(db, {
     accountId,
     workspaceId: row.workspaceId,
     sandboxGroupId: row.sandboxGroupId,
     expectedEpoch: row.leaseEpoch,
     ...captureClaim ? { expectedCaptureId: captureClaim.id } : {},
-    providerMissingBeforeCapture: providerMissing,
-    idleCommandContainmentMs: settings.sandboxIdleCommandContainmentMs
-  });
-  await publishDurableSessionEvents(bus, row.workspaceId, backgroundCommandEvents, (error) => {
-    observability.warn("sandbox reaper: contained command event fanout failed", {
-      sandboxGroupId: row.sandboxGroupId,
-      error: error instanceof Error ? error.message : String(error)
-    });
+    providerMissingBeforeCapture: providerMissing
   });
   if (wentCold) {
     if (providerMissing) {
       recordSandboxProviderMissingBeforeCapture(observability, backend);
     }
-    if (lease.unobservableCommandDrainIds?.length) {
-      recordSandboxCommandContainment(
-        observability,
-        providerMissing ? "provider_missing" : "contained"
-      );
-    }
     try {
       await appendSessionEventToSandboxGroup(db, row.workspaceId, row.sandboxGroupId, {
         type: "sandbox.box.terminated",
@@ -5356,7 +5317,7 @@ import {
   upsertScheduledSessionGoalForRun,
   withSessionActivityRlsContext
 } from "@opengeni/db";
-import { publishDurableSessionEvents as publishDurableSessionEvents2 } from "@opengeni/events";
+import { publishDurableSessionEvents } from "@opengeni/events";
 import {
   allowedFirstPartyMcpToolsForSession,
   resolveFirstPartyMcpToolPolicy,
@@ -6497,7 +6458,7 @@ function createScheduledTaskActivities(services) {
                     events: started.events
                   });
                 } else {
-                  await publishDurableSessionEvents2(
+                  await publishDurableSessionEvents(
                     bus,
                     task.workspaceId,
                     session.id,
@@ -6540,7 +6501,7 @@ function createScheduledTaskActivities(services) {
                 if (deferPublications) {
                   deferredEvents.push({ sessionId: session.id, events: started.events });
                 } else {
-                  await publishDurableSessionEvents2(
+                  await publishDurableSessionEvents(
                     bus,
                     task.workspaceId,
                     session.id,
@@ -6569,7 +6530,7 @@ function createScheduledTaskActivities(services) {
               if (deferPublications) {
                 deferredEvents.push({ sessionId: session.id, events: titleEvents });
               } else {
-                await publishDurableSessionEvents2(bus, task.workspaceId, session.id, titleEvents);
+                await publishDurableSessionEvents(bus, task.workspaceId, session.id, titleEvents);
               }
             }
             const scheduledUpdate = await addSessionSystemUpdateWithSourceMutation(
@@ -6656,7 +6617,7 @@ function createScheduledTaskActivities(services) {
                   events: scheduledUpdate.events
                 });
               } else {
-                await publishDurableSessionEvents2(
+                await publishDurableSessionEvents(
                   bus,
                   task.workspaceId,
                   session.id,
@@ -6783,7 +6744,7 @@ function createScheduledTaskActivities(services) {
                   events: bundled.events
                 });
               } else {
-                await publishDurableSessionEvents2(
+                await publishDurableSessionEvents(
                   bus,
                   task.workspaceId,
                   session.id,
@@ -6865,7 +6826,7 @@ function createScheduledTaskActivities(services) {
         });
       }
       for (const deferred of deferredEvents) {
-        await publishDurableSessionEvents2(
+        await publishDurableSessionEvents(
           bus,
           task.workspaceId,
           deferred.sessionId,
@@ -7097,7 +7058,7 @@ async function seedScheduledGeneratedSessionRoute(input) {
     if (input.deferPublications) {
       input.deferredEvents.push({ sessionId: input.session.id, events: failed.events });
     } else {
-      await publishDurableSessionEvents2(
+      await publishDurableSessionEvents(
         input.bus,
         input.task.workspaceId,
         input.session.id,
@@ -7367,7 +7328,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
     });
     workflowId = started.temporalWorkflowId;
     if (started.events.length > 0) {
-      await publishDurableSessionEvents2(input.bus, task.workspaceId, session.id, started.events);
+      await publishDurableSessionEvents(input.bus, task.workspaceId, session.id, started.events);
     }
     if (task.runMode === "reusable_session") {
       await materializeScheduledTaskReusableSessionFromRun(input.db, {
@@ -7386,7 +7347,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
       taskName: task.name
     });
     if (titleEvents.length > 0) {
-      await publishDurableSessionEvents2(input.bus, task.workspaceId, session.id, titleEvents);
+      await publishDurableSessionEvents(input.bus, task.workspaceId, session.id, titleEvents);
     }
   }
   const scheduledUpdate = await addSessionSystemUpdateWithSourceMutation(
@@ -7479,7 +7440,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
     recordUserMessageAccepted(input.observability, { surface: "scheduled" });
   }
   if (scheduledUpdate.added && scheduledUpdate.events.length > 0) {
-    await publishDurableSessionEvents2(
+    await publishDurableSessionEvents(
       input.bus,
       task.workspaceId,
       session.id,
@@ -7835,10 +7796,9 @@ import {
   expireSessionHumanInputRequest,
   markSessionAttemptQuiesced,
   requireSession as requireSession2,
-  settleSessionIdleWithParentOutbox,
-  SANDBOX_SETUP_RECOVERY_LIMIT
+  settleSessionIdleWithParentOutbox
 } from "@opengeni/db";
-import { publishDurableSessionEvents as publishDurableSessionEvents3 } from "@opengeni/events";
+import { publishDurableSessionEvents as publishDurableSessionEvents2 } from "@opengeni/events";
 import { CancelledFailure } from "@temporalio/activity";
 var WORKER_DEATH_MAX_REDISPATCHES = 3;
 function createSessionStateActivities(services, overrides = {}) {
@@ -7862,7 +7822,7 @@ function createSessionStateActivities(services, overrides = {}) {
   const requireSessionFn = overrides.requireSession ?? requireSession2;
   const settleSessionIdleWithParentOutboxFn = overrides.settleSessionIdleWithParentOutbox ?? settleSessionIdleWithParentOutbox;
   const markSessionAttemptQuiescedFn = overrides.markSessionAttemptQuiesced ?? markSessionAttemptQuiesced;
-  const publishDurableSessionEventsFn = overrides.publishDurableSessionEvents ?? publishDurableSessionEvents3;
+  const publishDurableSessionEventsFn = overrides.publishDurableSessionEvents ?? publishDurableSessionEvents2;
   const deliverFailedChildTurnToParentFn = overrides.deliverFailedChildTurnToParent ?? deliverFailedChildTurnToParent;
   const notifyParentOfChildIdleFn = overrides.notifyParentOfChildIdle ?? notifyParentOfChildIdle;
   const recordTurnsQueuedGaugeFn = overrides.recordTurnsQueuedGauge ?? recordTurnsQueuedGauge;
@@ -7951,16 +7911,12 @@ function createSessionStateActivities(services, overrides = {}) {
     const postClaimIdentityMatches = Boolean(
       postClaimRecovery && turn.id === postClaimRecovery.turnId && turn.triggerEventId === postClaimRecovery.triggerEventId && turn.executionGeneration === postClaimRecovery.executionGeneration
     );
-    if (postClaimRecovery?.sandboxSetupRecoveryExhausted && !postClaimIdentityMatches) {
-      return { action: "stale" };
-    }
     const providerRecoveryCount = postClaimIdentityMatches ? postClaimRecovery?.providerRecoveryCount : void 0;
     const providerFailureCode = postClaimIdentityMatches ? postClaimRecovery?.providerFailureCode : void 0;
     const hasProviderRecoveryCount = providerRecoveryCount !== void 0;
     const hasProviderFailureCode = providerFailureCode !== void 0;
     const setupOutcomeUnknown = postClaimIdentityMatches && postClaimRecovery?.sandboxSetupOutcomeUnknown === true;
-    const setupRecoveryExhausted = postClaimIdentityMatches && postClaimRecovery?.sandboxSetupRecoveryExhausted === true;
-    if (setupOutcomeUnknown && setupRecoveryExhausted || (setupOutcomeUnknown || setupRecoveryExhausted) && (hasProviderRecoveryCount || hasProviderFailureCode) || setupRecoveryExhausted && turn.metadata?.providerRecoveryCount !== SANDBOX_SETUP_RECOVERY_LIMIT) {
+    if (setupOutcomeUnknown && (hasProviderRecoveryCount || hasProviderFailureCode)) {
       return { action: "stale" };
     }
     if (hasProviderRecoveryCount !== hasProviderFailureCode) {
@@ -7976,20 +7932,13 @@ function createSessionStateActivities(services, overrides = {}) {
         turnId: turn.id,
         triggerEventId: turn.triggerEventId,
         attemptId: input.attemptId,
-        reason: setupOutcomeUnknown ? "sandbox_command_start_outcome_unknown" : setupRecoveryExhausted ? "sandbox_command_start_recovery_exhausted" : providerFailureCode ?? "claimed_attempt_database_failure",
+        reason: setupOutcomeUnknown ? "sandbox_command_start_outcome_unknown" : providerFailureCode ?? "claimed_attempt_database_failure",
         ...setupOutcomeUnknown ? { sandboxSetupOutcomeUnknown: true } : {},
-        ...setupRecoveryExhausted ? { sandboxSetupRecoveryExhausted: true } : {},
         ...providerRecoveryCount !== void 0 ? { providerRecoveryCount } : {},
         detail: {
-          code: setupOutcomeUnknown ? "sandbox_command_start_outcome_unknown" : setupRecoveryExhausted ? "sandbox_command_start_recovery_exhausted" : providerFailureCode ?? recoveredClaimCode,
-          retryable: !setupOutcomeUnknown && !setupRecoveryExhausted,
+          code: setupOutcomeUnknown ? "sandbox_command_start_outcome_unknown" : providerFailureCode ?? recoveredClaimCode,
+          retryable: !setupOutcomeUnknown,
           ...setupOutcomeUnknown ? { setupOutcome: "unknown", replay: "blocked" } : {},
-          ...setupRecoveryExhausted ? {
-            setupOutcome: "not_started",
-            replay: "blocked",
-            recoveryExhausted: true,
-            providerRecoveryCount: SANDBOX_SETUP_RECOVERY_LIMIT
-          } : {},
           ...providerRecoveryCount !== void 0 ? {
             databaseFailureCode: recoveredClaimCode,
             providerRecoveryCount
@@ -8445,4 +8394,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-TTGQGLCJ.js.map
+//# sourceMappingURL=activities-control-3HAH4FMG.js.map