@opengeni/worker-bundle 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,26 +54,26 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "1.0.2",
-    "@opengeni/capabilities": "1.0.2",
-    "@opengeni/codemode": "1.0.2",
-    "@opengeni/codex": "1.0.2",
-    "@opengeni/config": "1.0.2",
-    "@opengeni/contracts": "1.0.2",
-    "@opengeni/core": "1.0.2",
-    "@opengeni/db": "1.0.2",
-    "@opengeni/documents": "1.0.2",
-    "@opengeni/events": "1.0.2",
-    "@opengeni/github": "1.0.2",
-    "@opengeni/interaction": "1.0.2",
-    "@opengeni/jev": "1.0.2",
-    "@opengeni/network": "1.0.2",
-    "@opengeni/observability": "1.0.2",
-    "@opengeni/runtime": "1.0.2",
-    "@opengeni/sdk": "1.0.2",
-    "@opengeni/storage": "1.0.2",
-    "@opengeni/tool-gateway": "1.0.2",
-    "@opengeni/xai-subscription": "1.0.2",
+    "@opengeni/agent-proto": "1.1.0",
+    "@opengeni/capabilities": "1.1.0",
+    "@opengeni/codemode": "1.1.0",
+    "@opengeni/codex": "1.1.0",
+    "@opengeni/config": "1.1.0",
+    "@opengeni/contracts": "1.1.0",
+    "@opengeni/core": "1.1.0",
+    "@opengeni/db": "1.1.0",
+    "@opengeni/documents": "1.1.0",
+    "@opengeni/events": "1.1.0",
+    "@opengeni/github": "1.1.0",
+    "@opengeni/interaction": "1.1.0",
+    "@opengeni/jev": "1.1.0",
+    "@opengeni/network": "1.1.0",
+    "@opengeni/observability": "1.1.0",
+    "@opengeni/runtime": "1.1.0",
+    "@opengeni/sdk": "1.1.0",
+    "@opengeni/storage": "1.1.0",
+    "@opengeni/tool-gateway": "1.1.0",
+    "@opengeni/xai-subscription": "1.1.0",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-run-admission.ts

@@ -1,98 +1 @@
-import { configuredStaticUsageLimits, type Settings } from "@opengeni/config";
-import { modelFundingForAdmission } from "@opengeni/core";
-import {
-  checkWorkspaceAllowance,
-  getBillingBalance,
-  isCodexBilledTurn,
-  sumUsageQuantity,
-} from "@opengeni/db";
-import type { ControlActivityServices } from "./types";
-
-export type AgentRunAdmissionDenial =
-  | "insufficient_credits"
-  | "allowance_exhausted"
-  | "monthly_model_cost_limit"
-  | "monthly_agent_run_limit";
-
-/** One worker-side admission boundary for service-authored agent runs. */
-export async function agentRunAdmissionDenial(
-  services: Pick<ControlActivityServices, "db" | "entitlements"> & { settings: Settings },
-  input: {
-    accountId: string;
-    workspaceId: string;
-    model: string;
-    requestedAgentRuns: number;
-    /** The accepted work's causal human, not the scheduler/service caller. */
-    initiatingHumanSubjectId?: string | null;
-  },
-): Promise<AgentRunAdmissionDenial | null> {
-  const codexBilled = await isCodexBilledTurn({
-    db: services.db,
-    settings: services.settings,
-    workspaceId: input.workspaceId,
-    model: input.model,
-  });
-  const externallyBilled = modelFundingForAdmission(
-    services.settings,
-    input.model,
-    codexBilled,
-  ).fundedWithoutCredits;
-  if (
-    !externallyBilled &&
-    (services.settings.billingMode === "stripe" || services.settings.usageLimitsMode === "managed")
-  ) {
-    if (services.entitlements) {
-      const decision = await services.entitlements.admitRun({
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        action: "agent_run:create",
-        quantity: input.requestedAgentRuns,
-      });
-      if (!decision.allowed) return "insufficient_credits";
-    } else {
-      const balance = await getBillingBalance(services.db, input.accountId);
-      if (balance.balanceMicros <= 0) return "insufficient_credits";
-    }
-  }
-  if (!externallyBilled) {
-    const refusal = await checkWorkspaceAllowance(services.db, {
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      subjectId: input.initiatingHumanSubjectId ?? null,
-    });
-    if (refusal) return refusal.code;
-  }
-  if (
-    services.settings.usageLimitsMode !== "static" &&
-    services.settings.usageLimitsMode !== "managed"
-  ) {
-    return null;
-  }
-  const limits = configuredStaticUsageLimits(services.settings);
-  if (!externallyBilled && limits.maxMonthlyCostMicrosPerAccount) {
-    const used = await sumUsageQuantity(services.db, {
-      accountId: input.accountId,
-      eventType: "model.cost",
-      since: startOfUtcMonth(),
-    });
-    if (used >= limits.maxMonthlyCostMicrosPerAccount) {
-      return "monthly_model_cost_limit";
-    }
-  }
-  if (limits.maxMonthlyAgentRunsPerWorkspace) {
-    const used = await sumUsageQuantity(services.db, {
-      workspaceId: input.workspaceId,
-      eventType: "agent_run.created",
-      since: startOfUtcMonth(),
-    });
-    if (used + input.requestedAgentRuns > limits.maxMonthlyAgentRunsPerWorkspace) {
-      return "monthly_agent_run_limit";
-    }
-  }
-  return null;
-}
-
-function startOfUtcMonth(): Date {
-  const now = new Date();
-  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
-}
+export { agentRunAdmissionDenial, type AgentRunAdmissionDenial } from "@opengeni/core";

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

