chainlesschain 0.166.102 → 0.166.104

package/src/runtime/agent-core.js

@@ -1,3 +1,8 @@
+import {
+  providerFetch,
+  requireUnscopedToolExecution,
+} from "../lib/formal-budget-provider-scope.js";
+import { isFormalBudgetError } from "../lib/formal-budget-errors.js";
 /**
  * Agent Core — transport-independent agentic logic
  *
@@ -2613,6 +2618,7 @@ function snapshotApprovalPolicyAuthority(approvalGate, sessionId) {
  * @returns {Promise<object>} tool result
  */
 export async function executeTool(name, args, context = {}) {
+  requireUnscopedToolExecution();
   const liveExecutionContext = context;
   try {
     const executionPolicy = captureAgentExecutionPolicy(context);
@@ -7851,6 +7857,7 @@ async function executeToolInner(
         });
         return attachDescriptor(result);
       } catch (err) {
+        if (isFormalBudgetError(err)) throw err;
         return attachDescriptor({ error: `web_search failed: ${err.message}` });
       }
     }
@@ -9172,6 +9179,7 @@ async function executeToolInner(
         } catch (err) {
           if (
             isEvolutionIngressFailure(err) ||
+            isFormalBudgetError(err) ||
             err?.runtimeLedgerPersistence === true ||
             err?.workflowEffectOutcomeUnknown === true
           ) {
@@ -9281,24 +9289,122 @@ async function executeToolInner(
             ? null
             : captureSkillDecisionRuntime(skillDecisionRuntime);
         if (decisionRuntime !== null && routing.candidates.length > 0) {
-          const decision = await decisionRuntime.suggest({
-            query: args.query,
-            candidates: routing.candidates.slice(0, 5).map((candidate) => {
-              const descriptor = byDigest.get(candidate.digest);
+          const decisionInputsFor = (result, descriptors) => {
+            const descriptorsByDigest = new Map(
+              descriptors.map((skill) => [
+                skill.executionIdentity?.contentDigest,
+                skill,
+              ]),
+            );
+            return result.candidates.slice(0, 5).map((candidate) => {
+              const descriptor = descriptorsByDigest.get(candidate.digest);
               return {
-                id: candidate.id,
-                displayName: candidate.displayName,
-                description: descriptor?.description || candidate.displayName,
-                category: candidate.category,
-                digest: candidate.digest,
-                tags: Array.isArray(descriptor?.tags) ? descriptor.tags : [],
+                candidate: {
+                  id: candidate.id,
+                  displayName: candidate.displayName,
+                  description: descriptor?.description || candidate.displayName,
+                  category: candidate.category,
+                  digest: candidate.digest,
+                  tags: Array.isArray(descriptor?.tags)
+                    ? [...descriptor.tags]
+                    : [],
+                },
+                // Scope and compatibility are local routing inputs. They never
+                // leave the process, but changes invalidate the old advice.
+                identity: {
+                  namespace: candidate.namespace,
+                  version: candidate.version,
+                  paths: descriptor?.paths ?? null,
+                  os: descriptor?.os ?? null,
+                  capabilities: descriptor?.capabilities ?? null,
+                },
               };
-            }),
+            });
+          };
+          const decisionInputs = decisionInputsFor(routing, skills);
+          const snapshotFor = (result, inputs) =>
+            JSON.stringify({
+              candidates: inputs,
+              selectedDigest: result.selected?.digest ?? null,
+              conflicts: result.conflicts,
+            });
+          const decisionSnapshot = snapshotFor(routing, decisionInputs);
+          const contextRevision = `routing-${createHash("sha256")
+            .update(
+              JSON.stringify({
+                query: args.query,
+                category: args.category ?? null,
+                cwd,
+                turnId: turnId || toolCallId || "list-skills",
+                toolCallId: toolCallId ?? null,
+                decisionSnapshot,
+              }),
+            )
+            .digest("hex")}`;
+          const decision = await decisionRuntime.suggest({
+            query: args.query,
+            candidates: decisionInputs.map(({ candidate }) => candidate),
             turnId: turnId || toolCallId || "list-skills",
-            contextRevision: "skill-routing-v1",
+            contextRevision,
             signal,
           });
-          if (decision.visible) {
+          signal?.throwIfAborted();
+          // The provider result belongs to the captured candidate set. Recheck
+          // the persisted revocations and live loader before exposing advice.
+          await skillRetrievalRevocationReader?.refresh();
+          signal?.throwIfAborted();
+          const refreshedSkills =
+            typeof skillLoader.refreshResolvedSkills === "function"
+              ? await skillLoader.refreshResolvedSkills()
+              : skillLoader.getResolvedSkills();
+          signal?.throwIfAborted();
+          let currentSkills = await filterSkillsByCwd(
+            refreshedSkills.filter(skillAllowed),
+            cwd,
+          );
+          if (args.category) {
+            currentSkills = currentSkills.filter(
+              (s) => s.category.toLowerCase() === args.category.toLowerCase(),
+            );
+          }
+          // The vector index can change while the decision provider is in
+          // flight. Score the refreshed corpus again before comparing routing.
+          vector =
+            vectorAuthority === null
+              ? null
+              : await vectorAuthority.score({
+                  query: args.query,
+                  skills: currentSkills,
+                });
+          signal?.throwIfAborted();
+          const currentRouting = routeSkillDescriptors({
+            skills: currentSkills,
+            query: args.query,
+            target: { os: process.platform },
+            vectorScores: vector?.scores ?? null,
+            outcomeMetrics: outcomeAuthority.metrics,
+            revocationReader: skillRetrievalRevocationReader ?? null,
+            topK: Math.min(64, Math.max(1, currentSkills.length)),
+          });
+          const currentByDigest = new Map(
+            currentSkills.map((skill) => [
+              skill.executionIdentity?.contentDigest,
+              skill,
+            ]),
+          );
+          const currentDecisionSnapshot = snapshotFor(
+            currentRouting,
+            decisionInputsFor(currentRouting, currentSkills),
+          );
+          routing = currentRouting;
+          skills = routing.candidates
+            .map(({ digest }) => currentByDigest.get(digest))
+            .filter(Boolean);
+          signal?.throwIfAborted();
+          if (
+            decision.visible &&
+            currentDecisionSnapshot === decisionSnapshot
+          ) {
             routing = Object.freeze({
               ...routing,
               decisionSuggestion: Object.freeze({
@@ -10643,6 +10749,7 @@ function _throwBackgroundSubAgentUsageFailure(entry) {
   const error = entry?.outcome?.fatalError;
   if (
     isEvolutionIngressFailure(error) ||
+    isFormalBudgetError(error) ||
     error?.runtimeLedgerPersistence === true ||
     error?.workflowEffectOutcomeUnknown === true
   ) {
@@ -11621,6 +11728,7 @@ async function _executeSpawnSubAgent(args, ctx) {
             result: subCtx.result,
             error: err.message,
             ...(isEvolutionIngressFailure(err) ||
+            isFormalBudgetError(err) ||
             err?.runtimeLedgerPersistence === true ||
             err?.workflowEffectOutcomeUnknown === true
               ? { fatalError: err }
@@ -11757,6 +11865,7 @@ async function _executeSpawnSubAgent(args, ctx) {
 
     if (
       isEvolutionIngressFailure(err) ||
+      isFormalBudgetError(err) ||
       err?.runtimeLedgerPersistence === true ||
       err?.workflowEffectOutcomeUnknown === true
     ) {
@@ -12000,7 +12109,7 @@ export async function chatWithTools(rawMessages, options) {
         },
       );
     }
-    const response = await fetch(apiUrl, {
+    const response = await providerFetch(apiUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       signal,
@@ -12156,7 +12265,7 @@ export async function chatWithTools(rawMessages, options) {
       );
     }
 
-    const response = await fetch(`${url}/messages`, {
+    const response = await providerFetch(`${url}/messages`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -12312,7 +12421,7 @@ export async function chatWithTools(rawMessages, options) {
       );
     }
 
-    const response = await fetch(`${url}/responses`, {
+    const response = await providerFetch(`${url}/responses`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -12390,7 +12499,7 @@ export async function chatWithTools(rawMessages, options) {
     );
   }
 
-  const response = await fetch(`${url}/chat/completions`, {
+  const response = await providerFetch(`${url}/chat/completions`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -12627,6 +12736,7 @@ export function _streamErrorDisposition(
   partialText,
   visible = false,
 ) {
+  if (isFormalBudgetError(err)) return "rethrow";
   if (err?.isOutputBackpressureFailure === true) return "rethrow";
   if (isAbortError(err)) return "rethrow";
   if (signal && signal.aborted) return "rethrow";
@@ -12871,7 +12981,7 @@ async function _chatOllamaStreaming(
   stallMs,
   stallTimeoutMs,
 ) {
-  const response = await fetch(apiUrl, {
+  const response = await providerFetch(apiUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     signal,
@@ -12933,7 +13043,7 @@ async function _chatAnthropicStreaming(
   stallMs,
   stallTimeoutMs,
 ) {
-  const response = await fetch(apiUrl, {
+  const response = await providerFetch(apiUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json", ...extraHeaders },
     signal,
@@ -13000,7 +13110,7 @@ async function _chatOpenAIStreaming(
   stallTimeoutMs,
   providerRequestId = null,
 ) {
-  const response = await fetch(apiUrl, {
+  const response = await providerFetch(apiUrl, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -13083,7 +13193,7 @@ async function _chatOpenAIResponsesStreaming(
   stallTimeoutMs,
   providerRequestId = null,
 ) {
-  const response = await fetch(apiUrl, {
+  const response = await providerFetch(apiUrl, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -15479,6 +15589,7 @@ export async function* agentLoop(messages, options) {
         }
       } catch (_e) {
         if (isAbortError(_e) || signal?.aborted) throw _e;
+        if (isFormalBudgetError(_e)) throw _e;
         if (_e?.runtimeLedgerPersistence === true) throw _e;
         if (_e?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw _e;
         if (
@@ -15911,6 +16022,7 @@ export async function* agentLoop(messages, options) {
           ];
         }
       } catch (_e) {
+        if (isFormalBudgetError(_e)) throw _e;
         // prepareCall failures are non-critical — proceed with original messages
       }
     }
@@ -16511,6 +16623,7 @@ export async function* agentLoop(messages, options) {
                 : {}),
             },
             error: err.message,
+            fatalError: isFormalBudgetError(err) ? err : null,
           }),
         );
         return { call, toolArgs, workflowBinding, promise };
@@ -16518,7 +16631,12 @@ export async function* agentLoop(messages, options) {
       for (const { call, toolArgs, workflowBinding, promise } of inflight) {
         throwIfAborted(signal);
         _throwBackgroundUsageFailureState(backgroundUsageFailureState);
-        const { result: toolResult, error: toolError } = await promise;
+        const {
+          result: toolResult,
+          error: toolError,
+          fatalError,
+        } = await promise;
+        if (fatalError) throw fatalError;
         throwIfAborted(signal);
         const taskAdvanced = taskProgressTracker.record(
           call.function.name,
@@ -16961,6 +17079,7 @@ export async function* agentLoop(messages, options) {
           } catch (err) {
             if (
               isEvolutionIngressFailure(err) ||
+              isFormalBudgetError(err) ||
               err?.runtimeLedgerPersistence === true
             )
               throw err;

package/src/runtime/headless-runner.js

@@ -57,6 +57,7 @@ import {
   appendAuthorityEvent as jsonlAppendAuthorityEvent,
   readEvents as jsonlReadEvents,
   readVerifiedEvents as jsonlReadVerifiedEvents,
+  readVerifiedProjection as jsonlReadVerifiedProjection,
   findLatestEvent as jsonlFindLatestEvent,
   rebuildMessages as jsonlRebuildMessages,
   sessionExists as jsonlSessionExists,
@@ -137,7 +138,9 @@ import executionBroker from "../lib/process-execution-broker/index.js";
 import { extractPluginUsageAttribution } from "../lib/plugin-usage-attribution.js";
 import { formatManagedCheckpointEvent } from "../lib/managed-checkpoint-render.js";
 import {
+  normalizeSessionBudgetRootConfig,
   openProductionSessionBudgetRoot,
+  readProductionSessionBudget,
   sessionBudgetAdmissionError,
 } from "../lib/session-budget-production-root.js";
 import {
@@ -288,6 +291,74 @@ export function resolveHeadlessSkillDecisionOptions(options = {}) {
   });
 }
 
+function createDecisionUsageRecoveryProjection() {
+  const started = new Map();
+  const seenCallIds = new Set();
+  let blocked = false;
+  return {
+    accept(event) {
+      if (blocked) return;
+      const data = event?.data;
+      const callId = data?.callId;
+      const isDecision =
+        typeof data?.operationId === "string" &&
+        data.operationId.startsWith("decision:");
+      if (event?.type === "model_usage_started" && isDecision) {
+        if (typeof callId !== "string" || !callId || seenCallIds.has(callId)) {
+          blocked = true;
+          return;
+        }
+        let boundary;
+        try {
+          boundary = projectRuntimeUsageBoundary(data, "started");
+        } catch {
+          blocked = true;
+          return;
+        }
+        seenCallIds.add(callId);
+        started.set(callId, boundary);
+      } else if (
+        event?.type === "model_usage_unknown" &&
+        (isDecision || started.has(callId))
+      ) {
+        blocked = true;
+      } else if (event?.type === "token_usage" && started.has(callId)) {
+        let settlement;
+        try {
+          settlement = projectRuntimeTokenUsage(data);
+        } catch {
+          blocked = true;
+          return;
+        }
+        const boundary = started.get(callId);
+        if (
+          settlement.callId !== boundary.callId ||
+          settlement.operationId !== boundary.operationId ||
+          settlement.provider !== boundary.provider ||
+          settlement.model !== boundary.model ||
+          settlement.source !== boundary.source
+        ) {
+          blocked = true;
+          return;
+        }
+        started.delete(callId);
+      }
+    },
+    finish() {
+      return blocked || started.size > 0;
+    },
+  };
+}
+
+function hasUnreconciledDecisionUsage(events) {
+  if (!Array.isArray(events)) return true;
+  const projection = createDecisionUsageRecoveryProjection();
+  for (const event of events) {
+    projection.accept(event);
+  }
+  return projection.finish();
+}
+
 /**
  * Resolve a --permission-mode string into the session-policy tier + a
  * non-interactive confirmer + whether to clamp tools to the read-only set.
@@ -500,6 +571,7 @@ export function applyForkSession(opts = {}, store = {}) {
  */
 const HEADLESS_SESSION_RESOLUTION = Symbol("headlessSessionResolution");
 const HEADLESS_SESSION_HOST_LEASE = Symbol("headlessSessionHostLease");
+const HEADLESS_CANONICAL_ADMISSION = Symbol("headlessCanonicalAdmission");
 const HEADLESS_HOOK_EVENT_CLEANUP = Symbol("headlessHookEventCleanup");
 const HOST_EVENT_BACKLOG_CODE = "CC_HOST_EVENT_BACKLOG_EXHAUSTED";
 const HOST_EVENT_BACKLOG_ERROR =
@@ -528,6 +600,7 @@ async function withHeadlessSessionHostLease(options, deps, task) {
   let lease = null;
   let budgetRoot = null;
   let scopedOptions = options;
+  let preflightAdmission;
   try {
     // Session authority/lease/budget setup can lazily initialize AppConfig and
     // DatabaseManager. Those legacy diagnostics use console.info (stdout), and
@@ -589,13 +662,101 @@ async function withHeadlessSessionHostLease(options, deps, task) {
               : lease.signal,
           }
         : options;
+      const canReadCanonical =
+        !hasInjectedSessionStore ||
+        typeof deps.readVerifiedEvents === "function";
+      if (
+        authoritySessionId &&
+        !canReadCanonical &&
+        (deps.sessionBudgetStore || options.sessionBudgetRoot?.enabled) &&
+        (resolution.resumeId ||
+          deps.sessionExists?.(authoritySessionId) !== false)
+      ) {
+        throw Object.assign(
+          new Error("budgeted resume requires verified session events"),
+          { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+        );
+      }
+      if (authoritySessionId && canReadCanonical) {
+        preflightAdmission = readSessionHostResumeState(authoritySessionId, {
+          sessionHasPersistedEvidence:
+            deps.sessionHasPersistedEvidence ||
+            (!hasInjectedSessionStore
+              ? jsonlSessionHasPersistedEvidence
+              : undefined),
+          sessionExists: deps.sessionExists || jsonlSessionExists,
+          readVerifiedEvents:
+            deps.readVerifiedEvents || jsonlReadVerifiedEvents,
+        });
+      }
+      if (preflightAdmission && !preflightAdmission.snapshot.verified) {
+        // The inner runner reports the canonical failure without opening or
+        // mutating a budget sidecar for an unverified transcript.
+        return;
+      }
+      const sidecar =
+        authoritySessionId &&
+        (process.platform === "linux" || deps.sessionBudgetStore)
+          ? readProductionSessionBudget(authoritySessionId, {
+              store: deps.sessionBudgetStore,
+            })
+          : null;
+      if (!preflightAdmission && !hasInjectedSessionStore && sidecar) {
+        throw Object.assign(
+          new Error("budget sidecar has no canonical JSONL session"),
+          { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+        );
+      }
+      let effectiveBudgetConfig = options.sessionBudgetRoot;
+      if (preflightAdmission) {
+        const canonicalConfig = preflightAdmission.sessionBudgetRoot;
+        const requestedConfig = options.sessionBudgetRoot?.enabled
+          ? normalizeSessionBudgetRootConfig(options.sessionBudgetRoot)
+          : null;
+        if (canonicalConfig?.enabled) {
+          if (!sidecar) {
+            throw Object.assign(
+              new Error(
+                "budgeted session is missing its durable budget sidecar",
+              ),
+              { code: "CC_SESSION_BUDGET_SIDECAR_REQUIRED" },
+            );
+          }
+          if (requestedConfig) {
+            if (
+              JSON.stringify(requestedConfig) !==
+              JSON.stringify(canonicalConfig)
+            ) {
+              throw Object.assign(
+                new Error(
+                  "session budget does not match its JSONL declaration",
+                ),
+                { code: "CC_SESSION_BUDGET_CONFIG_MISMATCH" },
+              );
+            }
+          } else {
+            effectiveBudgetConfig = canonicalConfig;
+          }
+        } else if (requestedConfig || sidecar) {
+          throw Object.assign(
+            new Error(
+              "existing session has no canonical JSONL budget declaration",
+            ),
+            { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+          );
+        }
+      }
+      scopedOptions = {
+        ...scopedOptions,
+        sessionBudgetRoot: effectiveBudgetConfig,
+      };
       budgetRoot = openProductionSessionBudgetRoot(
         authoritySessionId,
-        options.sessionBudgetRoot,
+        effectiveBudgetConfig,
         {
           persist: resolution.persist,
           signal: scopedOptions.signal || null,
-          table: options.sessionBudgetRoot?.table,
+          table: effectiveBudgetConfig?.table || options.priceTable,
           open: deps.openSessionBudget,
           store: deps.sessionBudgetStore,
           registry: deps.sessionBudgetRegistry,
@@ -609,6 +770,7 @@ async function withHeadlessSessionHostLease(options, deps, task) {
       ...deps,
       [HEADLESS_SESSION_RESOLUTION]: resolution,
       [HEADLESS_SESSION_HOST_LEASE]: lease,
+      [HEADLESS_CANONICAL_ADMISSION]: preflightAdmission,
     });
   } finally {
     // Cleanup can touch the same lazy stores. Keep late diagnostics out of a
@@ -939,18 +1101,20 @@ async function runAgentHeadlessInWorkspace(
     !hasInjectedSessionStore || typeof deps.readVerifiedEvents === "function";
   const canonicalAdmissionId = resumeId || (persist ? sessionId : null);
   const canonicalAdmission =
-    canonicalAdmissionId && canReadCanonicalResume
-      ? readSessionHostResumeState(canonicalAdmissionId, {
-          sessionHasPersistedEvidence:
-            deps.sessionHasPersistedEvidence ||
-            (!hasInjectedSessionStore
-              ? jsonlSessionHasPersistedEvidence
-              : undefined),
-          sessionExists: deps.sessionExists || jsonlSessionExists,
-          readVerifiedEvents:
-            deps.readVerifiedEvents || jsonlReadVerifiedEvents,
-        })
-      : null;
+    deps[HEADLESS_CANONICAL_ADMISSION] !== undefined
+      ? deps[HEADLESS_CANONICAL_ADMISSION]
+      : canonicalAdmissionId && canReadCanonicalResume
+        ? readSessionHostResumeState(canonicalAdmissionId, {
+            sessionHasPersistedEvidence:
+              deps.sessionHasPersistedEvidence ||
+              (!hasInjectedSessionStore
+                ? jsonlSessionHasPersistedEvidence
+                : undefined),
+            sessionExists: deps.sessionExists || jsonlSessionExists,
+            readVerifiedEvents:
+              deps.readVerifiedEvents || jsonlReadVerifiedEvents,
+          })
+        : null;
   if (canonicalAdmission && !canonicalAdmission.snapshot.verified) {
     const message =
       "CC_SESSION_HOST_SNAPSHOT_UNVERIFIED: canonical JSONL session is not " +
@@ -2012,6 +2176,9 @@ async function runAgentHeadlessInWorkspace(
           provider,
           model,
           observabilityScope: options.observabilityScope,
+          ...(options.sessionBudgetRoot?.enabled === true
+            ? { sessionBudgetRoot: options.sessionBudgetRoot }
+            : {}),
           executionLocation: captureAmbientExecutionLocation({
             provider,
             model,
@@ -2458,13 +2625,35 @@ async function runAgentHeadlessInWorkspace(
   const skillDecisionOptions = resolveHeadlessSkillDecisionOptions(options);
   let skillDecisionRuntime = null;
   if (skillDecisionOptions.mode !== "off") {
-    const previousUnknownDecisionUsage = store.findLatestEvent(
-      sessionId,
-      "model_usage_unknown",
-      (event) =>
-        typeof event?.data?.operationId === "string" &&
-        event.data.operationId.startsWith("decision:"),
-    );
+    let previousUnreconciledDecisionUsage;
+    if (
+      !hasInjectedSessionStore ||
+      typeof deps.readVerifiedEvents === "function"
+    ) {
+      try {
+        previousUnreconciledDecisionUsage = hasInjectedSessionStore
+          ? hasUnreconciledDecisionUsage(store.readVerifiedEvents(sessionId))
+          : jsonlReadVerifiedProjection(
+              sessionId,
+              createDecisionUsageRecoveryProjection,
+            );
+      } catch {
+        // Without a verified settlement, a resumed provider call could be paid twice.
+        previousUnreconciledDecisionUsage = true;
+      }
+    } else {
+      // Legacy injected stores cannot prove a prior call was settled. Their
+      // explicit no-session answer still permits a fresh test/embedding run.
+      previousUnreconciledDecisionUsage =
+        store.sessionExists(sessionId) ||
+        store.findLatestEvent(
+          sessionId,
+          "model_usage_unknown",
+          (event) =>
+            typeof event?.data?.operationId === "string" &&
+            event.data.operationId.startsWith("decision:"),
+        ) != null;
+    }
     const decisionProvider =
       deps.decisionProvider ||
       createDecisionProvider({
@@ -2487,11 +2676,12 @@ async function runAgentHeadlessInWorkspace(
         options.decisionTenantId || evolutionIngress?.tenantId || "cli-local",
       sessionId,
       provider: decisionProvider,
+      evolutionIngress,
       persist: persistDecisionEvent,
       observe: (observation) =>
         persistDecisionEvent("skill_decision_observation", observation),
       sessionBudget: options.sessionBudget || null,
-      initialUsageUnknown: previousUnknownDecisionUsage != null,
+      initialUsageUnknown: previousUnreconciledDecisionUsage,
       timeoutMs: skillDecisionOptions.timeoutMs,
     });
   }