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

package/dist/{chunk-CYITU5UH.js → chunk-LJX7Z2KP.js}

@@ -1,10 +1,19 @@
 import {
-  observabilityEventLogger
-} from "./chunk-A4XQWVZK.js";
+  observabilityEventBusOptions
+} from "./chunk-3ZTRWDMN.js";
 
 // src/activity-services.ts
-import { dbSearchPath, getSettings, resolveNatsControlPlaneAuth } from "@opengeni/config";
-import { configureChildLifecycleNotices, createDb } from "@opengeni/db";
+import {
+  codeSearchDeploymentPolicy,
+  dbSearchPath,
+  getSettings,
+  resolveNatsControlPlaneAuth
+} from "@opengeni/config";
+import {
+  configureChildLifecycleNotices,
+  configureCodeSearchDeploymentPolicy,
+  createDb
+} from "@opengeni/db";
 import { createNatsEventBus } from "@opengeni/events";
 import { createObservability } from "@opengeni/observability";
 import { resolveCatalogSettings } from "@opengeni/core";
@@ -220,7 +229,7 @@ function exactPersonalGitHubDelegation(delegations, credentialBindingId) {
     (delegation2) => delegation2.serverId === PERSONAL_GITHUB_SERVER_ID && delegation2.connectionType === "github_personal" && delegation2.personalGitHubRepositorySelection?.credentialBindingId === credentialBindingId
   );
   const delegation = matches[0];
