@opengeni/worker-bundle 1.0.0-canary.0 → 1.0.0

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

@@ -8,6 +8,7 @@ import {
 import {
   INCIDENT_TELEMETRY_AUTHORITY_FENCE_LINEAGE_KEY,
   MAX_AUTOMATIC_PROVIDER_RECOVERIES,
+  agentRunAdmissionDenial,
   assertReusableSessionRevivable,
   captureConnectedCommandOutput,
   createCodexCapacityActivities,
@@ -23,59 +24,147 @@ import {
   notifyParentOfChildIdle,
   persistWorkspaceArchiveCandidate,
   providerRecoveryCountFromMetadata,
+  publishDurableSessionEvents,
   putVersion1TarArchiveOrInline,
   reconcileAutomaticSessionTitleFanout,
   reconcilePendingParentSystemUpdates,
   reconcilePendingSessionWorkflowWakes,
   resolveIncidentTelemetryResponderMetadata,
-  resolveWorkspacePackRuntime,
   rigProviderImageSourceImage,
   scheduledUserMessagePayload,
+  warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-CYITU5UH.js";
+} from "./chunk-LJX7Z2KP.js";
 import {
   inspectOpenSandboxKubernetesInventory,
+  recordActiveUserGauges,
   recordCreditBalanceGauges,
+  recordCreditGrantGauges,
   recordCreditMicros,
   recordExpiredDrainingSandboxLeaseGauges,
+  recordManagedAuthNewSignupsSwitchGauge,
   recordOpenSandboxKubernetesInventoryGauges,
   recordRetainedProcessInventoryGauges,
   recordRetainedProcessReconciliation,
   recordSandboxCheckpointArtifactGauges,
   recordSandboxCheckpointArtifactOutcome,
+  recordSandboxCommandContainment,
   recordSandboxDeadlineRotationsRequested,
   recordSandboxInventoryProjectionFailure,
   recordSandboxInventoryProjectionSuccess,
   recordSandboxLeaseGauges,
   recordSandboxOrphansTerminated,
+  recordSandboxProviderMissingBeforeCapture,
+  recordSandboxRecoveryObservationGauges,
   recordSandboxRotationBacklogGauges,
   recordTurnsQueuedGauge,
+  recordVerifiedSignupTrialDeploymentFlagGauge,
+  recordVerifiedSignupTrialSwitchGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-A4XQWVZK.js";
+} from "./chunk-3ZTRWDMN.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
 import { configuredStaticUsageLimits } from "@opengeni/config";
+import { documentEmbeddingCostMicros, paidDocumentEmbedding } from "@opengeni/core";
 import {
+  applyCreditDebitAfterUse,
   appendKnowledgeIndexChunks,
   claimKnowledgeIndexJobs,
+  checkWorkspaceAllowance,
   completeKnowledgeIndexJob,
   continueKnowledgeIndexJob,
+  creditDebitAttributionMetadata,
   deferKnowledgeIndexJob,
+  freezeKnowledgeIndexBillingMode,
   getBillingBalance,
+  guardPaidKnowledgeIndexPublication,
+  knowledgeIndexBillingActivationTime,
   readKnowledgeIndexSource,
   recordUsageEvent,
   sumUsageQuantity,
-  withWorkspaceUsageLock
+  withWorkspaceUsageLock,
+  waitKnowledgeIndexForFunding
 } from "@opengeni/db";
+var KnowledgeIndexUsageLimitError = class extends Error {
+  constructor() {
+    super("monthly document indexing limit reached");
+    this.name = "KnowledgeIndexUsageLimitError";
+  }
+};
+function knowledgeIndexFailureDiagnostic(stage, error) {
+  if (error instanceof KnowledgeIndexUsageLimitError) {
+    return {
+      errorClass: "KnowledgeIndexOperationError",
+      errorCode: "knowledge_index_usage_limit_reached",
+      origin: "worker"
+    };
+  }
+  if (stage === "embedding") {
+    const status = ownValue(error, "status");
+    return {
+      errorClass: "KnowledgeIndexOperationError",
+      errorCode: "knowledge_index_embedding_failed",
+      origin: "worker",
+      ...typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 ? { status } : {}
+    };
+  }
+  const postgres = postgresErrorState(error);
+  if (!postgres) {
+    return {
+      errorClass: "KnowledgeIndexOperationError",
+      errorCode: "knowledge_index_failed",
+      origin: "worker"
+    };
+  }
+  return {
+    errorClass: "KnowledgeIndexOperationError",
+    errorCode: "knowledge_index_persistence_failed",
+    origin: "db",
+    ...postgres.sqlState ? { sqlState: postgres.sqlState } : {}
+  };
+}
+function ownValue(value, key) {
+  try {
+    if (!value || typeof value !== "object") return void 0;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function postgresErrorState(error) {
+  let current = error;
+  for (let depth = 0; depth < 4 && current && typeof current === "object"; depth += 1) {
+    if (ownValue(current, "name") === "PostgresError") {
+      const code = ownValue(current, "code");
+      return typeof code === "string" && /^[0-9A-Z]{5}$/.test(code) ? { sqlState: code } : {};
+    }
+    current = ownValue(current, "cause");
+  }
+  return void 0;
+}
 function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
+  let activationTime;
   return {
     indexKnowledge: async () => {
       const result = { completed: 0, advanced: 0, deferred: 0, unavailable: 0 };
       if (!resolveDocumentServices) return result;
       const { db, settings, observability } = await services();
+      let policyActivatedAt;
+      if (paidDocumentEmbedding(settings)) {
+        if (!settings.documentEmbeddingCreditsActivatedAt)
+          throw new Error("paid Knowledge embedding requires an activation cutoff");
+        policyActivatedAt = new Date(settings.documentEmbeddingCreditsActivatedAt);
+      } else {
+        activationTime ??= knowledgeIndexBillingActivationTime(db).catch((error) => {
+          activationTime = void 0;
+          throw error;
+        });
+        policyActivatedAt = await activationTime;
+      }
       const { embedder } = await resolveDocumentServices();
       const { knowledgeIndexChunks } = await import("@opengeni/documents");
       const claims = await claimKnowledgeIndexJobs(db, {
@@ -84,6 +173,7 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
         limit: 2
       });
       for (const claim of claims) {
+        let stage = "processing";
         try {
           const source = await readKnowledgeIndexSource(db, claim);
           if (!source) {
@@ -107,9 +197,57 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
               chunks.push(chunk);
             }
             if (chunks.length) {
-              if (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed") {
+              const frozenPolicy = await freezeKnowledgeIndexBillingMode(
+                lockedDb,
+                claim,
+                // Deterministic embeddings incur no provider charge; a valid
+                // credits-mode config with zero tariff must still index them.
+                // OpenAI shadow keeps its price snapshot for internal estimates.
+                settings.documentEmbeddingProvider === "openai" ? settings.documentEmbeddingBillingMode ?? "usage_only" : "usage_only",
+                policyActivatedAt,
+                settings.documentEmbeddingRateMicrosPerMillionBytes ?? 0
+              );
+              if (frozenPolicy.mode === "awaiting_review") {
+                result.deferred++;
+                return;
+              }
+              if (frozenPolicy.mode === "obsolete") {
+                result.unavailable++;
+                return;
+              }
+              if (frozenPolicy.mode === "credits" && !paidDocumentEmbedding(settings)) {
+                await deferKnowledgeIndexJob(lockedDb, claim);
+                result.deferred++;
+                return;
+              }
+              const paid = frozenPolicy.mode === "credits";
+              if (paid && claim.billingAttribution.kind === "unknown") {
+                observability.warn("Paid Knowledge indexing awaits initiating attribution", {
+                  errorCode: "knowledge_index_attribution_unavailable"
+                });
+                await deferKnowledgeIndexJob(lockedDb, claim);
+                result.deferred++;
+                return;
+              }
+              if (paid && current.nextIndex === 0) {
                 const balance = await getBillingBalance(lockedDb, claim.accountId);
-                if (balance.balanceMicros <= 0) throw new Error("insufficient OpenGeni credits");
+                if (balance.balanceMicros <= 0) {
+                  await waitKnowledgeIndexForFunding(lockedDb, claim);
+                  result.deferred++;
+                  return;
+                }
+              }
+              if (paid) {
+                const refusal = await checkWorkspaceAllowance(lockedDb, {
+                  accountId: claim.accountId,
+                  workspaceId: current.billingWorkspaceId,
+                  subjectId: claim.billingAttribution.kind === "turn" || claim.billingAttribution.kind === "human" ? claim.billingAttribution.initiatingHumanSubjectId : null
+                });
+                if (refusal) {
+                  await deferKnowledgeIndexJob(lockedDb, claim);
+                  result.deferred++;
+                  return;
+                }
               }
               if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
                 const limit = configuredStaticUsageLimits(settings).maxDocumentIndexedChunksPerWorkspace;
@@ -120,13 +258,27 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                     eventType: "document.indexed",
                     since: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))
                   });
-                  if (used + chunks.length > limit)
-                    throw new Error("monthly document indexing limit reached");
+                  if (used + chunks.length > limit) throw new KnowledgeIndexUsageLimitError();
                 }
               }
-              const vectors = await embedder.embedMany(chunks.map((chunk) => chunk.embeddingInput));
+              const inputs = chunks.map((chunk) => chunk.embeddingInput);
+              const bytes = inputs.reduce(
+                (sum, input) => sum + Buffer.byteLength(input, "utf8"),
+                0
+              );
+              stage = "embedding";
+              const vectors = await embedder.embedMany(inputs);
               if (vectors.length !== chunks.length)
                 throw new Error("Incomplete Knowledge embeddings");
+              stage = "processing";
+              if (paid) {
+                const publication = await guardPaidKnowledgeIndexPublication(lockedDb, claim);
+                if (publication !== "published") {
+                  if (publication === "obsolete") result.unavailable++;
+                  else result.deferred++;
+                  return;
+                }
+              }
               const appended = await appendKnowledgeIndexChunks(
                 lockedDb,
                 claim,
@@ -147,6 +299,62 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                 sourceResourceId: claim.revisionId,
                 idempotencyKey: `knowledge.indexed:${claim.revisionId}:${claim.generation}:${current.nextIndex}`
               });
+              await recordUsageEvent(lockedDb, {
+                accountId: claim.accountId,
+                workspaceId: current.billingWorkspaceId,
+                eventType: "document.embedding_bytes",
+                quantity: bytes,
+                unit: "byte",
+                sourceResourceType: "knowledge_revision",
+                sourceResourceId: claim.revisionId,
+                idempotencyKey: `knowledge.embedding_bytes:${claim.revisionId}:${claim.generation}:${current.nextIndex}`
+              });
+              if (frozenPolicy.mode === "shadow" && frozenPolicy.rateMicrosPerMillionBytes > 0) {
+                const estimate = documentEmbeddingCostMicros(
+                  {
+                    ...settings,
+                    documentEmbeddingRateMicrosPerMillionBytes: frozenPolicy.rateMicrosPerMillionBytes
+                  },
+                  bytes
+                );
+                if (estimate > 0)
+                  await recordUsageEvent(lockedDb, {
+                    accountId: claim.accountId,
+                    workspaceId: current.billingWorkspaceId,
+                    eventType: "document.embedding_shadow_estimate",
+                    quantity: estimate,
+                    unit: "micro_usd",
+                    sourceResourceType: "knowledge_revision",
+                    sourceResourceId: claim.revisionId,
+                    idempotencyKey: `knowledge.embedding_shadow:${claim.revisionId}:${claim.generation}:${current.nextIndex}`
+                  });
+              }
+              if (paid) {
+                const cost = documentEmbeddingCostMicros(
+                  {
+                    ...settings,
+                    documentEmbeddingRateMicrosPerMillionBytes: frozenPolicy.rateMicrosPerMillionBytes
+                  },
+                  bytes
+                );
+                if (cost > 0)
+                  await applyCreditDebitAfterUse(lockedDb, {
+                    accountId: claim.accountId,
+                    workspaceId: current.billingWorkspaceId,
+                    type: "document_embedding_debit",
+                    amountMicros: cost,
+                    sourceType: "knowledge_revision",
+                    sourceId: claim.revisionId,
+                    idempotencyKey: `knowledge.embedding:${claim.revisionId}:${claim.generation}:${current.nextIndex}`,
+                    metadata: {
+                      ...creditDebitAttributionMetadata(claim.billingAttribution),
+                      model: claim.model,
+                      bytes,
+                      chunks: chunks.length,
+                      rateMicrosPerMillionBytes: frozenPolicy.rateMicrosPerMillionBytes
+                    }
+                  });
+              }
             }
             if (more) {
               await continueKnowledgeIndexJob(lockedDb, claim);
@@ -161,14 +369,19 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
               else result.unavailable++;
             }
           });
