chainlesschain 0.166.22 → 0.166.25

package/src/lib/autonomous-agent.js

@@ -43,6 +43,9 @@ export class CLIAutonomousAgent extends EventEmitter {
   constructor() {
     super();
     this._goals = new Map();
+    this._runningLoops = new Map();
+    this._closing = false;
+    this._shutdownAbort = new AbortController();
     this._llmChat = null;
     this._toolExecutor = null;
     this._hookManager = null;
@@ -88,6 +91,7 @@ export class CLIAutonomousAgent extends EventEmitter {
   async submitGoal(description, { tokenBudget = 50000 } = {}) {
     assertCLILegacyMutationAllowed("CLIAutonomousAgent.submitGoal");
     if (!this._initialized) throw new Error("Agent not initialized");
+    if (this._closing) throw new Error("Agent session is closing");
     if (!description) throw new Error("Goal description required");
 
     const goalId = `goal-${_deps.Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@@ -111,11 +115,7 @@ export class CLIAutonomousAgent extends EventEmitter {
     this.emit("goal:submitted", { goalId, description });
 
     // Start the ReAct loop asynchronously
-    this._runReActLoop(goal).catch((err) => {
-      goal.status = GoalStatus.FAILED;
-      goal.errors.push(err.message);
-      this.emit("goal:failed", { goalId, error: err.message });
-    });
+    this._launchGoalLoop(goal);
 
     return { goalId };
   }
@@ -162,6 +162,7 @@ export class CLIAutonomousAgent extends EventEmitter {
    */
   resumeGoal(goalId) {
     assertCLILegacyMutationAllowed("CLIAutonomousAgent.resumeGoal");
+    if (this._closing) return { error: "Agent session is closing" };
     const goal = this._goals.get(goalId);
     if (!goal) return { error: "Goal not found" };
     if (goal.status !== GoalStatus.PAUSED)
@@ -172,14 +173,51 @@ export class CLIAutonomousAgent extends EventEmitter {
     this.emit("goal:resumed", { goalId });
 
     // Continue the loop
-    this._runReActLoop(goal).catch((err) => {
-      goal.status = GoalStatus.FAILED;
-      goal.errors.push(err.message);
-    });
+    this._launchGoalLoop(goal);
 
     return { success: true };
   }
 
+  _launchGoalLoop(goal) {
+    // Resume during an in-flight model/tool call reuses that loop, rather than
+    // launching a second execution of the same goal.
+    if (this._runningLoops.has(goal.id)) return this._runningLoops.get(goal.id);
+    const running = this._runReActLoop(goal)
+      .catch((err) => {
+        if (goal.status === GoalStatus.CANCELLED) return;
+        goal.status = GoalStatus.FAILED;
+        goal.errors.push(err.message);
+        this.emit("goal:failed", { goalId: goal.id, error: err.message });
+      })
+      .finally(() => this._runningLoops.delete(goal.id));
+    this._runningLoops.set(goal.id, running);
+    return running;
+  }
+
+  get signal() {
+    return this._shutdownAbort.signal;
+  }
+
+  async shutdown() {
+    this._closing = true;
+    let interrupted = 0;
+    for (const goal of this._goals.values()) {
+      if (
+        ![GoalStatus.PENDING, GoalStatus.RUNNING, GoalStatus.PAUSED].includes(
+          goal.status,
+        )
+      )
+        continue;
+      interrupted++;
+      goal.status = GoalStatus.CANCELLED;
+      goal.updatedAt = new Date().toISOString();
+      this.emit("goal:cancelled", { goalId: goal.id });
+    }
+    this._shutdownAbort.abort(new Error("Agent session is closing"));
+    await Promise.allSettled([...this._runningLoops.values()]);
+    return { interrupted };
+  }
+
   /**
    * Cancel a goal.
    */
@@ -374,12 +412,13 @@ Goal: ${goal.description}
 
 Available tools: read_file, write_file, edit_file, run_shell, search_files, list_dir, run_skill
 
-Return a JSON array of steps, each with: { "description": "...", "tool": "tool_name", "params": {...} }
+Return a JSON array of steps, for example: [{ "description": "Describe the step", "tool": "tool_name", "params": {} }]
+Populate params with the selected tool's actual arguments.
 Only return the JSON array, no other text.`;
 
       const response = await this._llmChat(
         [{ role: "user", content: prompt }],
-        { maxTokens: 1024 },
+        { maxTokens: 1024, signal: this.signal },
       );
 
       // Parse steps from LLM response
@@ -396,6 +435,11 @@ Only return the JSON array, no other text.`;
       }));
     } catch (_err) {
       // Fallback: single step
+      if (
+        _err?.runtimeLedgerPersistence === true ||
+        _err?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED"
+      )
+        throw _err;
       return [
         {
           description: goal.description,
@@ -450,11 +494,12 @@ Should I:
 2. Add a new prerequisite step
 3. Skip this step and continue
 
-Reply with a JSON object: { "action": "retry|add_step|skip", "newParams": {...}, "newStep": {...} }`;
+Reply with a JSON object, for example: { "action": "retry", "newParams": {}, "newStep": { "description": "Corrective step", "tool": "tool_name", "params": {} } }
+Set action to retry, add_step, or skip. Supply newParams for retry and newStep for add_step.`;
 
       const response = await this._llmChat(
         [{ role: "user", content: prompt }],
-        { maxTokens: 512 },
+        { maxTokens: 512, signal: this.signal },
       );
 
       const correction = this._parseJSON(response);
@@ -499,6 +544,11 @@ Reply with a JSON object: { "action": "retry|add_step|skip", "newParams": {...},
 
       return false;
     } catch (_err) {
+      if (
+        _err?.runtimeLedgerPersistence === true ||
+        _err?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED"
+      )
+        throw _err;
       return false;
     }
   }

package/src/lib/cowork/ab-comparator-cli.js

@@ -10,8 +10,9 @@ import { runPeerGroup } from "./agent-group-runner.js";
 
 const DEFAULT_CRITERIA = ["quality", "performance", "readability"];
 
-function throwRuntimeLedgerFailure(error) {
+function throwTerminalModelFailure(error) {
   if (error?.runtimeLedgerPersistence === true) throw error;
+  if (error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw error;
 }
 
 const VARIANT_PROFILES = [
@@ -91,7 +92,7 @@ export async function compare({
   // Ordinary variant failures remain comparable, but a host ledger failure
   // must escape before judging can spend again or a partial result is emitted.
   for (const outcome of runResult.results) {
-    throwRuntimeLedgerFailure(outcome.error);
+    throwTerminalModelFailure(outcome.error);
   }
 
   const generatedVariants = runResult.results.map((r) => {
@@ -145,7 +146,7 @@ REASON: (1-2 sentence justification)`;
     winner = parseWinner(judgement) || generatedVariants[0]?.name || "unknown";
     reason = parseReason(judgement) || "See detailed scores above.";
   } catch (err) {
-    throwRuntimeLedgerFailure(err);
+    throwTerminalModelFailure(err);
     reason = `Scoring error: ${err.message}`;
   }
 

package/src/lib/cowork/debate-review-cli.js

@@ -10,8 +10,9 @@ import { runPeerGroup } from "./agent-group-runner.js";
 
 const DEFAULT_PERSPECTIVES = ["performance", "security", "maintainability"];
 
-function throwRuntimeLedgerFailure(error) {
+function throwTerminalModelFailure(error) {
   if (error?.runtimeLedgerPersistence === true) throw error;
+  if (error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw error;
 }
 
 const PERSPECTIVE_PROMPTS = {
@@ -104,7 +105,7 @@ export async function startDebate({
   // rows. A durable usage-ledger failure is host-terminal, not review content:
   // let the REPL latch stop this and every later paid call.
   for (const outcome of runResult.results) {
-    throwRuntimeLedgerFailure(outcome.error);
+    throwTerminalModelFailure(outcome.error);
   }
 
   const reviews = runResult.results.map((r) => {
@@ -153,7 +154,7 @@ export async function startDebate({
     finalVerdict = extractVerdict(summary);
     consensusScore = extractConsensusScore(summary);
   } catch (err) {
-    throwRuntimeLedgerFailure(err);
+    throwTerminalModelFailure(err);
     summary = `Moderator error: ${err.message}`;
   }
 

package/src/lib/cowork/decision-kb-cli.js

@@ -119,6 +119,11 @@ List all decisions you can find. If no explicit decisions are documented, infer
       summary: `Found ${decisions.length} architectural decisions in ${targetPath}\n\n${decisions.map((d) => `  - ${d.title} (${d.status})`).join("\n")}`,
     };
   } catch (err) {
+    if (
+      err?.runtimeLedgerPersistence === true ||
+      err?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED"
+    )
+      throw err;
     return {
       decisions: [],
       summary: `Decision extraction failed: ${err.message}`,

package/src/lib/cowork-adapter.js

@@ -10,6 +10,7 @@
 import { LLMProviderRegistry, BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { loadConfig } from "./config-manager.js";
 import { applyConfigLlmDefaults } from "./llm-config-defaults.js";
+import { captureAgentEvolutionIngress } from "./evolution/agent-evolution-ingress.js";
 
 function plainUsage(value) {
   return value && typeof value === "object" && !Array.isArray(value)
@@ -106,6 +107,8 @@ async function invokeChatCall(callWrapper, provider, model, call) {
  * @param {string} [options.model] - Model name override
  * @param {string} [options.baseUrl] - Base URL override
  * @param {string} [options.apiKey] - API key override
+ * @param {object} [options.evolutionIngress] - Branded session ingress captured
+ *        by the adapter; per-call options cannot remove or replace it.
  * @param {(request: {call: function, provider: string, model: string}) => Promise<object>} [options.callWrapper]
  *        Optional host boundary around each real provider call. The callback
  *        may invoke `call({ signal })` to bind cancellation and resolves to a
@@ -114,6 +117,10 @@ async function invokeChatCall(callWrapper, provider, model, call) {
  * @returns {(messages: object[], opts?: object) => Promise<string>}
  */
 export function createChatFn(options = {}) {
+  const evolutionIngress =
+    options.evolutionIngress == null
+      ? null
+      : captureAgentEvolutionIngress(options.evolutionIngress);
   // Fill provider/model/baseUrl/apiKey from config.llm only when the caller
   // gave no explicit provider AND no LLM_PROVIDER env override (both still win).
   // Fail-open: a config read must never break chat construction.
@@ -140,6 +147,20 @@ export function createChatFn(options = {}) {
   return async function chat(messages, opts = {}) {
     const currentModel = opts.model || model;
     const maxTokens = opts.maxTokens || 2048;
+    const requestSignal = (hostSignal) => {
+      const signals = [
+        ...new Set([hostSignal, opts.signal, resolved.signal].filter(Boolean)),
+      ];
+      return signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    };
+    // Run inside the host's per-call meter, immediately before provider encoding.
+    // Every invocation (including concurrent reviewers) gets fresh durable
+    // admission; the original conversation is never replaced in place.
+    const prepareMessages = async () =>
+      evolutionIngress === null
+        ? messages
+        : (await evolutionIngress.prepareModelRequest({ messages, tools: [] }))
+            .messages;
 
     if (provider === "ollama") {
       const envelope = await invokeChatCall(
@@ -147,13 +168,14 @@ export function createChatFn(options = {}) {
         provider,
         currentModel,
         async ({ signal = opts.signal || resolved.signal } = {}) => {
+          const modelMessages = await prepareMessages();
           const res = await fetch(`${baseUrl}/api/chat`, {
             method: "POST",
-            signal,
+            signal: requestSignal(signal),
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
               model: currentModel,
-              messages,
+              messages: modelMessages,
               stream: false,
               options: { num_predict: maxTokens },
             }),
@@ -172,25 +194,24 @@ export function createChatFn(options = {}) {
     if (provider === "anthropic") {
       const key = resolved.apiKey || process.env[providerDef.apiKeyEnv];
       if (!key) throw new Error("ANTHROPIC_API_KEY not set");
-      // Extract system message if present
-      const systemMsgs = messages.filter((m) => m.role === "system");
-      const otherMsgs = messages.filter((m) => m.role !== "system");
-      const body = {
-        model: currentModel,
-        max_tokens: maxTokens,
-        messages: otherMsgs,
-      };
-      if (systemMsgs.length > 0) {
-        body.system = systemMsgs.map((m) => m.content).join("\n");
-      }
       const envelope = await invokeChatCall(
         callWrapper,
         provider,
         currentModel,
         async ({ signal = opts.signal || resolved.signal } = {}) => {
+          const modelMessages = await prepareMessages();
+          const systemMsgs = modelMessages.filter((m) => m.role === "system");
+          const body = {
+            model: currentModel,
+            max_tokens: maxTokens,
+            messages: modelMessages.filter((m) => m.role !== "system"),
+            ...(systemMsgs.length
+              ? { system: systemMsgs.map((m) => m.content).join("\n") }
+              : {}),
+          };
           const res = await fetch(`${baseUrl}/messages`, {
             method: "POST",
-            signal,
+            signal: requestSignal(signal),
             headers: {
               "Content-Type": "application/json",
               "x-api-key": key,
@@ -218,16 +239,17 @@ export function createChatFn(options = {}) {
       provider,
       currentModel,
       async ({ signal = opts.signal || resolved.signal } = {}) => {
+        const modelMessages = await prepareMessages();
         const res = await fetch(`${baseUrl}/chat/completions`, {
           method: "POST",
-          signal,
+          signal: requestSignal(signal),
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${key}`,
           },
           body: JSON.stringify({
             model: currentModel,
-            messages,
+            messages: modelMessages,
             max_tokens: maxTokens,
           }),
         });

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

@@ -2,9 +2,15 @@ import crypto from "node:crypto";
 import evolutionRun from "@chainlesschain/session-core/evolution-run";
 
 import { EvolutionEvidenceArtifactAdapter } from "./evolution-evidence-artifact-adapter.js";
+import { EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST } from "./evolution-evidence-projector.js";
 import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
 import { captureEvolutionRunWikiMaintenanceProducer } from "./evolution-run-wiki-maintenance-source.js";
 import { WIKI_MAINTENANCE_TRIGGER_KIND } from "./wiki-maintenance-trigger-ledger-adapter.js";
+import { captureEvolutionReleaseTrain } from "./evolution-release-train.js";
+import {
+  snapshotAgentModelRequest,
+  buildAgentModelRequest,
+} from "./agent-model-projection.js";
 
 const { EVOLUTION_RUN_EVENT_SCHEMA, EVENT_TYPES } = evolutionRun;
 
@@ -80,15 +86,19 @@ function normalizeId(value, label) {
   return result;
 }
 
+function ingressFailure(cause) {
+  if (cause?.code === AGENT_EVOLUTION_INGRESS_FAILED_CODE) return cause;
+  const error = new Error(
+    `Agent evolution ingress failed: ${cause?.message || String(cause)}`,
+    { cause },
+  );
+  error.code = AGENT_EVOLUTION_INGRESS_FAILED_CODE;
+  return error;
+}
+
 function guardIngress(operation) {
   return Promise.resolve(operation).catch((cause) => {
-    if (cause?.code === AGENT_EVOLUTION_INGRESS_FAILED_CODE) throw cause;
-    const error = new Error(
-      `Agent evolution ingress failed: ${cause?.message || String(cause)}`,
-      { cause },
-    );
-    error.code = AGENT_EVOLUTION_INGRESS_FAILED_CODE;
-    throw error;
+    throw ingressFailure(cause);
   });
 }
 
@@ -97,6 +107,7 @@ export function createAgentEvolutionIngress({
   runAdapter,
   sourceEnvelopeAuthority,
   wikiMaintenanceProducer = null,
+  releaseTrain = null,
   completionTriggerKind = WIKI_MAINTENANCE_TRIGGER_KIND.SESSION_END,
   now = () => new Date(),
   idGenerator = () => crypto.randomUUID(),
@@ -117,6 +128,8 @@ export function createAgentEvolutionIngress({
     wikiMaintenanceProducer === null
       ? null
       : captureEvolutionRunWikiMaintenanceProducer(wikiMaintenanceProducer);
+  const completionReleaseTrain =
+    releaseTrain === null ? null : captureEvolutionReleaseTrain(releaseTrain);
   if (
     ![
       WIKI_MAINTENANCE_TRIGGER_KIND.SESSION_END,
@@ -132,9 +145,22 @@ export function createAgentEvolutionIngress({
   );
   const descriptor = runAdapter.descriptor;
   let tail = Promise.resolve();
+  let modelAdmissionFailure = null;
 
-  const serialize = (operation) => {
-    const pending = tail.then(operation, operation);
+  const serialize = (operation, latchModelFailure = false) => {
+    const invoke = latchModelFailure
+      ? async () => {
+          try {
+            return await operation();
+          } catch (cause) {
+            // Latch inside the serialized operation, before releasing the queue.
+            // A complete() already queued by another caller cannot win this race.
+            modelAdmissionFailure = ingressFailure(cause);
+            throw modelAdmissionFailure;
+          }
+        }
+      : operation;
+    const pending = tail.then(invoke, invoke);
     tail = pending.catch(() => undefined);
     return pending;
   };
@@ -164,9 +190,10 @@ export function createAgentEvolutionIngress({
     }).projection;
   };
 
-  const ingest = (kind, evidence, options = {}) =>
+  const ingest = (kind, evidence, options = {}, modelRequest = null) =>
     guardIngress(
       serialize(async () => {
+        if (modelAdmissionFailure !== null) throw modelAdmissionFailure;
         const projection = appendStarted();
         if (projection.status === "completed") {
           throw new Error(
@@ -181,7 +208,7 @@ export function createAgentEvolutionIngress({
           options.occurredAt ?? currentTimestamp(),
           "Agent evidence occurredAt",
         );
-        const payload = clone(evidence);
+        const payload = modelRequest ?? clone(evidence);
         const sourceEnvelope = await issueSourceEnvelope(
           Object.freeze({
             schema: AGENT_EVOLUTION_INGRESS_SCHEMA,
@@ -193,10 +220,17 @@ export function createAgentEvolutionIngress({
             evidence: payload,
           }),
         );
-        const persisted = await evidenceAdapter.projectAndPersist({
+        const projectionInput = {
           sourceEnvelope,
           payload,
-        });
+        };
+        const persisted =
+          modelRequest === null
+            ? await evidenceAdapter.projectAndPersist(projectionInput)
+            : await EvolutionEvidenceArtifactAdapter.prototype.projectAndPersistAgentModelRequest.call(
+                evidenceAdapter,
+                projectionInput,
+              );
         if (
           persisted?.tenantId !== descriptor.tenantId ||
           persisted.evidenceId == null ||
@@ -208,7 +242,7 @@ export function createAgentEvolutionIngress({
           );
         }
         const current = runAdapter.load();
-        return runAdapter.appendEvent({
+        const appended = runAdapter.appendEvent({
           schema: EVOLUTION_RUN_EVENT_SCHEMA,
           tenantId: descriptor.tenantId,
           runId: descriptor.runId,
@@ -225,7 +259,37 @@ export function createAgentEvolutionIngress({
             derivationManifestDigest: persisted.manifest.digest,
           },
         });
-      }),
+        if (modelRequest === 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.
+        const resolved =
+          await EvolutionEvidenceArtifactAdapter.prototype.resolve.call(
+            evidenceAdapter,
+            persisted,
+          );
+        if (
+          resolved.verification.verified !== true ||
+          resolved.verification.tenantId !== descriptor.tenantId ||
+          resolved.bundle.modelProjection.rulesetDigest !==
+            EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST ||
+          resolved.bundle.modelProjection.evidenceId !== persisted.evidenceId
+        ) {
+          throw new Error("Agent model projection readback is unbound");
+        }
+        // A concurrent writer/completion must not make this stale admission
+        // authoritative. Reauthenticate the exact committed Run frontier.
+        if (
+          digest(runAdapter.load().projection) !== digest(appended.projection)
+        ) {
+          throw new Error("Agent model projection Run frontier changed");
+        }
+        if (modelAdmissionFailure !== null) throw modelAdmissionFailure;
+        return buildAgentModelRequest(
+          modelRequest,
+          resolved.bundle.modelProjection,
+        );
+      }, modelRequest !== null),
     );
 
   const ingress = Object.freeze({
@@ -233,6 +297,18 @@ export function createAgentEvolutionIngress({
     tenantId: descriptor.tenantId,
     runId: descriptor.runId,
     start: () => guardIngress(serialize(() => appendStarted())),
+    prepareModelRequest: (request) => {
+      if (modelAdmissionFailure !== null)
+        return Promise.reject(modelAdmissionFailure);
+      let snapshot;
+      try {
+        snapshot = snapshotAgentModelRequest(request);
+      } catch (error) {
+        modelAdmissionFailure = ingressFailure(error);
+        return Promise.reject(modelAdmissionFailure);
+      }
+      return ingest("model-input", snapshot, {}, snapshot);
+    },
     ingestUserPrompt: (input, options) =>
       ingest("user-prompt", { input: clone(input) }, options),
     ingestAgentEvent: (event, options) => {
@@ -250,6 +326,7 @@ export function createAgentEvolutionIngress({
     complete: (options = {}) =>
       guardIngress(
         serialize(async () => {
+          if (modelAdmissionFailure !== null) throw modelAdmissionFailure;
           const loaded = runAdapter.load();
           let projection;
           if (loaded.projection?.status === "completed") {
@@ -281,6 +358,9 @@ export function createAgentEvolutionIngress({
               runId: descriptor.runId,
             });
           }
+          if (completionReleaseTrain !== null) {
+            await completionReleaseTrain.run();
+          }
           return projection;
         }),
       ),

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

@@ -19,6 +19,11 @@ import {
 } from "./evolution-ledger-file-backend.js";
 import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
 import { EvolutionWorkbenchMetricsLedgerAdapter } from "./evolution-workbench-metrics-ledger-adapter.js";
+import { EvolutionReleaseTrainLedgerAdapter } from "./evolution-release-train-ledger-adapter.js";
+import { WikiSkillProposalLedgerAdapter } from "./wiki-skill-proposal-ledger-adapter.js";
+import { EvolutionReleaseTrainStageOutputLedgerAdapter } from "./evolution-release-train-stage-output-ledger-adapter.js";
+import { createEvolutionReleaseTrainDomainStages } from "./evolution-release-train-domain-stages.js";
+import { createEvolutionReleaseTrain } from "./evolution-release-train.js";
 import { captureSkillOutcomeSourceCatalogAuthority } from "./skill-outcome-source-catalog-authority.js";
 import {
   captureAgentEvolutionIngress,
@@ -55,6 +60,8 @@ const ARTIFACT_AUTHORITY_KEYS = new Set([
 const SKILL_OUTCOME_SOURCE_KEYS = new Set(["composition", "skillName"]);
 const SKILL_OUTCOME_CATALOG_ENTRY_KEYS = new Set(["runId", "skillNames"]);
 const MAX_SKILL_OUTCOME_SOURCES = 128;
+const RELEASE_TRAIN_STAGE_KEYS = new Set(["plan", "stages"]);
+const RELEASE_TRAIN_DOMAIN_KEYS = new Set(["plan", "domain"]);
 
 function exactRecord(value, keys, label) {
   if (
@@ -183,6 +190,7 @@ export function createAgentEvolutionRuntimeComposition({
   evidenceIdGenerator,
   ingressIdGenerator,
   wikiMaintenanceProducer = null,
+  releaseTrain: releaseTrainInput = null,
   completionTriggerKind,
   secure = true,
   fsImpl,
@@ -376,11 +384,84 @@ export function createAgentEvolutionRuntimeComposition({
     skillOutcomeReaders.set(skillName, reader);
     return reader;
   });
+  let releaseTrain = null;
+  if (releaseTrainInput !== null) {
+    const releaseTrainKeys = Object.hasOwn(releaseTrainInput, "domain")
+      ? RELEASE_TRAIN_DOMAIN_KEYS
+      : RELEASE_TRAIN_STAGE_KEYS;
+    const releaseTrainConfig = exactRecord(
+      releaseTrainInput,
+      releaseTrainKeys,
+      "releaseTrain",
+    );
+    if (
+      releaseTrainConfig.plan?.tenantId !== tenantId ||
+      typeof releaseTrainConfig.plan?.skillId !== "string"
+    ) {
+      throw new TypeError(
+        "releaseTrain plan must belong to the composition tenant",
+      );
+    }
+    const releaseTrainAdapter = new EvolutionReleaseTrainLedgerAdapter({
+      descriptor: {
+        tenantId,
+        artifactTenantId: tenantId,
+        skillName: releaseTrainConfig.plan.skillId,
+        audience,
+        purpose: "evolution-ledger",
+      },
+      artifactPorts,
+      ledger: backend.ledger,
+      ledgerArtifactResolver,
+      clock: () => new Date(clock()).toISOString(),
+    });
+    let stages = releaseTrainConfig.stages;
+    if (Object.hasOwn(releaseTrainConfig, "domain")) {
+      const proposalLedger = new WikiSkillProposalLedgerAdapter({
+        descriptor: {
+          tenantId,
+          artifactTenantId: tenantId,
+          evolutionRunId: runId,
+          skillName: releaseTrainConfig.plan.skillId,
+          audience,
+          purpose: "evolution-ledger",
+        },
+        artifactPorts,
+        ledger: backend.ledger,
+        ledgerArtifactResolver,
+      });
+      const outputLedger = new EvolutionReleaseTrainStageOutputLedgerAdapter({
+        descriptor: {
+          tenantId,
+          artifactTenantId: tenantId,
+          skillName: releaseTrainConfig.plan.skillId,
+          audience,
+          purpose: "evolution-ledger",
+        },
+        artifactPorts,
+        ledger: backend.ledger,
+        ledgerArtifactResolver,
+      });
+      stages = createEvolutionReleaseTrainDomainStages({
+        domain: releaseTrainConfig.domain,
+        proposalLedger,
+        outputLedger,
+      });
+    }
+    releaseTrain = createEvolutionReleaseTrain({
+      plan: releaseTrainConfig.plan,
+      stateStore: releaseTrainAdapter.createStateStore(),
+      stages,
+      clock,
+    });
+  }
+
   const evolutionIngress = createAgentEvolutionIngress({
     evidenceAdapter,
     runAdapter,
     sourceEnvelopeAuthority: ports.sourceEnvelope,
     wikiMaintenanceProducer,
+    releaseTrain,
     ...(completionTriggerKind === undefined ? {} : { completionTriggerKind }),
     now: () => new Date(clock()),
     idGenerator: ingressIdGenerator,
@@ -395,6 +476,7 @@ export function createAgentEvolutionRuntimeComposition({
     loadRun: Object.freeze(() => runAdapter.load()),
     ledgerDescriptor: backend.descriptor,
     storage,
+    releaseTrain,
   });
   return composition;
 }