chainlesschain 0.166.26 → 0.166.29

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

package/src/commands/orchestrate.js

@@ -16,7 +16,9 @@ import fs from "fs";
 import path from "path";
 import { logger } from "../lib/logger.js";
 
-export function registerOrchestrateCommand(program) {
+export function registerOrchestrateCommand(program, dependencies = {}) {
+  const evolutionCompositionFactory =
+    dependencies.evolutionCompositionFactory ?? null;
   const cmd = program
     .command("orchestrate [task]")
     .description(
@@ -122,13 +124,13 @@ export function registerOrchestrateCommand(program) {
 
     // --watch mode
     if (options.watch) {
-      await _watchMode(cwd, options);
+      await _watchMode(cwd, options, evolutionCompositionFactory);
       return;
     }
 
     // --webhook mode: start HTTP server to receive commands from IM platforms
     if (options.webhook) {
-      await _webhookMode(cwd, options);
+      await _webhookMode(cwd, options, evolutionCompositionFactory);
       return;
     }
 
@@ -177,6 +179,7 @@ export function registerOrchestrateCommand(program) {
         ? { provider: options.provider, model: options.model }
         : {},
       verbose: options.verbose,
+      evolutionCompositionFactory,
     });
 
     if (options.json) {
@@ -520,7 +523,7 @@ async function _showStatus(cwd, options) {
 
 // ─── Webhook mode (receive commands from IM platforms) ─────────────
 
-async function _webhookMode(cwd, options) {
+async function _webhookMode(cwd, options, evolutionCompositionFactory = null) {
   const { createServer } = await import("http");
   const { parseDingTalkIncoming, parseFeishuIncoming, parseWeComIncoming } =
     await import("../lib/notifiers/index.js");
@@ -529,7 +532,11 @@ async function _webhookMode(cwd, options) {
 
   const port = parseInt(options.webhookPort, 10) || 18820;
 
-  const orch = new Orchestrator({ cwd, verbose: options.verbose });
+  const orch = new Orchestrator({
+    cwd,
+    verbose: options.verbose,
+    evolutionCompositionFactory,
+  });
   const secretEnvironmentName =
     options.webhookSecretEnv || "CC_ORCHESTRATE_WEBHOOK_SECRET";
   if (!/^[A-Z_][A-Z0-9_]{0,127}$/u.test(secretEnvironmentName)) {
@@ -738,11 +745,15 @@ async function _webhookMode(cwd, options) {
 
 // ─── Watch mode ──────────────────────────────────────────────────
 
-async function _watchMode(cwd, options) {
+async function _watchMode(cwd, options, evolutionCompositionFactory = null) {
   const { Orchestrator } = await import("../lib/orchestrator.js");
   const intervalMs = parseInt(options.interval, 10) * 60_000 || 600_000;
 
-  const orch = new Orchestrator({ cwd, verbose: options.verbose });
+  const orch = new Orchestrator({
+    cwd,
+    verbose: options.verbose,
+    evolutionCompositionFactory,
+  });
   orch.startCronWatch(intervalMs);
 
   orch.on("cron:tick", ({ at }) => {

package/src/data/changelog.json

@@ -1,6 +1,32 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.29",
+      "cliVersions": ["0.166.26", "0.166.29"],
+      "date": "2026-09-06",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.29: recover long-running agent tasks",
+          "body": "> `chainlesschain` **0.166.26 -> 0.166.29** (2026-09-06). VS Code and\n> JetBrains plugin updates will follow after this CLI version is publicly\n> installable and verified.\n\n- Track task progress separately from file coverage. Reading new files, updating\n  a TODO plan, or dispatching a sub-agent no longer counts as implementing the\n  user's task.\n- Share bounded exploration accounting between the main agent and sub-agents;\n  preserve the current plan, observed work, and delivered child findings across\n  compaction without widening a child agent's source-data access.\n- Prompt the agent to consolidate findings after sustained exploration, then\n  offer a one-turn recovery mode that removes broad-read and re-delegation\n  tools while keeping focused search, edits, and validation available.\n- Keep the repeated-read backstop for ignored recovery guidance, including when\n  planning calls are interleaved with the same EOF read.\n- Make IDE Stop reliable when chat state drifts: request interruption first,\n  terminate an unresponsive process after five seconds, and terminate\n  immediately on a second Stop. Late output from the old process is ignored.\n- Validate task recovery, parent/child accounting, compaction, Stop escalation,\n  and existing CLI/IDE contracts with 180 focused tests. Publication still\n  requires successful exact-commit CLI CI and CLI Strict Sandbox matrices."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.28",
+      "cliVersions": ["0.166.26", "0.166.28"],
+      "date": "2026-09-06",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.28: reduce repeated long-document output",
+          "body": "> `chainlesschain` **0.166.26 -> 0.166.28** (2026-09-06; incorporates the\n> unpublished 0.166.27 candidate), paired with\n> VS Code **0.37.85** and JetBrains **0.4.112**.\n\n- Direct task-count/status questions to current summary sections and local\n  aggregation, returning relevant rows, totals and source line numbers.\n- Budget script output after JSON escaping and explicitly report truncation\n  with guidance to retrieve missing sections instead of printing the file again.\n- Reference identical large command output while the original remains visible;\n  restore content after compaction. Every authorized command still executes.\n- Detect repeated large code/shell dumps across compaction and tool changes,\n  retaining recovery guidance and the incomplete-task backstop.\n- Validate with 80 focused regression tests; publication requires successful\n  CLI CI and CLI Strict Sandbox matrices for the exact release commit.\n- Regenerate the bundled changelog index so its entries match the canonical\n  release notes and package version before CI tests and packaging."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.26",

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

@@ -54,6 +54,7 @@ export async function handleCoworkTask(server, id, ws, message) {
       files,
       cwd: server.projectRoot || process.cwd(),
       llmOptions: {},
+      evolutionCompositionFactory: server.evolutionCompositionFactory ?? null,
       signal: ac.signal,
       ...(message.mcpSessionId ? { mcpSessionId: message.mcpSessionId } : {}),
       ...(useParallel
@@ -247,6 +248,7 @@ export async function handleOrchestrate(server, id, ws, message) {
       maxParallel: Math.min(parseInt(agents, 10) || 3, 10),
       ciCommand: ci,
       agents: strategy ? { strategy } : undefined,
+      evolutionCompositionFactory: server.evolutionCompositionFactory ?? null,
       verbose: false,
     });