chainlesschain 0.166.21 → 0.166.24

package/src/runtime/fallback-model.js

@@ -23,10 +23,35 @@
  * would be the silent auth-substitution this project forbids). A cross-provider
  * entry whose key is missing is SKIPPED with a clear reason, not attempted with
  * the wrong credential.
+ *
+ * Evolution-enabled loops bind factory-owned canonical transports to their
+ * ingress before startup awaits; every attempted model enters chatWithTools
+ * again and obtains a fresh durable projection. Strict call-ledger sessions
+ * and workflow-bound requests still allow only the primary attempt: retries
+ * require separate durable accounting/effect boundaries, not this wrapper.
  */
 
 import { chatWithTools } from "./agent-core.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import { throwIfAborted } from "../lib/abort-utils.js";
+import { isTerminalModelFailure } from "../lib/model-failure-policy.js";
+import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
+
+// Only this module can register a canonical transport. Function properties,
+// wrappers and proxies cannot confer this authority.
+const CANONICAL_FALLBACKS = new WeakMap();
+
+/** Bind a factory-owned canonical fallback to exactly one admitted Run. */
+export function captureCanonicalFallbackChatFn(value, evolutionIngress) {
+  const ingress = captureAgentEvolutionIngress(evolutionIngress);
+  const owned = CANONICAL_FALLBACKS.get(value);
+  if (!owned || (owned.ingress !== null && owned.ingress !== ingress)) {
+    throw new TypeError(
+      "Evolution ingress requires the canonical chatWithTools transport bound to the same Run",
+    );
+  }
+  return owned.ingress === ingress ? value : owned.bind(ingress);
+}
 
 // Claude Code caps the fallback chain at 3 backups; mirror that here so a
 // mis-configured comma list can't fan out into an unbounded retry storm.
