chainlesschain 0.166.20 → 0.166.22

package/src/harness/jsonl-session-store.js

@@ -90,6 +90,9 @@ import {
   verifyExecutionLocationResultBundle,
 } from "../lib/execution-location-result.js";
 import { normalizeExecutionLocationResultStoreReceipt } from "../lib/execution-location-result-store.js";
+import skillInvocationReceipt from "@chainlesschain/session-core/skill-invocation-receipt";
+
+const { verifySkillInvocationReceipt } = skillInvocationReceipt;
 
 let securedSessionsDir = null;
 let securedSessionsDirIdentity = null;
@@ -3189,7 +3192,16 @@ export function appendToolCall(sessionId, toolName, args) {
  */
 export function appendToolCallCompact(
   sessionId,
-  { id, tool, isError, skill, plugin, pluginVersion, durationMs } = {},
+  {
+    id,
+    tool,
+    isError,
+    skill,
+    plugin,
+    pluginVersion,
+    durationMs,
+    invocationReceipt,
+  } = {},
 ) {
   const cleanId =
     id === undefined
@@ -3203,6 +3215,15 @@ export function appendToolCallCompact(
   if (id !== undefined && !cleanId) {
     throw new TypeError("compact tool call id must be a bounded string");
   }
+  const verifiedInvocationReceipt =
+    invocationReceipt === undefined || invocationReceipt === null
+      ? null
+      : verifySkillInvocationReceipt(invocationReceipt);
+  if (verifiedInvocationReceipt !== null && tool !== "run_skill") {
+    throw new TypeError(
+      "Skill invocation receipt can only be attached to run_skill",
+    );
+  }
   const duration = normalizeCompactDuration(durationMs);
   appendEvent(sessionId, "tool_call", {
     ...(cleanId ? { id: cleanId } : {}),
@@ -3212,6 +3233,9 @@ export function appendToolCallCompact(
     ...(plugin ? { plugin: String(plugin) } : {}),
     ...(pluginVersion ? { plugin_version: String(pluginVersion) } : {}),
     ...(duration !== null ? { duration_ms: duration } : {}),
+    ...(verifiedInvocationReceipt
+      ? { skill_invocation_receipt: verifiedInvocationReceipt }
+      : {}),
   });
 }
 

package/src/index.js

@@ -13,6 +13,7 @@ import {
   startDefaultEventRuntimeHost,
   stopDefaultEventRuntimeHost,
 } from "./lib/event-runtime-host.js";
+import { loadEvolutionDeploymentCommandDependencies } from "./lib/evolution/evolution-deployment-loader.js";
 
 // The manifest entry is the canonical registration point for learning.  Keep
 // these names visible here for tooling that audits the CLI's command surface:
@@ -29,7 +30,9 @@ for (const entry of manifest.commands) {
     const modulePath = join(__dirname, entry.module.replace("./", ""));
     const moduleUrl = pathToFileURL(modulePath).href;
     const mod = await import(moduleUrl);
-    commandModules.push({ entry, mod });
+    const deploymentDependencies =
+      await loadEvolutionDeploymentCommandDependencies(entry.name);
+    commandModules.push({ entry, mod, deploymentDependencies });
   } catch (err) {
     // Store error for later reporting
     commandModules.push({ entry, error: err });
@@ -79,7 +82,7 @@ export function createProgram(options = {}) {
   });
 
   // Register all preloaded commands
-  for (const { entry, mod, error } of commandModules) {
+  for (const { entry, mod, error, deploymentDependencies } of commandModules) {
     if (shouldFilter && !allowedCommands.has(entry.name)) continue;
     if (error) {
       if (process.env.DEBUG) {
@@ -99,7 +102,12 @@ export function createProgram(options = {}) {
           `Register function '${entry.register}' not found in ${entry.module}`,
         );
       }
-      registerFn(program);
+      registerFn(
+        program,
+        options.commandDependencies?.[entry.name] ??
+          deploymentDependencies ??
+          undefined,
+      );
     } catch (err) {
       if (process.env.DEBUG) {
         console.warn(

package/src/lazy-dispatch.js

@@ -682,6 +682,12 @@ async function defaultLoadFullProgram() {
   return createProgramAsync();
 }
 
+async function defaultLoadCommandDependencies(commandName) {
+  const { loadEvolutionDeploymentCommandDependencies } =
+    await import("./lib/evolution/evolution-deployment-loader.js");
+  return loadEvolutionDeploymentCommandDependencies(commandName);
+}
+
 /**
  * Load/register may fall back to the compatibility program. parseAsync is
  * intentionally outside that catch: once an action begins, any failure must
@@ -692,6 +698,7 @@ export async function dispatchManifestEntry(
   entry,
   {
     loadCommandModule = defaultLoadCommandModule,
+    loadCommandDependencies = defaultLoadCommandDependencies,
     createBaseProgram = defaultCreateBaseProgram,
     loadFullProgram = defaultLoadFullProgram,
     stderr = process.stderr,
@@ -708,7 +715,8 @@ export async function dispatchManifestEntry(
         `Register function '${entry.register}' not found in ${entry.module}`,
       );
     }
-    registerFn(program);
+    const dependencies = await loadCommandDependencies(entry.name);
+    registerFn(program, dependencies ?? undefined);
   } catch (error) {
     if (env.DEBUG || env.CC_DEBUG) {
       stderr.write(

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

@@ -200,6 +200,14 @@ export class CliAgentKernelAdapter {
           turnOptions.evolutionIngress ??
           this.sessionOptions.evolutionIngress ??
           null,
+        skillOutcomeIndex:
+          turnOptions.skillOutcomeIndex ??
+          this.sessionOptions.skillOutcomeIndex ??
+          null,
+        skillVectorAuthority:
+          turnOptions.skillVectorAuthority ??
+          this.sessionOptions.skillVectorAuthority ??
+          null,
       },
       {
         ...this.dependencies,

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

@@ -6,7 +6,11 @@ import {
 import { createGraphAuthorityBinding } from "../graph-kernel/authority.js";
 import { GraphEventStore } from "../graph-kernel/event-store.js";
 import { GraphKernel } from "../graph-kernel/runtime.js";
-import { captureAgentEvolutionRuntimeComposition } from "../evolution/agent-evolution-runtime-composition-brand.js";
+import {
+  captureAgentEvolutionRuntimeComposition,
+  captureAgentSkillOutcomeIndex,
+} from "../evolution/agent-evolution-runtime-composition-brand.js";
+import { captureSkillVectorAuthority } from "../skill-vector-authority.js";
 import {
   diffGraphTrace,
   locateBlockedRoot,
@@ -145,6 +149,8 @@ export class AppServerGraphRuntime {
     createId = randomUUID,
     onEvent = null,
     evolutionCompositionFactory = null,
+    skillOutcomeIndex = null,
+    skillVectorAuthority = null,
     writerLeaseTtlMs = 24 * 60 * 60 * 1000,
   } = {}) {
     if (typeof executeNode !== "function") {
@@ -165,6 +171,21 @@ export class AppServerGraphRuntime {
     this.createId = createId;
     this.onEvent = typeof onEvent === "function" ? onEvent : null;
     this.evolutionCompositionFactory = evolutionCompositionFactory;
+    this.skillOutcomeIndex =
+      skillOutcomeIndex === null
+        ? null
+        : captureAgentSkillOutcomeIndex(skillOutcomeIndex);
+    this.skillVectorAuthority =
+      skillVectorAuthority === null
+        ? null
+        : captureSkillVectorAuthority(skillVectorAuthority);
+    if (
+      this.skillOutcomeIndex !== null &&
+      this.skillVectorAuthority !== null &&
+      this.skillOutcomeIndex.tenantId !== this.skillVectorAuthority.tenantId
+    ) {
+      throw new TypeError("Graph retrieval authorities must share one tenant");
+    }
     this.writerLeaseTtlMs = writerLeaseTtlMs;
     this.runs = new Map();
     this.drives = new Map();
@@ -190,6 +211,22 @@ export class AppServerGraphRuntime {
               "Agent evolution composition belongs to another Graph run",
             );
           }
+          if (
+            this.skillOutcomeIndex !== null &&
+            composition.tenantId !== this.skillOutcomeIndex.tenantId
+          ) {
+            throw new TypeError(
+              "Graph evolution composition and Skill outcome index must share one tenant",
+            );
+          }
+          if (
+            this.skillVectorAuthority !== null &&
+            composition.tenantId !== this.skillVectorAuthority.tenantId
+          ) {
+            throw new TypeError(
+              "Graph evolution composition and Skill vector authority must share one tenant",
+            );
+          }
           if (
             typeof composition.evolutionIngress?.start !== "function" ||
             typeof composition.evolutionIngress?.complete !== "function"
@@ -693,6 +730,8 @@ export class AppServerGraphRuntime {
         input: nodeInput(entry.inputs, nodeId),
         signal: controller.signal,
         evolutionIngress: evolutionComposition?.evolutionIngress || null,
+        skillOutcomeIndex: this.skillOutcomeIndex,
+        skillVectorAuthority: this.skillVectorAuthority,
       });
       if (!result || !["succeeded", "completed"].includes(result.status)) {
         const error = runtimeError(

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

@@ -7,8 +7,12 @@ import {
   createRolloutStore,
 } from "./rollout-store-factory.js";
 import { AppServerGraphRuntime } from "./graph-runtime.js";
+import { captureAgentSkillOutcomeIndex } from "../evolution/agent-evolution-runtime-composition-brand.js";
+import { captureSkillVectorAuthority } from "../skill-vector-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 {
   contextPlanCreatedNotification,
   memoryDeletionNotification,
@@ -145,6 +149,10 @@ export class CcAppServer {
     transport = "stdio",
     graphRuntime = null,
     evolutionCompositionFactory = null,
+    skillOutcomeIndex = null,
+    skillVectorAuthority = null,
+    evolutionWorkbenchHost = null,
+    governedKnowledgeReviewHost = null,
     contextMemoryRuntimeFactory = createCliContextMemoryRuntime,
   } = {}) {
     if (typeof send !== "function") {
@@ -166,9 +174,47 @@ export class CcAppServer {
       throw new TypeError("contextMemoryRuntimeFactory must be a function");
     }
     this.contextMemoryRuntimeFactory = contextMemoryRuntimeFactory;
-    if (graphRuntime && evolutionCompositionFactory) {
+    if (
+      evolutionWorkbenchHost !== null &&
+      !isEvolutionWorkbenchCliHost(evolutionWorkbenchHost)
+    ) {
+      throw new TypeError(
+        "CcAppServer evolutionWorkbenchHost must be a branded Workbench host",
+      );
+    }
+    this.evolutionWorkbenchHost = evolutionWorkbenchHost;
+    if (
+      governedKnowledgeReviewHost !== null &&
+      !isGovernedKnowledgeReviewHost(governedKnowledgeReviewHost)
+    ) {
+      throw new TypeError(
+        "CcAppServer governedKnowledgeReviewHost must be a branded review host",
+      );
+    }
+    this.governedKnowledgeReviewHost = governedKnowledgeReviewHost;
+    this.skillOutcomeIndex =
+      skillOutcomeIndex === null
+        ? null
+        : captureAgentSkillOutcomeIndex(skillOutcomeIndex);
+    this.skillVectorAuthority =
+      skillVectorAuthority === null
+        ? null
+        : captureSkillVectorAuthority(skillVectorAuthority);
+    if (
+      this.skillOutcomeIndex !== null &&
+      this.skillVectorAuthority !== null &&
+      this.skillOutcomeIndex.tenantId !== this.skillVectorAuthority.tenantId
+    ) {
+      throw new TypeError(
+        "App Server retrieval authorities must share one tenant",
+      );
+    }
+    if (
+      graphRuntime &&
+      (evolutionCompositionFactory || skillOutcomeIndex || skillVectorAuthority)
+    ) {
       throw new TypeError(
-        "graphRuntime and evolutionCompositionFactory cannot both be provided",
+        "graphRuntime and host-owned Graph authorities cannot both be provided",
       );
     }
     this.graphRuntime =
@@ -178,6 +224,8 @@ export class CcAppServer {
         now,
         createId,
         evolutionCompositionFactory,
+        skillOutcomeIndex: this.skillOutcomeIndex,
+        skillVectorAuthority: this.skillVectorAuthority,
         executeNode: (context) => this._executeGraphNode(context),
         requestHumanTask: (context) => this._requestHumanTask(context),
         onEvent: (event) => {
@@ -353,6 +401,18 @@ export class CcAppServer {
       "memory/decide": () => this._memoryDecide(message.params),
       "memory/delete": () => this._memoryDelete(message.params),
       "memory/reconcile": () => this._memoryReconcile(message.params),
+      "evolution/workbench/list": () =>
+        this._evolutionWorkbenchList(message.params),
+      "evolution/workbench/compare": () =>
+        this._evolutionWorkbenchCompare(message.params),
+      "evolution/workbench/review": () =>
+        this._evolutionWorkbenchReview(message.params),
+      "evolution/workbench/rollback": () =>
+        this._evolutionWorkbenchRollback(message.params),
+      "evolution/knowledge/conflicts": () =>
+        this._governedKnowledgeConflicts(message.params),
+      "evolution/knowledge/merge": () =>
+        this._governedKnowledgeMerge(message.params),
     };
     const handler = handlers[method];
     if (!handler) {
@@ -400,6 +460,20 @@ export class CcAppServer {
       websocket: { stability: "experimental" },
       limits: this.requestQueue.snapshot(),
       graphRuntime: this.graphRuntime.runtimeClaims(),
+      evolutionWorkbench: {
+        available: this.evolutionWorkbenchHost !== null,
+        methods:
+          this.evolutionWorkbenchHost === null
+            ? []
+            : ["list", "compare", "review", "rollback"],
+      },
+      governedKnowledgeReview: {
+        available: this.governedKnowledgeReviewHost !== null,
+        methods:
+          this.governedKnowledgeReviewHost === null
+            ? []
+            : ["conflicts", "merge"],
+      },
       schema: {
         id: APP_SERVER_SCHEMA.$id,
         version: APP_SERVER_PROTOCOL_VERSION,
@@ -415,6 +489,91 @@ export class CcAppServer {
     return runtime;
   }
 
+  _requireEvolutionWorkbenchHost() {
+    if (this.evolutionWorkbenchHost === null) {
+      throw new JsonRpcError(
+        JSON_RPC_ERROR.NOT_FOUND,
+        "Evolution Workbench is not configured for this App Server",
+      );
+    }
+    return this.evolutionWorkbenchHost;
+  }
+
+  _evolutionWorkbenchList(rawParams = {}) {
+    const params = requireObject(rawParams);
+    return this._requireEvolutionWorkbenchHost().list({
+      query: typeof params.query === "string" ? params.query : "",
+      status: params.status ?? null,
+      offset: params.offset ?? 0,
+      limit: params.limit ?? 100,
+    });
+  }
+
+  _evolutionWorkbenchCompare(rawParams) {
+    const params = requireObject(rawParams);
+    return this._requireEvolutionWorkbenchHost().compare(
+      requiredString(params.leftPacketDigest, "leftPacketDigest"),
+      requiredString(params.rightPacketDigest, "rightPacketDigest"),
+    );
+  }
+
+  _evolutionWorkbenchReview(rawParams) {
+    const params = requireObject(rawParams);
+    if (!Array.isArray(params.packetDigests)) {
+      throw new JsonRpcError(
+        JSON_RPC_ERROR.INVALID_PARAMS,
+        "packetDigests must be an array",
+      );
+    }
+    return this._requireEvolutionWorkbenchHost().review({
+      packetDigests: params.packetDigests,
+      decision: requiredString(params.decision, "decision"),
+      reason: requiredString(params.reason, "reason"),
+    });
+  }
+
+  _evolutionWorkbenchRollback(rawParams) {
+    const params = requireObject(rawParams);
+    return this._requireEvolutionWorkbenchHost().rollback({
+      fromPacketDigest: requiredString(
+        params.fromPacketDigest,
+        "fromPacketDigest",
+      ),
+      toPacketDigest: requiredString(params.toPacketDigest, "toPacketDigest"),
+      reason: requiredString(params.reason, "reason"),
+    });
+  }
+
+  _requireGovernedKnowledgeReviewHost() {
+    if (this.governedKnowledgeReviewHost === null) {
+      throw new JsonRpcError(
+        JSON_RPC_ERROR.NOT_FOUND,
+        "Governed knowledge review is not configured for this App Server",
+      );
+    }
+    return this.governedKnowledgeReviewHost;
+  }
+
+  _governedKnowledgeConflicts(rawParams = {}) {
+    const params = requireObject(rawParams);
+    return this._requireGovernedKnowledgeReviewHost().list({
+      cursor: params.cursor ?? 0,
+      limit: params.limit ?? 50,
+    });
+  }
+
+  _governedKnowledgeMerge(rawParams) {
+    const params = requireObject(rawParams);
+    return this._requireGovernedKnowledgeReviewHost().merge({
+      conflictEnvelopeDigest: requiredString(
+        params.conflictEnvelopeDigest,
+        "conflictEnvelopeDigest",
+      ),
+      mergedRecord: requireObject(params.mergedRecord, "mergedRecord"),
+      reason: requiredString(params.reason, "reason"),
+    });
+  }
+
   async _contextPlan(rawParams) {
     const params = requireObject(rawParams);
     const runtime = this._contextMemoryRuntime({
@@ -612,6 +771,8 @@ export class CcAppServer {
     input,
     signal,
     evolutionIngress,
+    skillOutcomeIndex,
+    skillVectorAuthority,
   }) {
     const threadId = `graph-agent:${runId}:${nodeId}`;
     const turn = { id: attempt.id, threadId };
@@ -622,9 +783,17 @@ export class CcAppServer {
     try {
       const turnOptions = { ...(input?.options || {}) };
       delete turnOptions.evolutionIngress;
+      delete turnOptions.skillOutcomeIndex;
+      delete turnOptions.skillVectorAuthority;
       if (evolutionIngress !== null && evolutionIngress !== undefined) {
         turnOptions.evolutionIngress = evolutionIngress;
       }
+      if (skillOutcomeIndex !== null && skillOutcomeIndex !== undefined) {
+        turnOptions.skillOutcomeIndex = skillOutcomeIndex;
+      }
+      if (skillVectorAuthority !== null && skillVectorAuthority !== undefined) {
+        turnOptions.skillVectorAuthority = skillVectorAuthority;
+      }
       const result = await this.kernel.startTurn({
         threadId,
         turnId: attempt.id,
@@ -866,11 +1035,20 @@ export class CcAppServer {
   async _runTurn(active, input, options) {
     const { turn } = active;
     try {
+      const turnOptions = { ...options };
+      delete turnOptions.skillOutcomeIndex;
+      delete turnOptions.skillVectorAuthority;
+      if (this.skillOutcomeIndex !== null) {
+        turnOptions.skillOutcomeIndex = this.skillOutcomeIndex;
+      }
+      if (this.skillVectorAuthority !== null) {
+        turnOptions.skillVectorAuthority = this.skillVectorAuthority;
+      }
       const result = await this.kernel.startTurn({
         threadId: turn.threadId,
         turnId: turn.id,
         input,
-        options,
+        options: turnOptions,
         emit: (event) => this._emitKernelEvent(turn, event),
         requestApproval: (event) => this._requestApproval(turn, event),
       });

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

@@ -10,6 +10,8 @@ import { WebSocketServer } from "ws";
 import { BoundedAsyncQueue, QueueOverloadedError } from "./bounded-queue.js";
 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";
 
 export const APP_SERVER_WEBSOCKET_PROTOCOL =
   "chainlesschain.app-server.experimental.v1";
@@ -250,6 +252,22 @@ export class WebSocketConnectionTransport extends EventEmitter {
 export class WebSocketAppServerHost extends EventEmitter {
   constructor(options = {}) {
     super();
+    if (
+      options.evolutionWorkbenchHost != null &&
+      !isEvolutionWorkbenchCliHost(options.evolutionWorkbenchHost)
+    ) {
+      throw new TypeError(
+        "WebSocket App Server evolutionWorkbenchHost must be a branded Workbench host",
+      );
+    }
+    if (
+      options.governedKnowledgeReviewHost != null &&
+      !isGovernedKnowledgeReviewHost(options.governedKnowledgeReviewHost)
+    ) {
+      throw new TypeError(
+        "WebSocket App Server governedKnowledgeReviewHost must be a branded review host",
+      );
+    }
     this.options = options;
     this.binding = validateWebSocketAppServerOptions(options);
     this.port = boundedInteger(options.port, 18800, 0, 65_535);
@@ -398,6 +416,11 @@ export class WebSocketAppServerHost extends EventEmitter {
           kernel: this.kernelFactory?.(),
           evolutionCompositionFactory:
             this.options.evolutionCompositionFactory ?? null,
+          skillOutcomeIndex: this.options.skillOutcomeIndex ?? null,
+          skillVectorAuthority: this.options.skillVectorAuthority ?? null,
+          evolutionWorkbenchHost: this.options.evolutionWorkbenchHost ?? null,
+          governedKnowledgeReviewHost:
+            this.options.governedKnowledgeReviewHost ?? null,
           transport: "websocket",
           maxQueuedRequests: this.options.maxQueuedRequests,
           maxQueuedRequestBytes: this.options.maxQueuedRequestBytes,

package/src/lib/evolution/agent-evolution-runtime-composition-brand.js

@@ -2,6 +2,7 @@ export const AGENT_EVOLUTION_RUNTIME_COMPOSITION_SCHEMA =
   "chainlesschain.agent-evolution-runtime-composition/v1";
 
 const COMPOSITIONS = new WeakSet();
+const SKILL_OUTCOME_INDEXES = new WeakSet();
 
 export function sealAgentEvolutionRuntimeComposition(fields) {
   const composition = Object.freeze({
@@ -20,3 +21,19 @@ export function captureAgentEvolutionRuntimeComposition(value) {
   }
   return value;
 }
+
+export function sealAgentSkillOutcomeIndex(fields) {
+  const index = Object.freeze({
+    schema: "chainlesschain.agent-skill-outcome-index/v1",
+    ...fields,
+  });
+  SKILL_OUTCOME_INDEXES.add(index);
+  return index;
+}
+
+export function captureAgentSkillOutcomeIndex(value) {
+  if (!SKILL_OUTCOME_INDEXES.has(value)) {
+    throw new TypeError("a branded Agent Skill outcome index is required");
+  }
+  return value;
+}