chainlesschain 0.166.25 → 0.166.28

package/src/runtime/agent-core.js

@@ -16,7 +16,10 @@
 
 import fs from "fs";
 import path from "path";
-import { buildReadFilePage } from "../lib/read-file-page.js";
+import {
+  buildReadFilePage,
+  buildReadFileOutline,
+} from "../lib/read-file-page.js";
 import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
 import broker from "../lib/process-execution-broker/index.js";
 import os from "os";
@@ -24,6 +27,7 @@ import { createHash, randomUUID } from "node:crypto";
 import skillInvocationReceipt from "@chainlesschain/session-core/skill-invocation-receipt";
 import { isProxy } from "node:util/types";
 import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
+import { isEvolutionIngressFailure } from "../lib/model-failure-policy.js";
 
 const { startSkillInvocation, settleSkillInvocation } = skillInvocationReceipt;
 import sharedCodingAgentPolicy from "./coding-agent-policy.cjs";
@@ -1088,6 +1092,8 @@ Key behaviors:
 - For long-running commands (builds, full test suites, dev servers) set run_shell { run_in_background: true } to get a task_id back immediately, then poll output and completion with check_shell { task_id }. Kill a backgrounded server with check_shell { task_id, kill: true } when finished
 - When asked about git status, diff, log, or other repository operations, use the git tool instead of run_shell
 - When asked about files or code, use search_files to locate relevant sections, then read_file with offset/limit. Follow nextRead for large files. Reuse unchanged content already in context instead of repeatedly reading the same page; re-read when the file changes or the earlier content is no longer available.
+- Large task documents include a sampled outline with line numbers. Use it to locate relevant unfinished work and inspect those sections instead of scanning the entire document unless the task requires full coverage. File coverage and excerpts survive compaction; reading to EOF is not completing the user's task.
+- For task counts or completion status, search the named document for the latest status/summary table first, then read that section. Distinguish historical entries from current status and repository work from external acceptance. Once the relevant entries are verified, answer; do not read every implementation detail just to count tasks.
 - Before renaming or changing a symbol, use code_intelligence (action: references/definition) to find every real usage instead of guessing with text search. It degrades to "unavailable" when no language server is installed — fall back to search_files then.
 - After an edit, if the tool result includes a "newDiagnostics" array, you just introduced (or exposed) those errors/warnings — read them and fix before moving on. You can also run code_intelligence (action: diagnostics) on any file to check it on demand.
 - If a tool result includes a "subtreeInstructions" array, you just entered a subdirectory that carries its own cc.md/CLAUDE.md/AGENTS.md — treat that content as authoritative project rules for work in that subtree (it is injected once, the first time you touch the subtree).
@@ -1097,6 +1103,7 @@ Key behaviors:
 
 When the user's problem involves data processing, calculations, file operations, text parsing, API calls, web scraping, or any task that can be solved programmatically:
 - Proactively write and execute code using run_code tool
+- For long documents, scripts should filter/count locally and print only the relevant rows, totals and source line numbers. Do not print an entire file or repeatedly dump its prefix through run_code/run_shell; use read_file offset/limit for missing sections. Truncated output is not full-file evidence.
 - Choose the best language: Python for data/math/scraping, Node.js for JSON/API, Bash for system tasks
 - Missing Python packages are NOT auto-installed by default; the tool result tells you (and the user) how to opt in (settings runCode.autoInstall)
 - Scripts run from a temp file by default; pass persist:true to keep one in .chainlesschain/agent-scripts/ for reference
@@ -3633,6 +3640,7 @@ export async function executeTool(name, args, context = {}) {
       sessionBudget: context.sessionBudget || null,
       hostResourceBudget: context.hostResourceBudget || null,
       readFileCache: context.readFileCache || null,
+      readFileLoopGuard: context.readFileLoopGuard || null,
       // Effective contract of THIS loop (parent ceiling for a nested spawn) +
       // the MCP tool definitions this loop exposes (inheritable by a spawn).
       subAgentContract: context.subAgentContract || null,
@@ -5178,6 +5186,7 @@ async function executeToolInner(
     toolAdmission = null,
     hostResourceBudget = null,
     readFileCache = null,
+    readFileLoopGuard = null,
     unattendedActionPolicy = null,
     managedCheckpoint = false,
     fileMutationScope = null,
@@ -5253,61 +5262,79 @@ async function executeToolInner(
         });
       }
       const fileVersion = `${fileStat.size}:${fileStat.mtimeMs}:${fileStat.ctimeMs}`;