@@ -77,7 +102,7 @@ const MODEL_NOT_FOUND_PATTERNS = [
  * @returns {boolean}
  */
 export function isRetryableModelError(err) {
-  if (!err) return false;
+  if (!err || isTerminalModelFailure(err)) return false;
   const status =
     typeof err.status === "number"
       ? err.status
@@ -107,7 +132,7 @@ export function isRetryableModelError(err) {
  * @returns {boolean}
  */
 export function isModelNotFoundError(err) {
-  if (!err) return false;
+  if (!err || isTerminalModelFailure(err)) return false;
   const status =
     typeof err.status === "number"
       ? err.status
@@ -245,6 +270,7 @@ export function resolveFallbackTarget(entry, opts = {}) {
  * @param {Function} [opts.isRetryable]              transient-error predicate (seam)
  * @param {Function} [opts.isModelNotFound]          missing-model predicate (seam)
  * @param {Function} [opts.onFallback]               notified ({from,to,error}) per hop
+ * @param {object} [opts.evolutionIngress]           optional fixed Run authority
  * @returns {Function} a (messages, options) => Promise<result> chatFn
  */
 export function makeFallbackChatFn(opts = {}) {
@@ -258,79 +284,134 @@ export function makeFallbackChatFn(opts = {}) {
 
   const env = opts.env || process.env;
   const providers = opts.providers || BUILT_IN_PROVIDERS || {};
+  const initialIngress =
+    opts.evolutionIngress == null
+      ? null
+      : captureAgentEvolutionIngress(opts.evolutionIngress);
+  const canonical = baseChatFn === chatWithTools;
+  if (initialIngress !== null && !canonical) {
+    throw new TypeError(
+      "Evolution ingress requires the canonical chatWithTools transport",
+    );
+  }
 
-  return async function chatWithFallback(messages, options = {}) {
-    try {
-      return await baseChatFn(messages, options);
-    } catch (firstErr) {
-      // A strict call-ledger boundary identifies exactly one provider/model
-      // transport. Retrying behind that boundary would either attribute the
-      // fallback's usage to the primary identity or lose the failed attempt's
-      // possible spend, so surface the primary error without another call.
-      if (options.strictUsageTelemetry === true) throw firstErr;
-      let err = firstErr;
-      let lastTried = options.model;
-      for (const candidate of models) {
-        const target = resolveFallbackTarget(candidate, { env, providers });
-        // A cross-provider hop whose key is absent (or an unknown provider) is
-        // skipped — never attempted with the wrong credential. Surface why.
-        if (target.unavailable) {
+  function createChatFn(boundIngress) {
+    const chatFn = async function chatWithFallback(messages, callOptions = {}) {
+      // Snapshot before any callback/await. Per-call overrides cannot remove a
+      // factory/loop-owned ingress, strict accounting or cancellation signal.
+      const options = { ...callOptions };
+      const requestedIngress =
+        options.evolutionIngress == null
+          ? null
+          : captureAgentEvolutionIngress(options.evolutionIngress);
+      if (
+        (requestedIngress !== null && !canonical) ||
+        (boundIngress !== null &&
+          requestedIngress !== null &&
+          requestedIngress !== boundIngress)
+      ) {
+        throw new TypeError(
+          "Evolution ingress requires the canonical chatWithTools transport bound to the same Run",
+        );
+      }
+      if (boundIngress !== null || requestedIngress !== null) {
+        options.evolutionIngress = boundIngress || requestedIngress;
+      }
+      const signal = options.signal;
+      throwIfAborted(signal);
+      try {
+        return await baseChatFn(messages, options);
+      } catch (firstErr) {
+        // A strict call-ledger boundary identifies exactly one provider/model
+        // transport. Retrying behind that boundary would either attribute the
+        // fallback's usage to the primary identity or lose the failed attempt's
+        // possible spend, so surface the primary error without another call.
+        if (
+          options.strictUsageTelemetry === true ||
+          options.workflowEffectId != null ||
+          options.providerRequestId != null
+        )
+          throw firstErr;
+        let err = firstErr;
+        let lastTried = options.model;
+        let lastProvider = options.provider;
+        for (const candidate of models) {
+          // Admission/ledger/cancellation failures are terminal even when a
+          // nested cause says "timeout", or an injected predicate says retry.
+          if (isTerminalModelFailure(err)) throw err;
+          throwIfAborted(signal);
+          if (!isRetryable(err) && !isModelNotFound(err)) throw err;
+          const target = resolveFallbackTarget(candidate, { env, providers });
+          // A cross-provider hop whose key is absent (or an unknown provider) is
+          // skipped — never attempted with the wrong credential. Surface why.
+          if (target.unavailable) {
+            if (typeof onFallback === "function") {
+              try {
+                onFallback({
+                  from: lastTried,
+                  to: candidate,
+                  skipped: true,
+                  reason: target.reason,
+                  error: err?.message || String(err),
+                });
+              } catch {
+                /* best-effort */
+              }
+            }
+            continue;
+          }
+          // Skip a no-op hop (same provider + same model just attempted).
+          const sameModel = target.model === lastTried;
+          const sameProvider =
+            (target.crossProvider ? target.provider : options.provider) ===
+            lastProvider;
+          if (!target.model || (sameModel && sameProvider)) continue;
           if (typeof onFallback === "function") {
             try {
               onFallback({
                 from: lastTried,
-                to: candidate,
-                skipped: true,
-                reason: target.reason,
+                to: target.crossProvider
+                  ? `${target.provider}:${target.model}`
+                  : target.model,
+                crossProvider: target.crossProvider,
                 error: err?.message || String(err),
               });
             } catch {
-              /* best-effort */
+              // Notification is best-effort — never mask the retry.
             }
           }
-          continue;
-        }
-        // Skip a no-op hop (same provider + same model just attempted).
-        const sameModel = target.model === lastTried;
-        const sameProvider =
-          !target.crossProvider || target.provider === options.provider;
-        if (!target.model || (sameModel && sameProvider)) continue;
-        // Only advance the chain for transient failures or a missing primary;
-        // a real bad-request / auth error is surfaced immediately.
-        if (!isRetryable(err) && !isModelNotFound(err)) throw err;
-        if (typeof onFallback === "function") {
+          lastTried = target.model;
+          lastProvider = target.crossProvider
+            ? target.provider
+            : options.provider;
+          // Build the per-hop options: same-provider swaps only the model; a
+          // cross-provider hop also swaps provider/baseUrl/apiKey.
+          const hopOptions = target.crossProvider
+            ? {
+                ...options,
+                model: target.model,
+                provider: target.provider,
+                baseUrl: target.baseUrl,
+                apiKey: target.apiKey,
+              }
+            : { ...options, model: target.model };
           try {
-            onFallback({
-              from: lastTried,
-              to: target.crossProvider
-                ? `${target.provider}:${target.model}`
-                : target.model,
-              crossProvider: target.crossProvider,
-              error: err?.message || String(err),
-            });
-          } catch {
-            // Notification is best-effort — never mask the retry.
+            throwIfAborted(signal);
+            return await baseChatFn(messages, hopOptions);
+          } catch (nextErr) {
+            err = nextErr;
           }
         }
-        lastTried = target.model;
-        // Build the per-hop options: same-provider swaps only the model; a
-        // cross-provider hop also swaps provider/baseUrl/apiKey.
-        const hopOptions = target.crossProvider
-          ? {
-              ...options,
-              model: target.model,
-              provider: target.provider,
-              baseUrl: target.baseUrl,
-              apiKey: target.apiKey,
-            }
-          : { ...options, model: target.model };
-        try {
-          return await baseChatFn(messages, hopOptions);
-        } catch (nextErr) {
-          err = nextErr;
-        }
+        throw err;
       }
-      throw err;
+    };
+    if (canonical) {
+      CANONICAL_FALLBACKS.set(chatFn, {
+        ingress: boundIngress,
+        bind: createChatFn,
+      });
     }
-  };
+    return chatFn;
+  }
+  return createChatFn(initialIngress);
 }

package/src/runtime/headless-runner.js

@@ -123,6 +123,7 @@ import { withQuietStdout } from "./quiet-stdout.js";
 import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
 import { captureAgentSkillOutcomeIndex } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../lib/skill-vector-authority.js";
+import { captureSkillRetrievalRevocationReader } from "../lib/evolution/skill-retrieval-revocation-authority.js";
 import { CostBudget } from "../lib/cost-budget.js";
 import { estimateTokens } from "../harness/prompt-compressor.js";
 import {
@@ -669,6 +670,12 @@ async function runAgentHeadlessInWorkspace(
     options.skillVectorAuthority == null
       ? null
       : captureSkillVectorAuthority(options.skillVectorAuthority);
+  const skillRetrievalRevocationReader =
+    options.skillRetrievalRevocationReader == null
+      ? null
+      : captureSkillRetrievalRevocationReader(
+          options.skillRetrievalRevocationReader,
+        );
   if (
     evolutionIngress !== null &&
     skillOutcomeIndex !== null &&
@@ -687,6 +694,20 @@ async function runAgentHeadlessInWorkspace(
   ) {
     throw new TypeError("Agent retrieval authorities must share one tenant");
   }
+  if (
+    skillVectorAuthority !== null &&
+    skillRetrievalRevocationReader !== null &&
+    skillVectorAuthority.tenantId !== skillRetrievalRevocationReader.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
+  if (
+    retrievalTenant !== null &&
+    skillRetrievalRevocationReader !== null &&
+    retrievalTenant !== skillRetrievalRevocationReader.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
   const prompt = (options.prompt || "").trim();
   if (!prompt) {
     throw new Error(
@@ -1686,11 +1707,7 @@ async function runAgentHeadlessInWorkspace(
     }
   }
 
-  const budget = Number.isFinite(options.maxTurns)
-    ? new IterationBudget({
-        limit: Math.max(1, Math.floor(options.maxTurns)),
-      })
-    : new IterationBudget();
+  const budget = IterationBudget.forRun({ maxTurns: options.maxTurns });
 
   // Effective system prompt: built-in base, optionally replaced by
   // --system-prompt and/or extended by --append-system-prompt.
@@ -2460,6 +2477,7 @@ async function runAgentHeadlessInWorkspace(
 
   const childToolExecs = new Map();
   const loopOptions = {
+    ...(evolutionIngress === null ? {} : { evolutionIngress }),
     model,
     provider,
     recorder: _otlpRecorder,
@@ -2479,6 +2497,9 @@ async function runAgentHeadlessInWorkspace(
     skillLoader: _runtimeSkillLoader,
     ...(skillOutcomeIndex === null ? {} : { skillOutcomeIndex }),
     ...(skillVectorAuthority === null ? {} : { skillVectorAuthority }),
+    ...(skillRetrievalRevocationReader === null
+      ? {}
+      : { skillRetrievalRevocationReader }),
     additionalDirectories,
     sandbox: options.sandbox || null,
     sessionId,
@@ -2813,7 +2834,7 @@ async function runAgentHeadlessInWorkspace(
     // True isolation level for tool subprocesses: os-sandbox (bwrap) /
     // container (docker) / policy-only (no sandbox — rules are pre-execution).
     isolation_level: isolationLevel(options.sandbox),
-    max_turns: budget.limit,
+    max_turns: Number.isFinite(budget.limit) ? budget.limit : null,
     resumed_from: resumeId,
     history_messages: history.length,
     additional_directories: additionalDirectories,
@@ -2891,7 +2912,8 @@ async function runAgentHeadlessInWorkspace(
       `You are judging whether a coding session met a completion condition.\n` +
       `Condition: ${cond.text || cond.source}\n\n` +
       `Latest assistant output:\n${String(transcript.finalText || "").slice(0, 2000)}\n\n` +
-      `Reply with STRICT JSON only: {"met": true|false, "reason": "<short>"}.`;
+      `Reply with STRICT JSON only, for example: {"met": false, "reason": "<short>"}. ` +
+      `Set met to true only when the condition is satisfied; otherwise false.`;
     const r = await runMeteredDirectModelCall({
       sessionId: resolveHeadlessMeteredSessionId(persist, sessionId),
       persist: persist
@@ -2903,6 +2925,7 @@ async function runAgentHeadlessInWorkspace(
       sessionBudget: options.sessionBudget || null,
       call: () =>
         chatWithTools([{ role: "user", content: judgePrompt }], {
+          ...(evolutionIngress === null ? {} : { evolutionIngress }),
           model,
           provider,
           baseUrl,
@@ -3544,6 +3567,13 @@ async function runAgentHeadlessInWorkspace(
               lastOutput: finalText,
             });
           } else {
+            if (evolutionIngress !== null && deps.goalConditionJudge) {
+              const error = new TypeError(
+                "Evolution goal judging requires the canonical model transport",
+              );
+              error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+              throw error;
+            }
             const judge = deps.goalConditionJudge || _defaultGoalJudge;
             evaluation = await judge(cond, {
               prompt: options.prompt,
@@ -3553,6 +3583,7 @@ async function runAgentHeadlessInWorkspace(
           }
         } catch (err) {
           if (err?.runtimeLedgerPersistence === true) throw err;
+          if (err?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw err;
           evaluation = {
             met: false,
             reason: `goal check failed: ${err.message}`,
@@ -3810,15 +3841,13 @@ async function runAgentHeadlessInWorkspace(
   // remains observable through onCleanupReport but must not replace it.
   if (loopFailureOutcome) return loopFailureOutcome;
   if (cleanupFailure) throw cleanupFailure;
-  if (evolutionIngress !== null) {
-    await evolutionIngress.complete();
-  }
 
   // A downstream consumer closed stdout/stderr. The abort above unwound the
   // model loop through the same `finally` as every other termination, so MCP,
   // background tasks, approval bridges, and hooks are settled. Do not attempt
   // more writes to the closed pipe or persist a partial assistant answer.
   if (pipeState.closed) {
+    if (evolutionIngress !== null) await evolutionIngress.complete();
     return { exitCode: 0, result: finalText, isError: false };
   }
 
@@ -3878,6 +3907,16 @@ async function runAgentHeadlessInWorkspace(
   // terminal because reporting the extra paid call as successful is unsafe.
   if (options.goalAssess && boundGoalId && !isError) {
     try {
+      if (
+        evolutionIngress !== null &&
+        (deps.assessChat || deps.assessGoalProgress)
+      ) {
+        const error = new TypeError(
+          "Evolution goal assessment requires the canonical model transport and assessor",
+        );
+        error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+        throw error;
+      }
       const { getGoal } = await import("../lib/goal-store.js");
       const goal = (deps.getGoal || getGoal)(boundGoalId);
       if (goal) {
@@ -3898,6 +3937,7 @@ async function runAgentHeadlessInWorkspace(
               sessionBudget: options.sessionBudget || null,
               call: () =>
                 chatWithTools([{ role: "user", content: assessPrompt }], {
+                  ...(evolutionIngress === null ? {} : { evolutionIngress }),
                   model,
                   provider,
                   baseUrl,
@@ -3940,10 +3980,14 @@ async function runAgentHeadlessInWorkspace(
           writeErr(`${RUNTIME_LEDGER_PERSISTENCE_FAILURE_MESSAGE}\n`);
         }
       }
+      if (error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw error;
       // Non-ledger assessment failures remain best-effort.
     }
   }
 
+  // The Run includes the final auxiliary assessment, not just the main loop.
+  if (evolutionIngress !== null && !isError) await evolutionIngress.complete();
+
   // End-of-run policy-denial summary so a non-interactive run surfaces what was
   // blocked (mirrors the REPL's `/permissions denials`). Text → stderr lines;
   // stream → a `denials_summary` event before the final result.

package/src/runtime/headless-stream.js

@@ -82,6 +82,7 @@ import {
 } from "../lib/evolution/agent-evolution-ingress.js";
 import { captureAgentSkillOutcomeIndex } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../lib/skill-vector-authority.js";
+import { captureSkillRetrievalRevocationReader } from "../lib/evolution/skill-retrieval-revocation-authority.js";
 import {
   resolveAgentMcp,
   resolvePermissionPromptTool,
@@ -1552,6 +1553,12 @@ async function runAgentHeadlessStreamInWorkspace(
     options.skillVectorAuthority == null
       ? null
       : captureSkillVectorAuthority(options.skillVectorAuthority);
+  const skillRetrievalRevocationReader =
+    options.skillRetrievalRevocationReader == null
+      ? null
+      : captureSkillRetrievalRevocationReader(
+          options.skillRetrievalRevocationReader,
+        );
   if (
     evolutionIngress !== null &&
     skillOutcomeIndex !== null &&
@@ -1570,6 +1577,20 @@ async function runAgentHeadlessStreamInWorkspace(
   ) {
     throw new TypeError("Agent retrieval authorities must share one tenant");
   }
+  if (
+    skillVectorAuthority !== null &&
+    skillRetrievalRevocationReader !== null &&
+    skillVectorAuthority.tenantId !== skillRetrievalRevocationReader.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
+  if (
+    retrievalTenant !== null &&
+    skillRetrievalRevocationReader !== null &&
+    retrievalTenant !== skillRetrievalRevocationReader.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
   const model = options.model || "qwen2.5:7b";
   const provider = options.provider || "ollama";
   const baseUrl = options.baseUrl || "http://localhost:11434";
@@ -3224,6 +3245,7 @@ async function runAgentHeadlessStreamInWorkspace(
   }
 
   const loopOptionsBase = {
+    ...(evolutionIngress === null ? {} : { evolutionIngress }),
     model,
     provider,
     // Extended thinking (Anthropic; opt-in via --think/--ultrathink).
@@ -3236,6 +3258,9 @@ async function runAgentHeadlessStreamInWorkspace(
     additionalDirectories,
     ...(skillOutcomeIndex === null ? {} : { skillOutcomeIndex }),
     ...(skillVectorAuthority === null ? {} : { skillVectorAuthority }),
+    ...(skillRetrievalRevocationReader === null
+      ? {}
+      : { skillRetrievalRevocationReader }),
     sessionId,
     sessionBudget: options.sessionBudget || null,
     hostResourceBudget,
@@ -3784,6 +3809,7 @@ async function runAgentHeadlessStreamInWorkspace(
       let compactionProviderStarted = false;
       try {
         const providerCompactionOptions = {
+          ...(evolutionIngress === null ? {} : { evolutionIngress }),
           provider,
           model,
           baseUrl,
@@ -3898,6 +3924,10 @@ async function runAgentHeadlessStreamInWorkspace(
       } catch (error) {
         if (isAbortError(error) || options.signal?.aborted) throw error;
         if (error?.runtimeLedgerPersistence === true) throw error;
+        if (error?.code === AGENT_EVOLUTION_INGRESS_FAILED_CODE) {
+          evolutionIngressFailed = true;
+          sawError = true;
+        }
         if (compactionProviderStarted) {
           const event = {
             type: "model-usage-unknown",
@@ -3915,6 +3945,17 @@ async function runAgentHeadlessStreamInWorkspace(
             );
           }
         }
+        if (error?.code === AGENT_EVOLUTION_INGRESS_FAILED_CODE) {
+          emit({
+            type: "result",
+            subtype: "error_evolution_ingress",
+            is_error: true,
+            code: error.code,
+            error: error.message,
+            session_id: sessionId,
+          });
+          break;
+        }
         emit({
           type: "compaction-degraded",
           reason: `compaction_failed:${String(error?.message || error).slice(0, 240)}`,
@@ -4284,12 +4325,15 @@ async function runAgentHeadlessStreamInWorkspace(
       });
     }
 
-    // Per-turn iteration budget so one turn can't starve the rest.
-    const budget = Number.isFinite(options.maxTurns)
-      ? new IterationBudget({
-          limit: Math.max(1, Math.floor(options.maxTurns)),
-        })
-      : new IterationBudget();
+    // Interactive hosts support interruption and steering. Do not silently
+    // stop long tasks at the unattended default of 50 model calls. Explicit
+    // --max-turns / CC_ITERATION_BUDGET and cost/session caps still apply.
+    const budget = IterationBudget.forRun({
+      maxTurns: options.maxTurns,
+      continuous:
+        options.interactiveApprovals === true ||
+        options.interactiveQuestions === true,
+    });
 
     // Custom slash-command macro expansion per user event (Claude-Code parity:
     // a /name from .claude/commands runs in panel / stream mode too, not just
@@ -4580,6 +4624,9 @@ async function runAgentHeadlessStreamInWorkspace(
           onUsageSettlement: persistUsageEvent,
           onToolCallBoundary: persistChildToolBoundary,
           onToolCallSettlement: persistChildToolSettlement,
+          // Keep the session heartbeat and protocol pumps live while a
+          // foreground command such as a networked git push is still running.
+          nonBlockingShell: true,
           // Resume-degenerate role merge for the first live model call only.
           mergeRoles: mergeRolesThisTurn,
         },

package/src/runtime/runtime-factory.js

@@ -5,6 +5,7 @@ import {
   captureAgentSkillOutcomeIndex,
 } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../lib/skill-vector-authority.js";
+import { captureSkillRetrievalRevocationReader } from "../lib/evolution/skill-retrieval-revocation-authority.js";
 import {
   resolveAgentPolicy,
   resolveServerPolicy,
@@ -17,6 +18,7 @@ export function createAgentRuntimeFactory({
   evolutionComposition = null,
   skillOutcomeIndex = null,
   skillVectorAuthority = null,
+  skillRetrievalRevocationReader = null,
 } = {}) {
   const composition =
     evolutionComposition === null
@@ -35,6 +37,10 @@ export function createAgentRuntimeFactory({
     skillVectorAuthority === null
       ? null
       : captureSkillVectorAuthority(skillVectorAuthority);
+  const revocationReader =
+    skillRetrievalRevocationReader === null
+      ? null
+      : captureSkillRetrievalRevocationReader(skillRetrievalRevocationReader);
   if (
     composition !== null &&
     outcomeIndex !== null &&
@@ -58,13 +64,38 @@ export function createAgentRuntimeFactory({
   ) {
     throw new TypeError("Agent retrieval authorities must share one tenant");
   }
+  if (
+    vectorAuthority !== null &&
+    revocationReader !== null &&
+    vectorAuthority.tenantId !== revocationReader.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
   if (vectorAuthority !== null && Object.hasOwn(deps, "skillVectorAuthority")) {
     throw new TypeError(
       "Skill vector authority must come from the production root only",
     );
   }
+  if (
+    retrievalTenant !== null &&
+    revocationReader !== null &&
+    retrievalTenant !== revocationReader.tenantId
+  ) {
+    throw new TypeError("Agent retrieval authorities must share one tenant");
+  }
+  if (
+    revocationReader !== null &&
+    Object.hasOwn(deps, "skillRetrievalRevocationReader")
+  ) {
+    throw new TypeError(
+      "Skill retrieval revocation reader must come from the production root only",
+    );
+  }
   const runtimeDeps =
-    composition === null && outcomeIndex === null && vectorAuthority === null
+    composition === null &&
+    outcomeIndex === null &&
+    vectorAuthority === null &&
+    revocationReader === null
       ? deps
       : Object.freeze({
           ...deps,
@@ -75,9 +106,14 @@ export function createAgentRuntimeFactory({
           ...(vectorAuthority === null
             ? {}
             : { skillVectorAuthority: vectorAuthority }),
+          ...(revocationReader === null
+            ? {}
+            : { skillRetrievalRevocationReader: revocationReader }),
         });
   const serverDeps =
-    outcomeIndex === null && vectorAuthority === null
+    outcomeIndex === null &&
+    vectorAuthority === null &&
+    revocationReader === null
       ? deps
       : Object.freeze({
           ...deps,
@@ -85,6 +121,9 @@ export function createAgentRuntimeFactory({
           ...(vectorAuthority === null
             ? {}
             : { skillVectorAuthority: vectorAuthority }),
+          ...(revocationReader === null
+            ? {}
+            : { skillRetrievalRevocationReader: revocationReader }),
         });
   return {
     createAgentRuntime(overrides = {}) {