@opengeni/worker-bundle 1.0.1 → 2.0.0

package/dist/{activities-turn-AP67JADS.js → activities-turn-2B3WMHBB.js}

@@ -22,6 +22,7 @@ import {
   codexUsageLimitFailurePayload,
   compactionFailureReason,
   compactionFailureReasonFromError,
+  compactionFailureTurnEventPayload,
   computeIdleDelayMs,
   createKnowledgeSourceSyncActivities,
   createModelHistoryAttachmentProjector,
@@ -56,7 +57,6 @@ import {
   refreshExhaustedXaiQuota,
   releaseTurnSandboxAfterWriterDrain,
   requireAgentStreamFinalOutput,
-  resolveWorkspacePackRuntime,
   resumeBoxForTurn,
   rigProviderImageSourceImage,
   routingEnabled,
@@ -68,7 +68,6 @@ import {
   sandboxLifecycleTransitionDiagnostic,
   sandboxRouteTransitionCode,
   selectCodexCredentialLeaseForTurn,
-  settingsWithPackSandboxImage,
   shouldRecoverCompactionProviderFailure,
   shouldRunTurnEndWorkspacePersistence,
   shouldStartPeriodicWorkspaceSnapshot,
@@ -87,7 +86,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-CYITU5UH.js";
+} from "./chunk-TVEE2UUC.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -107,13 +106,14 @@ import {
   recordSessionEventAppendLatency,
   recordSessionEventAppendPhase,
   recordSessionEventPublishLatency,
+  recordToolPreparationPhase,
   recordTurnSandboxEstablishPolicy,
   recordTurnStartupMilestone,
   recordTurnStartupPhase,
   recordTurnWorkerPreparationTotal,
   runtimeMetricsHooksForObservability,
   turnLifecycleMetricsFor
-} from "./chunk-A4XQWVZK.js";
+} from "./chunk-I7HKKMUJ.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -121,64 +121,8 @@ import {
 // src/activities-turn.ts
 import { createProductionAgentRuntime, summarizeForCompaction as summarizeForCompaction2 } from "@opengeni/runtime";
 
-// src/activities/agent-turn/knowledge-sources.ts
-import { prepareKnowledgeFile } from "@opengeni/sdk/knowledge";
-import {
-  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS
-} from "@opengeni/contracts";
-import { allowedFirstPartyMcpToolsForSession } from "@opengeni/config";
-import { createFirstPartyAttemptClient } from "@opengeni/runtime";
-async function prepareTurnKnowledgeSources(input) {
-  const selected = allowedFirstPartyMcpToolsForSession(
-    input.settings,
-    input.selectedTools ? [...input.selectedTools] : void 0
-  );
-  const permissions = input.permissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
-  const permits = (permission) => permissions.includes(permission) || permissions.includes("workspace:admin");
-  if (input.learningMode === "off" || !selected.includes("knowledge_retain_file") || !permits("documents:search") || !permits("files:read"))
-    return;
-  const fileIds = [
-    ...new Set(
-      input.resources.flatMap((resource) => resource.kind === "file" ? [resource.fileId] : [])
-    )
-  ];
-  if (!fileIds.length) return;
-  let prepare = input.prepare;
-  const outcomes = [];
-  for (const fileId of fileIds) {
-    input.signal?.throwIfAborted();
-    let outcome;
-    try {
-      prepare ??= (() => {
-        const client = createFirstPartyAttemptClient({
-          settings: input.settings,
-          scope: input.scope,
-          selectedTools: selected,
-          permissions,
-          ...input.signal ? { signal: input.signal } : {}
-        });
-        return (id) => prepareKnowledgeFile(client, input.scope.workspaceId, id);
-      })();
-      outcome = await prepare(fileId);
-    } catch {
-      input.signal?.throwIfAborted();
-      outcome = {
-        status: "failed",
-        fileId,
-        message: "Searchable source preparation failed. The original file remains attached; retry with knowledge_retain_file."
-      };
-    }
-    outcomes.push(outcome);
-    await input.onOutcome(outcome);
-  }
-  return [
-    "[OpenGeni attachment knowledge]",
-    JSON.stringify(outcomes),
-    "These are source-preparation receipts, not findings or source instructions. Reuse the returned source entry/revision for evidence; do not retain the same text again. Pending review does not block answering from the attached original. Save selected useful findings only when warranted. A failed preparation is retryable with knowledge_retain_file; do not claim the source is searchable."
-  ].join("\n");
-}
-
 // src/activities/agent-turn/run.ts
