chainlesschain 0.166.17 → 0.166.18

package/src/gateways/ws/ws-agent-handler.js

@@ -11,7 +11,7 @@
  * adapter.
  */
 
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { agentLoop, formatToolArgs } from "../../runtime/agent-core.js";
 import { classifyToolSideEffect } from "../../lib/side-effect-ledger.js";
 import { DiffReviewFollowUpTracker } from "../../lib/diff-review-follow-up.js";
@@ -81,6 +81,7 @@ import {
   rejectSessionBudgetUsageUnknown,
 } from "../../lib/session-budget-usage.js";
 import { HostResourceBudget } from "../../lib/host-resource-budget.js";
+import { captureAgentEvolutionRuntimeComposition } from "../../lib/evolution/agent-evolution-runtime-composition-brand.js";
 
 const CANONICAL_WS_TURN_QUEUES = new Map();
 const CANONICAL_WS_CLAIM_CAS_ATTEMPTS = 4;
@@ -176,6 +177,7 @@ export class WSAgentHandler {
     sessionHostLease = null,
     sessionBudgetRoot = null,
     hostResourceBudget = null,
+    evolutionCompositionFactory = null,
   }) {
     this.session = session;
     this.interaction = interaction;
@@ -243,6 +245,13 @@ export class WSAgentHandler {
     this._mcpRecoveryRevision = null;
     this._mcpRecoveryClient = null;
     this._agentLoop = runAgentLoop || agentLoop;
+    if (
+      evolutionCompositionFactory !== null &&
+      typeof evolutionCompositionFactory !== "function"
+    ) {
+      throw new TypeError("evolutionCompositionFactory must be a function");
+    }
+    this._evolutionCompositionFactory = evolutionCompositionFactory;
     this._compactionLlmQuery = compactionLlmQuery || null;
     this._compactionSettlementBlock = null;
     this._compactionChatFn =
@@ -297,6 +306,46 @@ export class WSAgentHandler {
       : Object.freeze(hostSystemPrefix);
   }
 
+  async _prepareEvolutionTurn(requestId) {
+    if (!this._evolutionCompositionFactory) return null;
+    const sessionId = String(this.session.id);
+    const stableRequestId =
+      typeof requestId === "string" && requestId.trim()
+        ? requestId.trim()
+        : randomUUID();
+    const runId = `ws-run-${createHash("sha256")
+      .update(`${sessionId}\0${stableRequestId}`, "utf8")
+      .digest("hex")}`;
+    try {
+      const composition = captureAgentEvolutionRuntimeComposition(
+        await this._evolutionCompositionFactory(
+          Object.freeze({
+            mode: "legacy-websocket",
+            runId,
+            sessionId,
+            requestId: stableRequestId,
+            cwd: this.session.projectRoot,
+          }),
+        ),
+      );
+      if (composition.runId !== runId) {
+        throw new TypeError(
+          "Agent evolution composition belongs to another WebSocket turn",
+        );
+      }
+      await composition.evolutionIngress.start();
+      return composition;
+    } catch (cause) {
+      if (cause?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw cause;
+      const error = new Error(
+        `WebSocket evolution ingress failed: ${cause?.message || String(cause)}`,
+        { cause },
+      );
+      error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+      throw error;
+    }
+  }
+
   attachInteraction(interaction) {
     if (!interaction || interaction === this.interaction) return false;
     const previous = this.interaction;
@@ -1277,6 +1326,7 @@ export class WSAgentHandler {
     let runRecorded = false;
     let canonicalTurn = null;
     let strictUsageTelemetry = false;
+    let evolutionComposition = null;
 
     try {
       const { session } = this;
@@ -1335,7 +1385,19 @@ export class WSAgentHandler {
           });
           return;
         }
-      } else {
+      }
+      if (this._evolutionCompositionFactory !== null) {
+        evolutionComposition = await this._prepareEvolutionTurn(requestId);
+      }
+      if (evolutionComposition !== null) {
+        await evolutionComposition.evolutionIngress.ingestUserPrompt({
+          content: userMessage,
+          sessionId: session.id,
+          requestId: requestId || null,
+          source: "legacy-websocket",
+        });
+      }
+      if (session.canonicalJsonlSession !== true) {
         session.messages.push({ role: "user", content: userMessage });
       }
       this._recordSessionState("run.started", {
@@ -1520,6 +1582,9 @@ export class WSAgentHandler {
           session.messages,
           loopOptions,
         )) {
+          if (evolutionComposition !== null) {
+            await evolutionComposition.evolutionIngress.ingestAgentEvent(event);
+          }
           switch (event.type) {
             case "slot-filling":
               this.interaction.emit("slot-filling", {
@@ -1710,6 +1775,9 @@ export class WSAgentHandler {
               break;
 
             case "response-complete":
+              if (evolutionComposition !== null) {
+                await evolutionComposition.evolutionIngress.complete();
+              }
               if (session.canonicalJsonlSession === true) {
                 const settled = this._settleCanonicalSuccess(
                   canonicalTurn,

package/src/gateways/ws/ws-server.js

@@ -322,6 +322,14 @@ export class ChainlessChainWSServer extends EventEmitter {
       LEGACY_WS_FLOW_DEFAULTS.maxCommandOutputBytes,
     );
     this._spawnProcess = options.spawn || _deps.spawn;
+    if (
+      options.evolutionCompositionFactory != null &&
+      typeof options.evolutionCompositionFactory !== "function"
+    ) {
+      throw new TypeError("evolutionCompositionFactory must be a function");
+    }
+    this.evolutionCompositionFactory =
+      options.evolutionCompositionFactory || null;
 
     /** Optional Phase-5 envelope bus for fan-out to hosted HTTP SSE. */
     this.envelopeBus = options.envelopeBus || null;

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

@@ -196,6 +196,10 @@ export class CliAgentKernelAdapter {
         interactiveApprovals: true,
         includePartialMessages: true,
         ephemeral: false,
+        evolutionIngress:
+          turnOptions.evolutionIngress ??
+          this.sessionOptions.evolutionIngress ??
+          null,
       },
       {
         ...this.dependencies,

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

@@ -6,6 +6,7 @@ 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 {
   diffGraphTrace,
   locateBlockedRoot,
@@ -143,11 +144,18 @@ export class AppServerGraphRuntime {
     now = Date.now,
     createId = randomUUID,
     onEvent = null,
+    evolutionCompositionFactory = null,
     writerLeaseTtlMs = 24 * 60 * 60 * 1000,
   } = {}) {
     if (typeof executeNode !== "function") {
       throw new TypeError("AppServerGraphRuntime requires executeNode()");
     }
+    if (
+      evolutionCompositionFactory !== null &&
+      typeof evolutionCompositionFactory !== "function"
+    ) {
+      throw new TypeError("evolutionCompositionFactory must be a function");
+    }
     this.eventStore = eventStore;
     this.rolloutStore = eventStore.rolloutStore;
     this.executeNode = executeNode;
@@ -156,12 +164,88 @@ export class AppServerGraphRuntime {
     this.now = now;
     this.createId = createId;
     this.onEvent = typeof onEvent === "function" ? onEvent : null;
+    this.evolutionCompositionFactory = evolutionCompositionFactory;
     this.writerLeaseTtlMs = writerLeaseTtlMs;
     this.runs = new Map();
     this.drives = new Map();
     this.active = new Map();
   }
 
+  async _prepareEvolution(entry) {
+    if (!this.evolutionCompositionFactory) return null;
+    if (!entry.evolutionCompositionPromise) {
+      const context = Object.freeze({
+        mode: "graph",
+        runId: entry.runId,
+        originSurface: entry.originSurface,
+        revisionDigest: entry.compiled.revisionDigest,
+        authorityMode: entry.authorityMode,
+      });
+      entry.evolutionCompositionPromise = Promise.resolve()
+        .then(() => this.evolutionCompositionFactory(context))
+        .then((value) => {
+          const composition = captureAgentEvolutionRuntimeComposition(value);
+          if (composition.runId !== entry.runId) {
+            throw new TypeError(
+              "Agent evolution composition belongs to another Graph run",
+            );
+          }
+          if (
+            typeof composition.evolutionIngress?.start !== "function" ||
+            typeof composition.evolutionIngress?.complete !== "function"
+          ) {
+            throw new TypeError(
+              "Agent evolution composition has no usable ingress",
+            );
+          }
+          return composition;
+        });
+    }
+    if (!entry.evolutionStartPromise) {
+      entry.evolutionStartPromise = entry.evolutionCompositionPromise.then(
+        async (composition) => {
+          await composition.evolutionIngress.start();
+          return composition;
+        },
+      );
+    }
+    try {
+      return await entry.evolutionStartPromise;
+    } catch (cause) {
+      entry.evolutionIngressFailed = true;
+      if (cause?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw cause;
+      const error = runtimeError(
+        "CC_AGENT_EVOLUTION_INGRESS_FAILED",
+        `Graph evolution ingress failed: ${cause?.message || String(cause)}`,
+        { cause },
+      );
+      throw error;
+    }
+  }
+
+  async _completeEvolution(entry) {
+    if (!this.evolutionCompositionFactory || entry.evolutionIngressFailed) {
+      return;
+    }
+    if (entry.evolutionCompletionPromise) {
+      return entry.evolutionCompletionPromise;
+    }
+    try {
+      entry.evolutionCompletionPromise = this._prepareEvolution(entry).then(
+        (composition) => composition.evolutionIngress.complete(),
+      );
+      await entry.evolutionCompletionPromise;
+    } catch (cause) {
+      entry.evolutionIngressFailed = true;
+      if (cause?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw cause;
+      throw runtimeError(
+        "CC_AGENT_EVOLUTION_INGRESS_FAILED",
+        `Graph evolution completion failed: ${cause?.message || String(cause)}`,
+        { cause },
+      );
+    }
+  }
+
   _requestThread(runId) {
     return `graph-request:${graphDigest(
       runId,
@@ -329,6 +413,8 @@ export class AppServerGraphRuntime {
       runId: id,
       compiled,
       inputs: { ...inputs },
+      originSurface,
+      authorityMode,
     });
     this._emit(id, "graph/run-started", { projection });
     return this.status(id);
@@ -339,9 +425,16 @@ export class AppServerGraphRuntime {
     if (projection.authorityMode === "shadow") {
       return Promise.resolve(this.status(projection.id));
     }
-    const settled = this._drive(projection.id);
-    if (options.waitForCompletion === true) return settled;
-    return Promise.resolve(projection);
+    const entry = this.runs.get(projection.id);
+    const launch = () => {
+      const settled = this._drive(projection.id);
+      if (options.waitForCompletion === true) return settled;
+      return projection;
+    };
+    if (this.evolutionCompositionFactory) {
+      return this._prepareEvolution(entry).then(launch);
+    }
+    return Promise.resolve(launch());
   }
 
   resume(runId, { waitForCompletion = false } = {}) {
@@ -375,12 +468,15 @@ export class AppServerGraphRuntime {
     if (!entry)
       throw runtimeError("CC_GRAPH_RUN_NOT_FOUND", "Graph run missing");
     const { kernel } = entry;
+    await this._prepareEvolution(entry);
     for (let steps = 0; steps < 10_000; steps += 1) {
       const status = kernel.getRun(runId);
-      if (
-        TERMINAL.has(status.status) ||
-        status.status === "reconciliation_required"
-      ) {
+      if (TERMINAL.has(status.status)) {
+        await this._completeEvolution(entry);
+        this._emit(runId, "graph/run-settled", { projection: status });
+        return status;
+      }
+      if (status.status === "reconciliation_required") {
         this._emit(runId, "graph/run-settled", { projection: status });
         return status;
       }
@@ -562,6 +658,7 @@ export class AppServerGraphRuntime {
   async _executeAttempt(entry, nodeId) {
     const { kernel } = entry;
     const runId = entry.runId;
+    const evolutionComposition = await this._prepareEvolution(entry);
     const attempt = kernel.assignNode(runId, nodeId, "app-server-agent", {
       ttlMs: this.writerLeaseTtlMs,
       leaseId: `app-server-attempt:${this.createId()}`,
@@ -595,6 +692,7 @@ export class AppServerGraphRuntime {
         attempt,
         input: nodeInput(entry.inputs, nodeId),
         signal: controller.signal,
+        evolutionIngress: evolutionComposition?.evolutionIngress || null,
       });
       if (!result || !["succeeded", "completed"].includes(result.status)) {
         const error = runtimeError(
@@ -631,6 +729,9 @@ export class AppServerGraphRuntime {
       });
       return settled;
     } catch (error) {
+      if (error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") {
+        entry.evolutionIngressFailed = true;
+      }
       if (controller.signal.aborted) return kernel.getRun(runId);
       if (effect) {
         const known = error?.outcomeKnown === true;
@@ -826,6 +927,8 @@ export class AppServerGraphRuntime {
       runId,
       compiled: compileGraphDefinition(request.definition),
       inputs: { ...request.inputs },
+      originSurface: request.originSurface,
+      authorityMode: request.authorityMode,
     };
     this.runs.set(runId, entry);
     this._recoverReceiptedAttempts(entry);
@@ -1003,7 +1106,7 @@ export class AppServerGraphRuntime {
   async cancel(runId, reason = "cancelled by App Server client") {
     const id = String(runId);
     const entry = this.runs.get(id) || this._recover(id);
-    return entry.kernel.cancelRun(id, {
+    const projection = await entry.kernel.cancelRun(id, {
       reason,
       interrupt: async (attempt) => {
         const active = this.active.get(attempt.id);
@@ -1012,6 +1115,10 @@ export class AppServerGraphRuntime {
         await active.done;
       },
     });
+    if (TERMINAL.has(projection.status)) {
+      await this._completeEvolution(entry);
+    }
+    return projection;
   }
 
   async reconcile(runId, input = {}) {

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

@@ -144,6 +144,7 @@ export class CcAppServer {
     interruptSettlementMs = 30_000,
     transport = "stdio",
     graphRuntime = null,
+    evolutionCompositionFactory = null,
     contextMemoryRuntimeFactory = createCliContextMemoryRuntime,
   } = {}) {
     if (typeof send !== "function") {
@@ -165,12 +166,18 @@ export class CcAppServer {
       throw new TypeError("contextMemoryRuntimeFactory must be a function");
     }
     this.contextMemoryRuntimeFactory = contextMemoryRuntimeFactory;
+    if (graphRuntime && evolutionCompositionFactory) {
+      throw new TypeError(
+        "graphRuntime and evolutionCompositionFactory cannot both be provided",
+      );
+    }
     this.graphRuntime =
       graphRuntime ||
       new AppServerGraphRuntime({
         rolloutStore: resolvedStore,
         now,
         createId,
+        evolutionCompositionFactory,
         executeNode: (context) => this._executeGraphNode(context),
         requestHumanTask: (context) => this._requestHumanTask(context),
         onEvent: (event) => {
@@ -598,7 +605,14 @@ export class CcAppServer {
     );
   }
 
-  async _executeGraphNode({ runId, nodeId, attempt, input, signal }) {
+  async _executeGraphNode({
+    runId,
+    nodeId,
+    attempt,
+    input,
+    signal,
+    evolutionIngress,
+  }) {
     const threadId = `graph-agent:${runId}:${nodeId}`;
     const turn = { id: attempt.id, threadId };
     const onAbort = () => {
@@ -606,11 +620,16 @@ export class CcAppServer {
     };
     signal?.addEventListener?.("abort", onAbort, { once: true });
     try {
+      const turnOptions = { ...(input?.options || {}) };
+      delete turnOptions.evolutionIngress;
+      if (evolutionIngress !== null && evolutionIngress !== undefined) {
+        turnOptions.evolutionIngress = evolutionIngress;
+      }
       const result = await this.kernel.startTurn({
         threadId,
         turnId: attempt.id,
         input: requiredString(input?.prompt, `inputs.${nodeId}.prompt`),
-        options: input?.options || {},
+        options: turnOptions,
         emit: (event) =>
           this._notify("graph/event", {
             type: "graph/agent-event",

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

@@ -396,6 +396,8 @@ export class WebSocketAppServerHost extends EventEmitter {
           send,
           store: this.store,
           kernel: this.kernelFactory?.(),
+          evolutionCompositionFactory:
+            this.options.evolutionCompositionFactory ?? null,
           transport: "websocket",
           maxQueuedRequests: this.options.maxQueuedRequests,
           maxQueuedRequestBytes: this.options.maxQueuedRequestBytes,