-      const cacheKey = JSON.stringify([
-        filePath,
-        args.offset ?? null,
-        args.limit ?? null,
-        args.column ?? null,
-        args.hashed === true,
-        args.raw === true,
-      ]);
-      const cached = readFileCache?.get(cacheKey);
-      if (cached?.fileVersion === fileVersion) {
-        // All permission checks ran before this point. A fresh stat still
-        // invalidates changed/deleted files; cache only bounded pages per run.
-        _recordFileObservation(filePath);
-        readFileCache.delete(cacheKey);
-        readFileCache.set(cacheKey, cached);
-        return attachDescriptor(
-          await _withSubtreeInstructions(
-            structuredClone(cached.page),
-            filePath,
-            cwd,
-            subtreeInstructionScope,
-          ),
-        );
-      }
-      const content = fs.readFileSync(filePath, "utf8");
-      // Record the mtime so a later edit can detect an external change that
-      // happened between this read and the edit (read-freshness guard).
       _recordFileObservation(filePath);
-      // Jupyter notebooks: render a compact cell listing (index/id/type/source,
-      // outputs summarized) so the model can find cells for notebook_edit
-      // without ingesting raw JSON / base64 output blobs. `raw:true` returns the
-      // underlying JSON. Non-.ipynb reads are unchanged.
-      const nbView =
-        args.raw !== true && /\.ipynb$/i.test(filePath)
-          ? renderNotebook(content)
-          : null;
-      // Hashline mode: prefix each line with a 6-char content hash tag
-      // so downstream edit_file_hashed calls can anchor by hash.
-      const rendered =
-        nbView || (args.hashed === true ? annotateLines(content) : content);
-      const page = buildReadFilePage(rendered, args, {
-        filePath,
-        fileVersion,
-        maxChars: MAX_TOOL_RESULT_CHARS,
-      });
-      if (nbView) page.notebook = true;
-      if (readFileCache && !page.error) {
-        readFileCache.delete(cacheKey);
-        readFileCache.set(cacheKey, {
+      let rendered;
+      let nbView;
+      let outline;
+      const render = () => {
+        if (rendered !== undefined) return rendered;
+        const content = fs.readFileSync(filePath, "utf8");
+        nbView =
+          args.raw !== true && /\.ipynb$/i.test(filePath)
+            ? renderNotebook(content)
+            : null;
+        rendered =
+          nbView || (args.hashed === true ? annotateLines(content) : content);
+        // Excerpts are data, never subtree instructions. Keep the index
+        // separate from read coverage so it cannot claim the file was read.
+        outline =
+          ((args.offset == null && args.limit == null) ||
+            Number(args.limit) >= 2000) &&
+          content.length > MAX_TOOL_RESULT_CHARS &&
+          /\.(?:md|mdx|txt)$/i.test(filePath)
+            ? buildReadFileOutline(content)
+            : null;
+        return rendered;
+      };
+      const readPage = (request) => {
+        const cacheKey = JSON.stringify([
+          filePath,
+          request.offset ?? null,
+          request.limit ?? null,
+          request.column ?? null,
+          args.hashed === true,
+          args.raw === true,
+        ]);
+        const cached = readFileCache?.get(cacheKey);
+        if (cached?.fileVersion === fileVersion)
+          return structuredClone(cached.page);
+        render();
+        const page = buildReadFilePage(rendered, request, {
+          filePath,
           fileVersion,
-          page: structuredClone(page),
+          // An unbounded large-document request starts with an index and a
+          // small preview. A task-specific search can then avoid a full scan.
+          maxChars:
+            outline && request.offset == null && request.limit == null
+              ? Math.min(MAX_TOOL_RESULT_CHARS, 12000)
+              : MAX_TOOL_RESULT_CHARS,
+          outline,
         });
-        while (readFileCache.size > 8)
-          readFileCache.delete(readFileCache.keys().next().value);
-      }
+        if (nbView) page.notebook = true;
+        if (readFileCache && !page.error) {
+          readFileCache.delete(cacheKey);
+          readFileCache.set(cacheKey, {
+            fileVersion,
+            page: structuredClone(page),
+          });
+          while (readFileCache.size > 8)
+            readFileCache.delete(readFileCache.keys().next().value);
+        }
+        return page;
+      };
+      const page = readFileLoopGuard
+        ? readFileLoopGuard.read(
+            args,
+            { filePath, fileVersion },
+            readPage,
+            (charOffset) => {
+              const prefix = render().slice(0, charOffset);
+              const offset = (prefix.match(/\n/g) || []).length + 1;
+              const column = charOffset - prefix.lastIndexOf("\n");
+              return readPage({ ...args, offset, column, limit: 2000 });
+            },
+          )
+        : readPage(args);
       return attachDescriptor(
         await _withSubtreeInstructions(
           page,
@@ -8203,6 +8230,7 @@ async function executeToolInner(
           });
         } catch (err) {
           if (
+            isEvolutionIngressFailure(err) ||
             err?.runtimeLedgerPersistence === true ||
             err?.workflowEffectOutcomeUnknown === true
           ) {
@@ -9202,7 +9230,7 @@ async function _executeRunCode(args, cwd) {
 
             return {
               success: true,
-              output: retryOutput.substring(0, 50000),
+              ...boundedCodeOutput(retryOutput),
               language: lang,
               duration: `${retryDuration}ms`,
               autoInstalled: [packageName],
@@ -9245,7 +9273,7 @@ async function _executeRunCode(args, cwd) {
     const duration = Date.now() - start;
     return {
       success: true,
-      output: output.substring(0, 50000),
+      ...boundedCodeOutput(output),
       language: lang,
       duration: `${duration}ms`,
       scriptPath: persist ? scriptPath : undefined,
@@ -9323,9 +9351,66 @@ export function capToolResultString(serialized, max = MAX_TOOL_RESULT_CHARS) {
   );
 }
 
+/** Leave room for JSON escaping and execution metadata, including the hint. */
+export function boundedCodeOutput(value) {
+  const output = String(value ?? "");
+  const budget = Math.max(0, MAX_TOOL_RESULT_CHARS - 4096);
+  let low = 0;
+  let high = Math.min(output.length, 50000);
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (JSON.stringify(output.slice(0, mid)).length <= budget) low = mid;
+    else high = mid - 1;
+  }
+  if (low === output.length) return { output };
+  if (low > 0 && /[\uD800-\uDBFF]/.test(output[low - 1])) low--;
+  return {
+    truncated: true,
+    outputChars: output.length,
+    returnedChars: low,
+    hint: "Only an output prefix is shown. Do not rerun the same full-file print: filter/count locally and print a bounded summary with source line numbers, or use read_file with offset/limit for a missing section. This prefix is not evidence of the entire file.",
+    output: output.slice(0, low),
+  };
+}
+
 /** Avoid injecting the same file page twice while its original is still visible. */
 export function toolResultForModel(tool, result, messages) {
   const serialized = capToolResultString(safeStringifyToolResult(result));
+  if (
+    (tool === "run_code" || tool === "run_shell") &&
+    !result?.error &&
+    typeof result?.output === "string" &&
+    result.output.length >= 8000
+  ) {
+    const callIds = new Set(
+      messages.flatMap((message) =>
+        (message.tool_calls || [])
+          .filter((call) => call.function?.name === tool)
+          .map((call) => call.id),
+      ),
+    );
+    const previous = messages.find((message) => {
+      if (message.role !== "tool" || !callIds.has(message.tool_call_id))
+        return false;
+      try {
+        const prior = JSON.parse(message.content.split("\n\n[Budget ")[0]);
+        return !prior.error && prior.output === result.output;
+      } catch {
+        return false;
+      }
+    });
+    if (previous) {
+      return capToolResultString(
+        safeStringifyToolResult({
+          ...result,
+          output: undefined,
+          outputOmitted: true,
+          previousToolCallId: previous.tool_call_id,
+          hint: "This command executed again and returned the same large output already visible in the referenced tool result. Reuse that output; filter/count locally or read a specific missing section instead of dumping it again. This does not establish that files or other command side effects are unchanged.",
+        }),
+      );
+    }
+  }
   if (
     tool !== "read_file" ||
     result?.error ||
@@ -9523,6 +9608,7 @@ function _backgroundSubAgentResultText(entry) {
 function _throwBackgroundSubAgentUsageFailure(entry) {
   const error = entry?.outcome?.fatalError;
   if (
+    isEvolutionIngressFailure(error) ||
     error?.runtimeLedgerPersistence === true ||
     error?.workflowEffectOutcomeUnknown === true
   ) {
@@ -10473,7 +10559,8 @@ async function _executeSpawnSubAgent(args, ctx) {
           return {
             result: subCtx.result,
             error: err.message,
-            ...(err?.runtimeLedgerPersistence === true ||
+            ...(isEvolutionIngressFailure(err) ||
+            err?.runtimeLedgerPersistence === true ||
             err?.workflowEffectOutcomeUnknown === true
               ? { fatalError: err }
               : {}),
@@ -10608,6 +10695,7 @@ async function _executeSpawnSubAgent(args, ctx) {
     });
 
     if (
+      isEvolutionIngressFailure(err) ||
       err?.runtimeLedgerPersistence === true ||
       err?.workflowEffectOutcomeUnknown === true
     ) {
@@ -13708,6 +13796,7 @@ export async function* agentLoop(messages, options) {
   // rather than looping forever (the iteration budget is the hard backstop).
   let emptyThinkingReprompted = false;
   const readFileLoopGuard = new ReadFileLoopGuard();
+  toolContext.readFileLoopGuard = readFileLoopGuard;
 
   while (budget.hasRemaining()) {
     readFileLoopGuard.finishBatch();
@@ -13718,7 +13807,7 @@ export async function* agentLoop(messages, options) {
       );
       yield* _drainSubAgentUsage(subAgentUsageSink);
       const error = new Error(
-        "Repeated unchanged file reads: stopped after three tool batches made no new reading progress, including a recovery attempt. The task is not complete. Continue with a different file section or a targeted search.",
+        "Repeated file reads or identical large command outputs: the model did not resume the task after six no-progress batches and recovery guidance. The task is not complete. Use a targeted section or compute a bounded summary before retrying.",
       );
       error.code = "CC_AGENT_REPEATED_FILE_READ";
       throw error;
@@ -14275,11 +14364,74 @@ export async function* agentLoop(messages, options) {
     // prepareCall runs fresh each iteration and returns an ephemeral
     // system-message supplement that is NOT persisted to messages history.
     let callMessages = messages;
+    // Give a looping model a turn focused on search/action rather than another
+    // whole-file request. This changes discovery for one request only; runtime
+    // permissions are untouched and ordinary reads return on the next turn.
+    const readRecoveryTurn = readFileLoopGuard.takeRecoveryTurn();
+    const iterationToolOptions = readRecoveryTurn
+      ? {
+          ...effectiveToolOptions,
+          disabledTools: [
+            ...(effectiveToolOptions.disabledTools || []),
+            "read_file",
+          ],
+        }
+      : effectiveToolOptions;
+    const readContext = [
+      readFileLoopGuard.findingsHint,
+      readFileLoopGuard.progressHint,
+    ].filter(Boolean);
+    if (readContext.length) {
+      // Preserve the last conversational turn and never split a tool call
+      // from its results. Source data must neither become system authority
+      // nor create an assistant prefill / a new generic user request.
+      const resultIndex = messages.findLastIndex(
+        (message) => message.role === "tool",
+      );
+      if (resultIndex >= 0) {
+        const result = messages[resultIndex];
+        const original =
+          typeof result.content === "string"
+            ? result.content
+            : safeStringifyToolResult(result.content);
+        let content;
+        try {
+          const value = JSON.parse(original);
+          content = JSON.stringify({
+            ...value,
+            retainedReadContext: readContext,
+          });
+        } catch {
+          content = original + "\n\n" + readContext.join("\n\n");
+        }
+        // Enrich only the ephemeral copy. This preserves signed assistant
+        // thinking blocks, the last tool result, and the persisted transcript.
+        callMessages = messages.map((message, index) =>
+          index === resultIndex ? { ...result, content } : message,
+        );
+      } else {
+        // Full compaction can leave only the pinned request. Reiterate that
+        // exact request after the source data, not a replacement objective.
+        const request = messages.findLast((message) => message.role === "user");
+        callMessages = [
+          ...messages,
+          ...readContext.map((content) => ({ role: "assistant", content })),
+          {
+            role: "user",
+            content: request?.content || "Continue the original user task.",
+          },
+        ];
+      }
+    }
     const contextMemoryTrustedSystemIndexes = [];
-    if (readFileLoopGuard.progressHint) {
+    if (readRecoveryTurn) {
       callMessages = [
         ...callMessages,
-        { role: "system", content: readFileLoopGuard.progressHint },
+        {
+          role: "system",
+          content:
+            "File-read loop recovery: read_file is temporarily omitted for this model turn. Use the retained findings to choose a concrete next action or a focused search. Do not claim the user's task is complete merely because the file was read. Normal read_file availability resumes on the following turn.",
+        },
       ];
       contextMemoryTrustedSystemIndexes.push(callMessages.length - 1);
     }
@@ -14328,7 +14480,7 @@ export async function* agentLoop(messages, options) {
         {
           ...options,
           contextMemoryToolDefinitions:
-            getEffectiveToolDefinitions(effectiveToolOptions),
+            getEffectiveToolDefinitions(iterationToolOptions),
           contextMemoryTrustedSystemIndexes,
         },
       );
@@ -14358,13 +14510,13 @@ export async function* agentLoop(messages, options) {
     );
     const plannedProviderOptions = canonicalProviderContext?.plan
       ? {
-          ...effectiveToolOptions,
+          ...iterationToolOptions,
           contextEngine: null,
           contextMemoryPreplanned: true,
           contextMemorySelectedToolNames:
             canonicalProviderContext.selectedToolNames,
         }
-      : effectiveToolOptions;
+      : iterationToolOptions;
     const requestOptions = providerRequestId
       ? { ...plannedProviderOptions, providerRequestId }
       : plannedProviderOptions;
@@ -14538,6 +14690,29 @@ export async function* agentLoop(messages, options) {
     }
 
     const toolCalls = msg.tool_calls;
+    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+      // Allocate missing provider IDs once, before transcript insertion and
+      // any evidence or execution boundary. This is only local correlation,
+      // not a provider receipt or an exactly-once execution guarantee.
+      const usedIds = new Set();
+      for (const call of toolCalls) {
+        if (!call || typeof call !== "object") continue;
+        if (call.id == null || call.id === "") {
+          // Letter-only encoding retains UUID entropy without introducing
+          // number-like control IDs into sensitive-data classification.
+          const localId = randomUUID()
+            .replaceAll("-", "")
+            .replace(/[0-9]/g, (digit) =>
+              String.fromCharCode(103 + Number(digit)),
+            );
+          call.id = `cc_tool_${localId}`;
+        }
+        if (typeof call.id !== "string" || usedIds.has(call.id)) {
+          throw new Error("Malformed or duplicate tool call identity");
+        }
+        usedIds.add(call.id);
+      }
+    }
 
     if (!toolCalls || toolCalls.length === 0) {
       // A final answer while background sub-agents are still outstanding is
@@ -14694,7 +14869,7 @@ export async function* agentLoop(messages, options) {
 
     // Add assistant message with tool calls
     messages.push(msg);
-    readFileLoopGuard.startBatch(toolCalls.length);
+    readFileLoopGuard.startBatch();
 
     // Concurrent READ-ONLY batch (latency optimization). When every call in the
     // turn is a well-formed read-only built-in (pure fs/DB reads — no mutation,
@@ -15175,7 +15350,11 @@ export async function* agentLoop(messages, options) {
               "tool_error",
             );
           } catch (err) {
-            if (err?.runtimeLedgerPersistence === true) throw err;
+            if (
+              isEvolutionIngressFailure(err) ||
+              err?.runtimeLedgerPersistence === true
+            )
+              throw err;
             toolResult = {
               error: err.message,
               ...(workflowBinding

package/src/runtime/agent-runtime.js

@@ -379,6 +379,9 @@ export class AgentRuntime {
   }
 
   async startChatSession() {
+    if (this.evolutionIngress !== null) {
+      await this.evolutionIngress.start();
+    }
     this.emit(RUNTIME_EVENTS.RUNTIME_START, {
       kind: this.kind,
       policy: this.policy,
@@ -387,7 +390,23 @@ export class AgentRuntime {
       kind: this.kind,
       sessionId: this.policy.sessionId || null,
     });
-    return this.deps.startChatRepl(this.policy);
+    const result = await this.deps.startChatRepl({
+      ...this.policy,
+      ...(this.evolutionIngress === null
+        ? {}
+        : { evolutionIngress: this.evolutionIngress }),
+    });
+    if (this.evolutionIngress !== null) {
+      if (result?.schema === AGENT_EVOLUTION_SESSION_SCHEMA) {
+        return await waitForAgentEvolutionSession(
+          result,
+          this.evolutionIngress,
+        );
+      }
+      if (result?.started === false) return result;
+      await this.evolutionIngress.complete();
+    }
+    return result;
   }
 
   async startServer() {

package/src/runtime/runtime-factory.js

@@ -140,7 +140,7 @@ export function createAgentRuntimeFactory({
         kind: "chat",
         policy: resolveAgentPolicy({ config, overrides }),
         config,
-        deps,
+        deps: runtimeDeps,
       });
     },
 

package/src/assets/web-panel/assets/MarkdownRenderer-BxIIB4k3.js

@@ -1 +0,0 @@
-import{P as c,J as d,b as a}from"./vendor-Bn1JzzAn.js";import{r as s}from"./markdown-Yo_c6Krv.js";import{_ as p}from"./index-CXmpR6N3.js";const _={__name:"MarkdownRenderer",props:{content:{type:String,default:""}},setup(t,{expose:o}){o();const e=t,r=a(()=>s(e.content||"")),n={props:e,rendered:r,computed:a,get renderMarkdown(){return s}};return Object.defineProperty(n,"__isScriptSetup",{enumerable:!1,value:!0}),n}},i=["innerHTML"];function m(t,o,e,r,n,u){return c(),d("div",{class:"markdown-content",innerHTML:r.rendered},null,8,i)}const w=p(_,[["render",m],["__scopeId","data-v-0b0b9f63"],["__file","/tmp/cc-web-panel-d2aftn/repo/packages/web-panel/src/components/MarkdownRenderer.vue"]]);export{w as M};

package/src/assets/web-panel/assets/devWarning-DuGrUMAS.js

@@ -1 +0,0 @@
-import{Q as r}from"./index-CXmpR6N3.js";const o=((n,a,e)=>{r(n,`[ant-design-vue: ${a}] ${e}`)});export{o as d};

package/src/assets/web-panel/assets/index-DvFfMAux.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-DkPTQ2Gl.js";import{a0 as t}from"./index-CXmpR6N3.js";import"./vendor-Bn1JzzAn.js";import"./index-BxctzdYQ.js";import"./icons-DG5UD-6K.js";const s=t(o);export{s as default};

package/src/assets/web-panel/assets/index-n6p-1A77.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-DivbeDE-.js";import{a0 as t}from"./index-CXmpR6N3.js";import"./vendor-Bn1JzzAn.js";import"./responsiveObserve-DTD02LAO.js";import"./useFlexGapSupport-BeozAWOo.js";import"./styleChecker-CFWD63T-.js";import"./index-BxctzdYQ.js";import"./icons-DG5UD-6K.js";const l=t(o);export{l as default};