chainlesschain 0.166.17 → 0.166.20

package/src/commands/evolution.js

@@ -1,10 +1,10 @@
 /**
  * Evolution metrics and governance-record commands
- * chainlesschain evolution assess|learn|diagnose|repair|predict|growth|stats|export
+ * chainlesschain evolution assess|record-model-metrics|diagnose|repair|predict|growth|stats|export
  */
 
 import chalk from "chalk";
-import { intArg, floatArg } from "../lib/cli-arg.js";
+import { intArg } from "../lib/cli-arg.js";
 import { numericOption } from "../lib/cli-numeric.js";
 import ora from "ora";
 import { logger } from "../lib/logger.js";
@@ -12,7 +12,7 @@ import { parseJsonOption } from "../lib/parse-json-option.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   assessCapability,
-  trainIncremental,
+  recordIncrementalModelMetrics,
   selfDiagnose,
   selfRepair,
   predictBehavior,
@@ -26,10 +26,9 @@ import {
   REPAIR_STRATEGY,
   GROWTH_MILESTONE,
   assessCapabilityV2,
-  getCapabilityV2,
   listCapabilitiesV2,
-  trainIncrementalV2,
-  listTrainingLogV2,
+  recordTrainingMetricsV2,
+  listTrainingMetricRecordsV2,
   selfDiagnoseV2,
   getDiagnosisV2,
   listDiagnosesV2,
@@ -97,12 +96,12 @@ export function registerEvolutionCommand(program) {
       }
     });
 
-  // evolution learn <model-id>
+  // evolution record-model-metrics <model-id>
   evolution
-    .command("learn")
-    .description("Record incremental model metrics (metrics-only)")
+    .command("record-model-metrics")
+    .description("Record a synthetic model metric estimate (no training)")
     .argument("<model-id>", "Model record ID")
