@opengeni/worker-bundle 2.2.0-canary.36855269964001 → 2.2.0

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

@@ -1,8 +1,5 @@
 import { measureMcpPhase, withMcpCallIdentity } from "@opengeni/observability";
 import {
-  appendSessionHistoryItems,
-  sessionTurnFinalReplyFacts,
-  sessionTurnHasFinalReplyNudge,
   getSessionEvent,
   getHumanInputResumeForEvent,
   getSessionHumanInputRequest,
@@ -93,14 +90,14 @@ import {
   type SessionTurn,
 } from "@opengeni/contracts";
 import { createModelCheckpointMemoryCollector } from "../../model-checkpoint-memory-collector";
-import { createModelCallAdmission } from "./model-call-admission";
 
 import {
   assertWorkspaceHumanInputAllowed,
   stableHumanInputRequestId,
   stableInteractionInterventionId,
   stableInteractionInterventionOperationId,
-  ensureRunAllowedBetweenModelCalls,
+  BudgetExhaustedError,
+  ensureRunAllowed,
 } from "./admission";
 import {
   compactionFailureReason,
@@ -144,7 +141,6 @@ import {
 import { inputWaitReply, latestDurableTurnMessageText } from "./input-wait-reply";
 import { waitForTurnOperation } from "./sandbox-provision";
 import { createSharedRigSetupCoordinator } from "./sandbox-shared-preparation";
-import { finalReplyNudge, needsFinalReply } from "./final-reply";
 
 import type { CompactionSummarizer } from "../context-compaction";
 import type { TurnExecutionPolicyV1 } from "@opengeni/contracts";
@@ -239,7 +235,6 @@ export type TurnStreamAttemptDeps = {
   groupBoxBackend: Settings["sandboxBackend"];
   turnExecutionPolicy: TurnExecutionPolicyV1;
   turn: Pick<SessionTurn, "initiator" | "initiatorContext"> & {
-    initiatingHumanSubjectId: string | null;
     id: string;
     executionGeneration: number;
     model: string;
@@ -588,41 +583,14 @@ export async function runTurnStreamAttempt(
   // durably: the reply a wait-ended human turn records on turn.completed.
   let latestAssistantMessageText: string | null = null;
   let workerPreparationTotalRecorded = false;
-  let toolsExecuted = false;
-  let finalReplyNudged = false;
-  const revalidateModelCallAdmission = async () => {
-    await historySink.reconcileConversationTruth({ requireDurable: true });
-    await ensureRunAllowedBetweenModelCalls({
-      settings,
-      db,
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      isExternallyBilledTurn: billingState.isExternallyBilledTurn,
-      entitlements,
-      chargesOpenGeniCredits: billingState.chargesOpenGeniCredits,
-      countsTowardTokenCap: billingState.countsTowardTokenCap,
-      initiatingHumanSubjectId: turn.initiatingHumanSubjectId,
-    });
-  };
   const runStreamAttempt = async (options: {
     requireTerminalModelResponse: boolean;
-  }): Promise<RunAgentTurnResult | "reply_nudge"> => {
+  }): Promise<RunAgentTurnResult> => {
     if (!runInput) {
       throw new Error("Run input was not prepared");
     }
-    // The previous stream was persisted before compaction; the sink is now
-    // seeded from its durable replacement. Do not reconcile the old prefix
-    // against that replacement while checking the next stream's admission.
-    eventing.stream = undefined;
-    // Compaction commits its paid usage and replacement history before this
-    // boundary, both during preparation and in-activity recovery. Revalidate
-    // the accepted turn's frozen human before another stream can dispatch.
-    if (options.requireTerminalModelResponse) await revalidateModelCallAdmission();
-    const modelCallAdmission = createModelCallAdmission({
-      signal: runtimeCancellationSignal,
-      admit: revalidateModelCallAdmission,
-    });
     const responseCountBeforeStream = modelResponseState.responseCount;
+    eventing.stream = undefined;
     eventing.batcher = null;
     // The SDK emits every processed call item for one model response before
     // it emits any result for that response. Keep that response-local batch
@@ -838,8 +806,6 @@ export async function runTurnStreamAttempt(
         }
         attempt.modelRequestStarted = true;
         return await runtime.runStream(agent, runInput!, eventing.modelRunSettings, {
-          beforeModelRequest: modelCallAdmission.beforeModelRequest,
-          onModelResponse: modelCallAdmission.onModelResponse,
           signal: runtimeCancellationSignal,
           sandboxEnvironment,
           onModelVisibleContext: async (snapshot) => {
@@ -975,13 +941,7 @@ export async function runTurnStreamAttempt(
     if (leases.xai.lost) {
       throw new Error("xAI credential lease expired before the model run");
     }
-    try {
-      eventing.stream = await withProviderRequestContext(runStreamOnce);
-    } catch (error) {
-      modelCallAdmission.fail(error);
-      modelCallAdmission.close();
-      throw error;
-    }
+    eventing.stream = await withProviderRequestContext(runStreamOnce);
     // Bounded provider label for the streaming SLIs — the resolved registry
     // provider id (or the built-in OpenAI/Azure provider), never a raw
     // user-supplied model string.
@@ -1134,22 +1094,35 @@ export async function runTurnStreamAttempt(
           await historySink.reconcileConversationTruth();
           turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
           modelCheckpointMemoryCollector.schedule(observability);
-          await ensureRunAllowedBetweenModelCalls({
-            settings,
-            db,
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            isExternallyBilledTurn: billingState.isExternallyBilledTurn,
-            entitlements,
-            chargesOpenGeniCredits: billingState.chargesOpenGeniCredits,
-            countsTowardTokenCap: billingState.countsTowardTokenCap,
-            initiatingHumanSubjectId: turn.initiatingHumanSubjectId,
-            serializedRunState: () =>
-              media.compactMediaRunState(String(eventing.stream!.state.toString())),
-          });
+          try {
+            await ensureRunAllowed(
+              settings,
+              db,
+              input.accountId,
+              input.workspaceId,
+              billingState.isExternallyBilledTurn,
+              entitlements,
+              billingState.chargesOpenGeniCredits,
+              billingState.countsTowardTokenCap,
+            );
+          } catch (limitError) {
+            // Capture the run state at the boundary so the budget valve in
+            // the outer catch can end this segment gracefully with full
+            // conversation context preserved for the post-top-up resume.
+            let serializedRunState: string | null = null;
+            try {
+              serializedRunState = media.compactMediaRunState(
+                String(eventing.stream.state.toString()),
+              );
+            } catch {
+              serializedRunState = null;
+            }
+            throw new BudgetExhaustedError(
+              limitError instanceof Error ? limitError.message : String(limitError),
+              serializedRunState,
+            );
+          }
         }
-        // Release only after both the debit and frozen-human admission finish.
-        modelCallAdmission.settle(next.value);
         const durableSdkEvent = generatedImageReceipt
           ? compactGeneratedImageSdkEvent(next.value, generatedImageReceipt)
           : next.value;
@@ -1186,7 +1159,6 @@ export async function runTurnStreamAttempt(
         }
         const completedToolCall = completedToolCallFromSdkEvent(durableSdkEvent);
         if (completedToolCall) {
-          toolsExecuted = true;
           retainedScreenshotMetadata =
             media.retainedScreenshotReceiptsByCallId.get(completedToolCall.callId) ?? null;
           const typedScreenshot = retainedScreenshotMetadata
@@ -1424,7 +1396,6 @@ export async function runTurnStreamAttempt(
         }
       }
     } catch (error) {
-      modelCallAdmission.fail(error);
       // Event processing can fail while SDK completion is still pending.
       // Close this stream before any failure publication; a legitimate
       // compaction retry may start a new, independently fenced generation.
@@ -1480,7 +1451,6 @@ export async function runTurnStreamAttempt(
       }
       throw error;
     } finally {
-      modelCallAdmission.close();
       if (!streamDone) {
         // ReadableStream cancellation synchronously trips the Agents SDK's
         // abort controller, but its returned promise may wait for an
@@ -1502,10 +1472,7 @@ export async function runTurnStreamAttempt(
     // External Codemode stays reachable until finalization. Close wait
     // admission before any terminal output/history decision, and drain an
     // already-admitted wait before consulting the actual runner-yield latch.
-    // Drain trusted receipts before deciding whether an empty stream may need
-    // a handoff. Do not terminally seal the attempt until that decision: the
-    // one same-turn stream still uses the ordinary input-wait admission gate.
-    await eventing.preparedTools?.inputWaitYield?.drainForHandoff(runtimeCancellationSignal);
+    await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
     if (
       options.requireTerminalModelResponse &&
       !eventing.preparedTools?.inputWaitYield?.yielded &&
@@ -1618,7 +1585,6 @@ export async function runTurnStreamAttempt(
       }
     }
     if (eventing.stream.interruptions.length > 0) {
-      await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
       await historySink.reconcileConversationTruth({ requireDurable: true });
       const approvals = runtime.serializeApprovals(eventing.stream.interruptions);
       const humanInputInterruptions =
@@ -1773,60 +1739,6 @@ export async function runTurnStreamAttempt(
     const finalOutput = String(
       requireAgentStreamFinalOutput(eventing.stream.finalOutput, inputWaitYielded),
     );
-    const durableReplyFacts =
-      !inputWaitYielded && finalOutput.trim().length === 0
-        ? await sessionTurnFinalReplyFacts(db, input.workspaceId, input.sessionId, activeTurnId)
-        : { toolsExecuted: false, completedGoal: false };
-    let emptyFinalReply = false;
-    if (
-      needsFinalReply({
-        output: finalOutput,
-        inputWaitYielded:
-          inputWaitYielded || eventing.preparedTools?.inputWaitYield?.requested === true,
-        interrupted: false, // interruption settlement returned above
-        maintenance: turn.source === "compaction",
-        toolsExecuted: toolsExecuted || finalReplyNudged || durableReplyFacts.toolsExecuted,
-        completedGoal: durableReplyFacts.completedGoal,
-      })
-    ) {
-      await historySink.reconcileConversationTruth({ requireDurable: true });
-      // Consult retained truth, including inactive compacted rows, so an
-      // attempt replacement or compaction cannot spend this bound again.
-      if (
-        finalReplyNudged ||
-        (await sessionTurnHasFinalReplyNudge(
-          db,
-          input.workspaceId,
-          input.sessionId,
-          activeTurnId,
-          finalReplyNudge(activeTurnId).content[0]!.text,
-        ))
-      ) {
-        // A second empty response is a delivery-quality notice, not failed
-        // execution: preserve goal continuation and later machine-input wakes.
-        emptyFinalReply = true;
-      } else {
-        const appended = await appendSessionHistoryItems(db, {
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          sessionId: input.sessionId,
-          turnId: activeTurnId,
-          expectedExecutionGeneration: attempt.executionGeneration,
-          expectedAttemptId: input.attemptId,
-          items: [
-            {
-              position: await nextSessionHistoryPosition(db, input.workspaceId, input.sessionId),
-              item: finalReplyNudge(activeTurnId),
-            },
-          ],
-        });
-        if (!appended) throw new TurnAttemptFencedError("turn ended before final reply handoff");
-        finalReplyNudged = true;
-        await prepareRunAttemptInput();
-        return "reply_nudge";
-      }
-    }
-    await eventing.preparedTools?.inputWaitYield?.sealForSettlement(runtimeCancellationSignal);
     // The final output is the newest message this stream completed, already
     // durable with its provider identity and phase. A phase-less settlement
     // copy is published only when this stream did not complete that text.
@@ -1861,11 +1773,7 @@ export async function runTurnStreamAttempt(
             : [{ type: "agent.message.completed" as const, payload: { text: finalOutput } }]),
           {
             type: "turn.completed",
-            payload: {
-              output: finalOutput,
-              ...(reply === null ? {} : { reply }),
-              ...(emptyFinalReply ? { emptyFinalReply: true } : {}),
-            },
+            payload: { output: finalOutput, ...(reply === null ? {} : { reply }) },
           },
           { type: "session.status.changed", payload: { status: "idle" } },
         ],
@@ -1926,9 +1834,6 @@ export async function runTurnStreamAttempt(
   ) {
     return claimedResult({ status: "cancelled" });
   }
-  // Preparation may have spent the last allowance on a completed summary.
-  // Neither the title sidecar nor ordinary inference may dispatch afterward.
-  await revalidateModelCallAdmission();
   if (
     turn.source !== "compaction" &&
     generateSessionTitleInParallel &&
@@ -1966,19 +1871,11 @@ export async function runTurnStreamAttempt(
   }
   try {
     let retriedAfterCompaction = false;
-    finalReplyNudged = await sessionTurnHasFinalReplyNudge(
-      db,
-      input.workspaceId,
-      input.sessionId,
-      activeTurnId,
-      finalReplyNudge(activeTurnId).content[0]!.text,
-    );
     while (true) {
       try {
         const result = await runStreamAttempt({
           requireTerminalModelResponse: retriedAfterCompaction,
         });
-        if (result === "reply_nudge") continue;
         if (retriedAfterCompaction) {
           observability.info("context compaction recovery succeeded after in-activity retry", {
             sessionId: input.sessionId,

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

@@ -68,10 +68,8 @@ import {
   buildApiIntegrationMcpServers,
   resolveCatalogSettings,
   resolveWorkspaceModelSelection,
-  loadWorkspaceCodexModelAvailability,
   withFrozenPersonalConnectionDelegations,
-  resolveTurnToolPolicy,
-  scheduledTurnMcpServerIds,
+  resolveSessionToolPolicy,
   hasPermission,
 } from "@opengeni/core";
 import { loadWorkspaceEnvironmentForRunWithCredentials } from "../environment";
@@ -225,20 +223,32 @@ export async function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps) {
   // sessions follow the current configured MCP set,
   // while explicit, inherited-fixed, and legacy sessions remain narrowed
   // to their stored materialized allow-list.
-  const resolvedToolPolicy = resolveTurnToolPolicy({
+  const scheduledEffectiveMcpServerIds = (() => {
+    const value =
+      turn.metadata && typeof turn.metadata === "object" && !Array.isArray(turn.metadata)
+        ? (turn.metadata as Record<string, unknown>).scheduledEffectiveMcpServerIds
+        : null;
+    return Array.isArray(value) && value.every((id) => typeof id === "string")
+      ? [...new Set(value)].sort()
+      : null;
+  })();
+  const currentMcpServerIds = new Set(runSettings.mcpServers.map((server) => server.id));
+  const resolvedToolPolicy = resolveSessionToolPolicy({
     toolPolicy: session.toolPolicy,
-    session,
-    turn,
-    availableMcpServerIds: runSettings.mcpServers.map((server) => server.id),
+    sessionTools: scheduledEffectiveMcpServerIds ? turn.tools : session.tools,
+    availableMcpServerIds: scheduledEffectiveMcpServerIds
+      ? scheduledEffectiveMcpServerIds.filter((id) => currentMcpServerIds.has(id))
+      : [...currentMcpServerIds],
     defaultMcpServerIds:
-      scheduledTurnMcpServerIds(turn) === null && session.toolPolicy.mode === "workspace_default"
+      scheduledEffectiveMcpServerIds ??
+      (session.toolPolicy.mode === "workspace_default"
         ? await workspaceSessionToolPolicyDefaultServerIds(
             db,
             input.workspaceId,
             capabilitySettings,
             fileAuthoritySubjectId ?? undefined,
           )
-        : [],
+        : []),
   });
   const mcpAvailabilityNote = unavailableMcpOperationalContext({
     droppedIds: resolvedToolPolicy.effectivePolicy.droppedIds,
@@ -898,7 +908,6 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
           organizationGatewayCustomModels,
           organizationOpenRouterConnectionActive,
           organizationOpenRouterCustomModels,
-          codexModelAvailability,
         ] = await Promise.all([
           getWorkspaceConnectionModelRestrictions(
             db,
@@ -944,11 +953,9 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
             workspaceId: input.workspaceId,
             providerKind: "openrouter",
           }),
-          loadWorkspaceCodexModelAvailability(db, currentSettings, input.workspaceId),
         ]);
         return {
           selections: resolveWorkspaceModelSelection({
-            observations: codexModelAvailability,
             connectionModelRestrictions,
             settings: currentSettings,
             policy,
@@ -1103,7 +1110,7 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
         sessionAttachedRemoteMcpTargets: selectedSessionRemoteMcpTargets(
           githubRestMcp.settings,
           session.mcpServers ?? [],
-          githubRestMcp.tools,
+          turn.tools ?? [],
           localMcpServers,
         ),
         ...(deps.runMcpCredentials ? { runMcpCredentials: deps.runMcpCredentials } : {}),

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

@@ -48,7 +48,6 @@ export type TurnSettleFn = (input: {
   sessionStatus: SessionStatus;
   activeTurnId: string | null;
   suppressGoalContinuation?: boolean;
-  allowanceGoalPause?: ApplySessionTurnSettlementInput["allowanceGoalPause"];
   consumeRequestedCompactionFailure?: boolean;
   runState?: ApplySessionTurnSettlementInput["runState"];
 }) => Promise<boolean>;

package/src/activities/capabilities.ts

@@ -40,8 +40,6 @@ import {
   listWorkspaceProviderCustomModels,
   getWorkspaceProviderCustomModelForExecution,
   loadWorkspaceProviderApiKey,
-  loadClaudeSubscriptionUsageCredential,
-  assertModelConnectionAllowsTurn,
   type Database,
   type SessionMcpServerForRun,
 } from "@opengeni/db";
@@ -305,30 +303,12 @@ export async function settingsWithOrganizationProviderCredentials(
     if (kind === "claude_subscription" && !settings.claudeSubscriptionEnabled) continue;
     const models = await buildModels(kind, claudeProviderId(kind) + "/");
     result = withClaudeConnectionCatalog(result, { [kind]: { models } });
-    const binding =
-      kind === "claude_subscription"
-        ? await loadClaudeSubscriptionUsageCredential(db, settings, {
-            accountId,
-            workspaceId,
-            scope: "organization",
-          })
-        : null;
-    const credential =
-      kind === "claude_subscription"
-        ? binding?.serializedCredential
-        : await loadOrganizationModelProviderApiKey(db, settings, {
-            accountId,
-            workspaceId,
-            providerKind: kind,
-          });
-    if (credential)
-      result = withClaudeConnectionCredential(
-        result,
-        kind,
-        credential,
-        "organization",
-        binding ?? undefined,
-      );
+    const credential = await loadOrganizationModelProviderApiKey(db, settings, {
+      accountId,
+      workspaceId,
+      providerKind: kind,
+    });
+    if (credential) result = withClaudeConnectionCredential(result, kind, credential);
     const workspaceModels = await listWorkspaceProviderCustomModels(db, {
       accountId,
       workspaceId,
@@ -353,33 +333,15 @@ export async function settingsWithOrganizationProviderCredentials(
       { [kind]: { models: workspaceModels } },
       "workspace",
     );
-    const workspaceBinding =
-      kind === "claude_subscription"
-        ? await loadClaudeSubscriptionUsageCredential(db, settings, {
-            accountId,
-            workspaceId,
-            scope: "workspace",
-          })
-        : null;
-    if (workspaceBinding && workspaceModelId)
-      await assertModelConnectionAllowsTurn(db, {
-        workspaceId,
-        subjectId: "worker:model-access",
-        modelId: workspaceModelId,
-        workspaceProviderConnectionId: workspaceBinding.connectionId,
-      });
-    const workspaceCredential =
-      kind === "claude_subscription"
-        ? workspaceBinding?.serializedCredential
-        : await loadWorkspaceProviderApiKey(db, settings, workspaceId, kind, workspaceModelId);
+    const workspaceCredential = await loadWorkspaceProviderApiKey(
+      db,
+      settings,
+      workspaceId,
+      kind,
+      workspaceModelId,
+    );
     if (workspaceCredential)
-      result = withClaudeConnectionCredential(
-        result,
-        kind,
-        workspaceCredential,
-        "workspace",
-        workspaceBinding ?? undefined,
-      );
+      result = withClaudeConnectionCredential(result, kind, workspaceCredential, "workspace");
   }
   return result;
 }

package/src/activities/goals.ts

@@ -19,10 +19,14 @@ import {
 import { isCodexBilledModel } from "@opengeni/codex";
 import {
   enqueueSessionWorkflowWakeIfRunnable,
+  getBillingBalance,
   getWorkspaceModelPolicy,
   getSessionGoal,
+  isCodexBilledTurn,
   materializeGoalContinuation,
   requireSession,
+  sumUsageQuantity,
+  type Database,
 } from "@opengeni/db";
 import type {
   ControlActivityServices,
@@ -34,7 +38,6 @@ import {
   resolveCatalogSettings,
   resolveWorkspaceCatalogSettings,
 } from "@opengeni/core";
-import { agentRunAdmissionDenial } from "./agent-run-admission";
 
 export function createGoalActivities(services: () => Promise<ControlActivityServices>) {
   async function enqueueGoalRetryWake(input: MaybeContinueGoalInput): Promise<void> {
@@ -106,6 +109,30 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
     ) {
       modelPolicyBlocked = `session is locked to Codex remote compaction v2; model "${continuationModel}" is not a Codex subscription model`;
     }
+    // A codex-model goal continuation is paid by the user's ChatGPT/Codex plan,
+    // so it must not be budget-paused for zero OpenGeni credits. This file uses
+    // BASE settings (no codex overlay); the predicate does its own credential read.
+    const isCodexRun = await isCodexBilledTurn({
+      db,
+      settings,
+      workspaceId: input.workspaceId,
+      model: continuationModel,
+    });
+    const fundedWithoutCredits = goalContinuationFundedWithoutCredits(
+      settings,
+      continuationModel,
+      isCodexRun,
+    );
+    // Budget exhaustion pauses the goal visibly instead of failing the
+    // session. Computed up front and applied inside the locked decision so a
+    // limits pause never consumes continuation budget.
+    const budgetBlocked = await goalRunBudgetBlocked(
+      settings,
+      db,
+      input.accountId,
+      input.workspaceId,
+      fundedWithoutCredits,
+    );
     const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
       modelId: continuationModel,
       requestedModelId: null,
@@ -130,25 +157,7 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
       // A model-policy block takes precedence: it is deterministic (a budget
       // pause can clear on its own; a policy pause needs a model/policy change)
       // and rides the same visible-pause channel.
-      admission: async (tx, causalTurn) => {
-        const budgetBlocked = modelPolicyBlocked
-          ? null
-          : await goalRunBudgetBlocked(
-              { ...service, settings, db: tx },
-              {
-                accountId: input.accountId,
-                workspaceId: input.workspaceId,
-                model: continuationModel,
-                initiatingHumanSubjectId: causalTurn?.initiatingHumanSubjectId ?? null,
-              },
-            );
-        return {
-          budgetBlocked: modelPolicyBlocked ?? budgetBlocked?.message ?? null,
-          budgetPausedReason: modelPolicyBlocked
-            ? "limits"
-            : (budgetBlocked?.pausedReason ?? "limits"),
-        };
-      },
+      budgetBlocked: modelPolicyBlocked ?? budgetBlocked,
       policy: {
         model: continuationModel,
         reasoningEffort: continuationReasoningEffort,
@@ -298,8 +307,6 @@ export function goalContinuationPrompt(
     "- For document report deliverables (a document the user asked for, or a large report meant to be kept or shared), follow the Documents Skill: create the durable native document first, inspect its relevant final head after the last edit, and provide the returned artifact reference. Declare report requirements through the available goal tools before authoring and satisfy every persisted report requirement with verified artifact delivery evidence before completion. Sandbox paths and raw file IDs do not prove report delivery. If artifact tooling or access is unavailable, keep that deliverable incomplete and state the blocker; never invent proof or silently substitute a local report. Ordinary chat answers, short progress updates, source-code links, and explicitly requested local-file work remain outside this report contract.",
     "",
     "Do not rely on intent, partial progress, memory of earlier work, or a plausible final answer as proof of completion. Call opengeni__goal_complete with concrete evidence only when the full objective is actually achieved and no required work remains.",
-    "Goal evidence is a short proof for the ledger, not the deliverable. After goal_complete succeeds, finish this same turn with the requested user-facing answer, or a concise summary and retained artifact link. Goal completion stops future automatic continuations; it does not send the answer or end this turn. Never compress a report into evidence or omit the final reply.",
-    "Goal progress notes are short human-readable milestone statuses, not raw transcripts or continuation instructions. Keep normal spaces and summarize detail instead of squeezing words into a ledger field. The text and successCriteria fields each allow 8192 UTF-8 bytes, progressNote allows 8192 UTF-8 bytes, rationale allows 2048 UTF-8 bytes, and evidence allows 8192 characters.",
     "",
     ...waitingGuidance,
     ...childNoticeGuidance,
@@ -329,22 +336,55 @@ export function withFirstPartyTools(settings: Settings, tools: ToolRef[]): ToolR
 }
 
 /**
- * Goals share scheduled admission and pause visibly without synthesizing work.
+ * Non-throwing variant of the scheduled-run admission check: returns a human
+ * readable reason when balance or monthly caps block another agent run.
  */
-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" };
+async function goalRunBudgetBlocked(
+  settings: Settings,
+  db: Database,
+  accountId: string,
+  workspaceId: string,
+  fundedWithoutCredits: boolean,
+): Promise<string | null> {
+  // Free, subscription, and workspace-funded continuations skip OpenGeni's
+  // credit-balance gate and monthly model-cost cap. The agent-run COUNT cap
+  // below is a volume quota (not a credit/cost gate) and remains enforced.
+  if (
+    !fundedWithoutCredits &&
+    (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed")
+  ) {
+    const balance = await getBillingBalance(db, accountId);
+    if (balance.balanceMicros <= 0) {
+      return "insufficient OpenGeni credits";
+    }
   }
-  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] };
+  if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
+    const limits = configuredStaticUsageLimits(settings);
+    if (!fundedWithoutCredits && limits.maxMonthlyCostMicrosPerAccount) {
+      const used = await sumUsageQuantity(db, {
+        accountId,
+        eventType: "model.cost",
+        since: startOfUtcMonth(),
+      });
+      if (used >= limits.maxMonthlyCostMicrosPerAccount) {
+        return `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`;
+      }
+    }
+    if (limits.maxMonthlyAgentRunsPerWorkspace) {
+      const used = await sumUsageQuantity(db, {
+        workspaceId,
+        eventType: "agent_run.created",
+        since: startOfUtcMonth(),
+      });
+      if (used + 1 > limits.maxMonthlyAgentRunsPerWorkspace) {
+        return `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`;
+      }
+    }
+  }
+  return null;
+}
+
+function startOfUtcMonth(): Date {
+  const now = new Date();
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
 }