@@ -60,6 +60,7 @@ import { createTurnCredentialLeases } from "./credential-leases";
 import { createTurnMediaArtifacts } from "./media-artifacts";
 import { readTurnExecutionPolicyV1 } from "@opengeni/contracts";
 import { turnCredentialRestriction } from "./credential-restriction";
+import { readProviderRecoveryObservation } from "./provider-recovery-metrics";
 
 import {
   credentialSubjectIdForTurnInitiator,
@@ -237,6 +238,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
   attempt.dispatchId = dispatchId;
   attempt.executionGeneration = turn.executionGeneration;
   attempt.providerRecoveryCount = providerRecoveryCountFromMetadata(turn.metadata);
+  attempt.providerRecoveryObservation = readProviderRecoveryObservation(turn.metadata ?? {});
   const authRecovery = turn.metadata?.claudeAuthRecovery;
   attempt.claudeAuthRecovery =
     authRecovery &&
@@ -391,6 +393,11 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
       latencyMode: turn.latencyMode,
     },
   );
+  // The durable same-turn recovery lane owns provider retries. Hidden SDK
+  // retries multiply that budget and keep the UI looking active during backoff.
+  // Apply before configuring/resolving clients so main, compaction and title
+  // requests all share this policy; standalone runtime consumers keep theirs.
+  capabilitySettings = { ...capabilitySettings, openaiMaxRetries: 0 };
   runtime.configure(capabilitySettings);
   const verifiedExecutionPolicy = assertTurnExecutionPolicyMatchesConfigV1(
     capabilitySettings,
@@ -402,6 +409,10 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     },
   );
   const turnExecutionPolicy = verifiedExecutionPolicy.policy;
+  attempt.modelMetricRoute = {
+    provider: turnExecutionPolicy.providerId,
+    model: turnExecutionPolicy.productModelId,
+  };
   assertSessionAllowsProductModel(session, turnExecutionPolicy.productModelId);
   const billingIdentity = turnExecutionPolicyBillingIdentity(turnExecutionPolicy);
   billingState.isExternallyBilledTurn = billingIdentity.externallyBilled;

package/src/activities/agent-turn/compaction-prep.ts

@@ -46,6 +46,7 @@ import {
   processCompactionModelUsageEvent,
 } from "./model-usage";
 import { waitForTurnOperation } from "./sandbox-provision";
+import { recordProviderRecoveryOutcome } from "./provider-recovery-metrics";
 
 import type { ClaimTurnOk } from "./claim";
 import type { GovernanceModelOk } from "./governance-model";