-    .option("--data <json>", "Training data as JSON array")
+    .option("--data <json>", "Observed data as JSON array")
     .option(
       "--type <type>",
       "Model type (classification|regression)",
@@ -123,13 +122,13 @@ export function registerEvolutionCommand(program) {
         if (options.data) {
           try {
             data = JSON.parse(options.data);
-          } catch (_err) {
+          } catch {
             // Use data string as single data point
             data = [options.data];
           }
         }
 
-        const result = trainIncremental(db, modelId, data, {
+        const result = recordIncrementalModelMetrics(db, modelId, data, {
           type: options.type,
         });
         spinner.succeed("Model metrics recorded");
@@ -139,8 +138,11 @@ export function registerEvolutionCommand(program) {
         } else {
           logger.log(chalk.bold(`Model: ${result.name}`));
           logger.log(`  Type:       ${result.type}`);
-          logger.log(`  Accuracy:   ${chalk.cyan(result.accuracy.toFixed(4))}`);
+          logger.log(
+            `  Formula Estimate: ${chalk.cyan(result.accuracy.toFixed(4))}`,
+          );
           logger.log(`  Data Points: ${result.dataPoints}`);
+          logger.log(`  Training Performed: ${result.performedTraining}`);
         }
 
         await shutdown();
@@ -389,7 +391,7 @@ export function registerEvolutionCommand(program) {
   // evolution export <model-id>
   evolution
     .command("export")
-    .description("Export a model for portability")
+    .description("Export a model metric record for portability")
     .argument("<model-id>", "Model ID to export")
     .option("--json", "Output as JSON")
     .action(async (modelId, options) => {
@@ -512,20 +514,20 @@ export function registerEvolutionCommand(program) {
     });
 
   evolution
-    .command("train-v2")
-    .description("Record V2 incremental training metrics (metrics-only)")
+    .command("record-training-metrics-v2")
+    .description("Record caller-supplied loss metrics (no training)")
     .requiredOption(
       "-s, --strategy <s>",
       "replay|elastic-weight|knowledge-distill",
     )
     .requiredOption("--data-size <n>", "Data size")
-    .requiredOption("--loss-before <n>", "Loss before training")
-    .requiredOption("--loss-after <n>", "Loss after training")
+    .requiredOption("--loss-before <n>", "Caller-reported loss before")
+    .requiredOption("--loss-after <n>", "Caller-reported loss after")
     .option("--duration-ms <n>", "Duration in ms", "0")
     .option("--json", "Output as JSON")
     .action((options) => {
       try {
-        const r = trainIncrementalV2({
+        const r = recordTrainingMetricsV2({
           strategy: options.strategy,
           dataSize: numericOption(options.dataSize, {
             name: "--data-size",
@@ -543,10 +545,11 @@ export function registerEvolutionCommand(program) {
         });
         if (options.json) console.log(JSON.stringify(r, null, 2));
         else {
-          logger.log(chalk.bold(`Training ${r.id}`));
+          logger.log(chalk.bold(`Metric Record ${r.id}`));
           logger.log(`  Strategy:          ${r.strategy}`);
           logger.log(`  KnowledgeRetention ${r.knowledgeRetention.toFixed(4)}`);
-          logger.log(`  Status:            ${r.status}`);
+          logger.log(`  Assessment:        ${r.retentionAssessment}`);
+          logger.log(`  Training Performed: ${r.performedTraining}`);
         }
       } catch (err) {
         logger.error(`Failed: ${err.message}`);
@@ -555,20 +558,23 @@ export function registerEvolutionCommand(program) {
     });
 
   evolution
-    .command("training-log-v2")
-    .description("List V2 training runs")
+    .command("training-metrics-v2")
+    .description("List V2 training metric records")
     .option("-s, --strategy <s>", "Filter by strategy")
     .option("-l, --limit <n>", "Limit")
     .option("--json", "Output as JSON")
     .action((options) => {
       const limit = options.limit ? parseInt(options.limit, 10) : undefined;
-      const list = listTrainingLogV2({ strategy: options.strategy, limit });
+      const list = listTrainingMetricRecordsV2({
+        strategy: options.strategy,
+        limit,
+      });
       if (options.json) console.log(JSON.stringify(list, null, 2));
       else {
-        if (list.length === 0) logger.log("(no training log)");
+        if (list.length === 0) logger.log("(no metric records)");
         for (const t of list) {
           logger.log(
-            `${new Date(t.createdAt).toISOString()} ${t.strategy.padEnd(20)} retention=${t.knowledgeRetention.toFixed(3)} status=${t.status}`,
+            `${new Date(t.createdAt).toISOString()} ${t.strategy.padEnd(20)} retention=${t.knowledgeRetention.toFixed(3)} assessment=${t.retentionAssessment}`,
           );
         }
       }
@@ -785,7 +791,7 @@ export function registerEvolutionCommand(program) {
       else {
         logger.log(chalk.bold("Evolution Stats V2"));
         logger.log(`  Capabilities: ${s.capabilityCount}`);
-        logger.log(`  TrainingRuns: ${s.trainingRuns}`);
+        logger.log(`  TrainingMetricRecords: ${s.trainingMetricRecords}`);
         logger.log(
           `  Diagnoses:    ${s.diagnoses.total} (${Object.entries(
             s.diagnoses.bySeverity,

package/src/commands/serve.js

@@ -7,7 +7,9 @@ import { logger } from "../lib/logger.js";
 import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 import path from "node:path";
 
-export function registerServeCommand(program) {
+export function registerServeCommand(program, dependencies = {}) {
+  const evolutionCompositionFactory =
+    dependencies.evolutionCompositionFactory ?? null;
   const serve = program
     .command("serve")
     .description("Start WebSocket server for remote CLI access")
@@ -126,6 +128,7 @@ export function registerServeCommand(program) {
               maxConnections: parseInt(opts.maxConnections, 10),
               store,
               kernelFactory: () => new CliAgentKernelAdapter({ cwd }),
+              evolutionCompositionFactory,
               maxQueuedRequests,
             });
             const info = await host.start();
@@ -155,6 +158,7 @@ export function registerServeCommand(program) {
             await runStdioAppServer({
               store,
               kernel: new CliAgentKernelAdapter({ cwd }),
+              evolutionCompositionFactory,
               maxQueuedRequests,
             });
           } finally {
@@ -162,7 +166,12 @@ export function registerServeCommand(program) {
           }
           return;
         }
-        const runtime = createAgentRuntimeFactory().createServerRuntime({
+        const runtime = createAgentRuntimeFactory({
+          deps:
+            evolutionCompositionFactory === null
+              ? {}
+              : { evolutionCompositionFactory },
+        }).createServerRuntime({
           port: parseInt(opts.port, 10),
           host: opts.host,
           token: opts.token,

package/src/data/changelog.json

@@ -3,14 +3,27 @@
   "releases": [
     {
       "productVersion": null,
-      "cliVersion": "0.166.17",
-      "cliVersions": ["0.3.9", "0.166.16", "0.166.17"],
-      "date": "2026-09-02",
+      "cliVersion": "0.166.20",
+      "cliVersions": ["0.3.10", "0.166.18", "0.166.20"],
+      "date": "2026-09-03",
       "title": "",
       "sections": [
         {
-          "heading": "Added - cc CLI 0.166.17 and Session Core 0.3.9: governed Skill evolution",
-          "body": "> `chainlesschain` **0.166.16 -> 0.166.17** and\n> `@chainlesschain/session-core` **0.3.8 -> 0.3.9** (release candidate,\n> 2026-09-02).\n\n- **Evaluated promotion**: Skill candidates must carry target-matrix evidence,\n  current-revision bindings, durable promotion receipts, and revocation-aware\n  attestations before an active revision can change.\n- **Crash-safe lifecycle**: tenant-scoped candidate and release registries,\n  lease/CAS promotion, last-known-good tracking, and rollback keep concurrent\n  or interrupted mutations fail closed.\n- **Bounded improvement pilot**: the CLI can propose constrained Skill\n  improvements and wiki-informed candidates without directly rewriting or\n  activating installed Skills.\n- **Cross-runtime evidence**: CLI, Desktop, and Graph adapters share the new\n  Session Core `EvolutionRun` and Skill-invocation receipt contracts, keeping\n  evidence identity consistent across runtimes.\n- **Deterministic async hooks**: tool execution now skips `async:true`\n  `PostToolUse` hooks when no supervisor/dispatcher is available, preventing a\n  hidden background command and a Windows timing race.\n- **Release boundary**: publication requires this exact candidate commit to\n  pass every configured Linux, Windows, and macOS job in `CLI CI` and\n  `CLI Strict Sandbox`; a local test result or an older green run is not\n  release authorization."
+          "heading": "Fixed - cc CLI 0.166.20 and Session Core 0.3.10: public-install agent startup",
+          "body": "> `chainlesschain` **0.166.18 -> 0.166.20** and\n> `@chainlesschain/session-core` **0.3.9 -> 0.3.10** (release candidate,\n> 2026-09-03).\n\n- **Restore `cc` and `cc agent` startup from public npm installs**: publish the\n  Session Core `./structured-evolution-memory` export consumed by the CLI's\n  Agent command graph. Version `0.166.18` referenced this source export while\n  the immutable public `session-core@0.3.9` bytes predated it, so lazy command\n  registration fell back and reported the misleading `unknown command 'agent'`.\n- **Preserve fast help/version paths** while requiring executable Agent\n  capability checks against installed package bytes before release.\n- **Release boundary**: publish Session Core `0.3.10` before the pinned CLI\n  `0.166.20`, then verify the public registry installation can execute\n  `cc agent --capabilities`."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.18",
+      "cliVersions": ["0.3.9", "0.166.17", "0.166.18"],
+      "date": "2026-09-03",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.166.18 and Session Core 0.3.9: governed Skill evolution",
+          "body": "> `chainlesschain` **0.166.17 -> 0.166.18** and\n> `@chainlesschain/session-core` **0.3.8 -> 0.3.9** (release candidate,\n> 2026-09-03).\n\n- **Evaluated promotion**: Skill candidates must carry target-matrix evidence,\n  current-revision bindings, durable promotion receipts, and revocation-aware\n  attestations before an active revision can change.\n- **Crash-safe lifecycle**: tenant-scoped candidate and release registries,\n  lease/CAS promotion, last-known-good tracking, and rollback keep concurrent\n  or interrupted mutations fail closed.\n- **Bounded improvement pilot**: the CLI can propose constrained Skill\n  improvements and wiki-informed candidates without directly rewriting or\n  activating installed Skills.\n- **Cross-runtime evidence**: CLI, Desktop, and Graph adapters share the new\n  Session Core `EvolutionRun` and Skill-invocation receipt contracts, keeping\n  evidence identity consistent across runtimes.\n- **Deterministic async hooks**: tool execution now skips `async:true`\n  `PostToolUse` hooks when no supervisor/dispatcher is available, preventing a\n  hidden background command and a Windows timing race.\n- **Release boundary**: publication requires this exact candidate commit to\n  pass every configured Linux, Windows, and macOS job in `CLI CI` and\n  `CLI Strict Sandbox`; a local test result or an older green run is not\n  release authorization."
         }
       ]
     },

package/src/gateways/ws/session-protocol.js

@@ -647,6 +647,7 @@ async function ensureSessionHandler(
         db: server.sessionManager.db,
         sessionHostLease,
         sessionBudgetRoot,
+        evolutionCompositionFactory: server.evolutionCompositionFactory,
       });
       sessionHostLease = null;
       sessionBudgetRoot = null;

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 = {}) {