nolo-cli 0.158.0-alpha.1 → 0.158.0

package/{chunk-3TBHZPNG.js → chunk-TTVMMYVH.js}

@@ -2,7 +2,7 @@ import {
   DEVIN_CONNECT_URL,
   parseSseDataLineJson,
   parseSseDataLineObject
-} from "./chunk-3C2QLERX.js";
+} from "./chunk-KMDDG73K.js";
 import {
   applyChatCompletionDelta,
   applyResponsesToolEvent,
@@ -11,7 +11,7 @@ import {
   flushChatCompletionStream,
   providerHttpFailure,
   throwIfChatCompletionStreamFailed
-} from "./chunk-L6EQV5OC.js";
+} from "./chunk-7NKZA46B.js";
 import {
   readSseFrames
 } from "./chunk-HNUWUO75.js";
@@ -25,13 +25,13 @@ import {
 import {
   hasImageInRuntimeMessages,
   stripImagePartsFromMessages
-} from "./chunk-G2WP7VPD.js";
+} from "./chunk-YKTAUOS7.js";
 import {
   clipToolText,
   resolveAgentImageInputSupport,
   resolveHistoricalToolContentCap,
   resolveToolOutputProfile
-} from "./chunk-IYBIRCQV.js";
+} from "./chunk-6BNW7WC4.js";
 import {
   applyShapingCounts,
   attachProjectionFacts,
@@ -66,7 +66,7 @@ import {
   hashStablePrefixContent,
   resolveResponseGuidelines,
   resolveToolGuidedSections
-} from "./chunk-LV4LV2B4.js";
+} from "./chunk-DOBOKBKS.js";
 import {
   classifyUnparsableToolArgs,
   collectStablePromptPrefix,
@@ -90,22 +90,26 @@ import {
   toOpenAiCompatibleMessages,
   toResponsesTools,
   transferDowngradedToolTurnOrigin
-} from "./chunk-6TF64IF2.js";
+} from "./chunk-DI7ZFGDQ.js";
 import {
   BRIDGE_STREAM_MAX_CHARS,
   DEFAULT_READ_DIALOG_MAX_RESPONSE_CHARS,
+  DEFAULT_SUBTASK_MAX_TOOL_CALLS,
+  DEFAULT_SUBTASK_MAX_WALL_CLOCK_MS,
   NOLO_WORKSPACE_TOOL_NAMES,
   applyToolSurfaceConstraints,
   buildDialogReadEnvelope,
   buildNoloWorkspaceCommandArgs,
   buildNoloWorkspaceOpenAiTools,
+  buildSubtaskBudgetExhaustedContent,
   createStreamingDialogReadProjector,
+  createSubtaskBudgetTracker,
   noloPositiveIntegerString,
   noloStringArg,
   parseNoloWorkspaceToolArguments,
   readTextStreamUpToChars,
   resolveNoloDialogInput
-} from "./chunk-QLQ573SU.js";
+} from "./chunk-3M52COK5.js";
 import {
   buildDialogFallbackTitleFromUserInput
 } from "./chunk-2MBTWINN.js";
@@ -120,7 +124,7 @@ import {
   resolveEmptyAssistantFallbackMessage,
   resolveEmptyAssistantOutcome,
   resolveTruncatedReasoningTailLog
-} from "./chunk-C6FY7HWI.js";
+} from "./chunk-HEC32F3G.js";
 import {
   COMPACTION_SUMMARY_SCHEMA_VERSION,
   COMPACTION_SUMMARY_SYSTEM_PROMPT,
@@ -143,7 +147,7 @@ import {
   sha256Hex,
   truncateToolOutputForContext,
   withProviderCallTimingFields
-} from "./chunk-2MTE2PEH.js";
+} from "./chunk-ASSNAASW.js";
 import {
   clipCompactText
 } from "./chunk-5MMAK75Q.js";
