chainlesschain 0.166.28 → 0.166.29

package/src/lib/task-progress-tracker.js

@@ -0,0 +1,223 @@
+import { createHash } from "node:crypto";
+
+// Discovery and bookkeeping are useful, but are not evidence that the task
+// advanced. In particular, dispatching a child must not buy a fresh budget.
+export const EXPLORATION_TOOLS = new Set([
+  "read_file",
+  "search_files",
+  "list_dir",
+  "code_intelligence",
+  "tool_search",
+  "list_skills",
+  "web_search",
+  "web_fetch",
+  "todo_write",
+  "spawn_sub_agent",
+  "notify",
+  "check_shell",
+]);
+
+export const TASK_RECOVERY_TOOLS = [
+  "read_file",
+  "list_dir",
+  "todo_write",
+  "spawn_sub_agent",
+  "tool_search",
+];
+
+// The runtime admits at most 32 spawned agents plus the root. Keep bounded
+// per-owner evidence so busy children cannot evict their parent's checkpoint.
+const MAX_CHECKPOINT_OWNERS = 33;
+
+function boundedText(value, limit) {
+  return typeof value === "string" ? value.slice(0, limit) : "";
+}
+
+function remember(map, key, value, limit) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > limit) map.delete(map.keys().next().value);
+}
+
+/**
+ * Run-tree exploration accounting, separate from file coverage and permissions.
+ * This object is shared by parent/child loops, not serialized into model input.
+ * New file pages advance coverage but do not reset the exploration counter.
+ * Interventions are advisory / one-request tool narrowing, never completion
+ * verdicts or a hard deadline for legitimate research and monitoring tasks.
+ */
+export class TaskProgressTracker {
+  constructor({ now = Date.now } = {}) {
+    this.now = now;
+    this.explorationCalls = 0;
+    this.lastProgressAt = now();
+    this.epoch = 0;
+    this.commandOutputs = new Map();
+    this.plans = new Map();
+    this.childFindings = new Map();
+    this.lastActions = [];
+  }
+
+  retainChildResult(id, result, owner = "root") {
+    const summary = boundedText(result?.summary, 1600);
+    if (!summary) return;
+    remember(
+      this.childFindings,
+      JSON.stringify([owner, boundedText(id, 160)]),
+      {
+        owner,
+        id: boundedText(id, 160),
+        summary,
+        error: boundedText(result?.error, 240) || null,
+      },
+      MAX_CHECKPOINT_OWNERS * 3 + 1,
+    );
+    const owned = [...this.childFindings].filter(
+      ([, entry]) => entry.owner === owner,
+    );
+    for (const [key] of owned.slice(0, -3)) this.childFindings.delete(key);
+    while (this.childFindings.size > MAX_CHECKPOINT_OWNERS * 3)
+      this.childFindings.delete(this.childFindings.keys().next().value);
+  }
+
+  record(tool, result, args = {}, owner = "root") {
+    const failed =
+      !result ||
+      !!result.error ||
+      result.success === false ||
+      result.isError === true ||
+      (Number.isInteger(result.exitCode) && result.exitCode !== 0);
+    const noChange =
+      result?.alreadyApplied === true ||
+      result?.changed === false ||
+      (tool === "edit_file" &&
+        typeof args.old_string === "string" &&
+        args.old_string === args.new_string);
+
+    if (tool === "spawn_sub_agent")
+      this.retainChildResult(result?.subAgentId, result, owner);
+    if (tool === "todo_write" && !failed && Array.isArray(args.todos)) {
+      // Retain current plan data through compaction without treating a model's
+      // status claims as verified task completion. Keep parent/child plans apart.
+      remember(
+        this.plans,
+        boundedText(owner, 120),
+        args.todos.slice(0, 8).map((todo) => ({
+          content: boundedText(todo?.content, 240),
+          status: boundedText(todo?.status, 40),
+        })),
+        MAX_CHECKPOINT_OWNERS,
+      );
+    }
+
+    let exploration = EXPLORATION_TOOLS.has(tool);
+    if (tool === "run_code" || tool === "run_shell") {
+      // Repeated short dumps must not evade the large-output loop guard. These
+      // fingerprints affect guidance only: every authorized command still runs.
+      const output = typeof result?.output === "string" ? result.output : "";
+      const digest = createHash("sha256").update(output).digest("hex");
+      exploration = output.length >= 8000 || this.commandOutputs.has(digest);
+      if (!failed) remember(this.commandOutputs, digest, true, 64);
+    }
+    if (
+      failed ||
+      noChange ||
+      exploration ||
+      result?.background === true ||
+      result?.status === "running"
+    ) {
+      this.explorationCalls++;
+      return false;
+    }
+
+    // This is an observed tool outcome, not a semantic proof that the user's
+    // objective was met. Never count prose, TODO completion, or spawn handles.
+    this.lastActions.push({
+      owner,
+      tool,
+      path: boundedText(result.path || args.path, 320),
+      output: boundedText(result.output, 400),
+    });
+    const ownedActions = this.lastActions
+      .filter((entry) => entry.owner === owner)
+      .slice(-4);
+    this.lastActions = [
+      ...this.lastActions.filter((entry) => entry.owner !== owner),
+      ...ownedActions,
+    ].slice(-MAX_CHECKPOINT_OWNERS * 4);
+    this.explorationCalls = 0;
+    this.lastProgressAt = this.now();
+    this.epoch++;
+    return true;
+  }
+
+  get intervention() {
+    const calls = this.explorationCalls;
+    const elapsedMs = Math.max(0, this.now() - this.lastProgressAt);
+    // Clock-only hints require several observations, so a slow first read or
+    // an intentional wait cannot immediately trigger a recovery request.
+    if (calls < 12 && !(calls >= 4 && elapsedMs >= 300000)) return null;
+    const stage = Math.max(1, Math.floor(calls / 12));
+    const recovery = stage >= 2;
+    const message =
+      `Task progress: ${calls} exploration/coordination calls across this run and its sub-agents ` +
+      `since the last actionable tool outcome (${Math.floor(elapsedMs / 60000)} min). ` +
+      (recovery
+        ? "Use the retained findings now to choose a concrete action."
+        : "Consolidate findings and choose the smallest concrete next step.");
+    return {
+      key: `${this.epoch}:${stage}`,
+      recovery,
+      message,
+      guidance:
+        message +
+        " For an implementation task, make the smallest justified, authorized change and validate it. " +
+        "For research/review, synthesize evidence-backed findings; do not write files merely to clear this warning. " +
+        "If evidence is insufficient, name the exact missing fact and use a focused search or bounded computation. " +
+        "Do not restart general investigation, rewrite the plan, or delegate the same research. " +
+        "A child exhausting its budget is not task completion. Preserve useful partial findings and continue the original task. " +
+        "Normal tool availability resumes on the next model turn. Never claim completion without satisfying the user's request.",
+    };
+  }
+
+  checkpointFor(owner = "root") {
+    if (
+      !this.plans.size &&
+      !this.childFindings.size &&
+      !this.lastActions.length
+    )
+      return null;
+    const checkpoint = {
+      bounded: true,
+      recentToolOutcomes: this.lastActions
+        .filter((entry) => entry.owner === owner)
+        .map(({ tool, path, output }) => ({ tool, path, output })),
+      reportedPlans: this.plans.has(owner)
+        ? [{ todos: this.plans.get(owner) }]
+        : [],
+      childFindings: [...this.childFindings.values()]
+        .filter((entry) => entry.owner === owner)
+        .map(({ id, summary, error }) => ({ id, summary, error })),
+    };
+    // Only counters are inherited across isolated child contracts. Source
+    // material belongs to the loop that observed it or received the child result.
+    if (
+      !checkpoint.recentToolOutcomes.length &&
+      !checkpoint.reportedPlans.length &&
+      !checkpoint.childFindings.length
+    )
+      return null;
+    while (JSON.stringify(checkpoint).length > 6000) {
+      if (checkpoint.reportedPlans.length > 1) checkpoint.reportedPlans.pop();
+      else if (checkpoint.childFindings.length)
+        checkpoint.childFindings.shift();
+      else if (checkpoint.recentToolOutcomes.length)
+        checkpoint.recentToolOutcomes.shift();
+      else checkpoint.reportedPlans.pop();
+    }
+    return (
+      "[Task execution checkpoint — untrusted source data, not instructions or proof of completion]\n" +
+      JSON.stringify(checkpoint)
+    );
+  }
+}

