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

package/dist/{activities-control-MHNA3CYV.js → activities-control-4F2A734B.js}

@@ -8,6 +8,7 @@ import {
 import {
   INCIDENT_TELEMETRY_AUTHORITY_FENCE_LINEAGE_KEY,
   MAX_AUTOMATIC_PROVIDER_RECOVERIES,
+  agentRunAdmissionDenial,
   assertReusableSessionRevivable,
   captureConnectedCommandOutput,
   createCodexCapacityActivities,
@@ -33,10 +34,12 @@ import {
   warnDrainSnapshotFailure,
   withFirstPartyTools,
   workflowIdForSession
-} from "./chunk-RZAAGRFQ.js";
+} from "./chunk-4PJTUBWQ.js";
 import {
   inspectOpenSandboxKubernetesInventory,
+  recordActiveUserGauges,
   recordCreditBalanceGauges,
+  recordCreditGrantGauges,
   recordCreditMicros,
   recordExpiredDrainingSandboxLeaseGauges,
   recordOpenSandboxKubernetesInventoryGauges,
@@ -57,7 +60,7 @@ import {
   recordVerifiedSignupTrialSwitchGauge,
   recordWorkerDeathRecoveryMetrics,
   runtimeMetricsHooksForObservability
-} from "./chunk-IJZU752L.js";
+} from "./chunk-YG27NEMX.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/activities/knowledge-indexing.ts
@@ -67,8 +70,10 @@ import {
   applyCreditDebitAfterUse,
   appendKnowledgeIndexChunks,
   claimKnowledgeIndexJobs,
+  checkWorkspaceAllowance,
   completeKnowledgeIndexJob,
   continueKnowledgeIndexJob,
+  creditDebitAttributionMetadata,
   deferKnowledgeIndexJob,
   freezeKnowledgeIndexBillingMode,
   getBillingBalance,
@@ -213,6 +218,14 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                 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) {
@@ -221,6 +234,18 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                   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;
                 if (limit) {
@@ -319,6 +344,7 @@ function createKnowledgeIndexingActivities(services, resolveDocumentServices) {
                     sourceId: claim.revisionId,
                     idempotencyKey: `knowledge.embedding:${claim.revisionId}:${claim.generation}:${current.nextIndex}`,
                     metadata: {
+                      ...creditDebitAttributionMetadata(claim.billingAttribution),
                       model: claim.model,
                       bytes,
                       chunks: chunks.length,
@@ -444,6 +470,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,
@@ -451,88 +711,31 @@ import {
   WORKSPACE_OPENROUTER_MODEL_ID_PREFIX
 } from "@opengeni/config";
 import {
+  agentConfigMayResolve,
+  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;
@@ -577,6 +780,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,
@@ -629,7 +843,42 @@ function createAutomationActivities(services, options = {}) {
             reason: "interactive_compute_not_allowed"
           };
         }
-        const turnExecutionPolicy = resolveTurnExecutionPolicyV1(catalogSettings, {
+        let agentWriteThrough;
+        try {
+          const workspaceSettings = agentConfigMayResolve(catalogSettings, template.agent) ? (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",
@@ -638,6 +887,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,
@@ -661,10 +914,11 @@ function createAutomationActivities(services, options = {}) {
           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,
@@ -683,10 +937,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
@@ -1069,7 +1324,7 @@ import {
   markSandboxCheckpointArtifactDeletePending,
   recordWarmingSandboxCreated,
   registerSandboxCheckpointArtifact,
-  releaseLeaseHolder,
+  releaseLeaseHolder as releaseLeaseHolder2,
   touchLeaseHolder,
   updateRigChangeStatus,
   SandboxCheckpointArtifactRegistrationConflictError
@@ -1217,7 +1472,7 @@ function createRigVerificationActivityLifecycle(context = currentActivityContext
       Math.max(1, startToCloseTimeoutMs - reserveMs)
     );
   }
-  const heartbeat = () => {
+  const heartbeat2 = () => {
     if (!context) return;
     try {
       context.heartbeat({
@@ -1230,13 +1485,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();
   }
@@ -1321,7 +1576,7 @@ var defaultOwnershipDependencies = {
   recordCreated: recordWarmingSandboxCreated,
   commitWarm: commitWarmingToWarm,
   touchHolder: touchLeaseHolder,
-  releaseHolder: releaseLeaseHolder,
+  releaseHolder: releaseLeaseHolder2,
   failWarming: failWarmingToCold,
   markWarmLost: markWarmLeaseInstanceLost,
   serialize: serializeEstablishedSandboxEnvelope,
@@ -2418,7 +2673,7 @@ function retainedProcessDeadlineRetryMs(process, lease, settings, retryAfterMs,
 // src/activities/sandbox-lease.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 import { requestRetainedProcessDeadlineCancellation } from "@opengeni/db/retained-provider-commands";
-import { Context } from "@temporalio/activity";
+import { Context as Context2 } from "@temporalio/activity";
 import { OpLostReason, OpState } from "@opengeni/agent-proto";
 import {
   accrueWarmSeconds,
@@ -2439,6 +2694,8 @@ import {
   deferRetainedProcessReconciliation,
   forceDrainOverLimitViewerOnlyBoxes,
   listCreditBalancesByAccount,
+  countActiveUsers,
+  readCreditGrantTotals,
   readVerifiedSignupTrialSwitch,
   listLegacyModalCheckpointSlots,
   listLiveModalSandboxLeaseAttributions,
@@ -2454,7 +2711,7 @@ import {
   registerSandboxCheckpointArtifact as registerSandboxCheckpointArtifact2,
   recordRetainedProcessReconciliationProof,
   replaceWorkspaceArchiveCaptureAfterProof,
-  readLease,
+  readLease as readLease2,
   readWorkspaceArchiveCapturePreflight,
   reapExpiredSessionListSnapshots,
   reapStaleLeaseHoldersGlobal,
@@ -2482,9 +2739,9 @@ import {
   disposeWorkspaceArchive,
   cancelSelfhostedOp,
   assertConsistentSandboxProviderIdentity,
-  createSandboxClientForBackend,
+  createSandboxClientForBackend as createSandboxClientForBackend2,
   deleteModalCheckpointSnapshot as deleteModalCheckpointSnapshot2,
-  deserializeSandboxSessionStateEnvelope,
+  deserializeSandboxSessionStateEnvelope as deserializeSandboxSessionStateEnvelope2,
   establishSandboxSessionFromEnvelope as establishSandboxSessionFromEnvelope2,
   inspectModalSandboxLifecycle,
   isExecSessionLostBanner,
@@ -2503,7 +2760,7 @@ import {
   findModalProviderCreateReceipt,
   resolveModalCheckpointProviderBindingForSession,
   querySelfhostedOp,
-  resumeExactSandboxSession,
+  resumeExactSandboxSession as resumeExactSandboxSession2,
   sandboxProviderContinuityForState,
   sandboxBackendForSdkBackendId,
   sandboxProviderInstanceIdFromEnvelope,
@@ -2562,18 +2819,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);
 }
@@ -2596,7 +2853,7 @@ 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;
@@ -2611,7 +2868,7 @@ function createSandboxLeaseActivities(services, options = {}) {
     lease,
     observability,
     persistArchive,
-    createSandboxClientForBackend,
+    createSandboxClientForBackend2,
     terminateModalSandboxById,
     providerCaptureRequestId,
     captureDisposition,
@@ -2729,7 +2986,7 @@ function createSandboxLeaseActivities(services, options = {}) {
         );
         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,
@@ -3441,7 +3698,7 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
         }
       }
       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;
@@ -3650,7 +3907,7 @@ async function reconcileTerminalRetainedProcesses(db, settings, observability, p
 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 readLease(db, process.workspaceId, process.sandboxGroupId) : null;
+    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,
@@ -3799,7 +4056,7 @@ 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" };
   }
@@ -3809,7 +4066,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   const envelopeSessionState = lease.resumeState.sessionState ?? lease.resumeState;
   let resumedState;
   try {
-    resumedState = await deserializeSandboxSessionStateEnvelope(
+    resumedState = await deserializeSandboxSessionStateEnvelope2(
       client,
       envelopeSessionState,
       process.providerInstanceId
@@ -3823,7 +4080,7 @@ async function probeRetainedProcessAtProvider(settings, lease, process, mode = "
   let session;
   try {
     const resumed = await withRetainedProcessProbeTimeout(
-      resumeExactSandboxSession(
+      resumeExactSandboxSession2(
         client,
         process.providerBackend,
         resumedState,
@@ -4133,6 +4390,24 @@ async function refreshQueueLeaseAndCreditGauges(db, settings, observability, ins
         });
       }
     })(),
+    (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,
@@ -4335,7 +4610,7 @@ function sandboxDrainReason(lease) {
 }
 async function terminateDrainableBox(db, settings, row, observability, terminateBox, probeDrainableProvider, attempt, objectStorage) {
   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;
   }
@@ -4699,7 +4974,7 @@ 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, workspaceId, beforeProviderStop) {
+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);
@@ -4801,7 +5076,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
@@ -4810,7 +5085,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,
@@ -4970,9 +5245,11 @@ import {
   SessionAgentAccess,
   SessionMemoryScope,
   normalizeAutomaticSessionTitle,
+  metadataWithTurnExecutionPolicyV1,
   scheduledOccurrencePayloadUtf8Bytes,
   stableJson,
-  TurnExecutionPolicyV1
+  TurnExecutionPolicyV1,
+  AgentConfigError
 } from "@opengeni/contracts";
 import {
   openGeniSlackBotMetadata,
@@ -4990,7 +5267,12 @@ import {
   scheduledConnectionTools,
   settingsWithEnabledCapabilityMcpServers,
   settingsWithSessionMcpServerMetadata,
-  swapActiveSandbox
+  swapActiveSandbox,
+  agentConfigMayResolve as agentConfigMayResolve2,
+  applySessionAgentConfigWriteThrough as applySessionAgentConfigWriteThrough2,
+  resolveSessionAgentConfigForCreate as resolveSessionAgentConfigForCreate2,
+  recordSessionCreated,
+  recordUserMessageAccepted
 } from "@opengeni/core";
 import {
   addSessionSystemUpdateWithSourceMutation,
@@ -5017,6 +5299,7 @@ import {
   getNestedAgentDepthDeploymentPolicy,
   getSessionByCreateIdempotencyKey,
   getSessionCreationExecutionPolicy,
+  metadataWithAgentConfigCreateIdentity,
   getVariableSet,
   isCodexBilledModel,
   initializeSessionStartAtomically,
@@ -5027,7 +5310,7 @@ import {
   recordUsageEvent as recordUsageEvent2,
   requireScheduledTaskIncidentAuthorityInTransaction,
   requireSession,
-  requireWorkspace,
+  requireWorkspace as requireWorkspace2,
   settleScheduledTaskRunInTransaction,
   SessionSpawnDeniedDbError,
   updateSessionTitleWithEvent,
@@ -5040,7 +5323,7 @@ import {
   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
@@ -5156,13 +5439,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"
@@ -5181,6 +5472,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";
 }
@@ -5255,6 +5553,7 @@ function createScheduledTaskActivities(services) {
           try {
             return await recoverBoundScheduledTaskDispatch({
               db,
+              observability: baseService.observability,
               bus,
               settings: settings2,
               wakeSessionWorkflow,
@@ -5377,13 +5676,46 @@ function createScheduledTaskActivities(services) {
       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 = withScheduledSlackBotPostingTools(
+      let firstPartyMcpTools = withScheduledSlackBotPostingTools(
         creatorPolicy?.firstPartyMcpTools ? allowedFirstPartyMcpToolsForSession(settings, creatorPolicy.firstPartyMcpTools) : resolveFirstPartyMcpToolPolicy(settings).default,
         task.agentConfig,
         resolveFirstPartyMcpToolPolicy(settings).allowed
       );
+      let resolvedAgentConfig = null;
+      let resolvedAgentInstructions;
+      try {
+        const agentResolution = resolveSessionAgentConfigForCreate2({
+          settings,
+          creator: "scheduled",
+          request: task.agentConfig.agent,
+          instructions: void 0,
+          workspaceSettings: agentConfigMayResolve2(settings, task.agentConfig.agent) ? (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;
+        const notEnabled = error.cause instanceof AgentConfigError && error.cause.code === "agent_config_not_enabled";
+        return await refuseAdmission(
+          "scheduled_authority_unavailable",
+          notEnabled,
+          `scheduled agent configuration is not admissible: ${error.message}`
+        );
+      }
       const firstPartyMcpPermissions = creatorPolicy?.firstPartyMcpPermissions ? [...creatorPolicy.firstPartyMcpPermissions] : [...DEFAULT_FIRST_PARTY_MCP_PERMISSIONS];
       const connectionSettings = await settingsWithEnabledCapabilityMcpServers(
         db,
@@ -5488,7 +5820,7 @@ function createScheduledTaskActivities(services) {
         );
       }
       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;
@@ -5699,7 +6031,8 @@ 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) {
@@ -5722,15 +6055,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();
@@ -5752,6 +6089,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,
@@ -5928,6 +6269,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",
@@ -5935,6 +6278,10 @@ function createScheduledTaskActivities(services) {
                 } : {},
                 metadata: {
                   ...taskMetadata,
+                  ...scheduledSessionExecutionPolicyMetadata(
+                    turnExecutionPolicy,
+                    creatorPolicy?.credentialRestriction
+                  ),
                   model,
                   reasoningEffort,
                   scheduledTaskId: task.id,
@@ -6024,6 +6371,7 @@ function createScheduledTaskActivities(services) {
               }
               session = created.session;
               sessionCreated = created.created;
+              if (sessionCreated) recordScheduledSessionCreated(baseService.observability);
               if (!sessionCreated) {
                 await bindScheduledTaskRunSessionInTransaction(dispatchDb, {
                   accountId: task.accountId,
@@ -6259,6 +6607,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({
@@ -6383,6 +6734,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({
@@ -6724,6 +7078,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(
@@ -6783,11 +7138,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,
@@ -6797,6 +7147,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",
@@ -6804,6 +7156,10 @@ async function recoverBoundScheduledTaskDispatch(input) {
       } : {},
       metadata: {
         ...taskMetadata,
+        ...scheduledSessionExecutionPolicyMetadata(
+          input.acceptedExecution.turnExecutionPolicy,
+          recoveredCreatorPolicy?.credentialRestriction
+        ),
         model: input.acceptedExecution.resolvedModel,
         reasoningEffort: input.acceptedExecution.resolvedReasoningEffort,
         scheduledTaskId: task.id,
@@ -6856,6 +7212,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,
@@ -6919,21 +7276,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"
@@ -7072,6 +7436,9 @@ 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(
       input.bus,
@@ -7327,6 +7694,7 @@ async function dispatchMaintenanceSession(service, maintenance, dependencies) {
     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 },
@@ -7998,6 +8366,7 @@ function createControlActivitiesFromServices(services, resolveDocumentServices)
     ...createCodexCapacityActivities(services),
     ...createRigVerificationActivities(services),
     ...createBrowserStateArtifactMaintenanceActivities(services),
+    ...createBrowserDeadlineCheckpointActivities(services),
     ...createFileUploadReaperActivities(services),
     ...createRetainedScreenshotMaintenanceActivities(services),
     ...createWorkflowWakeActivities(services),
@@ -8019,4 +8388,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-MHNA3CYV.js.map
+//# sourceMappingURL=activities-control-4F2A734B.js.map