@opengeni/worker-bundle 1.0.1 → 2.0.0

package/dist/{activities-control-HMFGSKC5.js → activities-control-BOLIY3H4.js}

@@ -28,12 +28,12 @@ import {
   reconcilePendingParentSystemUpdates,
   reconcilePendingSessionWorkflowWakes,
   resolveIncidentTelemetryResponderMetadata,
-  resolveWorkspacePackRuntime,
   rigProviderImageSourceImage,
   scheduledUserMessagePayload,
+  warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-CYITU5UH.js";
+} from "./chunk-TVEE2UUC.js";
 import {
   inspectOpenSandboxKubernetesInventory,
   recordCreditBalanceGauges,
@@ -53,7 +53,7 @@ import {
   recordTurnsQueuedGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-A4XQWVZK.js";
+} from "./chunk-I7HKKMUJ.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
@@ -978,13 +978,13 @@ var RIG_VERIFICATION_CLEANUP_OPERATION_MAX_MS = 6e4;
 var RIG_VERIFICATION_HEARTBEAT_MAX_INTERVAL_MS = 1e4;
 var RIG_VERIFICATION_HEARTBEAT_MIN_INTERVAL_MS = 250;
 var RIG_VERIFICATION_OWNER_TTL_MS = 20 * 6e4;
-var RIG_VERIFICATION_OWNERS_DISABLED_MESSAGE = "Rig verification lease ownership is disabled; refusing to create an unowned verifier sandbox";
+var RIG_VERIFICATION_OWNERS_DISABLED_MESSAGE = "Sandbox Environment verification lease ownership is disabled; refusing to create an unowned verifier sandbox";
 var RIG_VERIFICATION_HOLDER_TOUCH_INTERVAL_MS = 1e4;
 var RIG_VERIFICATION_RELEASE_GRACE_MS = 1;
 var RigVerificationActivityDeadlineError = class extends Error {
   constructor(startToCloseTimeoutMs, cleanupReserveMs) {
     super(
-      `Rig verification activity-local deadline reached with ${cleanupReserveMs}ms reserved for cleanup before the ${startToCloseTimeoutMs}ms Temporal start-to-close timeout`
+      `Sandbox Environment verification activity-local deadline reached with ${cleanupReserveMs}ms reserved for cleanup before the ${startToCloseTimeoutMs}ms Temporal start-to-close timeout`
     );
     this.startToCloseTimeoutMs = startToCloseTimeoutMs;
     this.cleanupReserveMs = cleanupReserveMs;
@@ -1003,7 +1003,9 @@ function createRigVerificationActivityLifecycle(context = currentActivityContext
   const temporalSignal = context?.cancellationSignal;
   const forwardTemporalCancellation = () => {
     if (!controller.signal.aborted) {
-      controller.abort(temporalSignal?.reason ?? new Error("Rig verification cancelled"));
+      controller.abort(
+        temporalSignal?.reason ?? new Error("Sandbox Environment verification cancelled")
+      );
     }
   };
   if (temporalSignal?.aborted) {
@@ -1065,7 +1067,7 @@ function createRigVerificationActivityLifecycle(context = currentActivityContext
   };
 }
 function abortReason(signal) {
-  return signal.reason ?? new Error("Rig verification cancelled");
+  return signal.reason ?? new Error("Sandbox Environment verification cancelled");
 }
 function throwIfAborted(signal) {
   if (signal.aborted) throw abortReason(signal);
@@ -1145,7 +1147,9 @@ var defaultOwnershipDependencies = {
 };
 var RigVerificationLeaseUnavailableError = class extends Error {
   constructor(sandboxGroupId, role) {
-    super(`Rig verification requires a new clean sandbox, but lease ${sandboxGroupId} was ${role}`);
+    super(
+      `Sandbox Environment verification requires a new clean sandbox, but lease ${sandboxGroupId} was ${role}`
+    );
     this.sandboxGroupId = sandboxGroupId;
     this.role = role;
   }
@@ -1168,7 +1172,7 @@ async function runWithOwnedRigVerificationSandbox(input, run, dependencies = def
   let establishmentSettled = false;
   let establishmentPromise = null;
   const warnCleanupTimeout = (operation, instanceId) => {
-    input.observability.warn("rig verifier: ownership cleanup timed out", {
+    input.observability.warn("sandbox environment verifier: ownership cleanup timed out", {
       holderId,
       instanceId,
       operation,
@@ -1176,7 +1180,7 @@ async function runWithOwnedRigVerificationSandbox(input, run, dependencies = def
     });
   };
   const warnCleanupFailure = (operation, instanceId, error) => {
-    input.observability.warn("rig verifier: ownership cleanup failed", {
+    input.observability.warn("sandbox environment verifier: ownership cleanup failed", {
       holderId,
       instanceId,
       operation,
@@ -1302,11 +1306,14 @@ async function runWithOwnedRigVerificationSandbox(input, run, dependencies = def
               );
             } catch (error) {
               if (!signal.aborted) {
-                input.observability.warn("rig verifier: Modal ownership tag failed", {
-                  holderId,
-                  instanceId: created.instanceId,
-                  error: error instanceof Error ? error.message : String(error)
-                });
+                input.observability.warn(
+                  "sandbox environment verifier: Modal ownership tag failed",
+                  {
+                    holderId,
+                    instanceId: created.instanceId,
+                    error: error instanceof Error ? error.message : String(error)
+                  }
+                );
               }
             }
           }
@@ -1501,10 +1508,12 @@ function rigProviderImageContentMarkerCommand(contentHash, markerRoot = "/var/op
 }
 function rigProviderImageContentMarker(contentHash, markerRoot = "/var/opengeni") {
   if (!/^sha256:[0-9a-f]{64}$/u.test(contentHash)) {
-    throw new Error("Rig provider image content marker requires a canonical SHA-256 value");
+    throw new Error(
+      "Sandbox Environment provider image content marker requires a canonical SHA-256 value"
+    );
   }
   if (!/^\/[A-Za-z0-9._/-]+$/u.test(markerRoot)) {
-    throw new Error("Rig provider image marker root must be a safe absolute path");
+    throw new Error("Sandbox Environment provider image marker root must be a safe absolute path");
   }
   const normalizedRoot = markerRoot.replace(/\/+$/u, "") || "/";
   const marker = `${normalizedRoot === "/" ? "" : normalizedRoot}/rig-setup-content-${contentHash.slice("sha256:".length)}.done`;
@@ -1542,7 +1551,9 @@ async function verifyRigProviderImageColdBoot(input, dependencies = defaultRigPr
         runContext.commandRunner
       );
       if (markerResult.exitCode !== 0) {
-        throw new Error("built provider image is missing its exact rig-content marker");
+        throw new Error(
+          "built provider image is missing its exact sandbox environment-content marker"
+        );
       }
       for (const check of rigPlatformChecksForSettings(input.settings)) {
         const result = await runCommand(
@@ -1627,7 +1638,7 @@ async function buildVerifiedRigProviderImage(input) {
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: {
           code: "provider_image_content_conflict",
-          message: "this exact rig version already records a provider image for different effective content; mint and verify a new version",
+          message: "this exact sandbox environment version already records a provider image for different effective content; mint and verify a new version",
           retryable: false
         }
       };
@@ -1801,37 +1812,36 @@ async function buildVerifiedRigProviderImage(input) {
     });
   }
 }
-function settingsForRigVerification(settings, packRuntime, rigImage) {
-  void packRuntime;
+function settingsForRigVerification(settings, rigImage) {
   void rigImage;
   return settings;
 }
 async function loadChangeTarget(db, workspaceId, changeId) {
   const change = await getRigChange(db, workspaceId, changeId);
   if (!change) {
-    throw new Error(`Rig change not found: ${changeId}`);
+    throw new Error(`Sandbox Environment change not found: ${changeId}`);
   }
   const rig = await getRig(db, workspaceId, change.rigId);
   if (!rig) {
-    throw new Error(`Rig not found for change: ${change.rigId}`);
+    throw new Error(`Sandbox Environment not found for change: ${change.rigId}`);
   }
   if (!change.baseVersionId) {
-    throw new Error(`Rig change ${change.id} has no base version`);
+    throw new Error(`Sandbox Environment change ${change.id} has no base version`);
   }
   const baseVersion = await getRigVersionById(db, workspaceId, change.baseVersionId);
   if (!baseVersion || baseVersion.rigId !== rig.id) {
-    throw new Error(`Base rig version not found: ${change.baseVersionId}`);
+    throw new Error(`Base sandbox environment version not found: ${change.baseVersionId}`);
   }
   return { rig, baseVersion, change };
 }
 async function loadVersionTarget(db, workspaceId, versionId) {
   const version = await getRigVersionById(db, workspaceId, versionId);
   if (!version) {
-    throw new Error(`Rig version not found: ${versionId}`);
+    throw new Error(`Sandbox Environment version not found: ${versionId}`);
   }
   const rig = await getRig(db, workspaceId, version.rigId);
   if (!rig) {
-    throw new Error(`Rig not found for version: ${version.rigId}`);
+    throw new Error(`Sandbox Environment not found for version: ${version.rigId}`);
   }
   return { rig, version };
 }
@@ -1874,12 +1884,7 @@ function createRigVerificationActivities(services) {
           change,
           candidateVersion
         );
-        const packRuntime = await resolveWorkspacePackRuntime(db, input.workspaceId);
-        const runSettings = settingsForRigVerification(
-          settings,
-          packRuntime,
-          candidateVersion.image
-        );
+        const runSettings = settingsForRigVerification(settings, candidateVersion.image);
         const providerImageContentHash = rigProviderImageContentHash({
           backend: runSettings.sandboxBackend,
           sourceImage: rigProviderImageSourceImage(runSettings, runSettings.sandboxBackend),
@@ -1953,7 +1958,7 @@ function createRigVerificationActivities(services) {
             );
             if (markerResult.exitCode !== 0) {
               throw new Error(
-                `Failed to seal rig provider image content marker: ${markerResult.output.slice(-2e3)}`
+                `Failed to seal sandbox environment provider image content marker: ${markerResult.output.slice(-2e3)}`
               );
             }
             const platformCheckResults = await runRigChecks(
@@ -2064,8 +2069,7 @@ function createRigVerificationActivities(services) {
         metadata: { versionId: version.id }
       });
       try {
-        const packRuntime = await resolveWorkspacePackRuntime(db, input.workspaceId);
-        const runSettings = settingsForRigVerification(settings, packRuntime, version.image);
+        const runSettings = settingsForRigVerification(settings, version.image);
         const providerImageContentHash = rigProviderImageContentHash({
           backend: runSettings.sandboxBackend,
           sourceImage: rigProviderImageSourceImage(runSettings, runSettings.sandboxBackend),
@@ -2107,7 +2111,7 @@ function createRigVerificationActivities(services) {
             );
             if (markerResult.exitCode !== 0) {
               throw new Error(
-                `Failed to seal rig provider image content marker: ${markerResult.output.slice(-2e3)}`
+                `Failed to seal sandbox environment provider image content marker: ${markerResult.output.slice(-2e3)}`
               );
             }
             const platformCheckResults = await runRigChecks(
@@ -2180,13 +2184,48 @@ function createRigVerificationActivities(services) {
   };
 }
 
+// src/retained-process-diagnostics.ts
+import {
+  databaseFailureCode,
+  nestedPostgresSqlState,
+  safeDatabaseErrorFacts,
+  SandboxWorkspaceMutationFencedError
+} from "@opengeni/db";
+function warnRetainedProcessProofFailure(observability, error, process) {
+  let correlationId;
+  try {
+    const sqlState = nestedPostgresSqlState(error);
+    const constraint = safeDatabaseErrorFacts(error).constraint;
+    correlationId = observability.recordFailureDiagnostic({
+      code: error instanceof SandboxWorkspaceMutationFencedError ? "retained_process_fenced" : sqlState ? databaseFailureCode(sqlState) : "retained_process_proof_failed",
+      stage: "sandbox_retained_processes.proof",
+      error,
+      processId: process.id,
+      sessionId: process.sessionId,
+      ...process.ownerAttemptId ? { attemptId: process.ownerAttemptId } : {},
+      ...process.ownerTurnId ? { turnId: process.ownerTurnId } : {},
+      attempts: process.reconcileAttempts,
+      sqlState,
+      ...constraint ? { constraint } : {}
+    });
+  } catch {
+  }
+  try {
+    observability.warn("sandbox reaper: retained-process proof checkpoint failed", {
+      ...correlationId ? { correlationId } : {}
+    });
+  } catch {
+  }
+}
+
 // src/activities/sandbox-lease.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { retainedProviderCommandPersistence } from "@opengeni/db/retained-provider-commands";
+import { requestRetainedProcessDeadlineCancellation } from "@opengeni/db/retained-provider-commands";
 import { Context } from "@temporalio/activity";
 import { OpLostReason, OpState } from "@opengeni/agent-proto";
 import {
   accrueWarmSeconds,
+  retainedProviderCommandPersistence,
   adoptLegacyModalCheckpointArtifact,
   confirmDrainCold,
   appendSessionEventToSandboxGroup,
@@ -2215,6 +2254,7 @@ import {
   recordRetainedProcessReconciliationProof,
   replaceWorkspaceArchiveCaptureAfterProof,
   readLease,
+  readWorkspaceArchiveCapturePreflight,
   reapExpiredSessionListSnapshots,
   reapStaleLeaseHoldersGlobal,
   requestDueSandboxRotationsGlobal,
@@ -2356,7 +2396,7 @@ function sandboxDrainActivityAttempt() {
   }
 }
 function createSandboxLeaseActivities(services, options = {}) {
-  const terminateBox = options.terminateBox ?? (async (settings, lease, observability, persistArchive, providerCaptureRequestId, captureDisposition, capturePolicy, diskBackedArchives, releaseFailedCapture) => await terminateProviderBox(
+  const terminateBox = options.terminateBox ?? (async (settings, lease, observability, persistArchive, providerCaptureRequestId, captureDisposition, capturePolicy, diskBackedArchives, releaseFailedCapture, workspaceId) => await terminateProviderBox(
     settings,
     lease,
     observability,
@@ -2367,7 +2407,8 @@ function createSandboxLeaseActivities(services, options = {}) {
     captureDisposition,
     capturePolicy,
     diskBackedArchives,
-    releaseFailedCapture
+    releaseFailedCapture,
+    workspaceId
   ));
   const sweepModalOrphans = options.sweepModalOrphans ?? sweepModalOrphansForConfiguredBackend;
   const inspectOpenSandboxInventory = options.inspectOpenSandboxKubernetesInventory ?? inspectOpenSandboxKubernetesInventory;
@@ -2904,18 +2945,14 @@ async function reconcileConnectedMachineBackgroundCommands(db, settings, observa
               journal: { attachGeneration: () => String(Date.now()), persistSettled: () => {
               } }
             });
-            const replay = await client.readExisting(
+            await replayConnectedCommandOutput(
+              client,
               claim.opId,
-              proof ? 5e3 : 250,
+              Boolean(proof),
               async (frames) => {
                 await captureConnectedCommandOutput(db, claim, bus)(claim.commandId, frames);
               }
             );
-            if (proof && replay.status !== "completed" && !replay.terminal) {
-              throw new Error(
-                "Connected command terminal output replay has not reached its exit frontier"
-              );
-            }
           }
           if (!proof) {
             await deferConnectedCommandClaim(
@@ -2989,6 +3026,23 @@ async function reconcileConnectedMachineBackgroundCommands(db, settings, observa
     if (claims.length < CONNECTED_COMMAND_RECONCILIATION_LIMIT) break;
   } while (Date.now() < deadline);
 }
+async function replayConnectedCommandOutput(client, opId, terminalKnown, capture) {
+  let capturedThrough = 0n;
+  while (true) {
+    const before = capturedThrough;
+    const replay = await client.readExisting(opId, terminalKnown ? 5e3 : 250, async (frames) => {
+      await capture(frames);
+      for (const frame of frames) {
+        const sequence = BigInt(frame.sequence);
+        if (sequence > capturedThrough) capturedThrough = sequence;
+      }
+    });
+    if (!terminalKnown || replay.status === "completed" || replay.terminal) return;
+    if (capturedThrough === before) {
+      throw new Error("Connected command terminal output replay has not reached its exit frontier");
+    }
+  }
+}
 async function probeConnectedMachineBackgroundCommand(claim, controlRpc, controlTimeoutMs, observedAt = /* @__PURE__ */ new Date()) {
   const input = {
     controlRpc,
@@ -3079,6 +3133,40 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
     let process = claim.process;
     const expected = retainedProcessSettlementIdentity(process);
     let proof = retainedProcessReconciliationProof(process);
+    const processScope = {
+      accountId: process.accountId,
+      workspaceId: process.workspaceId,
+      sessionId: process.sessionId,
+      processId: process.id
+    };
+    const storedCommandPersistence = retainedProviderCommandPersistence(
+      db,
+      processScope,
+      bus ? (events) => bus.publish(process.workspaceId, process.sessionId, events) : void 0
+    );
+    const commandPersistence = {
+      ...storedCommandPersistence,
+      requestCancellation: async (reason) => {
+        if (reason === "provider_deadline") {
+          await requestRetainedProcessDeadlineCancellation(db, processScope);
+          if (!await storedCommandPersistence.cancellationRequested())
+            throw new Error(
+              "Supervised deadline cancellation no longer owns its original rotating lease"
+            );
+        } else await storedCommandPersistence.requestCancellation(reason);
+      }
+    };
+    if (proof && process.providerBackend === "modal") {
+      try {
+        const command = await commandPersistence.load();
+        if (command?.kind === "modal-router-v1" && command.supervision && (!await commandPersistence.loadSupervisionReceipt() || ![command.streams.stdout, command.streams.stderr].every(
+          (stream) => stream.eof && stream.exitCode === 0
+        )))
+          proof = null;
+      } catch {
+        proof = null;
+      }
+    }
     if (!proof) {
       let observation = null;
       if (process.providerBackend === "modal" && process.routeTargetId === null && !process.providerBindingKey) {
@@ -3162,6 +3250,19 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
           }
         } else {
           try {
+            const command = await commandPersistence.load();
+            const supervised = command?.kind === "modal-router-v1" && Boolean(command.supervision);
+            const supervisionMetric = (outcome) => observability.incrementCounter({
+              name: "opengeni_command_supervision_total",
+              help: "Native retained command supervision reconciliation outcomes.",
+              labels: { outcome }
+            });
+            if (supervised && (lease.rotationReason === "provider_deadline" || claim.ownerState === "background_stopping")) {
+              await commandPersistence.requestCancellation(
+                lease.rotationReason === "provider_deadline" ? "provider_deadline" : "explicit_stop"
+              );
+              supervisionMetric("cancellation_intent");
+            }
             observation = await probe(
               settings,
               lease,
@@ -3183,13 +3284,17 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
                 if (events.length && bus)
                   await bus.publish(process.workspaceId, process.sessionId, events).catch(() => void 0);
               },
-              retainedProviderCommandPersistence(db, {
-                accountId: process.accountId,
-                workspaceId: process.workspaceId,
-                sessionId: process.sessionId,
-                processId: process.id
-              })
+              commandPersistence
             );
+            if (supervised) {
+              supervisionMetric(
+                await commandPersistence.loadSupervisionReceipt() ? "proof_retained" : "proof_missing"
+              );
+              if (observation.status === "deferred")
+                supervisionMetric(
+                  observation.reason === "provider_running" ? "checkpoint_blocked" : "provider_failure"
+                );
+            }
           } catch (error) {
             observability.warn("sandbox reaper: retained-process provider probe failed", {
               processId: process.id,
@@ -3248,10 +3353,7 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
         recordRetainedProcessReconciliation(observability, `proof_${proof.outcome}`);
       } catch (error) {
         recordRetainedProcessReconciliation(observability, "proof_checkpoint_failed");
-        observability.warn("sandbox reaper: retained-process proof checkpoint failed", {
-          processId: process.id,
-          error: error instanceof Error ? error.message : String(error)
-        });
+        warnRetainedProcessProofFailure(observability, error, process);
         continue;
       }
     }
@@ -3377,7 +3479,7 @@ async function captureRetainedProbeOutput(processId, result, capture) {
   pendingRetainedProbeOutput.delete(processId);
 }
 async function probeRetainedProcessAtProvider(settings, lease, process, mode = "observe", captureOutput, providerPersistence) {
-  if (lease.id !== process.leaseId || lease.sandboxGroupId !== process.sandboxGroupId || lease.leaseEpoch !== process.leaseEpoch || lease.backend !== process.providerBackend || lease.instanceId !== process.providerInstanceId || lease.resumeBackendId !== process.providerBackend || process.routeTargetId !== null) {
+  if (lease.id !== process.leaseId || lease.sandboxGroupId !== process.sandboxGroupId || lease.leaseEpoch !== process.leaseEpoch || lease.backend !== process.providerBackend || lease.instanceId !== process.providerInstanceId || !lease.resumeBackendId || sandboxBackendForSdkBackendId(lease.resumeBackendId) !== process.providerBackend || process.routeTargetId !== null) {
     return { status: "deferred", reason: "identity_mismatch" };
   }
   if (!lease.resumeState) {
@@ -3390,7 +3492,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
     return classifyRetainedProcessPollResult(pending.result, process.providerSessionId);
   }
   const envelopeBackend = lease.resumeState.backendId;
-  if (envelopeBackend !== void 0 && envelopeBackend !== process.providerBackend) {
+  if (envelopeBackend !== void 0 && (typeof envelopeBackend !== "string" || sandboxBackendForSdkBackendId(envelopeBackend) !== process.providerBackend)) {
     return { status: "deferred", reason: "identity_mismatch" };
   }
   if (sandboxProviderInstanceIdFromEnvelope(lease.resumeState) !== process.providerInstanceId) {
@@ -3418,7 +3520,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   } catch {
     return { status: "deferred", reason: "provider_error" };
   }
-  if (!client || client.backendId !== process.providerBackend || !client.resume) {
+  if (!client || sandboxBackendForSdkBackendId(client.backendId) !== process.providerBackend || !client.resume) {
     return { status: "deferred", reason: "backend_unsupported" };
   }
   const envelopeSessionState = lease.resumeState.sessionState ?? lease.resumeState;
@@ -3502,6 +3604,11 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
       return;
     }
     const page = session.getProviderCommandOutput?.(value);
+    if (page?.command.kind === "modal-router-v1" && typeof value === "string") {
+      if (!session.captureCommandOutput || !await session.captureCommandOutput(value))
+        throw new Error("Byte-offset output requires atomic capture before settlement");
+      return;
+    }
     if (page) {
       for (const chunk of page.chunks)
         if (chunk.text)
@@ -3513,10 +3620,14 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   };
   let result;
   try {
+    const supervisedCancelled = mode === "cancel" || lease.rotationReason === "provider_deadline" ? await session.cancelSupervisedCommand?.(
+      process.providerSessionId,
+      lease.rotationReason === "provider_deadline" ? "provider_deadline" : "explicit_stop"
+    ) ?? false : false;
     result = await withRetainedProcessProbeTimeout(
       session.writeStdin({
         sessionId: process.providerSessionId,
-        chars: mode === "cancel" ? "" : "",
+        chars: mode === "cancel" && !supervisedCancelled ? "" : "",
         yieldTimeMs: 1e3,
         maxOutputTokens: 2e3
       })
@@ -3542,7 +3653,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   }
   await capturePage(result);
   const observation = classifyRetainedProcessPollResult(result, process.providerSessionId, session);
-  if (observation.status === "deferred" && observation.reason === "provider_running" && lease.rotationRequestedAt !== null) {
+  if (observation.status === "deferred" && observation.reason === "provider_running" && lease.rotationRequestedAt !== null && !await providerPersistence?.load().then((command) => command?.kind === "modal-router-v1" && command.supervision)) {
     try {
       const interrupted = await withRetainedProcessProbeTimeout(
         session.writeStdin({
@@ -4118,6 +4229,16 @@ async function terminateDrainableBox(db, settings, row, observability, terminate
     }
     return result;
   };
+  if (!providerMissingBeforeCapture && backend === "modal" && lease.instanceId && !await readWorkspaceArchiveCapturePreflight(db, {
+    accountId,
+    workspaceId: row.workspaceId,
+    sandboxGroupId: row.sandboxGroupId,
+    expectedEpoch: row.leaseEpoch,
+    expectedInstanceId: lease.instanceId,
+    liveness: "draining"
+  })) {
+    return false;
+  }
   const termination = providerMissingBeforeCapture ? { terminated: true, providerMissingBeforeCapture: true } : await terminateBox(
     settings,
     lease,
@@ -4137,7 +4258,8 @@ async function terminateDrainableBox(db, settings, row, observability, terminate
         expectedEpoch: row.leaseEpoch,
         expectedInstanceId: lease.instanceId
       });
-    }
+    },
+    row.workspaceId
   );
   const terminated = typeof termination === "boolean" ? termination : termination.terminated;
   if (!terminated) {
@@ -4193,18 +4315,20 @@ function providerDrainLogIdentity(lease, backend) {
     instanceId: lease.instanceId
   };
 }
-async function terminateProviderBox(settings, lease, observability, persistArchive, createClientForBackend = createSandboxClientForBackend, terminateModalById = terminateModalSandboxById, providerCaptureRequestId, captureDisposition = "capture_required", claimedCapturePolicy, diskBackedArchives = false, releaseFailedCapture) {
+async function terminateProviderBox(settings, lease, observability, persistArchive, createClientForBackend = createSandboxClientForBackend, terminateModalById = terminateModalSandboxById, providerCaptureRequestId, captureDisposition = "capture_required", claimedCapturePolicy, diskBackedArchives = false, releaseFailedCapture, workspaceId) {
   const durableBackendId = lease.resumeBackendId ?? lease.backend;
   const backend = sandboxBackendForSdkBackendId(durableBackendId) ?? durableBackendId;
   const logIdentity = providerDrainLogIdentity(lease, backend);
+  const warnCaptureFailure = (message, error) => warnDrainSnapshotFailure(observability, message, error, {
+    sandboxGroupId: lease.sandboxGroupId,
+    leaseEpoch: lease.leaseEpoch,
+    ...workspaceId ? { workspaceId } : {}
+  });
   const releaseAfterCaptureFailure = async () => {
     try {
       await releaseFailedCapture?.();
     } catch (error) {
-      observability.warn("sandbox reaper: failed capture claim release failed", {
-        ...logIdentity,
-        error: error instanceof Error ? error.message : String(error)
-      });
+      warnCaptureFailure("sandbox reaper: failed capture claim release failed", error);
     }
   };
   if (!backend || backend === "none") {
@@ -4359,26 +4483,17 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
               }
             );
           } catch (error) {
-            observability.warn("sandbox reaper: late workspace capture publication failed", {
-              ...logIdentity,
-              error: error instanceof Error ? error.message : String(error)
-            });
+            warnCaptureFailure("sandbox reaper: late workspace capture publication failed", error);
           } finally {
             await disposeWorkspaceArchive(archive);
           }
         },
         observeLatePublicationFailure: (error) => {
-          observability.warn("sandbox reaper: late capture publication cleanup failed", {
-            ...logIdentity,
-            error: error instanceof Error ? error.message : String(error)
-          });
+          warnCaptureFailure("sandbox reaper: late capture publication cleanup failed", error);
         },
         observeLateFailure: (error) => {
           void releaseAfterCaptureFailure();
-          observability.warn("sandbox reaper: timed-out provider capture later failed", {
-            ...logIdentity,
-            error: error instanceof Error ? error.message : String(error)
-          });
+          warnCaptureFailure("sandbox reaper: timed-out provider capture later failed", error);
         }
       });
     }
@@ -4389,12 +4504,9 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
       });
       return { terminated: true, providerMissingBeforeCapture: true };
     }
-    observability.warn(
+    warnCaptureFailure(
       "sandbox reaper: persistWorkspace failed \u2014 leaving box draining (files NOT lost)",
-      {
-        ...logIdentity,
-        error: error instanceof Error ? error.message : String(error)
-      }
+      error
     );
     if (!(error instanceof SandboxProviderCaptureTimeoutError)) {
       await releaseAfterCaptureFailure();
@@ -4467,7 +4579,6 @@ import {
   TurnExecutionPolicyV1
 } from "@opengeni/contracts";
 import {
-  defaultSessionMcpServerIds,
   openGeniSlackBotMetadata,
   requireOpenGeniSlackBotConnection,
   resolveWorkspaceCatalogSettings as resolveWorkspaceCatalogSettings2,
@@ -4475,6 +4586,12 @@ import {
   workspaceCustomModelReference,
   lockActiveCustomModelForAdmission,
   scheduledSlackBotConnectionId,
+  freezeConnectionAccounts,
+  ConnectionAccountSelectionError,
+  scheduledConnectionSurfaceEligibility,
+  scheduledConnectionTools,
+  settingsWithEnabledCapabilityMcpServers,
+  settingsWithSessionMcpServerMetadata,
   swapActiveSandbox
 } from "@opengeni/core";
 import {
@@ -4489,7 +4606,6 @@ import {
   getScheduledTaskRunAcceptedExecution,
   getScheduledTaskRunByProducerKey,
   getScheduledTargetSessionExecution,
-  getScheduledTaskPersonalConnectionDelegations,
   getScheduledTaskRunPersonalResourceAuthority,
   getScheduledTaskPersonalResourceAuthoritySubject,
   getScheduledTaskRevisionAuthority,
@@ -4505,7 +4621,6 @@ import {
   isCodexBilledModel,
   initializeSessionStartAtomically,
   materializeScheduledTaskReusableSessionFromRun,
-  listEnabledMcpCapabilityServerIds,
   listInstalledApiIntegrationServerIdsForDelegations,
   markScheduledTaskRunFailedIfQueued,
   markScheduledTaskRunSkippedIfQueued,
@@ -4805,20 +4920,6 @@ function createScheduledTaskActivities(services) {
       if (incidentDeclaration.action === "blocked") {
         return incidentDeclaration;
       }
-      const taskPersonalConnectionDelegations = await getScheduledTaskPersonalConnectionDelegations(
-        db,
-        task.workspaceId,
-        task.id
-      );
-      const taskConnectionAuthoritySubjects = [
-        ...new Set(
-          taskPersonalConnectionDelegations.map((delegation) => delegation.ownerSubjectId)
-        )
-      ];
-      if (taskConnectionAuthoritySubjects.length > 1) {
-        throw new Error("scheduled connection authority has multiple causal humans");
-      }
-      const taskConnectionAuthoritySubjectId = taskConnectionAuthoritySubjects[0] ?? null;
       const taskPersonalResourceAuthoritySubjectId = await getScheduledTaskPersonalResourceAuthoritySubject(db, {
         accountId: task.accountId,
         workspaceId: task.workspaceId,
@@ -4831,10 +4932,12 @@ function createScheduledTaskActivities(services) {
         taskId: task.id,
         taskAuthorityRevision: task.authorityRevision
       });
-      if (taskConnectionAuthoritySubjectId && taskPersonalResourceAuthoritySubjectId && taskConnectionAuthoritySubjectId !== taskPersonalResourceAuthoritySubjectId) {
-        throw new Error("scheduled authority classes have different causal humans");
+      const taskAuthoritySubjectId = task.ownerSubjectId;
+      if (task.action.kind === "agent_turn" && ((taskRevisionAuthority?.subjectId ?? null) !== taskAuthoritySubjectId || [taskPersonalResourceAuthoritySubjectId].some(
+        (subject) => subject !== null && subject !== taskAuthoritySubjectId
+      ))) {
+        throw new Error("scheduled authority differs from its immutable execution owner");
       }
-      const taskAuthoritySubjectId = taskRevisionAuthority?.subjectId ?? taskPersonalResourceAuthoritySubjectId ?? taskConnectionAuthoritySubjectId;
       const acceptedTargetSessionId = task.runMode === "existing_session" ? task.targetSessionId : task.runMode === "reusable_session" ? task.reusableSessionId : null;
       const targetSessionExecutionBase = acceptedTargetSessionId ? await getScheduledTargetSessionExecution(
         db,
@@ -4851,6 +4954,50 @@ function createScheduledTaskActivities(services) {
       const creatorPolicy = await getScheduledTaskCreatorPolicy(db, task.workspaceId, task.id);
       const firstPartyMcpTools = creatorPolicy?.firstPartyMcpTools ? allowedFirstPartyMcpToolsForSession(settings, creatorPolicy.firstPartyMcpTools) : resolveFirstPartyMcpToolPolicy(settings).default;
       const firstPartyMcpPermissions = creatorPolicy?.firstPartyMcpPermissions ? [...creatorPolicy.firstPartyMcpPermissions] : [...DEFAULT_FIRST_PARTY_MCP_PERMISSIONS];
+      const connectionSettings = await settingsWithEnabledCapabilityMcpServers(
+        db,
+        task.workspaceId,
+        settings,
+        taskAuthoritySubjectId ? { subjectId: taskAuthoritySubjectId } : {}
+      );
+      const connectionTarget = acceptedTargetSessionId && targetSessionExecutionBase ? await requireSession(db, task.workspaceId, acceptedTargetSessionId) : null;
+      const connectionTools = await scheduledConnectionTools(
+        db,
+        task.workspaceId,
+        connectionSettings,
+        connectionTarget,
+        taskTools,
+        taskAuthoritySubjectId ?? void 0
+      );
+      const taskConnections = await freezeConnectionAccounts({
+        db,
+        accountId: task.accountId,
+        workspaceId: task.workspaceId,
+        settings: connectionTarget ? settingsWithSessionMcpServerMetadata(connectionSettings, connectionTarget.mcpServers) : connectionSettings,
+        tools: connectionTools,
+        resources: connectionTarget?.resources ?? task.agentConfig.resources,
+        source: taskAuthoritySubjectId ? { kind: "subject", subjectId: taskAuthoritySubjectId, accountId: task.accountId } : { kind: "none" },
+        authoritySelections: task.agentConfig.connectionAccounts ?? [],
+        authoritySelectionsFrozen: task.agentConfig.connectionAccountsFrozen === true,
+        ...scheduledConnectionSurfaceEligibility(
+          settings,
+          connectionTarget ?? {
+            firstPartyMcpTools,
+            firstPartyMcpPermissions
+          }
+        )
+      }).catch((error) => {
+        if (error instanceof ConnectionAccountSelectionError) return null;
+        throw error;
+      });
+      if (taskConnections === null) {
+        return { action: "blocked", reason: "connection_account_unavailable" };
+      }
+      const {
+        personalConnectionDelegations: taskPersonalConnectionDelegations,
+        mcpAccountBindings: taskMcpAccountBindings
+      } = taskConnections;
+      const taskConnectionAuthoritySubjectId = taskPersonalConnectionDelegations.length > 0 ? taskAuthoritySubjectId : null;
       const creatorSessionPolicy = scheduledCreatorSessionPolicyInput(
         creatorPolicy?.sessionPolicy ?? null
       );
@@ -4898,20 +5045,15 @@ function createScheduledTaskActivities(services) {
         };
       })() : null;
       const targetSessionExecution = targetSessionExecutionBase ? await (async () => {
-        const [capabilityServerIds, apiIntegrationServerIds] = await Promise.all([
-          listEnabledMcpCapabilityServerIds(db, task.workspaceId),
-          listInstalledApiIntegrationServerIdsForDelegations(
-            db,
-            task.workspaceId,
-            taskPersonalConnectionDelegations
-          )
-        ]);
-        const workspaceDefaultMcpServerIds = new Set(
-          settings.mcpServers.map((server) => server.id)
+        const apiIntegrationServerIds = await listInstalledApiIntegrationServerIdsForDelegations(
+          db,
+          task.workspaceId,
+          taskPersonalConnectionDelegations
         );
-        for (const id of capabilityServerIds) workspaceDefaultMcpServerIds.add(id);
-        for (const id of apiIntegrationServerIds) workspaceDefaultMcpServerIds.add(id);
-        const availableMcpServerIds = new Set(workspaceDefaultMcpServerIds);
+        const availableMcpServerIds = /* @__PURE__ */ new Set([
+          ...connectionSettings.mcpServers.map((server) => server.id),
+          ...apiIntegrationServerIds
+        ]);
         for (const id of targetSessionExecutionBase.mcpServerIds) {
           availableMcpServerIds.add(id);
         }
@@ -4919,9 +5061,10 @@ function createScheduledTaskActivities(services) {
           toolPolicy: targetSessionExecutionBase.toolPolicy,
           sessionTools: targetSessionExecutionBase.tools,
           availableMcpServerIds,
-          defaultMcpServerIds: defaultSessionMcpServerIds(
-            [...workspaceDefaultMcpServerIds].map((id) => ({ id }))
-          )
+          defaultMcpServerIds: [
+            ...connectionTools.map((tool) => tool.id),
+            ...apiIntegrationServerIds
+          ]
         });
         return {
           ...targetSessionExecutionBase,
@@ -4958,7 +5101,7 @@ function createScheduledTaskActivities(services) {
         task.rigId
       ) : null;
       if (generatedTarget && task.rigId && (!acceptedRig || !acceptedRig.activeVersion)) {
-        throw new Error(`rig has no active version to bind: ${task.rigId}`);
+        throw new Error(`sandbox environment has no active version to bind: ${task.rigId}`);
       }
       const acceptedRigDefaultVariableSets = acceptedRig?.activeVersion ? await Promise.all(
         acceptedRig.activeVersion.defaultVariableSetIds.map(async (variableSetId) => {
@@ -4972,7 +5115,9 @@ function createScheduledTaskActivities(services) {
             variableSetId
           );
           if (!variableSet) {
-            throw new Error(`rig default Variable Set not found: ${variableSetId}`);
+            throw new Error(
+              `sandbox environment default Variable Set not found: ${variableSetId}`
+            );
           }
           return { id: variableSet.id, generation: variableSet.generation };
         })
@@ -5130,6 +5275,7 @@ function createScheduledTaskActivities(services) {
           targetSessionExecution,
           generatedSessionBinding,
           personalConnectionDelegations: taskPersonalConnectionDelegations,
+          mcpAccountBindings: taskMcpAccountBindings,
           personalResourceAuthoritySubjectId: taskPersonalResourceAuthoritySubjectId,
           causalHumanSubjectId,
           causalHumanAuthority: taskRevisionAuthority,
@@ -5243,13 +5389,7 @@ function createScheduledTaskActivities(services) {
                 taskId: task.id
               }
             );
-            if (stableJson({
-              task: exactAuthority.task,
-              personalConnectionDelegations: exactAuthority.personalConnectionDelegations
-            }) !== stableJson({
-              task,
-              personalConnectionDelegations: taskPersonalConnectionDelegations
-            })) {
+            if (stableJson(exactAuthority) !== stableJson(task)) {
               throw new IncidentTelemetryPreflightBlockedError(
                 "incident_preflight_metadata_missing"
               );
@@ -5270,14 +5410,16 @@ function createScheduledTaskActivities(services) {
             if (task.rigId) {
               const rig = acceptedRig;
               if (!rig || !rig.activeVersion) {
-                throw new Error(`rig has no active version to bind: ${task.rigId}`);
+                throw new Error(`sandbox environment has no active version to bind: ${task.rigId}`);
               }
               frozenRigId = rig.id;
               frozenRigVersionId = runPersonalResourceAuthority?.resources.find(
                 (resource) => resource.resourceKind === "rig" && resource.resourceId === rig.id
               )?.resourceVersionId ?? rig.activeVersion.id;
               if (frozenRigVersionId !== rig.activeVersion.id) {
-                throw new Error("scheduled run rig version changed during admission");
+                throw new Error(
+                  "scheduled run sandbox environment version changed during admission"
+                );
               }
             }
             let session;
@@ -5577,6 +5719,7 @@ function createScheduledTaskActivities(services) {
                   ...taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? { xaiAuthoritySubjectId: task.createdBy.subjectId } : {}
                 },
                 personalConnectionDelegations: taskPersonalConnectionDelegations,
+                mcpAccountBindings: taskMcpAccountBindings,
                 xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
                 scheduledTaskRunId: run.id
               },
@@ -5686,6 +5829,7 @@ function createScheduledTaskActivities(services) {
                   ...taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? { xaiAuthoritySubjectId: task.createdBy.subjectId } : {}
                 },
                 personalConnectionDelegations: taskPersonalConnectionDelegations,
+                mcpAccountBindings: taskMcpAccountBindings,
                 xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
                 scheduledTaskRunId: run.id
               },
@@ -5941,46 +6085,38 @@ function scheduledSessionRejectionError(rejectionReason) {
 }
 async function prepareIncidentTelemetrySource(input) {
   const session = await requireSession(input.tx, input.workspaceId, input.sessionId);
-  const { task, personalConnectionDelegations } = input.acceptedExecution ? {
-    task: input.acceptedExecution.task,
-    personalConnectionDelegations: input.acceptedExecution.personalConnectionDelegations
-  } : await requireScheduledTaskIncidentAuthorityInTransaction(input.tx, {
-    workspaceId: input.workspaceId,
-    taskId: input.taskId
-  });
+  const { task, personalConnectionDelegations } = input.acceptedExecution;
   const responder = await resolveIncidentTelemetryResponderMetadata({
     db: input.tx,
     settings: input.settings,
     task,
     session,
     personalConnectionDelegations,
-    personalResourceAuthoritySubjectId: input.acceptedExecution?.personalResourceAuthoritySubjectId ?? null,
-    ...input.acceptedExecution ? {
-      executionPolicy: input.acceptedExecution.targetSessionExecution ? {
-        tools: input.acceptedExecution.targetSessionExecution.tools,
-        firstPartyMcpTools: input.acceptedExecution.targetSessionExecution.firstPartyMcpTools,
-        firstPartyMcpPermissions: input.acceptedExecution.targetSessionExecution.firstPartyMcpPermissions,
-        variableSetIds: input.acceptedExecution.targetSessionExecution.variableSets.map(
-          (variableSet) => variableSet.id
-        ),
-        variableSetId: input.acceptedExecution.targetSessionExecution.variableSetId,
-        rigId: input.acceptedExecution.targetSessionExecution.rigId,
-        rigVersionId: input.acceptedExecution.targetSessionExecution.rigVersionId,
-        toolPolicy: input.acceptedExecution.targetSessionExecution.toolPolicy,
-        mcpServerIds: input.acceptedExecution.targetSessionExecution.mcpServerIds,
-        toolPolicyVersion: input.acceptedExecution.targetSessionExecution.toolPolicyVersion
-      } : {
-        tools: input.acceptedExecution.resolvedTools,
-        firstPartyMcpTools: input.acceptedExecution.resolvedFirstPartyMcpTools,
-        firstPartyMcpPermissions: input.acceptedExecution.resolvedFirstPartyMcpPermissions,
-        variableSetId: input.acceptedExecution.resolvedVariableSet?.id ?? null,
-        rigId: input.acceptedExecution.resolvedRig?.id ?? null,
-        rigVersionId: input.acceptedExecution.resolvedRig?.versionId ?? null,
-        toolPolicy: session.toolPolicy,
-        mcpServerIds: [],
-        toolPolicyVersion: session.toolPolicyVersion
-      }
-    } : {}
+    personalResourceAuthoritySubjectId: input.acceptedExecution.personalResourceAuthoritySubjectId ?? null,
+    executionPolicy: input.acceptedExecution.targetSessionExecution ? {
+      tools: input.acceptedExecution.targetSessionExecution.tools,
+      firstPartyMcpTools: input.acceptedExecution.targetSessionExecution.firstPartyMcpTools,
+      firstPartyMcpPermissions: input.acceptedExecution.targetSessionExecution.firstPartyMcpPermissions,
+      variableSetIds: input.acceptedExecution.targetSessionExecution.variableSets.map(
+        (variableSet) => variableSet.id
+      ),
+      variableSetId: input.acceptedExecution.targetSessionExecution.variableSetId,
+      rigId: input.acceptedExecution.targetSessionExecution.rigId,
+      rigVersionId: input.acceptedExecution.targetSessionExecution.rigVersionId,
+      toolPolicy: input.acceptedExecution.targetSessionExecution.toolPolicy,
+      mcpServerIds: input.acceptedExecution.targetSessionExecution.mcpServerIds,
+      toolPolicyVersion: input.acceptedExecution.targetSessionExecution.toolPolicyVersion
+    } : {
+      tools: input.acceptedExecution.resolvedTools,
+      firstPartyMcpTools: input.acceptedExecution.resolvedFirstPartyMcpTools,
+      firstPartyMcpPermissions: input.acceptedExecution.resolvedFirstPartyMcpPermissions,
+      variableSetId: input.acceptedExecution.resolvedVariableSet?.id ?? null,
+      rigId: input.acceptedExecution.resolvedRig?.id ?? null,
+      rigVersionId: input.acceptedExecution.resolvedRig?.versionId ?? null,
+      toolPolicy: session.toolPolicy,
+      mcpServerIds: [],
+      toolPolicyVersion: session.toolPolicyVersion
+    }
   });
   const preflight = evaluateIncidentTelemetryPreflight({
     agentConfig: task.agentConfig,
@@ -6370,6 +6506,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
         ...input.acceptedExecution.xaiAuthoritySubjectId ? { xaiAuthoritySubjectId: input.acceptedExecution.xaiAuthoritySubjectId } : {}
       },
       personalConnectionDelegations: input.acceptedExecution.personalConnectionDelegations,
+      mcpAccountBindings: input.acceptedExecution.mcpAccountBindings ?? null,
       xaiProviderAccountAuthoritySnapshot: input.acceptedExecution.xaiProviderAccountAuthoritySnapshot,
       scheduledTaskRunId: input.run.id
     },
@@ -6766,6 +6903,7 @@ import {
   applySessionTurnSettlement,
   enqueueSessionWorkflowWake,
   failSessionWorkBeforeAttemptClaim,
+  blockSessionWorkBeforeAttemptClaim,
   requestSessionTurnRecovery,
   recoverSessionDispatch,
   reconcileSessionAttemptQuiescence,
@@ -6782,12 +6920,14 @@ import {
   settleSessionIdleWithParentOutbox
 } from "@opengeni/db";
 import { publishDurableSessionEvents as publishDurableSessionEvents2 } from "@opengeni/events";
+import { CancelledFailure } from "@temporalio/activity";
 var WORKER_DEATH_MAX_REDISPATCHES = 3;
 function createSessionStateActivities(services, overrides = {}) {
   const settleSessionAttemptInterruptionsFn = overrides.settleSessionAttemptInterruptions ?? settleSessionAttemptInterruptions;
   const applySessionTurnSettlementFn = overrides.applySessionTurnSettlement ?? applySessionTurnSettlement;
   const enqueueSessionWorkflowWakeFn = overrides.enqueueSessionWorkflowWake ?? enqueueSessionWorkflowWake;
   const failSessionWorkBeforeAttemptClaimFn = overrides.failSessionWorkBeforeAttemptClaim ?? failSessionWorkBeforeAttemptClaim;
+  const blockSessionWorkBeforeAttemptClaimFn = overrides.blockSessionWorkBeforeAttemptClaim ?? blockSessionWorkBeforeAttemptClaim;
   const requestSessionTurnRecoveryFn = overrides.requestSessionTurnRecovery ?? requestSessionTurnRecovery;
   const recoverSessionDispatchFn = overrides.recoverSessionDispatch ?? recoverSessionDispatch;
   const reconcileSessionAttemptQuiescenceFn = overrides.reconcileSessionAttemptQuiescence ?? reconcileSessionAttemptQuiescence;
@@ -6830,6 +6970,24 @@ function createSessionStateActivities(services, overrides = {}) {
       });
       if (attempt) return { action: "stale" };
       const preClaimFailureDisposition = input.preClaimFailure?.disposition ?? input.preClaimFailureDisposition;
+      if (preClaimFailureDisposition === "blocked" && input.admissionFence && input.preClaimFailure?.reason) {
+        const blocked = await blockSessionWorkBeforeAttemptClaimFn(db, input.workspaceId, {
+          accountId: input.accountId,
+          sessionId: input.sessionId,
+          workflowId,
+          attemptId: input.attemptId,
+          fence: input.admissionFence,
+          reason: input.preClaimFailure.reason,
+          sqlState: input.preClaimFailure.sqlState ?? null
+        });
+        await publishDurableSessionEventsFn(
+          bus,
+          input.workspaceId,
+          input.sessionId,
+          blocked.events
+        );
+        return { action: blocked.action };
+      }
       if (preClaimFailureDisposition === "permanent" && input.trigger) {
         const failed = await failSessionWorkBeforeAttemptClaimFn(db, input.workspaceId, {
           accountId: input.accountId,
@@ -6837,7 +6995,12 @@ function createSessionStateActivities(services, overrides = {}) {
           workflowId,
           trigger: input.trigger,
           error: input.error ?? "Agent turn admission failed before attempt claim.",
-          ...input.preClaimFailure ? { admissionFailure: input.preClaimFailure } : {}
+          ...input.preClaimFailure?.disposition === "permanent" ? {
+            admissionFailure: {
+              disposition: "permanent",
+              code: input.preClaimFailure.code
+            }
+          } : {}
         });
         if (failed.action === "terminal") return { action: "terminal" };
         if (failed.action === "stale") return { action: "stale" };
@@ -7091,8 +7254,39 @@ function createSessionStateActivities(services, overrides = {}) {
     return { action: "recovering" };
   }
   async function peekSessionWork(input) {
-    const { db, observability } = await services();
-    const peek = await peekSessionWorkFn(db, input.workspaceId, input.sessionId);
+    const { db, observability, inspectSessionAttemptActivity } = await services();
+    const peek = await peekSessionWorkFn(
+      db,
+      input.workspaceId,
+      input.sessionId,
+      input.includeAdmissionFence,
+      input.observerAccountId
+    );
+    if (peek.kind === "unavailable") return peek;
+    if (peek.kind === "attempt-owned") {
+      let ownerActivityState = "unknown";
+      if (inspectSessionAttemptActivity) {
+        try {
+          ownerActivityState = await inspectSessionAttemptActivity(peek.activityRef);
+        } catch (error) {
+          if (error instanceof CancelledFailure) throw error;
+          if (currentActivityContext()?.cancellationSignal.aborted)
+            throw new CancelledFailure("Control observation cancelled");
+        }
+      }
+      if (currentActivityContext()?.cancellationSignal.aborted)
+        throw new CancelledFailure("Control observation cancelled");
+      const current = await peekSessionWorkFn(
+        db,
+        input.workspaceId,
+        input.sessionId,
+        input.includeAdmissionFence,
+        input.observerAccountId
+      );
+      if (current.kind !== "attempt-owned" || current.turnId !== peek.turnId || current.attemptId !== peek.attemptId || current.executionGeneration !== peek.executionGeneration || current.activityRef.workflowId !== peek.activityRef.workflowId || current.activityRef.workflowRunId !== peek.activityRef.workflowRunId || current.activityRef.activityId !== peek.activityRef.activityId)
+        return current;
+      return { ...current, ownerActivityState };
+    }
     await refreshQueuedTurnsGauge(db, observability, countQueuedTurnsFn, recordTurnsQueuedGaugeFn);
     return peek;
   }
@@ -7173,6 +7367,7 @@ import {
   getWorkspaceControlEvent
 } from "@opengeni/db";
 import { publishDurableWorkspaceControlEvent } from "@opengeni/events";
+import { recordWorkflowWakeReconciliation } from "@opengeni/observability";
 var BATCH_SIZE = 1e3;
 var MAX_DELIVERIES_PER_ACTIVITY = 1e4;
 var MAX_TITLE_FANOUT_PER_ACTIVITY = 1e3;
@@ -7258,23 +7453,7 @@ function createWorkflowWakeActivities(services) {
         pendingAdmissionBlockers,
         exhaustedBatchLimit
       };
-      if (claimed > 0) {
-        service.observability.info("session workflow wake delivery reconciled", {
-          claimed,
-          signaled,
-          delivered,
-          pendingAdmission,
-          unconfirmed,
-          failed,
-          exhaustedBatchLimit,
-          ...Object.fromEntries(
-            Object.entries(pendingAdmissionBlockers).map(([blocker, count]) => [
-              `pendingAdmissionBlockers.${blocker}`,
-              count
-            ])
-          )
-        });
-      }
+      recordWorkflowWakeReconciliation(service.observability, result);
       return result;
     }
   };
@@ -7319,4 +7498,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-HMFGSKC5.js.map
+//# sourceMappingURL=activities-control-BOLIY3H4.js.map