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

package/dist/{activities-turn-FQ5OO2WW.js → activities-turn-TESOIOEX.js}

@@ -83,6 +83,7 @@ import {
   signalPendingCodexCapacityWakeTargets,
   startActivityHeartbeat,
   throwIfTurnOperationCancelled,
+  turnCredentialRestriction,
   turnFinalizerCancellationSignal,
   turnInput,
   turnOperationCancellationFailure,
@@ -94,7 +95,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-RZAAGRFQ.js";
+} from "./chunk-4PJTUBWQ.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -126,7 +127,7 @@ import {
   runtimeMetricsHooksForObservability,
   sandboxAutomaticRecoveryOutcome,
   turnLifecycleMetricsFor
-} from "./chunk-IJZU752L.js";
+} from "./chunk-YG27NEMX.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -139,10 +140,13 @@ import {
   getSessionAuthorityProjection,
   readActiveSandbox as readActiveSandbox3,
   getWorkspaceCredentialProvider,
-  loadClaudeSubscriptionUsageCredential
+  loadClaudeSubscriptionUsageCredential as loadClaudeSubscriptionUsageCredential2,
+  resolveClaudeSubscriptionCredential,
+  ClaudeSubscriptionReconnectRequired
 } from "@opengeni/db";
+import { resolveAgentToolFamilies as resolveAgentToolFamilies3 } from "@opengeni/contracts";
 import {
-  assertModelConnectionAllowsTurn,
+  assertModelConnectionAllowsTurn as assertModelConnectionAllowsTurn2,
   freezeAgentLearningPolicy as freezeAgentLearningPolicy2,
   recoverLegacyKnowledgeConfirmations,
   withSessionRlsActorContext
@@ -161,6 +165,7 @@ import {
 import {
   REMOTE_COMPACTION_V2_BETA_FEATURE,
   REMOTE_COMPACTION_V2_IMPLEMENTATION as REMOTE_COMPACTION_V2_IMPLEMENTATION2,
+  awaitModelCallAdmission,
   materializeSandboxFileDownloads as materializeSandboxFileDownloads3,
   sandboxFileDownloadFailureNote
 } from "@opengeni/runtime";
@@ -191,6 +196,17 @@ async function createClaudeUsageObserver(providers, latest, readCredential) {
       (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 [
@@ -205,7 +221,7 @@ async function createClaudeUsageObserver(providers, latest, readCredential) {
     })
   );
   const captured = new Map(bindings.filter((binding) => binding !== null));
-  return (providerId, response) => {
+  const observe2 = (providerId, response) => {
     const binding = captured.get(providerId);
     if (!binding) return;
     const { scope, ...identity } = binding;
@@ -230,6 +246,16 @@ async function createClaudeUsageObserver(providers, latest, readCredential) {
         ...response.status === 401 ? { refresh: { status: "reconnect", checkedAt: (/* @__PURE__ */ new Date()).toISOString() } } : {}
       });
   };
+  return Object.assign(observe2, {
+    binding(providerId) {
+      return captured.get(providerId);
+    },
+    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/run.ts
@@ -4435,13 +4461,16 @@ async function runCapture(input, ctx, startedAt, signal, stage, ownership) {
       "error.message": gcError instanceof Error ? gcError.message : String(gcError)
     });
   }
-  const durationMs = Date.now() - startedAt;
+  recordWorkspaceCaptureCompleted(observability, Date.now() - startedAt);
+}
+function recordWorkspaceCaptureCompleted(observability, durationMs) {
   observability.incrementCounter({
     name: "opengeni_workspace_capture_total",
     labels: { result: "ok" }
   });
   observability.observeHistogram({
-    name: "opengeni_workspace_capture_duration_seconds",
+    name: "opengeni_workspace_capture_revision_duration_seconds",
+    help: "Turn-end logical workspace revision capture duration for committed revisions.",
     value: durationMs / 1e3
   });
 }
@@ -5245,7 +5274,10 @@ import {
   isSessionEventPersistenceError as isSessionEventPersistenceError2
 } from "@opengeni/db";
 import { publishDurableSessionEvents as publishDurableSessionEvents2 } from "@opengeni/events";
-import { maxTurnsExceededRunState } from "@opengeni/runtime";
+import {
+  maxTurnsExceededRunState,
+  isModalTaskExecStartPreDispatchUnavailableError
+} from "@opengeni/runtime";
 import { ApplicationFailure, CancelledFailure } from "@temporalio/activity";
 import { TurnExecutionPolicyDefinitionMismatchError } from "@opengeni/config";
 import {
@@ -5256,7 +5288,7 @@ import {
 } from "@opengeni/codex";
 
 // src/activities/agent-turn/admission.ts
-import { getBillingBalance, sumUsageQuantity } from "@opengeni/db";
+import { checkWorkspaceAllowance, getBillingBalance, sumUsageQuantity } from "@opengeni/db";
 import {
   configuredStaticUsageLimits
 } from "@opengeni/config";
@@ -5901,13 +5933,48 @@ function stableInteractionInterventionUuid(namespace, sessionId, turnId, toolCal
   return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
 }
 var BudgetExhaustedError = class extends Error {
-  constructor(message, serializedRunState) {
+  constructor(message, serializedRunState, allowance = null) {
     super(message);
     this.serializedRunState = serializedRunState;
+    this.allowance = allowance;
     this.name = "BudgetExhaustedError";
   }
 };
-async function ensureRunAllowed(settings, db, accountId, workspaceId, isExternallyBilledTurn, entitlements, chargesOpenGeniCredits = !isExternallyBilledTurn, countsTowardTokenCap = !isExternallyBilledTurn) {
+var AllowanceExhaustedError = class extends Error {
+  constructor(refusal) {
+    super(refusal.message);
+    this.refusal = refusal;
+    this.name = "AllowanceExhaustedError";
+  }
+  code = "allowance_exhausted";
+};
+async function ensureRunAllowedBetweenModelCalls(input) {
+  try {
+    await ensureRunAllowed(
+      input.settings,
+      input.db,
+      input.accountId,
+      input.workspaceId,
+      input.isExternallyBilledTurn,
+      input.entitlements,
+      input.chargesOpenGeniCredits,
+      input.countsTowardTokenCap,
+      input.initiatingHumanSubjectId
+    );
+  } catch (limitError) {
+    let serializedRunState = null;
+    try {
+      serializedRunState = input.serializedRunState?.() ?? null;
+    } catch {
+    }
+    throw new BudgetExhaustedError(
+      limitError instanceof Error ? limitError.message : String(limitError),
+      serializedRunState,
+      limitError instanceof AllowanceExhaustedError ? limitError.refusal : null
+    );
+  }
+}
+async function ensureRunAllowed(settings, db, accountId, workspaceId, isExternallyBilledTurn, entitlements, chargesOpenGeniCredits = !isExternallyBilledTurn, countsTowardTokenCap = !isExternallyBilledTurn, initiatingHumanSubjectId = null) {
   if (chargesOpenGeniCredits && entitlements && (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed")) {
     const decision = await entitlements.admitRun({
       accountId,
@@ -5924,6 +5991,14 @@ async function ensureRunAllowed(settings, db, accountId, workspaceId, isExternal
       throw new Error("insufficient OpenGeni credits");
     }
   }
+  if (chargesOpenGeniCredits) {
+    const refusal = await checkWorkspaceAllowance(db, {
+      accountId,
+      workspaceId,
+      subjectId: initiatingHumanSubjectId
+    });
+    if (refusal) throw new AllowanceExhaustedError(refusal);
+  }
   if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
     const limits = configuredStaticUsageLimits(settings);
     if (limits.maxMonthlyAgentRunsPerWorkspace) {
@@ -6998,19 +7073,22 @@ async function settleTurnFailure(deps) {
     await historySink.reconcileConversationTruth();
     if (!await eventing.settle({
       events: [
+        ...error51.allowance ? [{ type: "usage.exhausted", payload: error51.allowance }] : [],
         {
           type: "turn.completed",
           payload: {
             output: "",
             segmentLimit: "budget_exhausted",
-            detail: error51.message
+            detail: error51.message,
+            ...error51.allowance ?? {}
           }
         },
         { type: "session.status.changed", payload: { status: "idle" } }
       ],
       turnStatus: "completed",
       sessionStatus: "idle",
-      activeTurnId: null
+      activeTurnId: null,
+      ...error51.allowance ? { allowanceGoalPause: { rationale: error51.allowance.message } } : {}
     })) {
       return claimedResult({ status: "cancelled" });
     }
@@ -7078,10 +7156,12 @@ async function settleTurnFailure(deps) {
     }
   }
   const earlyDefinitionMismatch = error51 instanceof TurnExecutionPolicyDefinitionMismatchError && !attempt.modelRequestStarted && !eventing.turnStartedPublished && !!attempt.turnId && !!attempt.triggerEventId && attempt.executionGeneration > 0;
+  const earlyCommandStartUnavailable = isModalTaskExecStartPreDispatchUnavailableError(error51) && !attempt.modelRequestStarted && !eventing.turnStartedPublished && !!attempt.turnId && !!attempt.triggerEventId && attempt.executionGeneration > 0;
+  const earlyRecoverableSetup = earlyDefinitionMismatch || earlyCommandStartUnavailable;
   let failure2 = earlyDefinitionMismatch ? { error: error51.message, code: error51.code, retryable: true } : codexTerminalFailure ?? agentRunFailurePayload(error51, {
     isCodexTurn: billingState.isCodexTurn
   });
-  if (attempt.turnId && (earlyDefinitionMismatch || failure2.retryable && eventing.publish && eventing.turnStartedPublished)) {
+  if (attempt.turnId && (earlyRecoverableSetup || failure2.retryable && eventing.publish && eventing.turnStartedPublished)) {
     const nextProviderRecoveryCount = attempt.providerRecoveryCount + 1;
     const recoveryResult = providerRecoveryResult({
       failureCode: failure2.code,
@@ -7090,7 +7170,7 @@ async function settleTurnFailure(deps) {
     });
     try {
       if (recoveryResult.status === "recovering") {
-        if (!earlyDefinitionMismatch) {
+        if (!earlyRecoverableSetup) {
           await flushRuntimeBatcher();
           await historySink.reconcileConversationTruth({ requireDurable: true });
         }
@@ -7121,13 +7201,13 @@ async function settleTurnFailure(deps) {
         return claimedResult(recoveryResult);
       }
       failure2 = providerRecoveryExhaustedFailure(failure2, recoveryResult);
-      if (earlyDefinitionMismatch) {
+      if (earlyRecoverableSetup) {
         control.activityStatus = "failed";
         control.turnMetricOutcome = "failed";
         control.activityError = error51;
         throw ApplicationFailure.create({
-          message: `${error51.message}. Automatic same-turn configuration recovery exhausted after ${recoveryResult.providerRecoveryCount} retries.`,
-          type: "TurnExecutionPolicyDefinitionMismatchError",
+          message: earlyDefinitionMismatch ? `${error51.message}. Automatic same-turn configuration recovery exhausted after ${recoveryResult.providerRecoveryCount} retries.` : failure2.error,
+          type: earlyDefinitionMismatch ? "TurnExecutionPolicyDefinitionMismatchError" : "SandboxCommandStartUnavailableError",
           nonRetryable: true
         });
       }
@@ -7216,6 +7296,9 @@ async function settleTurnFailure(deps) {
 // src/activities/agent-turn/stream-attempt.ts
 import { measureMcpPhase, withMcpCallIdentity } from "@opengeni/observability";
 import {
+  appendSessionHistoryItems as appendSessionHistoryItems3,
+  sessionTurnFinalReplyFacts,
+  sessionTurnHasFinalReplyNudge,
   getSessionHumanInputRequest,
   getWorkspace,
   recordUsageEvent as recordUsageEvent3,
@@ -7665,7 +7748,8 @@ async function resolveTurnSandboxAccess(sandboxState, sdkOwnedSandboxSession, un
 // src/activities/open-suffix-resume.ts
 import {
   OPEN_SUFFIX_RUN_STATE_BLOB,
-  approvalIdentifier
+  approvalIdentifier,
+  withPublicApprovalFields
 } from "@opengeni/contracts";
 import {
   appendSessionHistoryItems as appendSessionHistoryItems2,
@@ -7931,7 +8015,7 @@ async function settleOpenSuffixResumeIfNeeded(input) {
       ...requiresActionApprovals.length > 0 ? [
         {
           type: "session.requiresAction",
-          payload: { approvals: requiresActionApprovals }
+          payload: { approvals: requiresActionApprovals.map(withPublicApprovalFields) }
         }
       ] : [],
       {
@@ -7969,9 +8053,85 @@ function interruptionCallIdsFromPause(input) {
 // src/activities/agent-turn/stream-attempt.ts
 import {
   OPEN_SUFFIX_RUN_STATE_BLOB as OPEN_SUFFIX_RUN_STATE_BLOB2,
-  resolveWorkspaceAgentHumanInputEnabled
+  resolveWorkspaceAgentHumanInputEnabled,
+  withPublicApprovalFields as withPublicApprovalFields2
 } from "@opengeni/contracts";
 
+// src/activities/agent-turn/model-call-admission.ts
+function createModelCallAdmission(input) {
+  const receipts = /* @__PURE__ */ new WeakMap();
+  const responseReceipts = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const responseId = (event) => {
+    const id = event?.response?.id;
+    return typeof id === "string" && id.length > 0 ? id : null;
+  };
+  let latest = Promise.resolve();
+  let failure2;
+  let failed = false;
+  let rejectHalted;
+  const halted = new Promise((_, reject) => {
+    rejectHalted = reject;
+  });
+  void halted.catch(() => void 0);
+  const fail = (error51) => {
+    if (failed) return;
+    failed = true;
+    failure2 = error51;
+    rejectHalted(error51);
+    for (const receipt of pending) receipt.reject(error51);
+    pending.clear();
+    responseReceipts.clear();
+  };
+  const abort = () => fail(input.signal.reason ?? new Error("Model stream cancelled"));
+  input.signal.addEventListener("abort", abort, { once: true });
+  if (input.signal.aborted) abort();
+  return {
+    beforeModelRequest: async () => {
+      await Promise.race([latest, halted]);
+      if (failed) throw failure2;
+      await Promise.race([input.admit(), halted]);
+      if (failed) throw failure2;
+    },
+    onModelResponse: (event) => {
+      if (failed) return Promise.reject(failure2);
+      const id = responseId(event);
+      const existing = receipts.get(event) ?? (id ? responseReceipts.get(id) : void 0) ?? (!id && pending.size === 1 ? pending.values().next().value : void 0);
+      if (existing) return existing.promise;
+      let resolve;
+      let reject;
+      const promise2 = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+      });
+      void promise2.catch(() => void 0);
+      const receipt = { promise: promise2, resolve, reject };
+      receipts.set(event, receipt);
+      if (id) responseReceipts.set(id, receipt);
+      pending.add(receipt);
+      latest = promise2;
+      return promise2;
+    },
+    settle: (event) => {
+      if (event.type !== "raw_model_stream_event" || !event.data || typeof event.data !== "object")
+        return;
+      if (event.data.type !== "response_done") return;
+      const id = responseId(event.data);
+      const receipt = receipts.get(event.data) ?? (id ? responseReceipts.get(id) : void 0) ?? (pending.size === 1 ? pending.values().next().value : void 0);
+      if (!receipt) return;
+      pending.delete(receipt);
+      if (id) responseReceipts.delete(id);
+      receipt.resolve();
+    },
+    fail,
+    close: () => {
+      input.signal.removeEventListener("abort", abort);
+      if (pending.size > 0) fail(new Error("Model stream closed before response settlement"));
+      responseReceipts.clear();
+    }
+  };
+}
+
 // src/activities/agent-turn/session-title.ts
 import { hasPermission } from "@opengeni/core";
 import { isManagedOpenRouterFreeRoute } from "@opengeni/config";
@@ -7986,7 +8146,7 @@ function shouldRequestMissingSessionTitle(input) {
   const title = input.title?.trim() ?? "";
   const needsSemanticTitle = input.titleSource !== "user" && (!title || title === AUTOMATIC_SESSION_TITLE_FALLBACK);
   if (!needsSemanticTitle) return false;
-  if (!input.firstPartyMcpTools.includes("set_session_title")) return false;
+  if (!input.agentConfig && !input.firstPartyMcpTools.includes("set_session_title")) return false;
   const permissions = input.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
   return hasPermission([...permissions], "sessions:control");
 }
@@ -7994,7 +8154,7 @@ function routeAllowsSessionTitleRequests(resolvedModel) {
   return !resolvedModel || !isManagedOpenRouterFreeRoute(resolvedModel);
 }
 function sessionTitleToolPlan(input) {
-  const titleToolAvailable = input.shouldRequestTitle && input.tools.some((tool) => tool.kind === "mcp" && tool.id === "opengeni");
+  const titleToolAvailable = input.shouldRequestTitle && (input.agentConfig != null || input.tools.some((tool) => tool.kind === "mcp" && tool.id === "opengeni"));
   const titleRequestAllowed = titleToolAvailable && input.routeAllowsTitleRequests;
   const generateTitleInParallel = titleRequestAllowed && input.parallelGenerationAvailable;
   const promoteTitleTool = titleRequestAllowed && !generateTitleInParallel;
@@ -8301,6 +8461,24 @@ function createSharedRigSetupCoordinator(options) {
   };
 }
 
+// src/activities/agent-turn/final-reply.ts
+function finalReplyNudge(turnId) {
+  return {
+    type: "message",
+    role: "developer",
+    content: [
+      {
+        type: "input_text",
+        text: `[Runtime final-reply handoff for turn ${turnId}]
+Your final user-facing answer was empty. Reply to the user now with the requested deliverable or a concise outcome and its retained artifact link. Goal evidence is a short ledger proof, not the answer, and goal_complete does not deliver a chat reply. Use the completed work and tool results already in history; do not repeat completed tools or restart the task. If this is a late child result after goal completion, integrate material new findings and deliver any still-missing handoff. Do not change the completed goal or invent a result.`
+      }
+    ]
+  };
+}
+function needsFinalReply(input) {
+  return typeof input.output === "string" && input.output.trim().length === 0 && !input.inputWaitYielded && !input.interrupted && !input.maintenance && (input.toolsExecuted || input.completedGoal);
+}
+
 // src/activities/agent-turn/stream-attempt.ts
 async function attachPendingUpdatesBeforePreparingModelInput(input) {
   if (input.shouldAttach && !await input.attachPendingUpdates()) return false;
@@ -8567,12 +8745,33 @@ async function runTurnStreamAttempt(deps) {
   const modelResponseState = createModelResponseEventState(claimedModelUsageSourceKeys);
   let latestAssistantMessageText = null;
   let workerPreparationTotalRecorded = false;
+  let toolsExecuted = false;
+  let finalReplyNudged = false;
+  const revalidateModelCallAdmission = async () => {
+    await historySink.reconcileConversationTruth({ requireDurable: true });
+    await ensureRunAllowedBetweenModelCalls({
+      settings,
+      db,
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      isExternallyBilledTurn: billingState.isExternallyBilledTurn,
+      entitlements,
+      chargesOpenGeniCredits: billingState.chargesOpenGeniCredits,
+      countsTowardTokenCap: billingState.countsTowardTokenCap,
+      initiatingHumanSubjectId: turn.initiatingHumanSubjectId
+    });
+  };
   const runStreamAttempt = async (options) => {
     if (!runInput) {
       throw new Error("Run input was not prepared");
     }
-    const responseCountBeforeStream = modelResponseState.responseCount;
     eventing.stream = void 0;
+    if (options.requireTerminalModelResponse) await revalidateModelCallAdmission();
+    const modelCallAdmission = createModelCallAdmission({
+      signal: runtimeCancellationSignal,
+      admit: revalidateModelCallAdmission
+    });
+    const responseCountBeforeStream = modelResponseState.responseCount;
     eventing.batcher = null;
     let currentToolBatchCallIds = /* @__PURE__ */ new Set();
     let currentToolBatchCompletedCallIds = /* @__PURE__ */ new Set();
@@ -8740,6 +8939,8 @@ async function runTurnStreamAttempt(deps) {
         }
         attempt.modelRequestStarted = true;
         return await runtime.runStream(agent, runInput, eventing.modelRunSettings, {
+          beforeModelRequest: modelCallAdmission.beforeModelRequest,
+          onModelResponse: modelCallAdmission.onModelResponse,
           signal: runtimeCancellationSignal,
           sandboxEnvironment,
           onModelVisibleContext: async (snapshot) => {
@@ -8846,7 +9047,13 @@ async function runTurnStreamAttempt(deps) {
     if (leases.xai.lost) {
       throw new Error("xAI credential lease expired before the model run");
     }
-    eventing.stream = await withProviderRequestContext(runStreamOnce);
+    try {
+      eventing.stream = await withProviderRequestContext(runStreamOnce);
+    } catch (error51) {
+      modelCallAdmission.fail(error51);
+      modelCallAdmission.close();
+      throw error51;
+    }
     const streamTiming = new StreamTimingMetrics(observability, {
       provider: streamProvider
     });
@@ -8985,32 +9192,20 @@ async function runTurnStreamAttempt(deps) {
           await historySink.reconcileConversationTruth();
           turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
           modelCheckpointMemoryCollector.schedule(observability);
-          try {
-            await ensureRunAllowed(
-              settings,
-              db,
-              input.accountId,
-              input.workspaceId,
-              billingState.isExternallyBilledTurn,
-              entitlements,
-              billingState.chargesOpenGeniCredits,
-              billingState.countsTowardTokenCap
-            );
-          } catch (limitError) {
-            let serializedRunState = null;
-            try {
-              serializedRunState = media.compactMediaRunState(
-                String(eventing.stream.state.toString())
-              );
-            } catch {
-              serializedRunState = null;
-            }
-            throw new BudgetExhaustedError(
-              limitError instanceof Error ? limitError.message : String(limitError),
-              serializedRunState
-            );
-          }
+          await ensureRunAllowedBetweenModelCalls({
+            settings,
+            db,
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            isExternallyBilledTurn: billingState.isExternallyBilledTurn,
+            entitlements,
+            chargesOpenGeniCredits: billingState.chargesOpenGeniCredits,
+            countsTowardTokenCap: billingState.countsTowardTokenCap,
+            initiatingHumanSubjectId: turn.initiatingHumanSubjectId,
+            serializedRunState: () => media.compactMediaRunState(String(eventing.stream.state.toString()))
+          });
         }
+        modelCallAdmission.settle(next.value);
         const durableSdkEvent = generatedImageReceipt ? compactGeneratedImageSdkEvent(next.value, generatedImageReceipt) : next.value;
         const pendingToolCall = pendingToolCallFromSdkEvent(durableSdkEvent);
         if (pendingToolCall) {
@@ -9044,6 +9239,7 @@ async function runTurnStreamAttempt(deps) {
         }
         const completedToolCall = completedToolCallFromSdkEvent(durableSdkEvent);
         if (completedToolCall) {
+          toolsExecuted = true;
           retainedScreenshotMetadata = media.retainedScreenshotReceiptsByCallId.get(completedToolCall.callId) ?? null;
           const typedScreenshot = retainedScreenshotMetadata ? null : typedScreenshotFromSdkEvent(durableSdkEvent);
           if (!retainedScreenshotMetadata && media.retainedSessionImageCallIds.has(completedToolCall.callId) && sdkEventContainsInlineImage(durableSdkEvent) && !typedScreenshot) {
@@ -9225,6 +9421,7 @@ async function runTurnStreamAttempt(deps) {
         }
       }
     } catch (error51) {
+      modelCallAdmission.fail(error51);
       closeStreamWaitAdmission?.();
       if (fallbackProviderRequestLifecycleStartedAt !== null) {
         const durationMs = Math.max(
@@ -9274,6 +9471,7 @@ async function runTurnStreamAttempt(deps) {
       }
       throw error51;
     } finally {
+      modelCallAdmission.close();
       if (!streamDone) {
         void iterator.return?.().catch(() => void 0);
       }
@@ -9284,7 +9482,7 @@ async function runTurnStreamAttempt(deps) {
       temporalCancellationSignal: cancellationSignal,
       runtimeCancellationSignal
     });
-    await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
+    await eventing.preparedTools?.inputWaitYield?.drainForHandoff(runtimeCancellationSignal);
     if (options.requireTerminalModelResponse && !eventing.preparedTools?.inputWaitYield?.yielded && eventing.stream.interruptions.length === 0 && modelResponseState.responseCount === responseCountBeforeStream) {
       throwIfWorkerShuttingDown();
       throwIfTurnCancelled();
@@ -9380,6 +9578,7 @@ async function runTurnStreamAttempt(deps) {
       }
     }
     if (eventing.stream.interruptions.length > 0) {
+      await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
       await historySink.reconcileConversationTruth({ requireDurable: true });
       const approvals = runtime.serializeApprovals(eventing.stream.interruptions);
       const humanInputInterruptions = runtime.serializeHumanInputRequests?.(eventing.stream.interruptions) ?? [];
@@ -9487,9 +9686,11 @@ async function runTurnStreamAttempt(deps) {
               type: "session.requiresAction",
               payload: {
                 approvals: approvals.map(
-                  (approval) => withMcpToolDisplayMetadata(
-                    eventing.preparedTools?.mcpServers ?? [],
-                    approval
+                  (approval) => withPublicApprovalFields2(
+                    withMcpToolDisplayMetadata(
+                      eventing.preparedTools?.mcpServers ?? [],
+                      approval
+                    )
                   )
                 )
               }
@@ -9520,6 +9721,48 @@ async function runTurnStreamAttempt(deps) {
     const finalOutput = String(
       requireAgentStreamFinalOutput(eventing.stream.finalOutput, inputWaitYielded)
     );
+    const durableReplyFacts = !inputWaitYielded && finalOutput.trim().length === 0 ? await sessionTurnFinalReplyFacts(db, input.workspaceId, input.sessionId, activeTurnId) : { toolsExecuted: false, completedGoal: false };
+    let emptyFinalReply = false;
+    if (needsFinalReply({
+      output: finalOutput,
+      inputWaitYielded: inputWaitYielded || eventing.preparedTools?.inputWaitYield?.requested === true,
+      interrupted: false,
+      // interruption settlement returned above
+      maintenance: turn.source === "compaction",
+      toolsExecuted: toolsExecuted || finalReplyNudged || durableReplyFacts.toolsExecuted,
+      completedGoal: durableReplyFacts.completedGoal
+    })) {
+      await historySink.reconcileConversationTruth({ requireDurable: true });
+      if (finalReplyNudged || await sessionTurnHasFinalReplyNudge(
+        db,
+        input.workspaceId,
+        input.sessionId,
+        activeTurnId,
+        finalReplyNudge(activeTurnId).content[0].text
+      )) {
+        emptyFinalReply = true;
+      } else {
+        const appended = await appendSessionHistoryItems3(db, {
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: activeTurnId,
+          expectedExecutionGeneration: attempt.executionGeneration,
+          expectedAttemptId: input.attemptId,
+          items: [
+            {
+              position: await nextSessionHistoryPosition2(db, input.workspaceId, input.sessionId),
+              item: finalReplyNudge(activeTurnId)
+            }
+          ]
+        });
+        if (!appended) throw new TurnAttemptFencedError("turn ended before final reply handoff");
+        finalReplyNudged = true;
+        await prepareRunAttemptInput();
+        return "reply_nudge";
+      }
+    }
+    await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
     const finalOutputAlreadyCompleted = latestStreamedAssistantText === finalOutput;
     const reply = await inputWaitReply({
       inputWaitYielded,
@@ -9539,7 +9782,11 @@ async function runTurnStreamAttempt(deps) {
         ...inputWaitYielded || finalOutputAlreadyCompleted ? [] : [{ type: "agent.message.completed", payload: { text: finalOutput } }],
         {
           type: "turn.completed",
-          payload: { output: finalOutput, ...reply === null ? {} : { reply } }
+          payload: {
+            output: finalOutput,
+            ...reply === null ? {} : { reply },
+            ...emptyFinalReply ? { emptyFinalReply: true } : {}
+          }
         },
         { type: "session.status.changed", payload: { status: "idle" } }
       ],
@@ -9595,6 +9842,7 @@ async function runTurnStreamAttempt(deps) {
   })) {
     return claimedResult({ status: "cancelled" });
   }
+  await revalidateModelCallAdmission();
   if (turn.source !== "compaction" && generateSessionTitleInParallel && runtime.generateSessionTitle && !runtimeCancellationSignal.aborted) {
     const serviceTier = serviceTierForLatencyMode(
       turnExecutionPolicy.providerId,
@@ -9626,11 +9874,19 @@ async function runTurnStreamAttempt(deps) {
   }
   try {
     let retriedAfterCompaction = false;
+    finalReplyNudged = await sessionTurnHasFinalReplyNudge(
+      db,
+      input.workspaceId,
+      input.sessionId,
+      activeTurnId,
+      finalReplyNudge(activeTurnId).content[0].text
+    );
     while (true) {
       try {
         const result = await runStreamAttempt({
           requireTerminalModelResponse: retriedAfterCompaction
         });
+        if (result === "reply_nudge") continue;
         if (retriedAfterCompaction) {
           observability.info("context compaction recovery succeeded after in-activity retry", {
             sessionId: input.sessionId,
@@ -9841,7 +10097,9 @@ import {
   loadOrganizationModelProviderApiKey,
   listWorkspaceProviderCustomModels,
   getWorkspaceProviderCustomModelForExecution,
-  loadWorkspaceProviderApiKey
+  loadWorkspaceProviderApiKey,
+  loadClaudeSubscriptionUsageCredential,
+  assertModelConnectionAllowsTurn
 } from "@opengeni/db";
 async function settingsWithSessionMcpServersForRun(db, workspaceId, sessionId, attemptId, settings, options) {
   const encryptionKey = environmentsEncryptionKeyBytes(settings);
@@ -9999,12 +10257,24 @@ async function settingsWithOrganizationProviderCredentials(db, accountId, worksp
     if (kind === "claude_subscription" && !settings.claudeSubscriptionEnabled) continue;
     const models = await buildModels(kind, claudeProviderId(kind) + "/");
     result = withClaudeConnectionCatalog(result, { [kind]: { models } });
-    const credential = await loadOrganizationModelProviderApiKey(db, settings, {
+    const binding = kind === "claude_subscription" ? await loadClaudeSubscriptionUsageCredential(db, settings, {
+      accountId,
+      workspaceId,
+      scope: "organization"
+    }) : null;
+    const credential = kind === "claude_subscription" ? binding?.serializedCredential : await loadOrganizationModelProviderApiKey(db, settings, {
       accountId,
       workspaceId,
       providerKind: kind
     });
-    if (credential) result = withClaudeConnectionCredential(result, kind, credential);
+    if (credential)
+      result = withClaudeConnectionCredential(
+        result,
+        kind,
+        credential,
+        "organization",
+        binding ?? void 0
+      );
     const workspaceModels = await listWorkspaceProviderCustomModels(db, {
       accountId,
       workspaceId,
@@ -10027,15 +10297,27 @@ async function settingsWithOrganizationProviderCredentials(db, accountId, worksp
       { [kind]: { models: workspaceModels } },
       "workspace"
     );
-    const workspaceCredential = await loadWorkspaceProviderApiKey(
-      db,
-      settings,
+    const workspaceBinding = kind === "claude_subscription" ? await loadClaudeSubscriptionUsageCredential(db, settings, {
+      accountId,
       workspaceId,
-      kind,
-      workspaceModelId
-    );
+      scope: "workspace"
+    }) : null;
+    if (workspaceBinding && workspaceModelId)
+      await assertModelConnectionAllowsTurn(db, {
+        workspaceId,
+        subjectId: "worker:model-access",
+        modelId: workspaceModelId,
+        workspaceProviderConnectionId: workspaceBinding.connectionId
+      });
+    const workspaceCredential = kind === "claude_subscription" ? workspaceBinding?.serializedCredential : await loadWorkspaceProviderApiKey(db, settings, workspaceId, kind, workspaceModelId);
     if (workspaceCredential)
-      result = withClaudeConnectionCredential(result, kind, workspaceCredential, "workspace");
+      result = withClaudeConnectionCredential(
+        result,
+        kind,
+        workspaceCredential,
+        "workspace",
+        workspaceBinding ?? void 0
+      );
   }
   return result;
 }
@@ -10180,7 +10462,9 @@ async function claimTurnAttempt(deps) {
     claimedPolicy.kind === "valid" ? claimedPolicy.policy.productModelId : turn.model
   );
   const codexAppsCredentialId = capabilitySettings.codexConnectedAppsEnabled ? await resolveCodexAppsCredentialIdForRun(db, input.workspaceId) : null;
-  const policyForAbsent = claimedPolicy.kind === "valid" ? claimedPolicy.policy : resolveTurnExecutionPolicyV12(capabilitySettings, legacyTurnExecutionPolicyInput(turn));
+  const candidatePolicy = claimedPolicy.kind === "valid" ? claimedPolicy.policy : resolveTurnExecutionPolicyV12(capabilitySettings, legacyTurnExecutionPolicyInput(turn));
+  const credentialRestriction = claimedPolicy.kind === "absent" ? turn.initiatorContext?.credentialRestriction === "developer_setup" ? "developer_setup" : turnCredentialRestriction(candidatePolicy, session.metadata) : void 0;
+  const policyForAbsent = credentialRestriction ? { ...candidatePolicy, credentialRestriction } : candidatePolicy;
   const installedPolicy = await installOrReadTurnExecutionPolicyForAttempt(db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -10253,20 +10537,27 @@ async function claimTurnAttempt(deps) {
     return attached.action === "claimed" && attached.turn.id === turn.id;
   };
   turnLifecycleMetricsFor(observability).start({ attemptId: input.attemptId });
-  await waitForTurnOperation(
-    ensureRunAllowed(
-      capabilitySettings,
-      db,
-      input.accountId,
-      input.workspaceId,
-      billingState.isExternallyBilledTurn,
-      entitlements,
-      billingState.chargesOpenGeniCredits,
-      billingState.countsTowardTokenCap
-    ),
-    cancellationSignal,
-    void 0
-  );
+  let allowanceRefusal = null;
+  try {
+    await waitForTurnOperation(
+      ensureRunAllowed(
+        capabilitySettings,
+        db,
+        input.accountId,
+        input.workspaceId,
+        billingState.isExternallyBilledTurn,
+        entitlements,
+        billingState.chargesOpenGeniCredits,
+        billingState.countsTowardTokenCap,
+        turn.initiatingHumanSubjectId
+      ),
+      cancellationSignal,
+      void 0
+    );
+  } catch (error51) {
+    if (!(error51 instanceof AllowanceExhaustedError)) throw error51;
+    allowanceRefusal = error51.refusal;
+  }
   const throwIfWorkerShuttingDown = () => {
     const reason = activityContext?.cancellationSignal.reason;
     if (isWorkerShutdownCancellation(reason)) {
@@ -10371,6 +10662,7 @@ async function claimTurnAttempt(deps) {
       sessionStatus: inputSettlement.sessionStatus,
       activeTurnId: inputSettlement.activeTurnId,
       ...inputSettlement.suppressGoalContinuation !== void 0 ? { suppressGoalContinuation: inputSettlement.suppressGoalContinuation } : {},
+      ...inputSettlement.allowanceGoalPause ? { allowanceGoalPause: inputSettlement.allowanceGoalPause } : {},
       events: inputs,
       ...runState ? { runState } : {},
       ...compactionRequestFailure ? { compactionRequestFailure } : {}
@@ -10418,6 +10710,31 @@ async function claimTurnAttempt(deps) {
     durationSeconds: (performance.now() - activityStarted) / 1e3
   });
   const turnStartSettlementStartedAt = performance.now();
+  if (allowanceRefusal) {
+    if (!await eventing.settle({
+      events: [
+        { type: "usage.exhausted", payload: allowanceRefusal },
+        {
+          type: "turn.completed",
+          payload: {
+            output: "",
+            segmentLimit: "budget_exhausted",
+            ...allowanceRefusal
+          }
+        },
+        { type: "session.status.changed", payload: { status: "idle" } }
+      ],
+      turnStatus: "completed",
+      sessionStatus: "idle",
+      activeTurnId: null,
+      allowanceGoalPause: { rationale: allowanceRefusal.message }
+    })) {
+      return { exit: claimedResult({ status: "cancelled" }) };
+    }
+    control.turnMetricOutcome = "completed";
+    control.activityStatus = "idle";
+    return { exit: claimedResult({ status: "idle" }) };
+  }
   if (!await eventing.settle({
     events: [
       { type: "session.status.changed", payload: { status: "running" } },
@@ -11431,7 +11748,8 @@ import { retryWhileMissing as retryWhileMissing3 } from "@opengeni/storage";
 import { WorkspaceModelPolicyBlockedError } from "@opengeni/runtime";
 import {
   evaluateWorkspaceModelPolicy,
-  resolveWorkspaceAgentHumanInputEnabled as resolveWorkspaceAgentHumanInputEnabled2
+  resolveWorkspaceAgentHumanInputEnabled as resolveWorkspaceAgentHumanInputEnabled2,
+  resolveWorkspaceDefaultAgentIdentity
 } from "@opengeni/contracts";
 import { codeSearchEnabledForTurn } from "@opengeni/contracts/code-search";
 
@@ -11822,6 +12140,10 @@ async function prepareGovernanceAndModel(deps) {
   );
   const contextSelection = await resolveCompanyBrainContextSelection(db, governanceClaims);
   const workspaceAgentInstructions = contextSelection.legacyWorkspaceInstructions;
+  const workspaceAgentIdentity = resolveWorkspaceDefaultAgentIdentity(
+    workspace.settings,
+    workspaceAgentInstructions
+  ).identity;
   const memoryPromptMode = contextSelection.receipt.memoryPromptMode;
   assertWorkspaceHumanInputAllowed(agentHumanInputEnabled, "resume", humanInputResume !== null);
   const companyProfileIncluded = contextSelection.receipt.companyProfileIncluded;
@@ -11981,6 +12303,7 @@ async function prepareGovernanceAndModel(deps) {
       agentHumanInputEnabled,
       codeSearchEnabled,
       workspaceAgentInstructions,
+      workspaceAgentIdentity,
       workspaceGovernance,
       structuredWorkspacePolicyActive,
       workspaceMemory,
@@ -12008,7 +12331,9 @@ import {
   appendSessionInstructions,
   appendWorkspaceGovernance,
   appendWorkspaceMemory,
+  agentPromptResourcesFor,
   composeAgentInstructions,
+  inspectPersistentAgentInstructions,
   requestRemoteCompactionV2,
   preparedCompactionRequest,
   queuePreparedCompaction,
@@ -12018,6 +12343,39 @@ import {
   estimateSerializedValueTokens,
   compactionSummaryOutputTokens as compactionSummaryOutputTokens2
 } from "@opengeni/runtime";
+function standaloneCompactionInstructions(input) {
+  if (input.session.agent) {
+    return inspectPersistentAgentInstructions(input.settings, {
+      agentConfig: input.session.agent,
+      ...input.workspaceAgentIdentity ? { workspaceAgentIdentity: input.workspaceAgentIdentity } : {},
+      ...input.workspaceGovernance ? { workspaceGovernance: input.workspaceGovernance } : {},
+      ...input.workspaceMemory ? { workspaceMemory: input.workspaceMemory } : {},
+      ...input.session.instructions ? { sessionInstructions: input.session.instructions } : {},
+      ...input.rig ? { rig: input.rig } : {},
+      // Session-level facts only: per-turn attachments do not apply to a
+      // standalone compaction request.
+      agentPromptResources: agentPromptResourcesFor(
+        input.settings,
+        input.session.resources.filter((resource) => resource.kind !== "file"),
+        input.rig ? { rig: input.rig } : {}
+      )
+    }).composed;
+  }
+  return appendWorkspaceMemory(
+    appendSessionInstructions(
+      appendWorkspaceGovernance(
+        composeAgentInstructions(
+          input.structuredWorkspacePolicyActive ? input.settings.agentInstructionsTemplate : input.workspaceAgentInstructions ?? input.settings.agentInstructionsTemplate,
+          void 0,
+          input.rig
+        ),
+        input.workspaceGovernance ?? void 0
+      ),
+      input.session.instructions ?? void 0
+    ),
+    input.workspaceMemory ?? void 0
+  );
+}
 async function prepareCompaction(deps) {
   const {
     input,
@@ -12042,6 +12400,7 @@ async function prepareCompaction(deps) {
     turnExecutionPolicy,
     resolvedModel,
     workspaceAgentInstructions,
+    workspaceAgentIdentity,
     workspaceGovernance,
     structuredWorkspacePolicyActive,
     workspaceMemory,
@@ -12185,20 +12544,16 @@ async function prepareCompaction(deps) {
     return claimedResult({ status: "idle" });
   };
   if (compactionOnlyTurn && !remoteV2CompactionNeedsAgentPrefix && !portableResponsesNeedsAgentPrefix) {
-    const compactionInstructions = appendWorkspaceMemory(
-      appendSessionInstructions(
-        appendWorkspaceGovernance(
-          composeAgentInstructions(
-            structuredWorkspacePolicyActive ? eventing.modelRunSettings.agentInstructionsTemplate : workspaceAgentInstructions ?? eventing.modelRunSettings.agentInstructionsTemplate,
-            void 0,
-            rigVersion && rigName ? { name: rigName, version: rigVersion.version } : void 0
-          ),
-          workspaceGovernance ?? void 0
-        ),
-        session.instructions ?? void 0
-      ),
-      workspaceMemory ?? void 0
-    );
+    const compactionInstructions = standaloneCompactionInstructions({
+      settings: eventing.modelRunSettings,
+      session,
+      workspaceAgentInstructions,
+      workspaceAgentIdentity,
+      workspaceGovernance,
+      structuredWorkspacePolicyActive,
+      workspaceMemory,
+      rig: rigVersion && rigName ? { name: rigName, version: rigVersion.version } : void 0
+    });
     const requested = await isSessionCompactionRequested2(db, input.workspaceId, input.sessionId);
     let outcome = null;
     if (requested) {
@@ -13267,6 +13622,7 @@ async function resolveSandboxRoute(deps) {
     machinePrimary,
     groupBoxBackend,
     groupBoxImage,
+    groupBoxImagePolicy: "new_creates_only",
     sandboxCreationBackend,
     effectiveRunCredentialBackend
   };
@@ -13306,6 +13662,7 @@ async function establishTurnSandbox(deps) {
     machinePrimary,
     groupBoxBackend,
     groupBoxImage,
+    groupBoxImagePolicy,
     rigVersion,
     turnResources
   } = deps;
@@ -13560,7 +13917,8 @@ async function establishTurnSandbox(deps) {
               os: groupBoxOs,
               environment: sandboxEnvironment,
               ...groupBoxImage ? {
-                image: groupBoxImage
+                image: groupBoxImage,
+                imagePolicy: groupBoxImagePolicy
               } : {},
               // The lazy acquire must enforce the same frozen rig authority
               // as the eager acquire; otherwise a warm box for another rig
@@ -13637,16 +13995,16 @@ async function establishTurnSandbox(deps) {
                 backend: groupBoxBackend,
                 os: groupBoxOs,
                 environment: sandboxEnvironment,
-                // IMAGE IS SHARED STATE (B3): the container image
-                // this run resolves. The lease stamps it + conflicts on a live shared box
-                // running a DIFFERENT image (solo → durable rotation; N-holders →
-                // SandboxImageConflictError surfaced as an actionable turn error). Select
-                // the image for the actual group-box backend; a configured Modal image must
+                // Deployment/workspace pins select NEW creates only. The lease
+                // retains a live group's image through between-turn repins, even
+                // with other holders; only rotation/reaping elects a new image.
+                // Select the image for the actual group-box backend; a configured Modal image must
                 // never override a Docker run. The selfhosted branch
                 // (establishSelfhostedTurnSession) NEVER passes
                 // an image — B3 lives only on this managed-box branch.
                 ...groupBoxImage ? {
-                  image: groupBoxImage
+                  image: groupBoxImage,
+                  imagePolicy: groupBoxImagePolicy
                 } : {},
                 // RIG IS SHARED STATE (M3): stamp the frozen rig version so the lease
                 // conflicts on a live shared box set up under a different rig (solo
@@ -14342,6 +14700,100 @@ import {
 } from "@opengeni/runtime";
 import { codemodeWorkspaceUrl as codemodeWorkspaceUrl2 } from "@opengeni/config";
 
+// src/activities/mcp-account-routes.ts
+function accountRouteAuthNeededPayload(payload, bindings) {
+  const binding = bindings?.find((candidate) => candidate.serverId === payload.serverId);
+  return binding ? {
+    ...payload,
+    canonicalServerId: binding.canonicalServerId,
+    connectionSubjectScope: binding.subjectScope
+  } : payload;
+}
+function expandMcpAccountRoutes(input) {
+  if (input.bindings == null) {
+    return { settings: input.settings, tools: input.tools, accountLabels: /* @__PURE__ */ new Map() };
+  }
+  const configured = new Map(input.settings.mcpServers.map((server) => [server.id, server]));
+  const byCanonical = /* @__PURE__ */ new Map();
+  const routes = /* @__PURE__ */ new Set();
+  const accounts = /* @__PURE__ */ new Set();
+  for (const binding of input.bindings) {
+    const account = JSON.stringify([binding.canonicalServerId, binding.connectionId]);
+    if (routes.has(binding.serverId) || accounts.has(account) || configured.has(binding.serverId) || binding.subjectScope === "subject" !== (binding.ownerSubjectId !== null) || binding.connectionRef.authoritySource === "host" || binding.connectionRef.connectionId !== binding.connectionId || binding.connectionRef.subjectScope !== binding.subjectScope || binding.connectionRef.providerDomain !== binding.providerDomain || binding.connectionRef.kind !== binding.kind) {
+      throw new Error("Invalid accepted MCP account route");
+    }
+    routes.add(binding.serverId);
+    accounts.add(account);
+    const siblings = byCanonical.get(binding.canonicalServerId) ?? [];
+    siblings.push(binding);
+    byCanonical.set(binding.canonicalServerId, siblings);
+  }
+  const servers = [];
+  const tools = [];
+  const accountLabels = /* @__PURE__ */ new Map();
+  for (const tool of input.tools) {
+    const bindings = byCanonical.get(tool.id);
+    if (!bindings) {
+      if (!configured.get(tool.id)?.connectionRef) tools.push(tool);
+      continue;
+    }
+    const canonical = configured.get(tool.id);
+    if (!canonical?.connectionRef) {
+      throw new Error("Accepted MCP account route has no canonical connection configuration");
+    }
+    for (const binding of bindings) {
+      if (canonical.connectionRef.authoritySource === "host" || canonical.connectionRef.providerDomain !== binding.providerDomain || canonical.connectionRef.kind && canonical.connectionRef.kind !== binding.kind) {
+        throw new Error("Accepted MCP account route does not match canonical provider");
+      }
+      const { headers: _headers, ...config2 } = canonical;
+      const label = `${canonical.name ?? canonical.id} \u2014 ${binding.subjectScope === "subject" ? "Personal" : "Workspace"}: ${binding.accountLabel}`;
+      servers.push({
+        ...config2,
+        id: binding.serverId,
+        name: label,
+        connectionRef: structuredClone(binding.connectionRef)
+      });
+      tools.push({ ...tool, id: binding.serverId });
+      accountLabels.set(binding.serverId, label);
+    }
+  }
+  return {
+    settings: {
+      ...input.settings,
+      mcpServers: [
+        ...input.settings.mcpServers.filter((server) => !server.connectionRef),
+        ...servers
+      ]
+    },
+    tools,
+    accountLabels
+  };
+}
+function expandApiIntegrationAccountRoutes(input) {
+  const selected = new Set(input.tools.map((tool) => tool.id));
+  if (input.bindings == null)
+    return input.integrations.filter((item) => selected.has(item.serverId));
+  const acceptedBindings = input.bindings;
+  return input.integrations.flatMap((integration) => {
+    const bindings = acceptedBindings.filter(
+      (binding) => binding.canonicalServerId === integration.serverId
+    );
+    if (bindings.length === 0)
+      return !integration.connectionRef && selected.has(integration.serverId) ? [integration] : [];
+    return bindings.filter((binding) => selected.has(binding.serverId)).map((binding) => {
+      if (binding.connectionAuthorityGeneration === void 0) {
+        throw new Error("Accepted API integration account route has no authority generation");
+      }
+      return {
+        ...integration,
+        serverId: binding.serverId,
+        connectionRef: structuredClone(binding.connectionRef),
+        connectionAuthorityGeneration: binding.connectionAuthorityGeneration
+      };
+    });
+  });
+}
+
 // src/activities/git-credential-renewal.ts
 var GIT_CREDENTIAL_DEFAULT_REFRESH_MS = 30 * 6e4;
 var GIT_CREDENTIAL_EXPIRY_LEAD_MS = 5 * 6e4;
@@ -14700,6 +15152,8 @@ function credentialProviderRequestBody(input, initiatingHumanSubjectId, initiati
   lane: "workspace",
   mcpServers: []
 }) {
+  const via = input.initiatorContext.via;
+  const latestHop = Array.isArray(via) ? via.at(-1) : null;
   return {
     type: "credentials.request",
     lane: selection.lane,
@@ -14714,6 +15168,11 @@ function credentialProviderRequestBody(input, initiatingHumanSubjectId, initiati
     turnId: input.turnId,
     attemptId: input.attemptId,
     initiator: { kind: input.initiator.kind, subjectId: input.initiator.subjectId },
+    initiatorContext: {
+      kind: latestHop?.kind === "agent" ? "agent" : input.initiator.kind === "subject" ? "human" : "service",
+      initiator: input.initiator,
+      context: input.initiatorContext
+    },
     initiatingHumanSubjectId,
     initiatingHuman,
     sandboxBackend: input.effectiveSandboxBackend,
@@ -14905,7 +15364,7 @@ async function bindRunCredentialResolver(input) {
       mcpServers: selectedSessionRemoteMcpTargets(
         input.settings,
         input.session.mcpServers ?? [],
-        input.turn.tools ?? [],
+        input.effectiveTools,
         (input.localMcpServerIds ?? []).map((id) => ({ id }))
       )
     }
@@ -14921,22 +15380,23 @@ async function bindRunCredentialResolver(input) {
     workspaceId: input.workspaceId,
     sessionId: input.session.id
   };
+  const frozenRequest = structuredClone(
+    buildRunCredentialsRequest({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      session: input.session,
+      turn: input.turn,
+      attemptId: input.attemptId,
+      effectiveSandboxBackend: input.effectiveSandboxBackend,
+      variableSet: input.variableSet,
+      rootSessionId,
+      purpose: "provision",
+      forceRefresh: false
+    })
+  );
   return {
     resolve: async ({ purpose, forceRefresh }) => {
-      const resolution = await resolver(
-        buildRunCredentialsRequest({
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          session: input.session,
-          turn: input.turn,
-          attemptId: input.attemptId,
-          effectiveSandboxBackend: input.effectiveSandboxBackend,
-          variableSet: input.variableSet,
-          rootSessionId,
-          purpose,
-          forceRefresh
-        })
-      );
+      const resolution = await resolver({ ...frozenRequest, purpose, forceRefresh });
       return normalizeRunCredentialsResolution(resolution, scope);
     }
   };
@@ -14959,6 +15419,7 @@ async function prepareRunCredentials(deps) {
     sandboxState,
     turn,
     session,
+    turnExecutionPolicy,
     fileAuthoritySubjectId,
     runSettings,
     workspaceVariableSet,
@@ -14981,13 +15442,19 @@ async function prepareRunCredentials(deps) {
   const platformGitResources = turnResources.filter(
     (resource) => resource.kind !== "repository" || repositoryHasExplicitGitConnection(resource)
   );
+  const accountRoutes = expandMcpAccountRoutes({
+    settings: runSettings,
+    tools: deps.turnTools,
+    bindings: turn.mcpAccountBindings
+  });
   const runCredentialResolver = effectiveRunCredentialBackend === "none" || effectiveRunCredentialBackend === "selfhosted" ? null : await waitForTurnOperation(
     bindRunCredentialResolver({
       db,
-      settings: runSettings,
+      settings: accountRoutes.settings,
       initiatingHumanSubjectId: turn.initiatingHumanSubjectId ?? null,
       connectionCredentials: connectionCredentials ?? null,
       localMcpServerIds: deps.localMcpServerIds ?? [],
+      effectiveTools: accountRoutes.tools,
       accountId: input.accountId,
       workspaceId: input.workspaceId,
       session,
@@ -15026,9 +15493,9 @@ async function prepareRunCredentials(deps) {
   ) : null;
   const runMcpCredentials = new RunMcpCredentials(
     selectedSessionRemoteMcpTargets2(
-      runSettings,
+      accountRoutes.settings,
       session.mcpServers ?? [],
-      turn.tools ?? [],
+      accountRoutes.tools,
       (deps.localMcpServerIds ?? []).map((id) => ({ id }))
     ),
     {
@@ -15111,11 +15578,13 @@ async function prepareRunCredentials(deps) {
     attemptId: input.attemptId,
     turn
   }) : void 0;
+  const credentialRestriction = turnCredentialRestriction(turnExecutionPolicy, session.metadata);
   const codemodeAuthority = {
     sessionId: input.sessionId,
     turnId: turn.id,
     attemptId: input.attemptId,
-    executionGeneration: turn.executionGeneration
+    executionGeneration: turn.executionGeneration,
+    ...credentialRestriction ? { credentialRestriction } : {}
   };
   const sandboxArtifactRuntime = sandboxArtifactRuntimeAdmission(
     settings,
@@ -16410,100 +16879,6 @@ function isGitHubApiDestination(value) {
   }
 }
 
-// src/activities/mcp-account-routes.ts
-function accountRouteAuthNeededPayload(payload, bindings) {
-  const binding = bindings?.find((candidate) => candidate.serverId === payload.serverId);
-  return binding ? {
-    ...payload,
-    canonicalServerId: binding.canonicalServerId,
-    connectionSubjectScope: binding.subjectScope
-  } : payload;
-}
-function expandMcpAccountRoutes(input) {
-  if (input.bindings == null) {
-    return { settings: input.settings, tools: input.tools, accountLabels: /* @__PURE__ */ new Map() };
-  }
-  const configured = new Map(input.settings.mcpServers.map((server) => [server.id, server]));
-  const byCanonical = /* @__PURE__ */ new Map();
-  const routes = /* @__PURE__ */ new Set();
-  const accounts = /* @__PURE__ */ new Set();
-  for (const binding of input.bindings) {
-    const account = JSON.stringify([binding.canonicalServerId, binding.connectionId]);
-    if (routes.has(binding.serverId) || accounts.has(account) || configured.has(binding.serverId) || binding.subjectScope === "subject" !== (binding.ownerSubjectId !== null) || binding.connectionRef.authoritySource === "host" || binding.connectionRef.connectionId !== binding.connectionId || binding.connectionRef.subjectScope !== binding.subjectScope || binding.connectionRef.providerDomain !== binding.providerDomain || binding.connectionRef.kind !== binding.kind) {
-      throw new Error("Invalid accepted MCP account route");
-    }
-    routes.add(binding.serverId);
-    accounts.add(account);
-    const siblings = byCanonical.get(binding.canonicalServerId) ?? [];
-    siblings.push(binding);
-    byCanonical.set(binding.canonicalServerId, siblings);
-  }
-  const servers = [];
-  const tools = [];
-  const accountLabels = /* @__PURE__ */ new Map();
-  for (const tool of input.tools) {
-    const bindings = byCanonical.get(tool.id);
-    if (!bindings) {
-      if (!configured.get(tool.id)?.connectionRef) tools.push(tool);
-      continue;
-    }
-    const canonical = configured.get(tool.id);
-    if (!canonical?.connectionRef) {
-      throw new Error("Accepted MCP account route has no canonical connection configuration");
-    }
-    for (const binding of bindings) {
-      if (canonical.connectionRef.authoritySource === "host" || canonical.connectionRef.providerDomain !== binding.providerDomain || canonical.connectionRef.kind && canonical.connectionRef.kind !== binding.kind) {
-        throw new Error("Accepted MCP account route does not match canonical provider");
-      }
-      const { headers: _headers, ...config2 } = canonical;
-      const label = `${canonical.name ?? canonical.id} \u2014 ${binding.subjectScope === "subject" ? "Personal" : "Workspace"}: ${binding.accountLabel}`;
-      servers.push({
-        ...config2,
-        id: binding.serverId,
-        name: label,
-        connectionRef: structuredClone(binding.connectionRef)
-      });
-      tools.push({ ...tool, id: binding.serverId });
-      accountLabels.set(binding.serverId, label);
-    }
-  }
-  return {
-    settings: {
-      ...input.settings,
-      mcpServers: [
-        ...input.settings.mcpServers.filter((server) => !server.connectionRef),
-        ...servers
-      ]
-    },
-    tools,
-    accountLabels
-  };
-}
-function expandApiIntegrationAccountRoutes(input) {
-  const selected = new Set(input.tools.map((tool) => tool.id));
-  if (input.bindings == null)
-    return input.integrations.filter((item) => selected.has(item.serverId));
-  const acceptedBindings = input.bindings;
-  return input.integrations.flatMap((integration) => {
-    const bindings = acceptedBindings.filter(
-      (binding) => binding.canonicalServerId === integration.serverId
-    );
-    if (bindings.length === 0)
-      return !integration.connectionRef && selected.has(integration.serverId) ? [integration] : [];
-    return bindings.filter((binding) => selected.has(binding.serverId)).map((binding) => {
-      if (binding.connectionAuthorityGeneration === void 0) {
-        throw new Error("Accepted API integration account route has no authority generation");
-      }
-      return {
-        ...integration,
-        serverId: binding.serverId,
-        connectionRef: structuredClone(binding.connectionRef),
-        connectionAuthorityGeneration: binding.connectionAuthorityGeneration
-      };
-    });
-  });
-}
-
 // src/activities/agent-turn/tool-environment.ts
 import { createMcpOperationPersistence } from "@opengeni/db/mcp-operations";
 
@@ -32257,14 +32632,17 @@ import {
   buildApiIntegrationMcpServers,
   resolveCatalogSettings as resolveCatalogSettings2,
   resolveWorkspaceModelSelection,
+  loadWorkspaceCodexModelAvailability,
   withFrozenPersonalConnectionDelegations,
-  resolveSessionToolPolicy,
+  resolveTurnToolPolicy,
+  scheduledTurnMcpServerIds,
   hasPermission as hasPermission2
 } from "@opengeni/core";
 import { SandboxChannelAService as SandboxChannelAService3 } from "@opengeni/runtime/sandbox";
 import { sandboxRunAs as sandboxRunAs4 } from "@opengeni/runtime";
 import {
-  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2,
+  resolveAgentToolFamilies
 } from "@opengeni/contracts";
 
 // src/activities/agent-turn/list-models.ts
@@ -33703,27 +34081,31 @@ async function prepareTurnToolPolicy(deps) {
   } = deps;
   const turnResources = mergeResourceRefs(session.resources, turn.resources);
   const runtimeResources = runtimeResourcesForTurn(session.resources, turn.resources);
-  const scheduledEffectiveMcpServerIds = (() => {
-    const value = turn.metadata && typeof turn.metadata === "object" && !Array.isArray(turn.metadata) ? turn.metadata.scheduledEffectiveMcpServerIds : null;
-    return Array.isArray(value) && value.every((id) => typeof id === "string") ? [...new Set(value)].sort() : null;
-  })();
-  const currentMcpServerIds = new Set(runSettings.mcpServers.map((server) => server.id));
-  const resolvedToolPolicy = resolveSessionToolPolicy({
+  const resolvedToolPolicy = resolveTurnToolPolicy({
     toolPolicy: session.toolPolicy,
-    sessionTools: scheduledEffectiveMcpServerIds ? turn.tools : session.tools,
-    availableMcpServerIds: scheduledEffectiveMcpServerIds ? scheduledEffectiveMcpServerIds.filter((id) => currentMcpServerIds.has(id)) : [...currentMcpServerIds],
-    defaultMcpServerIds: scheduledEffectiveMcpServerIds ?? (session.toolPolicy.mode === "workspace_default" ? await workspaceSessionToolPolicyDefaultServerIds(
+    session,
+    turn,
+    availableMcpServerIds: runSettings.mcpServers.map((server) => server.id),
+    defaultMcpServerIds: scheduledTurnMcpServerIds(turn) === null && session.toolPolicy.mode === "workspace_default" ? await workspaceSessionToolPolicyDefaultServerIds(
       db,
       input.workspaceId,
       capabilitySettings,
       fileAuthoritySubjectId ?? void 0
-    ) : [])
+    ) : []
   });
   const mcpAvailabilityNote = unavailableMcpOperationalContext({
     droppedIds: resolvedToolPolicy.effectivePolicy.droppedIds,
     droppedCount: resolvedToolPolicy.effectivePolicy.counts.dropped
   });
-  const effectivePolicyTools = resolvedToolPolicy.toolRefs;
+  const families = resolveAgentToolFamilies(session.agent, {
+    productServerIds: /* @__PURE__ */ new Set([
+      ...session.mcpServers.map((server) => server.id),
+      ...session.toolPolicy.mode !== "workspace_default" ? session.tools.map((tool) => tool.id) : []
+    ])
+  });
+  const effectivePolicyTools = resolvedToolPolicy.toolRefs.filter(
+    (tool) => tool.kind !== "mcp" || families.allowsMcpServer(tool.id)
+  );
   const turnTools = withFirstPartyTools(runSettings, effectivePolicyTools);
   const connectionScope = {
     accountId: input.accountId,
@@ -33854,6 +34236,7 @@ async function prepareTurnToolRuntime(deps) {
   });
   const runSettings = accountRoutes.settings;
   const turnTools = accountRoutes.tools;
+  const credentialRestriction = turnCredentialRestriction(turnExecutionPolicy, session.metadata);
   const toolContextPreparationStartedAt = performance.now();
   throwIfWorkerShuttingDown();
   throwIfTurnCancelled();
@@ -34003,14 +34386,16 @@ async function prepareTurnToolRuntime(deps) {
   const effectiveFirstPartyPermissions = linkedAuthority ? (session.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2).filter(
     (permission) => hasPermission2(linkedAuthority.permissions, permission)
   ) : session.firstPartyMcpPermissions;
-  const selectedFirstPartyMcpTools = allowedFirstPartyMcpToolsForSession(
-    runSettings,
-    session.firstPartyMcpTools
+  const toolFamilies = resolveAgentToolFamilies(session.agent);
+  const selectedFirstPartyMcpTools = toolFamilies.firstPartyTools(
+    allowedFirstPartyMcpToolsForSession(runSettings, session.firstPartyMcpTools)
   );
   const titleToolPlan = sessionTitleToolPlan({
+    agentConfig: session.agent,
     tools: turnTools,
     selectedFirstPartyMcpTools,
     shouldRequestTitle: shouldRequestMissingSessionTitle({
+      agentConfig: session.agent,
       title: session.title,
       titleSource: session.titleSource,
       firstPartyMcpTools: selectedFirstPartyMcpTools,
@@ -34070,7 +34455,7 @@ async function prepareTurnToolRuntime(deps) {
     workspaceId: input.workspaceId,
     ...deps.fileAuthoritySubjectId ? { subjectId: deps.fileAuthoritySubjectId } : {}
   });
-  const skillCatalog = [
+  const skillCatalog = toolFamilies.skills === false ? [] : [
     ...sharedSkillDescriptors.filter((entry) => entry.activationMode === "workspace_managed").map((entry) => ({
       id: entry.id,
       name: entry.title,
@@ -34242,6 +34627,9 @@ async function prepareTurnToolRuntime(deps) {
       );
     }
   });
+  const attemptToolFamilies = resolveAgentToolFamilies(session.agent, {
+    hasSkills: skillCatalog.length > 0
+  });
   const attemptToolDefinitions = [
     ...operationReadStore ? [
       createOperationReadAttemptToolDefinition({
@@ -34283,7 +34671,8 @@ async function prepareTurnToolRuntime(deps) {
           organizationGatewayConnectionActive,
           organizationGatewayCustomModels,
           organizationOpenRouterConnectionActive,
-          organizationOpenRouterCustomModels
+          organizationOpenRouterCustomModels,
+          codexModelAvailability
         ] = await Promise.all([
           getWorkspaceConnectionModelRestrictions(
             db,
@@ -34326,10 +34715,12 @@ async function prepareTurnToolRuntime(deps) {
             accountId: input.accountId,
             workspaceId: input.workspaceId,
             providerKind: "openrouter"
-          })
+          }),
+          loadWorkspaceCodexModelAvailability(db, currentSettings, input.workspaceId)
         ]);
         return {
           selections: resolveWorkspaceModelSelection({
+            observations: codexModelAvailability,
             connectionModelRestrictions,
             settings: currentSettings,
             policy,
@@ -34369,6 +34760,7 @@ async function prepareTurnToolRuntime(deps) {
     ] : [],
     ...createFirstPartyInteractionAttemptToolDefinitions({
       settings: runSettings,
+      ...credentialRestriction ? { credentialRestriction } : {},
       scope: {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
@@ -34385,7 +34777,7 @@ async function prepareTurnToolRuntime(deps) {
     }),
     ...googleDrivePublicationTool && googleDrivePublicationAllowed ? [googleDrivePublicationTool] : [],
     ...codeSearchTools
-  ];
+  ].filter((tool) => attemptToolFamilies.allowsFunctionTool(tool.modelName));
   recordTurnStartupPhase(observability, {
     phase: "tool_context_preparation",
     provider: turnExecutionPolicy.providerId,
@@ -34455,6 +34847,7 @@ async function prepareTurnToolRuntime(deps) {
   try {
     eventing.preparedTools = await waitForTurnOperation(
       runtime.prepareTools(githubRestMcp.settings, githubRestMcp.tools, {
+        ...credentialRestriction ? { credentialRestriction } : {},
         mcpAccountLabels: accountRoutes.accountLabels,
         accountId: input.accountId,
         workspaceId: input.workspaceId,
@@ -34473,7 +34866,7 @@ async function prepareTurnToolRuntime(deps) {
         sessionAttachedRemoteMcpTargets: selectedSessionRemoteMcpTargets3(
           githubRestMcp.settings,
           session.mcpServers ?? [],
-          turn.tools ?? [],
+          githubRestMcp.tools,
           localMcpServers
         ),
         ...deps.runMcpCredentials ? { runMcpCredentials: deps.runMcpCredentials } : {},
@@ -34917,7 +35310,8 @@ import {
   getExternalLinkTurnAuthorization as getExternalLinkTurnAuthorization2,
   getSessionTurnForAttempt as getSessionTurnForAttempt2,
   ensureSessionReasoningConfiguration,
-  ensureSessionSkillCatalog
+  ensureSessionSkillCatalog,
+  sessionHasToolRouterHistory
 } from "@opengeni/db";
 import {
   formatSkillCatalog,
@@ -36073,7 +36467,7 @@ function validateReferenceImage(bytes) {
 // src/activities/agent-turn/agent-build.ts
 import { SandboxChannelAService as SandboxChannelAService4 } from "@opengeni/runtime/sandbox";
 import { sandboxRunAs as sandboxRunAs5 } from "@opengeni/runtime";
-import { VideoGenerationRejectedResult } from "@opengeni/contracts";
+import { VideoGenerationRejectedResult, resolveAgentToolFamilies as resolveAgentToolFamilies2 } from "@opengeni/contracts";
 
 // src/activities/agent-turn/video-reference-sandbox.ts
 async function resolveVideoReferenceSandboxAccess(request, sandboxState, sdkOwnedSandboxSession) {
@@ -36117,6 +36511,7 @@ async function buildTurnAgent(deps) {
     supportsImageInput,
     agentHumanInputEnabled,
     workspaceAgentInstructions,
+    workspaceAgentIdentity,
     workspaceGovernance,
     structuredWorkspacePolicyActive,
     workspaceMemory,
@@ -36197,7 +36592,7 @@ async function buildTurnAgent(deps) {
     }
   });
   const imageGenerationOption = (() => {
-    if (!objectStorage) return {};
+    if (!objectStorage || !resolveAgentToolFamilies2(session.agent).media) return {};
     if (nativeImageProviderBinding) {
       media.nativeImageGenerationRetention = {
         ...nativeImageProviderBinding,
@@ -36313,7 +36708,7 @@ async function buildTurnAgent(deps) {
   const videoGenerationPolicy = await getWorkspaceVideoGenerationPolicy2(db, input.workspaceId);
   const videoGenerationEnabled = videoGenerationPolicy.defaultModelId !== null && videoGenerationPolicy.enabledModelIds.length > 0;
   let videoGenerationCredential = null;
-  if (objectStorage && videoGenerationEnabled) {
+  if (objectStorage && videoGenerationEnabled && resolveAgentToolFamilies2(session.agent).media) {
     if (videoGenerationPolicy.fundingSource === "opengeni_credits") {
       videoGenerationCredential = managedVideoGenerationCredentialLease(eventing.modelRunSettings);
     } else if (videoGenerationPolicy.fundingSource === "workspace_gateway") {
@@ -36505,6 +36900,11 @@ async function buildTurnAgent(deps) {
     expectedAttemptId: input.attemptId,
     effort: turn.reasoningEffort
   }) : turn.reasoningEffort;
+  const toolRouterInHistory = session.agent ? await sessionHasToolRouterHistory(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId
+  }) : false;
   const agent = (() => {
     const agentConstructionStartedAt = performance.now();
     let agentConstructionOutcome = "completed";
@@ -36523,6 +36923,7 @@ async function buildTurnAgent(deps) {
           }
         } : {},
         ...preparedTools.inputWaitYield ? { inputWaitYield: preparedTools.inputWaitYield } : {},
+        ...session.agent ? { agentConfig: session.agent, toolRouterInHistory } : {},
         reasoningEffort: requestReasoningEffort,
         latencyMode: turnExecutionPolicy.latencyMode,
         ...serviceTier ? { serviceTier } : {},
@@ -36611,6 +37012,14 @@ async function buildTurnAgent(deps) {
         onRetainableSessionImageOutput: media.retainSessionImageAtToolBoundary,
         skillCatalog: deps.skillCatalog,
         skillCatalogInHistory: true,
+        // A session with an agent configuration composes the modular prompt
+        // (identity, base behavior, runtime mechanics, capability modules);
+        // its workspace identity survives instruction policies. Null keeps
+        // the legacy composition below byte-for-byte.
+        ...session.agent ? {
+          agentConfig: session.agent,
+          ...workspaceAgentIdentity ? { workspaceAgentIdentity } : {}
+        } : {},
         ...!structuredWorkspacePolicyActive && workspaceAgentInstructions ? { instructionsTemplate: workspaceAgentInstructions } : {},
         ...workspaceGovernance ? { workspaceGovernance } : {},
         ...workspaceMemory ? { workspaceMemory } : {},
@@ -36878,11 +37287,14 @@ function createRunAgentTurnActivity(services) {
       getModelRunSettings: () => eventing.modelRunSettings,
       getExecutionGeneration: () => attempt.executionGeneration
     });
-    const checkpointBeforeProviderDispatch = () => checkpointHistoryBeforeProviderDispatch(historySink, {
-      effectiveSandboxBackend: eventing.modelRunSettings.sandboxBackend,
-      routingEnabled: routingEnabled(settings),
-      readActiveSandbox: () => readActiveSandbox3(db, input.workspaceId, input.sessionId)
-    });
+    const checkpointBeforeProviderDispatch = async () => {
+      await awaitModelCallAdmission();
+      await checkpointHistoryBeforeProviderDispatch(historySink, {
+        effectiveSandboxBackend: eventing.modelRunSettings.sandboxBackend,
+        routingEnabled: routingEnabled(settings),
+        readActiveSandbox: () => readActiveSandbox3(db, input.workspaceId, input.sessionId)
+      });
+    };
     try {
       const claimed = await claimTurnAttempt({
         input,
@@ -37025,7 +37437,7 @@ function createRunAgentTurnActivity(services) {
             requiredGeneratedVideoFiles
           });
           if ("exit" in governance) return governance.exit;
-          await assertModelConnectionAllowsTurn(db, {
+          await assertModelConnectionAllowsTurn2(db, {
             workspaceId: input.workspaceId,
             subjectId: turn.initiatingHumanSubjectId ?? "worker:model-access",
             modelId: turnExecutionPolicy.productModelId,
@@ -37039,6 +37451,7 @@ function createRunAgentTurnActivity(services) {
             agentHumanInputEnabled,
             codeSearchEnabled,
             workspaceAgentInstructions,
+            workspaceAgentIdentity,
             workspaceGovernance,
             structuredWorkspacePolicyActive,
             workspaceMemory,
@@ -37221,8 +37634,12 @@ function createRunAgentTurnActivity(services) {
               credentialId: providerTurn.effectiveXaiCredentialId,
               authoritySnapshot: turn.xaiProviderAccountAuthoritySnapshot,
               hostedSearch: {
-                webSearch: runSettings.webSearchEnabled,
-                xSearch: runSettings.webSearchEnabled
+                webSearch: resolveAgentToolFamilies3(session.agent, {
+                  webSearch: runSettings.webSearchEnabled
+                }).webSearch,
+                xSearch: resolveAgentToolFamilies3(session.agent, {
+                  webSearch: runSettings.webSearchEnabled
+                }).webSearch
               },
               streamIdleTimeoutMs: runSettings.supergrokResponseStreamIdleTimeoutMs,
               nextRequestId: () => `${dispatchId}:xai:${++xaiModelRequestSequence}`,
@@ -37332,13 +37749,36 @@ function createRunAgentTurnActivity(services) {
           const claudeUsageObserver = await createClaudeUsageObserver(
             parseModelProvidersJson(runSettings.modelProvidersJson),
             providerTurn.latestClaudeUsage,
-            (scope) => loadClaudeSubscriptionUsageCredential(db, settings, {
+            (scope) => loadClaudeSubscriptionUsageCredential2(db, settings, {
               accountId: input.accountId,
               workspaceId: input.workspaceId,
               scope
             })
           );
-          const withClaudeUsage = (fn) => withClaudeUsageObserver(claudeUsageObserver, fn);
+          const withClaudeUsage = (fn) => withClaudeUsageObserver(claudeUsageObserver, fn, async (providerId, headers) => {
+            const binding = claudeUsageObserver.binding(providerId);
+            if (!binding) return headers;
+            const credential = await resolveClaudeSubscriptionCredential(
+              db,
+              settings,
+              {
+                accountId: input.accountId,
+                workspaceId: input.workspaceId,
+                scope: binding.scope
+              },
+              {
+                expectedConnectionId: binding.expectedConnectionId,
+                expectedCredentialVersion: binding.expectedCredentialVersion
+              }
+            );
+            if (!credential) return headers;
+            if ("reconnectRequired" in credential)
+              throw new ClaudeSubscriptionReconnectRequired();
+            claudeUsageObserver.renew(providerId, credential);
+            headers.set("authorization", `Bearer ${credential.token}`);
+            headers.delete("x-api-key");
+            return headers;
+          });
           const withCodex = (fn) => codexContext ? codexRequestStorage.run(codexContext, fn) : fn();
           const withProviderRequestContext = (fn) => withClaudeUsage(
             () => providerTurn.xaiRequestContext ? xaiSubscriptionRequestStorage.run(providerTurn.xaiRequestContext, fn) : withCodex(fn)
@@ -37396,6 +37836,7 @@ function createRunAgentTurnActivity(services) {
             turnExecutionPolicy,
             resolvedModel,
             workspaceAgentInstructions,
+            workspaceAgentIdentity,
             workspaceGovernance,
             structuredWorkspacePolicyActive,
             workspaceMemory,
@@ -37542,6 +37983,7 @@ These are publication receipts for the human's earlier answer. Do not call the r
             void 0
           );
           const runCredentials = await prepareRunCredentials({
+            turnTools,
             localMcpServerIds: installedApiIntegrations.map((integration) => integration.serverId),
             input,
             settings,
@@ -37557,6 +37999,7 @@ These are publication receipts for the human's earlier answer. Do not call the r
             sandboxRuntime,
             turn,
             session,
+            turnExecutionPolicy,
             fileAuthoritySubjectId,
             runSettings,
             workspaceVariableSet,
@@ -37774,6 +38217,7 @@ These are publication receipts for the human's earlier answer. Do not call the r
             supportsImageInput,
             agentHumanInputEnabled,
             workspaceAgentInstructions,
+            workspaceAgentIdentity,
             workspaceGovernance,
             structuredWorkspacePolicyActive,
             workspaceMemory,
@@ -37898,6 +38342,7 @@ These are publication receipts for the human's earlier answer. Do not call the r
             turnExecutionPolicy,
             resolvedModel,
             workspaceAgentInstructions,
+            workspaceAgentIdentity,
             workspaceGovernance,
             structuredWorkspacePolicyActive,
             workspaceMemory,
@@ -39307,4 +39752,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-FQ5OO2WW.js.map
+//# sourceMappingURL=activities-turn-TESOIOEX.js.map