@@ -330,6 +331,20 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     await publishDurableSessionEvents(bus, input.workspaceId, input.sessionId, events);
   };
   const publishCompactionOutcomeEvents = async (events: SessionEvent[]) => {
+    if (events.some((event) => event.type === "session.context.compacted")) {
+      // The summary and recovery reset already committed under the attempt
+      // fence. Skipped compaction does not prove successful model progress.
+      attempt.providerRecoveryCount = 0;
+      if (attempt.providerRecoveryObservation) {
+        recordProviderRecoveryOutcome(observability, {
+          route: attempt.modelMetricRoute,
+          cause: attempt.providerRecoveryObservation.cause,
+          outcome: "recovered",
+          elapsedMs: Date.now() - attempt.providerRecoveryObservation.startedAt,
+        });
+        attempt.providerRecoveryObservation = undefined;
+      }
+    }
     // `compaction.started` was already fanout via publishCompactionLiveEvents.
     await publishDurableSessionEvents(
       bus,

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

@@ -100,6 +100,11 @@ export const MAX_AUTOMATIC_PROVIDER_RECOVERIES = PROVIDER_CONNECTIVITY_BACKOFF_M
  * alone would spend every automatic recovery before the window resets.
  */
 export const PROVIDER_RATE_LIMIT_BACKOFF_MS = [10_000, 20_000, 40_000, 60_000, 120_000] as const;
+/** Positive-only spread: never shorten the provider's minimum delay. */
+export function providerRecoveryJitterMs(delayMs: number, sample: number): number {
+  const bounded = Number.isFinite(sample) ? Math.max(0, Math.min(sample, 1)) : 0;
+  return Math.floor(Math.min(5_000, delayMs * 0.2) * bounded);
+}
 export const POST_COMPACTION_CONTINUATION_EMPTY_CODE = "post_compaction_continuation_empty";
 
 export class PostCompactionContinuationEmptyError extends Error {
@@ -126,6 +131,7 @@ export function providerRecoveryResult(input: {
   failureCode: string | undefined;
   attemptNumber: number;
   retryAfterMs?: number | null;
+  jitterSample?: number;
 }): ProviderRecoveryResult {
   if (input.attemptNumber > MAX_AUTOMATIC_PROVIDER_RECOVERIES) {
     return {
@@ -171,7 +177,13 @@ export function providerRecoveryResult(input: {
         : PROVIDER_BACKPRESSURE_DELAY_MS;
   return {
     status: "recovering",
-    continueDelayMs,
+    continueDelayMs:
+      continueDelayMs +
+      (input.failureCode === "provider_rate_limited" ||
+      input.failureCode === "provider_unavailable" ||
+      input.failureCode === "upstream_connectivity_unavailable"
+        ? providerRecoveryJitterMs(continueDelayMs, input.jitterSample ?? 0)
+        : 0),
   };
 }
 
@@ -1086,19 +1098,28 @@ function isProviderSafetyRefusal(error: unknown): boolean {
   return providerSafetyRefusalDiagnostic(error) !== undefined;
 }
 
+/** Preserve the closest real HTTP status through SDK Error.cause wrappers. */
+function providerHttpStatus(error: unknown): number | undefined {
+  let current = error;
+  const seen = new Set<unknown>();
+  for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
+    if (seen.has(current)) break;
+    seen.add(current);
+    const value = current as { status?: unknown; statusCode?: unknown; cause?: unknown };
+    const status = Number(value.status ?? value.statusCode);
+    if (Number.isInteger(status) && status >= 100 && status < 600) return status;
+    current = value.cause;
+  }
+  return undefined;
+}
+
 export function isTransientProviderError(error: unknown): boolean {
   if (error instanceof ResponsesStreamingTerminalError) {
     return error.category === "unavailable";
   }
   // A semantic refusal can arrive inside a 5xx transport envelope.
   if (isProviderSafetyRefusal(error)) return false;
-  const status =
-    typeof error === "object" && error !== null
-      ? Number(
-          (error as { status?: unknown; statusCode?: unknown }).status ??
-            (error as { statusCode?: unknown }).statusCode,
-        )
-      : undefined;
+  const status = providerHttpStatus(error);
   // A real HTTP status is AUTHORITATIVE: a 5xx is transient, and ANY other status
   // (4xx validation/auth/404, plus the 429 the earlier branches already handled) is
   // a request fault that must NOT auto-retry — even if its body happens to read like
@@ -1399,13 +1420,7 @@ function baseAgentRunFailurePayload(
     };
   }
   const message = error instanceof Error ? error.message : String(error);
-  const status =
-    typeof error === "object" && error !== null
-      ? Number(
-          (error as { status?: unknown; statusCode?: unknown }).status ??
-            (error as { statusCode?: unknown }).statusCode,
-        )
-      : undefined;
+  const status = providerHttpStatus(error);
   const code =
     typeof error === "object" && error !== null && "code" in error
       ? String((error as { code?: unknown }).code)

package/src/activities/agent-turn/failure-settlement.ts

@@ -100,6 +100,7 @@ import type {
 } from "./turn-context";
 import type { CodexCredentialPolicySnapshotV1 } from "@opengeni/contracts";
 import { armAndReconcileCodexCapacityWait } from "../codex-capacity";
+import { providerRecoveryCause, recordProviderRecoveryOutcome } from "./provider-recovery-metrics";
 
 export type TurnFailureDeps = {
   error: unknown;
@@ -1995,6 +1996,7 @@ async function settleTurnFailureInAttempt(deps: TurnFailureDeps): Promise<RunAge
       failureCode: failure.code,
       attemptNumber: nextProviderRecoveryCount,
       retryAfterMs: providerRetryAfterMs(error),
+      jitterSample: Math.random(),
     });
     const setupRecoveryExhausted =
       earlyCommandStartUnavailable &&
@@ -2064,9 +2066,29 @@ async function settleTurnFailureInAttempt(deps: TurnFailureDeps): Promise<RunAge
         control.turnMetricOutcome = "recovering";
         control.activityStatus = "recovering";
         control.activityError = error;
+        const recoveryCause = providerRecoveryCause(failure.code);
+        if (recoveryCause) {
+          recordProviderRecoveryOutcome(observability, {
+            route: attempt.modelMetricRoute,
+            cause: recoveryCause,
+            outcome: "scheduled",
+            delayMs: recoveryResult.continueDelayMs,
+          });
+        }
         return claimedResult(recoveryResult);
       }
       failure = providerRecoveryExhaustedFailure(failure, recoveryResult);
+      const recoveryCause = providerRecoveryCause(failure.code);
+      if (recoveryCause) {
+        recordProviderRecoveryOutcome(observability, {
+          route: attempt.modelMetricRoute,
+          cause: recoveryCause,
+          outcome: "exhausted",
+          ...(attempt.providerRecoveryObservation
+            ? { elapsedMs: Date.now() - attempt.providerRecoveryObservation.startedAt }
+            : {}),
+        });
+      }
       if (earlyRecoverableSetup) {
         // Setup has no eventing sink yet. Carry only the fixed, safe diagnostic
         // through Temporal into exact-attempt workflow failure settlement.

package/src/activities/agent-turn/provider-recovery-metrics.ts

@@ -0,0 +1,64 @@
+import type { Observability } from "@opengeni/observability";
+
+export type ProviderRecoveryObservation = {
+  startedAt: number;
+  cause: "rate_limited" | "unavailable" | "connectivity";
+};
+
+export function providerRecoveryCause(code: unknown): ProviderRecoveryObservation["cause"] | null {
+  if (code === "provider_rate_limited") return "rate_limited";
+  if (code === "provider_unavailable") return "unavailable";
+  if (code === "upstream_connectivity_unavailable") return "connectivity";
+  return null;
+}
+
+export function readProviderRecoveryObservation(
+  metadata: Record<string, unknown>,
+): ProviderRecoveryObservation | undefined {
+  const cause = providerRecoveryCause(metadata.providerRecoveryReason);
+  const startedAt =
+    typeof metadata.providerRecoveryStartedAt === "string"
+      ? Date.parse(metadata.providerRecoveryStartedAt)
+      : Number.NaN;
+  return cause && Number.isFinite(startedAt) ? { cause, startedAt } : undefined;
+}
+
+/** Operational observations only; never retry authority, billing or diagnostics. */
+export function recordProviderRecoveryOutcome(
+  observability: Observability,
+  input: {
+    route?: { provider: string; model: string } | undefined;
+    cause: ProviderRecoveryObservation["cause"];
+    outcome: "scheduled" | "recovered" | "exhausted";
+    delayMs?: number;
+    elapsedMs?: number;
+  },
+): void {
+  if (!input.route) return;
+  const labels = { ...input.route, cause: input.cause, outcome: input.outcome };
+  try {
+    observability.incrementCounter({
+      name: "opengeni_model_recovery_total",
+      help: "Observed model recovery decisions and successful resumptions.",
+      labels,
+    });
+    if (input.delayMs !== undefined) {
+      observability.observeHistogram({
+        name: "opengeni_model_recovery_delay_seconds",
+        help: "Scheduled model recovery delay, including provider hints and jitter.",
+        labels: { ...input.route, cause: input.cause },
+        value: Math.max(0, input.delayMs) / 1_000,
+      });
+    }
+    if (input.elapsedMs !== undefined) {
+      observability.observeHistogram({
+        name: "opengeni_model_recovery_duration_seconds",
+        help: "Elapsed recovery episode including backoff, preparation and model requests.",
+        labels,
+        value: Math.max(0, input.elapsedMs) / 1_000,
+      });
+    }
+  } catch {
+    // Metrics cannot interrupt settlement or model progress.
+  }
+}

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

@@ -18,6 +18,7 @@ import {
   updateSessionTitleWithEvent,
 } from "@opengeni/db";
 import { publishDurableSessionEvents } from "@opengeni/events";
+import { recordProviderRecoveryOutcome } from "./provider-recovery-metrics";
 import {
   AssistantMessagePhaseTracker,
   normalizeModelCallUsage,
@@ -1132,6 +1133,15 @@ export async function runTurnStreamAttempt(
             ]);
             attempt.providerRecoveryCount = 0;
           }
+          if (attempt.providerRecoveryObservation) {
+            recordProviderRecoveryOutcome(observability, {
+              route: attempt.modelMetricRoute,
+              cause: attempt.providerRecoveryObservation.cause,
+              outcome: "recovered",
+              elapsedMs: Date.now() - attempt.providerRecoveryObservation.startedAt,
+            });
+            attempt.providerRecoveryObservation = undefined;
+          }
           const rawStreamHistory = (eventing.stream.state as { history?: unknown[] }).history;
           if (Array.isArray(rawStreamHistory)) {
             // The completed image item is normally retained from its own

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

@@ -82,6 +82,7 @@ import { createTurnMediaArtifacts } from "./media-artifacts";
 import { SandboxChannelAService } from "@opengeni/runtime/sandbox";
 import { sandboxRunAs } from "@opengeni/runtime";
 import {
+  bundledSkillSelectionForAgentConfig,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   resolveAgentToolFamilies,
   type ResourceRef,
@@ -596,7 +597,11 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
     session.firstPartyMcpPermissions,
     linkedAuthority,
   );
-  const toolFamilies = resolveAgentToolFamilies(session.agent);
+  // Background-command tools need compute: the effective route of this turn,
+  // a managed sandbox or an attached Connected Machine, not the durable home.
+  const toolFamilies = resolveAgentToolFamilies(session.agent, {
+    sandboxAttached: (activeSandboxBackend ?? groupBoxBackend) !== "none",
+  });
   const selectedFirstPartyMcpTools = toolFamilies.firstPartyTools(
     allowedFirstPartyMcpToolsForSession(runSettings, session.firstPartyMcpTools),
   );
@@ -669,7 +674,9 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
     }),
   ]);
   const bundledSkills = loadConfiguredBundledSkills({
-    bundledSkillIds: session.bundledSkillIds,
+    // Rows that could not freeze the "none" default at create (scheduled
+    // generated sessions, pre-existing rows) get the same rule here.
+    bundledSkillIds: bundledSkillSelectionForAgentConfig(session.bundledSkillIds, session.agent),
     firstPartyTools: selectedFirstPartyMcpTools,
     videoGenerationEnabled:
       skillConfiguration.defaultModelId !== null && skillConfiguration.enabledModelIds.length > 0,

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

@@ -68,6 +68,10 @@ export type AttemptIdentityState = {
   triggerEventId: string | undefined;
   executionGeneration: number;
   providerRecoveryCount: number;
+  providerRecoveryObservation?:
+    | import("./provider-recovery-metrics").ProviderRecoveryObservation
+    | undefined;
+  modelMetricRoute?: { provider: string; model: string };
   claudeAuthRecovery?: { credentialId: string; credentialVersion: number } | undefined;
   modelRequestStarted: boolean;
   redispatchesAtDispatch: number;

package/src/activities/goals.ts

@@ -1,27 +1,16 @@
 import {
   allowedFirstPartyMcpToolsForSession,
-  configuredStaticUsageLimits,
-  isModelAvailableForNewSelection,
-  policyProviderIdForModel,
-  resolveModelProvider,
   resolveTurnExecutionPolicyV1,
-  withCodexCatalogProvider,
-  withXaiSubscriptionCatalogProvider,
-  WORKSPACE_GATEWAY_MODEL_ID_PREFIX,
-  WORKSPACE_OPENROUTER_MODEL_ID_PREFIX,
   type Settings,
 } from "@opengeni/config";
 import {
-  evaluateWorkspaceModelPolicy,
   mergeToolRefs,
   readTurnExecutionPolicyV1,
   type SessionGoal,
   type ToolRef,
 } from "@opengeni/contracts";
-import { isCodexBilledModel } from "@opengeni/codex";
 import {
   enqueueSessionWorkflowWakeIfRunnable,
-  getWorkspaceModelPolicy,
   getSessionGoal,
   getSessionTurn,
   materializeGoalContinuation,
@@ -34,10 +23,10 @@ import type {
 } from "./types";
 import {
   modelFundingForAdmission,
-  resolveCatalogSettings,
-  resolveWorkspaceCatalogSettings,
+  goalRunBudgetBlocked,
+  resolveGoalModelAdmission,
 } from "@opengeni/core";
-import { agentRunAdmissionDenial } from "./agent-run-admission";
+export { goalContinuationModelDecision, goalRunBudgetBlocked } from "@opengeni/core";
 import { turnCredentialRestriction } from "./agent-turn/credential-restriction";
 
 export function createGoalActivities(services: () => Promise<ControlActivityServices>) {
@@ -80,42 +69,18 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
     if (session.status === "failed" || session.status === "cancelled") {
       return { action: "none" };
     }
-    let settings = (await resolveCatalogSettings(db, catalogSourceSettings)).settings;
-    const inheritedContinuationModel = session.model;
-    let continuationModel = inheritedContinuationModel;
+    const modelDecision = await resolveGoalModelAdmission(db, catalogSourceSettings, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      model: session.model,
+      codexCompactionMode: session.codexCompactionMode,
+      latencyMode: session.latencyMode,
+    });
+    const settings = modelDecision.settings;
+    const continuationModel = modelDecision.model;
     const continuationReasoningEffort = session.reasoningEffort;
     const continuationLatencyMode = session.latencyMode;
-    const workspaceModelPolicy = await getWorkspaceModelPolicy(db, input.workspaceId);
-    if (
-      inheritedContinuationModel.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) ||
-      inheritedContinuationModel.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX) ||
-      session.model.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX) ||
-      session.model.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX)
-    ) {
-      settings = (
-        await resolveWorkspaceCatalogSettings(db, catalogSourceSettings, {
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          retainedProductModelIds: [inheritedContinuationModel, session.model],
-        })
-      ).settings;
-    }
-    const modelDecision = goalContinuationModelDecision({
-      settings,
-      workspaceModelPolicy,
-      inheritedModel: inheritedContinuationModel,
-    });
-    continuationModel = modelDecision.model;
-    let modelPolicyBlocked = modelDecision.blocked;
-    // remote_v2 sessions may only continue on Codex models — refuse synthesis
-    // that would leave the portable/non-Codex path (and mixed history shapes).
-    if (
-      !modelPolicyBlocked &&
-      session.codexCompactionMode === "remote_v2" &&
-      !isCodexBilledModel(continuationModel)
-    ) {
-      modelPolicyBlocked = `session is locked to Codex remote compaction v2; model "${continuationModel}" is not a Codex subscription model`;
-    }
+    const modelPolicyBlocked = modelDecision.blocked;
     const turnExecutionPolicy = modelPolicyBlocked
       ? undefined
       : resolveTurnExecutionPolicyV1(settings, {
@@ -183,11 +148,12 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
                 initiatingHumanSubjectId: causalTurn?.initiatingHumanSubjectId ?? null,
               },
             );
+        const pausedReason = modelPolicyBlocked
+          ? modelDecision.pausedReason
+          : budgetBlocked?.pausedReason;
         return {
           budgetBlocked: modelPolicyBlocked ?? budgetBlocked?.message ?? null,
-          budgetPausedReason: modelPolicyBlocked
-            ? "limits"
-            : (budgetBlocked?.pausedReason ?? "limits"),
+          ...(pausedReason ? { budgetPausedReason: pausedReason } : {}),
         };
       },
       policy: continuationPolicy,
