@namzu/cli 38.2.0 → 39.0.0

package/dist/chunks/{chunk-A64X23MU.js → chunk-RQBT4RVE.js}

@@ -9342,7 +9342,7 @@ function codeFromMessage(message, status) {
   // a plain invalid request — which is not retryable, and which the
   // overflow rescue tests for by exact equality. The turn died holding
   // the remedy.
-  m.includes("too long for") || // The reference terminal's own wordings (its `context window` and
+  m.includes("too long for") || // Known wordings: `context window` and
   // `input length and max_tokens exceed context limit` matchers).
   // Only where the status cannot say otherwise: a 429, 5xx or 401 that
   // mentions the window is still a rate limit, a server fault or an auth
@@ -9781,14 +9781,14 @@ function revisionFileSegment(value) {
   return out;
 }
 __name(revisionFileSegment, "revisionFileSegment");
-function decodeRevisionFileSegment(segment) {
-  if (segment === "~empty")
+function decodeRevisionFileSegment(segment2) {
+  if (segment2 === "~empty")
     return "";
-  if (segment.length === 0)
+  if (segment2.length === 0)
     return null;
   let value = "";
-  for (let i = 0; i < segment.length; i++) {
-    const char = segment[i];
+  for (let i = 0; i < segment2.length; i++) {
+    const char = segment2[i];
     if (char === void 0)
       return null;
     if (char !== "~") {
@@ -9797,13 +9797,13 @@ function decodeRevisionFileSegment(segment) {
       value += char;
       continue;
     }
-    const escaped = segment.slice(i + 1, i + 5);
+    const escaped = segment2.slice(i + 1, i + 5);
     if (!/^[0-9a-f]{4}$/u.test(escaped))
       return null;
     value += String.fromCharCode(Number.parseInt(escaped, 16));
     i += 4;
   }
-  return revisionFileSegment(value) === segment ? value : null;
+  return revisionFileSegment(value) === segment2 ? value : null;
 }
 __name(decodeRevisionFileSegment, "decodeRevisionFileSegment");
 var DiskRevisionRecordStore = class {
@@ -10379,10 +10379,10 @@ var DiskSessionGoalStore = class extends SessionGoalStoreBase {
   }
   location(sessionId5) {
     const root = join4(this.config.rootDir, "goals");
-    const segment = revisionFileSegment(sessionId5);
+    const segment2 = revisionFileSegment(sessionId5);
     return {
-      legacyPath: join4(root, `${segment}.json`),
-      revisionsDir: join4(root, ".revisions", segment)
+      legacyPath: join4(root, `${segment2}.json`),
+      revisionsDir: join4(root, ".revisions", segment2)
     };
   }
   async put(record3) {
@@ -15849,8 +15849,8 @@ var OVERFLOW_BODY_PATTERNS = [
   // length" — so a pattern anchored on "exceeded" misses it entirely.
   /exceeds?\s+(?:the\s+)?(?:model'?s?\s+)?context\s+(?:length|window|size)/i,
   /context\s+(?:length|window|size)\s+exceed/i,
-  // The reference terminal's own list matches the bare phrase "context
-  // window". Here it must sit next to a verb that says the request did not
+  // The bare phrase "context
+  // window" is too broad on its own. Here it must sit next to a verb that says the request did not
   // fit ("larger than the model context window of N tokens"), so a 400 that
   // only names the window ("does not support this parameter with the 1M
   // context window beta") stays an invalid request. The same pattern lives in
@@ -23111,8 +23111,8 @@ var FILE_NAMES = new Set(PROTECTED_FILE_NAMES.map(fold));
 var NESTED = PROTECTED_NESTED_DIRECTORIES.map((sequence) => sequence.map(fold));
 function isProtectedPath(path2) {
   const segments = path2.split(/[\\/]+/).map(fold);
-  for (const segment of segments) {
-    if (DIRECTORIES.has(segment))
+  for (const segment2 of segments) {
+    if (DIRECTORIES.has(segment2))
       return true;
   }
   for (const sequence of NESTED) {
@@ -23345,10 +23345,10 @@ function checkTarget(program, args, spelled, word2, scope) {
 __name(checkTarget, "checkTarget");
 function hasParentAfterName(path2) {
   let named = false;
-  for (const segment of path2.split(/[\\/]+/)) {
-    if (segment === "" || segment === ".")
+  for (const segment2 of path2.split(/[\\/]+/)) {
+    if (segment2 === "" || segment2 === ".")
       continue;
-    if (segment === "..") {
+    if (segment2 === "..") {
       if (named)
         return true;
     } else
@@ -26011,6 +26011,298 @@ var Diff = class {
   }
 };
 
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+  let i;
+  for (i = 0; i < str1.length && i < str2.length; i++) {
+    if (str1[i] != str2[i]) {
+      return str1.slice(0, i);
+    }
+  }
+  return str1.slice(0, i);
+}
+__name(longestCommonPrefix, "longestCommonPrefix");
+function longestCommonSuffix(str1, str2) {
+  let i;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+    return "";
+  }
+  for (i = 0; i < str1.length && i < str2.length; i++) {
+    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+      return str1.slice(-i);
+    }
+  }
+  return str1.slice(-i);
+}
+__name(longestCommonSuffix, "longestCommonSuffix");
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  }
+  return newPrefix + string.slice(oldPrefix.length);
+}
+__name(replacePrefix, "replacePrefix");
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix) {
+    return string + newSuffix;
+  }
+  if (string.slice(-oldSuffix.length) != oldSuffix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  }
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+__name(replaceSuffix, "replaceSuffix");
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+__name(removePrefix, "removePrefix");
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+__name(removeSuffix, "removeSuffix");
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+__name(maximumOverlap, "maximumOverlap");
+function overlapCount(a, b) {
+  let startA = 0;
+  if (a.length > b.length) {
+    startA = a.length - b.length;
+  }
+  let endB = b.length;
+  if (a.length < b.length) {
+    endB = a.length;
+  }
+  const map = Array(endB);
+  let k = 0;
+  map[0] = 0;
+  for (let j = 1; j < endB; j++) {
+    if (b[j] == b[k]) {
+      map[j] = map[k];
+    } else {
+      map[j] = k;
+    }
+    while (k > 0 && b[j] != b[k]) {
+      k = map[k];
+    }
+    if (b[j] == b[k]) {
+      k++;
+    }
+  }
+  k = 0;
+  for (let i = startA; i < a.length; i++) {
+    while (k > 0 && a[i] != b[k]) {
+      k = map[k];
+    }
+    if (a[i] == b[k]) {
+      k++;
+    }
+  }
+  return k;
+}
+__name(overlapCount, "overlapCount");
+function segment(string, segmenter) {
+  const parts = [];
+  for (const segmentObj of Array.from(segmenter.segment(string))) {
+    const segment2 = segmentObj.segment;
+    if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment2)) {
+      parts[parts.length - 1] += segment2;
+    } else {
+      parts.push(segment2);
+    }
+  }
+  return parts;
+}
+__name(segment, "segment");
+function trailingWs(string, segmenter) {
+  if (segmenter) {
+    return leadingAndTrailingWs(string, segmenter)[1];
+  }
+  let i;
+  for (i = string.length - 1; i >= 0; i--) {
+    if (!string[i].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i + 1);
+}
+__name(trailingWs, "trailingWs");
+function leadingWs(string, segmenter) {
+  if (segmenter) {
+    return leadingAndTrailingWs(string, segmenter)[0];
+  }
+  const match2 = string.match(/^\s*/);
+  return match2 ? match2[0] : "";
+}
+__name(leadingWs, "leadingWs");
+function leadingAndTrailingWs(string, segmenter) {
+  if (!segmenter) {
+    return [leadingWs(string), trailingWs(string)];
+  }
+  if (segmenter.resolvedOptions().granularity != "word") {
+    throw new Error('The segmenter passed must have a granularity of "word"');
+  }
+  const segments = segment(string, segmenter);
+  const firstSeg = segments[0];
+  const lastSeg = segments[segments.length - 1];
+  const head2 = /\s/.test(firstSeg) ? firstSeg : "";
+  const tail = /\s/.test(lastSeg) ? lastSeg : "";
+  return [head2, tail];
+}
+__name(leadingAndTrailingWs, "leadingAndTrailingWs");
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/word.js
+var extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+var WordDiff = class extends Diff {
+  static {
+    __name(this, "WordDiff");
+  }
+  equals(left, right, options) {
+    if (options.ignoreCase) {
+      left = left.toLowerCase();
+      right = right.toLowerCase();
+    }
+    return left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      const segmenter = options.intlSegmenter;
+      if (segmenter.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = segment(value, segmenter);
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    const tokens = [];
+    let prevPart = null;
+    parts.forEach((part2) => {
+      if (/\s/.test(part2)) {
+        if (prevPart == null) {
+          tokens.push(part2);
+        } else {
+          tokens.push(tokens.pop() + part2);
+        }
+      } else if (prevPart != null && /\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part2);
+        } else {
+          tokens.push(prevPart + part2);
+        }
+      } else {
+        tokens.push(part2);
+      }
+      prevPart = part2;
+    });
+    return tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i) => {
+      if (i == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, "");
+      }
+    }).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
+    }
+    let lastKeep = null;
+    let insertion = null;
+    let deletion = null;
+    changes.forEach((change) => {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
+      } else {
+        if (insertion || deletion) {
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
+        }
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
+      }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
+    }
+    return changes;
+  }
+};
+var wordDiff = new WordDiff();
+function diffWords(oldStr, newStr, options) {
+  if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
+    return diffWordsWithSpace(oldStr, newStr, options);
+  }
+  return wordDiff.diff(oldStr, newStr, options);
+}
+__name(diffWords, "diffWords");
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
+  if (deletion && insertion) {
+    const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
+    const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
+    if (startKeep) {
+      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      const ws = leadingWs(insertion.value, segmenter);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      const ws = leadingWs(endKeep.value, segmenter);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
+    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
+    const deletionWsSuffix = trailingWs(deletion.value, segmenter);
+    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    const startKeepWsSuffix = trailingWs(startKeep.value, segmenter);
+    const deletionWsPrefix = leadingWs(deletion.value, segmenter);
+    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+__name(dedupeWhitespaceInChangeObjects, "dedupeWhitespaceInChangeObjects");
+var WordsWithSpaceDiff = class extends Diff {
+  static {
+    __name(this, "WordsWithSpaceDiff");
+  }
+  tokenize(value) {
+    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex) || [];
+  }
+};
+var wordsWithSpaceDiff = new WordsWithSpaceDiff();
+function diffWordsWithSpace(oldStr, newStr, options) {
+  return wordsWithSpaceDiff.diff(oldStr, newStr, options);
+}
+__name(diffWordsWithSpace, "diffWordsWithSpace");
+
 // ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/line.js
 var LineDiff = class extends Diff {
   static {
@@ -28833,7 +29125,7 @@ function evaluateRule(rule, toolName, toolInput, toolDef, compiledPattern, nameS
       if (rule.decision === "deny" || rule.decision === "review") {
         if (compiledPattern.test(subject))
           return rule.decision;
-        if (segments.some((segment) => compiledPattern.test(segment)))
+        if (segments.some((segment2) => compiledPattern.test(segment2)))
           return rule.decision;
         if (isUrl)
           return null;
@@ -28841,7 +29133,7 @@ function evaluateRule(rule, toolName, toolInput, toolDef, compiledPattern, nameS
       }
       if (opaque2)
         return null;
-      return segments.every((segment) => compiledPattern.test(segment)) ? "allow" : null;
+      return segments.every((segment2) => compiledPattern.test(segment2)) ? "allow" : null;
     }
     case "allow_by_tier": {
       if (toolDef?.tier && rule.tiers.includes(toolDef.tier)) {
@@ -34029,9 +34321,20 @@ var CompletionInbox = class {
    * `log` is optional and unresolved until it is actually needed (the
    * eviction-warning path in `hold()`), same reason as `LocalTaskScheduler`.
    */
-  constructor(log) {
+  constructor(log, options = {}) {
     this.log = log;
+    this.holdsTurnOpen = options.holdsTurnOpen !== false;
   }
+  /**
+   * Whether a turn about to end waits here for the tasks still running.
+   *
+   * `true` (the default) is the original contract: the turn parks at its settle
+   * point until the tasks it launched report back, so their results enter the
+   * same turn. `false` lets the turn end with them still running; the host owns
+   * their completion from then on (it keeps them alive and wakes the model when
+   * they end). Completions that have already arrived are delivered either way.
+   */
+  holdsTurnOpen;
   /**
    * Start listening.
    *
@@ -34207,6 +34510,14 @@ var CompletionInbox = class {
   get hasPendingWork() {
     return this.unheard.size > 0 || this.outstanding.size > 0;
   }
+  /**
+   * Whether the turn has a reason to wait at its settle point: anything
+   * pending when it {@link holdsTurnOpen}, else only a completion already in
+   * hand (waiting for its persistence gate).
+   */
+  get holdsTurn() {
+    return this.holdsTurnOpen ? this.hasPendingWork : this.unheard.size > 0;
+  }
   /**
    * Wait for the next completion, deadline or abort, whichever comes first.
    * Aborting releases only this waiter; work and undelivered results remain owned.
@@ -35093,7 +35404,7 @@ function awaitedJobGraceMs(remainingBeforeFinalizeMs) {
 }
 __name(awaitedJobGraceMs, "awaitedJobGraceMs");
 async function* holdForOutstandingWork(ctx, iterationNum, hasToolCalls2, deliverInbound) {
-  const inbox = ctx.completionInbox?.hasPendingWork ? ctx.completionInbox : void 0;
+  const inbox = ctx.completionInbox?.holdsTurn ? ctx.completionInbox : void 0;
   const jobs = ctx.awaitedJobs?.hasPendingWork ? ctx.awaitedJobs : void 0;
   if (!inbox && !jobs)
     return false;
@@ -35218,7 +35529,12 @@ function settleOutstandingWork(ctx) {
 __name(settleOutstandingWork, "settleOutstandingWork");
 function recordAbandonedWork(ctx) {
   const abandoned = ctx.completionInbox?.outstandingTaskIds ?? [];
-  if (abandoned.length > 0) {
+  if (abandoned.length > 0 && ctx.completionInbox?.holdsTurnOpen === false) {
+    ctx.log.info("Turn ended with delegated work left running in the background", {
+      [NAMZU.TURN_ID]: ctx.recorder.turnId,
+      "namzu.runtime.tasks": abandoned
+    });
+  } else if (abandoned.length > 0) {
     ctx.log.warn("Turn ended with delegated work still running", {
       [NAMZU.TURN_ID]: ctx.recorder.turnId,
       "namzu.runtime.tasks": abandoned
@@ -35357,11 +35673,11 @@ function tokenize2(text9) {
       out.push(whole);
     const segments = raw.split(/[/\\.:\-]+/).filter((s) => s.length > 0);
     if (segments.length > 1) {
-      for (const segment of segments) {
-        const lower = segment.toLowerCase();
+      for (const segment2 of segments) {
+        const lower = segment2.toLowerCase();
         if (!STOP_WORDS.has(lower) && lower !== whole)
           out.push(lower);
-        for (const part2 of splitIdentifier(segment))
+        for (const part2 of splitIdentifier(segment2))
           out.push(part2.toLowerCase());
       }
     } else {
@@ -57457,8 +57773,8 @@ var DiskMessageFeedbackStore = class {
       }
       ids.set(messageId4, messageId4);
     }
-    for (const segment of await records2.scanNames(this.revisionsDir(sessionId5), "")) {
-      const decoded = decodeRevisionFileSegment(segment);
+    for (const segment2 of await records2.scanNames(this.revisionsDir(sessionId5), "")) {
+      const decoded = decodeRevisionFileSegment(segment2);
       if (decoded === null)
         continue;
       const messageId4 = asMessageId(decoded);
@@ -61741,7 +62057,7 @@ async function resolveMcpEra(input) {
 __name(resolveMcpEra, "resolveMcpEra");
 
 // ../sdk/dist/version.js
-var VERSION2 = "52.7.0";
+var VERSION2 = "53.0.0";
 
 // ../sdk/dist/connector/mcp/client.js
 var MAX_LIST_PAGES = 100;
@@ -64915,8 +65231,6 @@ var PLAN_MODE_DOCTRINE = `## Plan mode
 You are in plan mode. Read, search and think; do not change anything. \`read\`, \`grep\`, \`glob\` and the other read-only tools work as usual, and you may keep a task list. Any \`edit\`, \`write\` or shell command that changes state will be refused, so do not attempt one.
 
 When you have understood the task, reply with the plan: what you would change, in which files, in what order, and what you would verify. Be concrete \u2014 name files and functions \u2014 and short enough to read in one screen. Then stop and wait; the user will leave plan mode to have the plan carried out, and that switch is their approval.`;
-var CODING_AGENT_HYPERMODE_DOCTRINE = `### Hypermode
-This session has hypermode on: treat delegation through \`Agent\` as the default for substantive work, not the exception. Before doing multi-step work yourself, ask whether an independent piece of it \u2014 a lookup, a draft, a check \u2014 could run as its own delegation, and prefer delegating it when the answer is yes. This changes only how eagerly you reach for \`Agent\` on work you would otherwise do inline; it does not mount a roster or start any delegation by itself. Agents in the same phase are launched in the same response, each with \`run_in_background: true\` when you mean to wait for them together; a phase is never started one agent at a time.`;
 
 // ../sdk/dist/manager/resident/learning.js
 import { createHash as createHash23 } from "node:crypto";
@@ -70148,6 +70462,15 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 		if (t === 'object') return typeof value.then === 'function' ? 'a promise' : 'an object';
 		return 'a ' + t;
 	}
+	function overBudget() {
+		return config.tokenLimit !== null && config.tokenLimit > 0 && spent.tokensUsed >= config.tokenLimit;
+	}
+	function budgetError() {
+		var e = new Error('Workflow token budget exceeded (' + spent.tokensUsed.toLocaleString('en-US') + ' / ' + config.tokenLimit.toLocaleString('en-US') + ' output tokens). Stopping further agent() calls. Agents already running will finish and their results are kept.');
+		e.name = 'WorkflowBudgetExceededError';
+		return e;
+	}
+	function isBudgetError(e) { return !!e && e.name === 'WorkflowBudgetExceededError'; }
 	async function agent(prompt, opts) {
 		if (typeof prompt !== 'string' || prompt.length === 0) {
 			throw new TypeError('agent(prompt, options?): the prompt must be a non-empty string, got ' + kind(prompt));
@@ -70156,6 +70479,7 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 		if (typeof o !== 'object' || Array.isArray(o)) {
 			throw new TypeError('agent(prompt, options?): options must be an object, got ' + kind(o));
 		}
+		if (overBudget()) throw budgetError();
 		var request = { prompt: prompt, cursor: cursor };
 		if (o.label != null) request.label = clean(o.label, 120);
 		if (o.phase != null) request.phase = clean(o.phase, 120);
@@ -70176,12 +70500,16 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 				throw new TypeError('parallel(thunks): item ' + (p + 1) + ' must be a function (wrap the work as () => agent(...)), got ' + kind(thunks[p]));
 			}
 		}
-		return Promise.all(thunks.map(function (t, n) {
+		var dropped = 0;
+		var results = await Promise.all(thunks.map(function (t, n) {
 			return Promise.resolve().then(t).catch(function (e) {
-				log('parallel item ' + (n + 1) + ' failed: ' + clean(e && e.message ? e.message : e, 300));
+				if (isBudgetError(e)) { dropped++; return null; }
+				log('Step ' + (n + 1) + ' stopped: ' + clean(e && e.message ? e.message : e, 300));
 				return null;
 			});
 		}));
+		if (dropped > 0) log('parallel: ' + dropped + (dropped === 1 ? ' item' : ' items') + ' dropped because the token budget is spent.');
+		return results;
 	}
 	async function pipeline(items) {
 		if (!Array.isArray(items)) {
@@ -70193,21 +70521,31 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 				throw new TypeError('pipeline(items, ...stages): stage ' + (s + 1) + ' must be a function, got ' + kind(stages[s]));
 			}
 		}
-		return Promise.all(items.map(async function (item, index) {
+		if (items.length > 0 && overBudget()) throw budgetError();
+		var dropped = 0;
+		var results = await Promise.all(items.map(async function (item, index) {
 			var value = item;
 			for (var i = 0; i < stages.length; i++) {
 				try {
-					value = await stages[i](value, index, item);
+					value = await stages[i](value, item, index);
 				} catch (e) {
-					log('pipeline item ' + (index + 1) + ' stopped at stage ' + (i + 1) + ': ' + clean(e && e.message ? e.message : e, 300));
+					if (isBudgetError(e)) { dropped++; return null; }
+					log('Item ' + (index + 1) + ' stopped at step ' + (i + 1) + ': ' + clean(e && e.message ? e.message : e, 300));
 					return null;
 				}
 				if (value === null || value === undefined) return null;
 			}
 			return value;
 		}));
+		if (dropped > 0) log('pipeline: ' + dropped + (dropped === 1 ? ' item' : ' items') + ' dropped because the token budget is spent.');
+		return results;
 	}
 	var budget = Object.freeze({
+		get total() { return config.tokenLimit; },
+		spent: function () { return spent.tokensUsed; },
+		remaining: function () {
+			return config.tokenLimit === null ? Infinity : Math.max(0, config.tokenLimit - spent.tokensUsed);
+		},
 		get tokensUsed() { return spent.tokensUsed; },
 		get tokenLimit() { return config.tokenLimit === null ? undefined : config.tokenLimit; },
 	});
@@ -70386,6 +70724,11 @@ var AGENT_CALL_KEYS = /* @__PURE__ */ new Set([
   "model",
   "effort"
 ]);
+function defaultAgentLabel(prompt, index) {
+  const label5 = prompt.slice(0, 60).replace(/\s+/g, " ").trim();
+  return label5.length > 0 ? label5 : `Agent ${index}`;
+}
+__name(defaultAgentLabel, "defaultAgentLabel");
 function integer4(name2, value, min, max) {
   if (!Number.isSafeInteger(value) || value < min || value > max) {
     throw new RangeError(`${name2} must be an integer between ${min} and ${max}.`);
@@ -70394,10 +70737,10 @@ function integer4(name2, value, min, max) {
 }
 __name(integer4, "integer");
 function resolveWorkflowLimits(limits = {}) {
-  const defaultConcurrency = Math.min(8, Math.max(1, cpus().length - 2));
+  const defaultConcurrency = Math.min(16, Math.max(2, cpus().length - 2));
   return {
     maxConcurrency: integer4("maxConcurrency", limits.maxConcurrency ?? defaultConcurrency, 1, 16),
-    maxAgents: integer4("maxAgents", limits.maxAgents ?? 200, 1, 1e3),
+    maxAgents: integer4("maxAgents", limits.maxAgents ?? 1e3, 1, 1e3),
     maxSourceBytes: integer4("maxSourceBytes", limits.maxSourceBytes ?? 256 * 1024, 1, 4 * 1024 * 1024),
     memoryLimitBytes: integer4("memoryLimitBytes", limits.memoryLimitBytes ?? 64 * 1024 * 1024, 16 * 1024 * 1024, 256 * 1024 * 1024),
     maxValueBytes: integer4("maxValueBytes", limits.maxValueBytes ?? 1024 * 1024, 1, 16 * 1024 * 1024),
@@ -70729,7 +71072,7 @@ var WorkflowRuntime = class {
       const queuedAt = now();
       const agent = {
         index,
-        label: call2.label || `Agent ${index}`,
+        label: call2.label || defaultAgentLabel(call2.prompt, index),
         prompt: call2.prompt,
         ...phase ? { phaseIndex: phase.index, phaseTitle: phase.title } : {},
         ...call2.agentType !== void 0 ? { agentType: call2.agentType } : {},
@@ -73518,7 +73861,7 @@ function pathOf(toolInput) {
   return void 0;
 }
 __name(pathOf, "pathOf");
-var REFERENCE_EVENT_NAMES = {
+var PASCAL_EVENT_NAMES = {
   user_prompt_submit: "UserPromptSubmit",
   session_start: "SessionStart",
   session_end: "SessionEnd",
@@ -73597,7 +73940,7 @@ function readShellHookJson(event, stdout) {
   if (typeof named !== "string") {
     return { invalid: "`hookSpecificOutput` is missing its `hookEventName`" };
   }
-  if (named !== event && named !== REFERENCE_EVENT_NAMES[event]) {
+  if (named !== event && named !== PASCAL_EVENT_NAMES[event]) {
     return {
       invalid: `\`hookSpecificOutput.hookEventName\` is "${named}" but this hook ran for ${event}`
     };
@@ -74206,7 +74549,7 @@ var AgentManager = class {
   }
   /**
    * The refusal for a delegation past the depth limit. It tells the model what
-   * to do instead (the reference terminal's rule): a bare limit leaves it
+   * to do instead: a bare limit leaves it
    * retrying the same spawn, while an instruction to do the work itself ends the
    * attempt. The limit is `AgentManagerConfig.maxDepth`; there is no env override.
    */
@@ -77294,17 +77637,17 @@ function planWalk(root, options) {
     });
   });
   const sets = matchers.flatMap((matcher) => matcher.set);
-  if (sets.some((set3) => set3.some((segment) => segment === ".."))) {
+  if (sets.some((set3) => set3.some((segment2) => segment2 === ".."))) {
     throw new Error("Expanded file walk pattern escapes its root");
   }
   const patternDepth = Math.max(1, ...sets.map((set3) => set3.includes(GLOBSTAR) ? Number.POSITIVE_INFINITY : set3.length));
   const maxDepth = Math.min(patternDepth, options.maxDepth === void 0 ? Number.POSITIVE_INFINITY : positiveInteger(options.maxDepth, "maxDepth"));
   const prefix = [];
   for (let index = 0; sets.length > 0; index += 1) {
-    const segment = sets[0]?.[index];
-    if (typeof segment !== "string" || !segment || segment === "." || sets.some((set3) => index >= set3.length - 1 || set3[index] !== segment))
+    const segment2 = sets[0]?.[index];
+    if (typeof segment2 !== "string" || !segment2 || segment2 === "." || sets.some((set3) => index >= set3.length - 1 || set3[index] !== segment2))
       break;
-    prefix.push(segment);
+    prefix.push(segment2);
   }
   const expressions = matchers.flatMap((matcher) => {
     const expression = matcher.makeRe();
@@ -77318,7 +77661,7 @@ function planWalk(root, options) {
     maxEntries: positiveInteger(options.maxEntries, "maxEntries"),
     maxVisitedEntries: positiveInteger(options.maxVisitedEntries ?? 2e4, "maxVisitedEntries"),
     includeHidden: options.includeHidden ?? false,
-    patterns: sets.map((set3) => set3.map((segment) => segment === GLOBSTAR ? null : typeof segment === "string" ? segment : { source: segment.source, flags: segment.flags }))
+    patterns: sets.map((set3) => set3.map((segment2) => segment2 === GLOBSTAR ? null : typeof segment2 === "string" ? segment2 : { source: segment2.source, flags: segment2.flags }))
   };
 }
 __name(planWalk, "planWalk");
@@ -77335,11 +77678,11 @@ function directoryMatcher(plan) {
     for (const name2 of relative10.split("/")) {
       const next = /* @__PURE__ */ new Set();
       for (const index of states) {
-        const segment = pattern[index];
-        if (segment === null) {
+        const segment2 = pattern[index];
+        if (segment2 === null) {
           if (plan.includeHidden || !name2.startsWith("."))
             next.add(index);
-        } else if (typeof segment === "string" ? segment === name2 : segment?.test(name2))
+        } else if (typeof segment2 === "string" ? segment2 === name2 : segment2?.test(name2))
           next.add(index + 1);
       }
       states = closure(next);
@@ -89911,17 +90254,17 @@ import { isAbsolute as isAbsolute13, join as join43, relative as relative8, sep
 // ../sdk/dist/tools/posix-path.js
 function normalizeSegments(path2) {
   const out = [];
-  for (const segment of path2.split("/")) {
-    if (segment === "" || segment === ".")
+  for (const segment2 of path2.split("/")) {
+    if (segment2 === "" || segment2 === ".")
       continue;
-    if (segment === "..") {
+    if (segment2 === "..") {
       if (out.length > 0 && out[out.length - 1] !== "..")
         out.pop();
       else
         out.push("..");
       continue;
     }
-    out.push(segment);
+    out.push(segment2);
   }
   return out;
 }
@@ -93244,6 +93587,7 @@ export {
   findPendingCheckpoint,
   isTerminalAgentTaskState,
   CompletionInbox,
+  formatCompletionNotification,
   buildAskUserQuestionTool,
   resolveTriggerThreshold,
   resolveContextWindow,
@@ -93276,6 +93620,8 @@ export {
   InMemorySessionTokenBudgetStore,
   DiskSessionCheckpointStore,
   createFileReadTracker,
+  diffWords,
+  structuredPatch,
   dryRunEdit,
   seedObservationLedger,
   toolResultInjectionGuardrail,
@@ -93357,7 +93703,6 @@ export {
   CODING_AGENT_WORKING_DOCTRINE,
   CODING_AGENT_DELEGATION_DOCTRINE,
   PLAN_MODE_DOCTRINE,
-  CODING_AGENT_HYPERMODE_DOCTRINE,
   projectResidentLearning,
   createResidentStepContributions,
   createResidentStepContext,
@@ -93437,4 +93782,4 @@ export {
   buildResidentToolEvidenceTools,
   createPalMessagingTools
 };
-//# sourceMappingURL=chunk-A64X23MU.js.map
+//# sourceMappingURL=chunk-RQBT4RVE.js.map