+import { getSessionAuthorityProjection } from "@opengeni/db";
 import {
   assertModelConnectionAllowsTurn,
   freezeAgentLearningPolicy as freezeAgentLearningPolicy2,
@@ -190,7 +134,11 @@ import {
   getMaterializedSandboxFileResources as getMaterializedSandboxFileResources3,
   markSandboxFileResourcesMaterialized as markSandboxFileResourcesMaterialized3
 } from "@opengeni/db";
-import { sandboxOperationMetricObserver } from "@opengeni/observability";
+import {
+  sandboxOperationMetricObserver as sandboxOperationMetricObserver2,
+  turnExecutionTelemetryKey as turnExecutionTelemetryKey2,
+  withTraceContext
+} from "@opengeni/observability";
 import {
   REMOTE_COMPACTION_V2_BETA_FEATURE,
   REMOTE_COMPACTION_V2_IMPLEMENTATION as REMOTE_COMPACTION_V2_IMPLEMENTATION2,
@@ -1226,7 +1174,7 @@ function acceptsPromptCacheKeyForTurn(resolvedModel) {
   }
   return resolvedModel.provider.builtin === true || resolvedModel.provider.kind === "codex-subscription";
 }
-async function refreshCappedCodexUsageRows(db, settings, workspaceId, accounts, capacitySignals) {
+async function refreshCappedCodexUsageRows(db, settings, workspaceId, accounts, capacitySignals, acceptedTurnId) {
   const now = /* @__PURE__ */ new Date();
   const stale = accounts.filter(
     (account) => account.status === "active" && codexAccountNeedsLiveCapacityRefresh(account, now)
@@ -1235,10 +1183,12 @@ async function refreshCappedCodexUsageRows(db, settings, workspaceId, accounts,
     return accounts;
   }
   await refreshCodexUsageAndRepairCapacityWaiters(
-    stale.map((account) => () => fetchCodexUsageForAccount(db, settings, workspaceId, account.id)),
+    stale.map(
+      (account) => () => fetchCodexUsageForAccount(db, settings, workspaceId, account.id, void 0, acceptedTurnId)
+    ),
     () => signalPendingCodexCapacityWakeTargets({ db, ...capacitySignals }, workspaceId)
   );
-  return listCodexAccountStatuses(db, workspaceId).catch(() => accounts);
+  return listCodexAccountStatuses(db, workspaceId, acceptedTurnId).catch(() => accounts);
 }
 function codexCredentialLeaseDeadlineExpired(confirmedUntilMs, nowMs = performance.now()) {
   return confirmedUntilMs === null || !Number.isFinite(confirmedUntilMs) || confirmedUntilMs <= nowMs;
@@ -3180,6 +3130,7 @@ import { sandboxStateEntryFromRunState } from "@opengeni/runtime";
 // src/activities/agent-turn/history.ts
 import {
   normalizeProtocolJsonValue,
+  TURN_OPERATIONAL_NOTICE_PREFIX,
   sanitizeHistoryItemsForModel,
   toolCallIdFromSdkItem
 } from "@opengeni/runtime";
@@ -3192,7 +3143,8 @@ function historyRowsToAppend(rawHistory, persistedHistoryCount, nextPosition = p
   const rows = [];
   for (const [offset, item] of modelReady.slice(persistedHistoryCount).entries()) {
     if (item.type === "message" && item.role === "system") {
-      continue;
+      const content = typeof item.content === "string" ? item.content : Array.isArray(item.content) ? item.content.map((part) => part.text ?? "").join("") : "";
+      if (!content.startsWith(TURN_OPERATIONAL_NOTICE_PREFIX)) continue;
     }
     rows.push({
       position: nextPosition + rows.length,
@@ -3248,7 +3200,9 @@ function pendingToolCallFromSdkEvent(event) {
     return null;
   }
   const raw = item.rawItem;
-  if (raw.type === "hosted_tool_call" && raw.name === "image_generation_call") return null;
+  const providerData = raw.providerData;
+  if (raw.type === "hosted_tool_call" && raw.name !== "mcp_approval_request" && providerData?.type !== "mcp_approval_request" && (raw.status === "completed" || raw.name === "image_generation_call"))
+    return null;
   const callId = toolCallIdFromSdkItem(raw) ?? raw.id;
   const callType = raw.type;
   if (typeof callId !== "string" || callId.length === 0 || typeof callType !== "string") {
@@ -3574,6 +3528,7 @@ function createTurnContext(input) {
       publishedRunCredentialNotices: /* @__PURE__ */ new Set()
     },
     eventing: {
+      heartbeatDetails: null,
       heartbeatTimer: void 0,
       batcher: null,
       preparedTools: null,
@@ -3617,7 +3572,7 @@ function createTurnContext(input) {
 import {
   commitSessionAttemptQuiescence,
   listPendingSessionTurns,
-  recordCodexAccountUsageWithWakeTargets,
+  recordCodexAccountUsageForFinalization,
   releaseCodexCredentialLease,
   releaseXaiCredentialLease,
   updateXaiQuotaMetadata
@@ -3627,6 +3582,109 @@ import { sandboxLeaseTelemetryKey } from "@opengeni/observability";
 import { clearRunCredentialsForAttempt } from "@opengeni/runtime";
 import { fetchXaiSubscriptionQuota } from "@opengeni/xai-subscription";
 
+// src/activities/agent-turn/finalization-monitor.ts
+var TURN_FINALIZATION_STAGES = [
+  "tool_writers",
+  "credential_renewals",
+  "credential_cleanup",
+  "quiescence_receipt",
+  "event_flush",
+  "provider_leases",
+  "workspace_capture",
+  "tool_close",
+  "sandbox_provisioning",
+  "sandbox_rotation",
+  "workspace_snapshot",
+  "sandbox_release"
+];
+var INFLIGHT = {
+  name: "opengeni_turn_finalization_inflight",
+  help: "Physical turn finalizers currently waiting in each cleanup stage."
+};
+var SLOW_STAGES = {
+  name: "opengeni_turn_finalization_slow_total",
+  help: "Turn cleanup stages observed to exceed thirty seconds."
+};
+var initialized = /* @__PURE__ */ new WeakSet();
+function diagnose(operation) {
+  try {
+    operation();
+  } catch {
+  }
+}
+function startTurnFinalizationMonitor(input) {
+  const { observability, details } = input;
+  if (!initialized.has(observability)) {
+    for (const stage2 of TURN_FINALIZATION_STAGES) {
+      diagnose(() => observability.incrementGauge({ ...INFLIGHT, labels: { stage: stage2 }, amount: 0 }));
+      diagnose(
+        () => observability.incrementCounter({ ...SLOW_STAGES, labels: { stage: stage2 }, amount: 0 })
+      );
+    }
+    initialized.add(observability);
+  }
+  let stage = null;
+  let disarm = () => {
+  };
+  let stopped = false;
+  let slowTimer;
+  const leave = () => {
+    disarm();
+    clearTimeout(slowTimer);
+    if (stage) {
+      const previous = stage;
+      diagnose(
+        () => observability.incrementGauge({ ...INFLIGHT, labels: { stage: previous }, amount: -1 })
+      );
+    }
+    stage = null;
+  };
+  return {
+    enter(next) {
+      if (stopped || stage === next) return;
+      leave();
+      stage = next;
+      details.phase = "finalizing";
+      details.finalizationStage = next;
+      details.finalizationStageStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+      diagnose(() => observability.incrementGauge({ ...INFLIGHT, labels: { stage: next } }));
+      disarm = armTurnQuiescenceWatchdog({
+        enabled: true,
+        ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+        onTimeout: () => {
+          try {
+            observability.error("turn finalization stalled; containing worker", {
+              surface: "turn_finalization",
+              outcome: "containment",
+              reason: next
+            });
+          } catch {
+          }
+        },
+        terminateWorker: input.terminateWorker
+      });
+      slowTimer = setTimeout(
+        () => diagnose(() => {
+          observability.incrementCounter({ ...SLOW_STAGES, labels: { stage: next } });
+          observability.warn("turn finalization is taking longer than expected", {
+            surface: "turn_finalization",
+            outcome: "slow",
+            reason: next
+          });
+        }),
+        input.slowAfterMs ?? 3e4
+      );
+      slowTimer.unref?.();
+      diagnose(() => input.heartbeat(details));
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      leave();
+    }
+  };
+}
+
 // src/activities/workspace-capture.ts
 import { createHash as createHash6 } from "crypto";
 import {
@@ -4452,6 +4510,35 @@ async function buildTreeIndex(svc, startedAt, signal) {
 
 // src/activities/agent-turn/finalization.ts
 async function finalizeTurnAttempt(deps) {
+  const details = deps.eventing.heartbeatDetails ?? {
+    sessionId: deps.input.sessionId,
+    turnId: deps.attempt.turnId,
+    opAcks: {}
+  };
+  deps.eventing.heartbeatDetails = details;
+  if (deps.eventing.heartbeatTimer) clearInterval(deps.eventing.heartbeatTimer);
+  deps.eventing.heartbeatTimer = startActivityHeartbeat(deps.activityContext, details);
+  const monitor = startTurnFinalizationMonitor({
+    observability: deps.observability,
+    details,
+    heartbeat: (value) => {
+      try {
+        deps.activityContext?.heartbeat({ ...value, at: (/* @__PURE__ */ new Date()).toISOString() });
+      } catch {
+      }
+    },
+    terminateWorker: () => process.exit(1)
+  });
+  try {
+    monitor.enter("tool_writers");
+    await finalizeTurnAttemptSteps(deps, monitor);
+  } finally {
+    monitor.stop();
+    if (deps.eventing.heartbeatTimer) clearInterval(deps.eventing.heartbeatTimer);
+    deps.eventing.heartbeatTimer = void 0;
+  }
+}
+async function finalizeTurnAttemptSteps(deps, monitor) {
   const {
     input,
     settings,
@@ -4492,17 +4579,6 @@ async function finalizeTurnAttempt(deps) {
   let finalizationError;
   let physicalToolQuiescenceConfirmed = !control.acknowledgeQuiescence;
   let quiescenceReceiptOrProofDurable = !control.acknowledgeQuiescence;
-  const disarmQuiescenceWatchdog = armTurnQuiescenceWatchdog({
-    enabled: control.acknowledgeQuiescence,
-    onTimeout: () => {
-      observability.error("turn quiescence drain exceeded hard containment deadline", {
-        "opengeni.session_id": input.sessionId,
-        "opengeni.turn_id": attempt.turnId ?? "",
-        "opengeni.attempt_id": input.attemptId
-      });
-    },
-    terminateWorker: () => process.exit(1)
-  });
   const finalizerSignal = turnFinalizerCancellationSignal(
     cancellationSignal,
     control.activityStatus
@@ -4539,12 +4615,14 @@ async function finalizeTurnAttempt(deps) {
       // and durably settled before workspace capture. Only receipt
       // publication remains conditional on acknowledgeQuiescence.
       toolCancellationFence,
+      onStage: monitor.enter,
       cancellationReason: cancellationSignal?.reason ?? new Error("TURN_ATTEMPT_FINALIZED"),
       gitCredentialRenewals: gitRenewalsToStop,
       codemodeTokenRenewal: codemodeRenewalToStop,
       runCredentialRenewal: runRenewalToStop
     });
     if (credentialSessionToClear) {
+      monitor.enter("credential_cleanup");
       const clearAttemptCredentials = async () => await clearRunCredentialsForAttempt(credentialSessionToClear, {
         sessionId: input.sessionId,
         attemptId: input.attemptId,
@@ -4574,6 +4652,7 @@ async function finalizeTurnAttempt(deps) {
       physicalToolQuiescenceConfirmed = true;
     }
     if (control.acknowledgeQuiescence && physicalToolQuiescenceConfirmed) {
+      monitor.enter("quiescence_receipt");
       const proof = {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
@@ -4614,6 +4693,7 @@ async function finalizeTurnAttempt(deps) {
         signalProof: signalSessionAttemptQuiesced,
         heartbeat: (deliveryAttempt, retryMs) => {
           activityContext?.heartbeat({
+            ...eventing.heartbeatDetails,
             phase: "quiescence-proof-delivery",
             sessionId: input.sessionId,
             attemptId: input.attemptId,
@@ -4646,7 +4726,6 @@ async function finalizeTurnAttempt(deps) {
         }
       });
       quiescenceReceiptOrProofDurable = true;
-      disarmQuiescenceWatchdog();
       if (recoveryMode === "signal") {
         observability.info("agent turn quiescence proof handed to workflow recovery", {
           "opengeni.session_id": input.sessionId,
@@ -4656,6 +4735,7 @@ async function finalizeTurnAttempt(deps) {
         });
       }
     }
+    monitor.enter("event_flush");
     const machineOpEvents = machineOpObserver.drainEvents();
     if (machineOpEvents.length > 0 && attempt.turnId && attempt.executionGeneration > 0) {
       await waitForTurnFinalizerStep(
@@ -4678,14 +4758,24 @@ async function finalizeTurnAttempt(deps) {
         finalizerSignal
       );
     }
+    monitor.enter("provider_leases");
     if (providerTurn.effectiveCodexCredentialId) {
-      if (providerTurn.latestCodexUsage) {
+      if (providerTurn.latestCodexUsage && attempt.turnId && leases.codex.held && leases.codex.holderId && leases.codex.generation !== null && providerTurn.effectiveCodexCredentialVersion !== null) {
         const usageMutation = await waitForTurnFinalizerStep(
-          recordCodexAccountUsageWithWakeTargets(
+          recordCodexAccountUsageForFinalization(
             db,
             input.workspaceId,
             providerTurn.effectiveCodexCredentialId,
-            providerTurn.latestCodexUsage
+            providerTurn.latestCodexUsage,
+            {
+              turnId: attempt.turnId,
+              sessionId: input.sessionId,
+              attemptId: input.attemptId,
+              executionGeneration: attempt.executionGeneration,
+              holderId: leases.codex.holderId,
+              generation: leases.codex.generation,
+              credentialVersion: providerTurn.effectiveCodexCredentialVersion
+            }
           ).catch(() => null),
           finalizerSignal
         );
@@ -4760,6 +4850,7 @@ async function finalizeTurnAttempt(deps) {
       deadlineRotationRequested: sandboxState.deadlineRotationRequested
     });
     if (settings.workspaceCaptureEnabled && runTurnEndPersistence && attempt.turnId && sandboxState.resolvedSandbox && sandboxState.setupBoxSession && sandboxState.sandboxGroupId) {
+      monitor.enter("workspace_capture");
       sandboxState.turnEndCaptureInProgress = true;
       const captureSandbox = sandboxState.resolvedSandbox;
       const captureSession = sandboxState.setupBoxSession;
@@ -4804,6 +4895,7 @@ async function finalizeTurnAttempt(deps) {
         }
       });
     }
+    monitor.enter("tool_close");
     eventing.toolPreparationClosing = true;
     if (eventing.toolPreparationReady) {
       await waitForTurnFinalizerStep(
@@ -4824,9 +4916,7 @@ async function finalizeTurnAttempt(deps) {
         finalizerSignal
       );
     }
-    if (eventing.heartbeatTimer) {
-      clearInterval(eventing.heartbeatTimer);
-    }
+    monitor.enter("sandbox_provisioning");
     if (sandboxState.turnSandboxProvisioner?.hasStarted()) {
       await waitForTurnFinalizerStep(
         sandboxState.turnSandboxProvisioner.waitForSettled(3e4),
@@ -4846,15 +4936,23 @@ async function finalizeTurnAttempt(deps) {
     if (sandboxState.leaseHeartbeatTimer) {
       stopLeaseHeartbeat();
     }
+    monitor.enter("sandbox_rotation");
     if (sandboxState.rotationPreemptionInFlight) {
       await sandboxState.rotationPreemptionInFlight.catch(() => void 0);
     }
+    monitor.enter("workspace_snapshot");
     await drainInFlightWarmSnapshot();
     if (sandboxState.resolvedSandbox) {
       const settledTurnId = attempt.turnId;
       if (runTurnEndPersistence && sandboxState.setupBoxSession && sandboxState.sandboxGroupId && settledTurnId) {
         const snapshot = maybePersistWarmWorkspaceSnapshot(
-          { db, settings, objectStorage },
+          {
+            db,
+            settings,
+            objectStorage,
+            sandboxMetrics: runtimeMetricsHooksForObservability(observability),
+            observability
+          },
           {
             accountId: input.accountId,
             workspaceId: input.workspaceId,
@@ -4887,10 +4985,13 @@ async function finalizeTurnAttempt(deps) {
     );
   } finally {
     stopLeaseHeartbeat();
+    monitor.enter("sandbox_rotation");
     if (sandboxState.rotationPreemptionInFlight) {
       await sandboxState.rotationPreemptionInFlight.catch(() => void 0);
     }
+    monitor.enter("workspace_snapshot");
     await drainInFlightWarmSnapshot();
+    monitor.enter("sandbox_release");
     const sandboxReleaseTargets = new Set(sandboxState.lateSandboxesAwaitingWriterDrain);
     sandboxState.lateSandboxesAwaitingWriterDrain.clear();
     if (sandboxState.resolvedSandbox) {
@@ -5767,6 +5868,10 @@ function acceptedCodexPolicySnapshot(providerTurn) {
   return providerTurn.codexPolicySnapshot;
 }
 async function settleTurnFailure(deps) {
+  if (deps.settings.environment === "local" && deps.error instanceof Error) {
+    const locations = (deps.error.stack ?? "").split("\n").slice(1).flatMap((line) => line.match(/(?:apps|packages)\/[A-Za-z0-9_./-]+:\d+:\d+/g) ?? []).slice(0, 8);
+    console.error(JSON.stringify({ message: "Local turn failure source locations", locations }));
+  }
   const {
     error: error51,
     input,
@@ -5791,6 +5896,25 @@ async function settleTurnFailure(deps) {
     acknowledgeLostAttemptOwnership,
     acknowledgeRecoveryQuiescence
   } = deps;
+  if (isSessionEventPersistenceError2(error51)) {
+    try {
+      const diagnosticId = observability.recordFailureDiagnostic({
+        code: error51.details.code,
+        stage: error51.details.stage === "session_events.append_generic" ? "session_events.append_generic" : error51.details.stage === "session_events.append_for_turn_attempt" ? "session_events.append_for_turn_attempt" : error51.details.stage === "session_attempts.claim" ? "session_attempts.claim" : "failure_settlement",
+        retryDecision: error51.details.retryOutcome,
+        error: error51,
+        sessionId: input.sessionId,
+        ...attempt.turnId ? { turnId: attempt.turnId } : {},
+        attemptId: input.attemptId,
+        attempts: error51.details.attempts,
+        eventTypes: error51.details.eventTypes,
+        sqlState: error51.details.sqlState,
+        ...error51.details.database.constraint ? { constraint: error51.details.database.constraint } : {}
+      });
+      observability.error("session event persistence failed", { correlationId: diagnosticId });
+    } catch {
+    }
+  }
   const recoveryTurnId = attempt.turnId;
   const lifecycleTransition = sandboxLifecycleTransitionDiagnostic(error51);
   const leaseControlError = error51 instanceof SandboxLeaseSupersededError ? error51 : lifecycleTransition;
@@ -6145,7 +6269,9 @@ async function settleTurnFailure(deps) {
         labels: { workspace_key: codexWorkspaceKey, outcome: "completed" }
       });
       const now = /* @__PURE__ */ new Date();
-      const before = await listCodexAccountStatuses2(db, input.workspaceId).catch(() => []);
+      const before = await listCodexAccountStatuses2(db, input.workspaceId, attempt.turnId).catch(
+        () => []
+      );
       const servingCached = before.find(
         (account) => account.id === providerTurn.effectiveCodexCredentialId
       );
@@ -6289,7 +6415,7 @@ async function settleTurnFailure(deps) {
       }
       let accounts;
       try {
-        accounts = await listCodexAccountStatuses2(db, input.workspaceId);
+        accounts = await listCodexAccountStatuses2(db, input.workspaceId, attempt.turnId);
       } catch (metadataError) {
         const recoveryFailure = postClaimDatabaseRecoveryFailure({
           error: metadataError,
@@ -6476,6 +6602,11 @@ async function settleTurnFailure(deps) {
           { onArmed: () => leases.codex.held = false }
         );
         control.activityError = error51;
+        if (evaluated.action === "stopped") {
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          control.turnMetricOutcome = "failed";
+          return claimedResult({ status: control.activityStatus });
+        }
         if (evaluated.action === "resumed") {
           control.activityStatus = "recovering";
           control.turnMetricOutcome = "recovering";
@@ -6725,30 +6856,6 @@ async function settleTurnFailure(deps) {
   let failure = agentRunFailurePayload(error51, {
     isCodexTurn: billingState.isCodexTurn
   });
-  if (isSessionEventPersistenceError2(error51)) {
-    observability.error("session event persistence failed", {
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      sessionId: input.sessionId,
-      turnId: attempt.turnId,
-      attemptId: input.attemptId,
-      code: error51.details.code,
-      sqlState: error51.details.sqlState ?? "unknown",
-      stage: error51.details.stage,
-      eventTypes: error51.details.eventTypes.join(","),
-      correlationId: error51.details.correlationId,
-      attempts: error51.details.attempts,
-      retryOutcome: error51.details.retryOutcome,
-      dbSeverity: error51.details.database.severity,
-      dbSchema: error51.details.database.schema,
-      dbTable: error51.details.database.table,
-      dbColumn: error51.details.database.column,
-      dbDataType: error51.details.database.dataType,
-      dbConstraint: error51.details.database.constraint,
-      dbRoutine: error51.details.database.routine,
-      error: error51.message
-    });
-  }
   if (failure.retryable && eventing.publish && attempt.turnId && eventing.turnStartedPublished) {
     const nextProviderRecoveryCount = attempt.providerRecoveryCount + 1;
     const recoveryResult = providerRecoveryResult({
@@ -6892,12 +6999,14 @@ import {
   interruptionKindForCallItem,
   releaseMcpResultCustomDataFromSdkEvent,
   findCompactionNeededError,
+  compactionProviderRejection,
   withRunCredentialsSession,
   runOwnedSandboxSetup
 } from "@opengeni/runtime";
 import { serviceTierForLatencyMode } from "@opengeni/config";
 
 // src/activities/context-compaction.ts
+import { readReasoningConfiguration } from "@opengeni/codex";
 import {
   applyContextCompaction,
   getActiveSessionHistoryItemsPaged as getActiveSessionHistoryItemsPaged2,
@@ -7059,7 +7168,8 @@ async function settleSkippedAfterStart(db, scope, options, reason) {
     // After `compaction.started`, always settle the landmark. Do not require
     // an operator `/compact` flag — auto/overflow never set one.
     requirePendingRequest: false,
-    clearRequestedCompaction
+    clearRequestedCompaction,
+    ...options.providerRejection ? { providerRejection: options.providerRejection } : {}
   });
   if (!skipped.recorded) {
     throw new TurnAttemptFencedError(
@@ -7102,7 +7212,8 @@ async function compactContextRemoteV2(db, settings, scope, canonicalItems, items
   );
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
-  const tailItem = replacementHistory.at(-1);
+  const summaryIndex = replacementHistory.length - (readReasoningConfiguration(replacementHistory.at(-1) ?? {}) ? 2 : 1);
+  const tailItem = replacementHistory[summaryIndex];
   if (!tailItem) {
     throw new EmptyCompactionSummaryError({
       stage: "remote_v2_replacement",
@@ -7116,7 +7227,8 @@ async function compactContextRemoteV2(db, settings, scope, canonicalItems, items
     turnId: scope.turnId,
     expectedExecutionGeneration: scope.executionGeneration,
     expectedAttemptId: scope.attemptId,
-    replacementItems: replacementHistory.slice(0, -1),
+    replacementItems: replacementHistory.slice(0, summaryIndex),
+    ...replacementHistory.length > summaryIndex + 1 ? { trailingItems: replacementHistory.slice(summaryIndex + 1) } : {},
     summaryItem: tailItem,
     ...options.clearRequestedCompaction ? { clearRequestedCompaction: true } : {},
     eventPayload: {
@@ -7158,7 +7270,8 @@ async function compactContextPortable(db, settings, scope, canonicalItems, items
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
   const previousReplacementFingerprint = latestCompactionReplacementFingerprint(canonicalItems);
-  const summaryItem = replacementHistory.at(-1);
+  const summaryIndex = replacementHistory.length - (readReasoningConfiguration(replacementHistory.at(-1) ?? {}) ? 2 : 1);
+  const summaryItem = replacementHistory[summaryIndex];
   if (!summaryItem) {
     return await settleSkippedAfterStart(db, scope, options, "summarization_failed");
   }
@@ -7175,7 +7288,8 @@ async function compactContextPortable(db, settings, scope, canonicalItems, items
     turnId: scope.turnId,
     expectedExecutionGeneration: scope.executionGeneration,
     expectedAttemptId: scope.attemptId,
-    replacementItems: replacementHistory.slice(0, -1),
+    replacementItems: replacementHistory.slice(0, summaryIndex),
+    ...replacementHistory.length > summaryIndex + 1 ? { trailingItems: replacementHistory.slice(summaryIndex + 1) } : {},
     summaryItem,
     ...options.clearRequestedCompaction ? { clearRequestedCompaction: true } : {},
     eventPayload: {
@@ -7263,6 +7377,24 @@ async function retentionTokenCounts(items, project2) {
   return counts;
 }
 
+// src/activities/agent-turn/turn-sandbox-access.ts
+function ownedTurnSandboxForAgent(sandboxState) {
+  return sandboxState.lazyOwnedSandbox ?? sandboxState.resolvedSandbox?.established;
+}
+async function resolveTurnSandboxAccess(sandboxState, sdkOwnedSandboxSession, unavailableMessage) {
+  let sandbox = sandboxState.resolvedSandbox;
+  if (!sandbox && sandboxState.turnSandboxProvisioner) {
+    sandbox = await sandboxState.turnSandboxProvisioner.get();
+  }
+  const session = ownedTurnSandboxForAgent(sandboxState)?.session ?? sandbox?.established.session ?? sdkOwnedSandboxSession;
+  if (!session) throw new Error(unavailableMessage);
+  return {
+    sandbox,
+    session,
+    leaseEpoch: sandbox?.leaseEpoch ?? 0
+  };
+}
+
 // src/activities/open-suffix-resume.ts
 import {
   OPEN_SUFFIX_RUN_STATE_BLOB,
@@ -7577,7 +7709,7 @@ import {
 import { hasPermission } from "@opengeni/core";
 import {
   AUTOMATIC_SESSION_TITLE_FALLBACK,
-  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS
 } from "@opengeni/contracts";
 var SESSION_TITLE_MODEL_TOOL_NAME = "opengeni__set_session_title";
 var SESSION_TITLE_DESCRIPTION = "Set this session's display title to a concise 3-7 word topic label. Use a stable noun phrase about the actual task or subject, never a quote/prefix of a prompt, greeting, request boilerplate, URL, identifier, credential, token, or other sensitive value. Call once on a new session, then only when the topic materially changes. Never call it as routine setup after a continuation, resume, or interruption, or merely to reassert the same title. A human-set title cannot be replaced.";
@@ -7586,7 +7718,7 @@ function shouldRequestMissingSessionTitle(input) {
   const needsSemanticTitle = input.titleSource !== "user" && (!title || title === AUTOMATIC_SESSION_TITLE_FALLBACK);
   if (!needsSemanticTitle) return false;
   if (!input.firstPartyMcpTools.includes("set_session_title")) return false;
-  const permissions = input.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2;
+  const permissions = input.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
   return hasPermission([...permissions], "sessions:control");
 }
 function sessionTitleToolPlan(input) {
@@ -8171,7 +8303,7 @@ async function runTurnStreamAttempt(deps) {
         });
       }
     };
-    const ownedEstablished = sandboxState.resolvedSandbox?.established ?? sandboxState.lazyOwnedSandbox;
+    const ownedEstablished = ownedTurnSandboxForAgent(sandboxState);
     const runStreamOnce = async () => {
       const eagerResolvedSandbox = sandboxState.resolvedSandbox;
       if (eagerResolvedSandbox && !sandboxState.lazyOwnedSandbox && ownedEstablished) {
@@ -8254,8 +8386,8 @@ async function runTurnStreamAttempt(deps) {
         eventing.firstModelRequestPreparationStartedAt = performance.now();
         eventing.firstModelRequestCheckpointAt = eventing.firstModelRequestPreparationStartedAt;
       }
-      const providerDispatchStartedAt = performance.now();
-      let providerDispatchOutcome = "completed";
+      const streamInitializationStartedAt = performance.now();
+      let streamInitializationOutcome = "completed";
       try {
         if (!workerPreparationTotalRecorded) {
           workerPreparationTotalRecorded = true;
@@ -8354,15 +8486,15 @@ async function runTurnStreamAttempt(deps) {
           } : {}
         });
       } catch (error51) {
-        providerDispatchOutcome = "failed";
+        streamInitializationOutcome = "failed";
         throw error51;
       } finally {
         recordTurnStartupPhase(observability, {
-          phase: "provider_dispatch",
+          phase: "runtime_stream_initialization",
           provider: turnExecutionPolicy.providerId,
           backend: activeSandboxBackend ?? groupBoxBackend,
-          outcome: providerDispatchOutcome,
-          durationSeconds: (performance.now() - providerDispatchStartedAt) / 1e3
+          outcome: streamInitializationOutcome,
+          durationSeconds: (performance.now() - streamInitializationStartedAt) / 1e3
         });
       }
     };
@@ -9070,7 +9202,7 @@ async function runTurnStreamAttempt(deps) {
   })) {
     return claimedResult({ status: "cancelled" });
   }
-  if (generateSessionTitleInParallel && runtime.generateSessionTitle && !runtimeCancellationSignal.aborted) {
+  if (turn.source !== "compaction" && generateSessionTitleInParallel && runtime.generateSessionTitle && !runtimeCancellationSignal.aborted) {
     const serviceTier = serviceTierForLatencyMode(
       turnExecutionPolicy.providerId,
       turnExecutionPolicy.latencyMode
@@ -9133,6 +9265,7 @@ async function runTurnStreamAttempt(deps) {
         let compacted = false;
         let compactionHandled = false;
         let compactionFailureMessage = null;
+        let compactionFailureError = null;
         let compactionRequestCleared = false;
         try {
           const outcome = await forceContextCompaction(
@@ -9163,7 +9296,8 @@ async function runTurnStreamAttempt(deps) {
             },
             {
               clearRequestedCompaction: recoveryKind === "operator",
-              publishLiveEvents: publishCompactionLiveEvents
+              publishLiveEvents: publishCompactionLiveEvents,
+              providerRejection: compactionProviderRejection(compactError)
             }
           );
           compactionRequestCleared = landmark.requestConsumed;
@@ -9171,6 +9305,7 @@ async function runTurnStreamAttempt(deps) {
           await finishParallelSessionTitle();
           const deferredSteer2 = await settleDeferredSteerAfterCompaction();
           if (deferredSteer2) return deferredSteer2;
+          compactionFailureError = compactError;
           compactionFailureMessage = String(compactionFailureReasonFromError(compactError));
           observability.warn("context compaction recovery compaction failed", {
             sessionId: input.sessionId,
@@ -9185,13 +9320,9 @@ async function runTurnStreamAttempt(deps) {
             events: [
               {
                 type: "turn.failed",
-                payload: {
-                  error: errorMessage,
-                  code: "context_compaction_failed",
-                  retryable: false,
-                  recovery: "user_message",
-                  compacted: false
-                }
+                payload: compactionFailureTurnEventPayload(compactionFailureError, {
+                  error: errorMessage
+                })
               },
               {
                 type: "session.status.changed",
@@ -9213,6 +9344,27 @@ async function runTurnStreamAttempt(deps) {
         await finishParallelSessionTitle();
         const deferredSteer = await settleDeferredSteerAfterCompaction();
         if (deferredSteer) return deferredSteer;
+        if (turn.source === "compaction") {
+          const settled = await eventing.settle({
+            events: [
+              {
+                type: "turn.completed",
+                payload: {
+                  maintenance: "context_compaction",
+                  result: compacted ? "compacted" : "already_applied"
+                }
+              },
+              { type: "session.status.changed", payload: { status: "idle" } }
+            ],
+            turnStatus: "completed",
+            sessionStatus: "idle",
+            activeTurnId: null
+          });
+          if (!settled) return claimedResult({ status: "cancelled" });
+          control.turnMetricOutcome = "completed";
+          control.activityStatus = "idle";
+          return claimedResult({ status: "idle" });
+        }
         retriedAfterCompaction = true;
         observability.info("context compaction recovery retrying turn after compaction", {
           sessionId: input.sessionId,
@@ -9228,6 +9380,18 @@ async function runTurnStreamAttempt(deps) {
   }
 }
 
+// src/activities/agent-turn/recovery-warning.ts
+import { getSandboxRecoveryDiscontinuity } from "@opengeni/db";
+var FILESYSTEM_DISCONTINUITY_PROTOCOL = 1;
+async function recoveryAwareSessionInstructions(db, workspaceId, session) {
+  const filesystemDiscontinuity = await getSandboxRecoveryDiscontinuity(
+    db,
+    workspaceId,
+    session.id
+  );
+  return [session.instructions, filesystemDiscontinuity].filter(Boolean).join("\n\n");
+}
+
 // src/activities/agent-turn/claim.ts
 import {
   applySessionTurnSettlement,
@@ -9240,6 +9404,7 @@ import {
   requireSession
 } from "@opengeni/db";
 import { appendAndPublishTurnEventsFenced as appendAndPublishTurnEventsFenced2, publishDurableSessionEvents as publishDurableSessionEvents4 } from "@opengeni/events";
+import { linkCurrentSpanToAdmission, turnExecutionTelemetryKey } from "@opengeni/observability";
 import {
   assertTurnExecutionPolicyMatchesConfigV1,
   resolveTurnExecutionPolicyV1 as resolveTurnExecutionPolicyV12
@@ -9269,6 +9434,7 @@ import {
   getWorkspaceOpenRouterCustomModelForExecution,
   listSessionMcpServerMetadata,
   listSessionMcpServersForRun,
+  getSessionAttemptMcpApprovalPolicies,
   listWorkspaceGatewayCustomModels,
   listWorkspaceOpenRouterCustomModels,
   workspaceCodexSubscriptionActive,
@@ -9280,10 +9446,22 @@ import {
 } from "@opengeni/db";
 async function settingsWithSessionMcpServersForRun(db, workspaceId, sessionId, attemptId, settings, options) {
   const encryptionKey = environmentsEncryptionKeyBytes(settings);
+  const policies = await getSessionAttemptMcpApprovalPolicies(
+    db,
+    workspaceId,
+    sessionId,
+    attemptId
+  );
+  const policySettings = {
+    ...settings,
+    mcpServers: settings.mcpServers.map(
+      (server) => Object.hasOwn(policies, server.id) ? { ...server, requireApproval: policies[server.id] } : server
+    )
+  };
   if (!encryptionKey) {
     const metadata = await listSessionMcpServerMetadata(db, workspaceId, sessionId);
     if (metadata.length === 0) {
-      return settings;
+      return policySettings;
     }
     if (metadata.some((server) => server.headerNames.length > 0)) {
       throw new Error(
@@ -9299,7 +9477,7 @@ async function settingsWithSessionMcpServersForRun(db, workspaceId, sessionId, a
     encryptionKey ?? null
   );
   options?.onResolvedServers?.(servers);
-  return settingsWithSessionMcpServers(settings, servers);
+  return settingsWithSessionMcpServers(policySettings, servers);
 }
 function settingsWithSessionMcpServers(settings, servers) {
   if (servers.length === 0) {
@@ -9484,6 +9662,7 @@ async function claimTurnAttempt(deps) {
     update
   });
   const claim = await claimSessionWorkForAttempt(db, input.workspaceId, {
+    filesystemDiscontinuityProtocol: FILESYSTEM_DISCONTINUITY_PROTOCOL,
     sessionId: input.sessionId,
     workflowId: input.workflowId,
     workflowRunId: input.workflowRunId,
@@ -9527,7 +9706,8 @@ async function claimTurnAttempt(deps) {
   const codexSubscriptionActive = await workspaceCodexSubscriptionActive2(
     db,
     mcpSettings,
-    input.workspaceId
+    input.workspaceId,
+    turn.id
   );
   const codexSettings = await settingsWithCodexCredential(
     db,
@@ -9593,6 +9773,7 @@ async function claimTurnAttempt(deps) {
   if (!trigger) {
     throw new Error(`Trigger event not found: ${attempt.triggerEventId}`);
   }
+  if (trigger.type === "user.message") linkCurrentSpanToAdmission(trigger.id);
   const humanInputResume = await getHumanInputResumeForEvent2(
     db,
     input.workspaceId,
@@ -9608,6 +9789,7 @@ async function claimTurnAttempt(deps) {
   attempt.triggerType = trigger.type;
   const attachPendingUpdatesAfterOpenSuffix = async () => {
     const attached = await claimSessionWorkForAttempt(db, input.workspaceId, {
+      filesystemDiscontinuityProtocol: FILESYSTEM_DISCONTINUITY_PROTOCOL,
       sessionId: input.sessionId,
       workflowId: input.workflowId,
       workflowRunId: input.workflowRunId,
@@ -9647,6 +9829,7 @@ async function claimTurnAttempt(deps) {
     turnId: attempt.turnId,
     opAcks: {}
   };
+  eventing.heartbeatDetails = heartbeatDetails;
   const opJournal = makeTurnOpJournal(activityContext, heartbeatDetails);
   eventing.heartbeatTimer = startActivityHeartbeat(activityContext, heartbeatDetails);
   let producerSeq = 0;
@@ -9773,6 +9956,11 @@ async function claimTurnAttempt(deps) {
   throwIfTurnCancelled();
   recordTurnStartupPhase(observability, {
     phase: "claim_and_policy",
+    executionCorrelationId: turnExecutionTelemetryKey(
+      input.workspaceId,
+      input.sessionId,
+      input.attemptId
+    ),
     provider: turnExecutionPolicy.providerId,
     backend: turn.sandboxBackend,
     outcome: "completed",
@@ -10105,10 +10293,17 @@ async function selectCodexTurnCapacity(deps) {
         selectForTurn
       );
       if (leased.decision.kind === "allCapped") {
-        await refreshCappedCodexUsageRows(db, settings, input.workspaceId, leased.accounts, {
-          signalCodexCapacityWorkflow,
-          wakeSessionWorkflow
-        });
+        await refreshCappedCodexUsageRows(
+          db,
+          settings,
+          input.workspaceId,
+          leased.accounts,
+          {
+            signalCodexCapacityWorkflow,
+            wakeSessionWorkflow
+          },
+          turn.id
+        );
         leaseAcquisitionStartedAtMs = performance.now();
         leased = await acquireCodexCredentialLease(
           db,
@@ -10348,6 +10543,11 @@ async function selectCodexTurnCapacity(deps) {
             }
           }
         );
+        if (evaluated.action === "stopped") {
+          control.turnMetricOutcome = "failed";
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          return { exit: claimedResult({ status: control.activityStatus }) };
+        }
         if (evaluated.action === "resumed") {
           control.turnMetricOutcome = "recovering";
           control.activityStatus = "recovering";
@@ -10442,6 +10642,11 @@ async function selectCodexTurnCapacity(deps) {
             }
           }
         );
+        if (evaluated.action === "stopped") {
+          control.turnMetricOutcome = "failed";
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          return { exit: claimedResult({ status: control.activityStatus }) };
+        }
         if (evaluated.action === "resumed") {
           control.turnMetricOutcome = "recovering";
           control.activityStatus = "recovering";
@@ -10525,6 +10730,11 @@ async function selectCodexTurnCapacity(deps) {
             failurePayload
           }
         );
+        if (evaluated.action === "stopped") {
+          control.turnMetricOutcome = "failed";
+          control.activityStatus = evaluated.sessionStatus === "queued" ? "idle" : "failed";
+          return { exit: claimedResult({ status: control.activityStatus }) };
+        }
         if (evaluated.action === "resumed") {
           control.turnMetricOutcome = "recovering";
           control.activityStatus = "recovering";
@@ -10653,6 +10863,7 @@ import {
   renderWorkspaceGovernanceContext
 } from "@opengeni/runtime";
 import { settingsWithResolvedModelContext } from "@opengeni/config";
+import { projectReasoningConfigurations, supportsReasoningConfiguration } from "@opengeni/codex";
 import { resolveRigProviderImageForRun } from "@opengeni/core";
 import { retryWhileMissing as retryWhileMissing3 } from "@opengeni/storage";
 import { WorkspaceModelPolicyBlockedError } from "@opengeni/runtime";
@@ -11002,12 +11213,10 @@ async function prepareGovernanceAndModel(deps) {
     executionGeneration: turn.executionGeneration
   };
   const [
-    packRuntime,
     rigMaterialization,
     [workspace, companyProfileSnapshot, instructionPolicySnapshot, preferenceSnapshot],
     workspaceModelPolicy
   ] = await Promise.all([
-    resolveWorkspacePackRuntime(db, input.workspaceId),
     session.rigId && session.rigVersionId ? (async () => await materializeRigVersionForAttempt(db, {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -11073,11 +11282,7 @@ async function prepareGovernanceAndModel(deps) {
     );
   } catch {
   }
-  const logicalSandboxSettings = rigVersion ? capabilitySettings : settingsWithPackSandboxImage(
-    capabilitySettings,
-    packRuntime.sandboxImage,
-    packRuntime.sandboxProviderImages
-  );
+  const logicalSandboxSettings = capabilitySettings;
   const providerImageSelection = await resolveRigProviderImageForRun(
     logicalSandboxSettings,
     rigVersion,
@@ -11086,9 +11291,8 @@ async function prepareGovernanceAndModel(deps) {
   const providerImageSettings = providerImageSelection.settings;
   const verifiedRigProviderImageId = providerImageSelection.reason === "selected" ? providerImageSelection.imageId ?? void 0 : void 0;
   const baseRunSettings = {
-    // IMAGE PRECEDENCE: a Rig uses the deployment platform base; a rig-less
-    // pre-v2 Pack may retain its compatibility image. A matching verified
-    // provider-native ID is then applied only to fresh creation without
+    // A Rig uses the deployment platform base. A matching verified
+    // provider-native ID is applied only to fresh creation without
     // changing the logical lease image.
     ...providerImageSettings,
     openaiModel: turn.model,
@@ -11128,8 +11332,12 @@ async function prepareGovernanceAndModel(deps) {
       fileIds
     })
   );
+  const useReasoningUpdates = runSettings.reasoningConfigurationUpdatesEnabled && providerApi === "responses" && (resolvedModel?.provider.id === "codex" || resolvedModel?.provider.id === "openai") && supportsReasoningConfiguration(turnExecutionPolicy.upstreamModelId, turn.reasoningEffort);
   const modelHistoryProjector = async (items, projectionOptions) => projectModelInputForCapabilities(
-    await attachmentProjector(items, projectionOptions),
+    projectReasoningConfigurations(
+      await attachmentProjector(items, projectionOptions),
+      useReasoningUpdates
+    ),
     modelInputPolicy
   );
   const generatedImageHistoryProjector = async (items) => {
@@ -11187,7 +11395,6 @@ async function prepareGovernanceAndModel(deps) {
   return {
     ok: {
       runtimePreparationStartedAt,
-      packRuntime,
       rigVersion,
       rigName,
       agentHumanInputEnabled,
@@ -11221,8 +11428,11 @@ import {
   appendWorkspaceMemory,
   composeAgentInstructions,
   requestRemoteCompactionV2,
-  serializedToolsForRemoteCompaction,
-  EmptyCompactionSummaryError as EmptyCompactionSummaryError2,
+  preparedCompactionRequest,
+  queuePreparedCompaction,
+  compactionThresholdTokens as compactionThresholdTokens2,
+  CompactionNeededError,
+  compactionProviderRejection as compactionProviderRejection2,
   SUMMARY_BUFFER_TOKENS as SUMMARY_BUFFER_TOKENS2
 } from "@opengeni/runtime";
 async function prepareCompaction(deps) {
@@ -11260,9 +11470,6 @@ async function prepareCompaction(deps) {
     withCodexRemoteCompaction
   } = deps;
   const remotePrefix = {
-    tools: [],
-    instructions: "",
-    toolsReady: false,
     agent: null
   };
   const promptCacheKey = acceptsPromptCacheKeyForTurn(resolvedModel) ? input.sessionId : void 0;
@@ -11315,38 +11522,16 @@ async function prepareCompaction(deps) {
     ...promptCacheKey ? { promptCacheKey } : {}
   });
   const remoteCompactionRequester = resolvedModel && billingState.isCodexTurn ? (s, m) => withCodexRemoteCompaction(async () => {
-    if (!remotePrefix.instructions.trim()) {
-      throw new EmptyCompactionSummaryError2({
-        stage: "remote_v2_instructions",
-        reason: "agent_missing_system_instructions"
-      });
-    }
-    if (!remotePrefix.toolsReady) {
-      if (!remotePrefix.agent) {
-        throw new EmptyCompactionSummaryError2({
-          stage: "remote_v2_tools",
-          reason: "agent_missing_for_tools"
-        });
-      }
-      try {
-        remotePrefix.tools = await serializedToolsForRemoteCompaction(remotePrefix.agent);
-      } catch (error51) {
-        throw new EmptyCompactionSummaryError2({
-          stage: "remote_v2_tools",
-          reason: "serialize_tools_failed",
-          error: String(error51)
-        });
-      }
-      remotePrefix.toolsReady = true;
-    }
+    if (!remotePrefix.agent) throw new Error("Compaction agent is unavailable");
+    const preparedRequest = preparedCompactionRequest(remotePrefix.agent);
     return requestRemoteCompactionV2(s, m, {
       client: resolvedModel.client,
       provider: resolvedModel.provider,
       model: turnExecutionPolicy.upstreamModelId,
-      systemInstructions: remotePrefix.instructions,
-      onUsage: recordCompactionUsage,
-      tools: remotePrefix.tools,
-      ...promptCacheKey ? { promptCacheKey } : {}
+      preparedRequest,
+      captureAgent: remotePrefix.agent,
+      signal: cancellationSignal,
+      onUsage: recordCompactionUsage
     });
   }) : void 0;
   const publishCompactionLiveEvents = async (events) => {
@@ -11458,22 +11643,16 @@ async function prepareCompaction(deps) {
           },
           {
             clearRequestedCompaction: true,
-            publishLiveEvents: publishCompactionLiveEvents
+            publishLiveEvents: publishCompactionLiveEvents,
+            providerRejection: compactionProviderRejection2(error51)
           }
         );
         if (!isCompactionSummaryFailure(error51)) throw error51;
-        const errorMessage = String(compactionFailureReasonFromError(error51));
         if (!await eventing.settle({
           events: [
             {
               type: "turn.failed",
-              payload: {
-                error: errorMessage,
-                code: "context_compaction_failed",
-                retryable: false,
-                recovery: "user_message",
-                compacted: false
-              }
+              payload: compactionFailureTurnEventPayload(error51)
             },
             {
               type: "session.status.changed",
@@ -11563,12 +11742,23 @@ async function runPostAgentCompaction(deps) {
     agentInstructions.trim() ? agentInstructions : void 0
   );
   if (remoteCompactionRequester) {
-    remotePrefix.instructions = agentInstructions;
     remotePrefix.agent = agent;
   }
   if (compactionOnlyTurn) {
     const requested = await isSessionCompactionRequested2(db, input.workspaceId, input.sessionId);
     let outcome = null;
+    if (requested && remoteCompactionRequester && session.codexCompactionMode === "remote_v2") {
+      queuePreparedCompaction(
+        agent,
+        new CompactionNeededError({
+          trigger: "operator",
+          signalSource: "operator",
+          signalTokens: session.lastInputTokens ?? 0,
+          thresholdTokens: compactionThresholdTokens2(eventing.modelRunSettings)
+        })
+      );
+      return { ok: { compactSummarizer } };
+    }
     if (requested) {
       try {
         outcome = await waitForTurnOperation(
@@ -11611,22 +11801,16 @@ async function runPostAgentCompaction(deps) {
           },
           {
             clearRequestedCompaction: true,
-            publishLiveEvents: publishCompactionLiveEvents
+            publishLiveEvents: publishCompactionLiveEvents,
+            providerRejection: compactionProviderRejection2(error51)
           }
         );
         if (!isCompactionSummaryFailure(error51)) throw error51;
-        const errorMessage = String(compactionFailureReasonFromError(error51));
         if (!await eventing.settle({
           events: [
             {
               type: "turn.failed",
-              payload: {
-                error: errorMessage,
-                code: "context_compaction_failed",
-                retryable: false,
-                recovery: "user_message",
-                compacted: false
-              }
+              payload: compactionFailureTurnEventPayload(error51)
             },
             {
               type: "session.status.changed",
@@ -11673,6 +11857,22 @@ async function runPostAgentCompaction(deps) {
     control.activityStatus = "idle";
     return { exit: claimedResult({ status: "idle" }) };
   }
+  if (remoteCompactionRequester && session.codexCompactionMode === "remote_v2") {
+    const forced = await isSessionCompactionRequested2(db, input.workspaceId, input.sessionId);
+    const thresholdTokens = compactionThresholdTokens2(eventing.modelRunSettings);
+    if (forced || (attempt.triggerType === "user.message" || attempt.triggerType === "system.update.delivered") && (session.lastInputTokens ?? 0) >= thresholdTokens) {
+      queuePreparedCompaction(
+        agent,
+        new CompactionNeededError({
+          trigger: forced ? "operator" : "threshold",
+          signalSource: forced ? "operator" : "provider",
+          signalTokens: session.lastInputTokens ?? 0,
+          thresholdTokens
+        })
+      );
+    }
+    return { ok: { compactSummarizer } };
+  }
   if (attempt.triggerType === "user.message" || attempt.triggerType === "system.update.delivered") {
     let forced = false;
     try {
@@ -11741,13 +11941,13 @@ async function runPostAgentCompaction(deps) {
         },
         {
           clearRequestedCompaction: forced,
-          publishLiveEvents: publishCompactionLiveEvents
+          publishLiveEvents: publishCompactionLiveEvents,
+          providerRejection: compactionProviderRejection2(compactError)
         }
       );
       if (!isCompactionSummaryFailure(compactError)) throw compactError;
       const deferredSteer = await settleDeferredSteerAfterCompaction();
       if (deferredSteer) return { exit: deferredSteer };
-      const errorMessage = String(compactionFailureReasonFromError(compactError));
       observability.error("context compaction failed", {
         sessionId: input.sessionId,
         turnId: attempt.turnId,
@@ -11757,13 +11957,7 @@ async function runPostAgentCompaction(deps) {
         events: [
           {
             type: "turn.failed",
-            payload: {
-              error: errorMessage,
-              code: "context_compaction_failed",
-              retryable: false,
-              recovery: "user_message",
-              compacted: false
-            }
+            payload: compactionFailureTurnEventPayload(compactError)
           },
           { type: "session.status.changed", payload: { status: "idle" } }
         ],
@@ -11793,7 +11987,8 @@ import {
   SandboxWorkspaceMutationFencedError
 } from "@opengeni/db";
 import {
-  RoutingMutationOutcomeUnknownError
+  RoutingMutationOutcomeUnknownError,
+  runManagedCodemodeClientHook
 } from "@opengeni/runtime";
 import {
   sandboxLifecycleTransitionWaitMs,
@@ -11844,12 +12039,23 @@ function createSandboxTurnRuntime(deps) {
       sandboxState.machinePrimarySession
     );
   };
-  const onHomeSandboxRebound = (rebound) => {
+  const onHomeSandboxRebound = async (rebound) => {
     const current = sandboxState.resolvedSandbox;
+    if (!current) throw new Error("Home sandbox rebound before turn sandbox admission");
+    if (rebound.established.backendId !== "selfhosted" && rebound.established.instanceId !== current.established.instanceId) {
+      const commandFence = eventing.toolCancellationFenceRef.current;
+      await runWorkspaceMutationForSandbox(
+        { ...current, established: rebound.established, leaseEpoch: rebound.leaseEpoch },
+        "homeSandboxClientPreparation",
+        () => runManagedCodemodeClientHook(rebound.established.session, {
+          environment: {},
+          ...commandFence ? { commandRunner: commandFence.runSandboxCommand.bind(commandFence) } : {}
+        })
+      );
+    }
     const previousSession = current?.established.session;
     const preserveRoutingProxy = current !== null && previousSession !== sandboxState.setupBoxSession;
     sandboxState.setupBoxSession = rebound.established.session;
-    if (!current) return;
     current.leaseEpoch = rebound.leaseEpoch;
     current.established = preserveRoutingProxy ? {
       ...current.established,
@@ -12120,7 +12326,13 @@ function createSandboxTurnRuntime(deps) {
         deadlineRotationRequested: sandboxState.deadlineRotationRequested
       })) {
         const snapshot = maybePersistWarmWorkspaceSnapshot(
-          { db, settings, objectStorage },
+          {
+            db,
+            settings,
+            objectStorage,
+            sandboxMetrics: runtimeMetricsHooksForObservability(observability),
+            observability
+          },
           {
             accountId: input.accountId,
             workspaceId: input.workspaceId,
@@ -12177,6 +12389,9 @@ import {
   getLiveEnrollmentConnection,
   assertPersonalMachineForAttempt
 } from "@opengeni/db";
+import {
+  sandboxCaptureWaitMetricObserver
+} from "@opengeni/observability";
 import {
   withRunCredentialsSession as withRunCredentialsSession2,
   runOwnedSandboxSetup as runOwnedSandboxSetup2,
@@ -12552,6 +12767,7 @@ async function establishTurnSandbox(deps) {
             bus,
             onOp: machineOpObserver.observer,
             onSandboxOperation: sandboxOperationObserver,
+            onSandboxCaptureWait: sandboxCaptureWaitMetricObserver(observability),
             opJournal
           },
           {
@@ -12614,6 +12830,7 @@ async function establishTurnSandbox(deps) {
               opJournal,
               onOp: machineOpObserver.observer,
               onSandboxOperation: sandboxOperationObserver,
+              onSandboxCaptureWait: sandboxCaptureWaitMetricObserver(observability),
               onHomeSandboxRebound,
               ...runtimeCancellationSignal ? { waitSignal: runtimeCancellationSignal } : {}
             },
@@ -12820,6 +13037,7 @@ async function establishTurnSandbox(deps) {
               bus,
               opJournal,
               onSandboxOperation: sandboxOperationObserver,
+              onSandboxCaptureWait: sandboxCaptureWaitMetricObserver(observability),
               onHomeSandboxLost: publishSandboxLost,
               onHomeSandboxRebound,
               ...runtimeCancellationSignal ? { waitSignal: runtimeCancellationSignal } : {}
@@ -13020,6 +13238,7 @@ async function bindLazySandboxProvisioner(deps) {
               {
                 settings: runSettings,
                 environment: sandboxEnvironment,
+                recordLazyManifest: true,
                 onRuntimeEvent: async (event) => {
                   await eventing.publish?.([{ type: event.type, payload: event.payload }], true);
                 },
@@ -13121,6 +13340,7 @@ async function bindLazySandboxProvisioner(deps) {
         opJournal,
         onOp: machineOpObserver.observer,
         onSandboxOperation: sandboxOperationObserver,
+        onSandboxCaptureWait: sandboxCaptureWaitMetricObserver(observability),
         onHomeSandboxLost: publishSandboxLost,
         onHomeSandboxRebound,
         ...runtimeCancellationSignal ? { waitSignal: runtimeCancellationSignal } : {}
@@ -13966,7 +14186,7 @@ async function prepareRunCredentials(deps) {
     )
   ]);
   const needsHostCredentialRoot = Boolean(
-    connectionCredentials?.gitCredentials || personalGitHubCredentials || connectionCredentials?.mcpCredentials
+    connectionCredentials?.gitCredentials || personalGitHubCredentials
   );
   const hostCredentialRootSessionId = needsHostCredentialRoot ? await getSessionRootId2(db, input.workspaceId, input.sessionId) : null;
   if (needsHostCredentialRoot && !hostCredentialRootSessionId) {
@@ -14336,7 +14556,6 @@ async function prepareRunCredentials(deps) {
     initialRunCredentialMaterial,
     runCredentialsNote,
     authorizeGitHubTokenMint,
-    hostCredentialRootSessionId,
     gitCredentialAuthority,
     codemodeAuthority,
     sandboxArtifactRuntime,
@@ -14442,7 +14661,7 @@ import { getWorkspaceConnectionModelRestrictions } from "@opengeni/db";
 import {
   beginConnectorActionExecution,
   getExternalLinkTurnAuthorization,
-  getSessionTurnForAttempt as getSessionTurnForAttempt2,
+  getSessionTurnForAttempt,
   getWorkspaceVideoGenerationPolicy,
   listSkillDescriptors as listSkillDescriptors2,
   completeConnectorActionExecution,
@@ -14516,15 +14735,14 @@ async function resolveGoogleDrivePublicationTarget(db, workspace, delegations, p
   );
   if (frozen.length !== 1) return null;
   const delegation = frozen[0];
-  const activated = delegation.userDelegation !== void 0;
-  if (!activated && !await ports.getMembership(db, {
+  if (!await ports.getMembership(db, {
     accountId: workspace.accountId,
     workspaceId,
     subjectId: delegation.ownerSubjectId
   })) {
     return null;
   }
-  const originWorkspaceId = activated ? delegation.originWorkspaceId : workspaceId;
+  const originWorkspaceId = delegation.originWorkspaceId;
   if (!originWorkspaceId) return null;
   const connection = await ports.getConnection(
     db,
@@ -15075,23 +15293,17 @@ function driveQuery(value) {
 }
 
 // src/activities/mcp-credentials.ts
+import { stableJson as stableJson2 } from "@opengeni/contracts";
 import {
   buildConnectionTokenResolver,
-  buildHostConnectionTokenResolver,
-  getSessionTurnForAttempt,
-  authorizeDirectHostMcpUse,
-  resolveAcceptedHostMcpBinding,
-  resolveAcceptedConnectionUse,
-  sessionTenancyProductActivated
+  resolveAcceptedConnectionUse
 } from "@opengeni/db";
-import { recordTenancyCompatibilityLaneUse } from "@opengeni/observability";
 
 // src/activities/mcp-operation-authority.ts
 import { createHash as createHash10 } from "crypto";
 import { stableJson } from "@opengeni/contracts";
 function mcpOperationAuthorityDigest(request, authority) {
   const n = authority.native;
-  const h = authority.host;
   const ref = request.connectionRef;
   const metadata = {
     version: 1,
@@ -15105,14 +15317,13 @@ function mcpOperationAuthorityDigest(request, authority) {
       providerDomain: ref.providerDomain,
       kind: ref.kind,
       subjectScope: ref.subjectScope,
-      hostBinding: ref.hostBinding,
       scopes: ref.scopes ? [...ref.scopes].sort() : void 0,
       resource: ref.resource,
       selectedResources: ref.selectedResources ? [...ref.selectedResources].sort(
         (a, b) => stableJson(a) < stableJson(b) ? -1 : stableJson(a) > stableJson(b) ? 1 : 0
       ) : void 0
     },
-    native: n ? {
+    native: {
       organizationId: n.organizationId,
       workspaceId: n.workspaceId,
       sessionId: n.sessionId,
@@ -15122,87 +15333,28 @@ function mcpOperationAuthorityDigest(request, authority) {
       ownerSubjectId: n.ownerSubjectId,
       authorityId: n.authorityId,
       grantId: n.grantId,
-      principal: "principal" in authority ? authority.principal : void 0
-    } : void 0,
-    host: h ? {
-      accountId: h.accountId,
-      workspaceId: h.workspaceId,
-      targetSessionId: h.targetSessionId,
-      targetSessionVisibility: h.targetSessionVisibility,
-      targetSessionAuthorityEpoch: h.targetSessionAuthorityEpoch,
-      ownerSubjectId: h.ownerSubjectId,
-      ownerOrganizationMembershipId: h.ownerOrganizationMembershipId,
-      ownerMembershipAuthorizationRevision: h.ownerMembershipAuthorizationRevision,
-      bindingId: h.bindingId,
-      bindingGeneration: h.bindingGeneration,
-      definition: h.definition,
-      delegationId: h.delegationId,
-      delegationGeneration: h.delegationGeneration
-    } : void 0
+      principal: authority.principal
+    }
   };
   return createHash10("sha256").update(stableJson(metadata)).digest("hex");
 }
 
 // src/activities/mcp-credentials.ts
-var OPENGENI_CONNECTION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 function connectionTokenResolverForTurn(input) {
-  const hostResolver = input.connectionCredentials?.mcpCredentials;
-  const readHostTurn = input.getHostTurnForAttempt ?? getSessionTurnForAttempt;
-  const hostDb = input.db;
-  const nativeResolver = buildConnectionTokenResolver(input.db, input.settings);
+  return bindNativeConnectionCredentialsToTurn(
+    input,
+    buildConnectionTokenResolver(input.db, input.settings)
+  );
+}
+function bindNativeConnectionCredentialsToTurn(input, nativeResolver) {
   const recoveryEnabled = (serverId) => input.settings.mcpServers.some(
     (server) => server.id === serverId && "operationRecovery" in server && server.operationRecovery !== void 0 && Object.keys(server.operationRecovery ?? {}).length > 0
   );
-  const configuredResolver = hostResolver ? async (credentialRequest) => {
-    let authorizedSnapshot;
-    const wantsDigest = recoveryEnabled(credentialRequest.serverId);
-    const resolver = buildHostConnectionTokenResolver(hostResolver, {
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      sessionId: input.sessionId,
-      rootSessionId: input.rootSessionId,
-      turnId: input.turn.id,
-      attemptId: input.attemptId,
-      executionGeneration: input.turn.executionGeneration,
-      initiator: input.turn.initiator,
-      initiatorContext: input.turn.initiatorContext,
-      surface: "model",
-      resolveAcceptedBinding: (request) => resolveAcceptedHostMcpBinding(hostDb, request),
-      // Only immutable captured direct-turn authority is currently supported.
-      // Direct, scheduled and exact causal/child snapshots are validated;
-      // no authority follows merely from a binding or creator identity.
-      authorizeDurableBinding: (request) => authorizeDirectHostMcpUse(
-        hostDb,
-        request,
-        wantsDigest ? (snapshot) => {
-          authorizedSnapshot = snapshot;
-        } : void 0
-      ),
-      authorizeExecution: async (request) => {
-        if (request.connectionRef.authoritySource !== "host" && (!request.connectionRef.connectionId || OPENGENI_CONNECTION_ID_PATTERN.test(request.connectionRef.connectionId)))
-          return true;
-        if (!request.attemptId) return false;
-        const current = await readHostTurn(
-          hostDb,
-          request.workspaceId,
-          request.sessionId,
-          request.attemptId
-        );
-        return current !== null && current.id === request.turnId && current.executionGeneration === request.executionGeneration;
-      }
-    });
-    const result = await resolver(credentialRequest);
-    return result.status === "ok" && authorizedSnapshot ? {
-      ...result,
-      operationAuthorityDigest: mcpOperationAuthorityDigest(credentialRequest, {
-        host: authorizedSnapshot
-      })
-    } : result;
-  } : nativeResolver;
-  const baseResolver = (request) => input.connectionCredentials?.mcpAuthoritySource === "host" && request.connectionRef.authoritySource !== "host" ? nativeResolver(request) : configuredResolver(request);
+  const canonicalMcpServerIds = new Set(
+    input.canonicalMcpServerIds ?? input.settings.mcpServers.filter((server) => server.connectionRef).map((server) => server.id)
+  );
   return async (request) => {
     if (request.connectionRef.authoritySource === "host") {
-      if (hostResolver) return await baseResolver(request);
       return {
         status: "auth_needed",
         reason: "unsupported_auth",
@@ -15215,22 +15367,15 @@ function connectionTokenResolverForTurn(input) {
         ...request.connectionRef.selectedResources ? { selectedResources: request.connectionRef.selectedResources } : {}
       };
     }
-    if (hostResolver && input.connectionCredentials?.mcpAuthoritySource !== "host" && request.connectionRef.connectionId && !OPENGENI_CONNECTION_ID_PATTERN.test(request.connectionRef.connectionId)) {
-      try {
-        return await baseResolver(request);
-      } catch {
-        return {
-          status: "auth_needed",
-          reason: "refresh_failed",
-          providerDomain: request.connectionRef.providerDomain,
-          authoritySource: "host",
-          ...request.connectionRef.provider ? { provider: request.connectionRef.provider } : {},
-          connectionId: request.connectionRef.connectionId,
-          ...request.connectionRef.scopes ? { scopes: request.connectionRef.scopes } : {},
-          ...request.connectionRef.resource ? { resource: request.connectionRef.resource } : {},
-          ...request.connectionRef.selectedResources ? { selectedResources: request.connectionRef.selectedResources } : {}
-        };
-      }
+    const accountBindings = input.turn.mcpAccountBindings ?? [];
+    const accountBinding = accountBindings.find((binding) => binding.serverId === request.serverId);
+    if (input.turn.mcpAccountBindings != null && !accountBinding && canonicalMcpServerIds.has(request.serverId) || !accountBinding && accountBindings.some((binding) => binding.canonicalServerId === request.serverId) || accountBinding && (request.connectionRef.connectionId !== accountBinding.connectionId || request.connectionRef.providerDomain !== accountBinding.providerDomain || request.connectionRef.kind !== accountBinding.kind || request.connectionRef.subjectScope !== accountBinding.subjectScope || stableJson2(request.connectionRef) !== stableJson2(accountBinding.connectionRef) || accountBinding.subjectScope === "subject" && request.subjectId !== accountBinding.ownerSubjectId)) {
+      return {
+        status: "auth_needed",
+        reason: "personal_authority_unavailable",
+        providerDomain: request.connectionRef.providerDomain,
+        ...request.connectionRef.provider ? { provider: request.connectionRef.provider } : {}
+      };
     }
     const acceptedDelegation = input.turn.personalConnectionDelegations.find(
       (delegation) => (delegation.connectionType === void 0 || delegation.connectionType === "mcp" || delegation.connectionType === "github_personal" && delegation.serverId === "github:personal" && request.serverId === "github:personal" && request.connectionRef.provider === "github" && request.connectionRef.kind === "oauth2" && request.connectionRef.providerDomain === "github.com" && request.credentialTarget === "http_api" && isGitHubApiDestination(request.destinationUrl)) && delegation.serverId === request.serverId && delegation.connectionId === request.connectionRef.connectionId
@@ -15245,19 +15390,12 @@ function connectionTokenResolverForTurn(input) {
       };
     }
     if (subjectScope === "workspace" && !request.connectionRef.connectionId) {
-      if (await (input.isSessionTenancyProductActivated ?? sessionTenancyProductActivated)(
-        input.db,
-        input.workspaceId
-      )) {
-        return {
-          status: "auth_needed",
-          reason: "missing_connection",
-          providerDomain: request.connectionRef.providerDomain,
-          ...request.connectionRef.provider ? { provider: request.connectionRef.provider } : {}
-        };
-      }
-      recordTenancyCompatibilityLaneUse(input.observability, "connection_pre_snapshot_ref");
-      return await baseResolver(request);
+      return {
+        status: "auth_needed",
+        reason: "missing_connection",
+        providerDomain: request.connectionRef.providerDomain,
+        ...request.connectionRef.provider ? { provider: request.connectionRef.provider } : {}
+      };
     }
     const credentialUseContext = {
       accountId: input.accountId,
@@ -15299,51 +15437,32 @@ function connectionTokenResolverForTurn(input) {
           })
         } : {},
         authorizeProviderRequest: async () => {
-          const authorization2 = await authorize({
+          const authorization = await authorize({
             ...credentialUseContext,
             physicalRequestId: crypto.randomUUID(),
             usePhase: "provider_request"
           });
-          return authorization2.status === "authorized";
+          return authorization.status === "authorized";
         }
       };
     };
-    const recordAuthorizedScope = (scope) => {
-      if (scope === "legacy_user") {
-        recordTenancyCompatibilityLaneUse(input.observability, "connection_legacy_user");
-      }
-    };
-    if (!hostResolver) {
-      const result2 = await baseResolver({
-        ...request,
-        connectionUseContext: credentialUseContext
-      });
-      if (result2.status === "ok") recordAuthorizedScope(result2.connectionUseAttribution?.scope);
-      return withProviderRequestAuthorization(result2);
-    }
-    const authorization = await authorize(credentialUseContext);
-    if (authorization.status === "denied") {
+    const { subjectId: requestSubjectId, ...requestWithoutSubject } = request;
+    const result = await nativeResolver({
+      ...requestWithoutSubject,
+      ...accountBinding?.connectionAuthorityGeneration !== void 0 ? { expectedAuthorityGeneration: accountBinding.connectionAuthorityGeneration } : {},
+      // Workspace authority has no personal owner, even when the turn has a
+      // causal human. Do not pass that human as credential ownership context.
+      ...accountBinding?.subjectScope !== "workspace" && requestSubjectId !== void 0 ? { subjectId: requestSubjectId } : {},
+      connectionUseContext: credentialUseContext
+    });
+    if (accountBinding && result.status === "ok" && result.connectionId !== accountBinding.connectionId) {
       return {
         status: "auth_needed",
-        reason: request.connectionRef.subjectScope === "subject" ? "personal_authority_unavailable" : "missing_connection",
-        providerDomain: request.connectionRef.providerDomain,
-        ...request.connectionRef.provider ? { provider: request.connectionRef.provider } : {}
+        reason: "personal_authority_unavailable",
+        providerDomain: accountBinding.providerDomain
       };
     }
-    recordAuthorizedScope(authorization.attribution.scope);
-    const result = await baseResolver({
-      ...request,
-      connectionUseContext: credentialUseContext,
-      connectionUseAuthority: authorization.attribution,
-      connectionRef: {
-        ...request.connectionRef,
-        connectionId: authorization.attribution.connectionId,
-        kind: authorization.connectionKind,
-        subjectScope: authorization.attribution.scope === "workspace" ? "workspace" : "subject"
-      },
-      ...authorization.attribution.ownerSubjectId ? { subjectId: authorization.attribution.ownerSubjectId } : {}
-    });
-    return withProviderRequestAuthorization(result, authorization.attribution);
+    return withProviderRequestAuthorization(result);
   };
 }
 function isGitHubApiDestination(value) {
@@ -15355,6 +15474,100 @@ 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";
 
@@ -30486,7 +30699,7 @@ function exactPersonalDelegation(delegations) {
     (delegation2) => delegation2.serverId === PERSONAL_GITHUB_DELEGATION_SERVER_ID && delegation2.connectionType === "github_personal"
   );
   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 GitHubRestAuthorityError("Personal GitHub delegation is unavailable");
   }
   return delegation;
@@ -30686,7 +30899,7 @@ async function materializeConnectorAttachmentsInChannel(channel, request, option
 }
 
 // src/activities/agent-turn/tool-environment.ts
-import { allowedFirstPartyMcpToolsForSession as allowedFirstPartyMcpToolsForSession2 } from "@opengeni/config";
+import { allowedFirstPartyMcpToolsForSession } from "@opengeni/config";
 
 // src/activities/codemode-dispatcher.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -31080,7 +31293,7 @@ function safeErrorMessage(error51) {
 // src/activities/agent-turn/tool-environment.ts
 import { CODEX_CLIENT_VERSION } from "@opengeni/codex";
 import {
-  defaultSessionMcpServerIds,
+  workspaceSessionToolPolicyDefaultServerIds,
   loadRigDefaultVariableSetEnvironment,
   mergeRigDefaultVariableSetEnvironment,
   buildApiIntegrationMcpServers,
@@ -31093,24 +31306,9 @@ import {
 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_PERMISSIONS3
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2
 } from "@opengeni/contracts";
 
-// src/activities/agent-turn/turn-sandbox-access.ts
-async function resolveTurnSandboxAccess(sandboxState, sdkOwnedSandboxSession, unavailableMessage) {
-  let sandbox = sandboxState.resolvedSandbox;
-  if (!sandbox && sandboxState.turnSandboxProvisioner) {
-    sandbox = await sandboxState.turnSandboxProvisioner.get();
-  }
-  const session = sandboxState.lazyOwnedSandbox?.session ?? sandbox?.established.session ?? sdkOwnedSandboxSession;
-  if (!session) throw new Error(unavailableMessage);
-  return {
-    sandbox,
-    session,
-    leaseEpoch: sandbox?.leaseEpoch ?? 0
-  };
-}
-
 // src/activities/agent-turn/list-models.ts
 import {
   compareModelPickerOrder,
@@ -31204,7 +31402,8 @@ import {
   portableSkillPluginKey,
   readSkill,
   resolveSkillImport,
-  saveSkill
+  saveSkill,
+  removeSkill
 } from "@opengeni/core";
 import {
   buildPortableSkillArtifact as buildPortableSkillArtifact3,
@@ -31369,7 +31568,7 @@ function createSkillSaveAttemptToolDefinition(input) {
     modelName: "skill_save",
     codemodePath: ["opengeni", "skill_save"],
     title: "Save Skill text",
-    description: "Create or edit a workspace Skill without a sandbox. Supply only changed UTF-8 text files and explicit deletions; omitted files are preserved. Use the revision and scope version returned by Skill discovery for stale-write protection. For creation choose a new UUID, set expectedRevisionId to null and expectedScopeVersion to 1. The effective Skills setting governs publication: Automatic publishes, Review first saves a pending revision in Knowledge > Needs review while the task continues, and Off prevents agent authoring. Report the actual receipt without asking an approval question. Private chats save personal Skills; shared chats save workspace Skills.",
+    description: "Create or edit a Skill for reusable procedures or context-specific and personal behavioral preferences, not retrieval-only facts. Put its applicability in the SKILL.md description so the prompt index can guide skill_read; the full body is loaded when relevant. Short always-on workspace rules use instruction_policy_save. Supply only changed UTF-8 text files and explicit deletions; omitted files are preserved. No sandbox is needed. Use the revision and scope version returned by Skill discovery for stale-write protection. For creation choose a new UUID, set expectedRevisionId to null and expectedScopeVersion to 1. The effective Skills setting governs publication: Automatic publishes, Review first saves a pending revision in Knowledge > Needs review while the task continues, and Off prevents agent authoring. Report the actual receipt without asking an approval question. Private chats save personal Skills; shared chats save workspace Skills. Preserve the intended scope; another destination is not a workaround for unavailable scope or learning restrictions.",
     inputSchema: {
       type: "object",
       properties: {
@@ -31492,6 +31691,43 @@ function createSkillInstallAttemptToolDefinition(input) {
   };
 }
 
+// src/activities/agent-turn/skill-remove.ts
+var SkillRemoveRequest = external_exports.object({
+  operationId: external_exports.uuid(),
+  skillId: external_exports.uuid(),
+  expectedRevisionId: external_exports.uuid().nullable(),
+  expectedScopeVersion: external_exports.number().int().positive(),
+  reason: external_exports.string().min(1).max(2e3)
+}).strict();
+function createSkillRemoveAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: "skill_remove" },
+    modelName: "skill_remove",
+    codemodePath: ["opengeni", "skill_remove"],
+    title: "Permanently remove Skill",
+    description: "Permanently delete a saved Skill and ALL its stored revisions, not a recoverable hide. Conversations remain unchanged. Read the exact Skill first; supply its current active revision and scope version. Built-in, repository and inline session Skills cannot be removed. Automatic applies deletion; Review first retains an explicitly labeled deletion proposal for human review in Knowledge > Needs review; Off refuses changes. Reuse the same operationId and exact arguments after an uncertain result. Never report a pending proposal as deleted.",
+    inputSchema: JSON.parse(JSON.stringify(external_exports.toJSONSchema(SkillRemoveRequest))),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await input.authorize();
+      const output = await input.remove(SkillRemoveRequest.parse(args));
+      const text = JSON.stringify(output);
+      return {
+        isError: false,
+        content: [{ type: "text", text }],
+        structuredContent: JSON.parse(text)
+      };
+    }
+  };
+}
+
 // src/activities/agent-turn/skill-transfer.ts
 import { posix } from "path";
 import {
@@ -31768,6 +32004,12 @@ function createWorkspaceSkillTools(input) {
     );
   };
   return [
+    createSkillRemoveAttemptToolDefinition({
+      authorize,
+      remove: async (request) => withReviewState(
+        await removeSkill(input.db, { ...context, ...request, actor: input.actor })
+      )
+    }),
     createSkillReadAttemptToolDefinition({ authorize, load }),
     createSkillSearchAttemptToolDefinition({
       authorize,
@@ -31784,7 +32026,7 @@ function createWorkspaceSkillTools(input) {
           id: entry.id,
           name: entry.artifact.name,
           description: entry.artifact.description || entry.artifact.name,
-          source: entry.id.startsWith("builtin:") ? "builtin" : entry.id.startsWith("session:") ? "session" : "pack"
+          source: entry.id.startsWith("builtin:") ? "builtin" : "session"
         }))
       ],
       publicSearch: createPublicSkillSearchClient(input.settings)
@@ -31904,6 +32146,8 @@ function configuredBundledSkillNames(context) {
   const tools = new Set(context.firstPartyTools);
   const artifacts = () => tools.has("editable_artifact_list") && tools.has("editable_artifact_get");
   const definitions = [
+    { name: "opengeni-help", include: () => true },
+    { name: "opengeni-client", include: () => true },
     { name: "opengeni-visualize", include: () => true },
     { name: "document-parsing", include: () => true },
     { name: "opengeni-skills", include: () => true },
@@ -31962,7 +32206,12 @@ async function prepareTurnToolPolicy(deps) {
     toolPolicy: session.toolPolicy,
     sessionTools: scheduledEffectiveMcpServerIds ? turn.tools : session.tools,
     availableMcpServerIds: scheduledEffectiveMcpServerIds ? scheduledEffectiveMcpServerIds.filter((id) => currentMcpServerIds.has(id)) : [...currentMcpServerIds],
-    defaultMcpServerIds: scheduledEffectiveMcpServerIds ?? defaultSessionMcpServerIds(capabilitySettings.mcpServers)
+    defaultMcpServerIds: scheduledEffectiveMcpServerIds ?? (session.toolPolicy.mode === "workspace_default" ? await workspaceSessionToolPolicyDefaultServerIds(
+      db,
+      input.workspaceId,
+      capabilitySettings,
+      fileAuthoritySubjectId ?? void 0
+    ) : [])
   });
   const mcpAvailabilityNote = unavailableMcpOperationalContext({
     droppedIds: resolvedToolPolicy.effectivePolicy.droppedIds,
@@ -32064,7 +32313,6 @@ async function prepareTurnToolRuntime(deps) {
     objectStorage,
     observability,
     cancellationSignal,
-    connectionCredentials,
     eventing,
     attempt,
     sandboxState,
@@ -32076,10 +32324,9 @@ async function prepareTurnToolRuntime(deps) {
     codexAppsCredentialId,
     turnExecutionPolicy,
     trigger,
-    runSettings,
+    runSettings: canonicalRunSettings,
     lazyToolTransport,
-    turnTools,
-    hostCredentialRootSessionId,
+    turnTools: canonicalTurnTools,
     sandboxArtifactRuntime,
     activeSandboxBackend,
     groupBoxBackend,
@@ -32091,21 +32338,25 @@ async function prepareTurnToolRuntime(deps) {
     throwIfWorkerShuttingDown,
     throwIfTurnCancelled
   } = deps;
+  const accountRoutes = expandMcpAccountRoutes({
+    settings: canonicalRunSettings,
+    tools: canonicalTurnTools,
+    bindings: turn.mcpAccountBindings
+  });
+  const runSettings = accountRoutes.settings;
+  const turnTools = accountRoutes.tools;
   const toolContextPreparationStartedAt = performance.now();
   throwIfWorkerShuttingDown();
   throwIfTurnCancelled();
-  const mcpCredentialRootSessionId = connectionCredentials?.mcpCredentials && hostCredentialRootSessionId ? hostCredentialRootSessionId : input.sessionId;
   const rawResolveCredential = connectionTokenResolverForTurn({
     db,
     settings: runSettings,
-    connectionCredentials: connectionCredentials ?? null,
+    canonicalMcpServerIds: canonicalRunSettings.mcpServers.filter((server) => server.connectionRef).map((server) => server.id),
     accountId: input.accountId,
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
-    rootSessionId: mcpCredentialRootSessionId,
     attemptId: input.attemptId,
-    turn,
-    observability
+    turn
   });
   const personalConnectionDelegations = turn.personalConnectionDelegations;
   const delegatedMembershipChecks = /* @__PURE__ */ new Map();
@@ -32163,16 +32414,24 @@ async function prepareTurnToolRuntime(deps) {
       return;
     }
     await eventing.publish(
-      [{ type: "tool.auth_needed", payload: rollingSafeToolAuthNeededPayload(payload) }],
+      [
+        {
+          type: "tool.auth_needed",
+          payload: rollingSafeToolAuthNeededPayload(
+            accountRouteAuthNeededPayload(payload, turn.mcpAccountBindings)
+          )
+        }
+      ],
       true
     );
   };
-  const selectedApiIntegrationServerIds = new Set(turnTools.map((tool) => tool.id));
   const apiIntegrationMcpServers = buildApiIntegrationMcpServers({
     settings: runSettings,
-    integrations: installedApiIntegrations.filter(
-      (integration) => selectedApiIntegrationServerIds.has(integration.serverId)
-    ),
+    integrations: expandApiIntegrationAccountRoutes({
+      integrations: installedApiIntegrations,
+      bindings: turn.mcpAccountBindings,
+      tools: turnTools
+    }),
     authority: {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -32230,10 +32489,10 @@ async function prepareTurnToolRuntime(deps) {
   );
   if (linkedAuthority && !linkedAuthority.authorized)
     throw new Error("Native identity link was revoked");
-  const effectiveFirstPartyPermissions = linkedAuthority ? (session.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3).filter(
+  const effectiveFirstPartyPermissions = linkedAuthority ? (session.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2).filter(
     (permission) => hasPermission2(linkedAuthority.permissions, permission)
   ) : session.firstPartyMcpPermissions;
-  const selectedFirstPartyMcpTools = allowedFirstPartyMcpToolsForSession2(
+  const selectedFirstPartyMcpTools = allowedFirstPartyMcpToolsForSession(
     runSettings,
     session.firstPartyMcpTools
   );
@@ -32249,10 +32508,10 @@ async function prepareTurnToolRuntime(deps) {
     parallelGenerationAvailable: typeof runtime.generateSessionTitle === "function"
   });
   const googleDrivePublicationAllowed = selectedFirstPartyMcpTools.includes("editable_artifact_export") && selectedFirstPartyMcpTools.includes("editable_artifact_export_status") && hasPermission2(
-    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3],
+    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2],
     "artifacts:read"
   ) && hasPermission2(
-    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3],
+    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2],
     "artifacts:publish"
   );
   const googleDriveConnectorBindings = googleDrivePublicationTool && googleDrivePublicationTarget && googleDrivePublicationAllowed ? [
@@ -32289,7 +32548,6 @@ async function prepareTurnToolRuntime(deps) {
   });
   const selectedSkills = [
     ...bundledSkills,
-    ...deps.selectedSkillActivations.map((entry) => ({ id: entry.id, artifact: entry.artifact })),
     ...session.skills.map((skill) => ({
       id: `session:${session.id}:${skill.name}`,
       artifact: skill
@@ -32391,7 +32649,7 @@ async function prepareTurnToolRuntime(deps) {
     assertAttempt: async () => {
       throwIfWorkerShuttingDown();
       throwIfTurnCancelled();
-      const current = await getSessionTurnForAttempt2(
+      const current = await getSessionTurnForAttempt(
         db,
         input.workspaceId,
         input.sessionId,
@@ -32597,6 +32855,7 @@ async function prepareTurnToolRuntime(deps) {
   try {
     eventing.preparedTools = await waitForTurnOperation(
       runtime.prepareTools(githubRestMcp.settings, githubRestMcp.tools, {
+        mcpAccountLabels: accountRoutes.accountLabels,
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
@@ -32614,7 +32873,7 @@ async function prepareTurnToolRuntime(deps) {
         ...operationPersistence ? { mcpOperationPersistence: operationPersistence } : {},
         ...linkedAuthority ? {
           authorizeAttemptExecution: async () => {
-            const current = await getSessionTurnForAttempt2(
+            const current = await getSessionTurnForAttempt(
               db,
               input.workspaceId,
               input.sessionId,
@@ -32636,13 +32895,10 @@ async function prepareTurnToolRuntime(deps) {
         localMcpServers,
         ...deferNonEagerToolPreparation ? { deferNonEagerUntilToolDemand: true } : {},
         onPreparationPhase: (measurement) => {
-          recordTurnStartupPhase(observability, {
-            phase: `tool_${measurement.phase}`,
+          recordToolPreparationPhase(observability, {
+            ...measurement,
             provider: turnExecutionPolicy.providerId,
-            backend: activeSandboxBackend ?? groupBoxBackend,
-            outcome: measurement.outcome,
-            durationSeconds: measurement.durationSeconds,
-            count: githubRestMcp.tools.length
+            backend: activeSandboxBackend ?? groupBoxBackend
           });
         },
         onAttemptToolCatalog: async (catalog) => {
@@ -32920,7 +33176,9 @@ import {
   getWorkspaceVideoGenerationPolicy as getWorkspaceVideoGenerationPolicy2,
   loadWorkspaceVercelAiGatewayCredentialLease,
   getExternalLinkTurnAuthorization as getExternalLinkTurnAuthorization2,
-  getSessionTurnForAttempt as getSessionTurnForAttempt3
+  getSessionTurnForAttempt as getSessionTurnForAttempt2,
+  ensureSessionReasoningConfiguration,
+  ensureSessionSkillCatalog
 } from "@opengeni/db";
 import {
   formatSkillCatalog
@@ -32931,6 +33189,7 @@ import {
   WORKSPACE_GATEWAY_PROVIDER_ID as WORKSPACE_GATEWAY_PROVIDER_ID2,
   resolveModelProvider as resolveModelProvider2
 } from "@opengeni/config";
+import { supportsReasoningConfiguration as supportsReasoningConfiguration2 } from "@opengeni/codex";
 
 // src/activities/xai-image-generation.ts
 import {
@@ -34144,6 +34403,11 @@ async function buildTurnAgent(deps) {
     codexContext
   } = deps;
   const preparedTools = eventing.preparedTools;
+  const sessionInstructions = await recoveryAwareSessionInstructions(
+    db,
+    input.workspaceId,
+    session
+  );
   const missingSessionTitleHint = preparationIndependentToolNames.includes(
     SESSION_TITLE_MODEL_TOOL_NAME
   );
@@ -34455,7 +34719,15 @@ async function buildTurnAgent(deps) {
     turnExecutionPolicy.latencyMode
   );
   const approvedToolCallId = approvedConnectorActionCallId(trigger);
-  const modelVisibleSkillCatalogText = formatSkillCatalog(deps.skillCatalog);
+  const modelVisibleSkillCatalogText = await ensureSessionSkillCatalog(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    turnId: turn.id,
+    expectedExecutionGeneration: turn.executionGeneration,
+    expectedAttemptId: input.attemptId,
+    catalog: formatSkillCatalog(deps.skillCatalog)
+  });
   try {
     eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
       buildCompanyBrainContributionReceiptFor(modelVisibleSkillCatalogText)
@@ -34479,6 +34751,16 @@ async function buildTurnAgent(deps) {
   );
   if (linkedToolAuthority && !linkedToolAuthority.authorized)
     throw new Error("Native identity link was revoked");
+  const useReasoningUpdates = eventing.modelRunSettings.reasoningConfigurationUpdatesEnabled && resolvedModel?.provider.api === "responses" && (resolvedModel.provider.id === "codex" || resolvedModel.provider.id === "openai") && supportsReasoningConfiguration2(turnExecutionPolicy.upstreamModelId, turn.reasoningEffort);
+  const requestReasoningEffort = useReasoningUpdates && supportsReasoningConfiguration2(turnExecutionPolicy.upstreamModelId, turn.reasoningEffort) ? await ensureSessionReasoningConfiguration(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    turnId: turn.id,
+    expectedExecutionGeneration: turn.executionGeneration,
+    expectedAttemptId: input.attemptId,
+    effort: turn.reasoningEffort
+  }) : turn.reasoningEffort;
   const agent = (() => {
     const agentConstructionStartedAt = performance.now();
     let agentConstructionOutcome = "completed";
@@ -34486,7 +34768,7 @@ async function buildTurnAgent(deps) {
       return runtime.buildAgent(eventing.modelRunSettings, runtimeResources, {
         ...linkedToolAuthority ? {
           authorizeAttemptExecution: async () => {
-            const current = await getSessionTurnForAttempt3(
+            const current = await getSessionTurnForAttempt2(
               db,
               input.workspaceId,
               input.sessionId,
@@ -34497,7 +34779,7 @@ async function buildTurnAgent(deps) {
           }
         } : {},
         ...preparedTools.inputWaitYield ? { inputWaitYield: preparedTools.inputWaitYield } : {},
-        reasoningEffort: turn.reasoningEffort,
+        reasoningEffort: requestReasoningEffort,
         latencyMode: turnExecutionPolicy.latencyMode,
         ...serviceTier ? { serviceTier } : {},
         ...humanInputResume ? { humanInputResponse: humanInputResume } : {},
@@ -34582,13 +34864,14 @@ async function buildTurnAgent(deps) {
         ),
         onRetainableSessionImageOutput: media.retainSessionImageAtToolBoundary,
         skillCatalog: deps.skillCatalog,
+        skillCatalogInHistory: true,
         ...!structuredWorkspacePolicyActive && workspaceAgentInstructions ? { instructionsTemplate: workspaceAgentInstructions } : {},
         ...workspaceGovernance ? { workspaceGovernance } : {},
         ...workspaceMemory ? { workspaceMemory } : {},
         // Per-session persona tier (session > workspace > deployment default).
         // Composed system-level AFTER the workspace persona so it refines it for
         // this one session; absent ⇒ byte-identical to today's composition.
-        ...session.instructions ? { sessionInstructions: session.instructions } : {},
+        ...sessionInstructions ? { sessionInstructions } : {},
         ...workspaceEnvironmentOption,
         // RIG RUNTIME (M3): the doctrine block, the setup-script hook (only when
         // the frozen version carries a non-empty script), and the rig credential
@@ -34687,7 +34970,7 @@ function createRunAgentTurnActivity(services) {
   });
   const modelCheckpointMemoryCollector = createModelCheckpointMemoryCollector();
   const turnCompletionMemoryCollector = createModelCheckpointMemoryCollector();
-  return async function runAgentTurn(input) {
+  const runAgentTurn = async (input, resolvedServices, activitySpan) => {
     const {
       settings,
       catalogSourceSettings = settings,
@@ -34704,7 +34987,7 @@ function createRunAgentTurnActivity(services) {
       connectionCredentials,
       personalGitHubCredentials,
       startVideoGenerationWorkflow
-    } = await services();
+    } = resolvedServices;
     const activityContext = currentActivityContext();
     const cancellationSignal = activityContext?.cancellationSignal;
     const sandboxResumeController = new AbortController();
@@ -34732,11 +35015,6 @@ function createRunAgentTurnActivity(services) {
     });
     const dispatchId = activityContext?.info.activityId ?? randomUUID6();
     const activityStarted = performance.now();
-    const activitySpan = observability.startSpan("worker.run_agent_segment", {
-      "opengeni.session_id": input.sessionId,
-      "opengeni.workflow_id": input.workflowId,
-      "opengeni.trigger_kind": input.trigger.kind
-    });
     const acknowledgeLostAttemptOwnership = () => {
       control.acknowledgeQuiescence = true;
       noteCancellationRequested();
@@ -34757,7 +35035,7 @@ function createRunAgentTurnActivity(services) {
     const machineOpObserver = makeMachineOpObserver(
       runtimeMetricsHooksForObservability(observability)
     );
-    const sandboxOperationObserver = sandboxOperationMetricObserver(observability);
+    const sandboxOperationObserver = sandboxOperationMetricObserver2(observability);
     const setLastInputTokensFenced = async (lastInputTokens) => {
       if (!attempt.turnId || attempt.executionGeneration <= 0) {
         throw new Error("Turn attempt was not initialized before token accounting");
@@ -34918,8 +35196,26 @@ function createRunAgentTurnActivity(services) {
           executionGeneration: attempt.executionGeneration
         }
       });
+      const attachmentAuthority = await getSessionAuthorityProjection(
+        db,
+        input.workspaceId,
+        input.sessionId
+      );
+      if (!attachmentAuthority) throw new Error("Session attachment authority unavailable");
       return await withSessionRlsActorContext(
         {
+          sessionAttachmentReadAccess: {
+            sessionId: input.sessionId,
+            authorityEpoch: attachmentAuthority.authorityEpoch,
+            actor: {
+              kind: "agent_attempt",
+              subjectId: "service:agent-turn",
+              callerSessionId: input.sessionId,
+              turnId: attempt.turnId,
+              attemptId: input.attemptId,
+              executionGeneration: attempt.executionGeneration
+            }
+          },
           subjectId: "service:agent-turn",
           initiatingHumanSubjectId: fileAuthoritySubjectId,
           privateFileOwnerSubjectId: learning.defaultScope === "personal" ? learning.subjectId : null
@@ -34987,7 +35283,6 @@ function createRunAgentTurnActivity(services) {
           });
           const {
             runtimePreparationStartedAt,
-            packRuntime,
             rigVersion,
             rigName,
             agentHumanInputEnabled,
@@ -35017,7 +35312,13 @@ function createRunAgentTurnActivity(services) {
               db,
               runSettings,
               input.workspaceId,
-              providerTurn.effectiveCodexCredentialId ?? ""
+              providerTurn.effectiveCodexCredentialId ?? "",
+              void 0,
+              {
+                turnId: turn.id,
+                holderId: leases.codex.holderId,
+                generation: leases.codex.generation
+              }
             );
             const resolveTrackedToken = async (resolve) => {
               const token = await resolve();
@@ -35408,38 +35709,7 @@ These are publication receipts for the human's earlier answer. Do not call the r
             cancellationSignal?.throwIfAborted();
             knowledgeRecoveryNote = "[OpenGeni confirmation recovery unavailable] Do not assume an earlier remember confirmation was published. Inspect the current Knowledge or instruction review.";
           }
-          const attachmentPreparationNote = await prepareTurnKnowledgeSources({
-            settings: runSettings,
-            scope: {
-              accountId: input.accountId,
-              workspaceId: input.workspaceId,
-              sessionId: input.sessionId,
-              turnId: turn.id,
-              attemptId: input.attemptId,
-              executionGeneration: attempt.executionGeneration
-            },
-            // Only attachments on this accepted turn are new source inputs.
-            // Session-level file receipts remain historical context and must
-            // never trigger metadata reads, downloads, or re-preparation.
-            resources: turn.resources,
-            selectedTools: session.firstPartyMcpTools,
-            permissions: session.firstPartyMcpPermissions,
-            learningMode: learning.effective.knowledge,
-            signal: cancellationSignal,
-            onOutcome: async (outcome) => {
-              if (outcome.status === "disabled") return;
-              await eventing.publish(
-                [
-                  {
-                    type: outcome.status === "failed" ? "knowledge.source.failed" : "knowledge.source.prepared",
-                    payload: outcome
-                  }
-                ],
-                true
-              );
-            }
-          });
-          const knowledgeSourcePreparationNote = [knowledgeRecoveryNote, attachmentPreparationNote].filter(Boolean).join("\n\n") || void 0;
+          const knowledgeSourcePreparationNote = knowledgeRecoveryNote;
           const sandboxRoute = await resolveSandboxRoute({
             input,
             settings,
@@ -35510,7 +35780,6 @@ These are publication receipts for the human's earlier answer. Do not call the r
             establishPolicy,
             initialRunCredentialMaterial,
             runCredentialsNote,
-            hostCredentialRootSessionId,
             codemodeAuthority,
             sandboxArtifactRuntime,
             sandboxEnvironment,
@@ -35628,7 +35897,6 @@ These are publication receipts for the human's earlier answer. Do not call the r
           ];
           const toolRuntime = await prepareTurnToolRuntime({
             fetchKnowledgeSource: sourceActivities.runKnowledgeSourceSyncBatch,
-            selectedSkillActivations: packRuntime.skillActivations,
             input,
             catalogSourceSettings,
             db,
@@ -35637,7 +35905,6 @@ These are publication receipts for the human's earlier answer. Do not call the r
             objectStorage,
             observability,
             cancellationSignal,
-            connectionCredentials,
             eventing,
             attempt,
             sandboxState,
@@ -35655,7 +35922,6 @@ These are publication receipts for the human's earlier answer. Do not call the r
             lazyToolTransport,
             turnTools,
             connectionScope,
-            hostCredentialRootSessionId,
             sandboxArtifactRuntime,
             activeSandboxBackend,
             groupBoxBackend,
@@ -36103,6 +36369,36 @@ These are publication receipts for the human's earlier answer. Do not call the r
       });
     }
   };
+  return async (input) => {
+    const resolvedServices = await services();
+    const correlationId = turnExecutionTelemetryKey2(
+      input.workspaceId,
+      input.sessionId,
+      input.attemptId
+    );
+    const span = resolvedServices.observability.startSpan(
+      "worker.run_agent_segment",
+      {
+        "opengeni.trigger_kind": input.trigger.kind,
+        correlationId
+      },
+      { parent: null }
+    );
+    try {
+      return await withTraceContext(span, () => {
+        try {
+          resolvedServices.observability.info("worker execution started", { correlationId });
+        } catch {
+        }
+        return runAgentTurn(input, resolvedServices, span);
+      });
+    } catch (error51) {
+      span.end({ error: error51 });
+      throw error51;
+    } finally {
+      span.end();
+    }
+  };
 }
 
 // src/activities/video-generation-reconciliation.ts
@@ -37202,4 +37498,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-AP67JADS.js.map
+//# sourceMappingURL=activities-turn-2B3WMHBB.js.map