chainlesschain 0.166.26 → 0.166.28

package/src/commands/ask.js

@@ -22,6 +22,10 @@
  */
 
 import ora from "ora";
+import { randomUUID } from "node:crypto";
+import { types as utilTypes } from "node:util";
+import { captureAgentEvolutionRuntimeComposition } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
+import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
 import { logger } from "../lib/logger.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
 import { loadConfig } from "../lib/config-manager.js";
@@ -97,9 +101,22 @@ export function extractCompletion(data, provider = "provider") {
   return content;
 }
 
-export async function queryLLM(question, options = {}) {
+export async function queryLLM(
+  question,
+  options = {},
+  evolutionIngress = null,
+) {
   const provider = options.provider || "ollama";
   const model = options.model || "qwen2:7b";
+  const messages = [{ role: "user", content: question }];
+  const providerMessages =
+    evolutionIngress === null
+      ? messages
+      : (
+          await captureAgentEvolutionIngress(
+            evolutionIngress,
+          ).prepareModelRequest({ messages, tools: [] })
+        ).messages;
 
   // Claude-Code 2.1.183 parity: warn (stderr only, so --json/stdout stays
   // clean) if the requested model is a provider-retired snapshot. Suppressed
@@ -123,7 +140,7 @@ export async function queryLLM(question, options = {}) {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         model,
-        messages: [{ role: "user", content: question }],
+        messages: providerMessages,
         stream: false,
       }),
     });
@@ -169,7 +186,7 @@ export async function queryLLM(question, options = {}) {
     },
     body: JSON.stringify({
       model: model || providerDef.models[0],
-      messages: [{ role: "user", content: question }],
+      messages: providerMessages,
     }),
   });
 
@@ -183,7 +200,29 @@ export async function queryLLM(question, options = {}) {
   return extractCompletion(data, provider);
 }
 
