chainlesschain 0.165.2 → 0.165.4

package/src/repl/agent-repl.js

@@ -79,6 +79,16 @@ import {
   readSessionHostResumeState,
 } from "../lib/session-host-snapshot.js";
 import { acquireSessionHostLease } from "../lib/session-host-lease.js";
+import {
+  openProductionSessionBudgetRoot,
+  sessionBudgetAdmissionError,
+} from "../lib/session-budget-production-root.js";
+import {
+  beginSessionBudgetUsage,
+  markSessionBudgetUsageUnknown,
+  recordSessionBudgetUsage,
+  rejectSessionBudgetUsageUnknown,
+} from "../lib/session-budget-usage.js";
 import {
   SideEffectLedger,
   classifyToolSideEffect,
@@ -236,6 +246,29 @@ export function resolveReplMeteredSessionId(useJsonl, sessionId) {
   return useJsonl && sessionId ? sessionId : null;
 }
 
+export function combineReplSignals(...signals) {
+  const active = [...new Set(signals.filter(Boolean))];
+  if (active.length === 0) return null;
+  if (active.length === 1) return active[0];
+  return AbortSignal.any(active);
+}
+
+export async function closeReplSessionBudgetRootScope(scope) {
+  const root = scope?.root || null;
+  if (!root) return false;
+  const closed = await root.close();
+  scope.root = null;
+  return closed;
+}
+
+function releaseReplSessionHostLeaseScope(scope) {
+  const lease = scope?.lease || null;
+  if (!lease) return false;
+  const released = lease.release?.();
+  scope.lease = null;
+  return released;
+}
+
 function attachReplCompactionLedgerMetadata(error, callId, settled) {
   let target = error;
   if (!target || (typeof target !== "object" && typeof target !== "function")) {
@@ -293,6 +326,7 @@ export async function runReplMeteredModelCallWithLedger({
   provider,
   model,
   source = "model",
+  sessionBudget = null,
   call,
   attachErrorMetadata = false,
 }) {
@@ -311,6 +345,7 @@ export async function runReplMeteredModelCallWithLedger({
       provider,
       model,
       source,
+      sessionBudget,
       call,
     });
     return Object.freeze({ result, callId, usageLedgerSettled });
@@ -545,7 +580,7 @@ async function _persistAlwaysAllow(tool, args) {
 /**
  * Execute a tool call — delegates to agent-core with REPL's hookDb and cwd.
  */
-async function executeTool(name, args) {
+async function executeTool(name, args, context = {}) {
   return coreExecuteTool(name, args, {
     hookDb: _hookDb,
     cwd: process.cwd(),
@@ -556,6 +591,9 @@ async function executeTool(name, args) {
     settingsHooks: _settingsHooks,
     classifyAllShell: _classifyAllShell,
     sandbox: _sandbox,
+    sessionId: context.sessionId || null,
+    sessionBudget: context.sessionBudget || null,
+    signal: context.signal || null,
   });
 }
 
@@ -938,6 +976,11 @@ export async function agentLoop(messages, options) {
           persistTokenUsage(options.sessionId, projectRuntimeTokenUsage(event)),
         );
       }
+      recordSessionBudgetUsage(
+        options.sessionBudget,
+        event,
+        "REPL usage settlement",
+      );
     } else if (
       event.type === "model-usage-started" ||
       event.type === "model-usage-unknown" ||
@@ -966,6 +1009,15 @@ export async function agentLoop(messages, options) {
           ),
         );
       }
+      if (event.type === "model-usage-started") {
+        beginSessionBudgetUsage(
+          options.sessionBudget,
+          event,
+          "REPL provider call",
+        );
+      } else if (markSessionBudgetUsageUnknown(options.sessionBudget, event)) {
+        rejectSessionBudgetUsageUnknown(event, "REPL provider call");
+      }
     } else if (event.type === "iteration-warning") {
       writeOut(chalk.yellow(`\n  ${event.message}\n`));
     } else if (event.type === "iteration-budget-exhausted") {
@@ -2630,6 +2682,17 @@ export async function runReplStartupBoundary(options, startupDependencies) {
     }
     return refuseStartup(options, startupCandidate);
   }
+  if (
+    options.sessionBudgetRoot?.enabled === true &&
+    startupAdmission.useJsonl !== true
+  ) {
+    throw Object.assign(
+      new Error(
+        "session budget root requires durable JSONL session persistence, but JSONL storage is unavailable",
+      ),
+      { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+    );
+  }
 
   // Only a frozen, branded admission capability may cross into workspace,
   // pipe, config, plugin, hook, MCP, model, or tool initialization.
@@ -2660,6 +2723,7 @@ export async function runReplStartupBoundary(options, startupDependencies) {
     null,
   );
   const leaseScope = options._sessionHostLeaseScope || null;
+  const budgetScope = options._sessionBudgetRootScope || null;
   const leaseSessionId = startupCandidate?.sessionId || options.sessionId;
   if (
     leaseScope &&
@@ -2669,9 +2733,79 @@ export async function runReplStartupBoundary(options, startupDependencies) {
   ) {
     leaseScope.lease = acquireHostLease(leaseSessionId, { hostKind: "repl" });
   }
+  let workspaceOptions = options;
+  if (options.sessionBudgetRoot?.enabled === true) {
+    if (!leaseSessionId || !leaseScope?.lease) {
+      throw Object.assign(
+        new Error(
+          "session budget root requires an acquired REPL host lease for its durable session",
+        ),
+        { code: "CC_SESSION_BUDGET_LEASE_REQUIRED" },
+      );
+    }
+    if (!budgetScope || budgetScope.root) {
+      throw Object.assign(
+        new Error("REPL session budget root scope is invalid"),
+        { code: "CC_SESSION_BUDGET_SCOPE_INVALID" },
+      );
+    }
+    const openBudgetRoot = dependencyDataFunction(
+      startupDependencies,
+      "openProductionSessionBudgetRoot",
+      null,
+    );
+    if (typeof openBudgetRoot !== "function") {
+      throw invalidReplRecovery(
+        "REPL session budget root dependency is missing",
+        "CC_REPL_STARTUP_DEPENDENCY_INVALID",
+      );
+    }
+    const root = openBudgetRoot(
+      leaseSessionId,
+      options.sessionBudgetRoot,
+      {
+        persist: true,
+        signal: combineReplSignals(options.signal, leaseScope.lease.signal),
+        table: options.sessionBudgetRoot.table,
+      },
+    );
+    if (
+      root?.enabled !== true ||
+      !root.budget ||
+      !root.options ||
+      root.options.sessionBudget !== root.budget ||
+      typeof root.close !== "function"
+    ) {
+      try {
+        root?.close?.();
+      } catch {
+        // The invalid root is rejected regardless of cleanup outcome.
+      }
+      throw Object.assign(new Error("REPL session budget root is invalid"), {
+        code: "CC_SESSION_BUDGET_ROOT_INVALID",
+      });
+    }
+    if (root.budget.signal?.aborted === true) {
+      const admissionError = sessionBudgetAdmissionError(
+        root.budget.reason?.(),
+        "REPL startup",
+      );
+      try {
+        await root.close();
+      } catch (cleanupError) {
+        throw new AggregateError(
+          [admissionError, cleanupError],
+          "REPL budget admission and authority cleanup both failed",
+        );
+      }
+      throw admissionError;
+    }
+    budgetScope.root = root;
+    workspaceOptions = { ...options, ...root.options };
+  }
   const trustedWorkspaceRoot = readCwd();
   return enterWorkspace(trustedWorkspaceRoot, () =>
-    startWorkspace(options, startupAdmission),
+    startWorkspace(workspaceOptions, startupAdmission),
   );
 }
 
@@ -2681,26 +2815,34 @@ export function startReplJsonlSession(
   requestedId,
   meta,
   observabilityScope,
+  options = {},
 ) {
+  const requireDurable =
+    observabilityScope != null || options.requireDurable === true;
   try {
     const sessionId = startSession(requestedId, {
       ...meta,
       ...(observabilityScope != null ? { observabilityScope } : {}),
     });
     if (
-      observabilityScope != null &&
+      requireDurable &&
       (typeof sessionId !== "string" || !sessionId)
     ) {
       throw new Error("JSONL session creation returned no durable session id");
     }
     return sessionId || null;
   } catch (error) {
-    if (observabilityScope == null) return null;
+    if (!requireDurable) return null;
     const failure = new Error(
-      "scoped JSONL session could not be durably created",
+      observabilityScope != null
+        ? "scoped JSONL session could not be durably created"
+        : "budgeted JSONL session could not be durably created",
       { cause: error },
     );
-    failure.code = "CC_OBSERVABILITY_SCOPE_START_FAILED";
+    failure.code =
+      observabilityScope != null
+        ? "CC_OBSERVABILITY_SCOPE_START_FAILED"
+        : "CC_SESSION_BUDGET_SESSION_START_FAILED";
     throw failure;
   }
 }
@@ -2708,23 +2850,45 @@ export function startReplJsonlSession(
 /** Start the agentic REPL with non-overridable production bindings. */
 export async function startAgentRepl(options = {}) {
   const sessionHostLeaseScope = { lease: null };
+  const sessionBudgetRootScope = { root: null };
   const runtimeOptions = {
     ...options,
     _sessionHostLeaseScope: sessionHostLeaseScope,
+    _sessionBudgetRootScope: sessionBudgetRootScope,
   };
   try {
     const result = await runReplStartupBoundary(runtimeOptions, {
       prepareReplStartupResume,
       refuseReplStartupResume,
       acquireSessionHostLease,
+      openProductionSessionBudgetRoot,
       cwd: () => process.cwd(),
       runWithHostHooksV2Workspace,
       startAgentReplInWorkspace,
     });
-    if (result?.started === false) sessionHostLeaseScope.lease?.release?.();
+    if (result?.started === false) {
+      await closeReplSessionBudgetRootScope(sessionBudgetRootScope);
+      releaseReplSessionHostLeaseScope(sessionHostLeaseScope);
+    }
     return result;
   } catch (error) {
-    sessionHostLeaseScope.lease?.release?.();
+    const cleanupErrors = [];
+    try {
+      await closeReplSessionBudgetRootScope(sessionBudgetRootScope);
+    } catch (cleanupError) {
+      cleanupErrors.push(cleanupError);
+    }
+    try {
+      releaseReplSessionHostLeaseScope(sessionHostLeaseScope);
+    } catch (cleanupError) {
+      cleanupErrors.push(cleanupError);
+    }
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError(
+        [error, ...cleanupErrors],
+        "REPL startup and authority cleanup both failed",
+      );
+    }
     throw error;
   }
 }
@@ -2802,6 +2966,8 @@ async function startAgentReplInWorkspaceOwned(
     }
   };
   const _sessionHostLeaseScope = options._sessionHostLeaseScope || null;
+  const _sessionBudgetRootScope = options._sessionBudgetRootScope || null;
+  const _sessionBudget = options.sessionBudget || null;
   let _sessionHostLeaseAbortListener = null;
   let _sessionHostLeaseAbortSignal = null;
   const _detachSessionHostLease = () => {
@@ -2840,6 +3006,35 @@ async function startAgentReplInWorkspaceOwned(
     return previous;
   };
   _attachSessionHostLease();
+  let _sessionBudgetAbortListener = null;
+  let _sessionBudgetAbortSignal = null;
+  const _detachSessionBudget = () => {
+    if (_sessionBudgetAbortListener && _sessionBudgetAbortSignal) {
+      _sessionBudgetAbortSignal.removeEventListener(
+        "abort",
+        _sessionBudgetAbortListener,
+      );
+    }
+    _sessionBudgetAbortListener = null;
+    _sessionBudgetAbortSignal = null;
+  };
+  const _attachSessionBudget = () => {
+    const signal = _sessionBudget?.signal;
+    if (!signal || _sessionBudgetAbortListener) return;
+    _sessionBudgetAbortListener = () =>
+      _requestReplOutputClose(
+        sessionBudgetAdmissionError(
+          _sessionBudget.reason?.() || "session-aborted",
+          "REPL session",
+        ),
+      );
+    _sessionBudgetAbortSignal = signal;
+    signal.addEventListener("abort", _sessionBudgetAbortListener, {
+      once: true,
+    });
+    if (signal.aborted) _sessionBudgetAbortListener();
+  };
+  _attachSessionBudget();
   const _replOutputFlow = outputScope.flow;
   outputScope.setFailureHandler(_requestReplOutputClose);
   const _disposeReplPipeSafety = installPipeSafety(undefined, () =>
@@ -2895,7 +3090,8 @@ async function startAgentReplInWorkspaceOwned(
         provider: callProvider || provider,
         model: callModel || model,
         source,
-        call,
+        sessionBudget: _sessionBudget,
+        call: () => call({ signal: options.signal || null }),
         attachErrorMetadata: includeLedgerMetadata,
       });
       return includeLedgerMetadata ? metered : metered.result;
@@ -2926,7 +3122,12 @@ async function startAgentReplInWorkspaceOwned(
         sessionId: durableSessionId,
         tool,
         args,
-        execute: executeTool,
+        execute: (name, toolArgs) =>
+          executeTool(name, toolArgs, {
+            sessionId: durableSessionId,
+            sessionBudget: _sessionBudget,
+            signal: options.signal || null,
+          }),
         now: options.now || Date.now,
         terminalLatch: _runtimeLedgerTerminalLatch,
       });
@@ -3089,13 +3290,13 @@ async function startAgentReplInWorkspaceOwned(
           callModel: model,
           source: "semantic-compaction",
           includeLedgerMetadata: true,
-          call: () =>
+          call: ({ signal }) =>
             chatWithTools([{ role: "user", content: prompt }], {
               provider,
               model,
               baseUrl,
               apiKey,
-              signal: _sessionHostLeaseScope?.lease?.signal,
+              signal,
               enabledToolNames: [],
               extraToolDefinitions: [],
               hostManagedToolPolicy: null,
@@ -3535,6 +3736,7 @@ async function startAgentReplInWorkspaceOwned(
         options.sessionId || null,
         meta,
         options.observabilityScope,
+        { requireDurable: Boolean(_sessionBudget) },
       );
       if (
         sessionId &&
@@ -4410,7 +4612,11 @@ async function startAgentReplInWorkspaceOwned(
           callProvider: request?.provider,
           callModel: request?.model,
           source: "model",
-          call: () => invokeToolFreeAdvisor(request),
+          call: ({ signal }) =>
+            invokeToolFreeAdvisor({
+              ...request,
+              signal: combineReplSignals(request?.signal, signal),
+            }),
         }),
       onEvent: (event) => {
         if (!useJsonl || !sessionId) return;
@@ -6953,6 +7159,14 @@ async function startAgentReplInWorkspaceOwned(
       if (sessionArg.startsWith("resume ")) {
         const resumeId = sessionArg.slice(7).trim();
         try {
+          if (_sessionBudget && resumeId !== sessionId) {
+            throw Object.assign(
+              new Error(
+                "a budgeted REPL is bound to its startup session; exit and restart to resume another session",
+              ),
+              { code: "CC_SESSION_BUDGET_REPL_SWITCH_UNSUPPORTED" },
+            );
+          }
           if (useJsonl) {
             const initialCandidate = _prepareJsonlResumeCandidate(resumeId);
             if (!initialCandidate.ok) throw initialCandidate.error;
@@ -9084,7 +9298,7 @@ async function startAgentReplInWorkspaceOwned(
         // of hanging forever. undefined → agent-core's 180s default (matches cc
         // chat/ask); config.llm.streamStallTimeoutMs tunes or disables (0).
         streamStallTimeoutMs: _streamStallTimeoutMs,
-        signal: _turnAbort.signal,
+        signal: combineReplSignals(_turnAbort.signal, options.signal),
         // On an auto-detected image turn, switch to the vision LLM for this
         // turn only (provider/baseUrl/apiKey unchanged, model → vision model).
         provider: _visionLlm ? _visionLlm.provider : provider,
@@ -9200,12 +9414,13 @@ async function startAgentReplInWorkspaceOwned(
               callProvider: provider,
               callModel: activeModel,
               source: "model",
-              call: () =>
+              call: ({ signal }) =>
                 chatWithTools([{ role: "user", content: p }], {
                   model: activeModel,
                   provider,
                   baseUrl,
                   apiKey,
+                  signal,
                   enabledToolNames: [],
                 }),
             });
@@ -9743,9 +9958,15 @@ async function startAgentReplInWorkspaceOwned(
     }
 
     // Shutdown runtime
+    _detachSessionBudget();
+    try {
+      await closeReplSessionBudgetRootScope(_sessionBudgetRootScope);
+    } catch (error) {
+      _replOutputFailure ||= error;
+    }
     _detachSessionHostLease();
     try {
-      _sessionHostLeaseScope?.lease?.release?.();
+      releaseReplSessionHostLeaseScope(_sessionHostLeaseScope);
     } catch (error) {
       _replOutputFailure ||= error;
     }

package/src/runtime/agent-core.js

@@ -109,8 +109,10 @@ import { buildPermissionDecision } from "../lib/permission-decision.js";
 import { resolveSandboxPolicyPath } from "../lib/agent-sandbox.js";
 import {
   beginManagedToolCheckpoint,
+  managedToolCheckpointBinding,
   settleManagedToolCheckpoint,
 } from "../lib/managed-tool-checkpoint.js";
+import { sessionBudgetAdmissionError } from "../lib/session-budget-production-root.js";
 import {
   createMcpCallLedger,
   McpEffect,
@@ -3570,6 +3572,35 @@ export async function executeTool(name, args, context = {}) {
     }
   }
 
+  let sessionBudgetTool = null;
+  if (typeof context.sessionBudget?.beginTool === "function") {
+    const toolBinding = JSON.stringify({
+      sessionId: context.sessionId || null,
+      turnId: context.turnId || null,
+      toolCallId: context.toolCallId || randomUUID(),
+      tool: name,
+    });
+    const toolBudgetId = `tool:${createHash("sha256")
+      .update(toolBinding, "utf8")
+      .digest("hex")
+      .slice(0, 48)}`;
+    sessionBudgetTool = context.sessionBudget.beginTool({
+      id: toolBudgetId,
+      kind: String(name || "tool").slice(0, 128),
+    });
+    if (!sessionBudgetTool?.ok) {
+      return {
+        error: `Session budget blocked tool execution: ${sessionBudgetTool?.reason || "session-aborted"}`,
+        code: "CC_SESSION_BUDGET_EXHAUSTED",
+        budgetReason: sessionBudgetTool?.reason || "session-aborted",
+        policy: {
+          decision: "blocked",
+          via: "session-budget",
+        },
+      };
+    }
+  }
+
   const startTime = Date.now();
   let toolResult;
   try {
@@ -3598,6 +3629,7 @@ export async function executeTool(name, args, context = {}) {
       strictUsageTelemetry: context.strictUsageTelemetry === true,
       onUsageBoundary: context.onUsageBoundary || null,
       onUsageSettlement: context.onUsageSettlement || null,
+      onProviderReceipt: context.onProviderReceipt || null,
       onToolCallBoundary: context.onToolCallBoundary || null,
       onToolCallSettlement: context.onToolCallSettlement || null,
       backgroundUsageFailureState: context.backgroundUsageFailureState || null,
@@ -3661,6 +3693,8 @@ export async function executeTool(name, args, context = {}) {
       }
     }
     throw err;
+  } finally {
+    sessionBudgetTool?.end?.();
   }
 
   const durationMs = Date.now() - startTime;
@@ -5014,6 +5048,7 @@ async function executeToolInner(
     strictUsageTelemetry = false,
     onUsageBoundary = null,
     onUsageSettlement = null,
+    onProviderReceipt = null,
     onToolCallBoundary = null,
     onToolCallSettlement = null,
     backgroundUsageFailureState = null,
@@ -6763,6 +6798,7 @@ async function executeToolInner(
           strictUsageTelemetry,
           onUsageBoundary,
           onUsageSettlement,
+          onProviderReceipt,
           onToolCallBoundary,
           onToolCallSettlement,
           backgroundUsageFailureState,
@@ -7689,6 +7725,15 @@ async function executeToolInner(
                   projectSkillUsage(event),
                 )
             : null;
+        const observeSkillReceipt =
+          strictUsageTelemetry === true &&
+          typeof onProviderReceipt === "function"
+            ? (event) =>
+                _notifyStrictProviderReceipt(
+                  onProviderReceipt,
+                  projectSkillUsage(event),
+                )
+            : null;
         const projectSkillTool = (event) => ({
           ...event,
           attribution: event?.attribution || projectSkillUsage({}).attribution,
@@ -7781,6 +7826,9 @@ async function executeToolInner(
                   strictUsageTelemetry: true,
                   onUsageBoundary: observeSkillBoundary,
                   onUsageSettlement: observeSkillSettlement,
+                  ...(observeSkillReceipt
+                    ? { onProviderReceipt: observeSkillReceipt }
+                    : {}),
                   onToolCallBoundary: observeSkillToolBoundary,
                   onToolCallSettlement: observeSkillToolSettlement,
                 }
@@ -9642,6 +9690,20 @@ async function _executeSpawnSubAgent(args, ctx) {
           }
         }
       : null;
+  const observeSubagentReceipt =
+    ctx.strictUsageTelemetry === true &&
+    typeof ctx.onProviderReceipt === "function"
+      ? (event) => {
+          try {
+            return _notifyStrictProviderReceipt(
+              ctx.onProviderReceipt,
+              projectSubagentUsage(event),
+            );
+          } catch (error) {
+            throw latchBackgroundUsageFailure(error);
+          }
+        }
+      : null;
   const projectSubagentTool = (event) => ({
     ...event,
     attribution:
@@ -9751,6 +9813,9 @@ async function _executeSpawnSubAgent(args, ctx) {
           strictUsageTelemetry: true,
           onUsageBoundary: observeSubagentBoundary,
           onUsageSettlement: observeSubagentSettlement,
+          ...(observeSubagentReceipt
+            ? { onProviderReceipt: observeSubagentReceipt }
+            : {}),
           onToolCallBoundary: observeSubagentToolBoundary,
           onToolCallSettlement: observeSubagentToolSettlement,
         }
@@ -12093,6 +12158,38 @@ function _notifyStrictUsageSettlement(observer, settlement) {
   }
 }
 
+function _notifyStrictProviderReceipt(observer, receipt) {
+  if (typeof observer !== "function") return;
+  let observation;
+  try {
+    observation = observer(receipt);
+  } catch (error) {
+    throw _runtimeUsageBoundaryFailure(
+      error,
+      "CC_USAGE_RECEIPT_PERSISTENCE_FAILED",
+      "Child provider receipt persistence failed",
+    );
+  }
+  let isThenable = false;
+  try {
+    isThenable = Boolean(observation && typeof observation.then === "function");
+  } catch (error) {
+    throw _runtimeUsageBoundaryFailure(
+      error,
+      "CC_USAGE_RECEIPT_OBSERVER_ASYNC",
+      "Child provider receipt observer must be synchronous",
+    );
+  }
+  if (isThenable) {
+    void Promise.resolve(observation).catch(() => {});
+    throw _runtimeUsageBoundaryFailure(
+      null,
+      "CC_USAGE_RECEIPT_OBSERVER_ASYNC",
+      "Child provider receipt observer must be synchronous",
+    );
+  }
+}
+
 function _notifyStrictToolObserver(observer, event, phase) {
   const upper = phase.toUpperCase();
   if (typeof observer !== "function") {
@@ -12757,6 +12854,9 @@ export async function* agentLoop(messages, options) {
       ...(typeof options.onUsageSettlement === "function"
         ? { onUsageSettlement: options.onUsageSettlement }
         : {}),
+      ...(typeof options.onProviderReceipt === "function"
+        ? { onProviderReceipt: options.onProviderReceipt }
+        : {}),
       ...(typeof options.onStreamRetry === "function"
         ? { onStreamRetry: options.onStreamRetry }
         : {}),
@@ -12773,6 +12873,7 @@ export async function* agentLoop(messages, options) {
     strictUsageTelemetry: options.strictUsageTelemetry === true,
     onUsageBoundary: options.onUsageBoundary || null,
     onUsageSettlement: options.onUsageSettlement || null,
+    onProviderReceipt: options.onProviderReceipt || null,
     onToolCallBoundary: options.onToolCallBoundary || null,
     onToolCallSettlement: options.onToolCallSettlement || null,
     parentMessages: messages, // pass parent messages for sub-agent auto-condensation
@@ -13013,6 +13114,21 @@ export async function* agentLoop(messages, options) {
   let emptyThinkingReprompted = false;
 
   while (budget.hasRemaining()) {
+    if (typeof toolContext.sessionBudget?.consumeTurn === "function") {
+      const turnBudgetId = `turn:${createHash("sha256")
+        .update(`${runId}:t${budget.consumed + 1}`, "utf8")
+        .digest("hex")
+        .slice(0, 48)}`;
+      const admission = toolContext.sessionBudget.consumeTurn({
+        id: turnBudgetId,
+      });
+      if (!admission?.ok) {
+        throw sessionBudgetAdmissionError(
+          admission?.reason,
+          `turn ${budget.consumed + 1}`,
+        );
+      }
+    }
     budget.consume();
     throwIfAborted(signal);
 
@@ -14205,6 +14321,13 @@ export async function* agentLoop(messages, options) {
             tool_use_id: call.id,
             turn_id: `${runId}:t${budget.consumed}`,
             ...(workflowBinding || {}),
+            ...(managedCheckpointHandle
+              ? {
+                  managedCheckpointBinding: managedToolCheckpointBinding(
+                    managedCheckpointHandle,
+                  ),
+                }
+              : {}),
           };
           // The event yield is a host persistence boundary. A detached child's
           // fatal usage write can settle while the consumer handles it; fence