@@ -220,47 +186,6 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
   };
 }
 
-export function goalContinuationModelDecision(input: {
-  settings: Settings;
-  workspaceModelPolicy: Awaited<ReturnType<typeof getWorkspaceModelPolicy>>;
-  inheritedModel: string;
-}): { model: string; blocked: string | null } {
-  const catalogSettings = input.settings.supergrokSubscriptionEnabled
-    ? withXaiSubscriptionCatalogProvider(
-        input.settings.codexSubscriptionEnabled
-          ? withCodexCatalogProvider(input.settings)
-          : input.settings,
-      )
-    : input.settings.codexSubscriptionEnabled
-      ? withCodexCatalogProvider(input.settings)
-      : input.settings;
-  const policyBlocks = (modelId: string): boolean =>
-    input.workspaceModelPolicy !== null &&
-    !evaluateWorkspaceModelPolicy(input.workspaceModelPolicy, {
-      providerId: policyProviderIdForModel(catalogSettings, modelId),
-      modelId,
-    }).allowed;
-  if (!resolveModelProvider(catalogSettings, input.inheritedModel)) {
-    return {
-      model: input.inheritedModel,
-      blocked: `model "${input.inheritedModel}" is no longer in the deployment or workspace catalog; choose an available model before resuming the goal`,
-    };
-  }
-  if (!isModelAvailableForNewSelection(catalogSettings, input.inheritedModel)) {
-    return {
-      model: input.inheritedModel,
-      blocked: `model "${input.inheritedModel}" is retired from new selection; choose an available model before resuming the goal`,
-    };
-  }
-  if (!policyBlocks(input.inheritedModel)) {
-    return { model: input.inheritedModel, blocked: null };
-  }
-  return {
-    model: input.inheritedModel,
-    blocked: `workspace model policy blocks model "${input.inheritedModel}"; pick an allowed model or change the workspace model policy`,
-  };
-}
-
 export function goalContinuationFundedWithoutCredits(
   settings: Settings,
   model: string,
@@ -364,24 +289,3 @@ export function withFirstPartyTools(settings: Settings, tools: ToolRef[]): ToolR
   }
   return mergeToolRefs(tools, [{ kind: "mcp", id: "opengeni" }]);
 }
-
-/**
- * Goals share scheduled admission and pause visibly without synthesizing work.
- */
-export async function goalRunBudgetBlocked(
-  services: Parameters<typeof agentRunAdmissionDenial>[0],
-  input: Omit<Parameters<typeof agentRunAdmissionDenial>[1], "requestedAgentRuns">,
-): Promise<{ pausedReason: "limits" | "allowance"; message: string } | null> {
-  const denial = await agentRunAdmissionDenial(services, { ...input, requestedAgentRuns: 1 });
-  if (denial === null) return null;
-  if (denial === "allowance_exhausted") {
-    return { pausedReason: "allowance", message: "Opengeni usage allowance exhausted" };
-  }
-  const limits = configuredStaticUsageLimits(services.settings);
-  const messages = {
-    insufficient_credits: "insufficient Opengeni credits",
-    monthly_model_cost_limit: `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`,
-    monthly_agent_run_limit: `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`,
-  };
-  return { pausedReason: "limits", message: messages[denial] };
-}