-export function registerAskCommand(program) {
+export function registerAskCommand(program, dependencies = {}) {
+  if (
+    !dependencies ||
+    typeof dependencies !== "object" ||
+    Array.isArray(dependencies) ||
+    utilTypes.isProxy(dependencies)
+  ) {
+    throw new TypeError("Ask command dependencies must be a plain object");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(
+    dependencies,
+    "evolutionCompositionFactory",
+  );
+  if (
+    descriptor &&
+    (!Object.hasOwn(descriptor, "value") ||
+      typeof descriptor.value !== "function")
+  ) {
+    throw new TypeError(
+      "Ask evolutionCompositionFactory must be a function data property",
+    );
+  }
+  const evolutionCompositionFactory = descriptor?.value ?? null;
   program
     .command("ask")
     .description("Ask a question to the AI (single-shot)")
@@ -239,7 +278,47 @@ export function registerAskCommand(program) {
 
       const spinner = ora("Thinking...").start();
       try {
-        const answer = await queryLLM(expandedQuestion, resolvedOptions);
+        let ingress = null;
+        if (evolutionCompositionFactory !== null) {
+          const runId = `ask-${randomUUID()}`;
+          const composition = captureAgentEvolutionRuntimeComposition(
+            await evolutionCompositionFactory(
+              Object.freeze({
+                mode: "ask",
+                runId,
+                taskId: runId,
+                cwd: process.cwd(),
+              }),
+            ),
+          );
+          ingress = composition.evolutionIngress;
+          if (
+            composition.runId !== runId ||
+            ingress.runId !== runId ||
+            composition.tenantId !== ingress.tenantId
+          ) {
+            throw new Error(
+              "Ask evolution composition is not bound to the requested Run",
+            );
+          }
+          await ingress.start();
+          await ingress.ingestUserPrompt({
+            content: expandedQuestion,
+            source: "ask",
+          });
+        }
+        const answer = await queryLLM(
+          expandedQuestion,
+          resolvedOptions,
+          ingress,
+        );
+        if (ingress !== null) {
+          await ingress.ingestAgentEvent({
+            type: "response-complete",
+            content: answer,
+          });
+          await ingress.complete();
+        }
 
         spinner.stop();
 

package/src/commands/chat.js

@@ -5,10 +5,69 @@
 
 import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 import { assertChatSessionUsageAdmission } from "../lib/chat-session-admission.js";
+import { randomUUID } from "node:crypto";
+import { types as utilTypes } from "node:util";
+import { captureAgentEvolutionRuntimeComposition } from "../lib/evolution/agent-evolution-runtime-composition.js";
 
 export { assertChatSessionUsageAdmission } from "../lib/chat-session-admission.js";
 
+function captureChatEvolutionCompositionFactory(commandDeps) {
+  if (
+    commandDeps === null ||
+    typeof commandDeps !== "object" ||
+    Array.isArray(commandDeps) ||
+    utilTypes.isProxy(commandDeps)
+  ) {
+    throw new TypeError("Chat command dependencies must be a plain object");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(
+    commandDeps,
+    "evolutionCompositionFactory",
+  );
+  if (!descriptor) return null;
+  if (
+    !Object.hasOwn(descriptor, "value") ||
+    typeof descriptor.value !== "function"
+  ) {
+    throw new TypeError(
+      "Chat evolutionCompositionFactory must be a function data property",
+    );
+  }
+  return descriptor.value;
+}
+
+export async function resolveChatCommandEvolutionComposition(
+  evolutionCompositionFactory,
+  { agent = false } = {},
+) {
+  if (evolutionCompositionFactory === null) return null;
+  const mode = agent ? "chat-agent" : "chat";
+  const runId = `${mode}-${randomUUID()}`;
+  const composition = captureAgentEvolutionRuntimeComposition(
+    await evolutionCompositionFactory(
+      Object.freeze({
+        mode,
+        runId,
+        taskId: runId,
+        cwd: process.cwd(),
+      }),
+    ),
+  );
+  if (
+    composition.runId !== runId ||
+    composition.evolutionIngress.runId !== runId ||
+    composition.tenantId !== composition.evolutionIngress.tenantId
+  ) {
+    throw new Error(
+      "Chat evolution composition is not bound to the requested Run",
+    );
+  }
+  return composition;
+}
+
 export function registerChatCommand(program, dependencies = {}) {
+  const evolutionCompositionFactory =
+    captureChatEvolutionCompositionFactory(dependencies);
   const createRuntimeFactory =
     dependencies.createAgentRuntimeFactory || createAgentRuntimeFactory;
   const assertUsageAdmission =
@@ -31,7 +90,14 @@ export function registerChatCommand(program, dependencies = {}) {
     .option("--session <id>", "Resume a previous session (agent mode)")
     .action(async (options) => {
       if (!options.agent) assertUsageAdmission(options.session);
-      const factory = createRuntimeFactory();
+      const evolutionComposition = await resolveChatCommandEvolutionComposition(
+        evolutionCompositionFactory,
+        { agent: Boolean(options.agent) },
+      );
+      const factory =
+        evolutionComposition === null
+          ? createRuntimeFactory()
+          : createRuntimeFactory({ evolutionComposition });
       const runtimeOptions = {
         model: options.model,
         provider: options.provider,

package/src/commands/compact.js

@@ -20,6 +20,9 @@
  */
 
 import chalk from "chalk";
+import { randomUUID } from "node:crypto";
+import { types as utilTypes } from "node:util";
+import { captureAgentEvolutionRuntimeComposition } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { logger } from "../lib/logger.js";
 import {
   appendAuthorityEventIfHead,
@@ -85,7 +88,14 @@ function attachMeteringMetadata(value, { callId, settled }) {
   }
 }
 
-function buildSemanticQuery(options, recorded, sessionId, operationId, ledger) {
+function buildSemanticQuery(
+  options,
+  recorded,
+  sessionId,
+  operationId,
+  ledger,
+  evolutionCompositionFactory,
+) {
   const provider = options.provider || recorded.provider || undefined;
   const model = options.model || recorded.model || undefined;
   // A preview must be both write-free and spend-free. It uses the same
@@ -97,6 +107,44 @@ function buildSemanticQuery(options, recorded, sessionId, operationId, ledger) {
   return async (prompt) => {
     let callId = null;
     try {
+      let ingress = null;
+      if (evolutionCompositionFactory !== null) {
+        try {
+          const runId = `compact-run-${randomUUID()}`;
+          const composition = captureAgentEvolutionRuntimeComposition(
+            await evolutionCompositionFactory(
+              Object.freeze({
+                mode: "compact",
+                runId,
+                sessionId,
+                operationId,
+                cwd: process.cwd(),
+              }),
+            ),
+          );
+          ingress = composition.evolutionIngress;
+          if (
+            composition.runId !== runId ||
+            ingress.runId !== runId ||
+            composition.tenantId !== ingress.tenantId
+          ) {
+            throw new Error(
+              "Compact evolution composition is not bound to the requested Run",
+            );
+          }
+          await ingress.start();
+          await ingress.ingestUserPrompt({
+            content: prompt,
+            source: "compact",
+          });
+        } catch (cause) {
+          const error = new Error("Compact evolution admission failed", {
+            cause,
+          });
+          error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+          throw error;
+        }
+      }
       const response = await runMeteredDirectModelCall({
         sessionId,
         provider,
@@ -129,8 +177,16 @@ function buildSemanticQuery(options, recorded, sessionId, operationId, ledger) {
             hostManagedToolPolicy: null,
             contextEngine: null,
             maxOutputTokens: 2048,
+            ...(ingress === null ? {} : { evolutionIngress: ingress }),
           }),
       });
+      if (ingress !== null) {
+        await ingress.ingestAgentEvent({
+          type: "response-complete",
+          content: response?.message?.content || "",
+        });
+        await ingress.complete();
+      }
       return {
         summary: response?.message?.content || "",
         usage: response?.usage || null,
@@ -373,7 +429,29 @@ function readCompactSource(sessionId) {
   });
 }
 
-export function registerCompactCommand(program) {
+export function registerCompactCommand(program, dependencies = {}) {
+  if (
+    !dependencies ||
+    typeof dependencies !== "object" ||
+    Array.isArray(dependencies) ||
+    utilTypes.isProxy(dependencies)
+  ) {
+    throw new TypeError("Compact command dependencies must be a plain object");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(
+    dependencies,
+    "evolutionCompositionFactory",
+  );
+  if (
+    descriptor &&
+    (!Object.hasOwn(descriptor, "value") ||
+      typeof descriptor.value !== "function")
+  ) {
+    throw new TypeError(
+      "Compact evolution composition factory must be a function data property",
+    );
+  }
+  const evolutionCompositionFactory = descriptor?.value ?? null;
   program
     .command("compact <session-id>")
     .description(
@@ -430,6 +508,7 @@ export function registerCompactCommand(program) {
           sessionId,
           operationId,
           ledger,
+          evolutionCompositionFactory,
         );
         const compressor = buildCompressor(options, source.recorded, llmQuery);
         const memoryRevision =

package/src/commands/complete.js

@@ -13,6 +13,9 @@
  * makes it snappier.
  */
 import { loadConfig } from "../lib/config-manager.js";
+import { randomUUID } from "node:crypto";
+import { types as utilTypes } from "node:util";
+import { captureAgentEvolutionRuntimeComposition } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { resolveOllamaBaseUrl, queryLLM } from "./ask.js";
 
 /** Hard cap so a runaway model can't flood the editor with a whole file. */
@@ -73,7 +76,29 @@ function readStdin() {
   });
 }
 
-export function registerCompleteCommand(program) {
+export function registerCompleteCommand(program, dependencies = {}) {
+  if (
+    !dependencies ||
+    typeof dependencies !== "object" ||
+    Array.isArray(dependencies) ||
+    utilTypes.isProxy(dependencies)
+  ) {
+    throw new TypeError("Complete command dependencies must be a plain object");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(
+    dependencies,
+    "evolutionCompositionFactory",
+  );
+  if (
+    descriptor &&
+    (!Object.hasOwn(descriptor, "value") ||
+      typeof descriptor.value !== "function")
+  ) {
+    throw new TypeError(
+      "Complete evolutionCompositionFactory must be a function data property",
+    );
+  }
+  const evolutionCompositionFactory = descriptor?.value ?? null;
   program
     .command("complete")
     .description(
@@ -125,10 +150,44 @@ export function registerCompleteCommand(program) {
           : options.baseUrl || config.llm?.baseUrl;
 
       try {
-        const reply = await queryLLM(
-          buildFimPrompt(prefix, suffix, language),
-          resolvedOptions,
-        );
+        const prompt = buildFimPrompt(prefix, suffix, language);
+        let ingress = null;
+        if (evolutionCompositionFactory !== null) {
+          const runId = `complete-${randomUUID()}`;
+          const composition = captureAgentEvolutionRuntimeComposition(
+            await evolutionCompositionFactory(
+              Object.freeze({
+                mode: "complete",
+                runId,
+                taskId: runId,
+                cwd: process.cwd(),
+              }),
+            ),
+          );
+          ingress = composition.evolutionIngress;
+          if (
+            composition.runId !== runId ||
+            ingress.runId !== runId ||
+            composition.tenantId !== ingress.tenantId
+          ) {
+            throw new Error(
+              "Complete evolution composition is not bound to the requested Run",
+            );
+          }
+          await ingress.start();
+          await ingress.ingestUserPrompt({
+            content: prompt,
+            source: "complete",
+          });
+        }
+        const reply = await queryLLM(prompt, resolvedOptions, ingress);
+        if (ingress !== null) {
+          await ingress.ingestAgentEvent({
+            type: "response-complete",
+            content: reply,
+          });
+          await ingress.complete();
+        }
         emit(cleanCompletion(reply), {
           model: resolvedOptions.model,
           provider,

package/src/commands/cowork.js

@@ -7,11 +7,85 @@ import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
 import path from "path";
+import { randomUUID } from "node:crypto";
+import { types as utilTypes } from "node:util";
 import { logger } from "../lib/logger.js";
+import { captureAgentEvolutionRuntimeComposition } from "../lib/evolution/agent-evolution-runtime-composition.js";
 
 const SESSION_EXECUTION_LOCATION_AUTHORITY_SCHEMA =
   "cc-session-execution-location-authority/v1";
 
+function captureCoworkEvolutionCompositionFactory(commandDeps) {
+  if (
+    commandDeps === null ||
+    typeof commandDeps !== "object" ||
+    Array.isArray(commandDeps) ||
+    utilTypes.isProxy(commandDeps)
+  ) {
+    throw new TypeError("Cowork command dependencies must be a plain object");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(
+    commandDeps,
+    "evolutionCompositionFactory",
+  );
+  if (!descriptor) return null;
+  if (
+    !Object.hasOwn(descriptor, "value") ||
+    typeof descriptor.value !== "function"
+  ) {
+    throw new TypeError(
+      "Cowork evolutionCompositionFactory must be a function data property",
+    );
+  }
+  return descriptor.value;
+}
+
+async function startCoworkCommandEvolution(
+  evolutionCompositionFactory,
+  { mode, content, source },
+) {
+  if (evolutionCompositionFactory === null) return null;
+  try {
+    const runId = `cowork-${mode}-${randomUUID()}`;
+    const composition = captureAgentEvolutionRuntimeComposition(
+      await evolutionCompositionFactory(
+        Object.freeze({
+          mode: `cowork-${mode}`,
+          runId,
+          taskId: runId,
+          cwd: process.cwd(),
+        }),
+      ),
+    );
+    const ingress = composition.evolutionIngress;
+    if (
+      composition.runId !== runId ||
+      ingress.runId !== runId ||
+      composition.tenantId !== ingress.tenantId
+    ) {
+      throw new Error(
+        "Cowork evolution composition is not bound to the requested Run",
+      );
+    }
+    await ingress.start();
+    await ingress.ingestUserPrompt({ content, source });
+    return Object.freeze({ composition, ingress });
+  } catch (cause) {
+    const error = new Error("Cowork evolution admission failed", { cause });
+    error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+    throw error;
+  }
+}
+
+async function completeCoworkCommandEvolution(evolution, result) {
+  if (evolution === null) return;
+  await evolution.ingress.ingestAgentEvent({
+    type: "response-complete",
+    content: result,
+  });
+  await evolution.ingress.complete();
+}
+
 function workflowAuthorityError(code, message) {
   const error = new Error(message);
   error.code = code;
@@ -114,6 +188,8 @@ function verifyWorkflowRunAuthorities(
 }
 
 export function registerCoworkCommand(program, commandDeps = {}) {
+  const evolutionCompositionFactory =
+    captureCoworkEvolutionCompositionFactory(commandDeps);
   const cowork = program
     .command("cowork")
     .description(
@@ -164,9 +240,20 @@ export function registerCoworkCommand(program, commandDeps = {}) {
       ).start();
 
       try {
+        const evolution = await startCoworkCommandEvolution(
+          evolutionCompositionFactory,
+          {
+            mode: "debate",
+            content: code,
+            source: "cowork:debate",
+          },
+        );
         const llmOptions = {};
         if (options.provider) llmOptions.provider = options.provider;
         if (options.model) llmOptions.model = options.model;
+        if (evolution !== null) {
+          llmOptions.evolutionIngress = evolution.ingress;
+        }
 
         const result = await startDebate({
           target: targetLabel,
@@ -174,6 +261,7 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           perspectives,
           llmOptions,
         });
+        await completeCoworkCommandEvolution(evolution, result);
         spinner.stop();
 
         if (options.json) {
@@ -257,9 +345,20 @@ export function registerCoworkCommand(program, commandDeps = {}) {
       ).start();
 
       try {
+        const evolution = await startCoworkCommandEvolution(
+          evolutionCompositionFactory,
+          {
+            mode: "compare",
+            content: prompt,
+            source: "cowork:compare",
+          },
+        );
         const llmOptions = {};
         if (options.provider) llmOptions.provider = options.provider;
         if (options.model) llmOptions.model = options.model;
+        if (evolution !== null) {
+          llmOptions.evolutionIngress = evolution.ingress;
+        }
 
         const result = await compare({
           prompt,
@@ -267,6 +366,7 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           criteria,
           llmOptions,
         });
+        await completeCoworkCommandEvolution(evolution, result);
         spinner.stop();
 
         if (options.json) {
@@ -342,6 +442,14 @@ export function registerCoworkCommand(program, commandDeps = {}) {
 
       try {
         let result;
+        const usesModel = ["style", "decisions"].includes(options.type);
+        const evolution = usesModel
+          ? await startCoworkCommandEvolution(evolutionCompositionFactory, {
+              mode: `analyze-${options.type}`,
+              content: resolved,
+              source: `cowork:analyze:${options.type}`,
+            })
+          : null;
 
         if (options.type === "style") {
           const { analyzeProjectStyle } =
@@ -349,6 +457,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           const llmOptions = {};
           if (options.provider) llmOptions.provider = options.provider;
           if (options.model) llmOptions.model = options.model;
+          if (evolution !== null) {
+            llmOptions.evolutionIngress = evolution.ingress;
+          }
           result = await analyzeProjectStyle({
             targetPath: resolved,
             llmOptions,
@@ -363,6 +474,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           const llmOptions = {};
           if (options.provider) llmOptions.provider = options.provider;
           if (options.model) llmOptions.model = options.model;
+          if (evolution !== null) {
+            llmOptions.evolutionIngress = evolution.ingress;
+          }
           result = await extractDecisions({
             targetPath: resolved,
             llmOptions,
@@ -372,6 +486,8 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           process.exit(1);
         }
 
+        await completeCoworkCommandEvolution(evolution, result);
+
         spinner.stop();
 
         if (options.json) {
@@ -875,10 +991,23 @@ export function registerCoworkCommand(program, commandDeps = {}) {
     .option("--model <name>", "LLM model to use")
     .action(async (prompt, options) => {
       try {
+        const evolution = await startCoworkCommandEvolution(
+          evolutionCompositionFactory,
+          {
+            mode: "workflow-draft",
+            content: prompt,
+            source: "cowork:workflow-draft",
+          },
+        );
         let chat;
         let provider;
         let model;
         if (Object.hasOwn(commandDeps, "workflowDraftChat")) {
+          if (evolution !== null) {
+            throw new Error(
+              "Cowork workflow draft chat seam cannot replace governed model ingress",
+            );
+          }
           const descriptor = Object.getOwnPropertyDescriptor(
             commandDeps,
             "workflowDraftChat",
@@ -920,6 +1049,9 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           chat = createChatFn({
             provider,
             model,
+            ...(evolution === null
+              ? {}
+              : { evolutionIngress: evolution.ingress }),
             ...(config.provider === provider && config.baseUrl
               ? { baseUrl: config.baseUrl }
               : {}),
@@ -934,6 +1066,7 @@ export function registerCoworkCommand(program, commandDeps = {}) {
           { prompt, provider, model },
           { chat },
         );
+        await completeCoworkCommandEvolution(evolution, draft);
         console.log(JSON.stringify(draft, null, 2));
       } catch (err) {
         logger.error(`WORKFLOW_DRAFT_FAILED: ${err.message}`);