chainlesschain 0.166.21 → 0.166.24

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;
 }

package/src/lib/evolution/agent-evolution-session-lifecycle.js

@@ -0,0 +1,46 @@
+import { captureAgentEvolutionIngress } from "./agent-evolution-ingress.js";
+
+export const AGENT_EVOLUTION_SESSION_SCHEMA = "agent-evolution-session/v1";
+const sessions = new WeakMap();
+
+// readline startup returns before the interactive session ends. Its owner must
+// finish the durable Run during teardown, before process.exit can terminate it.
+// The runtime receives only an opaque waiter, never the ability to close early.
+export function createAgentEvolutionSessionLifecycle(value) {
+  const ingress = captureAgentEvolutionIngress(value);
+  let resolveFinished;
+  let rejectFinished;
+  const finished = new Promise((resolve, reject) => {
+    resolveFinished = resolve;
+    rejectFinished = reject;
+  });
+  // Teardown can fail before startup has returned the handle to its consumer.
+  void finished.catch(() => {});
+  const handle = Object.freeze({ schema: AGENT_EVOLUTION_SESSION_SCHEMA });
+  sessions.set(handle, { ingress, finished });
+  let closing = null;
+  return Object.freeze({
+    handle,
+    close(error = null) {
+      if (closing === null) {
+        closing = (async () => {
+          if (error !== null) throw error;
+          await ingress.complete();
+        })();
+        void closing.then(resolveFinished, rejectFinished);
+      }
+      return closing;
+    },
+  });
+}
+
+export function waitForAgentEvolutionSession(handle, value) {
+  const ingress = captureAgentEvolutionIngress(value);
+  const session = sessions.get(handle);
+  if (!session || session.ingress !== ingress) {
+    throw Object.assign(new Error("Agent evolution session is unbound"), {
+      code: "CC_AGENT_EVOLUTION_INGRESS_FAILED",
+    });
+  }
+  return session.finished;
+}