-  if (matches.length !== 1 || !delegation || delegation.providerDomain !== "github.com" || delegation.kind !== "oauth2" || !delegation.originWorkspaceId || !delegation.userDelegation || !delegation.personalGitHubRepositorySelection) {
+  if (matches.length !== 1 || !delegation || delegation.providerDomain !== "github.com" || delegation.kind !== "oauth2" || !delegation.originWorkspaceId || !delegation.personalGitHubRepositorySelection) {
     throw new Error("personal GitHub Git delegation is unavailable");
   }
   return delegation;
@@ -246,7 +255,6 @@ function exactRequestedRepositories(refs, credentialBindingId, snapshots) {
 // src/pr-review-credentials.ts
 import { environmentsEncryptionKeyBytes } from "@opengeni/config";
 import { prReviewRegistrationIdFromCredentialBinding } from "@opengeni/core";
-import { createNativeRemoteMcpCredentialsPort } from "@opengeni/core/remote-mcp-credentials";
 import { decryptVariableSetValue, resolvePrReviewGitCredential } from "@opengeni/db";
 import {
   createGitHubAppInstallationTokenWithExpiry,
@@ -254,7 +262,6 @@ import {
 } from "@opengeni/github";
 function createStandaloneConnectionCredentialsPort(settings, db) {
   return {
-    ...createNativeRemoteMcpCredentialsPort(settings, db),
     gitCredentials: async (request) => await resolveStandaloneGitCredentials(settings, db, request)
   };
 }
@@ -324,7 +331,7 @@ async function resolveStandaloneGitCredentials(settings, db, request) {
       credentialEncrypted: authority.credentialEncrypted
     });
     if (authority.credentialKind === "managed_github_app" && settings.prReviewGithubAppId !== authority.appId) {
-      throw new Error("OpenGeni Lens App identity no longer matches this registration");
+      throw new Error("Opengeni Lens App identity no longer matches this registration");
     }
     const minted = await createGitHubAppInstallationTokenWithSigningSettings(signingSettings, {
       installationId: request.installationId,
@@ -405,6 +412,7 @@ function createSharedActivityServices(dependencies) {
       const db = dependencies.db ?? dbClient.db;
       const resolvedSettings = (await resolveCatalogSettings(db, settings)).settings;
       configureChildLifecycleNotices({ enabled: settings.childLifecycleNoticesEnabled });
+      configureCodeSearchDeploymentPolicy(codeSearchDeploymentPolicy(settings));
       return {
         settings: resolvedSettings,
         catalogSourceSettings: settings,
@@ -412,7 +420,7 @@ function createSharedActivityServices(dependencies) {
         bus: dependencies.bus ?? await createNatsEventBus(
           settings.natsUrl,
           controlPlaneAuth ? { user: controlPlaneAuth.user, pass: controlPlaneAuth.password } : void 0,
-          { logger: observabilityEventLogger(observability) }
+          observabilityEventBusOptions(observability)
         ),
         objectStorage: dependencies.objectStorage ?? createObjectStorage(settings),
         observability,
@@ -437,6 +445,9 @@ import {
   fetchCodexUsageForAccount,
   getCodexCapacityWaitForSession,
   getXaiCapacityWaitForSession,
+  getClaudeCapacityWaitForSession,
+  resolveClaudeWaiterSubject,
+  reconcileClaudeCapacityWait as reconcileClaudeCapacityWaitDb,
   resolveXaiWaiterSubject,
   listCodexAccountStatuses,
   listPendingCodexCapacityWakeTargets,
@@ -571,8 +582,13 @@ async function refreshExhaustedXaiQuota(input) {
 }
 
 // src/activities/codex-rotation.ts
-function codexAccountNeedsLiveCapacityRefresh(account, now) {
-  return (account.primaryUsedPercent ?? 0) >= CODEX_USAGE_EXHAUSTED_PCT || (account.secondaryUsedPercent ?? 0) >= CODEX_USAGE_EXHAUSTED_PCT || account.exhaustedKind === "quota" && account.exhaustedUntil !== null && account.exhaustedUntil > now;
+import { subscriptionAccountShardIndex } from "@opengeni/config";
+import { codexPlanExcludesModel, connectionModelAllowed } from "@opengeni/db";
+function codexAccountServesModel(account, modelId, now) {
+  return connectionModelAllowed(account.allowedModelIds, modelId) && !codexPlanExcludesModel(account, modelId, now);
+}
+function codexAccountNeedsLiveCapacityRefresh(account, _now) {
+  return (account.primaryUsedPercent ?? 0) >= CODEX_USAGE_EXHAUSTED_PCT || (account.secondaryUsedPercent ?? 0) >= CODEX_USAGE_EXHAUSTED_PCT || account.exhaustedKind === "quota" && account.exhaustedUntil !== null;
 }
 function effectiveRotationStrategy(_stored) {
   return "sharded";
@@ -618,21 +634,13 @@ function isCodexCredentialHealthy(acct, now) {
 function isCodexCredentialEligible(acct, now) {
   return acct.allocatorEnabled && isCodexCredentialHealthy(acct, now);
 }
-function fnv1a32(input) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
 function shardCredentialForSession(args) {
   const { sessionId, accounts, now } = args;
   const eligibles = accounts.filter((acct) => isCodexCredentialEligible(acct, now));
   if (eligibles.length === 0) {
     return null;
   }
-  const index = fnv1a32(sessionId) % eligibles.length;
+  const index = subscriptionAccountShardIndex(sessionId, eligibles.length);
   return eligibles[index].id;
 }
 function chooseShardedHome(args) {
@@ -761,7 +769,13 @@ function chooseRotationActive(args) {
   return decide(chosen);
 }
 function selectCodexCredentialLeaseForTurn(args) {
-  const { accounts, activeCredentialId, rotationEnabled, rotationStrategy, existingCredentialId } = args.context;
+  const { activeCredentialId, rotationEnabled, rotationStrategy, existingCredentialId } = args.context;
+  if (args.context.failoverExhausted) {
+    return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
+  }
+  const accounts = args.context.modelId ? args.context.accounts.filter(
+    (account) => codexAccountServesModel(account, args.context.modelId, args.now)
+  ) : args.context.accounts;
   const failedCredentialIds = new Set(args.context.failedCredentialIds ?? []);
   const strategy = effectiveRotationStrategy(rotationStrategy);
   const existing = existingCredentialId ? accounts.find((account) => account.id === existingCredentialId) : void 0;
@@ -787,6 +801,9 @@ function selectCodexCredentialLeaseForTurn(args) {
     if (!pinned) {
       return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
     }
+    if (failedCredentialIds.has(pinned.id)) {
+      return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
+    }
     if (!pinned.allocatorEnabled) {
       return {
         credentialId: null,
@@ -843,6 +860,9 @@ function selectCodexCredentialLeaseForTurn(args) {
     if (!active) {
       return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
     }
+    if (failedCredentialIds.has(active.id)) {
+      return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
+    }
     if (!active.allocatorEnabled) {
       return {
         credentialId: null,
@@ -910,8 +930,13 @@ async function signalPendingCodexCapacityWakeTargets(services, workspaceId) {
   );
   await signalCodexCapacityWakeTargets(services, targets);
 }
-function codexCapacityDecision(context) {
-  const now = /* @__PURE__ */ new Date();
+function codexCapacityDecision(context, now = /* @__PURE__ */ new Date()) {
+  context = {
+    ...context,
+    accounts: context.accounts.filter(
+      (account) => !context.modelId || codexAccountServesModel(account, context.modelId, now)
+    )
+  };
   const selected = selectCodexCredentialLeaseForTurn({
     context,
     sessionId: context.sessionId,
@@ -928,7 +953,9 @@ function codexCapacityDecision(context) {
       credentialId: selected.credentialId,
       diagnostic: {
         connectedCount: context.accounts.length,
-        eligibleCount: context.accounts.filter((account) => isCodexCredentialEligible(account, now)).length
+        eligibleCount: context.accounts.filter(
+          (account) => (account.id === selected.credentialId || !context.failedCredentialIds?.includes(account.id)) && isCodexCredentialEligible(account, now)
+        ).length
       }
     };
   }
@@ -936,7 +963,7 @@ function codexCapacityDecision(context) {
   const capacityAccounts = policyCredentialId ? context.accounts.filter((account) => account.id === policyCredentialId) : context.accounts;
   const authoritativeReset = authoritativeCodexCapacityResetAt(capacityAccounts, now);
   const hasReconcilableQuotaCooldown = capacityAccounts.some(
-    (account) => account.status === "active" && account.allocatorEnabled && account.exhaustedKind === "quota" && account.exhaustedUntil !== null && account.exhaustedUntil > now
+    (account) => account.status === "active" && account.allocatorEnabled && account.exhaustedKind === "quota" && account.exhaustedUntil !== null
   );
   const policyAccount = capacityAccounts[0] ?? null;
   const mutationOnlyStatusBlock = policyAccount != null && (!policyAccount.allocatorEnabled || policyAccount.status !== "active") || authoritativeReset === null && capacityAccounts.length > 0 && capacityAccounts.every(
@@ -946,7 +973,7 @@ function codexCapacityDecision(context) {
   return {
     kind: "unavailable",
     earliestResetAt: authoritativeReset,
-    resetKind: selected.decision.kind === "none" || selected.decision.kind === "allocatorDisabled" || mutationOnlyStatusBlock ? "mutation_only" : authoritativeReset && !hasReconcilableQuotaCooldown ? "authoritative" : "bounded_refresh",
+    resetKind: selected.decision.kind === "none" && !hasReconcilableQuotaCooldown && !authoritativeReset || selected.decision.kind === "allocatorDisabled" || mutationOnlyStatusBlock ? "mutation_only" : authoritativeReset && !hasReconcilableQuotaCooldown ? "authoritative" : "bounded_refresh",
     diagnostic: {
       connectedCount: context.accounts.length,
       allocatorEnabledCount: context.accounts.filter((account) => account.allocatorEnabled).length,
@@ -957,6 +984,16 @@ function codexCapacityDecision(context) {
 }
 async function armAndReconcileCodexCapacityWait(services, input, options = {}) {
   const armed = await armCodexCapacityWait(services.db, input);
+  if (armed.action === "stopped") {
+    options.onArmed?.();
+    await publishDurableSessionEvents(
+      services.bus,
+      input.workspaceId,
+      input.sessionId,
+      armed.events
+    );
+    return armed;
+  }
   if (armed.action !== "waiting") return armed;
   options.onArmed?.();
   await publishDurableSessionEvents(services.bus, input.workspaceId, input.sessionId, armed.events);
@@ -980,15 +1017,22 @@ async function armAndReconcileCodexCapacityWait(services, input, options = {}) {
   );
   return evaluated;
 }
-async function refreshCapacityMetadata(services, workspaceId) {
-  const accounts = await listCodexAccountStatuses(services.db, workspaceId).catch(() => []);
+async function refreshCapacityMetadata(services, workspaceId, turnId) {
+  const accounts = await listCodexAccountStatuses(services.db, workspaceId, turnId).catch(() => []);
   const now = /* @__PURE__ */ new Date();
   const stale = accounts.filter(
     (account) => account.allocatorEnabled && account.status === "active" && (codexAccountNeedsLiveCapacityRefresh(account, now) || account.usageCheckedAt === null)
   );
   await refreshCodexUsageAndRepairCapacityWaiters(
     stale.map(
-      (account) => () => fetchCodexUsageForAccount(services.db, services.settings, workspaceId, account.id)
+      (account) => () => fetchCodexUsageForAccount(
+        services.db,
+        services.settings,
+        workspaceId,
+        account.id,
+        void 0,
+        turnId
+      )
     ),
     () => signalPendingCodexCapacityWakeTargets(services, workspaceId)
   );
@@ -1002,9 +1046,10 @@ function createCodexCapacityActivities(services) {
       input.sessionId
     );
     const xaiWaiter = codexWaiter ? null : await getXaiCapacityWaitForSession(db, input.workspaceId, input.sessionId);
-    const waiter = codexWaiter ?? xaiWaiter;
+    const claudeWaiter = codexWaiter || xaiWaiter ? null : await getClaudeCapacityWaitForSession(db, input.workspaceId, input.sessionId);
+    const waiter = codexWaiter ?? xaiWaiter ?? claudeWaiter;
     return waiter ? {
-      ...xaiWaiter ? { provider: "xai" } : {},
+      ...xaiWaiter ? { provider: "xai" } : claudeWaiter ? { provider: "claude" } : {},
       waiterId: waiter.id,
       generation: waiter.generation,
       // A capacity mutation may have committed while its Temporal signal
@@ -1017,21 +1062,17 @@ function createCodexCapacityActivities(services) {
   }
   async function reconcileCodexCapacityWait(input) {
     const resolved = await services();
-    if (input.provider === "xai") {
-      const current2 = await getXaiCapacityWaitForSession(
-        resolved.db,
-        input.workspaceId,
-        input.sessionId
-      );
+    if (input.provider === "xai" || input.provider === "claude") {
+      const claude = input.provider === "claude";
+      const getWaiter = claude ? getClaudeCapacityWaitForSession : getXaiCapacityWaitForSession;
+      const resolveAuthority = claude ? resolveClaudeWaiterSubject : resolveXaiWaiterSubject;
+      const reconcile = claude ? reconcileClaudeCapacityWaitDb : reconcileXaiCapacityWaitDb;
+      const current2 = await getWaiter(resolved.db, input.workspaceId, input.sessionId);
       if (!current2 || current2.id !== input.waiterId || current2.generation !== input.generation) {
         return { action: "stale" };
       }
-      const authority = await resolveXaiWaiterSubject(
-        resolved.db,
-        input.workspaceId,
-        input.sessionId
-      );
-      if (authority)
+      const authority = await resolveAuthority(resolved.db, input.workspaceId, input.sessionId);
+      if (authority && !claude)
         await refreshExhaustedXaiQuota({
           db: resolved.db,
           settings: resolved.settings,
@@ -1042,7 +1083,7 @@ function createCodexCapacityActivities(services) {
           subjectId: authority.subjectId,
           authoritySnapshot: authority.snapshot
         });
-      const result2 = await reconcileXaiCapacityWaitDb(resolved.db, {
+      const result2 = await reconcile(resolved.db, {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
@@ -1059,7 +1100,7 @@ function createCodexCapacityActivities(services) {
       if (result2.action === "waiting") {
         return {
           action: "waiting",
-          provider: "xai",
+          provider: input.provider,
           waiterId: result2.waiter.id,
           generation: result2.waiter.generation,
           nextCheckAt: result2.waiter.nextCheckAt.toISOString(),
@@ -1078,7 +1119,7 @@ function createCodexCapacityActivities(services) {
     }
     const boundedRefreshAttempted = current.resetKind === "bounded_refresh" && input.cause === "timer" && current.nextCheckAt.getTime() <= Date.now();
     if (boundedRefreshAttempted) {
-      await refreshCapacityMetadata(resolved, input.workspaceId);
+      await refreshCapacityMetadata(resolved, input.workspaceId, current.blockedTurnId);
     }
     const result = await reconcileCodexCapacityWaitDb(
       resolved.db,
@@ -1194,7 +1235,8 @@ function createDocumentActivities(services, resolveDocumentServices) {
 // src/activities/goals.ts
 import {
   allowedFirstPartyMcpToolsForSession,
-  configuredStaticUsageLimits,
+  configuredStaticUsageLimits as configuredStaticUsageLimits2,
+  isModelAvailableForNewSelection,
   policyProviderIdForModel,
   resolveModelProvider,
   resolveTurnExecutionPolicyV1,
@@ -1205,25 +1247,106 @@ import {
 } from "@opengeni/config";
 import {
   evaluateWorkspaceModelPolicy,
-  mergeToolRefs
+  mergeToolRefs,
+  readTurnExecutionPolicyV1 as readTurnExecutionPolicyV12
 } from "@opengeni/contracts";
 import { isCodexBilledModel } from "@opengeni/codex";
 import {
   enqueueSessionWorkflowWakeIfRunnable,
-  getBillingBalance,
-  getLatestStartedSessionTurn,
   getWorkspaceModelPolicy,
   getSessionGoal,
-  isCodexBilledTurn,
+  getSessionTurn,
   materializeGoalContinuation,
-  requireSession,
-  sumUsageQuantity
+  requireSession
 } from "@opengeni/db";
 import {
-  modelFundingForAdmission,
+  modelFundingForAdmission as modelFundingForAdmission2,
   resolveCatalogSettings as resolveCatalogSettings2,
   resolveWorkspaceCatalogSettings
 } from "@opengeni/core";
+
+// src/activities/agent-run-admission.ts
+import { configuredStaticUsageLimits } from "@opengeni/config";
+import { modelFundingForAdmission } from "@opengeni/core";
+import {
+  checkWorkspaceAllowance,
+  getBillingBalance,
+  isCodexBilledTurn,
+  sumUsageQuantity
+} 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 getBillingBalance(services.db, input.accountId);
+      if (balance.balanceMicros <= 0) return "insufficient_credits";
+    }
+  }
+  if (!externallyBilled) {
+    const refusal = await checkWorkspaceAllowance(services.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      subjectId: input.initiatingHumanSubjectId ?? null
+    });
+    if (refusal) return refusal.code;
+  }
+  if (services.settings.usageLimitsMode !== "static" && services.settings.usageLimitsMode !== "managed") {
+    return null;
+  }
+  const limits = configuredStaticUsageLimits(services.settings);
+  if (!externallyBilled && limits.maxMonthlyCostMicrosPerAccount) {
+    const used = await sumUsageQuantity(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 sumUsageQuantity(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/agent-turn/credential-restriction.ts
+import { readTurnExecutionPolicyV1 } from "@opengeni/contracts";
+function turnCredentialRestriction(acceptedPolicy, initialSessionMetadata) {
+  const initialPolicy = readTurnExecutionPolicyV1(initialSessionMetadata);
+  return acceptedPolicy.credentialRestriction === "developer_setup" || initialPolicy.kind === "valid" && initialPolicy.policy.credentialRestriction === "developer_setup" ? "developer_setup" : void 0;
+}
+
+// src/activities/goals.ts
 function createGoalActivities(services) {
   async function enqueueGoalRetryWake(input) {
     const { db } = await services();
@@ -1246,17 +1369,15 @@ function createGoalActivities(services) {
     if (!existingGoal || existingGoal.status !== "active") {
       return { action: "none" };
     }
-    let settings = (await resolveCatalogSettings2(db, catalogSourceSettings)).settings;
     const session = await requireSession(db, input.workspaceId, input.sessionId);
-    const latestStartedTurn = await getLatestStartedSessionTurn(
-      db,
-      input.workspaceId,
-      input.sessionId
-    );
-    const inheritedContinuationModel = latestStartedTurn?.model ?? session.model;
+    if (session.status === "failed" || session.status === "cancelled") {
+      return { action: "none" };
+    }
+    let settings = (await resolveCatalogSettings2(db, catalogSourceSettings)).settings;
+    const inheritedContinuationModel = session.model;
     let continuationModel = inheritedContinuationModel;
-    const continuationReasoningEffort = latestStartedTurn?.reasoningEffort ?? session.reasoningEffort;
-    const continuationLatencyMode = latestStartedTurn?.latencyMode ?? session.latencyMode;
+    const continuationReasoningEffort = session.reasoningEffort;
+    const continuationLatencyMode = session.latencyMode;
     const workspaceModelPolicy = await getWorkspaceModelPolicy(db, input.workspaceId);
     if (inheritedContinuationModel.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) || inheritedContinuationModel.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX) || session.model.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) || session.model.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX)) {
       settings = (await resolveWorkspaceCatalogSettings(db, catalogSourceSettings, {
@@ -1275,25 +1396,7 @@ function createGoalActivities(services) {
     if (!modelPolicyBlocked && session.codexCompactionMode === "remote_v2" && !isCodexBilledModel(continuationModel)) {
       modelPolicyBlocked = `session is locked to Codex remote compaction v2; model "${continuationModel}" is not a Codex subscription model`;
     }
-    const isCodexRun = await isCodexBilledTurn({
-      db,
-      settings,
-      workspaceId: input.workspaceId,
-      model: continuationModel
-    });
-    const fundedWithoutCredits = goalContinuationFundedWithoutCredits(
-      settings,
-      continuationModel,
-      isCodexRun
-    );
-    const budgetBlocked = await goalRunBudgetBlocked(
-      settings,
-      db,
-      input.accountId,
-      input.workspaceId,
-      fundedWithoutCredits
-    );
-    const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
+    const turnExecutionPolicy = modelPolicyBlocked ? void 0 : resolveTurnExecutionPolicyV1(settings, {
       modelId: continuationModel,
       requestedModelId: null,
       modelSource: "continuation",
@@ -1302,6 +1405,14 @@ function createGoalActivities(services) {
       latencyMode: continuationLatencyMode,
       latencyModeSource: "continuation"
     });
+    const continuationPolicy = {
+      model: continuationModel,
+      reasoningEffort: continuationReasoningEffort,
+      latencyMode: continuationLatencyMode,
+      ...turnExecutionPolicy ? { turnExecutionPolicy } : {},
+      tools: withFirstPartyTools(settings, session.tools),
+      sandboxBackend: session.sandboxBackend
+    };
     const decision = await materializeGoalContinuation(db, {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -1317,15 +1428,34 @@ function createGoalActivities(services) {
       // A model-policy block takes precedence: it is deterministic (a budget
       // pause can clear on its own; a policy pause needs a model/policy change)
       // and rides the same visible-pause channel.
-      budgetBlocked: modelPolicyBlocked ?? budgetBlocked,
-      policy: {
-        model: continuationModel,
-        reasoningEffort: continuationReasoningEffort,
-        latencyMode: continuationLatencyMode,
-        turnExecutionPolicy,
-        tools: withFirstPartyTools(settings, session.tools),
-        sandboxBackend: session.sandboxBackend
+      admission: async (tx, causalTurn) => {
+        const sourceTurn = causalTurn ? await getSessionTurn(tx, input.workspaceId, causalTurn.id) : null;
+        if (causalTurn && (!sourceTurn || sourceTurn.sessionId !== input.sessionId)) {
+          throw new Error("Goal continuation source turn is unavailable");
+        }
+        const sourcePolicy = readTurnExecutionPolicyV12(sourceTurn?.metadata);
+        if (turnExecutionPolicy) {
+          const credentialRestriction = turnCredentialRestriction(
+            sourcePolicy.kind === "valid" ? sourcePolicy.policy : turnExecutionPolicy,
+            session.metadata
+          );
+          continuationPolicy.turnExecutionPolicy = credentialRestriction ? { ...turnExecutionPolicy, credentialRestriction } : turnExecutionPolicy;
+        }
+        const budgetBlocked = modelPolicyBlocked ? null : await goalRunBudgetBlocked(
+          { ...service, settings, db: tx },
+          {
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            model: continuationModel,
+            initiatingHumanSubjectId: causalTurn?.initiatingHumanSubjectId ?? null
+          }
+        );
+        return {
+          budgetBlocked: modelPolicyBlocked ?? budgetBlocked?.message ?? null,
+          budgetPausedReason: modelPolicyBlocked ? "limits" : budgetBlocked?.pausedReason ?? "limits"
+        };
       },
+      policy: continuationPolicy,
       // Long-wait guidance is only given when `wait_for_input` is actually in this
       // session's effective first-party selection (the same source the worker
       // signs into the delegated token and the API uses to register tools), so
@@ -1361,46 +1491,52 @@ function goalContinuationModelDecision(input) {
     providerId: policyProviderIdForModel(catalogSettings, modelId),
     modelId
   }).allowed;
-  if (resolveModelProvider(catalogSettings, input.inheritedModel) && !policyBlocks(input.inheritedModel)) {
-    return { model: input.inheritedModel, blocked: null };
-  }
   if (!resolveModelProvider(catalogSettings, input.inheritedModel)) {
     return {
       model: input.inheritedModel,
       blocked: `model "${input.inheritedModel}" is no longer in the deployment or workspace catalog; choose an available model before resuming the goal`
     };
   }
+  if (!isModelAvailableForNewSelection(catalogSettings, input.inheritedModel)) {
+    return {
+      model: input.inheritedModel,
+      blocked: `model "${input.inheritedModel}" is retired from new selection; choose an available model before resuming the goal`
+    };
+  }
+  if (!policyBlocks(input.inheritedModel)) {
+    return { model: input.inheritedModel, blocked: null };
+  }
   return {
     model: input.inheritedModel,
     blocked: `workspace model policy blocks model "${input.inheritedModel}"; pick an allowed model or change the workspace model policy`
   };
 }
-function goalContinuationFundedWithoutCredits(settings, model, codexBilled) {
-  return modelFundingForAdmission(settings, model, codexBilled).fundedWithoutCredits;
-}
 function goalContinuationPrompt(_goal, _autoContinuation, _cap, options = {}) {
   const waitingGuidance = options.inputWaitAvailable ? [
     "Waiting on child sessions, background commands, or external events:",
     "- When further progress depends on work already in flight, do not sleep, loop, or poll session or command state repeatedly.",
-    "- Re-check once; if the work is still in flight and the wait is long or uncertain, call opengeni__wait_for_input with a concrete reason and timeoutSeconds, then end your turn immediately. Relevant session input or the safety deadline will start a new turn, and this goal stays active.",
-    "- If the immediately preceding user-facing update already reported this same unchanged wait, do not restate it or produce another equivalent final answer. Call opengeni__wait_for_input and end the turn. Report only material new state or a newly discovered blocker.",
+    "- If progress depends on work already in flight and the wait is long or uncertain, call opengeni__wait_for_input with a concrete reason and timeoutSeconds, then end your turn immediately. A preliminary status check is not required. Relevant session input or the safety deadline will start a new turn, and this goal stays active.",
+    "- No short execution wait is required first. Choose the safety deadline for the dependency or a meaningful monitoring cadence; an out-of-turn wait may span hours or days within the tool's limits. Do not schedule model wakeups merely to repeat reassurance. Honor explicit user/task/Skill check or update cadences within existing authority.",
+    "- If the immediately preceding user-facing update already reported this same unchanged wait, do not restate it or produce another equivalent final answer. Call opengeni__wait_for_input and end the turn. Report only material new state or a newly discovered blocker, unless an explicit user/task/Skill update cadence calls for an update.",
     "- If you are blocked on a human decision, use opengeni__goal_pause under the blocked audit below instead.",
     ""
   ] : [];
   const childNoticeGuidance = [
     "Child lifecycle notices:",
-    "- A `child_requires_action` update means a worker you spawned is blocked on a question or a tool approval and will not progress until it is answered. " + (options.humanInputRespondAvailable ? "If you know the answer to its question, answer it with opengeni__session_human_input_respond (pass the worker's sessionId, the requestId from the notice, and a response). " : "") + "Tool approvals can only be decided by a human. If you cannot resolve the blocker yourself, report the exact blocker (worker session id, the question) to the user and wait or pause instead of retrying the worker.",
+    "- A `child_requires_action` update means a worker you spawned is blocked on a question or a tool approval and will not progress until it is answered. " + (options.humanInputRespondAvailable ? "If you know the answer to its question, answer it with opengeni__session_human_input_respond (pass the worker's sessionId, the requestId from the notice, and a response). " : "") + "Tool approvals can only be decided by a human. If you cannot resolve the blocker yourself, report the exact blocker (worker session id, the question); if it prevents further goal progress, pause under the blocked audit instead of retrying the worker or treating a human decision as an in-flight wait.",
     "- `child_requires_action_resolved`, `child_paused`, `child_waiting_capacity`, and `child_progress` updates are informational: a resolved notice means the worker is moving again; a paused worker needs a human or you to resume it; a capacity wait resumes by itself; a progress note needs no action.",
     ""
   ];
   return [
-    "Reconcile the active session goal against authoritative current state, then carry the work through to the full requested end state and verify it.",
+    "Automatic goal continuation (generated input, not a new user request or grant of authority). Resume established work toward the full applied objective and verify its requested end state.",
     "",
     "Goal recovery:",
+    "- Use the current applied goal frozen for this turn, including its success criteria, root constraints, and report requirements, as the authoritative objective. Pending proposals and older goal revisions do not replace it; change it only through the authorized goal-mutation controls, without widening authority.",
     "- Treat this continuation as re-entry into the full objective, not as a request to perform one step and stop.",
+    "- Resume from established work and relevant evidence rather than restarting discovery or a full reconciliation on every turn. Perform full reconciliation or a comprehensive audit when the goal, user, or applicable Skill calls for it, when uncertainty or recovery warrants it, or when required by risk or a gate.",
     "- Do not rely on previous assistant claims of progress or completion; use them only to locate authoritative evidence.",
     "- If authoritative evidence already proves the full objective, call opengeni__goal_complete instead of manufacturing more work.",
-    "- Before repeating a state-setting action, verify whether its desired state already holds. If it does, do not repeat it; continue reconciling the overall goal.",
+    "- Before repeating a state-setting action, verify whether its desired state already holds, using relevant evidence that remains valid or a fresh check when needed. If it does, do not repeat it; continue the overall goal.",
     "",
     "Continuation behavior:",
     "- This goal persists across turns. A runtime boundary can end one turn without shrinking the objective; the next continuation resumes the same full objective.",
@@ -1410,7 +1546,7 @@ function goalContinuationPrompt(_goal, _autoContinuation, _cap, options = {}) {
     "- Temporary rough edges are acceptable while the work is moving in the right direction. Completion still requires the requested end state to be true and verified.",
     "",
     "Work from evidence:",
-    "Use the current workspace and external state as authoritative. Conversation context can help locate relevant work, but it is not proof of the current state. Inspect the current state before relying on it. Improve, replace, or remove existing work as needed to satisfy the actual objective.",
+    "Use authoritative workspace and external evidence, including prior tool results that remain relevant and valid. Reuse evidence only for the requirement, scope, version, and state it actually establishes; recheck changed, stale, uncertain, or insufficient evidence. Conversation summaries and assistant claims are pointers, not proof. Do not infer progress or evidence validity merely from this continuation. Improve, replace, or remove existing work as needed within authority to satisfy the actual objective.",
     "",
     "Progress visibility:",
     "If a planning tool is available and the next work is meaningfully multi-step, use it to show a concise plan tied to the real objective. Keep the plan current as steps complete or the next best action changes. Skip planning overhead for trivial one-step progress, and do not treat a plan update as a substitute for doing the work.",
@@ -1421,22 +1557,26 @@ function goalContinuationPrompt(_goal, _autoContinuation, _cap, options = {}) {
     "- Treat alignment as movement toward the requested end state. An edit is aligned only if it makes the requested final state more true; useful-looking behavior that preserves a different end state is misaligned.",
     "",
     "Completion audit:",
-    "Before deciding that the goal is achieved, treat completion as unproven and verify it against the actual current state:",
+    "Before deciding that the goal is achieved, treat completion as unproven and verify it against the actual current state. This full completion audit is required even when ordinary continuation did not need full reconciliation; reuse still-valid authoritative evidence, but refresh it when the requirement or gate requires a fresh check:",
     "- Derive concrete requirements from the objective and any referenced files, plans, specifications, issues, or user instructions.",
-    "- Preserve the original scope; do not redefine success around the work that already exists.",
+    "- Preserve the applied objective's scope; do not redefine success around the work that already exists.",
     "- For every explicit requirement, named artifact, command, test, gate, invariant, and deliverable, identify and inspect the authoritative evidence that would prove it.",
     "- Match verification scope to requirement scope. Treat uncertain, indirect, incomplete, or missing evidence as not achieved and continue working.",
     "- The audit must prove completion, not merely fail to find obvious remaining work.",
+    "- For document report deliverables (a document the user asked for, or a large report meant to be kept or shared), follow the Documents Skill: create the durable native document first, inspect its relevant final head after the last edit, and provide the returned artifact reference. Declare report requirements through the available goal tools before authoring and satisfy every persisted report requirement with verified artifact delivery evidence before completion. Sandbox paths and raw file IDs do not prove report delivery. If artifact tooling or access is unavailable, keep that deliverable incomplete and state the blocker; never invent proof or silently substitute a local report. Ordinary chat answers, short progress updates, source-code links, and explicitly requested local-file work remain outside this report contract.",
     "",
     "Do not rely on intent, partial progress, memory of earlier work, or a plausible final answer as proof of completion. Call opengeni__goal_complete with concrete evidence only when the full objective is actually achieved and no required work remains.",
+    "Goal evidence is a short proof for the ledger, not the deliverable. After goal_complete succeeds, finish this same turn with the requested user-facing answer, or a concise summary and retained artifact link. Goal completion stops future automatic continuations; it does not send the answer or end this turn. Never compress a report into evidence or omit the final reply.",
+    "Goal progress notes are short human-readable milestone statuses, not raw transcripts or continuation instructions. Keep normal spaces and summarize detail instead of squeezing words into a ledger field. The text and successCriteria fields each allow 8192 UTF-8 bytes, progressNote allows 8192 UTF-8 bytes, rationale allows 2048 UTF-8 bytes, and evidence allows 8192 characters.",
     "",
     ...waitingGuidance,
     ...childNoticeGuidance,
     "Blocked audit:",
-    "- Do not call opengeni__goal_pause the first time a blocker appears.",
-    "- Pause only when the same blocking condition has repeated for at least three consecutive goal turns and meaningful progress is impossible without user input or an external-state change.",
+    "- Base persistence on evidence, not a fixed number of turns or retries. Investigate recoverable failures and try plausible safe alternatives within current authority when they could materially advance the goal; do not exhaust every imaginable alternative or repeat an unchanged failure without a reason to expect progress.",
+    "- A definitive missing permission, required human decision, or external prerequisite with no actionable authorized path can justify pausing immediately. State the concrete blocker, relevant evidence or attempted alternatives, and what must change to resume. Tool approvals remain human-only.",
+    "- If progress depends on work already in flight or a meaningful timed recheck, use the available waiting mechanism rather than pausing the goal; continue any independent authorized work first.",
     "- Do not pause merely because the work is hard, slow, uncertain, incomplete, or would benefit from clarification.",
-    "- Once that threshold is satisfied, call opengeni__goal_pause with the concrete blocker instead of repeatedly reporting it while leaving the goal active.",
+    "- When no meaningful authorized progress remains and the blocker requires human input or an external change that cannot be handled by an available wait or monitoring mechanism, call opengeni__goal_pause with the concrete blocker instead of repeatedly reporting it while leaving the goal active.",
     "",
     "Do not call opengeni__goal_complete or opengeni__goal_pause unless the corresponding audit above is satisfied."
   ].join("\n");
@@ -1447,44 +1587,26 @@ function withFirstPartyTools(settings, tools) {
   }
   return mergeToolRefs(tools, [{ kind: "mcp", id: "opengeni" }]);
 }
-async function goalRunBudgetBlocked(settings, db, accountId, workspaceId, fundedWithoutCredits) {
-  if (!fundedWithoutCredits && (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed")) {
-    const balance = await getBillingBalance(db, accountId);
-    if (balance.balanceMicros <= 0) {
-      return "insufficient OpenGeni credits";
-    }
-  }
-  if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
-    const limits = configuredStaticUsageLimits(settings);
-    if (!fundedWithoutCredits && limits.maxMonthlyCostMicrosPerAccount) {
-      const used = await sumUsageQuantity(db, {
-        accountId,
-        eventType: "model.cost",
-        since: startOfUtcMonth()
-      });
-      if (used >= limits.maxMonthlyCostMicrosPerAccount) {
-        return `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`;
-      }
-    }
-    if (limits.maxMonthlyAgentRunsPerWorkspace) {
-      const used = await sumUsageQuantity(db, {
-        workspaceId,
-        eventType: "agent_run.created",
-        since: startOfUtcMonth()
-      });
-      if (used + 1 > limits.maxMonthlyAgentRunsPerWorkspace) {
-        return `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`;
-      }
-    }
-  }
-  return null;
-}
-function startOfUtcMonth() {
-  const now = /* @__PURE__ */ new Date();
-  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+async function goalRunBudgetBlocked(services, input) {
+  const denial = await agentRunAdmissionDenial(services, { ...input, requestedAgentRuns: 1 });
+  if (denial === null) return null;
+  if (denial === "allowance_exhausted") {
+    return { pausedReason: "allowance", message: "Opengeni usage allowance exhausted" };
+  }
+  const limits = configuredStaticUsageLimits2(services.settings);
+  const messages = {
+    insufficient_credits: "insufficient Opengeni credits",
+    monthly_model_cost_limit: `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`,
+    monthly_agent_run_limit: `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`
+  };
+  return { pausedReason: "limits", message: messages[denial] };
 }
 
 // src/activities/knowledge-source-sync.ts
+import {
+  ATLASSIAN_NATIVE_RETIRED_REASON,
+  isRetiredNativeAtlassianSource
+} from "@opengeni/contracts/atlassian-native-retirement";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import { AsyncLocalStorage } from "async_hooks";
 import { scheduledTaskKnowledgeSource } from "@opengeni/contracts";
@@ -2018,6 +2140,12 @@ function createKnowledgeSourceSyncActivities(services, resolveDocumentServices)
       if (!task || !action || !liveTask || liveTask.status !== "active" || task.id !== input.taskId || task.accountId !== input.accountId || task.action.kind !== "agent_turn" || action.sourceId !== input.sourceId || accepted.causalHumanSubjectId !== action.initiatingSubjectId) {
         return { action: "failed", bufferedWake: false };
       }
+      if (isRetiredNativeAtlassianSource(action))
+        return {
+          action: "failed",
+          bufferedWake: false,
+          errorCode: ATLASSIAN_NATIVE_RETIRED_REASON
+        };
       boundSource = action;
       await authorize();
       await ensureKnowledgeSourceSyncState(db, task);
@@ -4583,65 +4711,10 @@ var SyncFailure = class extends Error {
 import {
   resolveRigProviderImageSelection,
   rigProviderImageSourceImage,
-  settingsWithPackSandboxImage,
   settingsWithRigImage,
   settingsWithRigProviderImage
 } from "@opengeni/core";
 
-// src/activities/packs.ts
-import { getWorkspace, listInstalledPortableSkills } from "@opengeni/db";
-import {
-  legacySandboxRuntimeFromPacks,
-  packInstallationUsesLegacyRuntime,
-  resolveWorkspaceLegacyRuntimePacks
-} from "@opengeni/core";
-import {
-  buildPortableSkillArtifact
-} from "@opengeni/runtime";
-var emptyPackRuntime = {
-  sandboxImage: null,
-  sandboxProviderImages: null,
-  skillActivations: []
-};
-async function resolveWorkspacePackRuntime(db, workspaceId) {
-  const packs = await resolveWorkspaceLegacyRuntimePacks(db, workspaceId);
-  if (packs.length === 0) return emptyPackRuntime;
-  return workspacePackRuntimeFromPacks(packs);
-}
-function workspacePackRuntimeFromPacks(packs) {
-  const sandboxRuntime = legacySandboxRuntimeFromPacks(packs);
-  const skillActivations = [];
-  const skillOwners = /* @__PURE__ */ new Map();
-  for (const pack of [...packs].sort((a, b) => a.id.localeCompare(b.id))) {
-    for (const skill of pack.skills) {
-      const key = skill.name.toLowerCase();
-      const existingOwner = skillOwners.get(key);
-      if (existingOwner !== void 0 && existingOwner !== pack.id) {
-        throw new Error(
-          `Enabled packs ${existingOwner} and ${pack.id} both declare a skill named "${skill.name}". Pack skill names must be unique across enabled packs; disable one of the packs and retry.`
-        );
-      }
-      skillOwners.set(key, pack.id);
-      const artifact = {
-        name: skill.name,
-        description: skill.description ?? null,
-        files: skill.files.map((file) => ({ path: file.path, content: file.content }))
-      };
-      skillActivations.push({
-        source: "pack",
-        id: `pack:${pack.id}:${skill.name}`,
-        artifact,
-        reason: `active legacy Pack ${pack.id}`
-      });
-    }
-  }
-  return {
-    sandboxImage: sandboxRuntime.sandboxImage,
-    sandboxProviderImages: sandboxRuntime.sandboxProviderImages,
-    skillActivations
-  };
-}
-
 // src/activities/streaming.ts
 import { TURN_ACTIVITY_CANCELLATION_HEARTBEAT_INTERVAL_MS } from "@opengeni/core";
 import { Context } from "@temporalio/activity";
@@ -4816,6 +4889,85 @@ async function nextStreamEvent(iterator, context) {
   });
 }
 
+// src/sandbox-snapshot-diagnostics.ts
+import { sandboxLeaseTelemetryKey } from "@opengeni/observability";
+function safeSnapshotError(error, origin = "sandbox-resume") {
+  const fields = {
+    errorClass: "SnapshotOperationError",
+    errorCode: "snapshot_operation_failed",
+    origin
+  };
+  try {
+    if (error && typeof error === "object") {
+      const candidate = error;
+      if (typeof candidate.name === "string" && /^[A-Z][A-Za-z0-9]{2,62}Error$/u.test(candidate.name)) {
+        fields.causeName = candidate.name;
+      }
+      if (typeof candidate.code === "string" && /^[a-z0-9_]{1,64}$/u.test(candidate.code)) {
+        fields.integrityCode = candidate.code;
+      }
+      const status = Number(candidate.status ?? candidate.statusCode);
+      if (Number.isInteger(status) && status >= 100 && status <= 599) fields.status = status;
+    }
+  } catch {
+  }
+  const read = (value, key) => {
+    try {
+      return value && typeof value === "object" ? Reflect.get(value, key) : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const details = read(error, "details");
+  const providerName = read(details, "errorName");
+  if (typeof providerName === "string" && [
+    "ClientError",
+    "TimeoutError",
+    "ConnectionError",
+    "AuthError",
+    "NotFoundError",
+    "InvalidError",
+    "RemoteError",
+    "AbortError"
+  ].includes(providerName))
+    fields.providerErrorName = providerName;
+  const grpcCode = read(details, "errorCode");
+  if (providerName === "ClientError" && typeof grpcCode === "number" && Number.isInteger(grpcCode) && grpcCode >= 0 && grpcCode <= 16)
+    fields.providerGrpcCode = grpcCode;
+  for (const key of ["status", "httpStatus", "responseStatus"]) {
+    const status = read(details, key);
+    if (typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599) {
+      fields.providerHttpStatus = status;
+      break;
+    }
+  }
+  const retryable = read(error, "retryable");
+  if (typeof retryable === "boolean") fields.providerRetryable = retryable;
+  return fields;
+}
+function warnDrainSnapshotFailure(observability, message, error, lease) {
+  try {
+    observability.warn(message, {
+      ...safeSnapshotError(error, "worker-lifecycle"),
+      ...lease.workspaceId ? { sandboxLeaseKey: sandboxLeaseTelemetryKey(lease.workspaceId, lease.sandboxGroupId) } : {},
+      leaseEpoch: lease.leaseEpoch
+    });
+  } catch {
+  }
+}
+
+// src/session-event-fanout.ts
+async function publishDurableSessionEvents2(bus, workspaceId, events, onError = () => void 0) {
+  if (!bus || !events?.length) return;
+  for (const sessionId of new Set(events.map((event) => event.sessionId))) {
+    await bus.publish(
+      workspaceId,
+      sessionId,
+      events.filter((event) => event.sessionId === sessionId)
+    ).catch(onError);
+  }
+}
+
 // src/sandbox-archive-storage.ts
 import { uploadWorkspaceArchiveSpool } from "@opengeni/storage";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -4949,15 +5101,17 @@ async function deleteUnpublishedWorkspaceArchiveObject(objectStorage, ref, metri
 }
 
 // src/sandbox-routing.ts
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 import { sandboxLifecycleTransitionWaitMs as sandboxLifecycleTransitionWaitMs2 } from "@opengeni/config";
 import {
   createProviderCommandRetainer,
-  retainedProviderCommandPersistence
+  supervisedCommandProtocolReady
 } from "@opengeni/db/retained-provider-commands";
 import {
   adoptConnectedMachineSessionBackgroundCommand,
   adoptManagedSessionBackgroundCommand,
   advanceWorkspaceGenerationForRetainedProcess,
+  retainedProviderCommandPersistence,
   advanceWorkspaceGeneration,
   getRetainedProcess,
   retainWorkspaceMutationProcess,
@@ -4974,7 +5128,10 @@ import {
   resolvePersonalMachineConnectionForAttempt,
   SandboxRetainedProcessPromotionFencedError
 } from "@opengeni/db";
-import { observeSessionBackgroundCommandCompletion } from "@opengeni/db/session-background-commands";
+import {
+  observeSessionBackgroundCommandCompletion,
+  recordConnectedCommandOutputConsumption
+} from "@opengeni/db/session-background-commands";
 import { appendSessionCommandOutput } from "@opengeni/db/session-command-output";
 import {
   buildSelfhostedBackendSession,
@@ -4999,17 +5156,29 @@ import {
 import {
   effectiveSandboxLifecycle,
   sandboxArchiveCaptureTimeoutMs,
-  sandboxLifecycleTransitionWaitMs
+  sandboxLifecycleTransitionWaitMs,
+  sandboxWarmRateMicrosPerSecond
 } from "@opengeni/config";
 import { randomUUID as randomUUID3 } from "crypto";
+
+// src/warm-capture-holder.ts
+function retainsHolderForWarmCapture(lease, expectedEpoch, now = Date.now()) {
+  return Boolean(
+    lease?.liveness === "warm" && lease.leaseEpoch === expectedEpoch && lease.archiveCapture && lease.archiveCapture.deadlineAt.getTime() > now
+  );
+}
+
+// src/sandbox-resume.ts
 import {
   acquireLease,
   adoptLegacyModalCheckpointArtifact,
   beginSandboxRematerialization,
+  sessionHoldsFreshWorkspaceRecovery,
   claimWorkspaceArchiveCapture,
   commitWarmingToWarm,
   failSandboxRematerialization,
   failWarmingToCold,
+  beginModalProviderCreate,
   getSandboxSessionEnvelope,
   heartbeatLeaseHolderStatus,
   markSandboxRestoreVerifying,
@@ -5054,6 +5223,7 @@ import {
   downloadWorkspaceArchiveSpool,
   WorkspaceArchiveStorageError
 } from "@opengeni/storage";
+import { sandboxLeaseTelemetryKey as sandboxLeaseTelemetryKey2 } from "@opengeni/observability";
 import { parseWorkspaceArchiveObjectRef as parseWorkspaceArchiveObjectRef2 } from "@opengeni/contracts";
 function sandboxLeaseHolderIdForAttempt(attemptId) {
   const normalized = attemptId.trim();
@@ -5130,6 +5300,42 @@ var SandboxSiblingWarmingTimeoutError = class extends SandboxWarmingTimeoutError
     this.name = "SandboxSiblingWarmingTimeoutError";
   }
 };
+var disposedUnreadyFreshSandboxErrors = /* @__PURE__ */ new WeakSet();
+function isReplaceableFreshSandboxReadinessTimeout(error) {
+  return error instanceof SandboxExecReadinessTimeoutError && disposedUnreadyFreshSandboxErrors.has(error);
+}
+var FRESH_SANDBOX_READINESS_REPLACEMENT_BASE_DELAY_MS = 2e3;
+var FRESH_SANDBOX_READINESS_REPLACEMENT_JITTER_MS = 8e3;
+function freshSandboxReadinessReplacementDelayMs(random = Math.random) {
+  const sample = random();
+  const unit = Number.isFinite(sample) ? Math.min(Math.max(sample, 0), 1 - Number.EPSILON) : 0;
+  return FRESH_SANDBOX_READINESS_REPLACEMENT_BASE_DELAY_MS + Math.floor(unit * FRESH_SANDBOX_READINESS_REPLACEMENT_JITTER_MS);
+}
+var FRESH_SANDBOX_READINESS_REPLACEMENTS_PER_TURN_ATTEMPT = 1;
+function createFreshSandboxReadinessReplacementBudget() {
+  return { remaining: FRESH_SANDBOX_READINESS_REPLACEMENTS_PER_TURN_ATTEMPT };
+}
+function recordFreshSandboxReadinessReplacement(metrics, backend, outcome) {
+  try {
+    metrics?.onSandboxReadinessReplacement?.({ backend, outcome });
+  } catch {
+  }
+}
+async function sleepUnlessCancelled(ms, signal) {
+  if (signal?.aborted) return false;
+  if (ms <= 0) return true;
+  return await new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve(false);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 var SandboxLeaseInstanceLostError = class extends SandboxLeaseSupersededError {
   constructor(sandboxGroupId, leaseEpoch, lostInstanceId) {
     super(sandboxGroupId, leaseEpoch);
@@ -5141,9 +5347,9 @@ var WARMING_POLL_INTERVAL_MS = 250;
 async function sleep(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function waitForSandboxExecReadiness(established, timeoutMs = MODAL_EXEC_READINESS_TIMEOUT_MS, identity = {}) {
+async function waitForSandboxExecReadiness(established, timeoutMs = MODAL_EXEC_READINESS_TIMEOUT_MS, identity = {}, signal) {
   try {
-    await verifySandboxExecReadiness(established, timeoutMs);
+    await verifySandboxExecReadiness(established, timeoutMs, signal);
   } catch (error) {
     if (error instanceof SandboxExecReadinessError && error.code === "exec_probe_timeout") {
       throw new SandboxExecReadinessTimeoutError(established.backendId, timeoutMs, {
@@ -5160,29 +5366,6 @@ var SnapshotTimeoutError = class extends Error {
     this.name = "SnapshotTimeoutError";
   }
 };
-function safeSnapshotError(error) {
-  const fields = {
-    errorClass: "SnapshotOperationError",
-    errorCode: "snapshot_operation_failed",
-    origin: "sandbox-resume"
-  };
-  try {
-    if (error && typeof error === "object") {
-      const candidate = error;
-      if (typeof candidate.name === "string" && /^[A-Z][A-Za-z0-9]{2,62}Error$/u.test(candidate.name)) {
-        fields.causeName = candidate.name;
-      }
-      if (typeof candidate.code === "string" && /^[a-z0-9_]{1,64}$/u.test(candidate.code)) {
-        fields.integrityCode = candidate.code;
-      }
-      const rawStatus = candidate.status ?? candidate.statusCode;
-      const status = Number(rawStatus);
-      if (Number.isInteger(status) && status >= 100 && status <= 599) fields.status = status;
-    }
-  } catch {
-  }
-  return fields;
-}
 async function waitForWarmSnapshot(snapshot, timeoutMs, signal) {
   if (signal?.aborted) return false;
   let timeout;
@@ -5305,8 +5488,9 @@ async function materializeSpawnEnvelopeArchive(envelope, objectStorage) {
   }
   if (!objectStorage) {
     throw new WorkspaceArchiveIntegrityError(
-      "archive_base64_invalid",
-      "workspace archive object storage is not configured"
+      "archive_storage_unavailable",
+      "workspace archive object storage is not configured",
+      { retryable: true }
     );
   }
   const descriptor = parseWorkspaceArchiveDescriptor(sessionState.workspaceArchiveMeta);
@@ -5361,6 +5545,18 @@ function maybePersistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch, s
 }
 async function persistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch, signal, force, registerOwnedContinuation) {
   const { db, settings } = services;
+  const warnSnapshotFailure = (message, error) => {
+    const fields = {
+      ...safeSnapshotError(error),
+      sandboxLeaseKey: sandboxLeaseTelemetryKey2(ids.workspaceId, ids.sandboxGroupId),
+      leaseEpoch
+    };
+    try {
+      if (services.observability) services.observability.warn(message, fields);
+      else console.warn(message, fields);
+    } catch {
+    }
+  };
   const intervalMs = settings.sandboxSnapshotIntervalMs;
   if (intervalMs <= 0 && !force) {
     return false;
@@ -5434,6 +5630,7 @@ async function persistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch,
       } : {}
     });
     if (claimed.status !== "claimed") {
+      if (claimed.status === "throttled") return false;
       console.error("mid-session workspace snapshot skipped (capture claim)", {
         sandboxGroupId: ids.sandboxGroupId,
         status: claimed.status
@@ -5472,6 +5669,8 @@ async function persistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch,
       }).catch(() => void 0);
     };
     const captureAndPublish = (async () => {
+      const captureStarted = performance.now();
+      let captureOutcome = "failed";
       let archive;
       let candidate = null;
       let publicationAttempted = false;
@@ -5521,6 +5720,7 @@ async function persistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch,
         if (!wrote && candidate) {
           await abandonCandidate(candidate.id, "snapshot_publication_fenced");
         }
+        if (wrote) captureOutcome = "completed";
         return wrote;
       } catch (error) {
         if (candidate && !publicationAttempted)
@@ -5538,20 +5738,23 @@ async function persistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch,
           expectedEpoch: leaseEpoch,
           expectedInstanceId: instanceId
         }).catch((error) => {
-          console.error(
-            "mid-session workspace capture gate release failed",
-            safeSnapshotError(error)
-          );
+          captureOutcome = "failed";
+          warnSnapshotFailure("mid-session workspace capture gate release failed", error);
         });
+        try {
+          services.sandboxMetrics?.onWorkspaceCapture?.({
+            backend: lease.backend,
+            outcome: captureOutcome,
+            durationSeconds: Math.max(0, performance.now() - captureStarted) / 1e3
+          });
+        } catch {
+        }
       }
     })();
     const settled = captureAndPublish.then(
       (persisted) => ({ kind: "settled", persisted }),
       (error) => {
-        console.error(
-          "mid-session workspace snapshot failed (turn unaffected)",
-          safeSnapshotError(error)
-        );
+        warnSnapshotFailure("mid-session workspace snapshot failed (turn unaffected)", error);
         return { kind: "settled", persisted: false };
       }
     );
@@ -5578,14 +5781,74 @@ async function persistWarmWorkspaceSnapshot(services, ids, session, leaseEpoch,
     });
     return outcome.kind === "settled" ? outcome.persisted : false;
   } catch (error) {
-    console.error(
-      "mid-session workspace snapshot failed (turn unaffected)",
-      safeSnapshotError(error)
-    );
+    warnSnapshotFailure("mid-session workspace snapshot failed (turn unaffected)", error);
     return false;
   }
 }
 async function resumeBoxForTurn(services, ids, kind, holderId) {
+  try {
+    return await resumeBoxForTurnOnce(services, ids, kind, holderId);
+  } catch (error) {
+    if (!isReplaceableFreshSandboxReadinessTimeout(error)) throw error;
+    const readiness = error;
+    const warn = (message, fields) => {
+      if (services.observability) services.observability.warn(message, fields);
+      else console.warn(message, fields);
+    };
+    const identity = {
+      workspaceId: ids.workspaceId,
+      sessionId: ids.sessionId,
+      sandboxGroupId: ids.sandboxGroupId,
+      backend: readiness.backend,
+      instanceId: readiness.instanceId,
+      readinessTimeoutMs: readiness.timeoutMs
+    };
+    const budget = services.freshSandboxReadinessReplacementBudget ?? createFreshSandboxReadinessReplacementBudget();
+    if (budget.remaining <= 0) {
+      recordFreshSandboxReadinessReplacement(
+        services.sandboxMetrics,
+        readiness.backend,
+        "budget_spent"
+      );
+      warn(
+        "sandbox command-readiness timed out on a fresh box; this turn attempt already used its replacement",
+        identity
+      );
+      throw error;
+    }
+    budget.remaining -= 1;
+    const delayMs = await (services.freshSandboxReadinessReplacementDelayMs ?? freshSandboxReadinessReplacementDelayMs)();
+    warn("sandbox command-readiness timed out on a fresh box; replacing it once after jitter", {
+      ...identity,
+      replacementDelayMs: delayMs
+    });
+    if (!await sleepUnlessCancelled(delayMs, services.cancellationSignal)) {
+      recordFreshSandboxReadinessReplacement(
+        services.sandboxMetrics,
+        readiness.backend,
+        "cancelled"
+      );
+      throw error;
+    }
+    try {
+      const replaced = await resumeBoxForTurnOnce(services, ids, kind, holderId);
+      recordFreshSandboxReadinessReplacement(
+        services.sandboxMetrics,
+        readiness.backend,
+        "replaced"
+      );
+      return replaced;
+    } catch (replacementError) {
+      recordFreshSandboxReadinessReplacement(
+        services.sandboxMetrics,
+        readiness.backend,
+        services.cancellationSignal?.aborted ? "cancelled" : replacementError instanceof SandboxExecReadinessTimeoutError ? "failed_again" : "replacement_failed"
+      );
+      throw replacementError;
+    }
+  }
+}
+async function resumeBoxForTurnOnce(services, ids, kind, holderId) {
   const { db, settings } = services;
   const os = ids.os ?? "linux";
   const leaseTtlMs = settings.sandboxLeaseTtlMs;
@@ -5658,13 +5921,18 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
     holderId,
     subjectId: ids.sessionId,
     backend: ids.backend,
+    warmBilling: {
+      mode: settings.sandboxWarmBillingMode,
+      rateMicrosPerSecond: sandboxWarmRateMicrosPerSecond(settings, ids.backend)
+    },
     os,
     // IMAGE IS SHARED STATE (B3): thread the resolved image so the lease stamps it +
-    // conflicts on a live box already running a different image. A
+    // conflicts on a live box already running a different required image. A
     // SandboxImageConflictError propagates while another holder is active; a
     // solo change requests a capture-and-drain rotation and this attempt retries
     // after the cold successor can safely stamp the new image.
     ...ids.image ? { image: ids.image } : {},
+    ...ids.imagePolicy ? { imagePolicy: ids.imagePolicy } : {},
     // RIG IS SHARED STATE (M3): thread the frozen rig version so the lease stamps it
     // + conflicts on a live box under a different rig. A SandboxRigConflictError
     // propagates while another holder is active; a solo change uses the same
@@ -5714,7 +5982,12 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
     });
     await providerRenewalInFlight;
   };
-  const releaseDeadHolder = (reason) => {
+  const releaseDeadHolder = async (reason) => {
+    if (reason === "holder_gone" && kind === "turn" && holderLeaseHeartbeat) {
+      const expectedEpoch = holderLeaseHeartbeat.expectedEpoch;
+      const lease = await readLease(db, ids.workspaceId, ids.sandboxGroupId);
+      if (retainsHolderForWarmCapture(lease, expectedEpoch)) return;
+    }
     const message = "sandbox resume holder released: holder no longer live";
     const fields = {
       workspaceId: ids.workspaceId,
@@ -5737,15 +6010,16 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
         kind,
         holderId,
         expectedEpoch: heartbeat2.expectedEpoch,
-        leaseTtlMs: heartbeat2.leaseTtlMs
-      }).then((status) => {
+        leaseTtlMs: heartbeat2.leaseTtlMs,
+        billingMode: services.settings.sandboxWarmBillingMode
+      }).then(async (status) => {
         if (heartbeat2 !== holderLeaseHeartbeat) return;
         if (!status.holderAlive) {
-          releaseDeadHolder(status.fence);
+          await releaseDeadHolder(status.fence);
           return;
         }
         if (status.fence === "epoch") {
-          releaseDeadHolder(status.fence);
+          await releaseDeadHolder(status.fence);
           return;
         }
         if (status.leaseExtended || status.fence === "rotation_requested") {
@@ -5760,10 +6034,10 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
       sandboxGroupId: ids.sandboxGroupId,
       kind,
       holderId
-    }).then((touched) => {
+    }).then(async (touched) => {
       if (heartbeat2 !== holderLeaseHeartbeat) return;
       if (!touched) {
-        releaseDeadHolder("holder_gone");
+        await releaseDeadHolder("holder_gone");
         return;
       }
       void maybeRenewProviderExpiration().catch(() => void 0);
@@ -5802,14 +6076,18 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
   if (acquired.role === "spawner") {
     const expectedEpoch = acquired.lease.leaseEpoch;
     let createdEstablished = null;
+    let providerCreateOperationId;
+    let providerCreateBindingKey;
     let rematerialization = null;
     try {
-      const envelope = await getSandboxSessionEnvelope(db, ids.workspaceId, ids.sessionId);
-      const fallbackArchiveEnvelope = acquired.lease.recovery.archive.status === "none" && workspaceArchiveFieldsFromEnvelope(envelope) !== null ? withoutSandboxProviderIdentity(envelope) : null;
-      let spawnEnvelope = fallbackArchiveEnvelope ?? acquired.lease.resumeState ?? envelope;
+      const freshWorkspaceRecoveryId = acquired.lease.freshWorkspaceRecoveryId ?? null;
+      const envelope = freshWorkspaceRecoveryId ? null : await getSandboxSessionEnvelope(db, ids.workspaceId, ids.sessionId);
+      const legacyFallbackRefused = !freshWorkspaceRecoveryId && acquired.lease.recovery.archive.status === "none" && workspaceArchiveFieldsFromEnvelope(envelope) !== null && await sessionHoldsFreshWorkspaceRecovery(db, ids.workspaceId, ids.sessionId);
+      const fallbackArchiveEnvelope = !freshWorkspaceRecoveryId && !legacyFallbackRefused && acquired.lease.recovery.archive.status === "none" && workspaceArchiveFieldsFromEnvelope(envelope) !== null ? withoutSandboxProviderIdentity(envelope) : null;
+      let spawnEnvelope = freshWorkspaceRecoveryId ? null : legacyFallbackRefused ? acquired.lease.resumeState ?? null : fallbackArchiveEnvelope ?? acquired.lease.resumeState ?? envelope;
       const archiveSource = acquired.lease.recovery.archive.status === "none" ? fallbackArchiveEnvelope : acquired.lease.resumeState;
       const continuityRecovery = acquired.lease.recovery.continuity;
-      if (acquired.lease.recovery.archive.status === "available" && acquired.lease.archiveComplete || acquired.lease.recovery.archive.status === "none" && workspaceArchiveFieldsFromEnvelope(archiveSource) !== null) {
+      if (!freshWorkspaceRecoveryId && (acquired.lease.recovery.archive.status === "available" && (acquired.lease.archiveComplete || acquired.lease.historicalRecoveryAuthorized === true) || acquired.lease.recovery.archive.status === "none" && workspaceArchiveFieldsFromEnvelope(archiveSource) !== null)) {
         const rematerializationId = crypto.randomUUID();
         const legacyNativeArchive = legacyNativeArchiveFromEnvelope(archiveSource);
         const begun = await beginSandboxRematerialization(db, {
@@ -5851,7 +6129,7 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
           legacyCheckpoint: begun.checkpointArtifact === null ? legacyNativeArchive : null,
           legacyProviderBinding: null
         };
-      } else if (acquired.lease.recovery.archive.status !== "none" && !continuityRecovery) {
+      } else if (!freshWorkspaceRecoveryId && acquired.lease.recovery.archive.status !== "none" && !continuityRecovery) {
         throw new SandboxLeaseRecoveryBlockedError(
           ids.sandboxGroupId,
           expectedEpoch,
@@ -5891,15 +6169,49 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
         ...ids.environment ? { environment: ids.environment } : {},
         ...services.sandboxMetrics ? { metrics: services.sandboxMetrics } : {},
         ...services.logicalFallbackSettings ? { logicalFallbackSettings: services.logicalFallbackSettings } : {},
-        onSandboxCreated: async (created) => {
-          createdEstablished = created;
-          providerRenewalTarget = {
-            backend: ids.backend,
-            instanceId: created.instanceId
-          };
-          providerRenewedAtMs = Date.now();
+        onBeforeSandboxCreate: async (createSettings, intent, providerContext) => {
+          if (ids.backend !== "modal") return;
+          if (!intent || !providerContext)
+            throw new Error("Modal create requires the provider dispatch boundary");
           throwIfReleasedOrCancelled();
-          if (rematerialization && (rematerialization.providerBindingKey || rematerialization.legacyCheckpoint)) {
+          const binding = await resolveModalCheckpointProviderBindingForSession(
+            createSettings,
+            providerContext
+          );
+          const operationId = intent.operationId;
+          await beginModalProviderCreate(db, {
+            accountId: ids.accountId,
+            workspaceId: ids.workspaceId,
+            sandboxGroupId: ids.sandboxGroupId,
+            expectedEpoch,
+            operationId,
+            providerBindingKey: binding.key,
+            rematerializationId: rematerialization?.id ?? null,
+            selectedRevision: rematerialization?.selectedRevision ?? null,
+            imageId: intent.imageId,
+            imageRef: createSettings.modalImageRef ?? null,
+            appId: intent.appId,
+            providerName: intent.name,
+            requestSha256: intent.requestSha256
+          });
+          providerCreateOperationId = operationId;
+          providerCreateBindingKey = binding.key;
+        },
+        onSandboxCreated: async (created) => {
+          createdEstablished = created;
+          providerRenewalTarget = {
+            backend: ids.backend,
+            instanceId: created.instanceId
+          };
+          providerRenewedAtMs = Date.now();
+          if (providerCreateBindingKey && !await modalSessionMatchesCheckpointProviderBinding(
+            settings,
+            created.session,
+            providerCreateBindingKey
+          )) {
+            throw new Error("Modal creation receipt crossed the fenced provider namespace");
+          }
+          if (rematerialization && (rematerialization.providerBindingKey || rematerialization.legacyCheckpoint)) {
             if (created.backendId !== "modal") {
               throw new WorkspaceArchiveIntegrityError(
                 "native_snapshot_reference_invalid",
@@ -5941,6 +6253,7 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
             sandboxGroupId: ids.sandboxGroupId,
             expectedEpoch,
             rematerializationId: rematerialization?.id ?? null,
+            ...providerCreateOperationId ? { providerCreateOperationId } : {},
             ...created.providerContinuity ? { continuityRecovery: created.providerContinuity } : {},
             instanceId: created.instanceId,
             resumeBackendId: created.backendId,
@@ -6016,9 +6329,20 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
       });
       createdEstablished = established;
       throwIfReleasedOrCancelled();
-      await waitForSandboxExecReadiness(established, MODAL_EXEC_READINESS_TIMEOUT_MS, {
-        sandboxGroupId: ids.sandboxGroupId
-      });
+      if (services.verifySpawnedSandboxReadiness) {
+        await services.verifySpawnedSandboxReadiness(established, {
+          sandboxGroupId: ids.sandboxGroupId
+        });
+      } else {
+        await waitForSandboxExecReadiness(
+          established,
+          MODAL_EXEC_READINESS_TIMEOUT_MS,
+          {
+            sandboxGroupId: ids.sandboxGroupId
+          },
+          cancellationSignal
+        );
+      }
       await maybeRenewProviderExpiration(true);
       throwIfReleasedOrCancelled();
       const resumeEnvelope = requirePersistableReplacementSandboxEnvelope(
@@ -6043,7 +6367,7 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
         dataPlaneUrl: null,
         resumeBackendId: established.backendId,
         resumeState: resumeEnvelope,
-        ...established.providerContinuity ? { continuityRecovery: established.providerContinuity } : rematerialization ? {
+        ...freshWorkspaceRecoveryId ? { freshWorkspace: { operationId: freshWorkspaceRecoveryId } } : established.providerContinuity ? { continuityRecovery: established.providerContinuity } : rematerialization ? {
           rematerialization: {
             id: rematerialization.id,
             verifiedRevision: rematerialization.selectedRevision
@@ -6112,6 +6436,9 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
       }
       await release();
       recordSandboxWarmingTimeout(services.sandboxMetrics, error);
+      if (terminated && createdEstablished && error instanceof SandboxExecReadinessTimeoutError && error.instanceId === createdEstablished.instanceId && (createdEstablished.origin === "created" || createdEstablished.origin === "restored") && !createdEstablished.providerContinuity) {
+        disposedUnreadyFreshSandboxErrors.add(error);
+      }
       throw sandboxProvisionStageError(rematerialization ? "archive_recovery" : "create", error);
     }
   }
@@ -6140,9 +6467,14 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
       if (services.verifyAttachedSandboxReadiness) {
         await services.verifyAttachedSandboxReadiness(established);
       } else {
-        await waitForSandboxExecReadiness(established, MODAL_EXEC_READINESS_TIMEOUT_MS, {
-          sandboxGroupId: ids.sandboxGroupId
-        });
+        await waitForSandboxExecReadiness(
+          established,
+          MODAL_EXEC_READINESS_TIMEOUT_MS,
+          {
+            sandboxGroupId: ids.sandboxGroupId
+          },
+          cancellationSignal
+        );
       }
       providerRenewalTarget = {
         backend: ids.backend,
@@ -6159,9 +6491,15 @@ async function resumeBoxForTurn(services, ids, kind, holderId) {
         workspaceId: ids.workspaceId,
         sandboxGroupId: ids.sandboxGroupId,
         expectedEpoch: leaseEpoch,
-        expectedInstanceId: live.instanceId
+        expectedInstanceId: live.instanceId,
+        expectedBackend: ids.backend
       });
       if (marked.status === "marked") {
+        await publishDurableSessionEvents2(
+          services.bus,
+          ids.workspaceId,
+          marked.backgroundCommandEvents
+        );
         await services.onSandboxLost?.({
           sandboxGroupId: ids.sandboxGroupId,
           instanceId: live.instanceId,
@@ -6289,7 +6627,7 @@ async function resolveCurrentHomeBackend(services, ids, established) {
     throw homeRouteRecoveryError(lease, fallbackEpoch);
   }
   if (lease.instanceId === established.instanceId) {
-    services.onHomeSandboxRebound?.({
+    await services.onHomeSandboxRebound?.({
       established,
       leaseEpoch: lease.leaseEpoch
     });
@@ -6329,9 +6667,15 @@ async function resolveCurrentHomeBackend(services, ids, established) {
       sandboxGroupId: ids.sandboxGroupId,
       expectedEpoch: lease.leaseEpoch,
       expectedInstanceId: lease.instanceId,
+      expectedBackend: lease.backend,
       diagnostic: "provider_not_found_during_home_route_rebind"
     });
     if (marked.status === "marked") {
+      await publishDurableSessionEvents2(
+        services.bus,
+        ids.workspaceId,
+        marked.backgroundCommandEvents
+      );
       await services.onHomeSandboxLost?.({
         sandboxGroupId: ids.sandboxGroupId,
         instanceId: lease.instanceId,
@@ -6348,7 +6692,7 @@ async function resolveCurrentHomeBackend(services, ids, established) {
   if (rebound.instanceId !== lease.instanceId || reboundBackend !== resumeBackend) {
     throw homeRouteRecoveryError(lease, lease.leaseEpoch);
   }
-  services.onHomeSandboxRebound?.({
+  await services.onHomeSandboxRebound?.({
     established: rebound,
     leaseEpoch: lease.leaseEpoch
   });
@@ -6400,7 +6744,7 @@ function afterPersistableHomeMutation(services, ids, home) {
     if (!exactAdmission || typeof exactAdmission.id !== "string" || typeof exactAdmission.workspaceGeneration !== "number" || !("providerBinding" in boundAdmission)) {
       throw new Error("Persistable home mutation settlement lacked its bound admission");
     }
-    if (outcome === "resolved" && retainedProcess) {
+    if ((outcome === "resolved" || outcome === "outcome_unknown") && retainedProcess) {
       try {
         await retainWorkspaceProviderCommand(services.db, {
           accountId: fence.accountId,
@@ -6445,6 +6789,8 @@ function afterPersistableHomeMutation(services, ids, home) {
       }
       return;
     }
+    if (outcome === "outcome_unknown")
+      throw new Error("Outcome-unknown command settlement requires its exact retained invocation");
     await verifyWorkspaceMutationSettlement(services.db, {
       accountId: fence.accountId,
       workspaceId: ids.workspaceId,
@@ -6553,7 +6899,7 @@ function settleRetainedProcessForTurn(services, ids) {
       sessionId: ids.sessionId,
       processId: process2.id
     });
-    if (!durable || durable.providerSessionId !== process2.providerSessionId || durable.providerBackend !== backend.kind || durable.providerInstanceId !== backend.providerInstanceId || durable.leaseEpoch !== backend.leaseEpoch || durable.routeKind !== (backend.sandboxId === null ? "home" : "active") || durable.routeTargetId !== backend.sandboxId || durable.routeEpoch !== backend.activeEpoch) {
+    if (!durable || durable.providerSessionId !== process2.providerSessionId || durable.providerBackend !== (sandboxBackendForSdkBackendId(backend.kind) ?? backend.kind) || durable.providerInstanceId !== backend.providerInstanceId || durable.leaseEpoch !== backend.leaseEpoch || durable.routeKind !== (backend.sandboxId === null ? "home" : "active") || durable.routeTargetId !== backend.sandboxId || durable.routeEpoch !== backend.activeEpoch) {
       throw new Error("Retained-process settlement lost its exact durable backend identity");
     }
     const settlement = await settleRetainedProcess(services.db, {
@@ -6575,16 +6921,43 @@ function settleRetainedProcessForTurn(services, ids) {
     }
   };
 }
+function isRetainedProcessSettledForTurn(services, ids) {
+  const fence = ids.workspaceMutationFence;
+  if (!fence) return void 0;
+  return async ({
+    backend,
+    process: process2
+  }) => {
+    const durable = await getRetainedProcess(services.db, {
+      workspaceId: ids.workspaceId,
+      sessionId: ids.sessionId,
+      processId: process2.id
+    });
+    if (!durable || durable.state === "active" || durable.providerSessionId !== process2.providerSessionId || durable.providerBackend !== (sandboxBackendForSdkBackendId(backend.kind) ?? backend.kind) || durable.providerInstanceId !== backend.providerInstanceId || durable.leaseEpoch !== backend.leaseEpoch || durable.routeKind !== (backend.sandboxId === null ? "home" : "active") || durable.routeTargetId !== backend.sandboxId || durable.routeEpoch !== backend.activeEpoch)
+      return false;
+    if (process2.providerCommand) {
+      const command = await retainedProviderCommandPersistence(services.db, {
+        accountId: fence.accountId,
+        workspaceId: ids.workspaceId,
+        sessionId: ids.sessionId,
+        processId: process2.id
+      }).load();
+      if (!command || command.kind !== process2.providerCommand.kind || command.execId !== process2.providerCommand.execId || command.taskId !== process2.providerCommand.taskId || command.sandboxId !== process2.providerCommand.sandboxId || Boolean(command.pty) !== Boolean(process2.providerCommand.pty) || command.kind === "modal-router-v1" && process2.providerCommand.kind === "modal-router-v1" && !isDeepStrictEqual3(command.supervision, process2.providerCommand.supervision))
+        return false;
+    }
+    return true;
+  };
+}
 function adoptRetainedProcessAsBackgroundCommandForTurn(services, ids) {
   const fence = ids.workspaceMutationFence;
   if (!fence) return void 0;
-  return async ({ backend, process: process2 }) => {
+  return async ({ backend, process: process2, command }) => {
     const durable = await getRetainedProcess(services.db, {
       workspaceId: ids.workspaceId,
       sessionId: ids.sessionId,
       processId: process2.id
     });
-    if (!durable || durable.providerSessionId !== process2.providerSessionId || durable.providerBackend !== backend.kind || durable.providerInstanceId !== backend.providerInstanceId || durable.leaseEpoch !== backend.leaseEpoch || durable.routeKind !== (backend.sandboxId === null ? "home" : "active") || durable.routeTargetId !== backend.sandboxId || durable.routeEpoch !== backend.activeEpoch) {
+    if (!durable || durable.providerSessionId !== process2.providerSessionId || durable.providerBackend !== (sandboxBackendForSdkBackendId(backend.kind) ?? backend.kind) || durable.providerInstanceId !== backend.providerInstanceId || durable.leaseEpoch !== backend.leaseEpoch || durable.routeKind !== (backend.sandboxId === null ? "home" : "active") || durable.routeTargetId !== backend.sandboxId || durable.routeEpoch !== backend.activeEpoch) {
       throw new Error("Background command adoption lost its exact retained-process identity");
     }
     await adoptManagedSessionBackgroundCommand(services.db, {
@@ -6596,7 +6969,7 @@ function adoptRetainedProcessAsBackgroundCommandForTurn(services, ids) {
       attemptId: fence.attemptId,
       processId: process2.id,
       expected: retainedProcessSettlementIdentity(durable),
-      command: "execCommand"
+      command: command ?? "Background command"
     });
   };
 }
@@ -6617,6 +6990,7 @@ function wrapTurnBoxWithRouting(services, ids, established) {
   const beforeProcessMutation = beforeRetainedProcessMutation(services, ids);
   const afterProcessMutation = afterRetainedProcessMutation(services, ids);
   const settleProcess = settleRetainedProcessForTurn(services, ids);
+  const isProcessSettled = isRetainedProcessSettledForTurn(services, ids);
   const adoptProcessAsBackgroundCommand = adoptRetainedProcessAsBackgroundCommandForTurn(
     services,
     ids
@@ -6769,20 +7143,27 @@ function wrapTurnBoxWithRouting(services, ids, established) {
     },
     resolveActiveBackend: resolver,
     ...services.onSandboxOperation ? { onOperation: services.onSandboxOperation } : {},
+    ...services.onSandboxCaptureWait ? { onCaptureWait: services.onSandboxCaptureWait } : {},
     providerCommandHandle: admittedCommandHandle,
+    providerSupervisionReady: async () => settings.modalCommandSupervisionEnabled && await supervisedCommandProtocolReady(db),
     ...ids.workspaceMutationFence ? {
-      providerCommandPersistence: (process2) => retainedProviderCommandPersistence(db, {
-        accountId: ids.workspaceMutationFence.accountId,
-        workspaceId: ids.workspaceId,
-        sessionId: ids.sessionId,
-        processId: process2.id
-      })
+      providerCommandPersistence: (process2) => retainedProviderCommandPersistence(
+        db,
+        {
+          accountId: ids.workspaceMutationFence.accountId,
+          workspaceId: ids.workspaceId,
+          sessionId: ids.sessionId,
+          processId: process2.id
+        },
+        services.bus ? (events) => services.bus.publish(ids.workspaceId, ids.sessionId, events) : void 0
+      )
     } : {},
     ...beforeMutation ? { beforeMutation } : {},
     ...afterMutation ? { afterMutation } : {},
     ...beforeProcessMutation ? { beforeProcessMutation } : {},
     ...afterProcessMutation ? { afterProcessMutation } : {},
     ...settleProcess ? { settleProcess } : {},
+    ...isProcessSettled ? { isProcessSettled } : {},
     ...ids.workspaceMutationFence ? { observeProcessTerminal: observeRetainedProcessTerminalForTurn(services, ids) } : {},
     ...ids.workspaceMutationFence ? { captureProcessOutput: captureRetainedProcessOutputForTurn(services, ids) } : {},
     ...adoptProcessAsBackgroundCommand ? { adoptProcessAsBackgroundCommand } : {},
@@ -6801,9 +7182,15 @@ function wrapTurnBoxWithRouting(services, ids, established) {
           sandboxGroupId: home.sandboxGroupId,
           expectedEpoch,
           expectedInstanceId,
+          expectedBackend: home.backend,
           diagnostic: "provider_not_found_during_routed_operation"
         });
         if (marked.status === "marked") {
+          await publishDurableSessionEvents2(
+            services.bus,
+            ids.workspaceId,
+            marked.backgroundCommandEvents
+          );
           await services.onHomeSandboxLost?.({
             sandboxGroupId: home.sandboxGroupId,
             instanceId: expectedInstanceId,
@@ -6830,6 +7217,7 @@ function wrapLazyTurnBoxWithRouting(services, ids, args) {
   const beforeProcessMutation = beforeRetainedProcessMutation(services, ids);
   const afterProcessMutation = afterRetainedProcessMutation(services, ids);
   const settleProcess = settleRetainedProcessForTurn(services, ids);
+  const isProcessSettled = isRetainedProcessSettledForTurn(services, ids);
   const adoptProcessAsBackgroundCommand = adoptRetainedProcessAsBackgroundCommandForTurn(
     services,
     ids
@@ -6965,21 +7353,28 @@ function wrapLazyTurnBoxWithRouting(services, ids, args) {
       return routedResolver(pointer);
     },
     ...services.onSandboxOperation ? { onOperation: services.onSandboxOperation } : {},
+    ...services.onSandboxCaptureWait ? { onCaptureWait: services.onSandboxCaptureWait } : {},
     ...args.onFirstOperation ? { onFirstOperation: args.onFirstOperation } : {},
     providerCommandHandle: admittedCommandHandle,
+    providerSupervisionReady: async () => settings.modalCommandSupervisionEnabled && await supervisedCommandProtocolReady(db),
     ...ids.workspaceMutationFence ? {
-      providerCommandPersistence: (process2) => retainedProviderCommandPersistence(db, {
-        accountId: ids.workspaceMutationFence.accountId,
-        workspaceId: ids.workspaceId,
-        sessionId: ids.sessionId,
-        processId: process2.id
-      })
+      providerCommandPersistence: (process2) => retainedProviderCommandPersistence(
+        db,
+        {
+          accountId: ids.workspaceMutationFence.accountId,
+          workspaceId: ids.workspaceId,
+          sessionId: ids.sessionId,
+          processId: process2.id
+        },
+        services.bus ? (events) => services.bus.publish(ids.workspaceId, ids.sessionId, events) : void 0
+      )
     } : {},
     ...beforeMutation ? { beforeMutation } : {},
     ...afterMutation ? { afterMutation } : {},
     ...beforeProcessMutation ? { beforeProcessMutation } : {},
     ...afterProcessMutation ? { afterProcessMutation } : {},
     ...settleProcess ? { settleProcess } : {},
+    ...isProcessSettled ? { isProcessSettled } : {},
     ...ids.workspaceMutationFence ? { observeProcessTerminal: observeRetainedProcessTerminalForTurn(services, ids) } : {},
     ...ids.workspaceMutationFence ? { captureProcessOutput: captureRetainedProcessOutputForTurn(services, ids) } : {},
     ...adoptProcessAsBackgroundCommand ? { adoptProcessAsBackgroundCommand } : {},
@@ -6999,9 +7394,15 @@ function wrapLazyTurnBoxWithRouting(services, ids, args) {
           sandboxGroupId: home.sandboxGroupId,
           expectedEpoch: backend.leaseEpoch,
           expectedInstanceId: backend.providerInstanceId,
+          expectedBackend: home.backend,
           diagnostic: "provider_not_found_during_routed_operation"
         });
         if (marked.status === "marked") {
+          await publishDurableSessionEvents2(
+            services.bus,
+            ids.workspaceId,
+            marked.backgroundCommandEvents
+          );
           await services.onHomeSandboxLost?.({
             sandboxGroupId: home.sandboxGroupId,
             instanceId: backend.providerInstanceId,
@@ -7171,6 +7572,20 @@ async function establishSelfhostedTurnSession(services, args) {
         reason: command.reason,
         ...command.failure ? { failure: command.failure } : {}
       });
+      if (command.outputReceipt && command.outcome === "exited" && command.exitCode !== null) {
+        await recordConnectedCommandOutputConsumption(db, {
+          accountId: args.accountId,
+          workspaceId: args.workspaceId,
+          sessionId: args.sessionId,
+          commandId: command.commandId,
+          controlWorkspaceId: command.controlWorkspaceId,
+          enrollmentId: command.enrollmentId,
+          connectionInstanceId: command.connectionInstanceId,
+          opId: command.opId,
+          receipt: command.outputReceipt,
+          exitCode: command.exitCode
+        });
+      }
       if (settlement && bus) {
         await bus.publish(args.workspaceId, args.sessionId, settlement.events).catch(() => void 0);
       }
@@ -7198,14 +7613,17 @@ function lazyProvisionEnabled(settings) {
 }
 
 // src/activities/parent-wake.ts
+import { getSessionParentClaudeProviderAccountAuthority } from "@opengeni/db";
 import {
   getSession,
   getSessionGoal as getSessionGoal2,
   getSessionParentPersonalConnectionDelegations,
+  getSessionParentMcpAccountBindings,
   getSessionParentXaiProviderAccountAuthority,
   addSessionSystemUpdateWithSourceMutation,
   claimPendingSessionSystemUpdateOutbox,
   claimPendingSessionWorkflowWakes,
+  repairPendingChildTerminalResultWakes,
   childRequiresActionDedupeKey,
   getSessionSystemUpdateOutboxByDedupeKey,
   getOrCreateSessionSystemUpdateOutbox,
@@ -7218,6 +7636,7 @@ import {
   sessionSystemUpdateOutboxKindPayload
 } from "@opengeni/db";
 import { requireSessionEventDurableFanoutCapability } from "@opengeni/events";
+var childTerminalRepairCursors = /* @__PURE__ */ new WeakMap();
 async function notifyParentOfChildIdle(svc, workspaceId, childSessionId, episodeKey) {
   try {
     const child = await getSession(svc.db, workspaceId, childSessionId);
@@ -7232,11 +7651,21 @@ async function notifyParentOfChildIdle(svc, workspaceId, childSessionId, episode
       workspaceId,
       childSessionId
     );
+    const mcpAccountBindings = await getSessionParentMcpAccountBindings(
+      svc.db,
+      workspaceId,
+      childSessionId
+    );
     const xaiAuthority = await getSessionParentXaiProviderAccountAuthority(
       svc.db,
       workspaceId,
       childSessionId
     );
+    const claudeAuthority = await getSessionParentClaudeProviderAccountAuthority(
+      svc.db,
+      workspaceId,
+      childSessionId
+    );
     const outbox = await getOrCreateSessionSystemUpdateOutbox(svc.db, {
       accountId: child.accountId,
       workspaceId,
@@ -7249,12 +7678,15 @@ async function notifyParentOfChildIdle(svc, workspaceId, childSessionId, episode
       summary: childCompletionSummary(child, goal, "idle"),
       payload,
       lineage: {
+        ...claudeAuthority.subjectId ? { claudeAuthoritySubjectId: claudeAuthority.subjectId } : {},
         childSessionId: child.id,
         parentSessionId: child.parentSessionId,
         ...xaiAuthority.subjectId ? { xaiAuthoritySubjectId: xaiAuthority.subjectId } : {}
       },
       personalConnectionDelegations,
-      xaiProviderAccountAuthoritySnapshot: xaiAuthority.snapshot
+      mcpAccountBindings,
+      xaiProviderAccountAuthoritySnapshot: xaiAuthority.snapshot,
+      claudeProviderAccountAuthoritySnapshot: claudeAuthority.snapshot
     });
     if (outbox.status === "delivered") {
       return;
@@ -7329,7 +7761,9 @@ async function deliverParentSystemUpdateOutbox(svc, outbox) {
         summary: outbox.summary,
         lineage: outbox.lineage,
         personalConnectionDelegations: outbox.personalConnectionDelegations,
-        xaiProviderAccountAuthoritySnapshot: outbox.xaiProviderAccountAuthoritySnapshot
+        mcpAccountBindings: outbox.mcpAccountBindings,
+        xaiProviderAccountAuthoritySnapshot: outbox.xaiProviderAccountAuthoritySnapshot,
+        claudeProviderAccountAuthoritySnapshot: outbox.claudeProviderAccountAuthoritySnapshot
       },
       async (tx) => {
         await markSessionSystemUpdateOutboxDeliveredInTransaction(tx, outbox);
@@ -7432,6 +7866,21 @@ async function reconcilePendingSessionWorkflowWakes(svc, limit = 1e3, overrides
       pendingAdmissionBlockers: {}
     };
   }
+  const repairChildren = overrides.repairPendingChildTerminalResultWakes ?? repairPendingChildTerminalResultWakes;
+  const inventory = await repairChildren(
+    svc.db,
+    Math.min(100, limit),
+    childTerminalRepairCursors.get(svc.db) ?? null
+  );
+  if (inventory.cursor) childTerminalRepairCursors.set(svc.db, inventory.cursor);
+  else childTerminalRepairCursors.delete(svc.db);
+  if (inventory.failed > 0) {
+    svc.observability.error("Pending child-result wake repair failed", {
+      examined: inventory.examined,
+      registered: inventory.registered,
+      failed: inventory.failed
+    });
+  }
   const repairs = await claimPendingSessionWorkflowWakesFn(svc.db, limit);
   let signaled = 0;
   let pendingAdmission = 0;
@@ -7562,7 +8011,7 @@ import {
   stableJson
 } from "@opengeni/contracts";
 import { createHash as createHash3 } from "crypto";
-import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
 var INCIDENT_TELEMETRY_AUTHORITY_FENCE_LINEAGE_KEY = "incidentTelemetryAuthorityFence";
 function incidentTelemetryPreflightDeclaration(agentConfig, incidentTriggered) {
   const rawConfig = agentConfig;
@@ -7595,7 +8044,7 @@ function evaluateIncidentTelemetryPreflight(input) {
     return blocked("incident_preflight_metadata_missing");
   }
   if (preflight.requiredResources.some(
-    (required) => !input.responder.resources.some((selected) => isDeepStrictEqual3(selected, required))
+    (required) => !input.responder.resources.some((selected) => isDeepStrictEqual4(selected, required))
   )) {
     return blocked("incident_responder_under_capable");
   }
@@ -7971,6 +8420,150 @@ async function validateIncidentTelemetrySystemUpdateAuthority(input) {
   return current && current.toolPolicyVersion === fence.toolPolicyVersion && current.responderDigest === fence.responderDigest && current.taskDigest === fence.taskDigest && current.alertSelectorDigest === fence.alertSelectorDigest ? { action: "accept" } : await reject();
 }
 
+// src/activities/agent-turn/provider-dispatch-barrier.ts
+var SandboxCapabilitiesChangedError = class extends Error {
+  code = "native_capabilities_changed_this_attempt";
+  constructor() {
+    super("The attached sandbox requires rebuilding this attempt's native capabilities.");
+    this.name = "SandboxCapabilitiesChangedError";
+  }
+};
+async function checkpointHistoryBeforeProviderDispatch(historySink, route) {
+  await historySink.reconcileConversationTruth({ requireDurable: true });
+  if (route?.effectiveSandboxBackend === "none" && route.routingEnabled) {
+    const active = await route.readActiveSandbox();
+    if (active?.activeSandboxId) throw new SandboxCapabilitiesChangedError();
+  }
+}
+
+// src/activities/agent-turn/claude-usage-observer.ts
+import { createHash as createHash4 } from "crypto";
+import {
+  emptyClaudeUsage,
+  mergeClaudeUsage,
+  parseClaudeUsageHeaders
+} from "@opengeni/config";
+var ClaudeSubscriptionConnectionUnavailable = class extends Error {
+  status = 409;
+  code = "claude_subscription_connection_changed";
+  constructor() {
+    super(
+      "Claude connection changed or was disconnected. Start a new turn with the current connection."
+    );
+  }
+};
+async function createClaudeUsageObserver(providers, latest, readCredential) {
+  const managedProviderIds = new Set(
+    providers.filter(
+      (provider) => provider.kind === "claude-subscription-workspace" || provider.kind === "claude-subscription-organization"
+    ).map((provider) => provider.id)
+  );
+  const bindings = await Promise.all(
+    providers.filter(
+      (provider) => provider.kind === "claude-subscription-workspace" || provider.kind === "claude-subscription-organization"
+    ).map(async (provider) => {
+      const scope = provider.kind === "claude-subscription-workspace" ? "workspace" : "organization";
+      const binding = provider.anthropic?.credentialBinding;
+      if (binding && provider.apiKey)
+        return [
+          provider.id,
+          {
+            scope,
+            token: provider.apiKey,
+            expectedConnectionId: binding.connectionId,
+            expectedCredentialVersion: binding.credentialVersion
+          }
+        ];
+      const credential = await readCredential(scope).catch(() => null);
+      if (!credential || credential.token !== provider.apiKey) return null;
+      return [
+        provider.id,
+        {
+          scope,
+          token: credential.token,
+          expectedConnectionId: credential.connectionId,
+          expectedCredentialVersion: credential.credentialVersion
+        }
+      ];
+    })
+  );
+  const captured = new Map(bindings.filter((binding) => binding !== null));
+  let anonymousReceipt = 0;
+  const observeBinding = (binding, response, upstreamModelId, requestToken) => {
+    if (requestToken === null) return;
+    if (!binding) return;
+    const { scope, ...capturedIdentity } = binding;
+    const identity = { ...capturedIdentity, token: requestToken ?? capturedIdentity.token };
+    const tokenKey = createHash4("sha256").update(identity.token).digest("hex");
+    const rawRequestId = response.headers.get("request-id");
+    const requestId = rawRequestId && rawRequestId.length <= 256 ? rawRequestId : void 0;
+    const receiptKey = requestId ?? (response.status === 401 || response.status === 429 ? `anonymous-${++anonymousReceipt}` : "aggregate");
+    const captureKey = `${receiptKey}:${scope}:${identity.expectedConnectionId}:${identity.expectedCredentialVersion}:${tokenKey}:${upstreamModelId ?? "unknown"}`;
+    const previous = latest.get(captureKey);
+    let observation = parseClaudeUsageHeaders(response.headers, /* @__PURE__ */ new Date(), upstreamModelId);
+    if (observation && previous?.observation) {
+      const merged = mergeClaudeUsage(
+        mergeClaudeUsage(emptyClaudeUsage(binding.expectedCredentialVersion), previous.observation),
+        observation
+      );
+      observation = {
+        windows: merged.windows,
+        observedAt: merged.observedAt,
+        source: merged.source,
+        requestStatus: merged.requestStatus ?? null,
+        requestRestrictions: merged.requestRestrictions ?? []
+      };
+    }
+    if (requestId || observation || response.status === 401 || response.status === 429)
+      latest.set(captureKey, {
+        scope,
+        responseStatus: response.status,
+        ...response.headers.get("request-id") && response.headers.get("request-id").length <= 256 ? { requestId: response.headers.get("request-id") } : {},
+        ...upstreamModelId ? { upstreamModelId } : {},
+        ...identity,
+        ...previous?.observation && !observation ? { observation: previous.observation } : {},
+        ...observation ? { observation } : {},
+        ...response.status === 401 ? { refresh: { status: "reconnect", checkedAt: (/* @__PURE__ */ new Date()).toISOString() } } : {}
+      });
+  };
+  const observe = (providerId, response, upstreamModelId, requestToken) => observeBinding(captured.get(providerId), response, upstreamModelId, requestToken);
+  const prepareRequestWithObserver = async (providerId, headers, resolve) => {
+    if (!managedProviderIds.has(providerId)) return { headers, observe };
+    const binding = captured.get(providerId);
+    if (!binding) throw new ClaudeSubscriptionConnectionUnavailable();
+    const credential = await resolve({
+      scope: binding.scope,
+      expectedConnectionId: binding.expectedConnectionId,
+      expectedCredentialVersion: binding.expectedCredentialVersion
+    });
+    if (!credential || credential.connectionId !== binding.expectedConnectionId || credential.credentialVersion !== binding.expectedCredentialVersion)
+      throw new ClaudeSubscriptionConnectionUnavailable();
+    const dispatched = Object.freeze({ ...binding, token: credential.token });
+    captured.set(providerId, dispatched);
+    headers.set("authorization", `Bearer ${credential.token}`);
+    headers.delete("x-api-key");
+    return {
+      headers,
+      observe: (_providerId, response, upstreamModelId, requestToken) => observeBinding(dispatched, response, upstreamModelId, requestToken)
+    };
+  };
+  return Object.assign(observe, {
+    prepareRequestWithObserver,
+    async prepareRequest(...args) {
+      return (await prepareRequestWithObserver(...args)).headers;
+    },
+    binding(providerId) {
+      const binding = captured.get(providerId);
+      return binding ? { ...binding } : void 0;
+    },
+    renew(providerId, credential) {
+      const binding = captured.get(providerId);
+      if (binding && binding.expectedConnectionId === credential.connectionId && binding.expectedCredentialVersion === credential.credentialVersion)
+        captured.set(providerId, { ...binding, token: credential.token });
+    }
+  });
+}
+
 // src/activities/agent-turn/sandbox-provision.ts
 import {
   SandboxLeaseRecoveryBlockedError as SandboxLeaseRecoveryBlockedError2,
@@ -8446,12 +9039,14 @@ async function persistOrSignalSessionAttemptQuiescence(input) {
   return "receipt";
 }
 async function drainAttemptOwnedSandboxWriters(input) {
+  input.onStage?.("tool_writers");
   if (input.toolCancellationFence) {
     input.toolCancellationFence.cancel(
       input.cancellationReason ?? new Error("TURN_ATTEMPT_FENCED")
     );
     await input.toolCancellationFence.waitForQuiescence();
   }
+  input.onStage?.("credential_renewals");
   await Promise.all(input.gitCredentialRenewals.map(async (renewal) => await renewal.stop()));
   await input.codemodeTokenRenewal?.stop();
   await input.runCredentialRenewal?.stop();
@@ -8564,7 +9159,7 @@ async function runMandatoryHistoryPersistenceStep(stage, operation) {
     throw new MandatoryHistoryPersistenceError(stage, cause);
   }
 }
-async function finalizeDurableTurnOpStreams(sessions, fallback) {
+async function finalizeDurableTurnOpStreams(sessions, fallback, toolCallIds) {
   const candidates = /* @__PURE__ */ new Set();
   for (const session of sessions) {
     const candidate = session;
@@ -8577,17 +9172,53 @@ async function finalizeDurableTurnOpStreams(sessions, fallback) {
   }
   for (const candidate of candidates) {
     try {
-      await candidate.finalizeOpStreamOps();
+      await candidate.finalizeOpStreamOps(toolCallIds);
     } catch {
     }
   }
 }
 
+// src/activities/agent-turn/errors.ts
+import { ClaudeSubscriptionReconnectRequired } from "@opengeni/db";
+
+// ../../node_modules/.bun/drizzle-orm@0.45.2+1d2c014f134ec9f4/node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+
+// ../../node_modules/.bun/drizzle-orm@0.45.2+1d2c014f134ec9f4/node_modules/drizzle-orm/errors.js
+var DrizzleError = class extends Error {
+  static [entityKind] = "DrizzleError";
+  constructor({ message, cause }) {
+    super(message);
+    this.name = "DrizzleError";
+    this.cause = cause;
+  }
+};
+var DrizzleQueryError = class _DrizzleQueryError extends Error {
+  constructor(query, params, cause) {
+    super(`Failed query: ${query}
+params: ${params}`);
+    this.query = query;
+    this.params = params;
+    this.cause = cause;
+    Error.captureStackTrace(this, _DrizzleQueryError);
+    if (cause) this.cause = cause;
+  }
+};
+var TransactionRollbackError = class extends DrizzleError {
+  static [entityKind] = "TransactionRollbackError";
+  constructor() {
+    super({ message: "Rollback" });
+  }
+};
+
 // src/activities/agent-turn/errors.ts
 import {
   ActiveSessionHistoryLimitExceededError,
   ApprovalRunStateLimitExceededError,
   nestedPostgresSqlState,
+  databaseFailureCode,
+  isRetryablePersistenceSqlState,
   safeDatabaseErrorFacts,
   isRetryableDatabaseTransportFailure,
   isSessionEventPersistenceError,
@@ -8595,14 +9226,27 @@ import {
 } from "@opengeni/db";
 import {
   ActiveBackendUnresolvableError as ActiveBackendUnresolvableError2,
+  AnthropicProviderRejection,
   CompactionProviderResponseError,
   EmptyCompactionSummaryError,
+  compactionProviderRejection,
+  describeCompactionProviderRejection,
   isMcpRequestTimeoutError,
   isMcpTransportConnectivityError,
-  isModalTaskExecStartDnsResolutionError,
+  isModalTaskExecStartPreDispatchUnavailableError,
+  isModalCommandStartOutcomeUnknownError,
+  isProviderCommandObservationUnavailableError,
+  isRoutingMutationOutcomeUnknownError,
   RoutingWorkspaceRootChangedError,
+  ResponsesStreamingTerminalError,
+  SandboxMaterializationVerificationError,
+  materializationVerificationDiagnostic,
+  PROVIDER_QUOTA_EXHAUSTED_CODE,
+  classifyProviderQuotaError,
+  providerQuotaExhaustedMessage,
   SelfhostedWorkspaceRootChangedError,
-  UNKNOWN_MODEL_FINISH_REASON_CODE
+  UNKNOWN_MODEL_FINISH_REASON_CODE,
+  AnthropicRequestError
 } from "@opengeni/runtime";
 import {
   mcpTransportRequestFailureDiagnostic
@@ -8616,7 +9260,7 @@ import {
   FileResourceRef,
   resourceMountPath
 } from "@opengeni/contracts";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import {
   getActiveSessionHistoryItemsPaged,
   getFilesForSubject,
@@ -8734,7 +9378,7 @@ async function modelAttachmentContentForFiles(files, readFileBytes, options = {}
           });
           continue;
         }
-        if (createHash4("sha256").update(bytes).digest("hex") !== checksum) {
+        if (createHash5("sha256").update(bytes).digest("hex") !== checksum) {
           console.error("model attachment checksum did not match finalized metadata", {
             fileId: file.id
           });
@@ -8772,12 +9416,8 @@ function attachmentRefsFromItem(item) {
   }
   return refs;
 }
-function attachmentReceiptText(ref, file) {
-  if (!file) {
-    return `[Earlier attachment: fileId=${ref.fileId}; mountDirectory=${resourceMountPath(ref)}. Use the existing file there, or call files__files_get_download_url with this fileId and download it with the shell.]`;
-  }
-  const path = sandboxFilePath(ref, file);
-  return `[Attachment: ${file.safeFilename}; fileId=${file.id}; type=${file.contentType}; bytes=${file.sizeBytes}; path=${path}. If the local path is absent, call files__files_get_download_url with this fileId and download it with the shell.]`;
+function attachmentReceiptText(ref) {
+  return `[Attachment: fileId=${ref.fileId}; mountDirectory=${resourceMountPath(ref)}. Use the existing file there, or call files__files_get_download_url with this fileId and download it with the shell.]`;
 }
 function createModelHistoryAttachmentProjector(policy, readFileBytes, loadAuthorizedFiles) {
   const contentById = /* @__PURE__ */ new Map();
@@ -8856,7 +9496,7 @@ function createModelHistoryAttachmentProjector(policy, readFileBytes, loadAuthor
         const attachment = currentFile ? contentById.get(ref.fileId) : void 0;
         const receipt = {
           type: "input_text",
-          text: attachmentReceiptText(ref, currentFile)
+          text: attachmentReceiptText(ref)
         };
         if (!attachment || attachment.kind !== "image") {
           return [receipt];
@@ -8875,12 +9515,18 @@ function createModelHistoryAttachmentProjector(policy, readFileBytes, loadAuthor
 }
 function withCurrentUserAttachmentRefs(historyItems, refs) {
   if (refs.length === 0) return historyItems;
+  const retainedIds = new Set(
+    historyItems.flatMap((item) => attachmentRefsFromItem(item).map((ref) => ref.fileId))
+  );
+  const missing = refs.filter((ref) => !retainedIds.has(ref.fileId));
+  if (missing.length === 0) return historyItems;
   for (let index = historyItems.length - 1; index >= 0; index -= 1) {
     const item = historyItems[index];
+    if (item[MODEL_ATTACHMENT_CATALOG_MARKER] === true) continue;
     if (item.type !== "message" || item.role !== "user") continue;
     const existing = attachmentRefsFromItem(item);
     const existingIds = new Set(existing.map((ref) => ref.fileId));
-    const additions = refs.filter((ref) => !existingIds.has(ref.fileId));
+    const additions = missing.filter((ref) => !existingIds.has(ref.fileId));
     if (additions.length === 0) return historyItems;
     const projected = [...historyItems];
     projected[index] = { ...item, [MODEL_ATTACHMENT_REFS_FIELD]: [...existing, ...additions] };
@@ -8950,8 +9596,8 @@ async function turnInput(db, runtime, agent, trigger, options) {
       options
     );
   }
-  if (trigger.type === "system.update.delivered") {
-    if (updates.length === 0) {
+  if (trigger.type === "system.update.delivered" || trigger.type === "session.context.compaction.requested") {
+    if (trigger.type === "system.update.delivered" && updates.length === 0) {
       throw new Error("Internal update inference has no delivered updates");
     }
     return await messageInput(
@@ -9116,11 +9762,125 @@ function sandboxFilePath(resource, file) {
 
 // src/activities/agent-turn/errors.ts
 import {
+  CODEX_USAGE_LIMIT_ERROR_TYPE,
   CodexReloginRequired,
+  classifyCodexEncryptedArtifactRejection,
+  classifyCodexEntitlementRejection,
   classifyCodexResponseTimeoutError,
   classifyCodexUsageLimitError,
   isCodexTransportError
 } from "@opengeni/codex";
+
+// src/activities/agent-turn/codex-plan-entitlement.ts
+import { productLabelForModelId } from "@opengeni/config";
+import {
+  codexPlanDisplayName,
+  codexPlanEntitlementLost,
+  codexPlanIsUpgrade,
+  codexPlanKey
+} from "@opengeni/codex";
+import {
+  codexPlanExcludesModel as codexPlanExcludesModel2,
+  codexPlanPreviouslyExcludedModel,
+  connectionModelAllowed as connectionModelAllowed2
+} from "@opengeni/db";
+var CODEX_PLAN_ENTITLEMENT_CODE = "codex_plan_entitlement";
+var CODEX_REQUEST_REJECTED_CODE = "codex_request_rejected";
+function codexAccountDisplayLabel(account) {
+  const label = account?.label?.trim() || null;
+  return label ? label.slice(0, 120) : null;
+}
+function accountPhrase(accountLabel) {
+  return accountLabel ? `The ChatGPT account "${accountLabel}"` : "The connected ChatGPT account";
+}
+function rejectionDetail(rejection) {
+  if (!rejection) return void 0;
+  return rejection.evidence === "empty_body" ? `The Codex backend answered HTTP ${rejection.status} with no error body.` : `The Codex backend refused the model for this plan (HTTP ${rejection.status}).`;
+}
+function codexPlanEntitlementFailurePayload(input) {
+  const plan = codexPlanDisplayName(input.planType);
+  const model = input.modelId ? productLabelForModelId(input.modelId) : "this model";
+  const lead = accountPhrase(input.accountLabel);
+  const next = input.waiting ? "Opengeni is waiting for another connected account to become available." : "Upgrade it, use another connected account, or choose another model.";
+  const error = plan ? `${lead} ${input.planChanged ? "is now" : "is"} on the ${plan} plan, which doesn't include ${model}. ${next}` : `${lead} no longer has access to ${model} on its current plan. ${next}`;
+  const detail = rejectionDetail(input.rejection ?? null);
+  return {
+    error,
+    code: CODEX_PLAN_ENTITLEMENT_CODE,
+    retryable: false,
+    planType: plan ? codexPlanKey(input.planType) : null,
+    model: input.modelId,
+    ...detail ? { detail } : {}
+  };
+}
+function codexRequestRejectedFailurePayload(input) {
+  const plan = codexPlanDisplayName(input.planType);
+  const lead = accountPhrase(input.accountLabel);
+  const planClause = input.planChecked === false ? "" : plan ? `${lead} still reports the ${plan} plan, so Opengeni did not switch accounts. ` : `Opengeni could not confirm the current plan of ${lead.charAt(0).toLowerCase()}${lead.slice(1)}, so it did not switch accounts. `;
+  return {
+    error: `The Codex backend rejected this request (HTTP ${input.rejection.status}) without an error message. ${planClause}Try again, or choose another model if it keeps failing.`,
+    code: CODEX_REQUEST_REJECTED_CODE,
+    retryable: false,
+    planType: plan ? codexPlanKey(input.planType) : null,
+    ...rejectionDetail(input.rejection) ? { detail: rejectionDetail(input.rejection) } : {}
+  };
+}
+var CodexPlanEntitlementError = class extends Error {
+  constructor(payload) {
+    super(payload.error);
+    this.payload = payload;
+    this.name = "CodexPlanEntitlementError";
+  }
+  code = CODEX_PLAN_ENTITLEMENT_CODE;
+};
+function assessCodexPlanEntitlement(rejection, recheck, modelId) {
+  const planObserved = recheck.planType !== null;
+  const planChangedFrom = planObserved && recheck.previousPlanType !== null && codexPlanKey(recheck.previousPlanType) !== codexPlanKey(recheck.planType) ? recheck.previousPlanType : recheck.planChangedFrom;
+  const planChanged = planObserved && planChangedFrom !== null && codexPlanKey(planChangedFrom) !== codexPlanKey(recheck.planType) && !codexPlanIsUpgrade(planChangedFrom, recheck.planType);
+  if (codexPlanEntitlementLost({
+    evidence: rejection.evidence,
+    currentPlanType: recheck.planType,
+    planChangedFrom,
+    previouslyExcluded: planObserved && codexPlanPreviouslyExcludedModel(
+      { planType: recheck.planType, planEntitlementExclusion: recheck.exclusion },
+      modelId
+    )
+  })) {
+    return {
+      kind: "entitlement_lost",
+      planType: planObserved ? recheck.planType : recheck.previousPlanType,
+      planObserved,
+      planChanged,
+      credentialVersion: recheck.credentialVersion
+    };
+  }
+  return { kind: "unexplained", planType: recheck.planType };
+}
+function codexPlanEntitlementAdmissionBlock(input) {
+  if (input.credentialId !== null) return null;
+  const permitted = input.accounts.filter(
+    (account) => connectionModelAllowed2(account.allowedModelIds, input.modelId)
+  );
+  const excluded = permitted.filter(
+    (account) => codexPlanExcludesModel2(account, input.modelId, input.now)
+  );
+  if (excluded.length === 0) return null;
+  if (input.pinnedCredentialId && input.pinSource !== "policy") {
+    const pinned = excluded.find((account) => account.id === input.pinnedCredentialId);
+    return pinned ? [pinned] : null;
+  }
+  if (!input.rotationEnabled) {
+    const active = excluded.find((account) => account.id === input.activeCredentialId);
+    return active ? [active] : null;
+  }
+  const allocatable = permitted.filter((account) => account.allocatorEnabled);
+  const allocatableExcluded = allocatable.filter(
+    (account) => codexPlanExcludesModel2(account, input.modelId, input.now)
+  );
+  return allocatable.length > 0 && allocatableExcluded.length === allocatable.length ? allocatableExcluded : null;
+}
+
+// src/activities/agent-turn/errors.ts
 import {
   classifyXaiSubscriptionStreamingTerminalError,
   classifyXaiSubscriptionStreamIdleTimeoutError,
@@ -9142,6 +9902,7 @@ var ESCAPED_MCP_TIMEOUT_RECOVERY_FAILURE_MESSAGE = "MCP request timeout recovery
 var PROVIDER_BACKPRESSURE_DELAY_MS = 6e4;
 var PROVIDER_CONNECTIVITY_BACKOFF_MS = [2e3, 5e3, 15e3, 3e4, 6e4];
 var MAX_AUTOMATIC_PROVIDER_RECOVERIES = PROVIDER_CONNECTIVITY_BACKOFF_MS.length;
+var PROVIDER_RATE_LIMIT_BACKOFF_MS = [1e4, 2e4, 4e4, 6e4, 12e4];
 var POST_COMPACTION_CONTINUATION_EMPTY_CODE = "post_compaction_continuation_empty";
 var PostCompactionContinuationEmptyError = class extends Error {
   code = POST_COMPACTION_CONTINUATION_EMPTY_CODE;
@@ -9159,7 +9920,13 @@ function providerRecoveryResult(input) {
     };
   }
   const providerDelay = input.retryAfterMs !== null && input.retryAfterMs !== void 0 && Number.isFinite(input.retryAfterMs) && input.retryAfterMs > 0 ? Math.ceil(input.retryAfterMs) : null;
-  const continueDelayMs = input.failureCode === "provider_rate_limited" ? providerDelay ?? PROVIDER_BACKPRESSURE_DELAY_MS : input.failureCode === "provider_unavailable" || input.failureCode === "upstream_connectivity_unavailable" || input.failureCode === "sandbox_command_start_unavailable" || input.failureCode === "mcp_transport_timeout" || input.failureCode === "mcp_transport_unavailable" || input.failureCode === POST_COMPACTION_CONTINUATION_EMPTY_CODE ? Math.max(
+  const continueDelayMs = input.failureCode === "provider_rate_limited" ? Math.max(
+    providerDelay ?? PROVIDER_BACKPRESSURE_DELAY_MS,
+    PROVIDER_RATE_LIMIT_BACKOFF_MS[Math.min(
+      Math.max(Math.trunc(input.attemptNumber) - 1, 0),
+      PROVIDER_RATE_LIMIT_BACKOFF_MS.length - 1
+    )]
+  ) : input.failureCode === "provider_unavailable" || input.failureCode === "upstream_connectivity_unavailable" || input.failureCode === "sandbox_command_start_unavailable" || input.failureCode === "mcp_transport_timeout" || input.failureCode === "mcp_transport_unavailable" || input.failureCode === "turn_execution_policy_definition_mismatch" || input.failureCode === POST_COMPACTION_CONTINUATION_EMPTY_CODE ? Math.max(
     providerDelay ?? 0,
     PROVIDER_CONNECTIVITY_BACKOFF_MS[Math.min(
       Math.max(Math.trunc(input.attemptNumber) - 1, 0),
@@ -9207,6 +9974,10 @@ function providerRetryAfterMs(error, nowMs = Date.now()) {
   for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
     const value = current;
     const body = value.error && typeof value.error === "object" ? value.error : null;
+    const milliseconds = Number(
+      headerValue(value.headers, "retry-after-ms") ?? headerValue(value.responseHeaders, "retry-after-ms") ?? headerValue(body?.headers, "retry-after-ms") ?? void 0
+    );
+    if (Number.isFinite(milliseconds) && milliseconds > 0) return Math.ceil(milliseconds);
     const directSeconds = Number(
       value.retry_after_seconds ?? body?.retry_after_seconds ?? value.retryAfterSeconds
     );
@@ -9242,9 +10013,15 @@ function escapedMcpTimeoutRecoveryFailure(input) {
 function preClaimAdmissionFailure(error) {
   const persistenceFailure = isSessionEventPersistenceError(error) ? error : null;
   const retryableCode = retryableDatabaseFailureCode(error);
+  const rejectedClaim = persistenceFailure?.details.stage === "session_attempts.claim" && persistenceFailure.details.retryOutcome === "not_retryable" && !retryableCode;
   const detail = {
-    disposition: persistenceFailure || retryableCode ? "retryable" : "permanent",
-    code: retryableCode ?? persistenceFailure?.details.code ?? "claim_invariant"
+    disposition: rejectedClaim ? "blocked" : persistenceFailure || retryableCode ? "retryable" : "permanent",
+    code: retryableCode ?? persistenceFailure?.details.code ?? "claim_invariant",
+    ...persistenceFailure && rejectedClaim ? {
+      sqlState: persistenceFailure.details.sqlState,
+      reason: persistenceFailure.details.stage === "session_attempts.claim" && persistenceFailure.details.sqlState === "OG001" ? "initiator_membership_required" : persistenceFailure.details.stage === "session_attempts.claim" && persistenceFailure.details.sqlState === "OG002" ? "personal_resource_grant_required" : "database_claim_rejected",
+      retryPolicy: "explicit_recheck"
+    } : {}
   };
   return ApplicationFailure.create({
     message: PRE_CLAIM_FAILURE_MESSAGE,
@@ -9253,20 +10030,122 @@ function preClaimAdmissionFailure(error) {
     details: [detail]
   });
 }
-function retryableDatabaseFailureCode(error) {
-  const persistenceFailure = isSessionEventPersistenceError(error) ? error : null;
-  const sqlState = persistenceFailure?.details.sqlState ?? null;
-  if (sqlState === null && isRetryableDatabaseTransportFailure(error)) {
-    return "db_failure";
+function databaseRecoveryCauseGraph(error) {
+  const graph = /* @__PURE__ */ new Map();
+  const queue = [];
+  let links = 0;
+  const add = (value) => {
+    if (!value || typeof value !== "object" || graph.has(value)) return true;
+    if (graph.size >= 64) return false;
+    graph.set(value, /* @__PURE__ */ new Set());
+    queue.push(value);
+    return true;
+  };
+  if (!add(error)) return null;
+  try {
+    for (const current of queue) {
+      const record = current;
+      const children = Array.isArray(current) ? current : ["cause", "original", "driverError", "error", "errors"].map((key) => record[key]);
+      for (const child of children) {
+        if (++links > 4096 || !add(child)) return null;
+        if (child && typeof child === "object") graph.get(current).add(child);
+      }
+    }
+  } catch {
+    return null;
   }
-  if (!persistenceFailure || !(sqlState === null || sqlState.startsWith("08") || sqlState.startsWith("40") || sqlState.startsWith("53") || sqlState === "55P03" || sqlState === "57014" || sqlState === "57P01" || sqlState === "57P02" || sqlState === "57P03" || sqlState.startsWith("58"))) {
+  return graph;
+}
+function retryableDatabaseFailureCode(error, requireDatabaseProvenance = false) {
+  try {
+    const graph = databaseRecoveryCauseGraph(error);
+    if (!graph) return null;
+    const transports = /* @__PURE__ */ new Set();
+    const boundaries = /* @__PURE__ */ new Set();
+    const ownDatabaseNodes = /* @__PURE__ */ new Set();
+    const codes = /* @__PURE__ */ new Set();
+    for (const node of graph.keys()) {
+      if (isRoutingMutationOutcomeUnknownError(node)) return null;
+      const record = node;
+      if (requireDatabaseProvenance ? isRunningTurnDatabaseTransportFailure(record) : isRetryableDatabaseTransportFailure({ code: record.code, errno: record.errno }))
+        transports.add(node);
+      const sqlState = isSessionEventPersistenceError(node) ? node.details.sqlState : record.name === "PostgresError" && typeof record.code === "string" ? record.code : null;
+      if (requireDatabaseProvenance ? isRunningTurnDatabaseConnectionSqlState(sqlState) : isDatabaseConnectionSqlState(sqlState))
+        transports.add(node);
+      if (node instanceof DrizzleQueryError || isSessionEventPersistenceError(node)) {
+        const queue = [node];
+        for (const source of queue) {
+          if (ownDatabaseNodes.has(source)) continue;
+          ownDatabaseNodes.add(source);
+          queue.push(...graph.get(source));
+        }
+      }
+    }
+    const hasOwnTransport = (boundary) => {
+      const seen = /* @__PURE__ */ new Set();
+      const queue = [boundary];
+      for (const node of queue) {
+        if (seen.has(node)) continue;
+        seen.add(node);
+        if (transports.has(node)) return true;
+        queue.push(...graph.get(node));
+      }
+      return false;
+    };
+    for (const node of graph.keys()) {
+      const record = node;
+      if (node instanceof DrizzleQueryError) {
+        boundaries.add(node);
+        if (hasOwnTransport(node)) codes.add("db_failure");
+      }
+      const typed = isSessionEventPersistenceError(node);
+      if (!typed && record.name !== "PostgresError") continue;
+      boundaries.add(node);
+      const sqlState = typed ? node.details.sqlState : typeof record.code === "string" ? record.code : null;
+      const connectionOutage = requireDatabaseProvenance ? isRunningTurnDatabaseConnectionSqlState(sqlState) : isDatabaseConnectionSqlState(sqlState);
+      const code = typed ? retryablePersistenceFailureCode(sqlState) : connectionOutage || isRetryablePersistenceSqlState(sqlState) ? databaseFailureCode(sqlState) : null;
+      if (!code || requireDatabaseProvenance && !connectionOutage && !(sqlState === null && hasOwnTransport(node)))
+        return null;
+      if (!requireDatabaseProvenance || ownDatabaseNodes.has(node)) codes.add(code);
+    }
+    if (!requireDatabaseProvenance && boundaries.size === 0 && transports.size > 0)
+      codes.add("db_failure");
+    for (const code of ["db_failure", "db_deadlock", "db_serialization_failure"])
+      if (codes.has(code)) return code;
+    return null;
+  } catch {
     return null;
   }
-  return persistenceFailure.details.code;
+}
+var RUNNING_TURN_DATABASE_TRANSPORT_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "CONNECT_TIMEOUT"
+]);
+function isRunningTurnDatabaseTransportFailure(record) {
+  return [record.code, record.errno].some(
+    (code) => typeof code === "string" && RUNNING_TURN_DATABASE_TRANSPORT_CODES.has(code)
+  );
+}
+function isRunningTurnDatabaseConnectionSqlState(sqlState) {
+  return sqlState !== null && (/^08[0-9A-Z]{3}$/.test(sqlState) || ["57P01", "57P02", "57P03"].includes(sqlState));
+}
+function isDatabaseConnectionSqlState(sqlState) {
+  return sqlState !== null && (sqlState.startsWith("08") || ["57P01", "57P02", "57P03"].includes(sqlState));
+}
+function retryablePersistenceFailureCode(sqlState) {
+  if (!(sqlState === null || sqlState.startsWith("08") || isRetryablePersistenceSqlState(sqlState) || sqlState.startsWith("53") || sqlState === "55P03" || sqlState === "57014" || sqlState === "57P01" || sqlState === "57P02" || sqlState === "57P03" || sqlState.startsWith("58"))) {
+    return null;
+  }
+  return databaseFailureCode(sqlState);
 }
 function postClaimDatabaseRecoveryFailure(input) {
-  const code = retryableDatabaseFailureCode(input.error);
-  if (!code || input.executionGeneration < 1) return null;
+  const code = retryableDatabaseFailureCode(input.error, input.requireDatabaseProvenance);
+  if (!code || input.executionGeneration < 1 || input.requireDatabaseProvenance && code !== "db_failure")
+    return null;
+  if (input.sandboxSetupOutcomeUnknown && input.sandboxSetupRecoveryExhausted || (input.sandboxSetupOutcomeUnknown || input.sandboxSetupRecoveryExhausted) && input.providerRecovery) {
+    return null;
+  }
   if (input.providerRecovery && (!Number.isSafeInteger(input.providerRecovery.providerRecoveryCount) || input.providerRecovery.providerRecoveryCount <= 0 || input.providerRecovery.providerRecoveryCount > MAX_AUTOMATIC_PROVIDER_RECOVERIES || !/^[a-z][a-z0-9_]{0,63}$/.test(input.providerRecovery.failureCode))) {
     return null;
   }
@@ -9275,6 +10154,8 @@ function postClaimDatabaseRecoveryFailure(input) {
     triggerEventId: input.triggerEventId,
     executionGeneration: input.executionGeneration,
     code,
+    ...input.sandboxSetupOutcomeUnknown ? { sandboxSetupOutcomeUnknown: true } : {},
+    ...input.sandboxSetupRecoveryExhausted ? { sandboxSetupRecoveryExhausted: true } : {},
     ...input.providerRecovery ? {
       providerFailureCode: input.providerRecovery.failureCode,
       providerRecoveryCount: input.providerRecovery.providerRecoveryCount
@@ -9319,6 +10200,20 @@ function sandboxLifecycleTransitionDiagnostic(error) {
   }
   return null;
 }
+function modelPreparationFailureEventPayload(error, durationMs) {
+  const transition = sandboxLifecycleTransitionDiagnostic(error);
+  return {
+    phase: "model_preparation",
+    durationMs: Math.max(0, Math.round(durationMs)),
+    expectedTransition: transition !== null,
+    ...transition ? {
+      failureCategory: "drain_capture_wait",
+      failureStage: "lifecycle_wait",
+      failureCode: transition.reason,
+      retryable: true
+    } : {}
+  };
+}
 function sandboxRouteTransitionCode(error) {
   const pending = [error];
   const seen = /* @__PURE__ */ new WeakSet();
@@ -9330,6 +10225,9 @@ function sandboxRouteTransitionCode(error) {
     seen.add(current);
     try {
       const record = current;
+      if ((current instanceof SandboxCapabilitiesChangedError || record.name === "SandboxCapabilitiesChangedError") && record.code === "native_capabilities_changed_this_attempt") {
+        return "native_capabilities_changed_this_attempt";
+      }
       if ((current instanceof ActiveBackendUnresolvableError2 || record.name === "ActiveBackendUnresolvableError") && record.code === "home_unavailable_this_turn") {
         return "home_unavailable_this_turn";
       }
@@ -9384,22 +10282,51 @@ function safeErrorForTelemetry(error) {
   safe.origin = diagnostic.origin;
   return safe;
 }
+var COMPACTION_PROVIDER_REJECTION_GUIDANCE = "The provider refused this exact request, so repeating it fails the same way until the conversation changes. If a new message fails again, start a new session.";
 function compactionFailureReasonFromError(error) {
+  const rejection = compactionProviderRejection(error);
+  if (rejection) {
+    return compactionFailureReason(
+      `the model provider rejected the compaction request (${describeCompactionProviderRejection(rejection)}). Active history was preserved. ${COMPACTION_PROVIDER_REJECTION_GUIDANCE}`
+    );
+  }
+  const quota = classifyProviderQuotaExhaustionError(error);
+  if (quota) {
+    return compactionFailureReason(
+      `${providerQuotaExhaustedMessage(quota.scope)} Active history was preserved.`
+    );
+  }
   if (error instanceof CompactionProviderResponseError || error instanceof EmptyCompactionSummaryError) {
     return compactionFailureReason(error.message);
   }
   const errorName = error instanceof Error && error.name ? error.name : "unknown error";
   return compactionFailureReason(`unexpected ${errorName}`);
 }
+function compactionFailureTurnEventPayload(error, overrides = {}) {
+  const rejection = compactionProviderRejection(error);
+  const quota = rejection ? null : classifyProviderQuotaExhaustionError(error);
+  return {
+    error: overrides.error ?? compactionFailureReasonFromError(error),
+    code: "context_compaction_failed",
+    retryable: false,
+    recovery: "user_message",
+    compacted: false,
+    ...rejection ? { providerRejection: rejection } : {},
+    ...quota ? { quotaScope: quota.scope } : {}
+  };
+}
 function isCompactionSummaryFailure(error) {
   return error instanceof CompactionProviderResponseError || error instanceof EmptyCompactionSummaryError;
 }
 function shouldRecoverCompactionProviderFailure(error) {
   if (!(error instanceof CompactionProviderResponseError)) return false;
   if (isCodexTransportError(error) && classifyCodexUsageLimitError(error)) return true;
+  if (classifyCodexEncryptedArtifactRejection(error)) return true;
+  if (classifyCodexEntitlementRejection(error)) return true;
   return agentRunFailurePayload(error).retryable === true;
 }
 function classifyContextWindowOverflowError(error) {
+  if (isProviderSafetyRefusal(error)) return null;
   const fields = collectErrorStrings(error);
   const matched = fields.find(
     (value) => /context[_\s-]*length[_\s-]*exceeded/i.test(value) || /exceeds?\s+(?:the\s+)?context\s+window/i.test(value) || /maximum\s+context\s+length/i.test(value) || /context\s+window[^.]*exceed/i.test(value)
@@ -9445,6 +10372,7 @@ function collectErrorStrings(value, seen = /* @__PURE__ */ new WeakSet()) {
   }
   seen.add(value);
   const out = [];
+  if (value instanceof ResponsesStreamingTerminalError) out.push(value.detail);
   const record = value;
   for (const key of ["message", "code", "type", "name", "param"]) {
     const field = record[key];
@@ -9462,8 +10390,11 @@ function isExactStatuslessUpstreamConnectivityMessage(message) {
   return message.trim().toLowerCase() === STATUSLESS_UPSTREAM_CONNECTIVITY_MESSAGE;
 }
 function providerSafetyRefusalDiagnostic(error) {
+  if (error instanceof ResponsesStreamingTerminalError) {
+    return error.category === "safety" ? error.detail : void 0;
+  }
   return collectErrorStrings(error).find(
-    (value) => /^(?:content_policy_violation|content_filter|safety_violation|bio_policy|cyber_policy)$/.test(
+    (value) => /^(?:content_policy_violation|content_filter|safety_violation|bio_policy|cyber_policy|misalignment_policy_violation)$/.test(
       value
     ) || /\bthis request was blocked by our safety systems\b/i.test(value)
   );
@@ -9472,6 +10403,9 @@ function isProviderSafetyRefusal(error) {
   return providerSafetyRefusalDiagnostic(error) !== void 0;
 }
 function isTransientProviderError(error) {
+  if (error instanceof ResponsesStreamingTerminalError) {
+    return error.category === "unavailable";
+  }
   if (isProviderSafetyRefusal(error)) return false;
   const status = typeof error === "object" && error !== null ? Number(
     error.status ?? error.statusCode
@@ -9491,6 +10425,13 @@ function isTransientProviderError(error) {
     message
   );
 }
+function hasCodexUsageLimitType(error) {
+  return collectErrorStrings(error).some((value) => value.includes(CODEX_USAGE_LIMIT_ERROR_TYPE));
+}
+function classifyProviderQuotaExhaustionError(error) {
+  if (isCodexTransportError(error) || isXaiSubscriptionTransportError(error)) return null;
+  return classifyProviderQuotaError(error);
+}
 function classifyXaiCredentialFailure(error) {
   if (isProviderSafetyRefusal(error)) return null;
   let relogin = error;
@@ -9545,12 +10486,50 @@ function findPostgresDriverError(error) {
   }
   return null;
 }
+function isRawDatabaseQueryError(error) {
+  return error instanceof Error && "query" in error && typeof error.query === "string" && "params" in error && Array.isArray(error.params);
+}
+function anthropicRequestDiagnostic(error) {
+  if (error instanceof AnthropicRequestError) return error;
+  return error instanceof Error && error.cause instanceof AnthropicRequestError ? error.cause : void 0;
+}
 function agentRunFailurePayload(error, options = {}) {
+  const failure = baseAgentRunFailurePayload(error, options);
+  const diagnostic = materializationVerificationDiagnostic(error);
+  const anthropic = anthropicRequestDiagnostic(error);
+  if (anthropic) {
+    const authenticationRejected = anthropic.status === 401 && (error === anthropic || error instanceof Error && error.status === 401);
+    return {
+      ...failure,
+      code: failure.code ?? (authenticationRejected ? "anthropic_authentication_error" : anthropic.code),
+      retryable: failure.retryable ?? false,
+      ...anthropic.detail ? { detail: anthropic.detail } : {},
+      ...anthropic.request_id ? { requestId: anthropic.request_id } : {}
+    };
+  }
+  return diagnostic ? { ...failure, materializationDiagnostic: diagnostic } : failure;
+}
+function agentRunRecoveryFailurePayload(error, failure) {
+  if (!anthropicRequestDiagnostic(error)) return failure;
+  const recovery = { ...failure };
+  delete recovery.detail;
+  return recovery;
+}
+function baseAgentRunFailurePayload(error, options = {}) {
+  if (error instanceof SandboxMaterializationVerificationError) {
+    return {
+      error: error.message,
+      code: error.code,
+      retryable: false,
+      materializationDiagnostic: error.diagnostic
+    };
+  }
   if (error instanceof RetainedAttachmentTransportLimitError) {
     return { error: error.message, code: "retained_attachment_transport_limit", retryable: false };
   }
   if (error instanceof MandatoryHistoryPersistenceError) {
-    const underlying = isSessionEventPersistenceError(error.cause) ? agentRunFailurePayload(error.cause, options) : {
+    const databaseFailure = isSessionEventPersistenceError(error.cause) || findPostgresDriverError(error.cause) !== null || isRawDatabaseQueryError(error.cause);
+    const underlying = databaseFailure ? agentRunFailurePayload(error.cause, options) : {
       error: error.cause instanceof Error ? error.cause.message : String(error.cause)
     };
     return {
@@ -9558,6 +10537,29 @@ function agentRunFailurePayload(error, options = {}) {
       historyPersistenceStage: error.stage
     };
   }
+  const postgresDriverError = findPostgresDriverError(error);
+  const rawOrmFailure = isRawDatabaseQueryError(error);
+  if ((postgresDriverError || rawOrmFailure) && !isSessionEventPersistenceError(error)) {
+    const database = safeDatabaseErrorFacts(postgresDriverError ?? error);
+    const sqlState = postgresDriverError ? nestedPostgresSqlState(postgresDriverError) : null;
+    return {
+      error: "Opengeni encountered a database error.",
+      code: databaseFailureCode(sqlState),
+      sqlState,
+      ...Object.keys(database).length > 0 ? { database } : {}
+    };
+  }
+  if (error instanceof ClaudeSubscriptionConnectionUnavailable) {
+    return { error: error.message, code: error.code, retryable: false };
+  }
+  if (error instanceof AnthropicProviderRejection) {
+    return {
+      error: error.message,
+      code: error.code === "content_policy_violation" ? "provider_safety_refusal" : error.code,
+      retryable: false,
+      ...error.request_id ? { requestId: error.request_id } : {}
+    };
+  }
   const safetyRefusalDiagnostic = providerSafetyRefusalDiagnostic(error);
   if (safetyRefusalDiagnostic !== void 0) {
     return {
@@ -9567,6 +10569,28 @@ function agentRunFailurePayload(error, options = {}) {
       detail: safetyRefusalDiagnostic
     };
   }
+  if (error instanceof ResponsesStreamingTerminalError) {
+    const quota2 = error.category === "unknown" || error.category === "rate_limit" ? classifyProviderQuotaExhaustionError({
+      code: error.code,
+      error: { code: error.code, type: error.type, message: error.detail },
+      retryAfterSeconds: error.retryAfterSeconds
+    }) : null;
+    if (quota2) {
+      return {
+        error: providerQuotaExhaustedMessage(quota2.scope),
+        code: PROVIDER_QUOTA_EXHAUSTED_CODE,
+        retryable: false,
+        quotaScope: quota2.scope,
+        detail: error.detail
+      };
+    }
+    return {
+      error: error.category === "rate_limit" ? "Model provider rate limit hit. Try again in a minute or lower the reasoning effort." : error.category === "unavailable" ? "The model provider is temporarily unavailable. The same turn will retry after a short delay." : "The model provider rejected the response. Automatic retries stopped.",
+      code: error.category === "rate_limit" ? "provider_rate_limited" : error.category === "unavailable" ? "provider_unavailable" : "provider_request_rejected",
+      retryable: error.category === "rate_limit" || error.category === "unavailable",
+      detail: error.detail
+    };
+  }
   const message = error instanceof Error ? error.message : String(error);
   const status = typeof error === "object" && error !== null ? Number(
     error.status ?? error.statusCode
@@ -9595,9 +10619,23 @@ function agentRunFailurePayload(error, options = {}) {
       retryable: true
     };
   }
-  if (isModalTaskExecStartDnsResolutionError(error)) {
+  if (isProviderCommandObservationUnavailableError(error)) {
     return {
-      error: "The managed sandbox command transport was temporarily unreachable before the command started. The same turn will retry after a short delay.",
+      error: "A managed sandbox command cannot be observed. Its exact invocation and writer remain retained; setup is blocked without replay until the incomplete operation can be reconciled.",
+      code: "sandbox_command_observation_unavailable",
+      retryable: false
+    };
+  }
+  if (isModalCommandStartOutcomeUnknownError(error)) {
+    return {
+      error: "A managed sandbox command has an unknown outcome. Its original invocation remains fenced; setup is blocked without replay until the incomplete operation can be reconciled.",
+      code: "sandbox_command_start_outcome_unknown",
+      retryable: false
+    };
+  }
+  if (!isRoutingMutationOutcomeUnknownError(error) && isModalTaskExecStartPreDispatchUnavailableError(error)) {
+    return {
+      error: "The managed sandbox command router was not ready before the command was sent. The same turn will retry after a short delay.",
       code: "sandbox_command_start_unavailable",
       retryable: true
     };
@@ -9653,8 +10691,26 @@ function agentRunFailurePayload(error, options = {}) {
       ...Object.keys(details.database).length > 0 ? { database: details.database } : {}
     };
   }
+  if (error instanceof CodexPlanEntitlementError) {
+    return error.payload;
+  }
+  const entitlementRejection = classifyCodexEntitlementRejection(error);
+  if (entitlementRejection) {
+    return entitlementRejection.evidence === "plan_entitlement" ? codexPlanEntitlementFailurePayload({
+      accountLabel: null,
+      planType: null,
+      planChanged: false,
+      modelId: null,
+      rejection: entitlementRejection
+    }) : codexRequestRejectedFailurePayload({
+      accountLabel: null,
+      planType: null,
+      rejection: entitlementRejection,
+      planChecked: false
+    });
+  }
   const usageLimit = classifyCodexUsageLimitError(error);
-  if (usageLimit) {
+  if (usageLimit && (isCodexTransportError(error) || hasCodexUsageLimitType(error))) {
     return codexUsageLimitFailurePayload(usageLimit, message);
   }
   const codexTimeout = classifyCodexResponseTimeoutError(error, {
@@ -9699,7 +10755,25 @@ function agentRunFailurePayload(error, options = {}) {
       retryable: true
     };
   }
-  if (status === 429 || code === "rate_limit_exceeded" || /(?:too many requests|rate.?limit|\b429\b)/i.test(message)) {
+  if (status === 402 && code === "anthropic_billing_error") {
+    return {
+      error: "Claude could not bill this request. Check the account's billing and payment details.",
+      code: "provider_billing_error",
+      retryable: false,
+      ...message ? { detail: message } : {}
+    };
+  }
+  const quota = classifyProviderQuotaExhaustionError(error);
+  if (quota) {
+    return {
+      error: providerQuotaExhaustedMessage(quota.scope),
+      code: PROVIDER_QUOTA_EXHAUSTED_CODE,
+      retryable: false,
+      quotaScope: quota.scope,
+      ...message ? { detail: message } : {}
+    };
+  }
+  if (status === 429 || (status === void 0 || !Number.isFinite(status)) && (code === "rate_limit_exceeded" || /(?:too many requests|rate.?limit|\b429\b)/i.test(message))) {
     return {
       error: "Model provider rate limit hit. Try again in a minute or lower the reasoning effort.",
       code: "provider_rate_limited",
@@ -9710,30 +10784,18 @@ function agentRunFailurePayload(error, options = {}) {
   if (isTransientProviderError(error)) {
     if (isExactStatuslessUpstreamConnectivityMessage(message)) {
       return {
-        error: "OpenGeni could not reach an upstream service. The same turn will retry after a short delay.",
+        error: "Opengeni could not reach an upstream service. The same turn will retry after a short delay.",
         code: "upstream_connectivity_unavailable",
         retryable: true
       };
     }
     return { error: message, code: "provider_unavailable", retryable: true };
   }
-  const postgresDriverError = findPostgresDriverError(error);
-  if (postgresDriverError) {
-    const database = safeDatabaseErrorFacts(postgresDriverError);
-    const sqlState = nestedPostgresSqlState(postgresDriverError);
-    if (sqlState !== null || Object.keys(database).length > 0) {
-      return {
-        error: message,
-        sqlState,
-        ...Object.keys(database).length > 0 ? { database } : {}
-      };
-    }
-  }
   return { error: message };
 }
 var CODEX_ALLOWANCE_FALLBACK_MS = 5 * 60 * 6e4;
 function codexCredentialCooldownUntil(failure, account, now) {
-  if (failure.kind === "auth" || failure.kind === "forbidden") {
+  if (failure.kind === "auth" || failure.kind === "forbidden" || failure.kind === "plan_entitlement") {
     return null;
   }
   const providerReset = failure.cooldownSeconds !== null && Number.isFinite(failure.cooldownSeconds) && failure.cooldownSeconds > 0 ? new Date(now.getTime() + Math.ceil(failure.cooldownSeconds) * 1e3) : null;
@@ -9766,6 +10828,9 @@ function classifyCodexCredentialFailure(error) {
   if (!isCodexTransportError(error)) {
     return null;
   }
+  if (classifyCodexEntitlementRejection(error)) {
+    return null;
+  }
   const usageLimit = classifyCodexUsageLimitError(error);
   if (usageLimit) {
     return { kind: "quota", cooldownSeconds: usageLimit.resetsInSeconds };
@@ -9825,6 +10890,28 @@ function codexUsageLimitFailurePayload(info, detail, opts) {
   };
 }
 var CODEX_USAGE_LIMIT_MAX_RESUME_MS = 60 * 6e4;
+function classifyClaudeCredentialFailure(error) {
+  if (isProviderSafetyRefusal(error)) return null;
+  let current = error;
+  for (let depth = 0; depth < 6 && current instanceof Error; depth++) {
+    if (current instanceof ClaudeSubscriptionReconnectRequired)
+      return { kind: "auth", cooldownMs: null };
+    if (current instanceof AnthropicRequestError && current.status === 401)
+      return {
+        kind: "auth",
+        cooldownMs: null,
+        ...current.request_id ? { requestId: current.request_id } : {}
+      };
+    if (current instanceof AnthropicRequestError && current.status === 429)
+      return {
+        kind: "rate_limit",
+        cooldownMs: providerRetryAfterMs(current) ?? PROVIDER_BACKPRESSURE_DELAY_MS,
+        ...current.request_id ? { requestId: current.request_id } : {}
+      };
+    current = current.cause;
+  }
+  return null;
+}
 
 export {
   createSharedActivityServices,
@@ -9841,20 +10928,23 @@ export {
   signalPendingCodexCapacityWakeTargets,
   armAndReconcileCodexCapacityWait,
   createCodexCapacityActivities,
+  agentRunAdmissionDenial,
   createDocumentActivities,
+  turnCredentialRestriction,
   createGoalActivities,
   withFirstPartyTools,
   createKnowledgeSourceSyncActivities,
   rigProviderImageSourceImage,
-  settingsWithPackSandboxImage,
-  resolveWorkspacePackRuntime,
   createRuntimeBatcher,
   currentActivityContext,
   startActivityHeartbeat,
   nextStreamEvent,
+  warnDrainSnapshotFailure,
+  publishDurableSessionEvents2 as publishDurableSessionEvents,
   persistWorkspaceArchiveCandidate,
   putVersion1TarArchiveOrInline,
   sandboxLeaseHolderIdForAttempt,
+  createFreshSandboxReadinessReplacementBudget,
   waitForWarmSnapshot,
   maybePersistWarmWorkspaceSnapshot,
   resumeBoxForTurn,
@@ -9880,9 +10970,17 @@ export {
   incidentTelemetryAuthorityFence,
   resolveIncidentTelemetryResponderMetadata,
   validateIncidentTelemetrySystemUpdateAuthority,
+  checkpointHistoryBeforeProviderDispatch,
+  createClaudeUsageObserver,
   projectRejectedProviderArtifacts,
   createModelHistoryAttachmentProjector,
   turnInput,
+  codexAccountDisplayLabel,
+  codexPlanEntitlementFailurePayload,
+  codexRequestRejectedFailurePayload,
+  CodexPlanEntitlementError,
+  assessCodexPlanEntitlement,
+  codexPlanEntitlementAdmissionBlock,
   SandboxDeadlineRotationError,
   turnOperationCancellationFailure,
   throwIfTurnOperationCancelled,
@@ -9920,19 +11018,23 @@ export {
   postClaimDatabaseRecoveryFailure,
   isWorkerShutdownCancellation,
   sandboxLifecycleTransitionDiagnostic,
+  modelPreparationFailureEventPayload,
   sandboxRouteTransitionCode,
   compactionFailureReason,
   safeErrorDiagnostic,
   safeErrorForTelemetry,
   compactionFailureReasonFromError,
+  compactionFailureTurnEventPayload,
   isCompactionSummaryFailure,
   shouldRecoverCompactionProviderFailure,
   classifyContextWindowOverflowError,
   classifyXaiCredentialFailure,
   agentRunFailurePayload,
+  agentRunRecoveryFailurePayload,
   codexCredentialCooldownUntil,
   classifyCodexCredentialFailure,
   codexUsageLimitFailurePayload,
-  CODEX_USAGE_LIMIT_MAX_RESUME_MS
+  CODEX_USAGE_LIMIT_MAX_RESUME_MS,
+  classifyClaudeCredentialFailure
 };
-//# sourceMappingURL=chunk-CYITU5UH.js.map
+//# sourceMappingURL=chunk-LJX7Z2KP.js.map