chainlesschain 0.166.22 → 0.166.25

package/src/harness/remote-session-registry.js

@@ -268,6 +268,8 @@ export class RemoteSessionRegistry {
     // explicitly require this authority and trigger its lazy construction.
     this._membershipAuthority = options.membershipAuthority ?? null;
     this._membershipCoordinator = options.membershipCoordinator ?? null;
+    this._refreshCoordinatorOnEnumeration =
+      options.refreshCoordinatorOnEnumeration === true;
     this.sessions = new Map();
     this.tokens = new Map();
     this._transportBindings = new Map();
@@ -1175,11 +1177,21 @@ export class RemoteSessionRegistry {
   }
 
   findHosted(agentSessionId, hostClientId) {
-    if (this._membershipCoordinator) {
+    const hasDurableSession = [...this.sessions.values()].some((session) =>
+      Boolean(session.hostPrincipalId),
+    );
+    if (
+      this._membershipCoordinator &&
+      (this._refreshCoordinatorOnEnumeration ||
+        this._coordinatorHydrated ||
+        hasDurableSession)
+    ) {
       // Enumeration cannot rely on the one-time startup hydration: another
       // server may have created, closed, or re-enabled a durable session since
-      // this process started. Refresh the coordinator index before matching
-      // local transport attachments.
+      // this process started. Explicit coordinator deployments and processes
+      // already serving durable sessions refresh before matching local
+      // transport attachments. A lazy default coordinator must stay unopened
+      // for purely in-memory sessions.
       this._hydrateCoordinatorSessions(this._resolveMembershipCoordinator());
     }
     const matches = [];

package/src/index.js

@@ -26,16 +26,22 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const commandModules = [];
 
 for (const entry of manifest.commands) {
+  let deploymentStarted = false;
   try {
     const modulePath = join(__dirname, entry.module.replace("./", ""));
     const moduleUrl = pathToFileURL(modulePath).href;
     const mod = await import(moduleUrl);
+    deploymentStarted = true;
     const deploymentDependencies =
       await loadEvolutionDeploymentCommandDependencies(entry.name);
     commandModules.push({ entry, mod, deploymentDependencies });
   } catch (err) {
     // Store error for later reporting
-    commandModules.push({ entry, error: err });
+    commandModules.push({
+      entry,
+      error: err,
+      deploymentError: deploymentStarted,
+    });
   }
 }
 
@@ -82,9 +88,16 @@ export function createProgram(options = {}) {
   });
 
   // Register all preloaded commands
-  for (const { entry, mod, error, deploymentDependencies } of commandModules) {
+  for (const {
+    entry,
+    mod,
+    error,
+    deploymentError,
+    deploymentDependencies,
+  } of commandModules) {
     if (shouldFilter && !allowedCommands.has(entry.name)) continue;
     if (error) {
+      if (deploymentError) throw error;
       if (process.env.DEBUG) {
         console.warn(
           chalk.yellow(
@@ -109,6 +122,11 @@ export function createProgram(options = {}) {
           undefined,
       );
     } catch (err) {
+      if (
+        options.commandDependencies?.[entry.name] != null ||
+        deploymentDependencies != null
+      )
+        throw err;
       if (process.env.DEBUG) {
         console.warn(
           chalk.yellow(

package/src/lazy-dispatch.js

@@ -706,6 +706,7 @@ export async function dispatchManifestEntry(
   } = {},
 ) {
   let program;
+  let allowCompatibilityFallback = true;
   try {
     program = await createBaseProgram();
     const mod = await loadCommandModule(entry);
@@ -715,9 +716,14 @@ export async function dispatchManifestEntry(
         `Register function '${entry.register}' not found in ${entry.module}`,
       );
     }
+    // Governed deployment loading may reconcile durable state. Do not hide a
+    // failed trust check or retry that assembly through the eager program.
+    allowCompatibilityFallback = false;
     const dependencies = await loadCommandDependencies(entry.name);
+    allowCompatibilityFallback = dependencies == null;
     registerFn(program, dependencies ?? undefined);
   } catch (error) {
+    if (!allowCompatibilityFallback) throw error;
     if (env.DEBUG || env.CC_DEBUG) {
       stderr.write(
         `Lazy command registration failed; loading compatibility program: ${error.message}\n`,

package/src/lib/advisor-runtime.js

@@ -12,6 +12,7 @@ import { CostBudget } from "./cost-budget.js";
 import { FREE_PROVIDERS, mergePricing } from "./llm-pricing.js";
 import { redactSecrets } from "./secret-scan.js";
 import { firstBalancedJson } from "./json-schema-output.js";
+import { captureAgentEvolutionIngress } from "./evolution/agent-evolution-ingress.js";
 
 export const ADVISOR_TRIGGERS = Object.freeze({
   MANUAL: "manual",
@@ -609,7 +610,12 @@ export async function invokeToolFreeAdvisor({
   apiKey,
   maxTokens = DEFAULT_ADVISOR_MAX_TOKENS,
   signal,
+  evolutionIngress = null,
 } = {}) {
+  const ingress =
+    evolutionIngress == null
+      ? null
+      : captureAgentEvolutionIngress(evolutionIngress);
   const { chatWithTools } = await import("../runtime/agent-core.js");
   let resolvedBaseUrl = baseUrl;
   if (!resolvedBaseUrl) {
@@ -625,6 +631,7 @@ export async function invokeToolFreeAdvisor({
     resolvedBaseUrl = "http://localhost:11434";
   }
   return chatWithTools(messages, {
+    ...(ingress === null ? {} : { evolutionIngress: ingress }),
     provider,
     model,
     baseUrl: resolvedBaseUrl,
@@ -640,6 +647,9 @@ export async function invokeToolFreeAdvisor({
 }
 
 export class AdvisorRuntime {
+  #evolutionIngress;
+  #callWrapper;
+
   constructor({
     config,
     managed,
@@ -649,11 +659,28 @@ export class AdvisorRuntime {
     baseUrl = null,
     apiKey = null,
     invoke = invokeToolFreeAdvisor,
+    evolutionIngress = null,
+    callWrapper = null,
     onEvent = null,
     priceTable = null,
     now = () => Date.now(),
     id = () => randomUUID(),
   } = {}) {
+    this.#evolutionIngress =
+      evolutionIngress == null
+        ? null
+        : captureAgentEvolutionIngress(evolutionIngress);
+    if (this.#evolutionIngress !== null && invoke !== invokeToolFreeAdvisor) {
+      throw Object.assign(
+        new TypeError(
+          "Evolution Advisor requires the canonical model transport",
+        ),
+        { code: "CC_AGENT_EVOLUTION_INGRESS_FAILED" },
+      );
+    }
+    if (callWrapper !== null && typeof callWrapper !== "function")
+      throw new TypeError("Advisor callWrapper must be a function");
+    this.#callWrapper = callWrapper;
     this.config = resolveAdvisorConfig({
       config,
       managed,
@@ -837,7 +864,7 @@ export class AdvisorRuntime {
       toolCount: 0,
     });
     try {
-      const rawResult = await this.invoke({
+      const request = {
         messages: requestMessages,
         provider: this.config.provider,
         model: this.config.model,
@@ -846,7 +873,28 @@ export class AdvisorRuntime {
         maxTokens: this.config.maxTokens,
         signal,
         enabledToolNames: [],
-      });
+        ...(this.#evolutionIngress === null
+          ? {}
+          : { evolutionIngress: this.#evolutionIngress }),
+      };
+      const invoke =
+        this.#evolutionIngress === null ? this.invoke : invokeToolFreeAdvisor;
+      const invokeCall = ({ signal: hostSignal = signal } = {}) =>
+        invoke({
+          ...request,
+          signal:
+            hostSignal && signal && hostSignal !== signal
+              ? AbortSignal.any([signal, hostSignal])
+              : hostSignal || signal,
+        });
+      const rawResult =
+        this.#callWrapper === null
+          ? await invokeCall()
+          : await this.#callWrapper({
+              call: invokeCall,
+              provider: request.provider,
+              model: request.model,
+            });
       const rawText = resultText(rawResult);
       const advice = parseAdvisorAdvice(rawText);
       const usage = usageFrom(rawResult, requestMessages, rawText);
@@ -889,6 +937,7 @@ export class AdvisorRuntime {
       };
     } catch (error) {
       if (error?.runtimeLedgerPersistence === true) throw error;
+      if (error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw error;
       const failure = {
         callId,
         trigger,
@@ -1019,6 +1068,8 @@ export async function createConfiguredAdvisorRuntime({
   overrides = {},
   onEvent = null,
   invoke = invokeToolFreeAdvisor,
+  evolutionIngress = null,
+  callWrapper = null,
   now,
   id,
 } = {}) {
@@ -1037,6 +1088,8 @@ export async function createConfiguredAdvisorRuntime({
     baseUrl,
     apiKey,
     invoke,
+    evolutionIngress,
+    callWrapper,
     onEvent,
     priceTable: mergePricing(config?.llm?.pricing),
     now,

package/src/lib/app-server/cli-agent-kernel-adapter.js

@@ -208,6 +208,10 @@ export class CliAgentKernelAdapter {
           turnOptions.skillVectorAuthority ??
           this.sessionOptions.skillVectorAuthority ??
           null,
+        skillRetrievalRevocationReader:
+          turnOptions.skillRetrievalRevocationReader ??
+          this.sessionOptions.skillRetrievalRevocationReader ??
+          null,
       },
       {
         ...this.dependencies,

package/src/lib/app-server/graph-runtime.js

@@ -11,6 +11,7 @@ import {
   captureAgentSkillOutcomeIndex,
 } from "../evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../skill-vector-authority.js";
+import { captureSkillRetrievalRevocationReader } from "../evolution/skill-retrieval-revocation-authority.js";
 import {
   diffGraphTrace,
   locateBlockedRoot,
@@ -151,6 +152,7 @@ export class AppServerGraphRuntime {
     evolutionCompositionFactory = null,
     skillOutcomeIndex = null,
     skillVectorAuthority = null,
+    skillRetrievalRevocationReader = null,
     writerLeaseTtlMs = 24 * 60 * 60 * 1000,
   } = {}) {
     if (typeof executeNode !== "function") {
@@ -179,6 +181,10 @@ export class AppServerGraphRuntime {
       skillVectorAuthority === null
         ? null
         : captureSkillVectorAuthority(skillVectorAuthority);
+    this.skillRetrievalRevocationReader =
+      skillRetrievalRevocationReader === null
+        ? null
+        : captureSkillRetrievalRevocationReader(skillRetrievalRevocationReader);
     if (
       this.skillOutcomeIndex !== null &&
       this.skillVectorAuthority !== null &&
@@ -186,6 +192,22 @@ export class AppServerGraphRuntime {
     ) {
       throw new TypeError("Graph retrieval authorities must share one tenant");
     }
+    if (
+      this.skillVectorAuthority !== null &&
+      this.skillRetrievalRevocationReader !== null &&
+      this.skillVectorAuthority.tenantId !==
+        this.skillRetrievalRevocationReader.tenantId
+    ) {
+      throw new TypeError("Graph retrieval authorities must share one tenant");
+    }
+    if (
+      this.skillOutcomeIndex !== null &&
+      this.skillRetrievalRevocationReader !== null &&
+      this.skillOutcomeIndex.tenantId !==
+        this.skillRetrievalRevocationReader.tenantId
+    ) {
+      throw new TypeError("Graph retrieval authorities must share one tenant");
+    }
     this.writerLeaseTtlMs = writerLeaseTtlMs;
     this.runs = new Map();
     this.drives = new Map();
@@ -227,6 +249,15 @@ export class AppServerGraphRuntime {
               "Graph evolution composition and Skill vector authority must share one tenant",
             );
           }
+          if (
+            this.skillRetrievalRevocationReader !== null &&
+            composition.tenantId !==
+              this.skillRetrievalRevocationReader.tenantId
+          ) {
+            throw new TypeError(
+              "Graph evolution composition and Skill revocation authority must share one tenant",
+            );
+          }
           if (
             typeof composition.evolutionIngress?.start !== "function" ||
             typeof composition.evolutionIngress?.complete !== "function"
@@ -732,6 +763,7 @@ export class AppServerGraphRuntime {
         evolutionIngress: evolutionComposition?.evolutionIngress || null,
         skillOutcomeIndex: this.skillOutcomeIndex,
         skillVectorAuthority: this.skillVectorAuthority,
+        skillRetrievalRevocationReader: this.skillRetrievalRevocationReader,
       });
       if (!result || !["succeeded", "completed"].includes(result.status)) {
         const error = runtimeError(

package/src/lib/app-server/server.js

@@ -9,10 +9,12 @@ import {
 import { AppServerGraphRuntime } from "./graph-runtime.js";
 import { captureAgentSkillOutcomeIndex } from "../evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../skill-vector-authority.js";
+import { captureSkillRetrievalRevocationReader } from "../evolution/skill-retrieval-revocation-authority.js";
 import { compileGraphDefinition } from "../graph-kernel/compiler.js";
 import { createCliContextMemoryRuntime } from "../context-memory-kernel/runtime.js";
 import { isEvolutionWorkbenchCliHost } from "../evolution/evolution-workbench-cli-host.js";
 import { isGovernedKnowledgeReviewHost } from "../evolution/governed-knowledge-review-host.js";
+import { isGovernedKnowledgeRevocationHost } from "../evolution/governed-knowledge-revocation-host.js";
 import {
   contextPlanCreatedNotification,
   memoryDeletionNotification,
@@ -151,8 +153,10 @@ export class CcAppServer {
     evolutionCompositionFactory = null,
     skillOutcomeIndex = null,
     skillVectorAuthority = null,
+    skillRetrievalRevocationReader = null,
     evolutionWorkbenchHost = null,
     governedKnowledgeReviewHost = null,
+    governedKnowledgeRevocationHost = null,
     contextMemoryRuntimeFactory = createCliContextMemoryRuntime,
   } = {}) {
     if (typeof send !== "function") {
@@ -192,6 +196,15 @@ export class CcAppServer {
       );
     }
     this.governedKnowledgeReviewHost = governedKnowledgeReviewHost;
+    if (
+      governedKnowledgeRevocationHost !== null &&
+      !isGovernedKnowledgeRevocationHost(governedKnowledgeRevocationHost)
+    ) {
+      throw new TypeError(
+        "CcAppServer governedKnowledgeRevocationHost must be a branded revocation host",
+      );
+    }
+    this.governedKnowledgeRevocationHost = governedKnowledgeRevocationHost;
     this.skillOutcomeIndex =
       skillOutcomeIndex === null
         ? null
@@ -200,6 +213,10 @@ export class CcAppServer {
       skillVectorAuthority === null
         ? null
         : captureSkillVectorAuthority(skillVectorAuthority);
+    this.skillRetrievalRevocationReader =
+      skillRetrievalRevocationReader === null
+        ? null
+        : captureSkillRetrievalRevocationReader(skillRetrievalRevocationReader);
     if (
       this.skillOutcomeIndex !== null &&
       this.skillVectorAuthority !== null &&
@@ -209,9 +226,32 @@ export class CcAppServer {
         "App Server retrieval authorities must share one tenant",
       );
     }
+    if (
+      this.skillVectorAuthority !== null &&
+      this.skillRetrievalRevocationReader !== null &&
+      this.skillVectorAuthority.tenantId !==
+        this.skillRetrievalRevocationReader.tenantId
+    ) {
+      throw new TypeError(
+        "App Server retrieval authorities must share one tenant",
+      );
+    }
+    if (
+      this.skillOutcomeIndex !== null &&
+      this.skillRetrievalRevocationReader !== null &&
+      this.skillOutcomeIndex.tenantId !==
+        this.skillRetrievalRevocationReader.tenantId
+    ) {
+      throw new TypeError(
+        "App Server retrieval authorities must share one tenant",
+      );
+    }
     if (
       graphRuntime &&
-      (evolutionCompositionFactory || skillOutcomeIndex || skillVectorAuthority)
+      (evolutionCompositionFactory ||
+        skillOutcomeIndex ||
+        skillVectorAuthority ||
+        skillRetrievalRevocationReader)
     ) {
       throw new TypeError(
         "graphRuntime and host-owned Graph authorities cannot both be provided",
@@ -226,6 +266,7 @@ export class CcAppServer {
         evolutionCompositionFactory,
         skillOutcomeIndex: this.skillOutcomeIndex,
         skillVectorAuthority: this.skillVectorAuthority,
+        skillRetrievalRevocationReader: this.skillRetrievalRevocationReader,
         executeNode: (context) => this._executeGraphNode(context),
         requestHumanTask: (context) => this._requestHumanTask(context),
         onEvent: (event) => {
@@ -413,6 +454,10 @@ export class CcAppServer {
         this._governedKnowledgeConflicts(message.params),
       "evolution/knowledge/merge": () =>
         this._governedKnowledgeMerge(message.params),
+      "evolution/knowledge/revocation/prepare": () =>
+        this._governedKnowledgeRevocationPrepare(message.params),
+      "evolution/knowledge/revocation/publish": () =>
+        this._governedKnowledgeRevocationPublish(message.params),
     };
     const handler = handlers[method];
     if (!handler) {
@@ -474,6 +519,13 @@ export class CcAppServer {
             ? []
             : ["conflicts", "merge"],
       },
+      governedKnowledgeRevocation: {
+        available: this.governedKnowledgeRevocationHost !== null,
+        methods:
+          this.governedKnowledgeRevocationHost === null
+            ? []
+            : ["prepare", "publish"],
+      },
       schema: {
         id: APP_SERVER_SCHEMA.$id,
         version: APP_SERVER_PROTOCOL_VERSION,
@@ -574,6 +626,33 @@ export class CcAppServer {
     });
   }
 
+  _requireGovernedKnowledgeRevocationHost() {
+    if (this.governedKnowledgeRevocationHost === null) {
+      throw new JsonRpcError(
+        JSON_RPC_ERROR.NOT_FOUND,
+        "Governed knowledge revocation is not configured for this App Server",
+      );
+    }
+    return this.governedKnowledgeRevocationHost;
+  }
+
+  _governedKnowledgeRevocationPrepare(rawParams) {
+    const params = requireObject(rawParams);
+    return this._requireGovernedKnowledgeRevocationHost().prepare(
+      requireObject(params.record, "record"),
+    );
+  }
+
+  _governedKnowledgeRevocationPublish(rawParams) {
+    const params = requireObject(rawParams);
+    return this._requireGovernedKnowledgeRevocationHost().publish({
+      operationDigest: requiredString(
+        params.operationDigest,
+        "operationDigest",
+      ),
+    });
+  }
+
   async _contextPlan(rawParams) {
     const params = requireObject(rawParams);
     const runtime = this._contextMemoryRuntime({
@@ -773,6 +852,7 @@ export class CcAppServer {
     evolutionIngress,
     skillOutcomeIndex,
     skillVectorAuthority,
+    skillRetrievalRevocationReader,
   }) {
     const threadId = `graph-agent:${runId}:${nodeId}`;
     const turn = { id: attempt.id, threadId };
@@ -785,6 +865,7 @@ export class CcAppServer {
       delete turnOptions.evolutionIngress;
       delete turnOptions.skillOutcomeIndex;
       delete turnOptions.skillVectorAuthority;
+      delete turnOptions.skillRetrievalRevocationReader;
       if (evolutionIngress !== null && evolutionIngress !== undefined) {
         turnOptions.evolutionIngress = evolutionIngress;
       }
@@ -794,6 +875,13 @@ export class CcAppServer {
       if (skillVectorAuthority !== null && skillVectorAuthority !== undefined) {
         turnOptions.skillVectorAuthority = skillVectorAuthority;
       }
+      if (
+        skillRetrievalRevocationReader !== null &&
+        skillRetrievalRevocationReader !== undefined
+      ) {
+        turnOptions.skillRetrievalRevocationReader =
+          skillRetrievalRevocationReader;
+      }
       const result = await this.kernel.startTurn({
         threadId,
         turnId: attempt.id,
@@ -1038,12 +1126,17 @@ export class CcAppServer {
       const turnOptions = { ...options };
       delete turnOptions.skillOutcomeIndex;
       delete turnOptions.skillVectorAuthority;
+      delete turnOptions.skillRetrievalRevocationReader;
       if (this.skillOutcomeIndex !== null) {
         turnOptions.skillOutcomeIndex = this.skillOutcomeIndex;
       }
       if (this.skillVectorAuthority !== null) {
         turnOptions.skillVectorAuthority = this.skillVectorAuthority;
       }
+      if (this.skillRetrievalRevocationReader !== null) {
+        turnOptions.skillRetrievalRevocationReader =
+          this.skillRetrievalRevocationReader;
+      }
       const result = await this.kernel.startTurn({
         threadId: turn.threadId,
         turnId: turn.id,

package/src/lib/app-server/websocket-transport.js

@@ -12,6 +12,7 @@ import { CcAppServer } from "./server.js";
 import { JSON_RPC_ERROR, JsonRpcError, rpcError } from "./protocol.js";
 import { isEvolutionWorkbenchCliHost } from "../evolution/evolution-workbench-cli-host.js";
 import { isGovernedKnowledgeReviewHost } from "../evolution/governed-knowledge-review-host.js";
+import { isGovernedKnowledgeRevocationHost } from "../evolution/governed-knowledge-revocation-host.js";
 
 export const APP_SERVER_WEBSOCKET_PROTOCOL =
   "chainlesschain.app-server.experimental.v1";
@@ -268,6 +269,16 @@ export class WebSocketAppServerHost extends EventEmitter {
         "WebSocket App Server governedKnowledgeReviewHost must be a branded review host",
       );
     }
+    if (
+      options.governedKnowledgeRevocationHost != null &&
+      !isGovernedKnowledgeRevocationHost(
+        options.governedKnowledgeRevocationHost,
+      )
+    ) {
+      throw new TypeError(
+        "WebSocket App Server governedKnowledgeRevocationHost must be a branded revocation host",
+      );
+    }
     this.options = options;
     this.binding = validateWebSocketAppServerOptions(options);
     this.port = boundedInteger(options.port, 18800, 0, 65_535);
@@ -418,9 +429,13 @@ export class WebSocketAppServerHost extends EventEmitter {
             this.options.evolutionCompositionFactory ?? null,
           skillOutcomeIndex: this.options.skillOutcomeIndex ?? null,
           skillVectorAuthority: this.options.skillVectorAuthority ?? null,
+          skillRetrievalRevocationReader:
+            this.options.skillRetrievalRevocationReader ?? null,
           evolutionWorkbenchHost: this.options.evolutionWorkbenchHost ?? null,
           governedKnowledgeReviewHost:
             this.options.governedKnowledgeReviewHost ?? null,
+          governedKnowledgeRevocationHost:
+            this.options.governedKnowledgeRevocationHost ?? null,
           transport: "websocket",
           maxQueuedRequests: this.options.maxQueuedRequests,
           maxQueuedRequestBytes: this.options.maxQueuedRequestBytes,