chainlesschain 0.166.102 → 0.166.104

package/src/lib/evolution/agent-evolution-ingress.js

@@ -5,6 +5,7 @@ import evolutionRun from "@chainlesschain/session-core/evolution-run";
 import { EvolutionEvidenceArtifactAdapter } from "./evolution-evidence-artifact-adapter.js";
 import {
   EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST,
+  EVOLUTION_SKILL_DECISION_PROJECTION_RULESET_DIGEST,
   EVOLUTION_PROJECTION_RULESET_DIGEST,
 } from "./evolution-evidence-projector.js";
 import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
@@ -15,6 +16,10 @@ import {
   snapshotAgentModelRequest,
   buildAgentModelRequest,
 } from "./agent-model-projection.js";
+import {
+  snapshotSkillDecisionRequest,
+  buildSkillDecisionPayload,
+} from "./skill-decision-projection.js";
 
 const { EVOLUTION_RUN_EVENT_SCHEMA, EVENT_TYPES } = evolutionRun;
 
@@ -265,6 +270,7 @@ export function createAgentEvolutionIngress({
     options = {},
     modelRequest = null,
     cacheRecord = false,
+    skillDecisionRequest = null,
   ) =>
     guardIngress(
       serialize(async () => {
@@ -304,7 +310,7 @@ export function createAgentEvolutionIngress({
               ),
               responseEvent: clone(lastModelResponse.event),
             }
-          : (modelRequest ?? clone(evidence));
+          : (skillDecisionRequest?.payload ?? modelRequest ?? clone(evidence));
         const sourceEnvelope = await issueSourceEnvelope(
           Object.freeze({
             schema: AGENT_EVOLUTION_INGRESS_SCHEMA,
@@ -321,12 +327,17 @@ export function createAgentEvolutionIngress({
           payload,
         };
         const persisted =
-          modelRequest === null
-            ? await evidenceAdapter.projectAndPersist(projectionInput)
-            : await EvolutionEvidenceArtifactAdapter.prototype.projectAndPersistAgentModelRequest.call(
+          skillDecisionRequest !== null
+            ? await EvolutionEvidenceArtifactAdapter.prototype.projectAndPersistSkillDecisionRequest.call(
                 evidenceAdapter,
                 projectionInput,
-              );
+              )
+            : modelRequest === null
+              ? await evidenceAdapter.projectAndPersist(projectionInput)
+              : await EvolutionEvidenceArtifactAdapter.prototype.projectAndPersistAgentModelRequest.call(
+                  evidenceAdapter,
+                  projectionInput,
+                );
         if (
           persisted?.tenantId !== descriptor.tenantId ||
           persisted.evidenceId == null ||
@@ -353,6 +364,13 @@ export function createAgentEvolutionIngress({
             evidenceKind: kind,
             occurredAt,
             derivationManifestDigest: persisted.manifest.digest,
+            ...(skillDecisionRequest === null
+              ? {}
+              : {
+                  decisionId: skillDecisionRequest.decisionId,
+                  requestDigest: skillDecisionRequest.requestDigest,
+                  candidateSetDigest: skillDecisionRequest.candidateSetDigest,
+                }),
           },
         });
         if (kind === "model-input") {
@@ -370,7 +388,8 @@ export function createAgentEvolutionIngress({
             eventId,
             artifact: persisted,
           });
-        if (modelRequest === null) return appended;
+        if (modelRequest === null && skillDecisionRequest === null)
+          return appended;
         // Resolve the published manifest and every attested component afresh.
         // The prototype call requires the real adapter's private state; an
         // instance-shaped facade cannot mint model-visible input.
@@ -383,7 +402,9 @@ export function createAgentEvolutionIngress({
           resolved.verification.verified !== true ||
           resolved.verification.tenantId !== descriptor.tenantId ||
           resolved.bundle.modelProjection.rulesetDigest !==
-            EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST ||
+            (skillDecisionRequest === null
+              ? EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST
+              : EVOLUTION_SKILL_DECISION_PROJECTION_RULESET_DIGEST) ||
           resolved.bundle.modelProjection.evidenceId !== persisted.evidenceId
         ) {
           throw new Error("Agent model projection readback is unbound");
@@ -396,6 +417,26 @@ export function createAgentEvolutionIngress({
           throw new Error("Agent model projection Run frontier changed");
         }
         if (admissionFailure !== null) throw admissionFailure;
+        if (skillDecisionRequest !== null) {
+          return Object.freeze({
+            payload: buildSkillDecisionPayload(
+              skillDecisionRequest.payload,
+              resolved.bundle.modelProjection,
+            ),
+            receipt: Object.freeze({
+              tenantId: descriptor.tenantId,
+              runId: descriptor.runId,
+              eventId,
+              evidenceId: persisted.evidenceId,
+              requestDigest: skillDecisionRequest.requestDigest,
+              candidateSetDigest: skillDecisionRequest.candidateSetDigest,
+              manifestDigest: persisted.manifest.digest,
+              projectionDigest:
+                resolved.bundle.modelProjection.projectionDigest,
+              rulesetDigest: resolved.bundle.modelProjection.rulesetDigest,
+            }),
+          });
+        }
         return buildAgentModelRequest(
           modelRequest,
           resolved.bundle.modelProjection,
@@ -522,6 +563,21 @@ export function createAgentEvolutionIngress({
       return response;
     },
     start: () => guardIngress(serialize(() => appendStarted())),
+    prepareSkillDecisionRequest: (request) => {
+      if (admissionFailure !== null) return Promise.reject(admissionFailure);
+      let snapshot;
+      try {
+        snapshot = snapshotSkillDecisionRequest(request);
+        if (snapshot.binding.tenantId !== descriptor.tenantId)
+          throw new TypeError(
+            "Skill decision request belongs to another tenant",
+          );
+      } catch (error) {
+        admissionFailure = ingressFailure(error);
+        return Promise.reject(admissionFailure);
+      }
+      return ingest("skill-decision-input", null, {}, null, false, snapshot);
+    },
     prepareModelRequest: (request) => {
       if (admissionFailure !== null) return Promise.reject(admissionFailure);
       let snapshot;

package/src/lib/evolution/evolution-evidence-artifact-adapter.js

@@ -340,6 +340,7 @@ export class EvolutionEvidenceArtifactAdapter {
   #ttlMs;
   #project;
   #projectAgentModel;
+  #projectSkillDecision;
   #verify;
   #ports;
   #resolveManifestRef;
@@ -385,6 +386,11 @@ export class EvolutionEvidenceArtifactAdapter {
       "projectAgentModelRequest",
       "projector",
     );
+    this.#projectSkillDecision = captureMethod(
+      projector,
+      "projectSkillDecisionRequest",
+      "projector",
+    );
     this.#verify = captureMethod(bundleVerifier, "verify", "bundleVerifier");
     this.#ports = artifactPorts;
     this.#resolveManifestRef =
@@ -411,6 +417,10 @@ export class EvolutionEvidenceArtifactAdapter {
     return this.#persist(await this.#projectAgentModel(input));
   }
 
+  async projectAndPersistSkillDecisionRequest(input) {
+    return this.#persist(await this.#projectSkillDecision(input));
+  }
+
   async #persist(bundle) {
     const verification = await this.#verify(bundle);
     if (

package/src/lib/evolution/evolution-evidence-projector.js

@@ -14,6 +14,7 @@ import {
   projectAgentOpaqueTransportBlock,
   snapshotAgentModelRequest,
 } from "./agent-model-projection.js";
+import { snapshotSkillDecisionPayload } from "./skill-decision-projection.js";
 import {
   createEvidenceJsonTextBoundary,
   EVIDENCE_JSON_POLICY,
@@ -523,7 +524,24 @@ export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST = `sha256:${createH
     "utf8",
   )
   .digest("hex")}`;
+const SKILL_DECISION_RULESET = Object.freeze({
+  ...AGENT_MODEL_RULESET_V2,
+  schema: "chainlesschain.evolution-skill-decision-projection-rules/v1",
+  version: 1,
+  protocol: "skill-routing-state-and-questions/v1",
+  maxInputBytes: 256 * 1024,
+});
+export const EVOLUTION_SKILL_DECISION_PROJECTION_RULESET_DIGEST = `sha256:${createHash(
+  "sha256",
+)
+  .update(
+    `${SKILL_DECISION_RULESET.schema}\0${JSON.stringify(SKILL_DECISION_RULESET)}`,
+    "utf8",
+  )
+  .digest("hex")}`;
+
 const SUPPORTED_RULESETS = new Map([
+  [EVOLUTION_SKILL_DECISION_PROJECTION_RULESET_DIGEST, SKILL_DECISION_RULESET],
   [RULESET_DIGEST, RULESET],
   [RAW_RULESET_V3_DIGEST, RAW_RULESET_V3],
   [AGENT_MODEL_RULESET_V1_DIGEST, AGENT_MODEL_RULESET_V1],
@@ -601,7 +619,8 @@ const AGENT_VALUE_PATTERNS = Object.freeze([
 ]);
 
 function valuePatterns(ruleset) {
-  return ruleset === AGENT_MODEL_RULESET ||
+  return ruleset === SKILL_DECISION_RULESET ||
+    ruleset === AGENT_MODEL_RULESET ||
     ruleset === AGENT_MODEL_RULESET_V2 ||
     ruleset === AGENT_MODEL_RULESET_V1
     ? AGENT_VALUE_PATTERNS
@@ -3101,6 +3120,18 @@ function validateBundleIntegrity(bundle) {
     );
   }
   if (model.content !== null) {
+    if (ruleset === SKILL_DECISION_RULESET) {
+      snapshotSkillDecisionPayload(model.content);
+      if (
+        model.truncated ||
+        (model.redactionSummary.byType["content-truncation"] ?? 0) > 0
+      ) {
+        throw projectionError(
+          EVOLUTION_PROJECTION_INVALID_CODE,
+          "Skill decision projection cannot be truncated",
+        );
+      }
+    }
     if (
       ruleset === AGENT_MODEL_RULESET ||
       ruleset === AGENT_MODEL_RULESET_V2 ||
@@ -3368,6 +3399,10 @@ export class EvolutionEvidenceProjector {
     return this.#project(input, AGENT_MODEL_RULESET);
   }
 
+  projectSkillDecisionRequest(input) {
+    return this.#project(input, SKILL_DECISION_RULESET);
+  }
+
   async #project(input, ruleset) {
     assertExactRecord(input, INPUT_KEYS, "evidence projection input");
     if (
@@ -3381,9 +3416,11 @@ export class EvolutionEvidenceProjector {
       );
     }
     const payload =
-      ruleset === AGENT_MODEL_RULESET
-        ? snapshotAgentModelRequest(input.payload)
-        : cloneCanonical(input.payload);
+      ruleset === SKILL_DECISION_RULESET
+        ? snapshotSkillDecisionPayload(input.payload)
+        : ruleset === AGENT_MODEL_RULESET
+          ? snapshotAgentModelRequest(input.payload)
+          : cloneCanonical(input.payload);
     const sourceInputDigest = digest(
       payload,
       "chainlesschain.evolution-raw-plaintext/v2",
@@ -3627,9 +3664,11 @@ export class EvolutionEvidenceProjector {
     const modelProjection = buildModelProjection(
       rawRecord,
       sanitized,
-      ruleset === AGENT_MODEL_RULESET
-        ? EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST
-        : RAW_RULESET_V3_DIGEST,
+      ruleset === SKILL_DECISION_RULESET
+        ? EVOLUTION_SKILL_DECISION_PROJECTION_RULESET_DIGEST
+        : ruleset === AGENT_MODEL_RULESET
+          ? EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST
+          : RAW_RULESET_V3_DIGEST,
     );
     const trustedSanitized = source.compilable
       ? sanitizePayload(

package/src/lib/evolution/governed-hub-llm.js

@@ -1,6 +1,10 @@
 import { createRequire } from "node:module";
 import { types } from "node:util";
 import { prepareGovernedModelTurn } from "./governed-model-turn.js";
+import {
+  providerFetch,
+  requireUnscopedModelTransport,
+} from "../formal-budget-provider-scope.js";
 
 const { createAuthenticatedEvolutionModelClient } = createRequire(
   import.meta.url,
@@ -97,21 +101,25 @@ function captureHubTransport(llm, sdk) {
           const signal = options.signal
             ? AbortSignal.any([controller.signal, options.signal])
             : controller.signal;
-          const response = await fetchImpl(`${baseUrl}/api/chat`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            redirect: "error",
-            signal,
-            body: JSON.stringify({
-              model,
-              messages,
-              stream: false,
-              options: {
-                temperature: options.temperature ?? 0.2,
-                ...(options.numCtx ? { num_ctx: options.numCtx } : {}),
-              },
-            }),
-          });
+          const response = await providerFetch(
+            `${baseUrl}/api/chat`,
+            {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              redirect: "error",
+              signal,
+              body: JSON.stringify({
+                model,
+                messages,
+                stream: false,
+                options: {
+                  temperature: options.temperature ?? 0.2,
+                  ...(options.numCtx ? { num_ctx: options.numCtx } : {}),
+                },
+              }),
+            },
+            fetchImpl,
+          );
           if (!response.ok)
             throw new Error(
               `Hub Ollama request failed: HTTP ${response.status}`,
@@ -202,6 +210,7 @@ function captureHubTransport(llm, sdk) {
           );
       },
       async chat(messages, options) {
+        requireUnscopedModelTransport();
         const result = await chat(messages, options);
         const text =
           result?.content ??
@@ -233,7 +242,13 @@ function captureHubTransport(llm, sdk) {
       },
     };
   }
-  return { assertIdentity() {}, chat: llm.chat.bind(llm) };
+  return {
+    assertIdentity() {},
+    chat(messages, options) {
+      requireUnscopedModelTransport();
+      return llm.chat(messages, options);
+    },
+  };
 }
 
 // A scoped wrapper preserves the Hub's independent local/cloud consent check.

package/src/lib/evolution/governed-hub-resolver.js

@@ -1,4 +1,5 @@
 import { prepareGovernedModelTurn } from "./governed-model-turn.js";
+import { requireUnscopedModelTransport } from "../formal-budget-provider-scope.js";
 import {
   captureGovernedHubSdkPorts,
   createGovernedHubLlm,
@@ -48,6 +49,9 @@ function captureEmbeddingTransport(stage, sdk) {
         );
     },
     async embed(profile) {
+      // Neither arbitrary embedding callbacks nor the native embeddings
+      // protocol have a verified Chat billing contract in this scope.
+      requireUnscopedModelTransport();
       if (!defaultOllama) return await embed.call(stage, profile);
       // The raw SDK ollamaEmbed remains closed. This private transport is only
       // invoked below, after the scoped Run projected the profile.

package/src/lib/evolution/governed-skill-synthesis-process-grader.js

@@ -8,6 +8,7 @@ import executionBroker, {
   SANDBOX_BOUNDARIES,
 } from "../process-execution-broker/index.js";
 import { BUILT_IN_PROVIDERS } from "../llm-providers.js";
+import { requireUnscopedModelTransport } from "../formal-budget-provider-scope.js";
 
 export const GOVERNED_SKILL_SYNTHESIS_PROCESS_GRADER_SCHEMA =
   "chainlesschain.governed-skill-synthesis-process-grader/v2";
@@ -399,6 +400,9 @@ export function createGovernedSkillSynthesisProcessGrader(options = {}) {
     persistentProcessAuditRequired: true,
   });
   const port = async (messages) => {
+    // This worker owns a separate credential reference and cannot inherit an
+    // async-local authority. Refuse before provisioning or launching it.
+    requireUnscopedModelTransport();
     const current = executionSnapshot();
     if (!executionSnapshotMatches(current, snapshot)) {
       throw new Error(

package/src/lib/evolution/skill-decision-projection.js

@@ -0,0 +1,211 @@
+import { types } from "node:util";
+import { createSkillDecisionRequest } from "../decision-layer/contracts.js";
+
+const MAX_BYTES = 256 * 1024;
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+// Capture descriptors before any authority await. Never evaluate source getters
+// or allow caller mutation to change committed evidence or outbound bytes.
+function snapshot(value) {
+  let nodes = 0;
+  let bytes = 0;
+  const seen = new Set();
+  const visit = (entry, depth) => {
+    if (++nodes > 4096 || depth > 16)
+      throw new TypeError("Skill decision input exceeds its structural budget");
+    if (typeof entry === "string") {
+      bytes += Buffer.byteLength(entry, "utf8");
+      if (bytes > MAX_BYTES)
+        throw new TypeError("Skill decision input exceeds its byte budget");
+      return entry;
+    }
+    if (
+      entry === null ||
+      typeof entry === "boolean" ||
+      (typeof entry === "number" && Number.isFinite(entry))
+    )
+      return entry;
+    if (
+      !entry ||
+      typeof entry !== "object" ||
+      types.isProxy(entry) ||
+      seen.has(entry)
+    )
+      throw new TypeError(
+        "Skill decision input must be acyclic plain JSON data",
+      );
+    const array = Array.isArray(entry);
+    if (
+      !array &&
+      ![Object.prototype, null].includes(Object.getPrototypeOf(entry))
+    )
+      throw new TypeError("Skill decision input must use plain objects");
+    const keys = Reflect.ownKeys(entry).filter(
+      (key) => !(array && key === "length"),
+    );
+    if (
+      array &&
+      (keys.length !== entry.length ||
+        keys.some((key, index) => key !== String(index)))
+    )
+      throw new TypeError("Skill decision arrays must be dense data");
+    seen.add(entry);
+    const output = array ? [] : Object.create(null);
+    for (const key of keys) {
+      const property = Object.getOwnPropertyDescriptor(entry, key);
+      if (
+        typeof key !== "string" ||
+        !property?.enumerable ||
+        !("value" in property)
+      )
+        throw new TypeError(
+          "Skill decision input cannot contain accessors or symbols",
+        );
+      bytes += Buffer.byteLength(key, "utf8");
+      if (bytes > MAX_BYTES)
+        throw new TypeError("Skill decision input exceeds its byte budget");
+      Object.defineProperty(output, key, {
+        value: visit(property.value, depth + 1),
+        enumerable: true,
+      });
+    }
+    seen.delete(entry);
+    return Object.freeze(output);
+  };
+  const result = visit(value, 0);
+  if (Buffer.byteLength(JSON.stringify(result), "utf8") > MAX_BYTES)
+    throw new TypeError("Skill decision input exceeds its byte budget");
+  return result;
+}
+
+function exact(value, keys) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).sort().join("\0") !== [...keys].sort().join("\0")
+  )
+    throw new TypeError("Skill decision has an unsupported protocol shape");
+}
+
+function text(value) {
+  if (typeof value !== "string" || !value.length)
+    throw new TypeError("Skill decision requires nonempty text");
+}
+
+export function snapshotSkillDecisionPayload(value) {
+  const payload = snapshot(value);
+  exact(payload, ["state", "questions"]);
+  exact(payload.state, ["task", "candidates"]);
+  text(payload.state.task);
+  const candidates = payload.state.candidates;
+  if (
+    !Array.isArray(candidates) ||
+    candidates.length < 1 ||
+    candidates.length > 8
+  )
+    throw new TypeError("Skill decision requires bounded candidates");
+  candidates.forEach((candidate, index) => {
+    exact(candidate, [
+      "candidateId",
+      "name",
+      "description",
+      "category",
+      "tags",
+    ]);
+    if (candidate.candidateId !== `c${index + 1}`)
+      throw new TypeError("Skill decision candidate identity changed");
+    for (const key of ["name", "description", "category"]) text(candidate[key]);
+    if (!Array.isArray(candidate.tags) || candidate.tags.length > 32)
+      throw new TypeError("Skill decision tags are unbounded");
+    candidate.tags.forEach(text);
+  });
+  const ids = candidates.map(({ candidateId }) => candidateId);
+  exact(payload.questions, [
+    "needs_skill",
+    "best_skill",
+    ...ids.map((id) => `fits_${id}`),
+  ]);
+  for (const key of ["needs_skill", ...ids.map((id) => `fits_${id}`)]) {
+    exact(payload.questions[key], ["type", "instructions"]);
+    if (payload.questions[key].type !== "noul")
+      throw new TypeError("Skill decision question type changed");
+    text(payload.questions[key].instructions);
+  }
+  const choice = payload.questions.best_skill;
+  exact(choice, ["type", "instructions", "criteria"]);
+  if (choice.type !== "choice")
+    throw new TypeError("Skill decision question type changed");
+  text(choice.instructions);
+  exact(choice.criteria, [...ids, "none"]);
+  Object.values(choice.criteria).forEach(text);
+  return payload;
+}
+
+export function snapshotSkillDecisionRequest(value) {
+  const request = snapshot(value);
+  const rebuilt = createSkillDecisionRequest({
+    decisionId: request.decisionId,
+    ...request.binding,
+    query: request.payload?.state?.task,
+    candidates: request.candidates,
+  });
+  if (canonical(request) !== canonical(rebuilt))
+    throw new TypeError("Skill decision request identity or contract changed");
+  snapshotSkillDecisionPayload(request.payload);
+  return request;
+}
+
+function textPath(path) {
+  return (
+    /^state\.task$/u.test(path) ||
+    /^state\.candidates\.\d+\.(?:name|description|category|tags\.\d+)$/u.test(
+      path,
+    ) ||
+    /^questions\.best_skill\.criteria\.c[1-8]$/u.test(path)
+  );
+}
+
+export function buildSkillDecisionPayload(original, projection) {
+  if (
+    projection.visibility !== "model-visible" ||
+    projection.truncated ||
+    (projection.redactionSummary?.byType?.["content-truncation"] ?? 0) > 0
+  )
+    throw new Error("Skill decision projection is opaque or truncated");
+  const captured = snapshotSkillDecisionPayload(original);
+  const projected = snapshotSkillDecisionPayload(projection.content);
+  const compare = (before, after, path = "") => {
+    if (
+      typeof before === "string" &&
+      typeof after === "string" &&
+      textPath(path)
+    )
+      return;
+    if (before === null || typeof before !== "object") {
+      if (before !== after)
+        throw new Error("Skill decision projection changed protocol metadata");
+      return;
+    }
+    if (
+      !after ||
+      typeof after !== "object" ||
+      Array.isArray(before) !== Array.isArray(after) ||
+      Object.keys(before).sort().join("\0") !==
+        Object.keys(after).sort().join("\0")
+    )
+      throw new Error("Skill decision projection changed protocol structure");
+    for (const key of Object.keys(before))
+      compare(before[key], after[key], path ? `${path}.${key}` : key);
+  };
+  compare(captured, projected);
+  return projected;
+}

package/src/lib/evolution/skill-retrieval-revocation-authority.js

@@ -239,9 +239,19 @@ export async function openSkillRetrievalRevocationAuthority({
     ) {
       throw new Error("Retrieval revocation load is not authoritative");
     }
-    state = loaded.found
+    const loadedState = loaded.found
       ? verifySkillRetrievalRevocationState(loaded.state, tenantId)
       : null;
+    if (
+      state !== null &&
+      (loadedState === null ||
+        loadedState.revision < state.revision ||
+        (loadedState.revision === state.revision &&
+          loadedState.stateDigest !== state.stateDigest))
+    ) {
+      throw new Error("Retrieval revocation state regressed");
+    }
+    state = loadedState;
     return state;
   }
 
@@ -265,6 +275,10 @@ export async function openSkillRetrievalRevocationAuthority({
         receiptDigest: entry?.propagationRequestDigest ?? null,
       });
     },
+    async refresh() {
+      const current = await reload();
+      return current?.stateDigest ?? null;
+    },
     async invalidateRetrieval(input) {
       const request = normalizeRequest(input, tenantId);
       const contentDigest = request.dependency.digest;
@@ -351,7 +365,8 @@ export function captureSkillRetrievalRevocationReader(reader) {
   if (
     !readerBrand.has(reader) ||
     reader.schema !== SKILL_RETRIEVAL_REVOCATION_READER_SCHEMA ||
-    typeof reader.inspect !== "function"
+    typeof reader.inspect !== "function" ||
+    typeof reader.refresh !== "function"
   ) {
     throw new TypeError(
       "A branded Skill retrieval revocation reader is required",