@@ -153,6 +157,12 @@ import {
 import {
   isAbortError
 } from "./chunk-7DPNBQSV.js";
+import {
+  buildDialogSummaryLayer
+} from "./chunk-VEA7H5FG.js";
+import {
+  buildUserResponseLanguageContext
+} from "./chunk-4VJAC32I.js";
 import {
   canonicalizeToolName,
   canonicalizeToolNames
@@ -167,16 +177,16 @@ import {
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
-import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
 import {
   estimateTokenCount
 } from "./chunk-PSCNXBYA.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
 import {
   buildProviderAuthHeaders,
   buildProviderExecutionPlan
-} from "./chunk-SUKSWFLP.js";
+} from "./chunk-PIG2IUVZ.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
@@ -198,12 +208,6 @@ import {
 import {
   resolveNoloStateDir
 } from "./chunk-ZWQUWF6W.js";
-import {
-  buildDialogSummaryLayer
-} from "./chunk-VEA7H5FG.js";
-import {
-  buildUserResponseLanguageContext
-} from "./chunk-4VJAC32I.js";
 import {
   __export
 } from "./chunk-4VNS5WPM.js";
@@ -14050,8 +14054,11 @@ function detectExecShellSynchronousWarnings(command, shell) {
 }
 
 // packages/agent-runtime/workspaceShell.ts
-import { resolve } from "node:path";
+import { createWriteStream, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname, join as join4, resolve } from "node:path";
 import { spawn as spawnChildProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
 
 // packages/agent-runtime/runtimeCompat.ts
 import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
@@ -14987,39 +14994,168 @@ function truncateToolOutput(value, limit = 2e4, options) {
 ${tail}`;
 }
 var DEFAULT_MAX_STREAM_BUFFER_BYTES = 5 * 1024 * 1024;
-function readNodeStream(stream, maxBytes = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
+function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
   if (!stream) return Promise.resolve("");
+  const options = typeof maxBytesOrOptions === "number" ? { maxBytes: maxBytesOrOptions } : maxBytesOrOptions ?? {};
+  const maxBytes = typeof options.maxBytes === "number" && Number.isFinite(options.maxBytes) && options.maxBytes >= 0 ? options.maxBytes : DEFAULT_MAX_STREAM_BUFFER_BYTES;
+  const spillPath = asOptionalTrimmedString(options.spillPath);
+  const createSink = options.spillSinkFactory ?? ((path) => createWriteStream(path));
   return new Promise((resolveStream, rejectStream) => {
     const chunks2 = [];
     let totalBytes = 0;
     let settled = false;
+    let truncated = false;
+    let spillState = spillPath ? "idle" : "disabled";
+    let spillError = null;
+    let spillSink = null;
+    let sourcePausedForSpill = false;
+    let sinkFinished = false;
     const formatLimit = maxBytes >= 1024 * 1024 ? `${Math.round(maxBytes / (1024 * 1024))}MB` : `${Math.round(maxBytes / 1024)}KB`;
-    const finalize2 = (truncated = false) => {
+    const resumeSourceIfPaused = () => {
+      if (!sourcePausedForSpill) return;
+      sourcePausedForSpill = false;
+      try {
+        stream.resume?.();
+      } catch {
+      }
+    };
+    const markSpillFailed = (error) => {
+      if (spillState === "failed") return;
+      spillState = "failed";
+      if (!spillError) {
+        spillError = toErrorMessage(error);
+      }
+      const sink = spillSink;
+      spillSink = null;
+      if (sink) {
+        try {
+          sink.destroy?.();
+        } catch {
+        }
+      }
+      resumeSourceIfPaused();
+    };
+    const writeToSink = (buf) => {
+      const sink = spillSink;
+      if (!sink || spillState !== "open") return;
+      if (sink.destroyed === true) {
+        markSpillFailed(new Error("spill writable closed before finish"));
+        return;
+      }
+      let accepted = true;
+      try {
+        accepted = sink.write(buf) !== false;
+      } catch (error) {
+        markSpillFailed(error);
+        return;
+      }
+      if (!accepted && !sourcePausedForSpill) {
+        sourcePausedForSpill = true;
+        try {
+          stream.pause?.();
+        } catch {
+          sourcePausedForSpill = false;
+        }
+      }
+    };
+    const openSpill = (headChunks, crossingChunk) => {
+      if (!spillPath || spillState !== "idle") return;
+      let sink;
+      try {
+        mkdirSync2(dirname(spillPath), { recursive: true });
+        sink = createSink(spillPath);
+        sink.on("error", (error) => markSpillFailed(error));
+        sink.on("drain", () => {
+          if (settled) return;
+          resumeSourceIfPaused();
+        });
+        sink.on("finish", () => {
+          sinkFinished = true;
+        });
+        sink.on("close", () => {
+          if (sinkFinished || spillState !== "open") return;
+          markSpillFailed(new Error("spill writable closed before finish"));
+        });
+      } catch (error) {
+        spillState = "failed";
+        spillError = toErrorMessage(error);
+        spillSink = null;
+        return;
+      }
+      spillSink = sink;
+      spillState = "open";
+      for (const head3 of headChunks) writeToSink(head3);
+      writeToSink(crossingChunk);
+    };
+    const finalize2 = (wasTruncated) => {
       if (settled) return;
       settled = true;
-      let text2 = Buffer.concat(chunks2).toString("utf8");
-      if (truncated) {
-        text2 += `
+      const truncatedNow = wasTruncated || truncated;
+      const baseText = Buffer.concat(chunks2).toString("utf8");
+      const done4 = () => {
+        let text2 = baseText;
+        if (truncatedNow) {
+          const notes = [`output exceeded ${formatLimit} buffer limit`];
+          if (spillState === "ok") {
+            notes.push(`full output: ${spillPath}`);
+          } else if (spillPath) {
+            notes.push(
+              `spill failed${spillError ? ` (${spillError})` : ""}; output incomplete`
+            );
+          }
+          text2 += `
 
-[stream pipe truncated: output exceeded ${formatLimit} buffer limit]`;
+[stream pipe truncated: ${notes.join("; ")}]`;
+        }
+        resolveStream(text2);
+      };
+      const sink = spillSink;
+      if (!sink || spillState !== "open") {
+        done4();
+        return;
+      }
+      let closed = false;
+      const settleSink = (failed, error) => {
+        if (closed) return;
+        closed = true;
+        if (failed) {
+          markSpillFailed(error ?? new Error("spill write failed"));
+        } else if (spillState === "open") {
+          spillState = "ok";
+        }
+        done4();
+      };
+      if (sink.destroyed === true) {
+        settleSink(true, new Error("spill writable closed before finish"));
+        return;
+      }
+      sink.once("error", (error) => settleSink(true, error));
+      sink.once("finish", () => settleSink(false));
+      sink.once("close", () => {
+        settleSink(!sinkFinished, new Error("spill writable closed before finish"));
+      });
+      try {
+        sink.end?.();
+      } catch (error) {
+        settleSink(true, error);
       }
-      resolveStream(text2);
     };
     stream.on("data", (chunk) => {
       if (settled) return;
       const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (truncated) {
+        writeToSink(buf);
+        return;
+      }
       if (totalBytes + buf.length >= maxBytes) {
         const remaining = Math.max(0, maxBytes - totalBytes);
+        const headChunks = chunks2.slice();
         if (remaining > 0) {
           chunks2.push(buf.subarray(0, remaining));
         }
-        try {
-          if (typeof stream.destroy === "function") {
-            stream.destroy();
-          }
-        } catch {
-        }
-        finalize2(true);
+        totalBytes += buf.length;
+        truncated = true;
+        openSpill(headChunks, buf);
         return;
       }
       totalBytes += buf.length;
@@ -15028,6 +15164,19 @@ function readNodeStream(stream, maxBytes = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
     stream.on("error", (error) => {
       if (settled) return;
       settled = true;
+      const sink = spillSink;
+      spillSink = null;
+      if (!spillError) spillError = toErrorMessage(error);
+      if (spillState !== "failed" && spillState !== "disabled") {
+        spillState = "failed";
+      }
+      if (sink) {
+        try {
+          sink.destroy?.();
+        } catch {
+        }
+      }
+      resumeSourceIfPaused();
       rejectStream(error);
     });
     stream.on("end", () => finalize2(false));
@@ -15140,8 +15289,12 @@ async function runWorkspaceCommand(args2) {
     process.removeListener("SIGINT", cleanupChildOnHostSignal);
   };
   exitPromise.then(detachSignalCleanup, detachSignalCleanup);
-  const stdoutCapture = stdoutPromiseResult(readNodeStream(proc.stdout));
-  const stderrCapture = stdoutPromiseResult(readNodeStream(proc.stderr));
+  const stdoutCapture = stdoutPromiseResult(
+    readNodeStream(proc.stdout, { spillPath: join4(tmpdir(), `nolo-stream-${randomUUID()}.log`) })
+  );
+  const stderrCapture = stdoutPromiseResult(
+    readNodeStream(proc.stderr, { spillPath: join4(tmpdir(), `nolo-stream-${randomUUID()}-stderr.log`) })
+  );
   const killChild = (signal) => {
     if (detached && typeof proc.pid === "number") {
       try {
@@ -15550,11 +15703,11 @@ async function invokeCapability(capabilityOrName, input, ctx = {}) {
 }
 
 // packages/agent-runtime/localWorkspaceTools.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { createHash as createHash4 } from "node:crypto";
 import { lstat, mkdir, readdir as readdir2, readFile as readFile3, realpath, stat as stat3, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve4, sep } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve4, sep } from "node:path";
 import { spawn as spawnChildProcess3 } from "node:child_process";
 
 // packages/core/readRangeLedger.ts
@@ -16836,7 +16989,7 @@ function resolveRipgrepBinary(env = process.env) {
   const fromEnv = asOptionalTrimmedString(env.NOLO_BUNDLED_RG);
   if (fromEnv) {
     try {
-      if (existsSync3(fromEnv)) return fromEnv;
+      if (existsSync4(fromEnv)) return fromEnv;
     } catch {
     }
   }
@@ -16942,6 +17095,7 @@ ${tail}`,
   };
 }
 var READ_FILE_LEDGER_MAX_RECORDS = 64;
+var READ_FILE_LEDGER_MAX_KEYS = 256;
 async function readFileTool(args2) {
   const parsed = parseWorkspaceToolArguments(args2.call.arguments);
   const requestedPath = requireWorkspaceToolPath(parsed);
@@ -16980,6 +17134,8 @@ async function readFileTool(args2) {
     const retainedCap = resolveHistoricalToolContentCap("readFile", 0);
     const retained = filterRetainedLedgerRecords(entry.records, retainedCap);
     if (retained.length > 0 && isLineRangeCovered(requestRange, retained)) {
+      ledger.delete(relativePath);
+      ledger.set(relativePath, entry);
       return {
         content: `[readFile] ${relativePath} lines ${requestRange.startLine}-${requestRange.endLine} were already delivered earlier and the file is unchanged; not resending. Pass force:true to refetch.`,
         metadata: {
@@ -17012,10 +17168,16 @@ async function readFileTool(args2) {
     const persistedChars = truncatedRead.content.length + "\n\n[tool metadata]\n".length + JSON.stringify(metadata).length;
     const records = entry?.records ?? [];
     records.push({ ...requestRange, chars: persistedChars });
+    ledger.delete(relativePath);
     ledger.set(relativePath, {
       fingerprint,
       records: records.slice(-READ_FILE_LEDGER_MAX_RECORDS)
     });
+    while (ledger.size > READ_FILE_LEDGER_MAX_KEYS) {
+      const oldestKey = ledger.keys().next().value;
+      if (oldestKey === void 0) break;
+      ledger.delete(oldestKey);
+    }
   }
   return { content: truncatedRead.content, metadata };
 }
@@ -17028,7 +17190,7 @@ async function writeFileTool(args2) {
     requestedPath,
     ...args2.confirmExternalFileAccess ? { confirmExternalFileAccess: args2.confirmExternalFileAccess } : {}
   });
-  await mkdir(dirname(absolutePath), { recursive: true });
+  await mkdir(dirname2(absolutePath), { recursive: true });
   await writeFile(absolutePath, content, "utf8");
   const relativePath = normalizeWorkspaceRelativePath({
     workspaceRoot: resolve4(args2.workspaceRoot),
@@ -17485,7 +17647,7 @@ async function execShellTool(args2) {
   );
 }
 var LAUNCH_PROCESS_STREAM_RING_CHARS = 65536;
-var LAUNCH_PROCESS_STREAM_CAPTURE_MAX_CHARS = 4e6;
+var LAUNCH_PROCESS_STREAM_CAPTURE_MAX_CHARS = 1e6;
 function createLaunchProcessStreamCapture() {
   let ring = "";
   let full = null;
@@ -18709,7 +18871,7 @@ var normalizeContextBlockScopes = (legacyBlocks = void 0, scopes = void 0) => {
 };
 
 // packages/agent-runtime/localAutoCompaction.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 function toPlanCompressionMessages(history) {
   return history.map((message, index) => ({
     id: typeof message.id === "string" && message.id.length > 0 ? message.id : `local-${index}`,
@@ -18944,7 +19106,7 @@ async function maybeAutoCompactLocalHistory(args2) {
     };
   }
   emitPhase({ kind: "compaction-start" });
-  const compactionAttemptId = randomUUID();
+  const compactionAttemptId = randomUUID2();
   let compactionT0 = Date.now();
   let compactionInputTokens;
   let compactionPrevSummaryTokens;
@@ -19624,6 +19786,17 @@ async function runLocalAgentTurn(input) {
     observationBoundary.attachCallbacks(legacyCallbacks);
   }
   const loopTiming = createLoopTiming();
+  const subtaskBudgetClock = input.subtaskBudgetNow ?? (() => Date.now());
+  const subtaskBudgetLimits = {
+    maxToolCalls: input.subtaskMaxToolCalls ?? input.subtaskBudgetLimits?.maxToolCalls ?? DEFAULT_SUBTASK_MAX_TOOL_CALLS,
+    maxWallClockMs: input.subtaskMaxWallClockMs ?? input.subtaskBudgetLimits?.maxWallClockMs ?? DEFAULT_SUBTASK_MAX_WALL_CLOCK_MS
+  };
+  const subtaskBudgetTracker = input.runKind === "subtask" ? createSubtaskBudgetTracker({
+    limits: subtaskBudgetLimits,
+    now: subtaskBudgetClock,
+    // 墙钟从 run 开始计（含 provider 初始化与首轮前的准备）。
+    startedAtMs: subtaskBudgetClock()
+  }) : null;
   try {
     loopTiming.mark("turnStart", 0);
     let agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
@@ -19859,12 +20032,8 @@ async function runLocalAgentTurn(input) {
         `[nolo] rewrote ${stats.rewrittenToolCalls} tool calls in ${stats.rewrittenAssistantMessages} assistant messages and ${stats.rewrittenToolMessages} tool-result messages (bad arguments: truncated=${stats.badArguments.truncated}, malformed=${stats.badArguments.malformed}); persisted history untouched`
       );
     }
-    const supportsImages = resolveAgentImageInputSupport({
-      apiSource: agentConfig.apiSource,
-      provider: agentConfig.provider,
-      model: agentConfig.model,
-      hasVision: agentConfig.hasVision
-    });
+    const supportsImages = resolveAgentImageInputSupport(agentConfig);
+    let imageDowngradeEmitted = false;
     if (!supportsImages && hasImageInRuntimeMessages(messages)) {
       messages = filterImagePartsFromMessages(messages, false);
       emitLoopEvent(observationBoundary, {
@@ -19872,6 +20041,7 @@ async function runLocalAgentTurn(input) {
         reason: "no-vision",
         atMs: Date.now()
       });
+      imageDowngradeEmitted = true;
     }
     const prefixCount = builtMessages.prefixCount;
     const capToolMessage = (msg) => msg.role === "tool" && typeof msg.content === "string" ? {
@@ -19886,7 +20056,7 @@ async function runLocalAgentTurn(input) {
     });
     const userInputText = extractUserInputText(input.input);
     let toolCallCount = 0;
-    let result4;
+    let result4 = { content: "" };
     const usageLedger = createTurnUsageLedger({
       model: agentConfig.model,
       provider: agentConfig.provider,
@@ -19898,12 +20068,36 @@ async function runLocalAgentTurn(input) {
     if (initialCompactionUsage) usageLedger.addCompaction(initialCompactionUsage);
     let loopError;
     let round = 0;
+    let budgetExhaustion = null;
+    const executedToolNameLog = [];
+    const markBudgetExhausted = () => {
+      if (!subtaskBudgetTracker || budgetExhaustion) return;
+      const exhaustion = subtaskBudgetTracker.exhaustion();
+      if (!exhaustion) return;
+      budgetExhaustion = exhaustion;
+      emitLoopEvent(observationBoundary, {
+        kind: "budget-exhausted",
+        limit: exhaustion.limit,
+        atMs: exhaustion.atMs,
+        maxToolCalls: exhaustion.limits.maxToolCalls,
+        maxWallClockMs: exhaustion.limits.maxWallClockMs,
+        toolCallsExecuted: exhaustion.toolCallsExecuted,
+        elapsedMs: exhaustion.elapsedMs,
+        round
+      });
+    };
     let emptyAssistantRepairPending = false;
     let emptyAssistantRepairUsed = false;
     let reasoningEmptyRepairCount = 0;
     let skipFinalAppend = false;
     let partialContent = "";
     const progressGuard = createLocalLoopProgressGuard(input.progressGuardConfig);
+    const budgetAdmissionGate = () => {
+      if (!subtaskBudgetTracker) return true;
+      if (!subtaskBudgetTracker.isExhausted()) return true;
+      markBudgetExhausted();
+      return false;
+    };
     try {
       const provider = await resolveProviderOnce();
       const applyPendingInjections = () => {
@@ -19938,6 +20132,14 @@ async function runLocalAgentTurn(input) {
           roundBudgetWarningInjected = true;
         }
         const preparedMessages = prepareMessagesForProviderCall(transcript.working());
+        if (!supportsImages && hasImageInRuntimeMessages(preparedMessages.messages) && !imageDowngradeEmitted) {
+          emitLoopEvent(observationBoundary, {
+            kind: "image-downgraded",
+            reason: "no-vision",
+            atMs: Date.now()
+          });
+          imageDowngradeEmitted = true;
+        }
         const baseRequestMessages = filterImagePartsFromMessages(
           preparedMessages.messages,
           supportsImages
@@ -19972,6 +20174,9 @@ async function runLocalAgentTurn(input) {
           messages: requestMessages,
           toolsHash: safeToolNamesHash(agentTools)
         });
+        if (!budgetAdmissionGate()) {
+          break;
+        }
         result4 = await runCompleteWithTimeout({
           provider,
           messages: requestMessages,
@@ -20160,6 +20365,11 @@ ${reasoningTailLog}
         const slotResults = new Array(toolCalls.length);
         const runSingleTool = async ({ index, toolCall }) => {
           throwIfAborted(input);
+          if (!budgetAdmissionGate()) {
+            skippedToolCalls.push(toolCall);
+            return;
+          }
+          subtaskBudgetTracker?.recordToolCallExecuted();
           const { toolResult, toolExecMs } = await executeToolCall({
             input,
             toolCall,
@@ -20179,6 +20389,7 @@ ${reasoningTailLog}
             toolResult,
             toolExecMs
           };
+          executedToolNameLog.push(toolCall.function.name);
         };
         const commitSlot = (i) => {
           const toolCall = toolCalls[i];
@@ -20204,6 +20415,7 @@ ${reasoningTailLog}
             ...observedMetadata ? { tool_result_metadata: observedMetadata } : {}
           });
         };
+        const skippedToolCalls = [];
         const batches = partitionToolCallsIntoBatches(toolCalls);
         for (const batch of batches) {
           throwIfAborted(input);
@@ -20227,6 +20439,17 @@ ${reasoningTailLog}
           }
           if (batchError) throw batchError;
         }
+        for (const skipped of skippedToolCalls) {
+          transcript.pushTool({
+            role: "tool",
+            content: "[\u5B50\u4EFB\u52A1\u9884\u7B97\u4E0A\u9650\u5DF2\u89E6\u53D1] \u8BE5\u5DE5\u5177\u8C03\u7528\u672A\u6267\u884C\uFF1A\u5DF2\u8FBE\u5B50\u4EFB\u52A1\u9884\u7B97\u4E0A\u9650\uFF0C\u672C\u8F6E\u4E0D\u518D\u53D1\u8D77\u65B0\u7684\u5DE5\u5177\u8C03\u7528\u3002",
+            tool_call_id: skipped.id,
+            toolName: skipped.function.name
+          });
+        }
+        if (budgetExhaustion) {
+          break;
+        }
         const toolExecutionGuardVerdict = progressGuard.observeToolExecution(
           toolCalls,
           executedToolResults
@@ -20248,12 +20471,29 @@ ${reasoningTailLog}
           break;
         }
         await compaction.maybeCompactInLoop();
+        if (!budgetAdmissionGate()) {
+          break;
+        }
         loopTiming.mark("roundEnd", round);
         round += 1;
       }
     } catch (error) {
       loopError = error;
     }
+    if (budgetExhaustion) {
+      const previousContent = typeof result4?.content === "string" ? result4.content.trim() : "";
+      result4 = {
+        ...result4,
+        content: [
+          previousContent,
+          buildSubtaskBudgetExhaustedContent({
+            exhaustion: budgetExhaustion,
+            roundsCompleted: round,
+            recentToolNames: executedToolNameLog
+          })
+        ].filter((part) => part.length > 0).join("\n\n")
+      };
+    }
     if (loopError) {
       const turnMessages2 = transcript.persisted(
         sanitizedPersistedInput,
@@ -21704,7 +21944,7 @@ function buildLoadSkillExecutor(args2) {
     const { resolveSkillByName } = await import("./skillDiscovery-QC35EQY4.js");
     const resolved = resolveSkillByName(args2.cwd, name);
     if (!resolved) {
-      const { resolveBuiltinSkillByName } = await import("./builtinSkillRegistry-H3AY27TR.js");
+      const { resolveBuiltinSkillByName } = await import("./builtinSkillRegistry-LJV7FHNI.js");
       const builtin = resolveBuiltinSkillByName(name);
       if (builtin) {
         return {
@@ -21782,7 +22022,7 @@ function resolveSessionKey(args2) {
 }
 
 // packages/agent-runtime/devin/devinProvider.ts
-import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
 var CLIENT_NAME = "chisel";
 var CLIENT_VERSION = "3000.11.3";
 function writeVarint(fieldNum, value) {
@@ -21842,7 +22082,7 @@ function encodeDevinClientMetadata(token) {
   ]);
 }
 function devinId(id, purpose) {
-  return id?.sessionKey && isStableSessionIdentityEnabled() ? deriveStableUuid(id.sessionKey, purpose) : randomUUID2();
+  return id?.sessionKey && isStableSessionIdentityEnabled() ? deriveStableUuid(id.sessionKey, purpose) : randomUUID3();
 }
 function encodeDevinChatMessage(msg, identity2, index = 0) {
   const source = msg.role === "assistant" ? 2 : msg.role === "tool" ? 4 : 1;
@@ -21936,7 +22176,7 @@ ${item.text}`;
   const chatMessageBuffers = coalesced.map((m, i) => encodeDevinChatMessage(m, identity2, i));
   const completionConfig = buildCompletionConfig({ temperature });
   const modelConfig = Buffer.concat([
-    writeStringField(1, randomUUID2()),
+    writeStringField(1, randomUUID3()),
     writeVarint(2, 1),
     writeVarint(3, 4)
   ]);
@@ -21948,7 +22188,7 @@ ${item.text}`;
     writeMessageField(8, completionConfig),
     ...tools.map((tool) => writeMessageField(10, encodeDevinToolDefinition(tool))),
     writeMessageField(15, modelConfig),
-    writeStringField(16, randomUUID2()),
+    writeStringField(16, randomUUID3()),
     writeVarint(20, 1),
     writeStringField(21, model)
   ]);

package/{chunk-I2RMFLLH.js → chunk-V7PCFWX3.js}

@@ -1,6 +1,6 @@
 import {
   getModelConfig
-} from "./chunk-TRW43TSC.js";
+} from "./chunk-6EQD4AQL.js";
 import {
   isPlatformHostedDeepseekModel,
   isPlatformHostedOpenAIImageModel,