@opengeni/worker-bundle 2.2.0 → 2.2.1-canary.36919050519001

package/src/activities/open-suffix-resume.ts

@@ -2,6 +2,7 @@ import type { Agent } from "@openai/agents";
 import {
   OPEN_SUFFIX_RUN_STATE_BLOB,
   approvalIdentifier,
+  withPublicApprovalFields,
   type HumanInputResponse,
   type SessionEvent,
 } from "@opengeni/contracts";
@@ -380,7 +381,7 @@ export async function settleOpenSuffixResumeIfNeeded(input: {
         ? [
             {
               type: "session.requiresAction" as const,
-              payload: { approvals: requiresActionApprovals },
+              payload: { approvals: requiresActionApprovals.map(withPublicApprovalFields) },
             },
           ]
         : []),

package/src/activities/run-credentials.ts

@@ -5,6 +5,7 @@ import type {
   RunCredentialsRequest,
   Session,
   SessionTurn,
+  ToolRef,
 } from "@opengeni/contracts";
 import type { Settings } from "@opengeni/config";
 import { getSessionRootId, type Database } from "@opengeni/db";
@@ -30,6 +31,8 @@ export type RunCredentialResolutionContext = {
   initiatingHumanSubjectId?: string | null;
   /** Installed in-process API routes must never enter a product callback. */
   localMcpServerIds?: readonly string[];
+  /** Exact execution selection, resolved once at the turn policy boundary. */
+  effectiveTools: readonly ToolRef[];
 };
 
 export type BoundRunCredentialResolver = {
@@ -42,7 +45,7 @@ export type BoundRunCredentialResolver = {
 export function buildRunCredentialsRequest(
   input: Omit<
     RunCredentialResolutionContext,
-    "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId"
+    "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId" | "effectiveTools"
   > & {
     rootSessionId: string;
     purpose: "provision" | "renewal";
@@ -125,7 +128,7 @@ export async function bindRunCredentialResolver(
           mcpServers: selectedSessionRemoteMcpTargets(
             input.settings,
             input.session.mcpServers ?? [],
-            input.turn.tools ?? [],
+            input.effectiveTools,
             (input.localMcpServerIds ?? []).map((id) => ({ id })),
           ),
         },
@@ -146,22 +149,25 @@ export async function bindRunCredentialResolver(
     workspaceId: input.workspaceId,
     sessionId: input.session.id,
   };
+  // A renewable resolver belongs to one admitted turn, even if its caller
+  // subsequently replaces or mutates an in-memory session/turn projection.
+  const frozenRequest = structuredClone(
+    buildRunCredentialsRequest({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      session: input.session,
+      turn: input.turn,
+      attemptId: input.attemptId,
+      effectiveSandboxBackend: input.effectiveSandboxBackend,
+      variableSet: input.variableSet,
+      rootSessionId,
+      purpose: "provision",
+      forceRefresh: false,
+    }),
+  );
   return {
     resolve: async ({ purpose, forceRefresh }) => {
-      const resolution = await resolver(
-        buildRunCredentialsRequest({
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          session: input.session,
-          turn: input.turn,
-          attemptId: input.attemptId,
-          effectiveSandboxBackend: input.effectiveSandboxBackend,
-          variableSet: input.variableSet,
-          rootSessionId,
-          purpose,
-          forceRefresh,
-        }),
-      );
+      const resolution = await resolver({ ...frozenRequest, purpose, forceRefresh });
       return normalizeRunCredentialsResolution(resolution, scope);
     },
   };

package/src/activities/scheduled-tasks.ts

@@ -15,6 +15,8 @@ import {
   TurnExecutionPolicyV1,
   type ScheduledTask,
   type ScheduledTaskRun,
+  AgentConfigError,
+  type ResolvedAgentConfig,
 } from "@opengeni/contracts";
 import {
   openGeniSlackBotMetadata,
@@ -33,6 +35,9 @@ import {
   settingsWithEnabledCapabilityMcpServers,
   settingsWithSessionMcpServerMetadata,
   swapActiveSandbox,
+  agentConfigMayResolve,
+  applySessionAgentConfigWriteThrough,
+  resolveSessionAgentConfigForCreate,
 } from "@opengeni/core";
 import {
   appendSessionEvents,
@@ -62,6 +67,7 @@ import {
   getNestedAgentDepthDeploymentPolicy,
   getSessionByCreateIdempotencyKey,
   getSessionCreationExecutionPolicy,
+  metadataWithAgentConfigCreateIdentity,
   getVariableSet,
   isCodexBilledModel,
   initializeSessionStartAtomically,
@@ -501,7 +507,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
         settings.openaiReasoningEffort;
       let sandboxBackend = task.agentConfig.sandboxBackend ?? settings.sandboxBackend;
       let sandboxOs: "linux" | "macos" | "windows" = "linux";
-      const taskTools = withFirstPartyTools(settings, task.agentConfig.tools);
+      let taskTools = withFirstPartyTools(settings, task.agentConfig.tools);
       // A task created by a live agent attempt froze its creator's effective
       // first-party selection, permission set, and session access policy;
       // its generated sessions inherit that boundary under today's
@@ -510,13 +516,55 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
       const creatorPolicy = await getScheduledTaskCreatorPolicy(db, task.workspaceId, task.id);
       // A person-chosen Slack channel adds only the two bot posting tools;
       // they post nowhere else, whatever the creator's own selection was.
-      const firstPartyMcpTools = withScheduledSlackBotPostingTools(
+      let firstPartyMcpTools = withScheduledSlackBotPostingTools(
         creatorPolicy?.firstPartyMcpTools
           ? allowedFirstPartyMcpToolsForSession(settings, creatorPolicy.firstPartyMcpTools)
           : resolveFirstPartyMcpToolPolicy(settings).default,
         task.agentConfig,
         resolveFirstPartyMcpToolPolicy(settings).allowed,
       );
+      // Agent configuration for generated sessions (null = legacy). The
+      // scheduled baseline above (creator policy or deployment default) is
+      // what "all" reproduces; capabilities only narrow it. Frozen into the
+      // accepted execution so retries and recovery never resolve again.
+      let resolvedAgentConfig: ResolvedAgentConfig | null = null;
+      let resolvedAgentInstructions: string | undefined;
+      try {
+        const agentResolution = resolveSessionAgentConfigForCreate({
+          settings,
+          creator: "scheduled",
+          request: task.agentConfig.agent,
+          instructions: undefined,
+          workspaceSettings: agentConfigMayResolve(settings, task.agentConfig.agent)
+            ? (await requireWorkspace(db, task.workspaceId)).settings
+            : {},
+          parent: null,
+          goal: task.agentConfig.goal !== undefined,
+        });
+        resolvedAgentConfig = agentResolution.config;
+        resolvedAgentInstructions = agentResolution.instructions;
+        const written = applySessionAgentConfigWriteThrough({
+          config: resolvedAgentConfig,
+          firstPartyMcpTools,
+          tools: taskTools,
+          toolPolicy: { mode: "explicit", inheritedFromSessionId: null },
+          productServerIds: task.agentConfig.tools.map((tool) => tool.id),
+        });
+        firstPartyMcpTools = written.firstPartyMcpTools;
+        taskTools = written.tools;
+      } catch (error) {
+        const status =
+          error instanceof Error ? (error as Error & { status?: unknown }).status : undefined;
+        if (!(error instanceof Error) || status !== 422) throw error;
+        const notEnabled =
+          error.cause instanceof AgentConfigError &&
+          error.cause.code === "agent_config_not_enabled";
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          notEnabled,
+          `scheduled agent configuration is not admissible: ${error.message}`,
+        );
+      }
       const firstPartyMcpPermissions = creatorPolicy?.firstPartyMcpPermissions
         ? [...creatorPolicy.firstPartyMcpPermissions]
         : [...DEFAULT_FIRST_PARTY_MCP_PERMISSIONS];
@@ -917,6 +965,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
           workspaceId: task.workspaceId,
           model: targetSessionExecution?.model ?? model,
           requestedAgentRuns: input.agentRunUsageIdempotencyKey ? 0 : 1,
+          initiatingHumanSubjectId: causalHumanSubjectId,
         },
       );
       if (admissionDenial) {
@@ -994,6 +1043,12 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
           resolvedTools: taskTools,
           resolvedFirstPartyMcpTools: firstPartyMcpTools,
           resolvedFirstPartyMcpPermissions: firstPartyMcpPermissions,
+          ...(resolvedAgentConfig
+            ? {
+                resolvedAgentConfig,
+                ...(resolvedAgentInstructions !== undefined ? { resolvedAgentInstructions } : {}),
+              }
+            : {}),
           resolvedVariableSet: acceptedVariableSet
             ? { id: acceptedVariableSet.id, generation: acceptedVariableSet.generation }
             : null,
@@ -1201,6 +1256,10 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
                 tools: taskTools,
                 firstPartyMcpTools,
                 firstPartyMcpPermissions,
+                ...(resolvedAgentConfig ? { agentConfig: resolvedAgentConfig } : {}),
+                ...(resolvedAgentInstructions !== undefined
+                  ? { instructions: resolvedAgentInstructions }
+                  : {}),
                 ...creatorSessionPolicy,
                 ...(task.agentConfig.knowledgeSource?.destination.kind === "personal"
                   ? {
@@ -2242,6 +2301,12 @@ async function recoverBoundScheduledTaskDispatch(input: {
       tools: input.acceptedExecution.resolvedTools,
       firstPartyMcpTools: input.acceptedExecution.resolvedFirstPartyMcpTools,
       firstPartyMcpPermissions: input.acceptedExecution.resolvedFirstPartyMcpPermissions,
+      ...(input.acceptedExecution.resolvedAgentConfig
+        ? { agentConfig: input.acceptedExecution.resolvedAgentConfig }
+        : {}),
+      ...(input.acceptedExecution.resolvedAgentInstructions !== undefined
+        ? { instructions: input.acceptedExecution.resolvedAgentInstructions }
+        : {}),
       ...scheduledCreatorSessionPolicyInput(recoveredCreatorPolicy?.sessionPolicy ?? null),
       ...(task.agentConfig.knowledgeSource?.destination.kind === "personal"
         ? {
@@ -2379,20 +2444,23 @@ async function recoverBoundScheduledTaskDispatch(input: {
     );
     const expectedTaskMetadata = { ...task.agentConfig.metadata };
     delete expectedTaskMetadata[OPENGENI_SLACK_BOT_SESSION_METADATA_KEY];
-    const expectedMetadata = {
-      ...expectedTaskMetadata,
-      model: input.acceptedExecution.resolvedModel,
-      reasoningEffort: input.acceptedExecution.resolvedReasoningEffort,
-      scheduledTaskId: task.id,
-      scheduledTaskRunMode: task.runMode,
-      ...(task.agentConfig.goal ? { scheduledTaskGoal: task.agentConfig.goal } : {}),
-      scheduledTaskRunId: canonicalGeneratedRunId,
-      ...(frozenSlack ? { [OPENGENI_SLACK_BOT_SESSION_METADATA_KEY]: frozenSlack.id } : {}),
-    };
+    const expectedMetadata = metadataWithAgentConfigCreateIdentity(
+      {
+        ...expectedTaskMetadata,
+        model: input.acceptedExecution.resolvedModel,
+        reasoningEffort: input.acceptedExecution.resolvedReasoningEffort,
+        scheduledTaskId: task.id,
+        scheduledTaskRunMode: task.runMode,
+        ...(task.agentConfig.goal ? { scheduledTaskGoal: task.agentConfig.goal } : {}),
+        scheduledTaskRunId: canonicalGeneratedRunId,
+        ...(frozenSlack ? { [OPENGENI_SLACK_BOT_SESSION_METADATA_KEY]: frozenSlack.id } : {}),
+      },
+      input.acceptedExecution.resolvedAgentConfig,
+    );
     if (
       session.createIdempotencyKey !== expectedCreateKey ||
       session.initialMessage !== task.agentConfig.prompt ||
-      session.instructions !== null ||
+      session.instructions !== (input.acceptedExecution.resolvedAgentInstructions ?? null) ||
       session.policyRole !== null ||
       stableJson(session.skills) !== "[]" ||
       stableJson(session.toolPolicy) !==
@@ -2434,6 +2502,8 @@ async function recoverBoundScheduledTaskDispatch(input: {
         stableJson(input.acceptedExecution.resolvedFirstPartyMcpTools) ||
       stableJson(session.firstPartyMcpPermissions) !==
         stableJson(input.acceptedExecution.resolvedFirstPartyMcpPermissions) ||
+      stableJson(session.agent) !==
+        stableJson(input.acceptedExecution.resolvedAgentConfig ?? null) ||
       session.maxNestedAgentDepthOverride !== (task.agentConfig.maxNestedAgentDepth ?? null) ||
       (session.variableSetId ?? null) !==
         (input.acceptedExecution.resolvedVariableSet?.id ?? null) ||

package/src/activities/types.ts

@@ -458,6 +458,7 @@ export type DispatchScheduledTaskRunResult =
       refusal?: import("@opengeni/contracts").ScheduledTaskAdmissionRefusal;
       reason:
         | "insufficient_credits"
+        | "allowance_exhausted"
         | "monthly_model_cost_limit"
         | "monthly_agent_run_limit"
         | "malformed_manual_trigger"

package/src/activities/workspace-credential-provider.ts

@@ -78,6 +78,8 @@ export function credentialProviderRequestBody(
     mcpServers: [],
   },
 ): CredentialProviderRequest {
+  const via = input.initiatorContext.via;
+  const latestHop = Array.isArray(via) ? via.at(-1) : null;
   return {
     type: "credentials.request",
     lane: selection.lane,
@@ -92,6 +94,16 @@ export function credentialProviderRequestBody(
     turnId: input.turnId,
     attemptId: input.attemptId,
     initiator: { kind: input.initiator.kind, subjectId: input.initiator.subjectId },
+    initiatorContext: {
+      kind:
+        latestHop?.kind === "agent"
+          ? "agent"
+          : input.initiator.kind === "subject"
+            ? "human"
+            : "service",
+      initiator: input.initiator,
+      context: input.initiatorContext,
+    },
     initiatingHumanSubjectId,
     initiatingHuman,
     sandboxBackend: input.effectiveSandboxBackend,

package/src/activities-control.ts

@@ -2,6 +2,7 @@ import { createKnowledgeIndexingActivities } from "./activities/knowledge-indexi
 import { createSharedActivityServices } from "./activity-services";
 import { createCodexCapacityActivities } from "./activities/codex-capacity";
 import { createBrowserStateArtifactMaintenanceActivities } from "./activities/browser-state-artifact-reaper";
+import { createBrowserDeadlineCheckpointActivities } from "./activities/browser-deadline-checkpoint";
 import { createAutomationActivities } from "./activities/automations";
 import { createDocumentActivities } from "./activities/documents";
 import { createFileUploadReaperActivities } from "./activities/file-upload-reaper";
@@ -39,6 +40,7 @@ export function createControlActivitiesFromServices(
     ...createCodexCapacityActivities(services),
     ...createRigVerificationActivities(services),
     ...createBrowserStateArtifactMaintenanceActivities(services),
+    ...createBrowserDeadlineCheckpointActivities(services),
     ...createFileUploadReaperActivities(services),
     ...createRetainedScreenshotMaintenanceActivities(services),
     ...createWorkflowWakeActivities(services),

package/src/activities.ts

@@ -117,6 +117,9 @@ export const maybeContinueGoal = defaultControlActivities.maybeContinueGoal;
 export const getCodexCapacityWait = defaultControlActivities.getCodexCapacityWait;
 export const reconcileCodexCapacityWait = defaultControlActivities.reconcileCodexCapacityWait;
 export const prepareSandboxLeaseSweep = defaultControlActivities.prepareSandboxLeaseSweep;
+export const listDueBrowserCheckpoints = defaultControlActivities.listDueBrowserCheckpoints;
+export const checkpointBrowserBeforeDeadline =
+  defaultControlActivities.checkpointBrowserBeforeDeadline;
 export const drainSandboxLease = defaultControlActivities.drainSandboxLease;
 export const maintainSandboxLeaseSweep = defaultControlActivities.maintainSandboxLeaseSweep;
 export const reapSandboxLeases = defaultControlActivities.reapSandboxLeases;

package/src/browser-deadline-checkpoint-contract.ts

@@ -0,0 +1,5 @@
+export const BROWSER_DEADLINE_CHECKPOINT_SWEEP_ID = "opengeni-browser-deadline-checkpoints-v1";
+const QUEUE_SUFFIX = "-browser-checkpoint-v1";
+export function browserDeadlineCheckpointTaskQueue(base: string): string {
+  return base.endsWith(QUEUE_SUFFIX) ? base : `${base}${QUEUE_SUFFIX}`;
+}

package/src/index.ts

@@ -99,6 +99,10 @@ import {
   SANDBOX_REAPER_V2_WORKFLOW_ID,
   sandboxLifecycleTaskQueue,
 } from "./sandbox-reaper-contract";
+import {
+  BROWSER_DEADLINE_CHECKPOINT_SWEEP_ID,
+  browserDeadlineCheckpointTaskQueue,
+} from "./browser-deadline-checkpoint-contract";
 
 export {
   createHostExportPump,
@@ -323,28 +327,39 @@ export async function createOpenGeniWorker(options: WorkerOptions): Promise<{
         return { worker, connection };
       }
 
+      const ownedWorkers = [worker];
       try {
-        const sandboxLifecycleWorker = await Worker.create({
-          ...sharedWorkerOptions,
-          ...workflowDefinition,
-          taskQueue: sandboxLifecycleTaskQueue(settings.temporalTaskQueue),
-          reuseV8Context: true,
-          workflowThreadPoolSize: 1,
-          maxCachedWorkflows: CONTROL_WORKER_MAX_CACHED_WORKFLOWS,
-          maxConcurrentWorkflowTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_WORKFLOW_TASKS,
-          maxConcurrentActivityTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_ACTIVITIES,
-        });
+        // The new activity type has its own queue. Retain the V1 poller so old
+        // drain histories finish; old binaries never receive checkpoint work.
+        for (const taskQueue of [
+          sandboxLifecycleTaskQueue(settings.temporalTaskQueue),
+          browserDeadlineCheckpointTaskQueue(settings.temporalTaskQueue),
+        ]) {
+          const lifecycleWorker = await Worker.create({
+            ...sharedWorkerOptions,
+            ...workflowDefinition,
+            taskQueue,
+            reuseV8Context: true,
+            workflowThreadPoolSize: 1,
+            maxCachedWorkflows: CONTROL_WORKER_MAX_CACHED_WORKFLOWS,
+            maxConcurrentWorkflowTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_WORKFLOW_TASKS,
+            maxConcurrentActivityTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_ACTIVITIES,
+          });
+          ownedWorkers.push(lifecycleWorker);
+        }
         return {
-          worker: combineWorkerRunTargets([worker, sandboxLifecycleWorker]),
+          worker: combineWorkerRunTargets(ownedWorkers),
           connection,
         };
       } catch (error) {
-        try {
-          worker.shutdown();
-        } catch {
-          // Preserve the lifecycle worker construction failure. The base poller
-          // still received its shutdown request; a secondary synchronous
-          // shutdown error must not replace the startup root cause.
+        for (const ownedWorker of ownedWorkers) {
+          try {
+            ownedWorker.shutdown();
+          } catch {
+            // Preserve the lifecycle worker construction failure. The base poller
+            // still received its shutdown request; a secondary synchronous
+            // shutdown error must not replace the startup root cause.
+          }
         }
         throw error;
       }
@@ -478,20 +493,33 @@ export async function createWorkerWorkflowSignaler(
       return normalizeTurnTaskQueueStats(response.stats);
     },
     startSandboxReaperWorkflow: async () => {
-      try {
-        await temporal.workflow.start("sandboxReaperWorkflowV2", {
+      // Same backend tick, no additional schedule. A bounded independent
+      // inventory cannot prevent the existing per-box drain from starting.
+      const starts = await Promise.allSettled([
+        temporal.workflow.start("sandboxReaperWorkflowV2", {
           taskQueue: sandboxLifecycleTaskQueue(settings.temporalTaskQueue),
           workflowId: SANDBOX_REAPER_V2_WORKFLOW_ID,
           workflowIdReusePolicy: "ALLOW_DUPLICATE",
           args: [],
-        });
-        return "started";
-      } catch (error) {
-        if (error instanceof WorkflowExecutionAlreadyStartedError) {
-          return "already_running";
+        }),
+        temporal.workflow.start("browserDeadlineCheckpointSweepWorkflow", {
+          taskQueue: browserDeadlineCheckpointTaskQueue(settings.temporalTaskQueue),
+          workflowId: BROWSER_DEADLINE_CHECKPOINT_SWEEP_ID,
+          workflowIdReusePolicy: "ALLOW_DUPLICATE",
+          args: [],
+        }),
+      ]);
+      for (const start of starts) {
+        if (
+          start.status === "rejected" &&
+          !(start.reason instanceof WorkflowExecutionAlreadyStartedError)
+        ) {
+          // The other start already settled. Retry the router without losing
+          // ordinary draining or silently omitting the checkpoint sweep.
+          throw start.reason;
         }
-        throw error;
       }
+      return starts[0].status === "fulfilled" ? "started" : "already_running";
     },
     startVideoGenerationWorkflow: async ({ accountId, workspaceId, operationId }) => {
       try {

package/src/sandbox-resume.ts

@@ -210,6 +210,9 @@ export type ResumeBoxIds = {
    * never conflicts).
    */
   image?: string;
+  /** Deployment/workspace image pins apply only to new creates; an existing
+   * group keeps its image. Omission preserves explicit image matching (B3). */
+  imagePolicy?: "require_match" | "new_creates_only";
   /**
    * RIG IS SHARED STATE (M3): the frozen rig version this run rides. Threaded to
    * acquireLease, which stamps it on the cold-create and conflicts on a live box
@@ -445,9 +448,10 @@ export async function waitForSandboxExecReadiness(
   established: EstablishedSandboxSession,
   timeoutMs = MODAL_EXEC_READINESS_TIMEOUT_MS,
   identity: { sandboxGroupId?: string | null } = {},
+  signal?: AbortSignal,
 ): Promise<void> {
   try {
-    await verifySandboxExecReadiness(established, timeoutMs);
+    await verifySandboxExecReadiness(established, timeoutMs, signal);
   } catch (error) {
     if (error instanceof SandboxExecReadinessError && error.code === "exec_probe_timeout") {
       throw new SandboxExecReadinessTimeoutError(established.backendId, timeoutMs, {
@@ -1347,11 +1351,12 @@ async function resumeBoxForTurnOnce(
     },
     os,
     // IMAGE IS SHARED STATE (B3): thread the resolved image so the lease stamps it +
-    // conflicts on a live box already running a different image. A
+    // conflicts on a live box already running a different required image. A
     // SandboxImageConflictError propagates while another holder is active; a
     // solo change requests a capture-and-drain rotation and this attempt retries
     // after the cold successor can safely stamp the new image.
     ...(ids.image ? { image: ids.image } : {}),
+    ...(ids.imagePolicy ? { imagePolicy: ids.imagePolicy } : {}),
     // RIG IS SHARED STATE (M3): thread the frozen rig version so the lease stamps it
     // + conflicts on a live box under a different rig. A SandboxRigConflictError
     // propagates while another holder is active; a solo change uses the same
@@ -1917,9 +1922,14 @@ async function resumeBoxForTurnOnce(
           sandboxGroupId: ids.sandboxGroupId,
         });
       } else {
-        await waitForSandboxExecReadiness(established, MODAL_EXEC_READINESS_TIMEOUT_MS, {
-          sandboxGroupId: ids.sandboxGroupId,
-        });
+        await waitForSandboxExecReadiness(
+          established,
+          MODAL_EXEC_READINESS_TIMEOUT_MS,
+          {
+            sandboxGroupId: ids.sandboxGroupId,
+          },
+          cancellationSignal,
+        );
       }
       await maybeRenewProviderExpiration(true);
       throwIfReleasedOrCancelled();
@@ -2117,9 +2127,14 @@ async function resumeBoxForTurnOnce(
       if (services.verifyAttachedSandboxReadiness) {
         await services.verifyAttachedSandboxReadiness(established);
       } else {
-        await waitForSandboxExecReadiness(established, MODAL_EXEC_READINESS_TIMEOUT_MS, {
-          sandboxGroupId: ids.sandboxGroupId,
-        });
+        await waitForSandboxExecReadiness(
+          established,
+          MODAL_EXEC_READINESS_TIMEOUT_MS,
+          {
+            sandboxGroupId: ids.sandboxGroupId,
+          },
+          cancellationSignal,
+        );
       }
       providerRenewalTarget = {
         backend: ids.backend,

package/src/sandbox-routing.ts

@@ -496,7 +496,7 @@ function afterPersistableHomeMutation(
       op: string;
       backend: ResolvedActiveBackend;
       admission: unknown;
-      outcome: "resolved" | "rejected";
+      outcome: "resolved" | "rejected" | "outcome_unknown";
       result?: unknown;
       retainedProcess?: RoutingRetainedProcess;
     }) => Promise<void | RoutingMutationSettlementResult>)
@@ -523,7 +523,7 @@ function afterPersistableHomeMutation(
     ) {
       throw new Error("Persistable home mutation settlement lacked its bound admission");
     }
-    if (outcome === "resolved" && retainedProcess) {
+    if ((outcome === "resolved" || outcome === "outcome_unknown") && retainedProcess) {
       try {
         await retainWorkspaceProviderCommand(services.db, {
           accountId: fence.accountId,
@@ -582,6 +582,8 @@ function afterPersistableHomeMutation(
       }
       return;
     }
+    if (outcome === "outcome_unknown")
+      throw new Error("Outcome-unknown command settlement requires its exact retained invocation");
     await verifyWorkspaceMutationSettlement(services.db, {
       accountId: fence.accountId,
       workspaceId: ids.workspaceId,

package/src/workflows/browser-deadline-checkpoint.ts

@@ -0,0 +1,50 @@
+import {
+  ParentClosePolicy,
+  WorkflowIdReusePolicy,
+  log,
+  proxyActivities,
+  startChild,
+  workflowInfo,
+} from "@temporalio/workflow";
+import type { BrowserDeadlineCheckpointTarget } from "@opengeni/db";
+import type * as activities from "../activities";
+
+const inventory = proxyActivities<Pick<typeof activities, "listDueBrowserCheckpoints">>({
+  startToCloseTimeout: "5 minutes",
+  heartbeatTimeout: "20 seconds",
+});
+const checkpoint = proxyActivities<Pick<typeof activities, "checkpointBrowserBeforeDeadline">>({
+  startToCloseTimeout: "25 minutes",
+  heartbeatTimeout: "20 seconds",
+  retry: { initialInterval: "1 second", maximumInterval: "30 seconds" },
+});
+
+export async function browserDeadlineCheckpointWorkflow(target: BrowserDeadlineCheckpointTarget) {
+  return await checkpoint.checkpointBrowserBeforeDeadline(target);
+}
+
+/** Runs from the existing lease-sweep dispatch. Inventory never performs provider
+ * I/O; each exact browser has an independent durable capture/cleanup child. */
+export async function browserDeadlineCheckpointSweepWorkflow(): Promise<void> {
+  const targets = await inventory.listDueBrowserCheckpoints();
+  await Promise.all(
+    targets.map(async (target) => {
+      try {
+        await startChild(browserDeadlineCheckpointWorkflow, {
+          workflowId: `browser-deadline:${target.browserSessionId}:${target.leaseEpoch}:${target.controllerGeneration}`,
+          taskQueue: workflowInfo().taskQueue,
+          workflowIdReusePolicy: WorkflowIdReusePolicy.ALLOW_DUPLICATE,
+          parentClosePolicy: ParentClosePolicy.ABANDON,
+          args: [target],
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "WorkflowExecutionAlreadyStartedError") return;
+        // Another sweep retries start; it cannot retire the browser's authority.
+        log.warn("browser deadline checkpoint child start deferred", {
+          browserSessionId: target.browserSessionId,
+          error: error instanceof Error ? error.name : "unknown",
+        });
+      }
+    }),
+  );
+}

package/src/workflows.ts

@@ -28,6 +28,10 @@ export {
   sandboxReaperWorkflowV2,
 } from "./workflows/sandbox-reaper";
 export { fileUploadReaperWorkflow } from "./workflows/file-upload-reaper";
+export {
+  browserDeadlineCheckpointWorkflow,
+  browserDeadlineCheckpointSweepWorkflow,
+} from "./workflows/browser-deadline-checkpoint";
 export { siteAuthMaintenanceWorkflow } from "./workflows/site-auth-maintenance";
 export {
   videoGenerationWorkflow,