@opengeni/worker-bundle 1.0.1 → 2.0.0

package/src/activities/agent-turn/skill-save.ts

@@ -41,7 +41,7 @@ export function createSkillSaveAttemptToolDefinition(input: {
     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.",
+      "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: {

package/src/activities/agent-turn/skill-search.ts

@@ -8,7 +8,7 @@ export type WorkspaceSkillSearchEntry = Readonly<{
   revisionId?: string;
   scopeVersion?: number;
   installationVersion?: number;
-  source?: "workspace" | "builtin" | "session" | "pack";
+  source?: "workspace" | "builtin" | "session";
 }>;
 
 export function createSkillSearchAttemptToolDefinition(input: {

package/src/activities/agent-turn/skill-selection.ts

@@ -14,6 +14,8 @@ export function configuredBundledSkillNames(context: BundledSkillConfiguration):
   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 },

package/src/activities/agent-turn/skill-tools.ts

@@ -18,6 +18,7 @@ import {
   readSkill,
   resolveSkillImport,
   saveSkill,
+  removeSkill,
 } from "@opengeni/core";
 import {
   buildPortableSkillArtifact,
@@ -31,6 +32,7 @@ import { createSkillReadAttemptToolDefinition, type SkillReadContent } from "./s
 import { createSkillSearchAttemptToolDefinition } from "./skill-search";
 import { createSkillSaveAttemptToolDefinition, type SkillSaveRequest } from "./skill-save";
 import { createSkillInstallAttemptToolDefinition } from "./skill-install";
+import { createSkillRemoveAttemptToolDefinition } from "./skill-remove";
 import {
   createSkillCheckoutAttemptToolDefinition,
   createSkillPublishAttemptToolDefinition,
@@ -122,6 +124,13 @@ export function createWorkspaceSkillTools(input: {
     );
   };
   return [
+    createSkillRemoveAttemptToolDefinition({
+      authorize,
+      remove: async (request) =>
+        withReviewState(
+          await removeSkill(input.db, { ...context, ...request, actor: input.actor }),
+        ),
+    }),
     createSkillReadAttemptToolDefinition({ authorize, load }),
     createSkillSearchAttemptToolDefinition({
       authorize,
@@ -140,11 +149,7 @@ export function createWorkspaceSkillTools(input: {
           id: entry.id,
           name: entry.artifact.name,
           description: entry.artifact.description || entry.artifact.name,
-          source: entry.id.startsWith("builtin:")
-            ? ("builtin" as const)
-            : entry.id.startsWith("session:")
-              ? ("session" as const)
-              : ("pack" as const),
+          source: entry.id.startsWith("builtin:") ? ("builtin" as const) : ("session" as const),
         })),
       ],
       publicSearch: createPublicSkillSearchClient(input.settings),

package/src/activities/agent-turn/stream-attempt.ts

@@ -22,6 +22,7 @@ import {
   interruptionKindForCallItem,
   releaseMcpResultCustomDataFromSdkEvent,
   findCompactionNeededError,
+  compactionProviderRejection,
   withRunCredentialsSession,
   runOwnedSandboxSetup,
   type SandboxFileDownload,
@@ -69,6 +70,7 @@ import {
   isCompletedGeneratedImageSdkEvent,
 } from "../generated-images";
 import { ToolResultSpill } from "./tool-result-spill";
+import { ownedTurnSandboxForAgent } from "./turn-sandbox-access";
 import { createTurnCredentialLeases } from "./credential-leases";
 import { createTurnMediaArtifacts } from "./media-artifacts";
 import { createTurnHistorySink } from "./history-sink";
@@ -96,6 +98,7 @@ import {
   compactionFailureReason,
   safeErrorDiagnostic,
   compactionFailureReasonFromError,
+  compactionFailureTurnEventPayload,
   isCompactionSummaryFailure,
   PostCompactionContinuationEmptyError,
   shouldRecoverCompactionProviderFailure,
@@ -221,7 +224,7 @@ export type TurnStreamAttemptDeps = {
   activeSandboxBackend: Settings["sandboxBackend"] | undefined;
   groupBoxBackend: Settings["sandboxBackend"];
   turnExecutionPolicy: TurnExecutionPolicyV1;
-  turn: { executionGeneration: number; model: string };
+  turn: { executionGeneration: number; model: string; source?: string };
   trigger: NonNullable<Awaited<ReturnType<typeof getSessionEvent>>>;
   humanInputResume: Awaited<ReturnType<typeof getHumanInputResumeForEvent>>;
   attachPendingUpdatesAfterOpenSuffix: () => Promise<boolean>;
@@ -650,8 +653,7 @@ export async function runTurnStreamAttempt(
         });
       }
     };
-    const ownedEstablished =
-      sandboxState.resolvedSandbox?.established ?? sandboxState.lazyOwnedSandbox;
+    const ownedEstablished = ownedTurnSandboxForAgent(sandboxState);
     const runStreamOnce = async (): ReturnType<OpenGeniRuntime["runStream"]> => {
       const eagerResolvedSandbox = sandboxState.resolvedSandbox;
       // Eager owned sessions must settle the exact platform-setup provider
@@ -759,8 +761,8 @@ export async function runTurnStreamAttempt(
         eventing.firstModelRequestPreparationStartedAt = performance.now();
         eventing.firstModelRequestCheckpointAt = eventing.firstModelRequestPreparationStartedAt;
       }
-      const providerDispatchStartedAt = performance.now();
-      let providerDispatchOutcome: "completed" | "failed" = "completed";
+      const streamInitializationStartedAt = performance.now();
+      let streamInitializationOutcome: "completed" | "failed" = "completed";
       try {
         // This histogram describes worker preparation until the first entry
         // into the runtime. Lazy SDK request preparation and the durable
@@ -894,15 +896,15 @@ export async function runTurnStreamAttempt(
             : {}),
         });
       } catch (error) {
-        providerDispatchOutcome = "failed";
+        streamInitializationOutcome = "failed";
         throw error;
       } finally {
         recordTurnStartupPhase(observability, {
-          phase: "provider_dispatch",
+          phase: "runtime_stream_initialization",
           provider: turnExecutionPolicy.providerId,
           backend: activeSandboxBackend ?? groupBoxBackend,
-          outcome: providerDispatchOutcome,
-          durationSeconds: (performance.now() - providerDispatchStartedAt) / 1_000,
+          outcome: streamInitializationOutcome,
+          durationSeconds: (performance.now() - streamInitializationStartedAt) / 1_000,
         });
       }
     };
@@ -1747,6 +1749,7 @@ export async function runTurnStreamAttempt(
     return claimedResult({ status: "cancelled" });
   }
   if (
+    turn.source !== "compaction" &&
     generateSessionTitleInParallel &&
     runtime.generateSessionTitle &&
     !runtimeCancellationSignal.aborted
@@ -1822,6 +1825,7 @@ export async function runTurnStreamAttempt(
         let compacted = false;
         let compactionHandled = false;
         let compactionFailureMessage: string | null = null;
+        let compactionFailureError: unknown = null;
         let compactionRequestCleared = false;
         try {
           const outcome = await forceContextCompaction(
@@ -1856,6 +1860,7 @@ export async function runTurnStreamAttempt(
             {
               clearRequestedCompaction: recoveryKind === "operator",
               publishLiveEvents: publishCompactionLiveEvents,
+              providerRejection: compactionProviderRejection(compactError),
             },
           );
           compactionRequestCleared = landmark.requestConsumed;
@@ -1863,6 +1868,7 @@ export async function runTurnStreamAttempt(
           await finishParallelSessionTitle();
           const deferredSteer = await settleDeferredSteerAfterCompaction();
           if (deferredSteer) return deferredSteer;
+          compactionFailureError = compactError;
           compactionFailureMessage = String(compactionFailureReasonFromError(compactError));
           observability.warn("context compaction recovery compaction failed", {
             sessionId: input.sessionId,
@@ -1880,13 +1886,9 @@ export async function runTurnStreamAttempt(
               events: [
                 {
                   type: "turn.failed",
-                  payload: {
+                  payload: compactionFailureTurnEventPayload(compactionFailureError, {
                     error: errorMessage,
-                    code: "context_compaction_failed",
-                    retryable: false,
-                    recovery: "user_message",
-                    compacted: false,
-                  },
+                  }),
                 },
                 {
                   type: "session.status.changed",
@@ -1919,6 +1921,27 @@ export async function runTurnStreamAttempt(
         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" });
+        }
         // Codex parity: compaction remains inside the same logical turn and
         // the same activity. Rebuild the model-visible history from the
         // durable replacement and continue the sampling loop; do not create

package/src/activities/agent-turn/tool-environment.ts

@@ -38,6 +38,11 @@ import {
   resolveGoogleDrivePublicationTarget,
 } from "../google-drive-publication";
 import { connectionTokenResolverForTurn } from "../mcp-credentials";
+import {
+  accountRouteAuthNeededPayload,
+  expandApiIntegrationAccountRoutes,
+  expandMcpAccountRoutes,
+} from "../mcp-account-routes";
 import { createMcpOperationPersistence } from "@opengeni/db/mcp-operations";
 import { createMcpOperationReadStore } from "../mcp-operation-store";
 import { createMcpOperationObserverResolver } from "../mcp-operation-observer";
@@ -51,7 +56,7 @@ import { buildCodexTokenResolver } from "../codex-auth";
 import { CODEX_CLIENT_VERSION } from "@opengeni/codex";
 import { mergeResourceRefs } from "../common";
 import {
-  defaultSessionMcpServerIds,
+  workspaceSessionToolPolicyDefaultServerIds,
   loadRigDefaultVariableSetEnvironment,
   mergeRigDefaultVariableSetEnvironment,
   buildApiIntegrationMcpServers,
@@ -64,7 +69,7 @@ import {
 import { loadWorkspaceEnvironmentForRunWithCredentials } from "../environment";
 import { withFirstPartyTools } from "../goals";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput } from "../types";
-import { recordTurnStartupPhase } from "../../observability-metrics";
+import { recordToolPreparationPhase, recordTurnStartupPhase } from "../../observability-metrics";
 import { ToolResultSpill } from "./tool-result-spill";
 import { createTurnMediaArtifacts } from "./media-artifacts";
 import { SandboxChannelAService } from "@opengeni/runtime/sandbox";
@@ -103,7 +108,6 @@ import { createListModelsAttemptToolDefinition } from "./list-models";
 import { createWorkspaceSkillTools } from "./skill-tools";
 import { loadConfiguredBundledSkills } from "./skill-selection";
 import { guardSkillFilesystem } from "./skill-transfer";
-import type { RuntimeSkillActivation } from "@opengeni/runtime";
 
 export type PrepareTurnToolPolicyDeps = {
   input: RunAgentTurnInput;
@@ -125,7 +129,6 @@ export type PrepareTurnToolRuntimeDeps = {
         input: import("../types").RunKnowledgeSourceSyncBatchInput,
       ) => Promise<import("../types").RunKnowledgeSourceSyncBatchResult>)
     | undefined;
-  selectedSkillActivations: readonly RuntimeSkillActivation[];
   input: RunAgentTurnInput;
   catalogSourceSettings: Settings;
   db: ActivityServices["db"];
@@ -134,7 +137,6 @@ export type PrepareTurnToolRuntimeDeps = {
   objectStorage: ActivityServices["objectStorage"];
   observability: ActivityServices["observability"];
   cancellationSignal: AbortSignal | undefined;
-  connectionCredentials: ActivityServices["connectionCredentials"];
   eventing: EventingState;
   attempt: AttemptIdentityState;
   sandboxState: SandboxRuntimeState;
@@ -152,7 +154,6 @@ export type PrepareTurnToolRuntimeDeps = {
   lazyToolTransport: GovernanceModelOk["lazyToolTransport"];
   turnTools: ReturnType<typeof withFirstPartyTools>;
   connectionScope: { accountId: string; workspaceId: string };
-  hostCredentialRootSessionId: string | null;
   sandboxArtifactRuntime: ReturnType<typeof sandboxArtifactRuntimeAdmission>;
   activeSandboxBackend: Settings["sandboxBackend"] | undefined;
   groupBoxBackend: Settings["sandboxBackend"];
@@ -212,7 +213,15 @@ export async function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps) {
       ? scheduledEffectiveMcpServerIds.filter((id) => currentMcpServerIds.has(id))
       : [...currentMcpServerIds],
     defaultMcpServerIds:
-      scheduledEffectiveMcpServerIds ?? defaultSessionMcpServerIds(capabilitySettings.mcpServers),
+      scheduledEffectiveMcpServerIds ??
+      (session.toolPolicy.mode === "workspace_default"
+        ? await workspaceSessionToolPolicyDefaultServerIds(
+            db,
+            input.workspaceId,
+            capabilitySettings,
+            fileAuthoritySubjectId ?? undefined,
+          )
+        : []),
   });
   const mcpAvailabilityNote = unavailableMcpOperationalContext({
     droppedIds: resolvedToolPolicy.effectivePolicy.droppedIds,
@@ -349,7 +358,6 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
     objectStorage,
     observability,
     cancellationSignal,
-    connectionCredentials,
     eventing,
     attempt,
     sandboxState,
@@ -361,10 +369,9 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
     codexAppsCredentialId,
     turnExecutionPolicy,
     trigger,
-    runSettings,
+    runSettings: canonicalRunSettings,
     lazyToolTransport,
-    turnTools,
-    hostCredentialRootSessionId,
+    turnTools: canonicalTurnTools,
     sandboxArtifactRuntime,
     activeSandboxBackend,
     groupBoxBackend,
@@ -377,26 +384,29 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
     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;
   // Connection credentials and the optional Apps credential are resolved
   // independently. Inference auth is never an Apps fallback.
   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,
   });
   const personalConnectionDelegations = turn.personalConnectionDelegations;
   const delegatedMembershipChecks = new Map<string, Promise<boolean>>();
@@ -463,16 +473,24 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
       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,
@@ -608,7 +626,6 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
   });
   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,
@@ -950,6 +967,7 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
   try {
     eventing.preparedTools = await waitForTurnOperation(
       runtime.prepareTools(githubRestMcp.settings, githubRestMcp.tools, {
+        mcpAccountLabels: accountRoutes.accountLabels,
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
@@ -1002,13 +1020,10 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
         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,
           });
         },
         onAttemptToolCatalog: async (catalog) => {

package/src/activities/agent-turn/turn-context.ts

@@ -1,3 +1,4 @@
+import type { TurnHeartbeatDetails } from "../../op-journal";
 import type { Settings } from "@opengeni/config";
 import type { CodexUsageHeaderSnapshot } from "@opengeni/codex";
 import type { AppendEventInput, ApplySessionTurnSettlementInput } from "@opengeni/db";
@@ -123,6 +124,7 @@ export type RenewalState = {
 };
 
 export type EventingState = {
+  heartbeatDetails: TurnHeartbeatDetails | null;
   heartbeatTimer: ReturnType<typeof startActivityHeartbeat> | undefined;
   batcher: ReturnType<typeof createRuntimeBatcher> | null;
   preparedTools: Awaited<ReturnType<OpenGeniRuntime["prepareTools"]>> | null;
@@ -254,6 +256,7 @@ export function createTurnContext(input: {
       publishedRunCredentialNotices: new Set(),
     },
     eventing: {
+      heartbeatDetails: null,
       heartbeatTimer: undefined,
       batcher: null,
       preparedTools: null,

package/src/activities/agent-turn/turn-sandbox-access.ts

@@ -13,6 +13,12 @@ export type ResolvedTurnSandboxAccess = Readonly<{
   leaseEpoch: number;
 }>;
 
+/** The lazy wrapper remains the agent's owner even after provisioning fills
+ * resolvedSandbox with the raw provider handle for capture and release. */
+export function ownedTurnSandboxForAgent(sandboxState: TurnSandboxAccessState) {
+  return sandboxState.lazyOwnedSandbox ?? sandboxState.resolvedSandbox?.established;
+}
+
 /** Join the turn's canonical sandbox boundary and return its active routed session. */
 export async function resolveTurnSandboxAccess(
   sandboxState: TurnSandboxAccessState,
@@ -24,7 +30,7 @@ export async function resolveTurnSandboxAccess(
     sandbox = await sandboxState.turnSandboxProvisioner.get();
   }
 
-  const session = (sandboxState.lazyOwnedSandbox?.session ??
+  const session = (ownedTurnSandboxForAgent(sandboxState)?.session ??
     sandbox?.established.session ??
     sdkOwnedSandboxSession) as ChannelASession | null;
   if (!session) throw new Error(unavailableMessage);

package/src/activities/capabilities.ts

@@ -22,6 +22,7 @@ import {
   getWorkspaceOpenRouterCustomModelForExecution,
   listSessionMcpServerMetadata,
   listSessionMcpServersForRun,
+  getSessionAttemptMcpApprovalPolicies,
   listWorkspaceGatewayCustomModels,
   listWorkspaceOpenRouterCustomModels,
   workspaceCodexSubscriptionActive,
@@ -47,10 +48,24 @@ export async function settingsWithSessionMcpServersForRun(
   },
 ): Promise<Settings> {
   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(
@@ -69,7 +84,7 @@ export async function settingsWithSessionMcpServersForRun(
   // overlaid into settings. A session projection read earlier in the turn can
   // be stale after a concurrent mcpCredentialUpdates renewal.
   options?.onResolvedServers?.(servers);
-  return settingsWithSessionMcpServers(settings, servers);
+  return settingsWithSessionMcpServers(policySettings, servers);
 }
 
 export function settingsWithSessionMcpServers(

package/src/activities/codex-capacity.ts

@@ -1,4 +1,5 @@
 import {
+  connectionModelAllowed,
   armCodexCapacityWait,
   fetchCodexUsageForAccount,
   getCodexCapacityWaitForSession,
@@ -90,8 +91,15 @@ export async function signalPendingCodexCapacityWakeTargets(
 
 export function codexCapacityDecision<TPolicyScope = never, TUnavailableDiagnostic = never>(
   context: CodexCapacitySelectionContext<TPolicyScope, TUnavailableDiagnostic>,
+  now = new Date(),
 ): ReturnType<Parameters<typeof reconcileCodexCapacityWaitDb>[2]> {
-  const now = new Date();
+  context = {
+    ...context,
+    accounts: context.accounts.filter(
+      (account) =>
+        !context.modelId || connectionModelAllowed(account.allowedModelIds, context.modelId),
+    ),
+  };
   const selected = selectCodexCredentialLeaseForTurn({
     context,
     sessionId: context.sessionId,
@@ -114,8 +122,12 @@ export function codexCapacityDecision<TPolicyScope = never, TUnavailableDiagnost
       credentialId: selected.credentialId,
       diagnostic: {
         connectedCount: context.accounts.length,
-        eligibleCount: context.accounts.filter((account) => isCodexCredentialEligible(account, now))
-          .length,
+        eligibleCount: context.accounts.filter(
+          (account) =>
+            (account.id === selected.credentialId ||
+              !context.failedCredentialIds?.includes(account.id)) &&
+            isCodexCredentialEligible(account, now),
+        ).length,
       },
     };
   }
@@ -134,8 +146,7 @@ export function codexCapacityDecision<TPolicyScope = never, TUnavailableDiagnost
       account.status === "active" &&
       account.allocatorEnabled &&
       account.exhaustedKind === "quota" &&
-      account.exhaustedUntil !== null &&
-      account.exhaustedUntil > now,
+      account.exhaustedUntil !== null,
   );
   const policyAccount = capacityAccounts[0] ?? null;
   const mutationOnlyStatusBlock =
@@ -162,7 +173,7 @@ export function codexCapacityDecision<TPolicyScope = never, TUnavailableDiagnost
     kind: "unavailable",
     earliestResetAt: authoritativeReset,
     resetKind:
-      selected.decision.kind === "none" ||
+      (selected.decision.kind === "none" && !hasReconcilableQuotaCooldown && !authoritativeReset) ||
       selected.decision.kind === "allocatorDisabled" ||
       mutationOnlyStatusBlock
         ? "mutation_only"
@@ -191,6 +202,16 @@ export async function armAndReconcileCodexCapacityWait(
   options: { onArmed?: () => void } = {},
 ) {
   const armed = await armCodexCapacityWait(services.db, input);
+  if (armed.action === "stopped") {
+    options.onArmed?.();
+    await publishDurableSessionEvents(
+      services.bus,
+      input.workspaceId,
+      input.sessionId,
+      armed.events,
+    );
+    return armed;
+  }
   if (armed.action !== "waiting") return armed;
 
   options.onArmed?.();
@@ -219,8 +240,9 @@ export async function armAndReconcileCodexCapacityWait(
 async function refreshCapacityMetadata(
   services: ControlActivityServices,
   workspaceId: string,
+  turnId: string,
 ): Promise<void> {
-  const accounts = await listCodexAccountStatuses(services.db, workspaceId).catch(() => []);
+  const accounts = await listCodexAccountStatuses(services.db, workspaceId, turnId).catch(() => []);
   const now = new Date();
   const stale = accounts.filter(
     (account) =>
@@ -231,7 +253,14 @@ async function refreshCapacityMetadata(
   await refreshCodexUsageAndRepairCapacityWaiters(
     stale.map(
       (account) => () =>
-        fetchCodexUsageForAccount(services.db, services.settings, workspaceId, account.id),
+        fetchCodexUsageForAccount(
+          services.db,
+          services.settings,
+          workspaceId,
+          account.id,
+          undefined,
+          turnId,
+        ),
     ),
     () => signalPendingCodexCapacityWakeTargets(services, workspaceId),
   );
@@ -338,7 +367,7 @@ export function createCodexCapacityActivities(services: () => Promise<ControlAct
     if (boundedRefreshAttempted) {
       // This is a bounded secret-safe control-plane quota refresh. It creates no
       // turn, model call, user message, schedule, or entitlement action.
-      await refreshCapacityMetadata(resolved, input.workspaceId);
+      await refreshCapacityMetadata(resolved, input.workspaceId, current.blockedTurnId);
     }
     const result = await reconcileCodexCapacityWaitDb(
       resolved.db,

package/src/activities/codex-rotation.ts

@@ -12,6 +12,7 @@ import type {
   CodexLeaseAccountStatus,
   CodexPinSource,
 } from "@opengeni/db";
+import { connectionModelAllowed } from "@opengeni/db";
 
 export type CodexRotationAccount = CodexAccountStatus | CodexLeaseAccountStatus;
 
@@ -21,14 +22,12 @@ export function codexAccountNeedsLiveCapacityRefresh(
     CodexAccountStatus,
     "primaryUsedPercent" | "secondaryUsedPercent" | "exhaustedUntil" | "exhaustedKind"
   >,
-  now: Date,
+  _now: Date,
 ): boolean {
   return (
     (account.primaryUsedPercent ?? 0) >= CODEX_USAGE_EXHAUSTED_PCT ||
     (account.secondaryUsedPercent ?? 0) >= CODEX_USAGE_EXHAUSTED_PCT ||
-    (account.exhaustedKind === "quota" &&
-      account.exhaustedUntil !== null &&
-      account.exhaustedUntil > now)
+    (account.exhaustedKind === "quota" && account.exhaustedUntil !== null)
   );
 }
 
@@ -524,8 +523,16 @@ export function selectCodexCredentialLeaseForTurn<
   sessionLastCredentialId: string | null;
   now: Date;
 }): CodexTurnLeaseSelection {
-  const { accounts, activeCredentialId, rotationEnabled, rotationStrategy, existingCredentialId } =
+  const { activeCredentialId, rotationEnabled, rotationStrategy, existingCredentialId } =
     args.context;
+  if (args.context.failoverExhausted) {
+    return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
+  }
+  const accounts = args.context.modelId
+    ? args.context.accounts.filter((account) =>
+        connectionModelAllowed(account.allowedModelIds, args.context.modelId!),
+      )
+    : args.context.accounts;
   const failedCredentialIds = new Set(args.context.failedCredentialIds ?? []);
   // Normalized: rotation-enabled always behaves as sharded (see
   // effectiveRotationStrategy); the stored value is only ever legacy residue.
@@ -564,6 +571,9 @@ export function selectCodexCredentialLeaseForTurn<
     if (!pinned) {
       return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
     }
+    if (failedCredentialIds.has(pinned.id)) {
+      return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
+    }
     if (!pinned.allocatorEnabled) {
       return {
         credentialId: null,
@@ -633,6 +643,9 @@ export function selectCodexCredentialLeaseForTurn<
     if (!active) {
       return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
     }
+    if (failedCredentialIds.has(active.id)) {
+      return { credentialId: null, decision: { kind: "none" }, advanceActivePointer: false };
+    }
     if (!active.allocatorEnabled) {
       return {
         credentialId: null,