@wrongstack/core 0.296.4 → 0.298.0

package/dist/execution/index.js

@@ -514,7 +514,7 @@ var ConversationState = class {
       message._estTokens = computeMessageTokens(message);
     }
     this.ctx.messages.splice(this.ctx.messages.length, 0, message);
-    const overflow = this.overflowCount();
+    const overflow = this.overflowCount(this.ctx.messages);
     if (overflow > 0) {
       this.ctx.messages.splice(0, overflow);
       this.ctx.toolAdjacencyDirty = true;
@@ -534,8 +534,7 @@ var ConversationState = class {
    * content blocks.  It runs whenever the token cap is enabled; the count
    * cap determines the starting index for the sum but does not gate it.
    */
-  overflowCount() {
-    const arr = this.ctx.messages;
+  overflowCount(arr) {
     let drop = Context.MAX_MESSAGES > 0 ? Math.max(0, arr.length - Context.MAX_MESSAGES) : 0;
     if (Context.MAX_MESSAGE_TOKENS <= 0) return drop;
     let total = 0;
@@ -578,27 +577,30 @@ var ConversationState = class {
     for (const m of messages) {
       if (m._estTokens === void 0) {
         m._estTokens = computeMessageTokens(m);
-        if (Array.isArray(m.content)) {
-          for (const b of m.content) {
-            if (b.type === "tool_use" || b.type === "tool_result") {
-              hasToolBlock = true;
-              break;
-            }
+      }
+      if (!hasToolBlock && Array.isArray(m.content)) {
+        for (const b of m.content) {
+          if (b.type === "tool_use" || b.type === "tool_result") {
+            hasToolBlock = true;
+            break;
           }
         }
       }
     }
+    const overflow = this.overflowCount(messages);
+    const retained = overflow > 0 ? messages.slice(overflow) : messages;
+    if (overflow > 0) this.ctx.toolAdjacencyDirty = true;
     const arr = this.ctx.messages;
-    if (messages.length < arr.length) {
-      arr.length = messages.length;
+    if (retained.length < arr.length) {
+      arr.length = retained.length;
     }
-    for (let i = 0; i < messages.length; i++) {
-      arr[i] = messages[i];
+    for (let i = 0; i < retained.length; i++) {
+      arr[i] = retained[i];
     }
     if (hasToolBlock) {
       this.ctx.toolAdjacencyDirty = true;
     }
-    this.emit({ kind: "messages_replaced", messages: [...messages] });
+    this.emit({ kind: "messages_replaced", messages: [...retained] });
   }
   replaceTodos(todos) {
     const allDone = todos.length > 0 && todos.every((t) => t.status === "completed");
@@ -656,7 +658,7 @@ var Context = class _Context {
    * (e.g., during a /rewind, provider error storm, or custom embedder).
    * Set to 0 for unlimited (legacy/test behaviour).
    */
-  static MAX_MESSAGES = 2e3;
+  static MAX_MESSAGES = 1e3;
   /**
    * Companion size cap on the same history, in estimated tokens.
    *
@@ -666,12 +668,12 @@ var Context = class _Context {
    * conversation, reached without ever tripping the count cap. Both caps guard
    * the same failure — compaction not running — so both belong here.
    *
-   * 8M tokens is roughly 32M characters, i.e. ~64 MB of text before JS object
-   * overhead. That is ~40x a full 200k-token context window, so this never
-   * engages while compaction is doing its job; it only bounds the runaway.
+   * 1M tokens is roughly 4M characters, i.e. ~8 MB of UTF-16 text before JS
+   * object overhead. That is still 5x a full 200k-token context window, so normal
+   * compaction runs first; a broken compactor cannot retain tens of millions of characters.
    * Set to 0 for unlimited (legacy/test behaviour).
    */
-  static MAX_MESSAGE_TOKENS = 8e6;
+  static MAX_MESSAGE_TOKENS = 1e6;
   /**
    * Hard cap on distinct tracked-file paths retained in memory per session.
    * Past this limit the oldest (least-recently-entered) path is dropped.
@@ -3103,7 +3105,7 @@ var DefaultLogger = class _DefaultLogger {
         root.pendingFileWrites += 1;
         root.pendingFileBytes += bytes;
         this.enqueueRotate(this.file);
-        this._tail = this._tail.then(() => fsp.appendFile(this.file, line)).catch(() => void 0).finally(() => {
+        this._tail = this._tail.then(() => fsp.appendFile(this.file, line, { mode: 384 })).catch(() => void 0).finally(() => {
           root.pendingFileWrites = Math.max(0, root.pendingFileWrites - 1);
           root.pendingFileBytes = Math.max(0, root.pendingFileBytes - bytes);
         });
@@ -4362,30 +4364,6 @@ function kindToCode(kind) {
   return KIND_TO_CODE[kind];
 }
 
-// src/core/model-ref.ts
-function parseModelRef(ref) {
-  const trimmed = ref.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash !== -1) {
-    return {
-      provider: trimmed.slice(0, slash) || void 0,
-      model: trimmed.slice(slash + 1).trim()
-    };
-  }
-  const parts = trimmed.split(/\s+/);
-  if (parts.length >= 2) {
-    return { provider: parts[0], model: parts.slice(1).join(" ") };
-  }
-  return { model: trimmed };
-}
-function formatModelRef(ref, defaultProvider) {
-  const provider = ref.provider ?? defaultProvider;
-  return provider ? `${provider}/${ref.model}` : ref.model;
-}
-function normalizeModelRef(ref, defaultProvider) {
-  return formatModelRef(parseModelRef(ref), defaultProvider);
-}
-
 // src/core/model-availability-calendar.ts
 function logicalCalendarTarget(providerId, model) {
   if (providerId !== "omniroute") return { providerId, model };
@@ -4464,6 +4442,30 @@ function evaluateModelCalendar(rules, providerId, model, at = /* @__PURE__ */ ne
   return { allowed: true };
 }
 
+// src/core/model-ref.ts
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+function formatModelRef(ref, defaultProvider) {
+  const provider = ref.provider ?? defaultProvider;
+  return provider ? `${provider}/${ref.model}` : ref.model;
+}
+function normalizeModelRef(ref, defaultProvider) {
+  return formatModelRef(parseModelRef(ref), defaultProvider);
+}
+
 // src/core/fallback-profile-manager.ts
 function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -4564,18 +4566,42 @@ var FallbackProfileManager = class {
    * Mirrors the previous `effectiveFallbackChain()` logic but centralized.
    */
   resolveEffective(opts = {}) {
+    const bridge = this.resolveBridge(opts.exclude);
+    let selected = FREEZER_EMPTY;
     if (opts.fallbackModels && opts.fallbackModels.length > 0) {
       const resolved = this.resolveRefs(opts.fallbackModels, opts.exclude);
-      if (resolved.length > 0) return resolved;
+      if (resolved.length > 0) selected = resolved;
     }
-    if (opts.fallbackProfile) {
+    if (selected.length === 0 && opts.fallbackProfile) {
       const resolved = this.resolve(opts.fallbackProfile, { exclude: opts.exclude });
-      if (resolved.length > 0) return resolved;
+      if (resolved.length > 0) selected = resolved;
     }
-    if (opts.fallbackAuto !== false) {
-      return this.smartDefault(opts.exclude);
+    if (selected.length === 0 && opts.fallbackAuto !== false) {
+      selected = this.smartDefault(opts.exclude);
     }
-    return FREEZER_EMPTY;
+    if (bridge.length === 0) return selected;
+    if (selected.length === 0) return bridge;
+    const seen = new Set(bridge.map((entry) => `${entry.providerId}/${entry.model}`));
+    return Object.freeze([
+      ...bridge,
+      ...selected.filter((entry) => !seen.has(`${entry.providerId}/${entry.model}`))
+    ]);
+  }
+  /** Resolve the optional, fully-qualified emergency continuity route. */
+  resolveBridge(exclude) {
+    const ref = this.config.fallbackBridge?.trim();
+    if (!ref) return FREEZER_EMPTY;
+    const parsed = parseModelRef(ref);
+    if (!parsed.provider || !parsed.model) return FREEZER_EMPTY;
+    return this.resolveRefs([ref], exclude);
+  }
+  /**
+   * Resolve every usable configured target as an uncapped last-resort chain.
+   * Normal smart defaults stay bounded; callers append this only after the
+   * preferred chain and only when automatic fallback is enabled.
+   */
+  resolveAllConfigured(exclude) {
+    return this.smartDefault(exclude, Number.POSITIVE_INFINITY);
   }
   // ── Provider availability (read-only) ──────────────────────────────────
   checkProvider(providerId) {
@@ -4634,7 +4660,7 @@ var FallbackProfileManager = class {
    * explicit is set. Same-provider alternatives first, then cross-provider.
    * Limited to 4 entries to avoid burning through models on a transient blip.
    */
-  smartDefault(exclude) {
+  smartDefault(exclude, maxCandidates = 4) {
     const leaderProvider = this.config.provider;
     const leaderModel = this.config.model;
     const providers = this.config.providers ?? {};
@@ -4675,8 +4701,18 @@ var FallbackProfileManager = class {
         (id === leaderProvider ? sameProvider : crossProvider).push(ref);
       }
     }
-    const MAX = 4;
-    const all = [...favorites, ...sameProvider, ...crossProvider].slice(0, MAX);
+    const ordered = [...favorites, ...sameProvider, ...crossProvider];
+    const all = Number.isFinite(maxCandidates) ? ordered.slice(0, Math.max(0, maxCandidates)) : [...ordered];
+    const firstCrossProvider = ordered.find((ref) => {
+      const parsed = parseModelRef(ref);
+      return (parsed.provider ?? leaderProvider) !== leaderProvider;
+    });
+    if (all.length > 0 && firstCrossProvider && !all.some((ref) => {
+      const parsed = parseModelRef(ref);
+      return (parsed.provider ?? leaderProvider) !== leaderProvider;
+    })) {
+      all[all.length - 1] = firstCrossProvider;
+    }
     return Object.freeze(
       all.map((ref) => {
         const p = parseModelRef(ref);
@@ -6389,6 +6425,11 @@ import { createReadStream } from "node:fs";
 import { access, appendFile as appendFile2, mkdir as mkdir2, rename as rename2, stat as stat2 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 import { createInterface } from "node:readline";
+
+// src/security/file-permissions.ts
+var SECRET_FILE_MODE = 384;
+
+// src/coordination/brain-ledger.ts
 var QUESTION_MAX = 200;
 var DETAIL_MAX = 240;
 var truncate2 = (s, max) => s === void 0 ? void 0 : s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
@@ -6667,7 +6708,7 @@ var BrainDecisionLedger = class _BrainDecisionLedger {
         this.dirReady = true;
       }
       await this.maybeRotate();
-      await appendFile2(this.opts.filePath, line, "utf8");
+      await appendFile2(this.opts.filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
     }).catch(() => {
     }).finally(() => {
       this.pendingWriteCount = Math.max(0, this.pendingWriteCount - 1);
@@ -6741,7 +6782,7 @@ function brainCacheKey(request) {
   ].join("|");
 }
 var CACHEABLE_TIERS = /* @__PURE__ */ new Set(["council", "llm"]);
-var BrainDecisionCache = class {
+var BrainDecisionCache = class _BrainDecisionCache {
   constructor(opts = {}) {
     this.opts = opts;
     this.enabled = opts.enabled === true;
@@ -6750,6 +6791,12 @@ var BrainDecisionCache = class {
     this.now = opts.now ?? Date.now;
   }
   opts;
+  /**
+   * Max request ids retained per cached entry. Served (replayed) request ids
+   * are kept only so a later `brain.outcome` failure can evict the verdict;
+   * past this cap the oldest ids are dropped — the entry itself stays.
+   */
+  static MAX_REQUEST_IDS_PER_ENTRY = 500;
   entries = /* @__PURE__ */ new Map();
   keyByRequestId = /* @__PURE__ */ new Map();
   unsubscribers = [];
@@ -6758,6 +6805,22 @@ var BrainDecisionCache = class {
   ttlMs;
   maxEntries;
   now;
+  /**
+   * Delete an entry and every request-id index mapping that points at it.
+   * Every eviction path (TTL expiry, max-entry eviction, outcome failure,
+   * same-key replacement) must go through this so `keyByRequestId` cannot
+   * outlive its entry — otherwise the index grows one string per unique
+   * request id for the process lifetime.
+   */
+  removeEntry(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return false;
+    for (const requestId of entry.requestIds) {
+      if (this.keyByRequestId.get(requestId) === key) this.keyByRequestId.delete(requestId);
+    }
+    this.entries.delete(key);
+    return true;
+  }
   /** Subscribe to the outcome feed so failures evict their decision. */
   start() {
     if (!this.enabled || !this.opts.events) return;
@@ -6766,7 +6829,7 @@ var BrainDecisionCache = class {
         if (e.outcome !== "failure") return;
         const key = this.keyByRequestId.get(e.requestId);
         if (key === void 0) return;
-        if (this.entries.delete(key)) this.stats.evictions += 1;
+        if (this.removeEntry(key)) this.stats.evictions += 1;
       })
     );
   }
@@ -6783,11 +6846,18 @@ var BrainDecisionCache = class {
       return void 0;
     }
     if (this.now() - entry.storedAt > this.ttlMs) {
-      this.entries.delete(key);
+      this.removeEntry(key);
       this.stats.evictions += 1;
       this.stats.misses += 1;
       return void 0;
     }
+    if (entry.requestIds.size >= _BrainDecisionCache.MAX_REQUEST_IDS_PER_ENTRY) {
+      const oldest = entry.requestIds.values().next().value;
+      if (oldest !== void 0) {
+        entry.requestIds.delete(oldest);
+        this.keyByRequestId.delete(oldest);
+      }
+    }
     entry.requestIds.add(request.id);
     this.keyByRequestId.set(request.id, key);
     this.stats.hits += 1;
@@ -6803,7 +6873,7 @@ var BrainDecisionCache = class {
     if (decision.type === "ask_human") return false;
     if (tier === void 0 || !CACHEABLE_TIERS.has(tier)) return false;
     const key = brainCacheKey(request);
-    this.entries.delete(key);
+    this.removeEntry(key);
     this.entries.set(key, {
       decision,
       storedAt: this.now(),
@@ -6814,7 +6884,7 @@ var BrainDecisionCache = class {
     while (this.entries.size > this.maxEntries) {
       const oldest = this.entries.keys().next();
       if (oldest.done) break;
-      this.entries.delete(oldest.value);
+      this.removeEntry(oldest.value);
       this.stats.evictions += 1;
     }
     return true;
@@ -8061,17 +8131,98 @@ import { existsSync } from "node:fs";
 import * as fs2 from "node:fs/promises";
 import * as path5 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var KIT_FILE = "KIT.md";
-var TOKENS_FILE = "tokens.json";
-var FOUNDATIONS_ID = "_foundations";
+
+// src/skills/frontmatter.ts
+var SCALAR_KEYS = /* @__PURE__ */ new Set(["name", "description", "trigger", "version", "license", "compatibility"]);
+function parseSkillFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return {};
+  return parseFrontmatterBlock(text.slice(4, end));
+}
 function stripFrontmatter(raw) {
-  if (!raw.startsWith("---")) return raw;
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return raw;
-  let body = raw.slice(end + 4);
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return text;
+  let body = text.slice(end + 4);
   if (body.startsWith("\n")) body = body.slice(1);
   return body;
 }
+function normalizeLineEndings(s) {
+  return s.replace(/\r\n?/g, "\n");
+}
+function parseFrontmatterBlock(block) {
+  const out = {};
+  const lines = block.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const m = /^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const key = m[1] ?? "";
+    const rest = (m[2] ?? "").trim();
+    if (key === "metadata") {
+      const map = {};
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        const sm = /^\s+([a-zA-Z0-9_.-]+):\s*(.*)$/.exec(sub);
+        if (!sm) break;
+        map[sm[1] ?? ""] = unquote((sm[2] ?? "").trim());
+        i++;
+      }
+      if (Object.keys(map).length > 0) out.metadata = map;
+      continue;
+    }
+    if (rest === "|" || rest === ">") {
+      const collected = [];
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        if (sub === "" || sub.startsWith(" ") || sub.startsWith("	")) {
+          collected.push(sub.replace(/^\s+/, ""));
+          i++;
+        } else break;
+      }
+      out[normalizeKey(key)] = collected.join("\n").trim();
+      continue;
+    }
+    if (key === "allowed-tools" || key === "allowedTools") {
+      out.allowedTools = rest.split(/[\s,]+/).filter(Boolean);
+      i++;
+      continue;
+    }
+    if (SCALAR_KEYS.has(key)) {
+      out[key] = unquote(rest);
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return out;
+}
+function normalizeKey(key) {
+  return key === "allowed-tools" ? "allowedTools" : key;
+}
+function unquote(s) {
+  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function isValidSkillNameFormat(name) {
+  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+
+// src/execution/design-kit-loader.ts
+var KIT_FILE = "KIT.md";
+var TOKENS_FILE = "tokens.json";
+var FOUNDATIONS_ID = "_foundations";
 function parseList(value) {
   const trimmed = value.trim();
   const inner = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
@@ -8893,15 +9044,18 @@ function buildRecoveryStrategies(opts) {
               resolve8();
               return;
             }
-            const timer = setTimeout(resolve8, delay);
-            ctx.signal.addEventListener(
-              "abort",
-              () => {
-                clearTimeout(timer);
-                resolve8();
-              },
-              { once: true }
-            );
+            let settled = false;
+            let timer;
+            const onAbort = () => finish();
+            const finish = () => {
+              if (settled) return;
+              settled = true;
+              if (timer !== void 0) clearTimeout(timer);
+              ctx.signal.removeEventListener("abort", onAbort);
+              resolve8();
+            };
+            timer = setTimeout(finish, delay);
+            ctx.signal.addEventListener("abort", onAbort, { once: true });
           });
         } else {
           await new Promise((r) => setTimeout(r, delay));
@@ -9129,6 +9283,11 @@ function applyGoalDeliverableCompletions(goal, completed) {
       (item, index) => completedIndices.has(index) && !isGoalDeliverableComplete(item) ? `\u2705 ${item}` : item
     )
   };
+  next = appendGoalDeliverableJournals(next, completed);
+  return recomputeGoalProgress(next);
+}
+function appendGoalDeliverableJournals(goal, completed) {
+  let next = goal;
   for (const item of completed) {
     next = appendJournal(next, {
       source: "deliverable",
@@ -9137,7 +9296,7 @@ function applyGoalDeliverableCompletions(goal, completed) {
       note: `[DONE: ${item.index + 1}]`
     });
   }
-  return recomputeGoalProgress(next);
+  return next;
 }
 function recomputeGoalProgress(goal) {
   const deliverables = goal.deliverables ?? [];
@@ -9150,10 +9309,19 @@ async function coordinateGoalIteration(options) {
   const current = await loadGoal(options.goalPath, options.events);
   if (!current) return null;
   const completed = parseCompletedGoalDeliverables(options.finalText, current.deliverables ?? []);
-  let goal = applyGoalDeliverableCompletions(current, completed);
-  await saveGoal(options.goalPath, goal, options.events);
-  const kanbanUpdatedTaskIds = await refreshGoalKanban(options.projectRoot, goal, completed);
-  goal = await recomputeGoalProgressFromKanban(options.projectRoot, goal);
+  const board = await resolveGoalBoard(options.projectRoot, current);
+  let kanbanUpdatedTaskIds = [];
+  let goal;
+  if (board) {
+    kanbanUpdatedTaskIds = await refreshGoalKanban(options.projectRoot, current, completed, board);
+    goal = await recomputeGoalProgressFromKanban(options.projectRoot, current);
+    const confirmed = completed.filter(
+      (item) => !isGoalDeliverableComplete(current.deliverables?.[item.index] ?? "") && isGoalDeliverableComplete(goal.deliverables?.[item.index] ?? "")
+    );
+    goal = appendGoalDeliverableJournals(goal, confirmed);
+  } else {
+    goal = applyGoalDeliverableCompletions(current, completed);
+  }
   let reached = false;
   const allComplete = (goal.deliverables?.length ?? 0) > 0 && goal.deliverables?.every(isGoalDeliverableComplete) === true;
   if (allComplete && options.brain) {
@@ -9218,9 +9386,9 @@ async function resolveGoalBoard(projectRoot, goal) {
   }
   return findGoalBoardByTag(projectRoot, goal);
 }
-async function refreshGoalKanban(projectRoot, goal, completed) {
+async function refreshGoalKanban(projectRoot, goal, completed, resolvedBoard) {
   if (completed.length === 0) return [];
-  const board = await resolveGoalBoard(projectRoot, goal);
+  const board = resolvedBoard ?? await resolveGoalBoard(projectRoot, goal);
   if (!board) return [];
   const doneColumn = board.columns.find((column) => column.title.toLowerCase() === "done");
   if (!doneColumn) return [];
@@ -9229,7 +9397,7 @@ async function refreshGoalKanban(projectRoot, goal, completed) {
   const updated = [];
   for (const task of board.tasks) {
     const originMatch = task.origin?.system === "goal" && task.origin?.taskId ? originKeys.has(task.origin.taskId) : false;
-    const titleMatch = completedTitles.has(normalizeTitle(task.title));
+    const titleMatch = !task.origin?.taskId && completedTitles.has(normalizeTitle(task.title));
     if (!originMatch && !titleMatch) continue;
     const result = await updateTask(
       projectRoot,
@@ -9248,12 +9416,17 @@ async function refreshGoalKanban(projectRoot, goal, completed) {
 async function recomputeGoalProgressFromKanban(projectRoot, goal) {
   const board = await resolveGoalBoard(projectRoot, goal);
   if (!board || !goal.deliverables?.length) return recomputeGoalProgress(goal);
-  const completedTitles = new Set(
-    board.tasks.filter((task) => task.status === "completed").map((task) => normalizeTitle(task.title))
+  const tasksByOrigin = new Map(
+    board.tasks.filter((task) => task.origin?.system === "goal" && task.origin.taskId).map((task) => [task.origin.taskId, task])
   );
-  const deliverables = goal.deliverables.map((item) => {
-    if (isGoalDeliverableComplete(item)) return item;
-    return completedTitles.has(normalizeTitle(item)) ? `\u2705 ${item}` : item;
+  const completedLegacyTitles = new Set(
+    board.tasks.filter((task) => !task.origin?.taskId && task.status === "completed").map((task) => normalizeTitle(task.title))
+  );
+  const deliverables = goal.deliverables.map((item, index) => {
+    const text = stripGoalDeliverableMarker(item);
+    const originTask = tasksByOrigin.get(`deliverable:${index}`);
+    const complete = originTask ? originTask.status === "completed" : completedLegacyTitles.has(normalizeTitle(text)) || isGoalDeliverableComplete(item);
+    return complete ? `\u2705 ${text}` : text;
   });
   return recomputeGoalProgress({ ...goal, deliverables });
 }
@@ -10941,7 +11114,26 @@ var SubagentBudget = class _SubagentBudget {
 var ToolCapabilities = {
   /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
   SHELL_ARBITRARY: "shell.arbitrary",
-  /** Can execute a restricted set of commands (the `exec` tool). */
+  /**
+   * Can execute the `exec` tool's allowlisted commands.
+   *
+   * "Restricted" describes the command NAME check, not the resulting power.
+   * Treat this as equivalent to {@link SHELL_ARBITRARY} when deciding what to
+   * grant: the allowlist includes general-purpose interpreters (`node`,
+   * `python`, `perl`, `ruby`) and, on Windows, the platform shells (`cmd`,
+   * `powershell`, `pwsh`) — deliberately, since without them `exec` cannot run
+   * `dir`/`type`/any cmdlet. `node -e …` or `cmd /c …` therefore reaches
+   * arbitrary execution, and per-argument denylisting cannot close that while
+   * the shells remain (blocking `node -e` still leaves `cmd /c node -e`).
+   *
+   * What actually bounds this is downstream, not the name check: the permission
+   * policy reconstructs the full command line and runs it through the
+   * destructive classifier, so destructive calls still require confirmation.
+   *
+   * Granting `shell.restricted` while withholding `shell.arbitrary` therefore
+   * buys no meaningful reduction in blast radius. Documented rather than
+   * silently implied, because the two read as a narrow/wide pair (WS-083).
+   */
   SHELL_RESTRICTED: "shell.restricted",
   /** Can run a restricted project formatter/linter-style command. */
   SHELL_EXEC: "shell.exec",
@@ -17041,84 +17233,6 @@ function resolveForeignToolIdsWithWarnings(opt) {
   return { ids: FOREIGN_SKILL_TOOLS.map((t) => t.id), unknownIds: [] };
 }
 
-// src/skills/frontmatter.ts
-var SCALAR_KEYS = /* @__PURE__ */ new Set(["name", "description", "version", "license", "compatibility"]);
-function parseSkillFrontmatter(raw) {
-  const text = normalizeLineEndings(raw);
-  if (!text.startsWith("---")) return {};
-  const end = text.indexOf("\n---", 4);
-  if (end === -1) return {};
-  return parseFrontmatterBlock(text.slice(4, end));
-}
-function normalizeLineEndings(s) {
-  return s.replace(/\r\n?/g, "\n");
-}
-function parseFrontmatterBlock(block) {
-  const out = {};
-  const lines = block.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const m = /^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
-    if (!m) {
-      i++;
-      continue;
-    }
-    const key = m[1] ?? "";
-    const rest = (m[2] ?? "").trim();
-    if (key === "metadata") {
-      const map = {};
-      i++;
-      while (i < lines.length) {
-        const sub = lines[i] ?? "";
-        const sm = /^\s+([a-zA-Z0-9_.-]+):\s*(.*)$/.exec(sub);
-        if (!sm) break;
-        map[sm[1] ?? ""] = unquote((sm[2] ?? "").trim());
-        i++;
-      }
-      if (Object.keys(map).length > 0) out.metadata = map;
-      continue;
-    }
-    if (rest === "|" || rest === ">") {
-      const collected = [];
-      i++;
-      while (i < lines.length) {
-        const sub = lines[i] ?? "";
-        if (sub === "" || sub.startsWith(" ") || sub.startsWith("	")) {
-          collected.push(sub.replace(/^\s+/, ""));
-          i++;
-        } else break;
-      }
-      out[normalizeKey(key)] = collected.join("\n").trim();
-      continue;
-    }
-    if (key === "allowed-tools" || key === "allowedTools") {
-      out.allowedTools = rest.split(/[\s,]+/).filter(Boolean);
-      i++;
-      continue;
-    }
-    if (SCALAR_KEYS.has(key)) {
-      out[key] = unquote(rest);
-      i++;
-      continue;
-    }
-    i++;
-  }
-  return out;
-}
-function normalizeKey(key) {
-  return key === "allowed-tools" ? "allowedTools" : key;
-}
-function unquote(s) {
-  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-function isValidSkillNameFormat(name) {
-  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
-}
-
 // src/skills/limits.ts
 var SKILL_LIMITS = {
   /**
@@ -17160,6 +17274,14 @@ var SKILL_LIMITS = {
    * Consumer: `downloadGitHubTarball`.
    */
   MAX_TARBALL_SIZE: 50 * 1024 * 1024,
+  /**
+   * Maximum size of a GitHub skill tarball after gzip decompression. The
+   * compressed download limit alone does not protect against highly
+   * compressible archives expanding until the process runs out of memory.
+   *
+   * Consumer: `downloadGitHubTarball`.
+   */
+  MAX_UNCOMPRESSED_TARBALL_SIZE: 64 * 1024 * 1024,
   /**
    * Default total char budget for skill bodies injected in eager mode when
    * `config.skills.eagerMaxChars` is unset. ~6k tokens. Skills are injected
@@ -17171,6 +17293,17 @@ var SKILL_LIMITS = {
    * `skillEagerMaxChars`).
    */
   EAGER_DEFAULT_MAX_CHARS: 24e3,
+  /**
+   * Default total char budget for compact (token-saving) skill bodies injected
+   * by `buildCompactSkillBodiesText`. Mirrors the eager ceiling so compact mode
+   * can never inject more total skill text than eager mode. Before this bound
+   * existed, compact mode injected EVERY skill's compact body with no cap, so
+   * the section grew linearly with the number of installed skills. Skills past
+   * the budget overflow to a name list the agent loads via the `skill` tool.
+   *
+   * Consumer: `buildCompactSkillBodiesText` (default for its `budget` param).
+   */
+  COMPACT_DEFAULT_MAX_CHARS: 24e3,
   /**
    * Auto-compact body limits (the token-saving fallback used when a skill has
    * no hand-crafted `SKILL.save.md`). The Overview and Rules sections are
@@ -17200,14 +17333,6 @@ var SKILL_LIMITS = {
 };
 
 // src/execution/skill-loader.ts
-function stripFrontmatter2(raw) {
-  if (!raw.startsWith("---")) return raw;
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return raw;
-  let body = raw.slice(end + 4);
-  if (body.startsWith("\n")) body = body.slice(1);
-  return body;
-}
 function compactSkillBody(body) {
   const sections = [];
   const overviewMatch = body.match(/##\s*Overview\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
@@ -17246,6 +17371,9 @@ var DefaultSkillLoader = class {
   cache;
   entriesCache;
   bodyCache = /* @__PURE__ */ new Map();
+  /** Load-time diagnostics from the most recent full `list()` scan. */
+  skipped = [];
+  shadowed = [];
   constructor(opts) {
     const readClaude = opts.readClaudeSkills !== false;
     const foreignIds = resolveForeignToolIds(opts.foreignSources);
@@ -17275,6 +17403,9 @@ var DefaultSkillLoader = class {
     if (this.cache) return this.cache;
     const found = [];
     const seen = /* @__PURE__ */ new Set();
+    const claimedBy = /* @__PURE__ */ new Map();
+    this.skipped = [];
+    this.shadowed = [];
     for (const { dir, source, originTool } of this.dirs) {
       try {
         const entries = (await fs4.readdir(dir, { withFileTypes: true })).sort(
@@ -17283,27 +17414,61 @@ var DefaultSkillLoader = class {
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
           const skillFile = path11.join(dir, e.name, "SKILL.md");
+          let raw;
           try {
-            const raw = await fs4.readFile(skillFile, "utf8");
-            const fm = parseSkillFrontmatter(raw);
-            if (!fm.name || !fm.description) continue;
-            if (!isValidSkillNameFormat(fm.name)) continue;
-            if (seen.has(fm.name)) continue;
-            seen.add(fm.name);
-            found.push({
+            raw = await fs4.readFile(skillFile, "utf8");
+          } catch {
+            continue;
+          }
+          const fm = parseSkillFrontmatter(raw);
+          if (!fm.name) {
+            this.skipped.push({ dir, entry: e.name, reason: "missing-name" });
+            continue;
+          }
+          if (!fm.description) {
+            this.skipped.push({
+              dir,
+              entry: e.name,
+              reason: "missing-description",
+              name: fm.name
+            });
+            continue;
+          }
+          if (!isValidSkillNameFormat(fm.name)) {
+            this.skipped.push({
+              dir,
+              entry: e.name,
+              reason: "invalid-name-format",
+              name: fm.name
+            });
+            continue;
+          }
+          if (seen.has(fm.name)) {
+            const claimant = claimedBy.get(fm.name);
+            this.shadowed.push({
               name: fm.name,
-              description: fm.description,
-              version: fm.version,
-              license: fm.license,
-              compatibility: fm.compatibility,
-              metadata: fm.metadata,
-              allowedTools: fm.allowedTools,
-              path: skillFile,
               source,
-              originTool
+              path: skillFile,
+              shadowedBy: claimant?.source ?? "unknown",
+              shadowedByPath: claimant?.path
             });
-          } catch {
+            continue;
           }
+          seen.add(fm.name);
+          claimedBy.set(fm.name, { source, path: skillFile });
+          found.push({
+            name: fm.name,
+            description: fm.description,
+            trigger: fm.trigger,
+            version: fm.version,
+            license: fm.license,
+            compatibility: fm.compatibility,
+            metadata: fm.metadata,
+            allowedTools: fm.allowedTools,
+            path: skillFile,
+            source,
+            originTool
+          });
         }
       } catch {
       }
@@ -17332,11 +17497,12 @@ var DefaultSkillLoader = class {
     const skills = await this.list();
     const entries = [];
     for (const s of skills) {
-      const { trigger, scope } = parseDescriptionFromText(s.description ?? "");
+      const parsed = parseDescriptionFromText(s.description ?? "");
+      const trigger = s.trigger?.trim() || parsed.trigger;
       entries.push({
         name: s.name,
         trigger,
-        scope,
+        scope: parsed.scope,
         source: s.source,
         originTool: s.originTool,
         path: s.path
@@ -17349,6 +17515,16 @@ var DefaultSkillLoader = class {
     this.cache = void 0;
     this.entriesCache = void 0;
     this.bodyCache.clear();
+    this.skipped = [];
+    this.shadowed = [];
+  }
+  /**
+   * Load-time diagnostics from the most recent full `list()` scan: skills
+   * skipped as malformed and skills shadowed by a higher-priority layer.
+   * Returns copies so callers cannot mutate internal state.
+   */
+  diagnostics() {
+    return { skipped: [...this.skipped], shadowed: [...this.shadowed] };
   }
   async readBody(name) {
     const key = name.toLowerCase();
@@ -17372,7 +17548,7 @@ var DefaultSkillLoader = class {
       result = await fs4.readFile(savePath, "utf8");
     } catch {
       const full = await fs4.readFile(m.path, "utf8");
-      const body = stripFrontmatter2(full);
+      const body = stripFrontmatter(full);
       const compact = compactSkillBody(body);
       if (compact) {
         result = `## Overview
@@ -18069,12 +18245,38 @@ function createToolOutputSerializer(opts = {}) {
       return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
     }
     const half = Math.floor(available / 2);
-    const first = text.slice(0, half);
-    const second = text.slice(text.length - half);
+    const first = utf8Prefix(text, half);
+    const second = utf8Suffix(text, available - Buffer.byteLength(first, "utf8"));
     return { text: `${first}${marker}${second}`, newBudget: 0 };
   }
   return { serialize, enforceCap, capBytes };
 }
+function utf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  let end = low;
+  if (end > 0 && /[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+  return text.slice(0, end);
+}
+function utf8Suffix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const chars = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(text.length - chars), "utf8") <= maxBytes) low = chars;
+    else high = chars - 1;
+  }
+  let start = text.length - low;
+  if (start < text.length && /[\uDC00-\uDFFF]/.test(text[start])) start++;
+  return text.slice(start);
+}
 function renderToolObject(toolName, obj, input) {
   if (toolName === "read" && typeof obj["text"] === "string") {
     return joinSections([
@@ -18699,13 +18901,43 @@ function normalizePathSubject(value) {
 function isPathSubjectKey(subjectKey) {
   return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
 }
+function renderCommandLine(command, args) {
+  if (!Array.isArray(args) || args.length === 0) return command;
+  const rendered = args.map((arg) => {
+    const str = String(arg);
+    return /\s/.test(str) ? `"${str.replace(/"/g, '\\"')}"` : str;
+  });
+  return [command, ...rendered].join(" ");
+}
 function subjectForToolInput(toolName, input, subjectKey) {
   if (!input || typeof input !== "object") return void 0;
   const obj = input;
   if (subjectKey) {
     const value = obj[subjectKey];
     if (typeof value === "string") {
-      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+      if (isPathSubjectKey(subjectKey)) {
+        const normalized = normalizePathSubject(value);
+        if (subjectKey === "files" && obj["check"] === true) return `${normalized}:check`;
+        if (subjectKey === "files" && obj["dry_run"] === true) return `${normalized}:dry-run`;
+        return normalized;
+      }
+      if (subjectKey === "command") {
+        const rendered = renderCommandLine(value, obj["args"]);
+        if (value === "commit" && obj["dry_run"] === true) {
+          return `${escapeGlobSubject(rendered)}:dry-run`;
+        }
+        return escapeGlobSubject(rendered);
+      }
+      if (subjectKey === "directory" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      if (subjectKey === "packages" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      if (subjectKey === "name" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      return escapeGlobSubject(value);
     }
   }
   if (toolName === "bash" && typeof obj.command === "string") {
@@ -18838,26 +19070,24 @@ function readPolicy(ctx) {
 
 // src/execution/tool-executor.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
+import * as fs8 from "node:fs/promises";
+import * as path16 from "node:path";
+import { isDeepStrictEqual } from "node:util";
 
-// src/observability/process-telemetry.ts
+// src/observability/network-telemetry.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var storage = new AsyncLocalStorage();
-function runWithProcessTelemetry(context, run) {
+function runWithNetworkTelemetry(context, run) {
   return storage.run(context, run);
 }
 
-// src/observability/network-telemetry.ts
+// src/observability/process-telemetry.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage2 = new AsyncLocalStorage2();
-function runWithNetworkTelemetry(context, run) {
+function runWithProcessTelemetry(context, run) {
   return storage2.run(context, run);
 }
 
-// src/execution/tool-executor.ts
-import { isDeepStrictEqual } from "node:util";
-import * as fs8 from "node:fs/promises";
-import * as path16 from "node:path";
-
 // src/security/kanban-boundary.ts
 import { realpath } from "node:fs/promises";
 import * as path14 from "node:path";
@@ -19225,47 +19455,6 @@ function sliceUtf8Suffix(text, maxBytes) {
   return text.slice(start);
 }
 
-// src/execution/tool-executor-results.ts
-function unknownToolResult(use, listFns) {
-  return {
-    type: "tool_result",
-    tool_use_id: use.id,
-    content: `Tool "${use.name}" is not registered. Available tools: ${listFns().join(", ")}`,
-    is_error: true
-  };
-}
-function malformedInputResult(use, raw) {
-  let content = `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`;
-  if (raw) {
-    const max = 800;
-    const excerpt = raw.length > max ? `${raw.slice(0, max)}\u2026 (truncated, ${raw.length} chars total)` : raw;
-    content += ` Common cause: a string field (e.g. code in old_string/new_string) contains literal newlines, quotes, or backslashes that must be JSON-escaped, or the payload was cut off mid-stream. The raw arguments received were:
-${excerpt}`;
-  }
-  return {
-    type: "tool_result",
-    tool_use_id: use.id,
-    content,
-    is_error: true
-  };
-}
-function deniedResult(use, reason) {
-  return {
-    type: "tool_result",
-    tool_use_id: use.id,
-    content: `Tool "${use.name}" denied: ${reason ?? "policy"}`,
-    is_error: true
-  };
-}
-function blockedByHookResult(use, reason) {
-  return {
-    type: "tool_result",
-    tool_use_id: use.id,
-    content: `Tool "${use.name}" was blocked by a PreToolUse hook: ${reason ?? "no reason given"}`,
-    is_error: true
-  };
-}
-
 // src/execution/tool-executor-logging.ts
 function toolLogBase(ctx, use, toolName, durationMs) {
   return {
@@ -19330,6 +19519,82 @@ function logToolFailure(opts, ctx, use, toolName, durationMs, err) {
   });
 }
 
+// src/execution/tool-executor-results.ts
+function unknownToolResult(use, listFns) {
+  return {
+    type: "tool_result",
+    tool_use_id: use.id,
+    content: `Tool "${use.name}" is not registered. Available tools: ${listFns().join(", ")}`,
+    is_error: true
+  };
+}
+function malformedInputResult(use, raw) {
+  let content = `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`;
+  if (raw) {
+    const max = 800;
+    const excerpt = raw.length > max ? `${raw.slice(0, max)}\u2026 (truncated, ${raw.length} chars total)` : raw;
+    content += ` Common cause: a string field (e.g. code in old_string/new_string) contains literal newlines, quotes, or backslashes that must be JSON-escaped, or the payload was cut off mid-stream. The raw arguments received were:
+${excerpt}`;
+  }
+  return {
+    type: "tool_result",
+    tool_use_id: use.id,
+    content,
+    is_error: true
+  };
+}
+function deniedResult(use, reason) {
+  return {
+    type: "tool_result",
+    tool_use_id: use.id,
+    content: `Tool "${use.name}" denied: ${reason ?? "policy"}`,
+    is_error: true
+  };
+}
+function blockedByHookResult(use, reason) {
+  return {
+    type: "tool_result",
+    tool_use_id: use.id,
+    content: `Tool "${use.name}" was blocked by a PreToolUse hook: ${reason ?? "no reason given"}`,
+    is_error: true
+  };
+}
+
+// src/execution/tool-error-taxonomy.ts
+function toolErrorResult(use, err, opts = {}) {
+  const { category, retryable, detail } = classifyToolError(err);
+  const rawMessage = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
+  const userMessage = opts.scrubber ? opts.scrubber(rawMessage) : rawMessage;
+  const info = {
+    category,
+    retryable,
+    userMessage,
+    ...detail !== void 0 ? { detail } : {}
+  };
+  const prefix = formatErrorPrefix(category, retryable);
+  const detailSuffix = detail ? ` [${detail}]` : "";
+  return {
+    type: "tool_result",
+    tool_use_id: use.id,
+    content: `${prefix}: ${userMessage}${detailSuffix}`,
+    is_error: true,
+    // Attach structured info for programmatic consumers (retry logic,
+    // audit log, observability).
+    _toolErrorInfo: info
+  };
+}
+function formatErrorPrefix(category, retryable) {
+  const label = CATEGORY_LABELS[category] ?? "Error";
+  return retryable ? `${label} (retryable)` : label;
+}
+var CATEGORY_LABELS = {
+  ["transient" /* TRANSIENT */]: "Transient error",
+  ["not_found" /* NOT_FOUND */]: "Not found",
+  ["permission" /* PERMISSION */]: "Permission denied",
+  ["validation" /* VALIDATION */]: "Validation error",
+  ["fatal" /* FATAL */]: "Error"
+};
+
 // src/execution/tool-executor-stream.ts
 async function executeStreamedTool({
   tool,
@@ -19430,12 +19695,27 @@ ${progressTail}` : progressTail;
 }
 
 // src/execution/tool-executor.ts
+async function mapWithConcurrency(items, limit, run) {
+  if (items.length === 0) return [];
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await run(items[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}
 var ToolExecutor = class _ToolExecutor {
   constructor(registry, opts) {
     this.registry = registry;
     this.opts = opts;
     this.iterationTimeoutMs = opts.iterationTimeoutMs ?? 3e5;
     this.maxToolTimeoutMs = opts.maxToolTimeoutMs ?? 3e5;
+    const requestedParallelism = opts.maxParallelTools ?? 4;
+    this.maxParallelTools = Number.isFinite(requestedParallelism) ? Math.max(1, Math.min(16, Math.floor(requestedParallelism))) : 4;
     this.serializer = createToolOutputSerializer({
       perIterationOutputCapBytes: opts.perIterationOutputCapBytes ?? 1e5
     });
@@ -19451,6 +19731,7 @@ var ToolExecutor = class _ToolExecutor {
   serializer;
   iterationTimeoutMs;
   maxToolTimeoutMs;
+  maxParallelTools;
   /**
    * Clear the interactive confirm awaiter so the executor returns
    * `ToolConfirmPendingResult` instead of blocking on stdin. Used by
@@ -19778,12 +20059,9 @@ ${post.additionalContext}`;
         const { category, retryable, detail } = classifyToolError(err);
         this.hintRenderMode(tool.name);
         this.opts.renderer?.writeToolResult(tool.name, scrubbed, true);
-        const result = {
-          type: "tool_result",
-          tool_use_id: use.id,
-          content: `Tool "${tool.name}" threw: ${scrubbed}`,
-          is_error: true
-        };
+        const result = toolErrorResult(use, err, {
+          scrubber: (s) => this.opts.secretScrubber.scrub(s)
+        });
         budget = this.budgetForString(result.content, budget);
         if (err instanceof Error) span?.recordError(err);
         span?.setAttribute("tool.is_error", true);
@@ -19803,21 +20081,17 @@ ${post.additionalContext}`;
         const isStructured = isWrongStackError(err);
         const msg = isStructured ? err.describe() : toErrorMessage(err);
         const scrubbed = this.opts.secretScrubber.scrub(msg);
-        const { category, retryable, detail } = classifyToolError(err);
         const tool = this.registry.get(use.name);
         const toolName = tool?.name ?? use.name;
         this.hintRenderMode(toolName);
         this.opts.renderer?.writeToolResult(toolName, scrubbed, true);
-        const result = {
-          type: "tool_result",
-          tool_use_id: use.id,
-          content: isStructured ? scrubbed : `Tool "${use.name}" execution failed: ${scrubbed}`,
-          is_error: true
-        };
+        const result = toolErrorResult(use, err, {
+          scrubber: (s) => this.opts.secretScrubber.scrub(s)
+        });
+        if (isStructured) {
+          result.content = scrubbed;
+        }
         budget = this.budgetForString(result.content, budget);
-        void category;
-        void retryable;
-        void detail;
         return { result, tool, durationMs: 0 };
       }
     };
@@ -19829,7 +20103,7 @@ ${post.additionalContext}`;
       return { outputs, remainingBudget: budget };
     }
     if (strategy === "parallel") {
-      const outputs = await Promise.all(toolUses.map((use) => safeRun(use)));
+      const outputs = await mapWithConcurrency(toolUses, this.maxParallelTools, safeRun);
       return { outputs, remainingBudget: budget };
     }
     const nonMutating = [];
@@ -19840,7 +20114,7 @@ ${post.additionalContext}`;
       if (tool?.mutating) mutating.push(use);
       else nonMutating.push(use);
     }
-    const firstPass = await Promise.all(nonMutating.map((use) => safeRun(use)));
+    const firstPass = await mapWithConcurrency(nonMutating, this.maxParallelTools, safeRun);
     const secondPass = [];
     for (const use of mutating) {
       secondPass.push(await safeRun(use));
@@ -19975,25 +20249,28 @@ ${post.additionalContext}`;
     let output;
     const execute = () => typeof tool.executeStream === "function" ? this.runStreamedTool(tool, input, ctx, combined, toolUseId) : (async () => tool.execute(input, ctx, { signal: combined }))();
     const telemetryToolCallId = toolUseId ?? `nested-${randomUUID4()}`;
-    const toolPromise = this.opts.events ? runWithNetworkTelemetry({
-      events: this.opts.events,
-      sessionId: resolveEventSessionId(ctx),
-      ...ctx.traceId ? { traceId: ctx.traceId } : {},
-      ...ctx.agentId ? { agentId: ctx.agentId } : {},
-      toolCallId: telemetryToolCallId,
-      initiator: "tool",
-      operationName: tool.name
-    }, () => runWithProcessTelemetry(
+    const toolPromise = this.opts.events ? runWithNetworkTelemetry(
       {
         events: this.opts.events,
         sessionId: resolveEventSessionId(ctx),
         ...ctx.traceId ? { traceId: ctx.traceId } : {},
         ...ctx.agentId ? { agentId: ctx.agentId } : {},
         toolCallId: telemetryToolCallId,
-        toolName: tool.name
+        initiator: "tool",
+        operationName: tool.name
       },
-      execute
-    )) : execute();
+      () => runWithProcessTelemetry(
+        {
+          events: this.opts.events,
+          sessionId: resolveEventSessionId(ctx),
+          ...ctx.traceId ? { traceId: ctx.traceId } : {},
+          ...ctx.agentId ? { agentId: ctx.agentId } : {},
+          toolCallId: telemetryToolCallId,
+          toolName: tool.name
+        },
+        execute
+      )
+    ) : execute();
     toolPromise.catch(() => {
     });
     try {
@@ -20245,19 +20522,39 @@ var OneShotOrchestrator = class {
    */
   resolveFallbackChain(input, config, target) {
     const mgr = this.opts.fallbackProfileManager;
+    let selected = mgr.resolveEffective({
+      fallbackAuto: false,
+      exclude: target
+    });
     if (input.fallbackModels && input.fallbackModels.length > 0) {
-      return mgr.resolveRefs(input.fallbackModels, target);
-    }
-    if (config.fallbackModels && config.fallbackModels.length > 0) {
-      return mgr.resolveRefs(config.fallbackModels, target);
-    }
-    if (config.fallbackAuto !== false) {
-      return mgr.resolveEffective({
+      selected = mgr.resolveEffective({
+        fallbackModels: input.fallbackModels,
+        fallbackAuto: false,
+        exclude: target
+      });
+    } else if (config.fallbackModels && config.fallbackModels.length > 0) {
+      selected = mgr.resolveEffective({
+        fallbackModels: config.fallbackModels,
+        fallbackAuto: false,
+        exclude: target
+      });
+    } else if (config.fallbackAuto !== false) {
+      selected = mgr.resolveEffective({
         fallbackAuto: true,
         exclude: target
       });
     }
-    return Object.freeze([]);
+    if (config.fallbackAuto === false) return selected;
+    const combined = [...selected, ...mgr.resolveAllConfigured(target)];
+    const seen = /* @__PURE__ */ new Set();
+    return Object.freeze(
+      combined.filter((entry) => {
+        const key = `${entry.providerId}/${entry.model}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      })
+    );
   }
   /** Attempt a provider call while preserving the actual failure for callers. */
   async tryCall(provider, request, signal, providerId, model) {