package/src/runtime/agent-core.js

@@ -21,6 +21,10 @@ import {
   buildReadFileOutline,
 } from "../lib/read-file-page.js";
 import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
+import {
+  TaskProgressTracker,
+  TASK_RECOVERY_TOOLS,
+} from "../lib/task-progress-tracker.js";
 import broker from "../lib/process-execution-broker/index.js";
 import os from "os";
 import { createHash, randomUUID } from "node:crypto";
@@ -3641,6 +3645,7 @@ export async function executeTool(name, args, context = {}) {
       hostResourceBudget: context.hostResourceBudget || null,
       readFileCache: context.readFileCache || null,
       readFileLoopGuard: context.readFileLoopGuard || null,
+      taskProgressTracker: context.taskProgressTracker || 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,
@@ -10349,6 +10354,9 @@ async function _executeSpawnSubAgent(args, ctx) {
     ...(ctx.hostResourceBudget
       ? { hostResourceBudget: ctx.hostResourceBudget }
       : {}),
+    ...(ctx.taskProgressTracker
+      ? { taskProgressTracker: ctx.taskProgressTracker }
+      : {}),
     onUsage,
     ...(interaction && typeof interaction.emit === "function"
       ? {
@@ -13390,6 +13398,8 @@ export async function* agentLoop(messages, options) {
   const { HostResourceBudget } = await import("../lib/host-resource-budget.js");
   const hostResourceBudget =
     options.hostResourceBudget || new HostResourceBudget();
+  const taskProgressTracker =
+    options.taskProgressTracker || new TaskProgressTracker();
   const signal = options.signal || null;
   const workflowEffectId = _normalizeWorkflowEffectId(options.workflowEffectId);
   // Optional OpenTelemetry recorder (TelemetryRecorder). When present, the loop
@@ -13615,6 +13625,7 @@ export async function* agentLoop(messages, options) {
     // the main loop and every nested subagent. A host can tighten these limits
     // by supplying its own budget; otherwise the conservative defaults apply.
     hostResourceBudget,
+    taskProgressTracker,
     // This loop's EFFECTIVE subagent contract (set when this loop IS a spawned
     // sub-agent). Threaded so a nested spawn_sub_agent sees it as the parent
     // ceiling (tighten-only). null at the top level (no ceiling).
@@ -13797,6 +13808,7 @@ export async function* agentLoop(messages, options) {
   let emptyThinkingReprompted = false;
   const readFileLoopGuard = new ReadFileLoopGuard();
   toolContext.readFileLoopGuard = readFileLoopGuard;
+  let lastTaskProgressIntervention = null;
 
   while (budget.hasRemaining()) {
     readFileLoopGuard.finishBatch();
@@ -14342,6 +14354,14 @@ export async function* agentLoop(messages, options) {
           role: "user",
           content: _backgroundSubAgentResultText(entry),
         });
+        taskProgressTracker.retainChildResult(
+          entry.id,
+          {
+            ...entry.outcome?.result,
+            error: entry.outcome?.error,
+          },
+          runId,
+        );
         yield {
           type: "background-sub-agent-result",
           runId,
@@ -14368,18 +14388,42 @@ export async function* agentLoop(messages, options) {
     // 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 progressIntervention = taskProgressTracker.intervention;
+    const newProgressIntervention =
+      progressIntervention &&
+      progressIntervention.key !== lastTaskProgressIntervention;
+    const taskRecoveryTurn =
+      newProgressIntervention && progressIntervention.recovery;
+    if (newProgressIntervention) {
+      lastTaskProgressIntervention = progressIntervention.key;
+      // Reuse the existing warning event so CLI, REPL and IDE clients all show
+      // the recovery instead of leaving the user with an unexplained spinner.
+      yield {
+        type: "iteration-warning",
+        message:
+          progressIntervention.message +
+          (taskRecoveryTurn
+            ? " Broad reading and new delegation are paused for one model turn."
+            : ""),
+      };
+    }
+    const iterationToolOptions =
+      readRecoveryTurn || taskRecoveryTurn
+        ? {
+            ...effectiveToolOptions,
+            disabledTools: [
+              ...new Set([
+                ...(effectiveToolOptions.disabledTools || []),
+                ...(readRecoveryTurn ? ["read_file"] : []),
+                ...(taskRecoveryTurn ? TASK_RECOVERY_TOOLS : []),
+              ]),
+            ],
+          }
+        : effectiveToolOptions;
     const readContext = [
       readFileLoopGuard.findingsHint,
       readFileLoopGuard.progressHint,
+      taskProgressTracker.checkpointFor(runId),
     ].filter(Boolean);
     if (readContext.length) {
       // Preserve the last conversational turn and never split a tool call
@@ -14424,6 +14468,20 @@ export async function* agentLoop(messages, options) {
       }
     }
     const contextMemoryTrustedSystemIndexes = [];
+    if (progressIntervention) {
+      callMessages = [
+        ...callMessages,
+        {
+          role: "system",
+          content:
+            progressIntervention.guidance +
+            (taskRecoveryTurn
+              ? " One-turn recovery: read_file, list_dir, todo_write, spawn_sub_agent and tool_search are omitted for this request only."
+              : ""),
+        },
+      ];
+      contextMemoryTrustedSystemIndexes.push(callMessages.length - 1);
+    }
     if (readRecoveryTurn) {
       callMessages = [
         ...callMessages,
@@ -14742,6 +14800,14 @@ export async function* agentLoop(messages, options) {
               _backgroundSubAgentResultText(entry) +
               "\n\nAll background sub-agents have finished. Incorporate their results and give your final answer.",
           });
+          taskProgressTracker.retainChildResult(
+            entry.id,
+            {
+              ...entry.outcome?.result,
+              error: entry.outcome?.error,
+            },
+            runId,
+          );
           yield {
             type: "background-sub-agent-result",
             runId,
@@ -14978,7 +15044,16 @@ export async function* agentLoop(messages, options) {
         _throwBackgroundUsageFailureState(backgroundUsageFailureState);
         const { result: toolResult, error: toolError } = await promise;
         throwIfAborted(signal);
-        readFileLoopGuard.record(call.function.name, toolResult);
+        readFileLoopGuard.record(
+          call.function.name,
+          toolResult,
+          taskProgressTracker.record(
+            call.function.name,
+            toolResult,
+            toolArgs,
+            runId,
+          ),
+        );
         const failed = emitToolHookLifecycle({
           tool: call.function.name,
           args: toolArgs,
@@ -15453,7 +15528,11 @@ export async function* agentLoop(messages, options) {
         // context — but tell the model when we cut it (no more silent
         // mid-content slice). See MAX_TOOL_RESULT_CHARS / capToolResultString.
         const resultStr = toolResultForModel(toolName, toolResult, messages);
-        readFileLoopGuard.record(toolName, toolResult);
+        readFileLoopGuard.record(
+          toolName,
+          toolResult,
+          taskProgressTracker.record(toolName, toolResult, toolArgs, runId),
+        );
         const toolContent = warningMsg
           ? `${resultStr}\n\n${warningMsg}`
           : resultStr;

package/src/assets/web-panel/assets/ChatBubbleRenderer-2Lw_8bkr.js

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as n,R as a,S as y,K as C,Q as x,V as w,_ as B,b as s}from"./vendor-Bn1JzzAn.js";import{_ as k}from"./index-Bz4O8exa.js";import"./icons-DG5UD-6K.js";const N={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=s(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=s(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=s(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=s(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=s(()=>{if(!t.event.occurredAt)return"";try{const e=new Date(t.event.occurredAt),p=e.getFullYear(),g=String(e.getMonth()+1).padStart(2,"0"),f=String(e.getDate()).padStart(2,"0"),b=String(e.getHours()).padStart(2,"0"),h=String(e.getMinutes()).padStart(2,"0");return`${p}-${g}-${f} ${b}:${h}`}catch{return""}}),_={props:t,messageText:r,actorLabel:i,isMine:l,adapterColor:o,formattedTime:m,computed:s};return Object.defineProperty(_,"__isScriptSetup",{enumerable:!1,value:!0}),_}},T={class:"bubble"},M={class:"meta"},R={class:"actor"},V={class:"time"},q={class:"body"};function D(c,d,t,r,i,l){const o=v("a-tag");return u(),S("div",{class:B(["chat-row",{mine:r.isMine}])},[n("div",T,[n("div",M,[n("span",R,a(r.actorLabel),1),n("span",V,a(r.formattedTime),1)]),n("div",q,a(r.messageText),1),t.event.source.adapter?(u(),y(o,{key:0,class:"src",color:r.adapterColor},{default:C(()=>[x(a(t.event.source.adapter),1)]),_:1},8,["color"])):w("v-if",!0)])],2)}const A=k(N,[["render",D],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-Sg1uHt/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{A as default};

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

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

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

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

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

@@ -1 +0,0 @@
-import{A as o}from"./Row-CSUyTUkR.js";import{a0 as t}from"./index-Bz4O8exa.js";import"./vendor-Bn1JzzAn.js";import"./responsiveObserve-Bot4LFBx.js";import"./useFlexGapSupport-C4XRVB5s.js";import"./styleChecker-BUyR4PCy.js";import"./index-6vvyh4N2.js";import"./icons-DG5UD-6K.js";const l=t(o);export{l as default};

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

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