-        } catch {
-          await deferKnowledgeIndexJob(db, claim).catch(() => void 0);
-          result.deferred++;
-          observability.warn("Knowledge indexing batch deferred", {
-            accountId: claim.accountId,
-            entryId: claim.entryId,
-            revisionId: claim.revisionId
+        } catch (error) {
+          observability.warn(
+            "Knowledge indexing batch deferred",
+            knowledgeIndexFailureDiagnostic(stage, error)
+          );
+          await deferKnowledgeIndexJob(db, claim).catch((deferError) => {
+            const deferDiagnostic = knowledgeIndexFailureDiagnostic("processing", deferError);
+            observability.warn("Knowledge indexing batch deferral failed", {
+              ...deferDiagnostic,
+              errorCode: "knowledge_index_defer_failed"
+            });
           });
+          result.deferred++;
         }
       }
       return result;
@@ -260,6 +473,240 @@ function cleanupErrorCategory(error) {
   return typeof code === "string" && SAFE_PROVIDER_ERROR_CODES.has(code) ? code : "unknown";
 }
 
+// src/activities/browser-deadline-checkpoint.ts
+import { Context } from "@temporalio/activity";
+import {
+  environmentsEncryptionKeyBytes,
+  resolveFirstPartyDelegationSecret
+} from "@opengeni/config";
+import { BROWSER_STATE_ARTIFACT_CONTENT_TYPE } from "@opengeni/contracts";
+import {
+  browserDeadlineCheckpoint,
+  clearSuspendedBrowserSessionController,
+  commitBrowserSessionSuspension,
+  dispatchBrowserSessionOperation,
+  failBrowserSessionSuspension,
+  listBrowserDeadlineCheckpoints,
+  readLease,
+  releaseLeaseHolder,
+  withRlsContext
+} from "@opengeni/db";
+import { deriveBrowserControllerAdminToken } from "@opengeni/interaction/browser-controller-authority";
+import {
+  browserStateArtifactAad,
+  browserStateManifestDigest,
+  browserStateObjectKey,
+  deriveBrowserStateDataKey,
+  wrapBrowserStateDataKey
+} from "@opengeni/interaction/browser-state-authority";
+import {
+  BrowserControlClient,
+  BrowserControlRequestError,
+  createSandboxClientForBackend,
+  deserializeSandboxSessionStateEnvelope,
+  resumeExactSandboxSession
+} from "@opengeni/runtime";
+var UPLOAD_CLEANUP_GRACE_MS = 24 * 60 * 6e4;
+function heartbeat() {
+  try {
+    Context.current().heartbeat();
+  } catch {
+  }
+}
+async function withActivityHeartbeat(run) {
+  heartbeat();
+  const timer = setInterval(heartbeat, 5e3);
+  try {
+    return await run();
+  } finally {
+    clearInterval(timer);
+  }
+}
+async function resumeCheckpointController({
+  target,
+  lease,
+  settings,
+  controllerRoot
+}) {
+  const provider = createSandboxClientForBackend("modal", settings);
+  const envelope = lease.resumeState;
+  const state = await deserializeSandboxSessionStateEnvelope(
+    provider,
+    envelope.sessionState ?? lease.resumeState,
+    target.instanceId
+  );
+  const resumed = await resumeExactSandboxSession(provider, "modal", state, target.instanceId);
+  return new BrowserControlClient(resumed.session, {
+    adminToken: deriveBrowserControllerAdminToken({
+      rootSecret: controllerRoot,
+      accountId: target.accountId,
+      workspaceId: target.workspaceId,
+      placement: { kind: "sandbox_group", sandboxGroupId: target.sandboxGroupId },
+      placementInstanceId: target.instanceId
+    })
+  });
+}
+function createBrowserDeadlineCheckpointActivities(services, connectController = resumeCheckpointController) {
+  return {
+    async listDueBrowserCheckpoints() {
+      return await withActivityHeartbeat(async () => {
+        const { db, settings, objectStorage } = await services();
+        if (!settings.sandboxOwnershipEnabled || !objectStorage || !resolveFirstPartyDelegationSecret(settings))
+          return [];
+        const root = environmentsEncryptionKeyBytes(settings);
+        if (!root) return [];
+        root.fill(0);
+        return await listBrowserDeadlineCheckpoints(db);
+      });
+    },
+    async checkpointBrowserBeforeDeadline(target) {
+      return await withActivityHeartbeat(async () => {
+        const { db, settings, objectStorage } = await services();
+        const rootKey = environmentsEncryptionKeyBytes(settings);
+        const controllerRoot = resolveFirstPartyDelegationSecret(settings);
+        if (!rootKey || !objectStorage || !controllerRoot) {
+          rootKey?.fill(0);
+          throw new Error("browser deadline checkpoint storage or encryption is unavailable");
+        }
+        let dataKey = null;
+        let aad = null;
+        let timer = null;
+        try {
+          const claim = await browserDeadlineCheckpoint(db, target, { prepare: true, touch: true });
+          if (!claim) return { status: "skipped" };
+          let pulseRunning = false;
+          let authorityLost = false;
+          const pulse = async () => {
+            if (pulseRunning) return;
+            pulseRunning = true;
+            try {
+              if (!await browserDeadlineCheckpoint(db, target, { touch: true }))
+                authorityLost = true;
+            } finally {
+              pulseRunning = false;
+            }
+          };
+          timer = setInterval(() => {
+            void pulse().catch(() => void 0);
+          }, 5e3);
+          const lease = await readLease(db, target.workspaceId, target.sandboxGroupId);
+          if (!lease || lease.instanceId !== target.instanceId || lease.leaseEpoch !== target.leaseEpoch || !lease.resumeState) {
+            throw new Error("browser deadline checkpoint placement changed");
+          }
+          const placement = {
+            kind: "sandbox_group",
+            sandboxGroupId: target.sandboxGroupId
+          };
+          const client = await connectController({ target, lease, settings, controllerRoot });
+          if (authorityLost || !await browserDeadlineCheckpoint(db, target, { touch: true })) {
+            throw new Error("browser deadline checkpoint authority changed");
+          }
+          if (claim.state !== "completed") {
+            const scope = { ...target, operationId: claim.operationId };
+            const objectKey = browserStateObjectKey(target.workspaceId, claim.operationId);
+            dataKey = deriveBrowserStateDataKey(rootKey, { ...scope, objectKey });
+            aad = browserStateArtifactAad({ ...scope, objectKey });
+            await dispatchBrowserSessionOperation(db, {
+              ...scope,
+              deadlineTarget: target,
+              stateUpload: {
+                objectKey,
+                cleanupAfter: new Date(Date.now() + UPLOAD_CLEANUP_GRACE_MS)
+              }
+            });
+            const signed = await objectStorage.createPutUrl({
+              key: objectKey,
+              contentType: BROWSER_STATE_ARTIFACT_CONTENT_TYPE,
+              audience: "sandbox"
+            });
+            const receipt = await client.captureState({
+              ...scope,
+              objectKey,
+              afterCapture: "stop",
+              dataKey,
+              aad,
+              upload: {
+                url: signed.url,
+                requiredHeaders: signed.requiredHeaders,
+                expiresAt: signed.expiresAt.toISOString()
+              }
+            }).catch(async (error) => {
+              if (error instanceof BrowserControlRequestError && (error.error.code === "outcome_unknown" || !error.error.retryable)) {
+                await failBrowserSessionSuspension(db, { ...scope, error: error.error });
+              }
+              throw error;
+            });
+            if (authorityLost) throw new Error("browser deadline checkpoint authority changed");
+            const portable = receipt.manifest.profileCrypto !== "platform_bound";
+            await commitBrowserSessionSuspension(db, {
+              ...scope,
+              deadlineTarget: target,
+              artifact: {
+                kind: "chromium_profile",
+                format: receipt.format,
+                objectKey,
+                artifactDigest: receipt.artifactDigest,
+                contentDigest: receipt.contentDigest,
+                manifestDigest: browserStateManifestDigest(receipt.manifest),
+                sizeBytes: receipt.sizeBytes,
+                encryptedDataKey: wrapBrowserStateDataKey(rootKey, dataKey, {
+                  ...scope,
+                  objectKey,
+                  artifactDigest: receipt.artifactDigest,
+                  contentDigest: receipt.contentDigest
+                }),
+                materialization: {
+                  portability: portable ? "portable" : "placement_bound",
+                  reason: portable ? null : "Profile encryption depends on the source operating-system credential store.",
+                  platform: receipt.manifest.platform,
+                  architecture: receipt.manifest.architecture,
+                  engine: receipt.manifest.engine,
+                  engineVersion: receipt.manifest.engineVersion,
+                  driverId: receipt.manifest.driverId,
+                  driverSchemaVersion: receipt.manifest.driverSchemaVersion,
+                  profileCrypto: receipt.manifest.profileCrypto,
+                  providerId: null,
+                  placement: portable ? null : placement
+                }
+              }
+            });
+          }
+          await client.endSession(target, { removeState: true }).catch((error) => {
+            if (!(error instanceof BrowserControlRequestError && error.status === 404)) throw error;
+          });
+          await withRlsContext(
+            db,
+            target,
+            async (tx) => {
+              if ((await browserDeadlineCheckpoint(tx, target))?.state !== "completed") {
+                throw new Error("browser deadline checkpoint cleanup authority changed");
+              }
+              await clearSuspendedBrowserSessionController(tx, {
+                ...target,
+                expectedControllerGeneration: target.controllerGeneration
+              });
+              await releaseLeaseHolder(tx, {
+                ...target,
+                kind: "interaction",
+                holderId: `browser-session:${target.browserSessionId}`,
+                idleGraceMs: settings.sandboxIdleGraceMs
+              });
+            },
+            void 0,
+            "none"
+          );
+          return { status: "suspended" };
+        } finally {
+          if (timer) clearInterval(timer);
+          dataKey?.fill(0);
+          aad?.fill(0);
+          rootKey.fill(0);
+        }
+      });
+    }
+  };
+}
+
 // src/activities/automations.ts
 import {
   resolveTurnExecutionPolicyV1,
@@ -267,88 +714,30 @@ import {
   WORKSPACE_OPENROUTER_MODEL_ID_PREFIX
 } from "@opengeni/config";
 import {
+  applySessionAgentConfigWriteThrough,
   assertWorkspaceModelPolicyAllows,
   canonicalConfiguredModel,
+  resolveSessionAgentConfigForCreate,
   createAndStartSessionWithOutcome,
   recordWorkspaceUsage,
   resolveCatalogSettings,
-  resolveWorkspaceCatalogSettings
+  resolveWorkspaceCatalogSettings,
+  isDeveloperSetupDelegatedPermissionAllowed
 } from "@opengeni/core";
 import {
   AutomationAuthorityRevokedError,
   assertAutomationRunAuthorityInTransaction,
   claimAutomationRun,
-  settleAutomationRun
+  settleAutomationRun,
+  requireWorkspace
 } from "@opengeni/db";
 import { SessionSkills } from "@opengeni/contracts";
-
-// src/activities/agent-run-admission.ts
-import { configuredStaticUsageLimits as configuredStaticUsageLimits2 } from "@opengeni/config";
-import { modelFundingForAdmission } from "@opengeni/core";
-import { getBillingBalance as getBillingBalance2, isCodexBilledTurn, sumUsageQuantity as sumUsageQuantity2 } from "@opengeni/db";
-async function agentRunAdmissionDenial(services, input) {
-  const codexBilled = await isCodexBilledTurn({
-    db: services.db,
-    settings: services.settings,
-    workspaceId: input.workspaceId,
-    model: input.model
-  });
-  const externallyBilled = modelFundingForAdmission(
-    services.settings,
-    input.model,
-    codexBilled
-  ).fundedWithoutCredits;
-  if (!externallyBilled && (services.settings.billingMode === "stripe" || services.settings.usageLimitsMode === "managed")) {
-    if (services.entitlements) {
-      const decision = await services.entitlements.admitRun({
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        action: "agent_run:create",
-        quantity: input.requestedAgentRuns
-      });
-      if (!decision.allowed) return "insufficient_credits";
-    } else {
-      const balance = await getBillingBalance2(services.db, input.accountId);
-      if (balance.balanceMicros <= 0) return "insufficient_credits";
-    }
-  }
-  if (services.settings.usageLimitsMode !== "static" && services.settings.usageLimitsMode !== "managed") {
-    return null;
-  }
-  const limits = configuredStaticUsageLimits2(services.settings);
-  if (!externallyBilled && limits.maxMonthlyCostMicrosPerAccount) {
-    const used = await sumUsageQuantity2(services.db, {
-      accountId: input.accountId,
-      eventType: "model.cost",
-      since: startOfUtcMonth()
-    });
-    if (used >= limits.maxMonthlyCostMicrosPerAccount) {
-      return "monthly_model_cost_limit";
-    }
-  }
-  if (limits.maxMonthlyAgentRunsPerWorkspace) {
-    const used = await sumUsageQuantity2(services.db, {
-      workspaceId: input.workspaceId,
-      eventType: "agent_run.created",
-      since: startOfUtcMonth()
-    });
-    if (used + input.requestedAgentRuns > limits.maxMonthlyAgentRunsPerWorkspace) {
-      return "monthly_agent_run_limit";
-    }
-  }
-  return null;
-}
-function startOfUtcMonth() {
-  const now = /* @__PURE__ */ new Date();
-  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
-}
-
-// src/activities/automations.ts
 function createAutomationActivities(services, options = {}) {
   const claim = options.claim ?? claimAutomationRun;
   const settle = options.settle ?? settleAutomationRun;
   const assertAuthority = options.assertAuthority ?? assertAutomationRunAuthorityInTransaction;
   const createSession2 = options.createSession ?? createAndStartSessionWithOutcome;
+  const readWorkspace = options.readWorkspace ?? requireWorkspace;
   const admit = options.admit ?? agentRunAdmissionDenial;
   const assertModelPolicy = options.assertModelPolicy ?? assertWorkspaceModelPolicyAllows;
   const recordUsage = options.recordUsage ?? recordWorkspaceUsage;
@@ -393,6 +782,17 @@ function createAutomationActivities(services, options = {}) {
           return { action: "skipped", reason: "accepted_execution_mismatch" };
         }
         const template = accepted.sessionTemplate;
+        if (template.credentialRestriction === "developer_setup" && template.firstPartyMcpPermissions.some(
+          (permission) => !isDeveloperSetupDelegatedPermissionAllowed(permission)
+        )) {
+          await settle(service.db, {
+            workspaceId: input.workspaceId,
+            runId: run.id,
+            status: "failed",
+            errorCode: "credential_restriction_violation"
+          });
+          return { action: "failed", reason: "credential_restriction_violation" };
+        }
         const requestedModel = template.model ?? deploymentCatalogSettings.openaiModel;
         const catalogSettings = requestedModel.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) || requestedModel.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX) ? (await resolveWorkspaceCatalogSettings(service.db, catalogSourceSettings, {
           accountId: input.accountId,
@@ -445,7 +845,42 @@ function createAutomationActivities(services, options = {}) {
             reason: "interactive_compute_not_allowed"
           };
         }
-        const turnExecutionPolicy = resolveTurnExecutionPolicyV1(catalogSettings, {
+        let agentWriteThrough;
+        try {
+          const workspaceSettings = (await readWorkspace(service.db, input.workspaceId)).settings;
+          const resolution = resolveSessionAgentConfigForCreate({
+            settings: catalogSettings,
+            creator: "automation",
+            request: template.agent,
+            instructions: template.instructions ?? void 0,
+            workspaceSettings,
+            parent: null,
+            goal: false
+          });
+          const written = applySessionAgentConfigWriteThrough({
+            config: resolution.config,
+            firstPartyMcpTools: template.firstPartyMcpTools,
+            tools: template.tools,
+            toolPolicy: { mode: "explicit", inheritedFromSessionId: null },
+            productServerIds: template.tools.map((tool) => tool.id)
+          });
+          agentWriteThrough = {
+            config: resolution.config,
+            instructions: resolution.instructions,
+            firstPartyMcpTools: written.firstPartyMcpTools,
+            tools: written.tools
+          };
+        } catch (error) {
+          if (!isUnprocessableEntity(error)) throw error;
+          await settle(service.db, {
+            workspaceId: input.workspaceId,
+            runId: run.id,
+            status: "failed",
+            errorCode: "dispatch_failed"
+          });
+          return { action: "failed", reason: "dispatch_failed" };
+        }
+        const resolvedTurnExecutionPolicy = resolveTurnExecutionPolicyV1(catalogSettings, {
           modelId: model,
           requestedModelId: template.model,
           modelSource: template.model ? "explicit" : "deployment",
@@ -454,6 +889,10 @@ function createAutomationActivities(services, options = {}) {
           latencyMode: "standard",
           latencyModeSource: "deployment"
         });
+        const turnExecutionPolicy = template.credentialRestriction ? {
+          ...resolvedTurnExecutionPolicy,
+          credentialRestriction: template.credentialRestriction
+        } : resolvedTurnExecutionPolicy;
         const created = await createSession2({
           db: service.db,
           bus: service.bus,
@@ -476,10 +915,12 @@ function createAutomationActivities(services, options = {}) {
           accountId: input.accountId,
           workspaceId: input.workspaceId,
           initialMessage: accepted.initialMessage,
+          surface: "automation",
+          metrics: service.observability,
           resources: template.resources,
           skills: SessionSkills.parse(template.skills),
           bundledSkillIds: template.bundledSkillIds,
-          tools: template.tools,
+          tools: agentWriteThrough.tools,
           toolPolicy: { mode: "explicit", inheritedFromSessionId: null },
           model,
           reasoningEffort,
@@ -498,10 +939,11 @@ function createAutomationActivities(services, options = {}) {
             label: accepted.serviceLabel
           },
           createdByContext: accepted.provenance,
-          instructions: template.instructions,
+          instructions: agentWriteThrough.instructions ?? template.instructions,
           policyRole: template.policyRole,
           firstPartyMcpPermissions: template.firstPartyMcpPermissions,
-          firstPartyMcpTools: template.firstPartyMcpTools,
+          firstPartyMcpTools: agentWriteThrough.firstPartyMcpTools,
+          ...agentWriteThrough.config ? { agentConfig: agentWriteThrough.config } : {},
           retainWorkspaceCustomModel: model.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) || model.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX),
           createIdempotencyKey: `automation-run:${run.id}`,
           subjectId: accepted.serviceSubjectId
@@ -716,6 +1158,85 @@ function createFileUploadReaperActivities(services, options = {}) {
   return { reapExpiredFileUploads, recoverVideoGenerationWorkflows };
 }
 
+// src/activities/model-call-fact-reconciler.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { listWorkspaceIdsAfter, reconcileModelCallFacts } from "@opengeni/db";
+var MODEL_CALL_FACT_RECONCILE_LOOKBACK_MS = 2 * 60 * 60 * 1e3;
+var MODEL_CALL_FACT_RECONCILE_SETTLE_MS = 10 * 60 * 1e3;
+var MODEL_CALL_FACT_RECONCILE_WORKSPACE_LIMIT = 500;
+var MODEL_CALL_FACT_RECONCILE_RUN_BUDGET_MS = 3 * 60 * 1e3;
+var WORKSPACE_PAGE_SIZE = 200;
+function createModelCallFactReconcilerActivities(services, options = {}) {
+  const now = options.now ?? Date.now;
+  const runBudgetMs = options.runBudgetMs ?? MODEL_CALL_FACT_RECONCILE_RUN_BUDGET_MS;
+  const startAfterWorkspaceId = options.startAfterWorkspaceId ?? randomUUID2;
+  const reconcile = options.reconcile ?? reconcileModelCallFacts;
+  const listWorkspaces = options.listWorkspaces ?? listWorkspaceIdsAfter;
+  async function reconcileRecentModelCallFacts() {
+    const { db, observability } = await services();
+    const startedAt = now();
+    const until = new Date(startedAt - MODEL_CALL_FACT_RECONCILE_SETTLE_MS);
+    const since = new Date(until.getTime() - MODEL_CALL_FACT_RECONCILE_LOOKBACK_MS);
+    const result = {
+      workspaces: 0,
+      missing: 0,
+      repaired: 0,
+      unrepaired: 0,
+      truncatedWorkspaces: 0,
+      failedWorkspaces: 0,
+      budgetExhausted: false
+    };
+    const start = startAfterWorkspaceId();
+    let cursor = start;
+    let wrapped = false;
+    while (true) {
+      const page = await listWorkspaces(db, { afterId: cursor, limit: WORKSPACE_PAGE_SIZE });
+      const ids = wrapped ? page.filter((id) => id <= start) : page;
+      for (const workspaceId of ids) {
+        if (now() - startedAt >= runBudgetMs) {
+          result.budgetExhausted = true;
+          break;
+        }
+        result.workspaces += 1;
+        try {
+          const outcome = await reconcile(db, {
+            workspaceId,
+            since,
+            until,
+            limit: MODEL_CALL_FACT_RECONCILE_WORKSPACE_LIMIT
+          });
+          result.missing += outcome.missing;
+          result.repaired += outcome.repaired;
+          result.unrepaired += outcome.unrepaired;
+          if (outcome.truncated) result.truncatedWorkspaces += 1;
+        } catch (error) {
+          result.failedWorkspaces += 1;
+          observability.warn("model call fact reconciliation failed for a workspace", {
+            workspaceId,
+            errorName: error instanceof Error ? error.name : "unknown"
+          });
+        }
+      }
+      if (result.budgetExhausted) break;
+      if (wrapped && ids.length < page.length) break;
+      if (page.length < WORKSPACE_PAGE_SIZE) {
+        if (wrapped) break;
+        wrapped = true;
+        cursor = null;
+        continue;
+      }
+      cursor = page[page.length - 1];
+    }
+    if (result.failedWorkspaces > 0 || result.truncatedWorkspaces > 0 || result.budgetExhausted) {
+      observability.warn("model call fact reconciliation incomplete", { ...result });
+    } else if (result.missing > 0) {
+      observability.info("model call fact reconciliation", { ...result });
+    }
+    return result;
+  }
+  return { reconcileRecentModelCallFacts };
+}
+
 // src/activities/retained-screenshot-reaper.ts
 import {
   claimRetainedScreenshotMaintenance,
@@ -884,7 +1405,7 @@ import {
   markSandboxCheckpointArtifactDeletePending,
   recordWarmingSandboxCreated,
   registerSandboxCheckpointArtifact,
-  releaseLeaseHolder,
+  releaseLeaseHolder as releaseLeaseHolder2,
   touchLeaseHolder,
   updateRigChangeStatus,
   SandboxCheckpointArtifactRegistrationConflictError
@@ -978,13 +1499,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 +1524,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) {
@@ -1030,7 +1553,7 @@ function createRigVerificationActivityLifecycle(context = currentActivityContext
       Math.max(1, startToCloseTimeoutMs - reserveMs)
     );
   }
-  const heartbeat = () => {
+  const heartbeat2 = () => {
     if (!context) return;
     try {
       context.heartbeat({
@@ -1043,13 +1566,13 @@ function createRigVerificationActivityLifecycle(context = currentActivityContext
       if (!controller.signal.aborted) controller.abort(error);
     }
   };
-  heartbeat();
+  heartbeat2();
   const heartbeatTimeoutMs = context?.info.heartbeatTimeoutMs;
   const heartbeatIntervalMs = typeof heartbeatTimeoutMs === "number" && heartbeatTimeoutMs > 0 ? Math.min(
     RIG_VERIFICATION_HEARTBEAT_MAX_INTERVAL_MS,
     Math.max(RIG_VERIFICATION_HEARTBEAT_MIN_INTERVAL_MS, Math.floor(heartbeatTimeoutMs / 3))
   ) : RIG_VERIFICATION_HEARTBEAT_MAX_INTERVAL_MS;
-  const heartbeatTimer = context ? setInterval(heartbeat, heartbeatIntervalMs) : null;
+  const heartbeatTimer = context ? setInterval(heartbeat2, heartbeatIntervalMs) : null;
   if (heartbeatTimer && "unref" in heartbeatTimer && typeof heartbeatTimer.unref === "function") {
     heartbeatTimer.unref();
   }
@@ -1065,7 +1588,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);
@@ -1134,7 +1657,7 @@ var defaultOwnershipDependencies = {
   recordCreated: recordWarmingSandboxCreated,
   commitWarm: commitWarmingToWarm,
   touchHolder: touchLeaseHolder,
-  releaseHolder: releaseLeaseHolder,
+  releaseHolder: releaseLeaseHolder2,
   failWarming: failWarmingToCold,
   markWarmLost: markWarmLeaseInstanceLost,
   serialize: serializeEstablishedSandboxEnvelope,
@@ -1145,7 +1668,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 +1693,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 +1701,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 +1827,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 +2029,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 +2072,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 +2159,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 +2333,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 +2405,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 +2479,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 +2590,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 +2632,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 +2705,60 @@ 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/retained-process-retry.ts
+function retainedProcessDeadlineRetryMs(process, lease, settings, retryAfterMs, now = Date.now()) {
+  if (process.providerBackend !== "modal" || process.routeTargetId !== null || !lease || lease.id !== process.leaseId || lease.leaseEpoch !== process.leaseEpoch || lease.backend !== process.providerBackend || lease.instanceId !== process.providerInstanceId || !lease.providerDeadlineAt)
+    return retryAfterMs;
+  const untilRotation = lease.providerDeadlineAt.getTime() - settings.sandboxRotationLeadMs - now;
+  if (!Number.isFinite(untilRotation)) return retryAfterMs;
+  return Math.min(
+    retryAfterMs,
+    Math.max(1e3, settings.sandboxLeaseReaperPeriodMs, untilRotation)
+  );
+}
+
 // src/activities/sandbox-lease.ts
-import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { retainedProviderCommandPersistence } from "@opengeni/db/retained-provider-commands";
-import { Context } from "@temporalio/activity";
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { requestRetainedProcessDeadlineCancellation } from "@opengeni/db/retained-provider-commands";
+import { Context as Context2 } from "@temporalio/activity";
 import { OpLostReason, OpState } from "@opengeni/agent-proto";
 import {
   accrueWarmSeconds,
+  retainedProviderCommandPersistence,
   adoptLegacyModalCheckpointArtifact,
   confirmDrainCold,
   appendSessionEventToSandboxGroup,
@@ -2202,10 +2774,17 @@ import {
   countSandboxLeasesByLiveness,
   deferRetainedProcessReconciliation,
   forceDrainOverLimitViewerOnlyBoxes,
-  getBillingBalance as getBillingBalance3,
   listCreditBalancesByAccount,
+  countActiveUsers,
+  readCreditGrantTotals,
+  readManagedAuthNewSignupsSwitch,
+  readVerifiedSignupTrialSwitch,
   listLegacyModalCheckpointSlots,
   listLiveModalSandboxLeaseAttributions,
+  listPendingModalProviderCreates,
+  claimModalProviderCreateRecovery,
+  recordRecoveredModalProviderCreate,
+  markWarmBillingStopCutoff,
   listMeterableWarmLeases,
   listSandboxViewerForceDrainWorkspaceIds,
   markSandboxCheckpointArtifactDeletePending as markSandboxCheckpointArtifactDeletePending2,
@@ -2214,23 +2793,29 @@ import {
   registerSandboxCheckpointArtifact as registerSandboxCheckpointArtifact2,
   recordRetainedProcessReconciliationProof,
   replaceWorkspaceArchiveCaptureAfterProof,
-  readLease,
+  readLease as readLease2,
+  readWorkspaceArchiveCapturePreflight,
   reapExpiredSessionListSnapshots,
   reapStaleLeaseHoldersGlobal,
   requestDueSandboxRotationsGlobal,
   readSandboxRotationBacklog,
+  readRecentSandboxRecoveryObservations,
   workspaceArchiveCaptureDeadlineElapsed,
   retainedProcessReconciliationProof,
   retainedProcessSettlementIdentity,
+  recoverManagedSessionBackgroundCommand,
   settleClaimedConnectedMachineBackgroundCommand,
   settleSandboxCheckpointArtifactGc,
   rlsContextForWorkspace,
   settleRetainedProcess
 } from "@opengeni/db";
 import {
+  claimConnectedCommandOutputReleases,
   claimConnectedMachineSessionBackgroundCommands,
   deferConnectedMachineBackgroundCommandReconciliation,
-  recordConnectedMachineBackgroundCommandProof
+  recordConnectedMachineBackgroundCommandProof,
+  recordConnectedCommandOutputConsumption,
+  settleConnectedCommandOutputReleaseClaim
 } from "@opengeni/db/session-background-commands";
 import { sandboxWarmRateMicrosPerSecond } from "@opengeni/config";
 import { appendSessionCommandOutput } from "@opengeni/db/session-command-output";
@@ -2240,9 +2825,9 @@ import {
   disposeWorkspaceArchive,
   cancelSelfhostedOp,
   assertConsistentSandboxProviderIdentity,
-  createSandboxClientForBackend,
+  createSandboxClientForBackend as createSandboxClientForBackend2,
   deleteModalCheckpointSnapshot as deleteModalCheckpointSnapshot2,
-  deserializeSandboxSessionStateEnvelope,
+  deserializeSandboxSessionStateEnvelope as deserializeSandboxSessionStateEnvelope2,
   establishSandboxSessionFromEnvelope as establishSandboxSessionFromEnvelope2,
   inspectModalSandboxLifecycle,
   isExecSessionLostBanner,
@@ -2258,9 +2843,10 @@ import {
   providerWorkspaceCapturePolicy,
   resolveModalCheckpointProviderBindingForLiveSandbox,
   resolveModalCheckpointProviderBinding,
+  findModalProviderCreateReceipt,
   resolveModalCheckpointProviderBindingForSession,
   querySelfhostedOp,
-  resumeExactSandboxSession,
+  resumeExactSandboxSession as resumeExactSandboxSession2,
   sandboxProviderContinuityForState,
   sandboxBackendForSdkBackendId,
   sandboxProviderInstanceIdFromEnvelope,
@@ -2277,6 +2863,10 @@ import { sandboxLeaseTelemetryKey as sandboxLeaseTelemetryKey2 } from "@opengeni
 var RETAINED_PROCESS_RECONCILIATION_LIMIT = 20;
 var RETAINED_PROCESS_RECONCILIATION_CLAIM_TTL_MS = 5 * 6e4;
 var RETAINED_PROCESS_PROVIDER_PROBE_TIMEOUT_MS = 5e3;
+var RETAINED_PROCESS_OUTPUT_DRAIN_MAX_READS = 8;
+var RETAINED_PROCESS_OUTPUT_DRAIN_BUDGET_MS = 1e4;
+var RETAINED_PROCESS_OUTPUT_DRAIN_SWEEP_BUDGET_MS = 6e4;
+var RETAINED_PROCESS_OUTPUT_BACKLOG_BYTES = 256 * 1024;
 var RETAINED_PROCESS_BINDING_QUARANTINE_AFTER_ATTEMPTS = 5;
 var RETAINED_PROCESS_BINDING_QUARANTINE_RETRY_MS = 24 * 60 * 6e4;
 var CONNECTED_COMMAND_RECONCILIATION_LIMIT = 20;
@@ -2315,18 +2905,18 @@ async function awaitProviderCaptureWithLatePublication(input) {
 function startSandboxReaperHeartbeat(details) {
   let context;
   try {
-    context = Context.current();
+    context = Context2.current();
   } catch {
     return () => void 0;
   }
-  const heartbeat = () => {
+  const heartbeat2 = () => {
     try {
       context.heartbeat({ ...details, heartbeatAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch {
     }
   };
-  heartbeat();
-  const timer = setInterval(heartbeat, SANDBOX_REAPER_ACTIVITY_HEARTBEAT_INTERVAL_MS);
+  heartbeat2();
+  const timer = setInterval(heartbeat2, SANDBOX_REAPER_ACTIVITY_HEARTBEAT_INTERVAL_MS);
   if ("unref" in timer && typeof timer.unref === "function") timer.unref();
   return () => clearInterval(timer);
 }
@@ -2349,25 +2939,30 @@ function sandboxDrainCaptureId(operationId, attempt) {
 }
 function sandboxDrainActivityAttempt() {
   try {
-    const attempt = Context.current().info.attempt;
+    const attempt = Context2.current().info.attempt;
     return Number.isSafeInteger(attempt) && attempt > 0 ? attempt : 1;
   } catch {
     return 1;
   }
 }
 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 (...args) => {
+    await args[10]?.();
+    return options.terminateBox(...args);
+  } : null) ?? (async (settings, lease, observability, persistArchive, providerCaptureRequestId, captureDisposition, capturePolicy, diskBackedArchives, releaseFailedCapture, workspaceId, beforeProviderStop) => await terminateProviderBox(
     settings,
     lease,
     observability,
     persistArchive,
-    createSandboxClientForBackend,
+    createSandboxClientForBackend2,
     terminateModalSandboxById,
     providerCaptureRequestId,
     captureDisposition,
     capturePolicy,
     diskBackedArchives,
-    releaseFailedCapture
+    releaseFailedCapture,
+    workspaceId,
+    beforeProviderStop
   ));
   const sweepModalOrphans = options.sweepModalOrphans ?? sweepModalOrphansForConfiguredBackend;
   const inspectOpenSandboxInventory = options.inspectOpenSandboxKubernetesInventory ?? inspectOpenSandboxKubernetesInventory;
@@ -2378,14 +2973,18 @@ function createSandboxLeaseActivities(services, options = {}) {
     try {
       const { db, settings, observability } = await services();
       const timing = sandboxDrainTiming(settings);
-      const onUnobservableCommandDrainError = (error) => {
-        observability.warn("sandbox reaper: unobservable command drain inspection failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
+      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)
+          });
+        }
       };
       if (!settings.sandboxOwnershipEnabled) {
         const drainableInventory2 = await reapStaleLeaseHoldersGlobal(db, {
-          onUnobservableCommandDrainError,
+          ...commandContainment,
           viewerHolderTtlMs: settings.sandboxViewerHolderTtlMs,
           turnHolderTtlMs: settings.sandboxLeaseTtlMs,
           interactionHolderTtlMs: settings.sandboxInteractionHolderTtlMs,
@@ -2412,7 +3011,7 @@ function createSandboxLeaseActivities(services, options = {}) {
       });
       recordSandboxDeadlineRotationsRequested(observability, rotationsRequested);
       const drainableInventory = await reapStaleLeaseHoldersGlobal(db, {
-        onUnobservableCommandDrainError,
+        ...commandContainment,
         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
@@ -2453,7 +3052,7 @@ function createSandboxLeaseActivities(services, options = {}) {
       instanceId: input.target.instanceId
     });
     try {
-      const { db, settings, observability, objectStorage } = await services();
+      const { db, settings, observability, objectStorage, bus } = await services();
       assertSandboxDrainInputTiming(input);
       const drainSettings = settings.sandboxSnapshotTimeoutMs === input.snapshotTimeoutMs ? settings : { ...settings, sandboxSnapshotTimeoutMs: input.snapshotTimeoutMs };
       const row = input.target;
@@ -2473,11 +3072,12 @@ function createSandboxLeaseActivities(services, options = {}) {
           terminateBox,
           probeDrainableProvider,
           captureAttempt,
-          objectStorage
+          objectStorage,
+          bus
         );
         return { status: drainedCold ? "terminated" : "skipped" };
       } catch (error) {
-        const lease = await readLease(db, row.workspaceId, row.sandboxGroupId).catch(() => null);
+        const lease = await readLease2(db, row.workspaceId, row.sandboxGroupId).catch(() => null);
         const details = {
           sandboxLeaseKey: sandboxLeaseTelemetryKey(row.workspaceId, row.sandboxGroupId),
           workspaceId: row.workspaceId,
@@ -2540,6 +3140,19 @@ function createSandboxLeaseActivities(services, options = {}) {
       const rotationsRequested = input.rotationsRequested;
       let modalOrphansTerminated = 0;
       await reconcileConnectedMachineBackgroundCommands(db, settings, observability, service.bus);
+      await reconcileConnectedCommandOutputReleases(db, settings, observability, service.bus);
+      try {
+        await reconcileModalProviderCreates(
+          db,
+          settings,
+          observability,
+          options.findModalProviderCreateReceipt
+        );
+      } catch (error) {
+        observability.warn("sandbox reaper: Modal create recovery inventory failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
       if (!settings.sandboxOwnershipEnabled) {
         await refreshQueueLeaseAndCreditGauges(
           db,
@@ -2557,7 +3170,7 @@ function createSandboxLeaseActivities(services, options = {}) {
       const meterResult = await accrueWarmTick(db, settings, observability);
       metered = meterResult.accrued;
       const forceDrainWorkspaceIds = /* @__PURE__ */ new Set();
-      if (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed" || settings.sandboxMaxWarmSecondsPerWorkspace > 0) {
+      if (settings.sandboxWarmBillingMode === "credits" || settings.sandboxMaxWarmSecondsPerWorkspace > 0) {
         for (const workspaceId of meterResult.workspaceIds) {
           forceDrainWorkspaceIds.add(workspaceId);
         }
@@ -2657,7 +3270,7 @@ function createSandboxLeaseActivities(services, options = {}) {
           timeoutClass: plan.timeoutClass,
           snapshotTimeoutMs: plan.snapshotTimeoutMs,
           captureTimeoutMs: plan.captureTimeoutMs,
-          operationId: randomUUID2()
+          operationId: randomUUID3()
         })
       )
     );
@@ -2849,6 +3462,7 @@ async function reconcileConnectedMachineBackgroundCommands(db, settings, observa
     );
     await forEachWithConcurrency(claims, SANDBOX_MAINTENANCE_ITEM_CONCURRENCY, async (claim) => {
       let proof = claim.proof;
+      let outputReplay = null;
       const connectionKey = JSON.stringify([
         claim.controlWorkspaceId,
         claim.enrollmentId,
@@ -2904,18 +3518,14 @@ async function reconcileConnectedMachineBackgroundCommands(db, settings, observa
               journal: { attachGeneration: () => String(Date.now()), persistSettled: () => {
               } }
             });
-            const replay = await client.readExisting(
+            outputReplay = 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(
@@ -2966,6 +3576,15 @@ async function reconcileConnectedMachineBackgroundCommands(db, settings, observa
         if (!settlement.settled) {
           throw new Error("Connected command settlement lost its exact claim or proof");
         }
+        const receipt = outputReplay?.outputReceipt ?? (outputReplay?.status === "running" ? outputReplay.terminal?.outputReceipt : void 0);
+        const terminal = outputReplay?.status === "completed" ? outputReplay : outputReplay?.terminal;
+        if (proof.outcome === "exited" && receipt && terminal) {
+          await recordConnectedCommandOutputConsumption(db, {
+            ...claim,
+            receipt,
+            exitCode: terminal.outcome.response.exitCode
+          });
+        }
         if (settlement.events.length > 0) {
           try {
             await bus.publish(claim.workspaceId, claim.sessionId, settlement.events);
@@ -2989,6 +3608,133 @@ 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, capture);
+    if (!terminalKnown || replay.status === "completed" || replay.terminal) return replay;
+    capturedThrough = BigInt(replay.replaySequence);
+    if (capturedThrough === before) {
+      throw new Error("Connected command terminal output replay has not reached its exit frontier");
+    }
+  }
+}
+async function reconcileConnectedCommandOutputReleases(db, settings, observability, bus, controlRpcOverride) {
+  const dueBefore = /* @__PURE__ */ new Date();
+  const deadline = Date.now() + settings.sandboxLeaseReaperPeriodMs;
+  const controlRpc = controlRpcOverride ?? new NatsControlRpc(async () => bus.getRequestConnection());
+  do {
+    let claims;
+    try {
+      claims = await claimConnectedCommandOutputReleases(db, {
+        claimId: crypto.randomUUID(),
+        dueBefore,
+        limit: CONNECTED_COMMAND_RECONCILIATION_LIMIT,
+        claimTtlMs: CONNECTED_COMMAND_RECONCILIATION_CLAIM_TTL_MS
+      });
+    } catch (error) {
+      recordConnectedCommandReconciliation(observability, "claim_failed");
+      observability.warn("sandbox reaper: connected-command output claim failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    await forEachWithConcurrency(claims, SANDBOX_MAINTENANCE_ITEM_CONCURRENCY, async (claim) => {
+      try {
+        if (!bus.getOpStreamConnection)
+          throw new Error("Connected command output transport unavailable");
+        const rpcSubject = subjectFor(
+          claim.controlWorkspaceId,
+          claim.enrollmentId,
+          claim.connectionInstanceId
+        );
+        const controlTimeoutMs = Math.min(
+          settings.sandboxSelfhostedControlTimeoutMs,
+          RETAINED_PROCESS_PROVIDER_PROBE_TIMEOUT_MS
+        );
+        const client = new OpStreamExecClient({
+          workspaceId: claim.controlWorkspaceId,
+          agentId: claim.enrollmentId,
+          connectionInstanceId: claim.connectionInstanceId,
+          epoch: 0,
+          controlRpc,
+          rpcSubject,
+          transport: new NatsOpStreamTransport(async () => bus.getOpStreamConnection?.() ?? null),
+          controlTimeoutMs,
+          retryClock: defaultSelfhostedRetryClock,
+          journal: {
+            attachGeneration: () => String(Date.now()),
+            persistSettled: () => {
+              throw new Error("Background output release requires its database receipt");
+            }
+          }
+        });
+        let receipt = claim.receipt;
+        if (!receipt) {
+          const status = await querySelfhostedOp({
+            controlRpc,
+            rpcSubject,
+            opId: claim.opId,
+            controlTimeoutMs
+          });
+          if (status.state === OpState.OP_STATE_LOST) {
+            if (!await settleConnectedCommandOutputReleaseClaim(db, {
+              claim,
+              outcome: "unavailable",
+              retryAfterMs: 0
+            }))
+              throw new Error("Connected command output loss no longer owns its exact claim");
+            recordConnectedCommandReconciliation(observability, "output_unavailable");
+            return;
+          }
+          if (status.state !== OpState.OP_STATE_COMPLETE)
+            throw new Error("Terminal command output returned a live operation");
+          const replay = await replayConnectedCommandOutput(
+            client,
+            claim.opId,
+            true,
+            async (frames) => captureConnectedCommandOutput(db, claim, bus)(claim.commandId, frames)
+          );
+          const terminal = replay.status === "completed" ? replay : replay.terminal;
+          receipt = replay.outputReceipt ?? (replay.status === "running" ? replay.terminal?.outputReceipt : void 0) ?? null;
+          if (!terminal || !receipt)
+            throw new Error("Connected command output replay has no complete custody receipt");
+          await recordConnectedCommandOutputConsumption(db, {
+            ...claim,
+            receipt,
+            exitCode: terminal.outcome.response.exitCode
+          });
+        }
+        const outcome = await client.releaseCapturedOutput(claim.opId, receipt);
+        if (!await settleConnectedCommandOutputReleaseClaim(db, {
+          claim,
+          outcome,
+          retryAfterMs: outcome === "published" ? settings.sandboxLeaseReaperPeriodMs : 0
+        }))
+          throw new Error("Connected command output release no longer owns its exact claim");
+        recordConnectedCommandReconciliation(
+          observability,
+          outcome === "published" ? "output_ack_published" : "output_released"
+        );
+      } catch (error) {
+        await settleConnectedCommandOutputReleaseClaim(db, {
+          claim,
+          outcome: "retry",
+          retryAfterMs: Math.min(
+            5 * 6e4,
+            Math.max(settings.sandboxLeaseReaperPeriodMs, 3e4) * 2 ** Math.min(4, claim.reconcileAttempts - 1)
+          )
+        }).catch(() => false);
+        observability.warn("sandbox reaper: connected-command output release deferred", {
+          commandId: claim.commandId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    if (claims.length < CONNECTED_COMMAND_RECONCILIATION_LIMIT) break;
+  } while (Date.now() < deadline);
+}
 async function probeConnectedMachineBackgroundCommand(claim, controlRpc, controlTimeoutMs, observedAt = /* @__PURE__ */ new Date()) {
   const input = {
     controlRpc,
@@ -3075,10 +3821,65 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
     });
     return;
   }
+  const drainBudget = {
+    until: Date.now() + RETAINED_PROCESS_OUTPUT_DRAIN_SWEEP_BUDGET_MS
+  };
   for (const claim of claims) {
     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
+    };
+    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,
+      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) {
@@ -3121,8 +3922,18 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
           };
         }
       }
+      if (observation?.status === "deferred" && process.providerBackend === "modal" && !process.providerBindingKey && !process.deadlineCancellationRequestedAt) {
+        try {
+          await requestRetainedProcessDeadlineCancellation(db, processScope);
+        } catch (error) {
+          observability.warn("sandbox reaper: legacy deadline cancellation intent failed", {
+            processId: process.id,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
       if (observation === null) {
-        const lease = await readLease(db, process.workspaceId, process.sandboxGroupId).catch(
+        const lease = await readLease2(db, process.workspaceId, process.sandboxGroupId).catch(
           () => null
         );
         const currentLeaseIdentityMatches = Boolean(lease) && lease.id === process.leaseId && lease.leaseEpoch === process.leaseEpoch && lease.backend === process.providerBackend && lease.instanceId === process.providerInstanceId && process.routeTargetId === null;
@@ -3162,11 +3973,25 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
           }
         } else {
           try {
-            observation = await probe(
+            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");
+            }
+            const legacyDeadlineStop = lease.rotationReason === "provider_deadline" && !supervised && !process.deadlineCancellationRequestedAt;
+            const probeOutcome = await probe(
               settings,
               lease,
               process,
-              claim.ownerState === "background_stopping" ? "cancel" : "observe",
+              claim.ownerState === "background_stopping" && !process.deadlineCancellationRequestedAt || legacyDeadlineStop ? "cancel" : "observe",
               async (result, chunkId, stream, streamFidelity) => {
                 if (typeof result !== "string" || !stream && isExecSessionLostBanner(result, process.providerSessionId))
                   return;
@@ -3183,13 +4008,25 @@ 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,
+              drainBudget
+            ).then(
+              (value) => ({ ok: true, value }),
+              (error) => ({ ok: false, error })
             );
+            if (legacyDeadlineStop && !await requestRetainedProcessDeadlineCancellation(db, processScope))
+              throw new Error("Deadline cancellation no longer owns its rotating lease");
+            if (!probeOutcome.ok) throw probeOutcome.error;
+            observation = probeOutcome.value;
+            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,
@@ -3230,7 +4067,8 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
           process,
           expected,
           claim.claimId,
-          observation.reason
+          observation.reason,
+          observation.outputBacklog === true
         );
         continue;
       }
@@ -3248,10 +4086,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;
       }
     }
@@ -3304,9 +4139,10 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
     }
   }
 }
-async function deferRetainedProcessClaim(db, settings, observability, process, expected, claimId, outcome) {
-  const deferral = retainedProcessReconciliationDeferral(settings, process, outcome);
+async function deferRetainedProcessClaim(db, settings, observability, process, expected, claimId, outcome, outputBacklog = false) {
+  const deferral = retainedProcessReconciliationDeferral(settings, process, outcome, outputBacklog);
   try {
+    const lease = process.providerBackend === "modal" && process.routeTargetId === null ? await readLease2(db, process.workspaceId, process.sandboxGroupId) : null;
     await deferRetainedProcessReconciliation(db, {
       accountId: process.accountId,
       workspaceId: process.workspaceId,
@@ -3315,7 +4151,7 @@ async function deferRetainedProcessClaim(db, settings, observability, process, e
       expected,
       claimId,
       outcome: deferral.durableOutcome,
-      retryAfterMs: deferral.retryAfterMs
+      retryAfterMs: retainedProcessDeadlineRetryMs(process, lease, settings, deferral.retryAfterMs)
     });
     recordRetainedProcessReconciliation(observability, deferral.metricOutcome);
   } catch (error) {
@@ -3326,7 +4162,7 @@ async function deferRetainedProcessClaim(db, settings, observability, process, e
     });
   }
 }
-function retainedProcessReconciliationDeferral(settings, process, outcome) {
+function retainedProcessReconciliationDeferral(settings, process, outcome, outputBacklog = false) {
   const bindingQuarantine = process.reconcileAttempts >= RETAINED_PROCESS_BINDING_QUARANTINE_AFTER_ATTEMPTS && (outcome === "provider_binding_missing" || outcome === "provider_binding_mismatch" || outcome === "process_observation_unavailable");
   if (bindingQuarantine) {
     return {
@@ -3336,11 +4172,9 @@ function retainedProcessReconciliationDeferral(settings, process, outcome) {
       quarantined: true
     };
   }
-  const exponent = Math.min(4, Math.max(0, process.reconcileAttempts - 1));
-  const retryAfterMs = Math.min(
-    5 * 6e4,
-    Math.max(settings.sandboxLeaseReaperPeriodMs, 3e4) * 2 ** exponent
-  );
+  const baseRetryMs = Math.max(settings.sandboxLeaseReaperPeriodMs, 3e4);
+  const exponent = outcome === "provider_running" && outputBacklog ? 0 : Math.min(4, Math.max(0, process.reconcileAttempts - 1));
+  const retryAfterMs = Math.min(5 * 6e4, baseRetryMs * 2 ** exponent);
   return {
     durableOutcome: outcome,
     metricOutcome: outcome,
@@ -3349,6 +4183,45 @@ function retainedProcessReconciliationDeferral(settings, process, outcome) {
   };
 }
 var RETAINED_PROCESS_PROBE_TIMEOUT = Symbol("retained-process-provider-probe-timeout");
+async function drainRetainedCommandBacklog(session, providerSessionId, first, capturePage, budget) {
+  let backlog = retainedBacklogRemains(session, first);
+  await capturePage(first);
+  let observation = classifyRetainedProcessPollResult(first, providerSessionId, session);
+  if (typeof session.writeStdin !== "function") return observation;
+  const until = Math.min(
+    Date.now() + RETAINED_PROCESS_OUTPUT_DRAIN_BUDGET_MS,
+    budget?.until ?? Number.POSITIVE_INFINITY
+  );
+  for (let reads = 0; backlog && observation.status === "deferred" && observation.reason === "provider_running" && reads < RETAINED_PROCESS_OUTPUT_DRAIN_MAX_READS && Date.now() < until; reads++) {
+    let next;
+    try {
+      next = await withRetainedProcessProbeTimeout(
+        session.writeStdin({
+          sessionId: providerSessionId,
+          chars: "",
+          yieldTimeMs: 1e3,
+          maxOutputTokens: 2e3
+        })
+      );
+    } catch {
+      break;
+    }
+    backlog = retainedBacklogRemains(session, next);
+    await capturePage(next);
+    observation = classifyRetainedProcessPollResult(next, providerSessionId, session);
+  }
+  return backlog && observation.status === "deferred" && observation.reason === "provider_running" ? { ...observation, outputBacklog: true } : observation;
+}
+function retainedBacklogRemains(session, result) {
+  const page = session.getProviderCommandOutput?.(result);
+  if (!page?.expected || page.command.kind !== "modal-router-v1") return false;
+  if (page.command.supervision || page.exitCode !== null) return false;
+  if (page.providerExited) return true;
+  const { command, expected } = page;
+  return ["stdout", "stderr"].some(
+    (stream) => command.streams[stream].byteOffset - expected.streams[stream].byteOffset >= RETAINED_PROCESS_OUTPUT_BACKLOG_BYTES
+  );
+}
 async function withRetainedProcessProbeTimeout(promise) {
   let timer;
   try {
@@ -3376,8 +4249,8 @@ async function captureRetainedProbeOutput(processId, result, capture) {
   await capture(pending.result, pending.chunkId);
   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) {
+async function probeRetainedProcessAtProvider(settings, lease, process, mode = "observe", captureOutput, providerPersistence, drainBudget) {
+  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) {
@@ -3387,10 +4260,14 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   if (pending) {
     if (!captureOutput) throw new Error("Pending command output requires its persistence callback");
     await captureRetainedProbeOutput(process.id, pending.result, captureOutput);
-    return classifyRetainedProcessPollResult(pending.result, process.providerSessionId);
+    const pendingObservation = classifyRetainedProcessPollResult(
+      pending.result,
+      process.providerSessionId
+    );
+    if (mode !== "cancel" || pendingObservation.status === "proved") return pendingObservation;
   }
   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) {
@@ -3414,17 +4291,17 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   }
   let client;
   try {
-    client = createSandboxClientForBackend(process.providerBackend, settings);
+    client = createSandboxClientForBackend2(process.providerBackend, settings);
   } 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;
   let resumedState;
   try {
-    resumedState = await deserializeSandboxSessionStateEnvelope(
+    resumedState = await deserializeSandboxSessionStateEnvelope2(
       client,
       envelopeSessionState,
       process.providerInstanceId
@@ -3438,7 +4315,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   let session;
   try {
     const resumed = await withRetainedProcessProbeTimeout(
-      resumeExactSandboxSession(
+      resumeExactSandboxSession2(
         client,
         process.providerBackend,
         resumedState,
@@ -3468,6 +4345,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   if (typeof session.writeStdin !== "function") {
     return { status: "deferred", reason: "backend_unsupported" };
   }
+  let legacyPty = false;
   if (process.providerBackend === "modal") {
     let liveBinding;
     try {
@@ -3494,6 +4372,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
     if (!command || !providerPersistence || !session.bindProviderCommand)
       return { status: "deferred", reason: "process_observation_unavailable" };
     session.bindProviderCommand(process.providerSessionId, command, providerPersistence);
+    legacyPty = command.pty === true;
   }
   const capturePage = async (value) => {
     if (!captureOutput) {
@@ -3502,6 +4381,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 +4397,16 @@ 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" ? "" : "",
+        // Ctrl-C is a signal only through a PTY. For a non-PTY command it is
+        // ordinary stdin data and can corrupt the command's input.
+        chars: mode === "cancel" && !supervisedCancelled && (process.providerBackend !== "modal" || legacyPty) ? "" : "",
         yieldTimeMs: 1e3,
         maxOutputTokens: 2e3
       })
@@ -3540,9 +4430,14 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
     }
     return { status: "deferred", reason: "provider_error" };
   }
-  await capturePage(result);
-  const observation = classifyRetainedProcessPollResult(result, process.providerSessionId, session);
-  if (observation.status === "deferred" && observation.reason === "provider_running" && lease.rotationRequestedAt !== null) {
+  const observation = await drainRetainedCommandBacklog(
+    session,
+    process.providerSessionId,
+    result,
+    capturePage,
+    drainBudget
+  );
+  if (observation.status === "deferred" && observation.reason === "provider_running" && lease.rotationRequestedAt !== null && mode !== "cancel" && !process.cancellationRequestedAt && legacyPty && !await providerPersistence?.load().then((command) => command?.kind === "modal-router-v1" && command.supervision)) {
     try {
       const interrupted = await withRetainedProcessProbeTimeout(
         session.writeStdin({
@@ -3619,19 +4514,22 @@ async function accrueWarmTick(db, settings, observability) {
   }
   await forEachWithConcurrency(leases, SANDBOX_MAINTENANCE_ITEM_CONCURRENCY, async (lease) => {
     try {
-      const rate = sandboxWarmRateMicrosPerSecond(settings, lease.backend);
+      const rate = settings.sandboxWarmBillingMode === "usage_only" ? 0 : sandboxWarmRateMicrosPerSecond(settings, lease.backend);
       const result = await accrueWarmSeconds(db, {
         accountId: lease.accountId,
         workspaceId: lease.workspaceId,
         sandboxGroupId: lease.sandboxGroupId,
         expectedEpoch: lease.leaseEpoch,
         warmRateMicrosPerSecond: rate,
+        billingMode: settings.sandboxWarmBillingMode,
         subjectId: lease.sandboxGroupId
       });
       if (result.accrued) {
         accrued += 1;
       }
-      recordCreditMicros(observability, "usage", result.costMicros);
+      if (result.costMicros > 0 && settings.sandboxWarmBillingMode === "credits") {
+        recordCreditMicros(observability, "usage", result.costMicros);
+      }
     } catch (error) {
       observability.warn("sandbox reaper: warm-seconds accrual failed for lease", {
         workspaceId: lease.workspaceId,
@@ -3667,6 +4565,17 @@ async function refreshQueueLeaseAndCreditGauges(db, settings, observability, ins
         );
       }
     ),
+    refreshSandboxInventoryGauge(
+      observability,
+      "recovery_observations",
+      "recovery-observations",
+      async () => {
+        recordSandboxRecoveryObservationGauges(
+          observability,
+          await readRecentSandboxRecoveryObservations(db)
+        );
+      }
+    ),
     refreshSandboxInventoryGauge(
       observability,
       "rotation_backlog",
@@ -3715,6 +4624,51 @@ async function refreshQueueLeaseAndCreditGauges(db, settings, observability, ins
           error: error instanceof Error ? error.message : String(error)
         });
       }
+    })(),
+    (async () => {
+      try {
+        recordActiveUserGauges(observability, await countActiveUsers(db));
+      } catch (error) {
+        observability.warn("sandbox reaper: active-user gauge refresh failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    })(),
+    (async () => {
+      try {
+        recordCreditGrantGauges(observability, await readCreditGrantTotals(db));
+      } catch (error) {
+        observability.warn("sandbox reaper: credit-grant gauge refresh failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    })(),
+    (async () => {
+      recordVerifiedSignupTrialDeploymentFlagGauge(
+        observability,
+        settings.verifiedSignupTrialCreditsEnabled
+      );
+      try {
+        const trialSwitch = await readVerifiedSignupTrialSwitch(db);
+        recordVerifiedSignupTrialSwitchGauge(observability, trialSwitch?.grantsEnabled === true);
+      } catch (error) {
+        observability.warn("sandbox reaper: trial-credit switch gauge refresh failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    })(),
+    (async () => {
+      try {
+        const signupsSwitch = await readManagedAuthNewSignupsSwitch(db);
+        recordManagedAuthNewSignupsSwitchGauge(
+          observability,
+          signupsSwitch?.signupsEnabled !== false
+        );
+      } catch (error) {
+        observability.warn("sandbox reaper: new-signups switch gauge refresh failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
     })()
   ]);
 }
@@ -3730,7 +4684,7 @@ async function refreshSandboxInventoryGauge(observability, domain, diagnosticNam
   }
 }
 async function forceDrainOverLimitWorkspaces(db, settings, workspaceIds, observability) {
-  const enforceBalance = settings.billingMode === "stripe" || settings.usageLimitsMode === "managed";
+  const enforceBalance = false;
   const cap = settings.sandboxMaxWarmSecondsPerWorkspace;
   let forceDrained = 0;
   await forEachWithConcurrency(
@@ -3738,11 +4692,8 @@ async function forceDrainOverLimitWorkspaces(db, settings, workspaceIds, observa
     SANDBOX_MAINTENANCE_ITEM_CONCURRENCY,
     async (workspaceId) => {
       try {
-        const { accountId } = await rlsContextForWorkspace(db, workspaceId);
-        const balance = enforceBalance ? await getBillingBalance3(db, accountId) : { balanceMicros: 1 };
         const result = await forceDrainOverLimitViewerOnlyBoxes(db, {
           workspaceId,
-          balanceMicros: balance.balanceMicros,
           enforceBalance,
           maxWarmSecondsPerWorkspace: cap,
           idleGraceMs: settings.sandboxIdleGraceMs
@@ -3765,7 +4716,37 @@ async function forceDrainOverLimitWorkspaces(db, settings, workspaceIds, observa
   );
   return forceDrained;
 }
+async function reconcileModalProviderCreates(db, settings, observability, discover = findModalProviderCreateReceipt) {
+  if (settings.sandboxBackend !== "modal" && !settings.modalTokenId && !settings.modalTokenSecret)
+    return;
+  const candidates = await listPendingModalProviderCreates(db);
+  await forEachWithConcurrency(candidates, 2, async (candidate) => {
+    try {
+      const { accountId } = await rlsContextForWorkspace(db, candidate.workspaceId);
+      const identity = { ...candidate, accountId };
+      const attempt = await claimModalProviderCreateRecovery(db, identity);
+      if (!attempt) return;
+      const instanceId = await discover(settings, attempt);
+      if (!instanceId) return;
+      if (await recordRecoveredModalProviderCreate(db, { ...identity, attempt, instanceId })) {
+        observability.info("sandbox reaper: recovered Modal create receipt", {
+          ...candidate,
+          operationId: attempt.operationId,
+          instanceId
+        });
+      }
+    } catch (error) {
+      observability.warn("sandbox reaper: Modal create remains fenced pending discovery", {
+        ...candidate,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+}
 function modalOrphanTerminationStillEligible(latest, candidate) {
+  if (latest.some((lease) => lease.liveness === "warming" && lease.instanceId === null)) {
+    return false;
+  }
   if (latest.some((lease) => lease.instanceId === candidate.sandboxId)) {
     return false;
   }
@@ -3875,9 +4856,9 @@ 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) {
+async function terminateDrainableBox(db, settings, row, observability, terminateBox, probeDrainableProvider, attempt, objectStorage, bus = null) {
   const { accountId } = await rlsContextForWorkspace(db, row.workspaceId);
-  const lease = await readLease(db, row.workspaceId, row.sandboxGroupId);
+  const lease = await readLease2(db, row.workspaceId, row.sandboxGroupId);
   if (!lease) {
     return false;
   }
@@ -4118,6 +5099,27 @@ 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;
+  }
+  let stopCutoffMarked = false;
+  const beforeProviderStop = async () => {
+    const cutoff = await markWarmBillingStopCutoff(db, {
+      accountId,
+      workspaceId: row.workspaceId,
+      sandboxGroupId: row.sandboxGroupId,
+      expectedEpoch: row.leaseEpoch
+    });
+    if (!cutoff) throw new Error("sandbox stop cutoff was fenced before provider termination");
+    stopCutoffMarked = true;
+  };
   const termination = providerMissingBeforeCapture ? { terminated: true, providerMissingBeforeCapture: true } : await terminateBox(
     settings,
     lease,
@@ -4137,22 +5139,62 @@ async function terminateDrainableBox(db, settings, row, observability, terminate
         expectedEpoch: row.leaseEpoch,
         expectedInstanceId: lease.instanceId
       });
-    }
+    },
+    row.workspaceId,
+    beforeProviderStop
   );
   const terminated = typeof termination === "boolean" ? termination : termination.terminated;
   if (!terminated) {
     return false;
   }
+  const providerMissingDuringStop = providerMissingBeforeCapture || typeof termination !== "boolean" && termination.providerMissingBeforeCapture;
+  if (!stopCutoffMarked && !providerMissingDuringStop) {
+    if (managedProvider && lease.instanceId) {
+      throw new Error("managed sandbox stopped without a warm usage cutoff");
+    }
+    await beforeProviderStop();
+  }
+  const finalRate = settings.sandboxWarmBillingMode === "usage_only" ? 0 : sandboxWarmRateMicrosPerSecond(settings, backend);
+  if (!providerMissingDuringStop) {
+    const finalTick = await accrueWarmSeconds(db, {
+      accountId,
+      workspaceId: row.workspaceId,
+      sandboxGroupId: row.sandboxGroupId,
+      expectedEpoch: row.leaseEpoch,
+      warmRateMicrosPerSecond: finalRate,
+      billingMode: settings.sandboxWarmBillingMode,
+      finalDrain: true
+    });
+    if (finalTick.costMicros > 0 && settings.sandboxWarmBillingMode === "credits") {
+      recordCreditMicros(observability, "usage", finalTick.costMicros);
+    }
+  }
   const providerMissing = providerMissingBeforeCapture || (typeof termination === "boolean" ? false : termination.providerMissingBeforeCapture);
-  const { wentCold } = await confirmDrainCold(db, {
+  const { wentCold, backgroundCommandEvents } = await confirmDrainCold(db, {
     accountId,
     workspaceId: row.workspaceId,
     sandboxGroupId: row.sandboxGroupId,
     expectedEpoch: row.leaseEpoch,
     ...captureClaim ? { expectedCaptureId: captureClaim.id } : {},
-    providerMissingBeforeCapture: providerMissing
+    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)
+    });
   });
   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",
@@ -4193,18 +5235,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 = createSandboxClientForBackend2, terminateModalById = terminateModalSandboxById, providerCaptureRequestId, captureDisposition = "capture_required", claimedCapturePolicy, diskBackedArchives = false, releaseFailedCapture, workspaceId, beforeProviderStop) {
   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") {
@@ -4230,6 +5274,11 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
   }
   const persistedInstanceId = assertConsistentSandboxProviderIdentity(backend, lease.resumeState);
   if (!lease.instanceId) {
+    if (lease.providerCreateAttempt?.instanceId === null) {
+      throw new Error(
+        "provider_create_outcome_unknown: cannot infer termination from missing instance ID"
+      );
+    }
     if (persistedInstanceId) {
       throw new Error(
         `sandbox backend ${backend} has persisted provider identity ${persistedInstanceId} but no authoritative lease instance; refusing teardown`
@@ -4255,7 +5304,13 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
       return { terminated: false, providerMissingBeforeCapture: false };
     }
     try {
-      await terminateModalById(settings, lease.instanceId);
+      await beforeProviderStop?.();
+      await terminateModalById(
+        settings,
+        lease.instanceId,
+        void 0,
+        lease.providerCreateAttempt?.providerBindingKey
+      );
     } catch (error) {
       if (!isProviderSandboxNotFoundError("modal", error)) {
         throw error;
@@ -4282,7 +5337,7 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
       throw new Error(`sandbox backend ${backend} cannot resume a drainable provider box`);
     }
     const envelopeSessionState = lease.resumeState.sessionState ?? lease.resumeState;
-    const resumedState = await deserializeSandboxSessionStateEnvelope(
+    const resumedState = await deserializeSandboxSessionStateEnvelope2(
       client,
       envelopeSessionState,
       lease.instanceId
@@ -4291,7 +5346,7 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
       throw new Error(`sandbox backend ${backend} returned no resumable provider state`);
     }
     const continuity = sandboxProviderContinuityForState(backend, resumedState, lease.instanceId);
-    const resumed = await resumeExactSandboxSession(
+    const resumed = await resumeExactSandboxSession2(
       client,
       backend,
       resumedState,
@@ -4329,7 +5384,7 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
         session,
         Date.now(),
         {
-          requestId: providerCaptureRequestId ?? randomUUID2(),
+          requestId: providerCaptureRequestId ?? randomUUID3(),
           strategy: liveCapturePolicy.strategy
         },
         diskBackedArchives
@@ -4359,26 +5414,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 +5435,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();
@@ -4436,6 +5479,7 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
       throw new Error(`sandbox backend ${backend} returned no terminable session state`);
     }
     prepareProviderForTeardownAfterCapture(backend, session);
+    await beforeProviderStop?.();
     await terminateManagedSandboxSession2(client, sessionState, session);
     return { terminated: true, providerMissingBeforeCapture: false };
   } catch (error) {
@@ -4450,6 +5494,11 @@ async function terminateProviderBox(settings, lease, observability, persistArchi
 }
 
 // src/activities/scheduled-tasks.ts
+import { getScheduledTaskClaudeProviderAccountAuthoritySnapshot } from "@opengeni/db";
+import {
+  ATLASSIAN_NATIVE_RETIRED_REASON,
+  isRetiredNativeAtlassianTask
+} from "@opengeni/contracts/atlassian-native-retirement";
 import {
   AUTOMATIC_SESSION_TITLE_FALLBACK,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
@@ -4462,25 +5511,40 @@ import {
   SessionAgentAccess,
   SessionMemoryScope,
   normalizeAutomaticSessionTitle,
+  metadataWithTurnExecutionPolicyV1,
+  mergeResourceRefs,
   scheduledOccurrencePayloadUtf8Bytes,
   stableJson,
   TurnExecutionPolicyV1
 } from "@opengeni/contracts";
 import {
-  defaultSessionMcpServerIds,
   openGeniSlackBotMetadata,
   requireOpenGeniSlackBotConnection,
+  withScheduledSlackBotPostingTools,
   resolveWorkspaceCatalogSettings as resolveWorkspaceCatalogSettings2,
+  resolveScheduledTaskDefaultModel,
   resolveSessionToolPolicy,
   workspaceCustomModelReference,
   lockActiveCustomModelForAdmission,
   scheduledSlackBotConnectionId,
-  swapActiveSandbox
+  freezeConnectionAccounts,
+  ConnectionAccountSelectionError,
+  scheduledConnectionSurfaceEligibility,
+  scheduledConnectionTools,
+  settingsWithEnabledCapabilityMcpServers,
+  settingsWithSessionMcpServerMetadata,
+  swapActiveSandbox,
+  applySessionAgentConfigWriteThrough as applySessionAgentConfigWriteThrough2,
+  resolveSessionAgentConfigForCreate as resolveSessionAgentConfigForCreate2,
+  recordSessionCreated,
+  recordUserMessageAccepted
 } from "@opengeni/core";
 import {
   addSessionSystemUpdateWithSourceMutation,
   bindScheduledTaskRunSessionInTransaction,
   createScheduledTaskRun,
+  recordScheduledTaskAdmissionFailure,
+  recordScheduledTaskAdmissionRefusal,
   createSessionWithIdempotencyKeyResult,
   enqueueSessionWorkflowWakeIfRunnable,
   failScheduledGeneratedSessionRoute,
@@ -4489,7 +5553,6 @@ import {
   getScheduledTaskRunAcceptedExecution,
   getScheduledTaskRunByProducerKey,
   getScheduledTargetSessionExecution,
-  getScheduledTaskPersonalConnectionDelegations,
   getScheduledTaskRunPersonalResourceAuthority,
   getScheduledTaskPersonalResourceAuthoritySubject,
   getScheduledTaskRevisionAuthority,
@@ -4501,31 +5564,31 @@ import {
   getNestedAgentDepthDeploymentPolicy,
   getSessionByCreateIdempotencyKey,
   getSessionCreationExecutionPolicy,
+  metadataWithAgentConfigCreateIdentity,
   getVariableSet,
   isCodexBilledModel,
   initializeSessionStartAtomically,
   materializeScheduledTaskReusableSessionFromRun,
-  listEnabledMcpCapabilityServerIds,
   listInstalledApiIntegrationServerIdsForDelegations,
   markScheduledTaskRunFailedIfQueued,
   markScheduledTaskRunSkippedIfQueued,
   recordUsageEvent as recordUsageEvent2,
   requireScheduledTaskIncidentAuthorityInTransaction,
   requireSession,
-  requireWorkspace,
+  requireWorkspace as requireWorkspace2,
   settleScheduledTaskRunInTransaction,
   SessionSpawnDeniedDbError,
   updateSessionTitleWithEvent,
   upsertScheduledSessionGoalForRun,
   withSessionActivityRlsContext
 } from "@opengeni/db";
-import { publishDurableSessionEvents } from "@opengeni/events";
+import { publishDurableSessionEvents as publishDurableSessionEvents2 } from "@opengeni/events";
 import {
   allowedFirstPartyMcpToolsForSession,
   resolveFirstPartyMcpToolPolicy,
   resolveTurnExecutionPolicyV1 as resolveTurnExecutionPolicyV12
 } from "@opengeni/config";
-import { Context as Context2 } from "@temporalio/activity";
+import { Context as Context3 } from "@temporalio/activity";
 import { createHash as createHash3 } from "crypto";
 
 // src/scheduled-alert-occurrence.ts
@@ -4641,13 +5704,21 @@ function canonicalLabels(value) {
 }
 
 // src/activities/scheduled-tasks.ts
+function scheduledTaskRunExecutionPolicy(policy, input, creatorRestriction) {
+  return creatorRestriction === "developer_setup" || input.triggerType !== "scheduled" && input.credentialRestriction === "developer_setup" ? { ...policy, credentialRestriction: "developer_setup" } : policy;
+}
+function scheduledSessionExecutionPolicyMetadata(policy, creatorRestriction) {
+  if (policy === void 0 || policy === null) return {};
+  const acceptedPolicy = TurnExecutionPolicyV1.parse(policy);
+  return creatorRestriction === "developer_setup" && acceptedPolicy.credentialRestriction === "developer_setup" ? metadataWithTurnExecutionPolicyV1({}, acceptedPolicy) : {};
+}
 function scheduledTaskRunProducerKey(input, suppliedActivityIdentity) {
   if (input.producerKey) return input.producerKey;
   if (input.triggerType !== "scheduled") return input.agentRunUsageIdempotencyKey;
   let info = suppliedActivityIdentity;
   if (!info) {
     try {
-      info = Context2.current().info;
+      info = Context3.current().info;
     } catch {
       throw new Error(
         "scheduled task delivery without a producer key requires a Temporal activity execution"
@@ -4666,6 +5737,13 @@ function scheduledTaskGeneratedSessionCreateIdempotencyKey(producerKey) {
   const digest = createHash3("sha256").update("scheduled-task-run\0", "utf8").update(producerKey, "utf8").digest("hex");
   return `scheduled-task-run:${digest}`;
 }
+function recordScheduledSessionCreated(observability) {
+  recordSessionCreated(observability, {
+    surface: "scheduled",
+    createdByKind: "service",
+    parentSessionId: null
+  });
+}
 function scheduledTaskSessionTitle(taskName) {
   return normalizeAutomaticSessionTitle(taskName) ?? "Scheduled run";
 }
@@ -4708,6 +5786,9 @@ function createScheduledTaskActivities(services) {
         producerKey: stableProducerKey
       });
       if (priorRun?.actionKind === "agent_turn") {
+        if (priorRun.admissionDiagnostic || priorRun.admissionRefusal) {
+          return scheduledAdmissionRefusalResult(priorRun);
+        }
         const acceptedExecution = await getScheduledTaskRunAcceptedExecution(db, {
           workspaceId: input.workspaceId,
           runId: priorRun.id
@@ -4718,6 +5799,15 @@ function createScheduledTaskActivities(services) {
           }
           throw new Error("scheduled agent run is missing accepted execution truth");
         }
+        if (priorRun.status === "queued" && isRetiredNativeAtlassianTask(acceptedExecution.task)) {
+          await markScheduledTaskRunFailedIfQueued(
+            db,
+            priorRun.workspaceId,
+            priorRun.id,
+            ATLASSIAN_NATIVE_RETIRED_REASON
+          );
+          return scheduledRunTerminalResult(ATLASSIAN_NATIVE_RETIRED_REASON);
+        }
         await recordScheduledTaskFiredUsage(db, acceptedExecution, priorRun);
         if (priorRun.status === "dispatched") {
           return await replayScheduledTaskDispatch({
@@ -4737,6 +5827,7 @@ function createScheduledTaskActivities(services) {
           try {
             return await recoverBoundScheduledTaskDispatch({
               db,
+              observability: baseService.observability,
               bus,
               settings: settings2,
               wakeSessionWorkflow,
@@ -4778,6 +5869,8 @@ function createScheduledTaskActivities(services) {
       if (!task) {
         return { action: "deleted" };
       }
+      if (isRetiredNativeAtlassianTask(task))
+        return { action: "blocked", reason: ATLASSIAN_NATIVE_RETIRED_REASON };
       if (task.action.kind !== "agent_turn") {
         return { action: "blocked", reason: "legacy_source_schedule_requires_migration" };
       }
@@ -4805,20 +5898,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 +5910,35 @@ 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;
+      const refuseAdmission = async (reason, retryable, detail) => {
+        console.warn(
+          `[scheduled-task] refused occurrence of ${task.id} (revision ${task.authorityRevision}): ${reason}: ${detail}`
+        );
+        const receipt = await recordScheduledTaskAdmissionRefusal(db, {
+          workspaceId: task.workspaceId,
+          taskId: task.id,
+          taskAuthorityRevision: task.authorityRevision,
+          taskExecutionDigest: task.executionDigest,
+          triggerType: input.triggerType,
+          producerKey: stableProducerKey,
+          reason,
+          retryable
+        });
+        if (!receipt.admissionRefusal) {
+          return createScheduledTaskActivities(services).dispatchScheduledTaskRun(input);
+        }
+        return scheduledAdmissionRefusalResult(receipt);
+      };
+      if (task.action.kind === "agent_turn" && ((taskRevisionAuthority?.subjectId ?? null) !== taskAuthoritySubjectId || [taskPersonalResourceAuthoritySubjectId].some(
+        (subject) => subject !== null && subject !== taskAuthoritySubjectId
+      ))) {
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "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,
@@ -4843,18 +5947,113 @@ function createScheduledTaskActivities(services) {
         taskAuthoritySubjectId
       ) : null;
       const settings = await settingsForTask(task, targetSessionExecutionBase?.model);
-      const model = task.agentConfig.model ?? settings.openaiModel;
-      const reasoningEffort = task.agentConfig.reasoningEffort ?? settings.openaiReasoningEffort;
+      const resolvedDefault = task.agentConfig.model || targetSessionExecutionBase ? null : await resolveScheduledTaskDefaultModel(db, settings, task);
+      const model = task.agentConfig.model ?? resolvedDefault?.model ?? settings.openaiModel;
+      const reasoningEffort = task.agentConfig.reasoningEffort ?? resolvedDefault?.reasoningEffort ?? settings.openaiReasoningEffort;
       let sandboxBackend = task.agentConfig.sandboxBackend ?? settings.sandboxBackend;
       let sandboxOs = "linux";
-      const taskTools = withFirstPartyTools(settings, task.agentConfig.tools);
+      let taskTools = withFirstPartyTools(settings, task.agentConfig.tools);
       const creatorPolicy = await getScheduledTaskCreatorPolicy(db, task.workspaceId, task.id);
-      const firstPartyMcpTools = creatorPolicy?.firstPartyMcpTools ? allowedFirstPartyMcpToolsForSession(settings, creatorPolicy.firstPartyMcpTools) : resolveFirstPartyMcpToolPolicy(settings).default;
+      let firstPartyMcpTools = withScheduledSlackBotPostingTools(
+        creatorPolicy?.firstPartyMcpTools ? allowedFirstPartyMcpToolsForSession(settings, creatorPolicy.firstPartyMcpTools) : resolveFirstPartyMcpToolPolicy(settings).default,
+        task.agentConfig,
+        resolveFirstPartyMcpToolPolicy(settings).allowed
+      );
+      let resolvedAgentConfig = null;
+      let resolvedAgentInstructions;
+      const generatedTarget = task.runMode === "new_session_per_run" || task.runMode === "reusable_session" && task.reusableSessionId === null;
+      if (generatedTarget) {
+        try {
+          const agentResolution = resolveSessionAgentConfigForCreate2({
+            settings,
+            creator: "scheduled",
+            request: task.agentConfig.agent,
+            instructions: void 0,
+            workspaceSettings: (await requireWorkspace2(db, task.workspaceId)).settings,
+            parent: null,
+            goal: task.agentConfig.goal !== void 0
+          });
+          resolvedAgentConfig = agentResolution.config;
+          resolvedAgentInstructions = agentResolution.instructions;
+          const written = applySessionAgentConfigWriteThrough2({
+            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.status : void 0;
+          if (!(error instanceof Error) || status !== 422) throw error;
+          return await refuseAdmission(
+            "scheduled_authority_unavailable",
+            false,
+            `scheduled agent configuration is not admissible: ${error.message}`
+          );
+        }
+      }
       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: mergeResourceRefs(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 error;
+        throw error;
+      });
+      if (taskConnections instanceof ConnectionAccountSelectionError) {
+        const receipt = await recordScheduledTaskAdmissionFailure(db, {
+          workspaceId: task.workspaceId,
+          taskId: task.id,
+          taskAuthorityRevision: task.authorityRevision,
+          taskExecutionDigest: task.executionDigest,
+          triggerType: input.triggerType,
+          producerKey: stableProducerKey,
+          diagnostic: taskConnections.diagnostic
+        });
+        if (!receipt.admissionDiagnostic) {
+          return createScheduledTaskActivities(services).dispatchScheduledTaskRun(input);
+        }
+        return scheduledAdmissionRefusalResult(receipt);
+      }
+      const {
+        personalConnectionDelegations: taskPersonalConnectionDelegations,
+        mcpAccountBindings: taskMcpAccountBindings
+      } = taskConnections;
+      const taskConnectionAuthoritySubjectId = taskPersonalConnectionDelegations.length > 0 ? taskAuthoritySubjectId : null;
       const creatorSessionPolicy = scheduledCreatorSessionPolicyInput(
         creatorPolicy?.sessionPolicy ?? null
       );
-      const generatedTarget = task.runMode === "new_session_per_run" || task.runMode === "reusable_session" && task.reusableSessionId === null;
       if (generatedTarget && task.agentConfig.machineTarget) {
         const access = {
           accountId: task.accountId,
@@ -4867,19 +6066,38 @@ function createScheduledTaskActivities(services) {
           task.agentConfig.machineTarget.targetSandboxId
         );
         if (!machine || machine.kind !== "selfhosted" || !machine.enrollmentId || machine.scope === "user") {
-          throw new Error("scheduled Connected Machine target is unavailable");
+          return await refuseAdmission(
+            "machine_target_unavailable",
+            false,
+            "scheduled Connected Machine target is unavailable"
+          );
         }
         const enrollment = await getEnrollment(db, access, machine.enrollmentId);
-        if (!enrollment || enrollment.status !== "active") {
-          throw new Error("scheduled Connected Machine enrollment is unavailable");
+        if (!enrollment) {
+          return await refuseAdmission(
+            "machine_target_unavailable",
+            false,
+            "scheduled Connected Machine enrollment is gone"
+          );
+        }
+        if (enrollment.status !== "active") {
+          return await refuseAdmission(
+            "machine_enrollment_inactive",
+            true,
+            `scheduled Connected Machine enrollment is ${enrollment.status}`
+          );
         }
         sandboxBackend = "selfhosted";
         sandboxOs = enrollment.os;
       } else if (generatedTarget && sandboxBackend === "selfhosted") {
-        throw new Error("self-hosted scheduled task has no Connected Machine target");
+        return await refuseAdmission(
+          "machine_target_unavailable",
+          false,
+          "self-hosted scheduled task has no Connected Machine target"
+        );
       }
       const generatedSessionDepthPolicy = generatedTarget ? await (async () => {
-        const workspace = await requireWorkspace(db, task.workspaceId);
+        const workspace = await requireWorkspace2(db, task.workspaceId);
         const deployment = await getNestedAgentDepthDeploymentPolicy(db);
         const taskOverride = task.agentConfig.maxNestedAgentDepth ?? null;
         const workspaceOverride = typeof workspace.settings.maxNestedAgentDepth === "number" ? workspace.settings.maxNestedAgentDepth : null;
@@ -4898,20 +6116,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 +6132,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,
@@ -4946,7 +6160,11 @@ function createScheduledTaskActivities(services) {
         task.variableSetId
       ) : null;
       if (generatedTarget && task.variableSetId && !acceptedVariableSet) {
-        throw new Error(`variable set not found: ${task.variableSetId}`);
+        return await refuseAdmission(
+          "variable_set_unavailable",
+          false,
+          `variable set not found: ${task.variableSetId}`
+        );
       }
       const acceptedRig = generatedTarget && task.rigId ? await getRig2(
         db,
@@ -4958,11 +6176,16 @@ 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}`);
+        return await refuseAdmission(
+          "rig_version_unavailable",
+          false,
+          `sandbox environment has no active version to bind: ${task.rigId}`
+        );
       }
-      const acceptedRigDefaultVariableSets = acceptedRig?.activeVersion ? await Promise.all(
-        acceptedRig.activeVersion.defaultVariableSetIds.map(async (variableSetId) => {
-          const variableSet = await getVariableSet(
+      const acceptedRigDefaultVariableSetRows = acceptedRig?.activeVersion ? await Promise.all(
+        acceptedRig.activeVersion.defaultVariableSetIds.map(async (variableSetId) => ({
+          variableSetId,
+          variableSet: await getVariableSet(
             db,
             {
               accountId: task.accountId,
@@ -4970,13 +6193,22 @@ function createScheduledTaskActivities(services) {
               subjectId: taskAuthoritySubjectId ?? task.createdBy.subjectId
             },
             variableSetId
-          );
-          if (!variableSet) {
-            throw new Error(`rig default Variable Set not found: ${variableSetId}`);
-          }
-          return { id: variableSet.id, generation: variableSet.generation };
-        })
+          )
+        }))
       ) : [];
+      const missingRigDefaultVariableSet = acceptedRigDefaultVariableSetRows.find(
+        (row) => !row.variableSet
+      );
+      if (missingRigDefaultVariableSet) {
+        return await refuseAdmission(
+          "variable_set_unavailable",
+          false,
+          `sandbox environment default Variable Set not found: ${missingRigDefaultVariableSet.variableSetId}`
+        );
+      }
+      const acceptedRigDefaultVariableSets = acceptedRigDefaultVariableSetRows.map(
+        ({ variableSet }) => ({ id: variableSet.id, generation: variableSet.generation })
+      );
       let incidentPreflightRequired = incidentDeclaration.action === "required";
       if (incidentPreflightRequired) {
         const existingSessionId = task.runMode === "existing_session" ? task.targetSessionId : task.reusableSessionId;
@@ -5031,6 +6263,7 @@ function createScheduledTaskActivities(services) {
         incidentPreflightRequired = preflight.action === "ready";
       }
       const taskXaiProviderAccountAuthoritySnapshot = await getScheduledTaskXaiProviderAccountAuthoritySnapshot(db, task.workspaceId, task.id);
+      const taskClaudeProviderAccountAuthoritySnapshot = await getScheduledTaskClaudeProviderAccountAuthoritySnapshot(db, task.workspaceId, task.id);
       const slackBotConnection = task.agentConfig.slackBotConnectionId ? await requireOpenGeniSlackBotConnection(
         db,
         task.workspaceId,
@@ -5038,23 +6271,58 @@ function createScheduledTaskActivities(services) {
       ) : null;
       const slackBotMetadata = slackBotConnection ? openGeniSlackBotMetadata(slackBotConnection.metadata) : null;
       if (slackBotConnection && !slackBotMetadata) {
-        throw new Error("OpenGeni Slack bot connection metadata is invalid");
+        throw new Error("Opengeni Slack bot connection metadata is invalid");
       }
       const xaiAuthoritySubjectId = taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? task.createdBy.subjectId : null;
       if (taskXaiProviderAccountAuthoritySnapshot.scope === "user" && !xaiAuthoritySubjectId) {
-        throw new Error("scheduled user-scoped xAI authority has no causal human");
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "scheduled user-scoped xAI authority has no causal human"
+        );
       }
       if (xaiAuthoritySubjectId && taskAuthoritySubjectId && xaiAuthoritySubjectId !== taskAuthoritySubjectId) {
-        throw new Error("scheduled authority classes have different causal humans");
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "scheduled authority classes have different causal humans"
+        );
       }
-      const causalHumanSubjectId = taskAuthoritySubjectId ?? xaiAuthoritySubjectId;
+      const claudeAuthoritySubjectId = taskClaudeProviderAccountAuthoritySnapshot.scope === "user" && task.ownerSubjectId ? task.ownerSubjectId : null;
+      if (taskClaudeProviderAccountAuthoritySnapshot.scope === "user" && !claudeAuthoritySubjectId) {
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "scheduled user-scoped Claude authority has no causal human"
+        );
+      }
+      if (claudeAuthoritySubjectId && taskAuthoritySubjectId && claudeAuthoritySubjectId !== taskAuthoritySubjectId) {
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "scheduled authority classes have different causal humans"
+        );
+      }
+      const causalHumanSubjectId = taskAuthoritySubjectId ?? xaiAuthoritySubjectId ?? claudeAuthoritySubjectId;
+      if (xaiAuthoritySubjectId && claudeAuthoritySubjectId && xaiAuthoritySubjectId !== claudeAuthoritySubjectId)
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "scheduled subscription pools have different causal humans"
+        );
       if (task.agentConfig.knowledgeSource && causalHumanSubjectId !== task.agentConfig.knowledgeSource.initiatingSubjectId) {
-        throw new Error(
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
           "Source schedule requires its connection owner's current human authorization; update the source schedule to authorize it"
         );
       }
       if ((acceptedVariableSet?.scope === "user" || acceptedRig?.scope === "user") && !causalHumanSubjectId) {
-        throw new Error("scheduled personal-resource execution has no causal human");
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          false,
+          "scheduled personal-resource execution has no causal human"
+        );
       }
       const admissionDenial = await agentRunAdmissionDenial(
         { ...baseService, settings },
@@ -5062,11 +6330,12 @@ function createScheduledTaskActivities(services) {
           accountId: task.accountId,
           workspaceId: task.workspaceId,
           model: targetSessionExecution?.model ?? model,
-          requestedAgentRuns: input.agentRunUsageIdempotencyKey ? 0 : 1
+          requestedAgentRuns: input.agentRunUsageIdempotencyKey ? 0 : 1,
+          initiatingHumanSubjectId: causalHumanSubjectId
         }
       );
       if (admissionDenial) {
-        return { action: "blocked", reason: admissionDenial };
+        return await refuseAdmission(admissionDenial, true, "agent run admission denied");
       }
       const acceptedModel = targetSessionExecution?.model ?? model;
       const acceptedReasoningEffort = targetSessionExecution?.reasoningEffort ?? reasoningEffort;
@@ -5085,15 +6354,19 @@ function createScheduledTaskActivities(services) {
           );
         }
       } : void 0;
-      const turnExecutionPolicy = resolveTurnExecutionPolicyV12(settings, {
-        modelId: acceptedModel,
-        requestedModelId: generatedTarget && task.agentConfig.model ? task.agentConfig.model : null,
-        modelSource: generatedTarget ? task.agentConfig.model ? "explicit" : "deployment" : "session",
-        reasoningEffort: acceptedReasoningEffort,
-        reasoningSource: generatedTarget ? task.agentConfig.reasoningEffort ? "explicit" : "deployment" : "session",
-        latencyMode: acceptedLatencyMode,
-        latencyModeSource: generatedTarget ? "deployment" : "session"
-      });
+      const turnExecutionPolicy = scheduledTaskRunExecutionPolicy(
+        resolveTurnExecutionPolicyV12(settings, {
+          modelId: acceptedModel,
+          requestedModelId: generatedTarget && task.agentConfig.model ? task.agentConfig.model : null,
+          modelSource: generatedTarget ? task.agentConfig.model ? "explicit" : "deployment" : "session",
+          reasoningEffort: acceptedReasoningEffort,
+          reasoningSource: generatedTarget ? task.agentConfig.reasoningEffort ? "explicit" : "deployment" : "session",
+          latencyMode: acceptedLatencyMode,
+          latencyModeSource: generatedTarget ? "deployment" : "session"
+        }),
+        input,
+        creatorPolicy?.credentialRestriction
+      );
       const deferredEvents = [];
       const executeDispatch = async (dispatchDb, deferPublications) => {
         const admittedRunId = crypto.randomUUID();
@@ -5115,6 +6388,10 @@ function createScheduledTaskActivities(services) {
           resolvedTools: taskTools,
           resolvedFirstPartyMcpTools: firstPartyMcpTools,
           resolvedFirstPartyMcpPermissions: firstPartyMcpPermissions,
+          ...resolvedAgentConfig ? {
+            resolvedAgentConfig,
+            ...resolvedAgentInstructions !== void 0 ? { resolvedAgentInstructions } : {}
+          } : {},
           resolvedVariableSet: acceptedVariableSet ? { id: acceptedVariableSet.id, generation: acceptedVariableSet.generation } : null,
           resolvedRig: acceptedRig?.activeVersion ? {
             id: acceptedRig.id,
@@ -5130,11 +6407,14 @@ function createScheduledTaskActivities(services) {
           targetSessionExecution,
           generatedSessionBinding,
           personalConnectionDelegations: taskPersonalConnectionDelegations,
+          mcpAccountBindings: taskMcpAccountBindings,
           personalResourceAuthoritySubjectId: taskPersonalResourceAuthoritySubjectId,
           causalHumanSubjectId,
           causalHumanAuthority: taskRevisionAuthority,
           xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
+          claudeProviderAccountAuthoritySnapshot: taskClaudeProviderAccountAuthoritySnapshot,
           xaiAuthoritySubjectId,
+          claudeAuthoritySubjectId,
           connectionAuthoritySubjectId: taskConnectionAuthoritySubjectId,
           triggerInitiator: input.initiator ?? { kind: "service", subjectId: "scheduler" },
           agentRunUsageIdempotencyKey: input.agentRunUsageIdempotencyKey ?? null,
@@ -5243,13 +6523,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 +6544,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;
@@ -5294,6 +6570,8 @@ function createScheduledTaskActivities(services) {
                 tools: taskTools,
                 firstPartyMcpTools,
                 firstPartyMcpPermissions,
+                ...resolvedAgentConfig ? { agentConfig: resolvedAgentConfig } : {},
+                ...resolvedAgentInstructions !== void 0 ? { instructions: resolvedAgentInstructions } : {},
                 ...creatorSessionPolicy,
                 ...task.agentConfig.knowledgeSource?.destination.kind === "personal" ? {
                   visibility: "user_private",
@@ -5301,6 +6579,10 @@ function createScheduledTaskActivities(services) {
                 } : {},
                 metadata: {
                   ...taskMetadata,
+                  ...scheduledSessionExecutionPolicyMetadata(
+                    turnExecutionPolicy,
+                    creatorPolicy?.credentialRestriction
+                  ),
                   model,
                   reasoningEffort,
                   scheduledTaskId: task.id,
@@ -5330,6 +6612,7 @@ function createScheduledTaskActivities(services) {
                 rigVersionId: frozenRigVersionId,
                 personalConnectionDelegations: [],
                 initialXaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
+                initialClaudeProviderAccountAuthoritySnapshot: taskClaudeProviderAccountAuthoritySnapshot,
                 maxNestedAgentDepthOverride: task.agentConfig.maxNestedAgentDepth ?? null,
                 frozenNestedAgentDepthPolicy: {
                   effectiveMaxNestedAgentDepth: generatedSessionBinding.effectiveMaxNestedAgentDepth,
@@ -5390,6 +6673,7 @@ function createScheduledTaskActivities(services) {
               }
               session = created.session;
               sessionCreated = created.created;
+              if (sessionCreated) recordScheduledSessionCreated(baseService.observability);
               if (!sessionCreated) {
                 await bindScheduledTaskRunSessionInTransaction(dispatchDb, {
                   accountId: task.accountId,
@@ -5420,7 +6704,7 @@ function createScheduledTaskActivities(services) {
               }
               if (scheduledSlackBotConnectionId(session.metadata) !== (task.agentConfig.slackBotConnectionId ?? null)) {
                 throw new Error(
-                  "scheduled alert occurrence OpenGeni Slack bot binding does not match its canonical session"
+                  "scheduled alert occurrence Opengeni Slack bot binding does not match its canonical session"
                 );
               }
             }
@@ -5476,7 +6760,7 @@ function createScheduledTaskActivities(services) {
                     events: started.events
                   });
                 } else {
-                  await publishDurableSessionEvents(
+                  await publishDurableSessionEvents2(
                     bus,
                     task.workspaceId,
                     session.id,
@@ -5519,7 +6803,7 @@ function createScheduledTaskActivities(services) {
                 if (deferPublications) {
                   deferredEvents.push({ sessionId: session.id, events: started.events });
                 } else {
-                  await publishDurableSessionEvents(
+                  await publishDurableSessionEvents2(
                     bus,
                     task.workspaceId,
                     session.id,
@@ -5548,7 +6832,7 @@ function createScheduledTaskActivities(services) {
               if (deferPublications) {
                 deferredEvents.push({ sessionId: session.id, events: titleEvents });
               } else {
-                await publishDurableSessionEvents(bus, task.workspaceId, session.id, titleEvents);
+                await publishDurableSessionEvents2(bus, task.workspaceId, session.id, titleEvents);
               }
             }
             const scheduledUpdate = await addSessionSystemUpdateWithSourceMutation(
@@ -5574,10 +6858,13 @@ function createScheduledTaskActivities(services) {
                   scheduledTaskRunId: run.id,
                   ...causalHumanSubjectId ? { causalHumanSubjectId } : {},
                   ...taskConnectionAuthoritySubjectId ? { connectionAuthoritySubjectId: taskConnectionAuthoritySubjectId } : {},
-                  ...taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? { xaiAuthoritySubjectId: task.createdBy.subjectId } : {}
+                  ...taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? { xaiAuthoritySubjectId: task.createdBy.subjectId } : {},
+                  ...claudeAuthoritySubjectId ? { claudeAuthoritySubjectId } : {}
                 },
                 personalConnectionDelegations: taskPersonalConnectionDelegations,
+                mcpAccountBindings: taskMcpAccountBindings,
                 xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
+                claudeProviderAccountAuthoritySnapshot: taskClaudeProviderAccountAuthoritySnapshot,
                 scheduledTaskRunId: run.id
               },
               async (tx, wakeEventId, _updateId, rejectionReason) => {
@@ -5624,6 +6911,9 @@ function createScheduledTaskActivities(services) {
                 run: { ...run, status: "skipped", error }
               };
             }
+            if (scheduledUpdate.added) {
+              recordUserMessageAccepted(baseService.observability, { surface: "scheduled" });
+            }
             if (scheduledUpdate.added && scheduledUpdate.events.length > 0) {
               if (deferPublications) {
                 deferredEvents.push({
@@ -5631,7 +6921,7 @@ function createScheduledTaskActivities(services) {
                   events: scheduledUpdate.events
                 });
               } else {
-                await publishDurableSessionEvents(
+                await publishDurableSessionEvents2(
                   bus,
                   task.workspaceId,
                   session.id,
@@ -5683,10 +6973,13 @@ function createScheduledTaskActivities(services) {
                   scheduledTaskRunId: run.id,
                   ...causalHumanSubjectId ? { causalHumanSubjectId } : {},
                   ...taskConnectionAuthoritySubjectId ? { connectionAuthoritySubjectId: taskConnectionAuthoritySubjectId } : {},
-                  ...taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? { xaiAuthoritySubjectId: task.createdBy.subjectId } : {}
+                  ...taskXaiProviderAccountAuthoritySnapshot.scope === "user" && task.createdBy.kind === "subject" ? { xaiAuthoritySubjectId: task.createdBy.subjectId } : {},
+                  ...claudeAuthoritySubjectId ? { claudeAuthoritySubjectId } : {}
                 },
                 personalConnectionDelegations: taskPersonalConnectionDelegations,
+                mcpAccountBindings: taskMcpAccountBindings,
                 xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
+                claudeProviderAccountAuthoritySnapshot: taskClaudeProviderAccountAuthoritySnapshot,
                 scheduledTaskRunId: run.id
               },
               async (tx, wakeEventId, _updateId, rejectionReason) => {
@@ -5747,6 +7040,9 @@ function createScheduledTaskActivities(services) {
                 run: { ...run, status: "skipped", error }
               };
             }
+            if (bundled.added) {
+              recordUserMessageAccepted(baseService.observability, { surface: "scheduled" });
+            }
             if (bundled.added && bundled.events.length > 0) {
               if (deferPublications) {
                 deferredEvents.push({
@@ -5754,7 +7050,7 @@ function createScheduledTaskActivities(services) {
                   events: bundled.events
                 });
               } else {
-                await publishDurableSessionEvents(
+                await publishDurableSessionEvents2(
                   bus,
                   task.workspaceId,
                   session.id,
@@ -5836,7 +7132,7 @@ function createScheduledTaskActivities(services) {
         });
       }
       for (const deferred of deferredEvents) {
-        await publishDurableSessionEvents(
+        await publishDurableSessionEvents2(
           bus,
           task.workspaceId,
           deferred.sessionId,
@@ -5866,16 +7162,11 @@ var IncidentTelemetryPreflightBlockedError = class extends Error {
   }
 };
 function assertReusableSessionBindingMatches(session, task) {
-  if ((session.variableSetId ?? null) !== (task.variableSetId ?? null)) {
-    throw new ScheduledRunTerminalAuthorityError(
-      "scheduled_reusable_binding_changed",
-      "scheduled task variableSet attachment does not match its reusable session"
-    );
-  }
+  if (task.runMode === "existing_session") return;
   if (scheduledSlackBotConnectionId(session.metadata) !== (task.agentConfig.slackBotConnectionId ?? null)) {
     throw new ScheduledRunTerminalAuthorityError(
       "scheduled_reusable_binding_changed",
-      "scheduled task OpenGeni Slack bot binding does not match its reusable session"
+      "scheduled task Opengeni Slack bot binding does not match its reusable session"
     );
   }
 }
@@ -5921,7 +7212,25 @@ function scheduledRunRecoveryTerminalError(error) {
   }
   return null;
 }
+function scheduledAdmissionRefusalResult(run) {
+  if (run.admissionRefusal) {
+    return {
+      action: "blocked",
+      reason: run.admissionRefusal.reason,
+      runId: run.id,
+      refusal: run.admissionRefusal
+    };
+  }
+  return {
+    action: "blocked",
+    reason: "connection_account_unavailable",
+    runId: run.id,
+    ...run.admissionDiagnostic ? { diagnostic: run.admissionDiagnostic } : {}
+  };
+}
 function scheduledRunTerminalResult(error) {
+  if (error === ATLASSIAN_NATIVE_RETIRED_REASON)
+    return { action: "blocked", reason: ATLASSIAN_NATIVE_RETIRED_REASON };
   if (error === "scheduled_authority_exhausted") {
     return { action: "blocked", reason: "scheduled_authority_exhausted" };
   }
@@ -5941,46 +7250,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,
@@ -6060,7 +7361,7 @@ async function seedScheduledGeneratedSessionRoute(input) {
     if (input.deferPublications) {
       input.deferredEvents.push({ sessionId: input.session.id, events: failed.events });
     } else {
-      await publishDurableSessionEvents(
+      await publishDurableSessionEvents2(
         input.bus,
         input.task.workspaceId,
         input.session.id,
@@ -6080,6 +7381,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
     throw new Error("scheduled run is not an exact queued recovery");
   }
   const generatedSession = task.runMode === "new_session_per_run" || task.runMode === "reusable_session" && task.reusableSessionId === null;
+  const recoveredCreatorPolicy = generatedSession ? await getScheduledTaskCreatorPolicy(input.db, task.workspaceId, task.id) : null;
   const frozenSlack = input.acceptedExecution.resolvedSlackBotConnection;
   if (frozenSlack) {
     const currentSlack = await requireOpenGeniSlackBotConnection(
@@ -6139,11 +7441,6 @@ async function recoverBoundScheduledTaskDispatch(input) {
     }
     const taskMetadata = { ...task.agentConfig.metadata };
     delete taskMetadata[OPENGENI_SLACK_BOT_SESSION_METADATA_KEY];
-    const recoveredCreatorPolicy = await getScheduledTaskCreatorPolicy(
-      input.db,
-      task.workspaceId,
-      task.id
-    );
     const created = await createSessionWithIdempotencyKeyResult(input.db, {
       accountId: task.accountId,
       workspaceId: task.workspaceId,
@@ -6153,6 +7450,8 @@ 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 !== void 0 ? { instructions: input.acceptedExecution.resolvedAgentInstructions } : {},
       ...scheduledCreatorSessionPolicyInput(recoveredCreatorPolicy?.sessionPolicy ?? null),
       ...task.agentConfig.knowledgeSource?.destination.kind === "personal" ? {
         visibility: "user_private",
@@ -6160,6 +7459,10 @@ async function recoverBoundScheduledTaskDispatch(input) {
       } : {},
       metadata: {
         ...taskMetadata,
+        ...scheduledSessionExecutionPolicyMetadata(
+          input.acceptedExecution.turnExecutionPolicy,
+          recoveredCreatorPolicy?.credentialRestriction
+        ),
         model: input.acceptedExecution.resolvedModel,
         reasoningEffort: input.acceptedExecution.resolvedReasoningEffort,
         scheduledTaskId: task.id,
@@ -6187,6 +7490,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
       rigVersionId: rig?.versionId ?? null,
       personalConnectionDelegations: [],
       initialXaiProviderAccountAuthoritySnapshot: input.acceptedExecution.xaiProviderAccountAuthoritySnapshot,
+      initialClaudeProviderAccountAuthoritySnapshot: input.acceptedExecution.claudeProviderAccountAuthoritySnapshot,
       maxNestedAgentDepthOverride: task.agentConfig.maxNestedAgentDepth ?? null,
       frozenNestedAgentDepthPolicy: {
         effectiveMaxNestedAgentDepth: input.acceptedExecution.generatedSessionBinding.effectiveMaxNestedAgentDepth,
@@ -6212,6 +7516,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
     });
     if (created.denied) throw new SessionSpawnDeniedDbError(created.denial);
     session = created.session;
+    if (created.created) recordScheduledSessionCreated(input.observability);
     if (!created.created) {
       await bindScheduledTaskRunSessionInTransaction(input.db, {
         accountId: task.accountId,
@@ -6275,21 +7580,28 @@ 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 } : {}
-    };
-    if (session.createIdempotencyKey !== expectedCreateKey || session.initialMessage !== task.agentConfig.prompt || session.instructions !== null || session.policyRole !== null || stableJson(session.skills) !== "[]" || stableJson(session.toolPolicy) !== stableJson({ mode: "explicit", inheritedFromSessionId: null }) || session.toolPolicyVersion !== 1 || session.mcpServers.length !== 0 || session.parentSessionId !== null || session.rootSessionId !== session.id || session.nestedAgentDepth !== 0 || session.effectiveMaxNestedAgentDepth !== generatedBinding.effectiveMaxNestedAgentDepth || session.nestedAgentDepthPolicySource !== generatedBinding.nestedAgentDepthPolicySource || session.nestedAgentDepthPolicySessionId !== (generatedBinding.nestedAgentDepthPolicySource === "session" ? session.id : null) || session.sandboxGroupId !== session.id || session.channelId !== null || session.codexCompactionMode !== generatedBinding.codexCompactionMode || stableJson(session.metadata) !== stableJson(expectedMetadata) || session.createdBy.kind !== "service" || session.createdBy.subjectId !== "scheduler" || stableJson(session.createdByContext) !== stableJson({
+    const expectedMetadata = metadataWithAgentConfigCreateIdentity(
+      {
+        ...expectedTaskMetadata,
+        ...scheduledSessionExecutionPolicyMetadata(
+          input.acceptedExecution.turnExecutionPolicy,
+          recoveredCreatorPolicy?.credentialRestriction
+        ),
+        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 !== (input.acceptedExecution.resolvedAgentInstructions ?? null) || session.policyRole !== null || stableJson(session.skills) !== "[]" || stableJson(session.toolPolicy) !== stableJson({ mode: "explicit", inheritedFromSessionId: null }) || session.toolPolicyVersion !== 1 || session.mcpServers.length !== 0 || session.parentSessionId !== null || session.rootSessionId !== session.id || session.nestedAgentDepth !== 0 || session.effectiveMaxNestedAgentDepth !== generatedBinding.effectiveMaxNestedAgentDepth || session.nestedAgentDepthPolicySource !== generatedBinding.nestedAgentDepthPolicySource || session.nestedAgentDepthPolicySessionId !== (generatedBinding.nestedAgentDepthPolicySource === "session" ? session.id : null) || session.sandboxGroupId !== session.id || session.channelId !== null || session.codexCompactionMode !== generatedBinding.codexCompactionMode || stableJson(session.metadata) !== stableJson(expectedMetadata) || session.createdBy.kind !== "service" || session.createdBy.subjectId !== "scheduler" || stableJson(session.createdByContext) !== stableJson({
       label: "OpenGeni scheduler",
       scheduledTaskId: task.id,
       scheduledTaskRunId: canonicalGeneratedRunId
-    }) || task.runMode === "new_session_per_run" && input.acceptedExecution.alertOccurrenceLabels === null && (session.metadata.scheduledTaskRunId !== input.run.id || session.createdByContext.scheduledTaskRunId !== input.run.id) || creationPolicy?.model !== input.acceptedExecution.resolvedModel || creationPolicy.reasoningEffort !== input.acceptedExecution.resolvedReasoningEffort || creationPolicy.latencyMode !== input.acceptedExecution.resolvedLatencyMode || session.sandboxBackend !== input.acceptedExecution.resolvedSandboxBackend || session.sandboxOs !== input.acceptedExecution.resolvedSandboxOs || session.activeSandboxId !== (task.agentConfig.machineTarget?.targetSandboxId ?? null) || stableJson(session.resources) !== stableJson(task.agentConfig.resources) || stableJson(session.tools) !== stableJson(input.acceptedExecution.resolvedTools) || stableJson(session.firstPartyMcpTools) !== stableJson(input.acceptedExecution.resolvedFirstPartyMcpTools) || stableJson(session.firstPartyMcpPermissions) !== stableJson(input.acceptedExecution.resolvedFirstPartyMcpPermissions) || session.maxNestedAgentDepthOverride !== (task.agentConfig.maxNestedAgentDepth ?? null) || (session.variableSetId ?? null) !== (input.acceptedExecution.resolvedVariableSet?.id ?? null) || (session.rigId ?? null) !== (input.acceptedExecution.resolvedRig?.id ?? null) || (session.rigVersionId ?? null) !== (input.acceptedExecution.resolvedRig?.versionId ?? null) || scheduledSlackBotConnectionId(session.metadata) !== (frozenSlack?.id ?? null)) {
+    }) || task.runMode === "new_session_per_run" && input.acceptedExecution.alertOccurrenceLabels === null && (session.metadata.scheduledTaskRunId !== input.run.id || session.createdByContext.scheduledTaskRunId !== input.run.id) || creationPolicy?.model !== input.acceptedExecution.resolvedModel || creationPolicy.reasoningEffort !== input.acceptedExecution.resolvedReasoningEffort || creationPolicy.latencyMode !== input.acceptedExecution.resolvedLatencyMode || session.sandboxBackend !== input.acceptedExecution.resolvedSandboxBackend || session.sandboxOs !== input.acceptedExecution.resolvedSandboxOs || session.activeSandboxId !== (task.agentConfig.machineTarget?.targetSandboxId ?? null) || stableJson(session.resources) !== stableJson(task.agentConfig.resources) || stableJson(session.tools) !== stableJson(input.acceptedExecution.resolvedTools) || stableJson(session.firstPartyMcpTools) !== 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) || (session.rigId ?? null) !== (input.acceptedExecution.resolvedRig?.id ?? null) || (session.rigVersionId ?? null) !== (input.acceptedExecution.resolvedRig?.versionId ?? null) || scheduledSlackBotConnectionId(session.metadata) !== (frozenSlack?.id ?? null)) {
       throw new ScheduledRunTerminalAuthorityError(
         "scheduled_generated_session_changed",
         "scheduled generated session differs from accepted execution"
@@ -6320,7 +7632,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
     });
     workflowId = started.temporalWorkflowId;
     if (started.events.length > 0) {
-      await publishDurableSessionEvents(input.bus, task.workspaceId, session.id, started.events);
+      await publishDurableSessionEvents2(input.bus, task.workspaceId, session.id, started.events);
     }
     if (task.runMode === "reusable_session") {
       await materializeScheduledTaskReusableSessionFromRun(input.db, {
@@ -6339,7 +7651,7 @@ async function recoverBoundScheduledTaskDispatch(input) {
       taskName: task.name
     });
     if (titleEvents.length > 0) {
-      await publishDurableSessionEvents(input.bus, task.workspaceId, session.id, titleEvents);
+      await publishDurableSessionEvents2(input.bus, task.workspaceId, session.id, titleEvents);
     }
   }
   const scheduledUpdate = await addSessionSystemUpdateWithSourceMutation(
@@ -6367,10 +7679,13 @@ async function recoverBoundScheduledTaskDispatch(input) {
         ...input.acceptedExecution.connectionAuthoritySubjectId ? {
           connectionAuthoritySubjectId: input.acceptedExecution.connectionAuthoritySubjectId
         } : {},
-        ...input.acceptedExecution.xaiAuthoritySubjectId ? { xaiAuthoritySubjectId: input.acceptedExecution.xaiAuthoritySubjectId } : {}
+        ...input.acceptedExecution.xaiAuthoritySubjectId ? { xaiAuthoritySubjectId: input.acceptedExecution.xaiAuthoritySubjectId } : {},
+        ...input.acceptedExecution.claudeAuthoritySubjectId ? { claudeAuthoritySubjectId: input.acceptedExecution.claudeAuthoritySubjectId } : {}
       },
       personalConnectionDelegations: input.acceptedExecution.personalConnectionDelegations,
+      mcpAccountBindings: input.acceptedExecution.mcpAccountBindings ?? null,
       xaiProviderAccountAuthoritySnapshot: input.acceptedExecution.xaiProviderAccountAuthoritySnapshot,
+      claudeProviderAccountAuthoritySnapshot: input.acceptedExecution.claudeProviderAccountAuthoritySnapshot,
       scheduledTaskRunId: input.run.id
     },
     async (tx, wakeEventId, _updateId, rejectionReason) => {
@@ -6427,8 +7742,11 @@ async function recoverBoundScheduledTaskDispatch(input) {
   if (scheduledUpdate.reason === "session_cancelled" || scheduledUpdate.reason === "session_not_idle") {
     return { action: "blocked", reason: "scheduled_run_terminal" };
   }
+  if (scheduledUpdate.added) {
+    recordUserMessageAccepted(input.observability, { surface: "scheduled" });
+  }
   if (scheduledUpdate.added && scheduledUpdate.events.length > 0) {
-    await publishDurableSessionEvents(
+    await publishDurableSessionEvents2(
       input.bus,
       task.workspaceId,
       session.id,
@@ -6680,6 +7998,9 @@ async function dispatchMaintenanceSession(service, maintenance, dependencies) {
     accountId: maintenance.accountId,
     workspaceId: maintenance.workspaceId,
     initialMessage: maintenancePrompt(maintenance),
+    // OpenGeni's own periodic check: no human or product surface entered it.
+    surface: "system",
+    metrics: service.observability,
     resources: [],
     tools: [{ kind: "mcp", id: "opengeni" }],
     toolPolicy: { mode: "explicit", inheritedFromSessionId: null },
@@ -6766,43 +8087,55 @@ import {
   applySessionTurnSettlement,
   enqueueSessionWorkflowWake,
   failSessionWorkBeforeAttemptClaim,
+  blockSessionWorkBeforeAttemptClaim,
   requestSessionTurnRecovery,
   recoverSessionDispatch,
+  reconcileSettledSessionAttempt,
   reconcileSessionAttemptQuiescence,
+  reconcileCompletedSandboxSetup,
   peekSessionWork as peekSessionWorkDb,
   settleSessionInputWait as settleSessionInputWaitDb,
   countQueuedTurns as countQueuedTurns2,
   getSessionAttemptActivityRef,
   getSessionEvent,
   getSessionTurnForAttempt,
+  getWorkspace,
   expireSessionInteractionIntervention as expireSessionInteractionInterventionDb,
+  expireScheduledRunHumanWait as expireScheduledRunHumanWaitDb,
   expireSessionHumanInputRequest,
   markSessionAttemptQuiesced,
   requireSession as requireSession2,
-  settleSessionIdleWithParentOutbox
+  settleSessionIdleWithParentOutbox,
+  SANDBOX_SETUP_RECOVERY_LIMIT
 } from "@opengeni/db";
-import { publishDurableSessionEvents as publishDurableSessionEvents2 } from "@opengeni/events";
+import { publishDurableSessionEvents as publishDurableSessionEvents3 } 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 reconcileSettledSessionAttemptFn = overrides.reconcileSettledSessionAttempt ?? reconcileSettledSessionAttempt;
   const reconcileSessionAttemptQuiescenceFn = overrides.reconcileSessionAttemptQuiescence ?? reconcileSessionAttemptQuiescence;
   const peekSessionWorkFn = overrides.peekSessionWork ?? peekSessionWorkDb;
+  const reconcileCompletedSandboxSetupFn = overrides.reconcileCompletedSandboxSetup ?? reconcileCompletedSandboxSetup;
   const settleSessionInputWaitFn = overrides.settleSessionInputWait ?? settleSessionInputWaitDb;
   const countQueuedTurnsFn = overrides.countQueuedTurns ?? countQueuedTurns2;
   const getSessionAttemptActivityRefFn = overrides.getSessionAttemptActivityRef ?? getSessionAttemptActivityRef;
   const getSessionEventFn = overrides.getSessionEvent ?? getSessionEvent;
   const getSessionTurnForAttemptFn = overrides.getSessionTurnForAttempt ?? getSessionTurnForAttempt;
+  const getWorkspaceFn = overrides.getWorkspace ?? getWorkspace;
   const expireSessionHumanInputRequestFn = overrides.expireSessionHumanInputRequest ?? expireSessionHumanInputRequest;
   const expireSessionInteractionInterventionFn = overrides.expireSessionInteractionIntervention ?? expireSessionInteractionInterventionDb;
+  const expireScheduledRunHumanWaitFn = overrides.expireScheduledRunHumanWait ?? expireScheduledRunHumanWaitDb;
   const requireSessionFn = overrides.requireSession ?? requireSession2;
   const settleSessionIdleWithParentOutboxFn = overrides.settleSessionIdleWithParentOutbox ?? settleSessionIdleWithParentOutbox;
   const markSessionAttemptQuiescedFn = overrides.markSessionAttemptQuiesced ?? markSessionAttemptQuiesced;
-  const publishDurableSessionEventsFn = overrides.publishDurableSessionEvents ?? publishDurableSessionEvents2;
+  const publishDurableSessionEventsFn = overrides.publishDurableSessionEvents ?? publishDurableSessionEvents3;
   const deliverFailedChildTurnToParentFn = overrides.deliverFailedChildTurnToParent ?? deliverFailedChildTurnToParent;
   const notifyParentOfChildIdleFn = overrides.notifyParentOfChildIdle ?? notifyParentOfChildIdle;
   const recordTurnsQueuedGaugeFn = overrides.recordTurnsQueuedGauge ?? recordTurnsQueuedGauge;
@@ -6830,6 +8163,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 +8188,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" };
@@ -6868,10 +8224,18 @@ 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) {
+      return { action: "stale" };
+    }
     if (hasProviderRecoveryCount !== hasProviderFailureCode) {
       return { action: "stale" };
     }
@@ -6885,11 +8249,20 @@ function createSessionStateActivities(services, overrides = {}) {
         turnId: turn.id,
         triggerEventId: turn.triggerEventId,
         attemptId: input.attemptId,
-        reason: providerFailureCode ?? "claimed_attempt_database_failure",
+        reason: setupOutcomeUnknown ? "sandbox_command_start_outcome_unknown" : setupRecoveryExhausted ? "sandbox_command_start_recovery_exhausted" : providerFailureCode ?? "claimed_attempt_database_failure",
+        ...setupOutcomeUnknown ? { sandboxSetupOutcomeUnknown: true } : {},
+        ...setupRecoveryExhausted ? { sandboxSetupRecoveryExhausted: true } : {},
         ...providerRecoveryCount !== void 0 ? { providerRecoveryCount } : {},
         detail: {
-          code: providerFailureCode ?? recoveredClaimCode,
-          retryable: true,
+          code: setupOutcomeUnknown ? "sandbox_command_start_outcome_unknown" : setupRecoveryExhausted ? "sandbox_command_start_recovery_exhausted" : providerFailureCode ?? recoveredClaimCode,
+          retryable: !setupOutcomeUnknown && !setupRecoveryExhausted,
+          ...setupOutcomeUnknown ? { setupOutcome: "unknown", replay: "blocked" } : {},
+          ...setupRecoveryExhausted ? {
+            setupOutcome: "not_started",
+            replay: "blocked",
+            recoveryExhausted: true,
+            providerRecoveryCount: SANDBOX_SETUP_RECOVERY_LIMIT
+          } : {},
           ...providerRecoveryCount !== void 0 ? {
             databaseFailureCode: recoveredClaimCode,
             providerRecoveryCount
@@ -7019,6 +8392,54 @@ function createSessionStateActivities(services, overrides = {}) {
     }
     return { action: result.action };
   }
+  async function reconcileSettledSessionAttemptActivity(input) {
+    const { db, bus, inspectSessionAttemptActivity, settings, observability, wakeSessionWorkflow } = await services();
+    const ref = await getSessionAttemptActivityRefFn(db, {
+      ...input,
+      temporalWorkflowId: input.workflowId
+    });
+    if (!ref || ref.workflowRunId !== input.workflowRunId || ref.activityId !== input.activityId)
+      return { action: "stale" };
+    if (!inspectSessionAttemptActivity) return { action: "pending" };
+    try {
+      if (await inspectSessionAttemptActivity(ref) !== "settled") return { action: "pending" };
+    } catch (error) {
+      if (error instanceof CancelledFailure) throw error;
+      if (currentActivityContext()?.cancellationSignal.aborted)
+        throw new CancelledFailure("Settled-owner reconciliation cancelled");
+      return { action: "pending" };
+    }
+    if (currentActivityContext()?.cancellationSignal.aborted)
+      throw new CancelledFailure("Settled-owner reconciliation cancelled");
+    const result = await reconcileSettledSessionAttemptFn(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId: input.turnId,
+      attemptId: input.attemptId,
+      executionGeneration: input.executionGeneration,
+      temporalWorkflowId: ref.workflowId,
+      temporalWorkflowRunId: ref.workflowRunId,
+      temporalActivityId: ref.activityId,
+      activitySettled: true,
+      maxRedispatches: WORKER_DEATH_MAX_REDISPATCHES
+    });
+    if (result.events.length > 0)
+      await publishDurableSessionEventsFn(
+        bus,
+        input.workspaceId,
+        input.sessionId,
+        result.events
+      ).catch(() => void 0);
+    if (result.action === "exceeded")
+      await deliverFailedChildTurnToParentFn(
+        { db, bus, settings, observability, wakeSessionWorkflow },
+        input.workspaceId,
+        input.sessionId,
+        result.turnId
+      );
+    return { action: result.action };
+  }
   async function recoverDispatch(input) {
     const { settings, db, bus, observability, wakeSessionWorkflow } = await services();
     const result = await recoverSessionDispatchFn(db, input.workspaceId, {
@@ -7091,8 +8512,68 @@ 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, bus, observability, inspectSessionAttemptActivity } = await services();
+    const observerAccountId = input.observerAccountId ?? (await getWorkspaceFn(db, input.workspaceId))?.accountId;
+    if (!observerAccountId) return { kind: "unavailable" };
+    let peek = await peekSessionWorkFn(
+      db,
+      input.workspaceId,
+      input.sessionId,
+      input.includeAdmissionFence,
+      observerAccountId
+    );
+    if (peek.kind === "unavailable") return peek;
+    if (peek.kind === "admission-blocked" && peek.reason === "sandbox_setup_outcome_unknown") {
+      const ref = peek.ref;
+      if (ref && "turnId" in ref && "attemptId" in ref) {
+        const settled = await reconcileCompletedSandboxSetupFn(db, {
+          accountId: observerAccountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: ref.turnId,
+          attemptId: ref.attemptId
+        });
+        if (settled.events.length > 0)
+          await publishDurableSessionEventsFn(
+            bus,
+            input.workspaceId,
+            input.sessionId,
+            settled.events
+          );
+        if (settled.reconciled)
+          peek = await peekSessionWorkFn(
+            db,
+            input.workspaceId,
+            input.sessionId,
+            input.includeAdmissionFence,
+            observerAccountId
+          );
+      }
+    }
+    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,
+        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;
   }
@@ -7123,6 +8604,14 @@ function createSessionStateActivities(services, overrides = {}) {
     }
     return { action: result.action };
   }
+  async function expireScheduledRunHumanWait(input) {
+    const { db, bus } = await services();
+    const result = await expireScheduledRunHumanWaitFn(db, input);
+    if (result.events.length > 0) {
+      await publishDurableSessionEventsFn(bus, input.workspaceId, input.sessionId, result.events);
+    }
+    return { action: result.action };
+  }
   async function markSessionIdle(input) {
     const { db, bus, settings, observability, wakeSessionWorkflow } = await services();
     const settled = await settleSessionIdleWithParentOutboxFn(
@@ -7149,12 +8638,14 @@ function createSessionStateActivities(services, overrides = {}) {
     settleSessionInterruptions,
     persistSessionAttemptQuiescence,
     reconcileSessionAttemptQuiescence: reconcileSessionAttemptQuiescenceActivity,
+    reconcileSettledSessionAttempt: reconcileSettledSessionAttemptActivity,
     recoverDispatch,
     recoverEscapedMcpTimeout,
     peekSessionWork,
     settleSessionInputWait,
     expireSessionHumanInput,
     expireSessionInteractionIntervention,
+    expireScheduledRunHumanWait,
     markSessionIdle
   };
 }
@@ -7173,6 +8664,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 +8750,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;
     }
   };
@@ -7298,7 +8774,9 @@ function createControlActivitiesFromServices(services, resolveDocumentServices)
     ...createCodexCapacityActivities(services),
     ...createRigVerificationActivities(services),
     ...createBrowserStateArtifactMaintenanceActivities(services),
+    ...createBrowserDeadlineCheckpointActivities(services),
     ...createFileUploadReaperActivities(services),
+    ...createModelCallFactReconcilerActivities(services),
     ...createRetainedScreenshotMaintenanceActivities(services),
     ...createWorkflowWakeActivities(services),
     ...createSandboxLeaseActivities(services)
@@ -7319,4 +8797,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-HMFGSKC5.js.map
+//# sourceMappingURL=activities-control-BNPTRTOE.js.map