chainlesschain 0.166.26 → 0.166.28

package/src/lib/orchestrator.js

@@ -26,7 +26,9 @@ import crypto from "crypto";
 import { AgentRouter } from "./agent-router.js";
 import { NotificationManager } from "./notifiers/index.js";
 import { createChatFn } from "./cowork-adapter.js";
+import { captureAgentEvolutionRuntimeComposition } from "./evolution/agent-evolution-runtime-composition-brand.js";
 import { firstBalancedJson } from "./json-schema-output.js";
+import { isTerminalModelFailure } from "./model-failure-policy.js";
 import {
   assertCLILegacyMutationAllowed,
   cliLegacyRuntimeReadOnly,
@@ -58,6 +60,7 @@ export const TASK_STATUS = {
   CI_PASSED: "ci-passed",
   CI_FAILED: "ci-failed",
   RETRYING: "retrying",
+  FINALIZING: "finalizing",
   COMPLETED: "completed",
   FAILED: "failed",
 };
@@ -98,6 +101,15 @@ export class Orchestrator extends EventEmitter {
     this.maxRetries = options.maxRetries || 3;
     this.ciCommand = options.ciCommand || "npm test";
     this.verbose = options.verbose || false;
+    this._evolutionCompositionFactory =
+      options.evolutionCompositionFactory ?? null;
+    if (
+      this._evolutionCompositionFactory !== null &&
+      typeof this._evolutionCompositionFactory !== "function"
+    ) {
+      throw new TypeError("evolutionCompositionFactory must be a function");
+    }
+    this._llmOptions = options.llm || {};
 
     // Cap retained task history. Every addTask stores a record in _tasks and
     // nothing ever removes it, so a long-running orchestrator (cron-watch /
@@ -141,7 +153,7 @@ export class Orchestrator extends EventEmitter {
     this.notifier =
       options.notifier || NotificationManager.fromEnv(options.notify || {});
 
-    this._chat = createChatFn(options.llm || {});
+    this._chat = createChatFn(this._llmOptions);
     this._cronTimer = null;
 
     // Forward router events
@@ -210,7 +222,51 @@ export class Orchestrator extends EventEmitter {
         .catch(() => {});
     }
 
-    await this._orchestrate(task);
+    let evolutionComposition = null;
+    try {
+      if (this._evolutionCompositionFactory !== null) {
+        evolutionComposition = captureAgentEvolutionRuntimeComposition(
+          await this._evolutionCompositionFactory(
+            Object.freeze({
+              mode: "orchestrate",
+              runId: task.id,
+              taskId: task.id,
+              source: task.source,
+              cwd: task.cwd,
+            }),
+          ),
+        );
+        if (
+          evolutionComposition.runId !== task.id ||
+          evolutionComposition.evolutionIngress.runId !== task.id ||
+          evolutionComposition.evolutionIngress.tenantId !==
+            evolutionComposition.tenantId
+        ) {
+          const error = new Error(
+            "Orchestrator evolution composition is not bound to the requested Run",
+          );
+          error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+          throw error;
+        }
+        await evolutionComposition.evolutionIngress.start();
+        await evolutionComposition.evolutionIngress.ingestUserPrompt({
+          content: task.description,
+          context: task.context,
+          taskId: task.id,
+          source: `orchestrate:${task.source}`,
+        });
+      }
+    } catch (error) {
+      task.status = TASK_STATUS.FAILED;
+      task.error = error.message;
+      this.emit("task:failed", { task, error });
+      throw error;
+    }
+
+    await this._orchestrate(
+      task,
+      evolutionComposition?.evolutionIngress ?? null,
+    );
     return task;
   }
 
@@ -257,24 +313,22 @@ export class Orchestrator extends EventEmitter {
 
   // ─── Orchestration pipeline ──────────────────────────────────────
 
-  async _orchestrate(task) {
+  async _orchestrate(task, evolutionIngress = null) {
     assertCLILegacyMutationAllowed("Orchestrator._orchestrate");
     try {
       // Step 1: Decompose
-      task.subtasks = await this._decompose(task);
+      task.subtasks = await this._decompose(task, evolutionIngress);
       task.status = TASK_STATUS.DISPATCHED;
 
       // Step 2: Dispatch to Claude Code agents
-      task.agentResults = await this._dispatch(task);
+      task.agentResults = await this._dispatch(task, evolutionIngress);
       this._assertSuccessfulAgentResults(task);
 
       // Step 3: CI/CD check
       if (task.runCI) {
-        await this._ciLoop(task);
+        await this._ciLoop(task, evolutionIngress);
       } else {
-        task.status = TASK_STATUS.COMPLETED;
-        task.completedAt = new Date().toISOString();
-        this.emit("task:complete", task);
+        await this._completeTask(task, evolutionIngress);
       }
     } catch (err) {
       task.status = TASK_STATUS.FAILED;
@@ -284,8 +338,26 @@ export class Orchestrator extends EventEmitter {
     }
   }
 
+  async _completeTask(task, evolutionIngress, ciResult = null) {
+    assertCLILegacyMutationAllowed("Orchestrator._completeTask");
+    task.status = TASK_STATUS.FINALIZING;
+    if (evolutionIngress !== null) await evolutionIngress.complete();
+    if (ciResult !== null && this.notifier.isConfigured && task.notify) {
+      await this.notifier.notifySuccess({
+        taskId: task.id,
+        description: task.description.slice(0, 100),
+        agentCount: task.subtasks.length,
+        duration: Date.now() - new Date(task.createdAt).getTime(),
+        filesChanged: ciResult.filesChanged || [],
+      });
+    }
+    task.completedAt = new Date().toISOString();
+    task.status = TASK_STATUS.COMPLETED;
+    this.emit("task:complete", task);
+  }
+
   /** LLM-driven task decomposition into coding subtasks. */
-  async _decompose(task) {
+  async _decompose(task, evolutionIngress = null) {
     assertCLILegacyMutationAllowed("Orchestrator._decompose");
     task.status = TASK_STATUS.DECOMPOSING;
     this.emit("task:decomposing", task);
@@ -302,7 +374,14 @@ export class Orchestrator extends EventEmitter {
       (task.context ? `\nAdditional context:\n${task.context}` : "");
 
     try {
-      const raw = await this._chat(
+      const chat =
+        evolutionIngress === null
+          ? this._chat
+          : createChatFn({
+              ...this._llmOptions,
+              evolutionIngress,
+            });
+      const raw = await chat(
         [
           { role: "system", content: systemPrompt },
           { role: "user", content: userMsg },
@@ -317,7 +396,8 @@ export class Orchestrator extends EventEmitter {
       this.emit("task:decomposed", { task, subtasks });
       this._log(`Decomposed into ${subtasks.length} subtask(s)`);
       return subtasks;
-    } catch {
+    } catch (error) {
+      if (isTerminalModelFailure(error)) throw error;
       // Fallback: treat whole task as single subtask
       const fallback = [
         { id: "sub-1", description: task.description, context: task.context },
@@ -328,7 +408,7 @@ export class Orchestrator extends EventEmitter {
   }
 
   /** Dispatch subtasks to the Claude Code pool. */
-  async _dispatch(task) {
+  async _dispatch(task, evolutionIngress = null) {
     assertCLILegacyMutationAllowed("Orchestrator._dispatch");
     this.emit("agents:dispatched", { task, count: task.subtasks.length });
     this._log(
@@ -337,13 +417,14 @@ export class Orchestrator extends EventEmitter {
 
     const results = await this._router.dispatch(task.subtasks, {
       cwd: task.cwd,
+      ...(evolutionIngress === null ? {} : { evolutionIngress }),
     });
     this.emit("agents:complete", { task, results });
     return results;
   }
 
   /** Run CI command and retry loop. */
-  async _ciLoop(task) {
+  async _ciLoop(task, evolutionIngress = null) {
     assertCLILegacyMutationAllowed("Orchestrator._ciLoop");
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       task.status = TASK_STATUS.CI_CHECKING;
@@ -356,22 +437,10 @@ export class Orchestrator extends EventEmitter {
 
       if (ciResult.pass) {
         task.status = TASK_STATUS.CI_PASSED;
-        task.completedAt = new Date().toISOString();
         this.emit("ci:pass", { task });
         this._log(`CI passed for task ${task.id}`);
 
-        if (this.notifier.isConfigured && task.notify) {
-          await this.notifier.notifySuccess({
-            taskId: task.id,
-            description: task.description.slice(0, 100),
-            agentCount: task.subtasks.length,
-            duration: Date.now() - new Date(task.createdAt).getTime(),
-            filesChanged: ciResult.filesChanged || [],
-          });
-        }
-
-        task.status = TASK_STATUS.COMPLETED;
-        this.emit("task:complete", task);
+        await this._completeTask(task, evolutionIngress, ciResult);
         return;
       }
 
@@ -409,6 +478,7 @@ export class Orchestrator extends EventEmitter {
 
       task.agentResults = await this._router.dispatch(fixSubtasks, {
         cwd: task.cwd,
+        ...(evolutionIngress === null ? {} : { evolutionIngress }),
       });
       this._assertSuccessfulAgentResults(task);
       this.emit("agents:complete", { task, results: task.agentResults });

package/src/lib/read-file-loop-guard.js

@@ -34,6 +34,7 @@ export class ReadFileLoopGuard {
     this.repeatedBatches = 0;
     this.recoveryOfferedAt = 0;
     this.batch = null;
+    this.largeOutputs = new Set();
   }
 
   startBatch() {
@@ -152,6 +153,24 @@ export class ReadFileLoopGuard {
       if (result?.readRecovery?.action === "targeted-review")
         this.batch.advanced = true;
       if (result?.readProgress?.newContent === false) this.batch.duplicates++;
+    } else if (
+      (tool === "run_code" || tool === "run_shell") &&
+      typeof result?.output === "string" &&
+      result.output.length >= 8000
+    ) {
+      // Arbitrary code may just dump the same file again. Compare returned
+      // evidence, not code spelling or timings. Never cache/skip execution:
+      // identical stdout does not imply identical filesystem side effects.
+      const fingerprint = createHash("sha256")
+        .update(result.output)
+        .digest("hex");
+      if (this.largeOutputs.has(fingerprint)) this.batch.duplicates++;
+      else {
+        this.largeOutputs.add(fingerprint);
+        this.batch.advanced = true;
+        while (this.largeOutputs.size > 64)
+          this.largeOutputs.delete(this.largeOutputs.values().next().value);
+      }
     } else if (!DISCOVERY_TOOLS.has(tool)) {
       this.batch.substantive = true;
     }
@@ -163,6 +182,7 @@ export class ReadFileLoopGuard {
       this.repeatedBatches = 0;
       this.recoveryOfferedAt = 0;
       if (this.batch.substantive) {
+        this.largeOutputs.clear();
         for (const entry of this.progress.values()) entry.rereads.clear();
       }
     } else if (this.batch.duplicates) this.repeatedBatches++;
@@ -172,7 +192,7 @@ export class ReadFileLoopGuard {
 
   get recoveryHint() {
     return this.repeatedBatches >= 1
-      ? "Repeated unchanged file reads detected. The runtime continues unfinished scans automatically and returns use-findings after EOF. Use the retained file outline to locate the relevant work, then implement/verify the user's task. Do not restart a whole-file scan after context compaction. A targeted search does not itself complete the task."
+      ? "Repeated file reads or identical large command outputs detected. Do not switch to run_code/run_shell to dump the same file again. Filter/count locally and print only relevant rows, totals and source line numbers, or use a focused search. The runtime continues unfinished read_file scans automatically and returns use-findings after EOF. Use the retained outline to perform the user's task. Do not restart a whole-file scan after context compaction; answer once the requested evidence is sufficient."
       : null;
   }
 

package/src/lib/sub-agent-context.js

@@ -12,6 +12,8 @@ import crypto from "crypto";
 import { CLIContextEngineering } from "./cli-context-engineering.js";
 import { agentLoop, buildSystemPrompt, AGENT_TOOLS } from "./agent-core.js";
 import { feature } from "./feature-flags.js";
+import { isEvolutionIngressFailure } from "./model-failure-policy.js";
+import { captureAgentEvolutionIngress } from "./evolution/agent-evolution-ingress.js";
 import {
   createWorktree,
   removeWorktree,
@@ -589,7 +591,13 @@ export class SubAgentContext {
       }
       return result;
     } catch (err) {
-      if (err?.runtimeLedgerPersistence === true || this._workflowEffectId) {
+      if (
+        isEvolutionIngressFailure(err) ||
+        err?.runtimeLedgerPersistence === true ||
+        this._workflowEffectId
+      ) {
+        this.status = "failed";
+        this.completedAt = new Date().toISOString();
         throw err;
       }
       // If worktree creation fails (e.g. not a git repo), fall back to direct
@@ -875,12 +883,21 @@ export class SubAgentContext {
       options.approvalGate = this._approvalGate;
     }
 
+    const evolutionIngress =
+      options.evolutionIngress == null
+        ? null
+        : captureAgentEvolutionIngress(options.evolutionIngress);
+    if (evolutionIngress !== null) options.evolutionIngress = evolutionIngress;
+
     try {
       // Use a separate messages array for the agent loop
       // The agentLoop will append to this.messages directly
       const gen = agentLoop(this.messages, options);
 
       for await (const event of gen) {
+        if (evolutionIngress !== null) {
+          await evolutionIngress.ingestAgentEvent(event);
+        }
         this._iterationCount++;
 
         if (event.type === "run-started" && event.runId) {
@@ -1099,6 +1116,13 @@ export class SubAgentContext {
           this._tokenCount += Math.ceil((lastContent.length || 0) / 4);
         }
 
+        if (event.type === "run-ended" && event.reason !== "complete") {
+          this.forceComplete(event.reason || "unknown-terminal-reason", {
+            partialContent: lastContent,
+            artifacts,
+          });
+        }
+
         // Emit progress to consumer if callback provided
         if (this._onProgress) {
           try {
@@ -1161,7 +1185,13 @@ export class SubAgentContext {
         throw error;
       }
     } catch (err) {
-      if (err?.runtimeLedgerPersistence === true || this._workflowEffectId) {
+      if (
+        isEvolutionIngressFailure(err) ||
+        err?.runtimeLedgerPersistence === true ||
+        this._workflowEffectId
+      ) {
+        this.status = "failed";
+        this.completedAt = new Date().toISOString();
         throw err;
       }
       if (this.isAborted()) {
@@ -1295,6 +1325,8 @@ export class SubAgentContext {
             : "";
         this.result = {
           summary: `(Sub-agent force-completed: ${reason})${partialText}`,
+          incomplete: true,
+          completionReason: reason,
           artifacts: Array.isArray(partial.artifacts) ? partial.artifacts : [],
           tokenCount: this._tokenCount,
           toolsUsed: [...new Set(this._toolsUsed)],

package/src/repl/chat-repl.js

@@ -56,6 +56,8 @@ import { installPipeSafety } from "../runtime/pipe-safety.js";
 import { installOutputBackpressure } from "../runtime/output-backpressure.js";
 import { assertChatSessionUsageAdmission } from "../lib/chat-session-admission.js";
 import { captureAmbientExecutionLocation } from "../lib/execution-location-runtime.js";
+import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
+import { createAgentEvolutionSessionLifecycle } from "../lib/evolution/agent-evolution-session-lifecycle.js";
 
 const SLASH_COMMANDS = {
   "/exit": "Exit the chat",
@@ -94,9 +96,17 @@ const SLASH_COMMANDS = {
  * @param {object} options
  */
 export async function startChatRepl(options = {}) {
+  const evolutionIngress =
+    options.evolutionIngress == null
+      ? null
+      : captureAgentEvolutionIngress(options.evolutionIngress);
   const admittedSessionId = options.sessionId
     ? assertChatSessionUsageAdmission(options.sessionId)
     : null;
+  const evolutionSession =
+    evolutionIngress === null
+      ? null
+      : createAgentEvolutionSessionLifecycle(evolutionIngress);
   let model = options.model || "qwen2:7b";
   let provider = options.provider || "ollama";
   const baseUrl = options.baseUrl || "http://localhost:11434";
@@ -147,7 +157,9 @@ export async function startChatRepl(options = {}) {
     ),
   );
   try {
-    rl = readline.createInterface({
+    const createInterface =
+      options.createInterface || readline.createInterface.bind(readline);
+    rl = createInterface({
       input: options.input || process.stdin,
       output: stdout,
       prompt: chalk.green("you> "),
@@ -266,13 +278,20 @@ export async function startChatRepl(options = {}) {
       logger.verbose?.(`[@ref] expansion skipped: ${err.message}`);
     }
 
-    // Add user message
-    messages.push({ role: "user", content: userContent });
+    try {
+      if (evolutionIngress !== null) {
+        await evolutionIngress.ingestUserPrompt({
+          content: userContent,
+          sessionId,
+        });
+      }
 
-    // Stream the response
-    stdout.write(chalk.blue("ai>  "));
+      // Add user message
+      messages.push({ role: "user", content: userContent });
+
+      // Stream the response
+      stdout.write(chalk.blue("ai>  "));
 
-    try {
       let response;
       const onToken = (token) => {
         const accepted = stdout.write(token);
@@ -302,9 +321,19 @@ export async function startChatRepl(options = {}) {
       if (sessionId)
         appendEvent(sessionId, "user_message", { content: trimmed });
 
+      const providerMessages =
+        evolutionIngress === null
+          ? messages
+          : (
+              await evolutionIngress.prepareModelRequest({
+                messages,
+                tools: [],
+              })
+            ).messages;
+
       if (provider === "ollama") {
         response = await streamOllama(
-          messages,
+          providerMessages,
           model,
           baseUrl,
           onToken,
@@ -325,7 +354,7 @@ export async function startChatRepl(options = {}) {
             `API key required for anthropic (set ${providerDef?.apiKeyEnv || "ANTHROPIC_API_KEY"})`,
           );
         response = await streamAnthropic(
-          messages,
+          providerMessages,
           model,
           url,
           key,
@@ -348,7 +377,7 @@ export async function startChatRepl(options = {}) {
             `API key required for ${provider} (set ${providerDef?.apiKeyEnv || "API key"})`,
           );
         response = await streamOpenAI(
-          messages,
+          providerMessages,
           model,
           url,
           key,
@@ -358,6 +387,14 @@ export async function startChatRepl(options = {}) {
         );
       }
 
+      if (evolutionIngress !== null) {
+        await evolutionIngress.ingestAgentEvent({
+          type: "response-complete",
+          content: response,
+          sessionId,
+        });
+      }
+
       stdout.write("\n\n");
       messages.push({ role: "assistant", content: response });
 
@@ -410,6 +447,19 @@ export async function startChatRepl(options = {}) {
       : 0;
     disposePipeSafety();
     outputFlow.restore();
-    process.exit(exitCode);
+    if (evolutionSession !== null) {
+      try {
+        await evolutionSession.close(outputFailure);
+      } catch (error) {
+        outputFailure ||= error;
+      }
+    }
+    const finalExitCode = outputFailure
+      ? outputFailure.code === "EPIPE"
+        ? 0
+        : 1
+      : exitCode;
+    process.exit(finalExitCode);
   });
+  return evolutionSession?.handle;
 }