@ashx-j/lunr 0.2.25 → 0.2.27

package/dist/node-runtime/{src-IVPNZ2BX.js → src-6RV4PXKJ.js}

@@ -22,16 +22,26 @@ import {
 import {
   typebox_exports
 } from "./chunk-PL6JKXWI.js";
+import {
+  withFileMutationQueue
+} from "./chunk-YSB6URMT.js";
 import {
   DEFAULT_MAX_BYTES,
   DEFAULT_MAX_LINES,
   truncateHead
 } from "./chunk-53YJI7JU.js";
+import {
+  protectedTargetWriteReason,
+  resolveToCwd
+} from "./chunk-F2V2F4ZG.js";
+import "./chunk-BDRGN3L2.js";
 import {
   isEditToolResult,
   isReadToolResult,
   isWriteToolResult
 } from "./chunk-OR4L3IB2.js";
+import "./chunk-64XTQNLA.js";
+import "./chunk-Q4Q6D4IY.js";
 import {
   __toESM
 } from "./chunk-BRJX2PRC.js";
@@ -41,7 +51,7 @@ var import_vscode_languageserver_protocol3 = __toESM(require_api(), 1);
 
 // packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/runtime.js
 var defaultLoaders = {
-  loadLspManager: () => import("./lsp-manager-3ASUSO4T.js"),
+  loadLspManager: () => import("./lsp-manager-S554V5HR.js"),
   loadFileSync: () => import("./file-sync-HCOP2QVF.js"),
   loadTreeSitter: () => import("./parser-manager-TQHWYDH7.js"),
   loadWorkspaceIndex: () => import("./workspace-index-6DBXSTJ6.js")
@@ -1587,6 +1597,7 @@ function hasErrors(node) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/search-engine.js
+import { createHash } from "node:crypto";
 import { resolve as resolve2 } from "node:path";
 import { readdir as readdir2, readFile as readFile8, stat } from "node:fs/promises";
 async function searchFiles(pattern, rootDir, treeSitter, options = {}) {
@@ -1600,12 +1611,13 @@ async function searchFiles(pattern, rootDir, treeSitter, options = {}) {
       let content = await readFile8(file, "utf-8"), tree = await treeSitter.parseWithLanguage(file, content, pattern.languageId);
       if (!tree)
         continue;
-      let fileMatches = findMatches(tree.rootNode, pattern.root);
+      let sourceHash = createHash("sha256").update(content).digest("hex"), fileMatches = findMatches(tree.rootNode, pattern.root);
       for (let m of fileMatches) {
         if (matches.length >= maxResults)
           break;
         matches.push({
           file,
+          sourceHash,
           line: m.node.startPosition.row + 1,
           column: m.node.startPosition.column + 1,
           matchedText: m.node.text,
@@ -1800,6 +1812,8 @@ function createCodeSearchTool(rootDirOrGetter, treeSitter) {
 import { relative as relative8 } from "node:path";
 
 // packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.js
+import { createHash as createHash2 } from "node:crypto";
+import { dirname } from "node:path";
 import { readFile as readFile9, writeFile } from "node:fs/promises";
 var METAVAR_REF_RE = /\$\$\$([A-Z_][A-Z0-9_]*)|\$([A-Z_][A-Z0-9_]*)/g;
 function substituteCaptures(template, captures) {
@@ -1824,28 +1838,47 @@ function computeRewrites(matches, replacementTemplate) {
     };
   });
 }
-async function applyRewrites(matches, replacementTemplate) {
+async function applyRewrites(matches, replacementTemplate, cwd) {
   let byFile = /* @__PURE__ */ new Map();
-  for (let m of matches) {
-    let existing = byFile.get(m.file);
-    existing ? existing.push(m) : byFile.set(m.file, [m]);
+  for (let match of matches) {
+    let existing = byFile.get(match.file);
+    existing ? existing.push(match) : byFile.set(match.file, [match]);
+  }
+  let result = { changes: [], filesModified: 0, modifiedFiles: [], failures: [], skippedFiles: [] }, files = [...byFile.keys()];
+  for (let file of files) {
+    let reason = protectedTargetWriteReason(file, cwd ?? dirname(file));
+    reason && result.failures.push({ file, reason });
   }
-  let changes = [], filesModified = 0;
+  if (result.failures.length)
+    return result.skippedFiles = files.filter((file) => !result.failures.some((failure) => failure.file === file)), result;
   for (let [file, fileMatches] of byFile) {
-    let sorted = [...fileMatches].sort((a, b) => b.startIndex - a.startIndex), content = await readFile9(file, "utf-8"), modified = !1;
-    for (let m of sorted) {
-      let raw = substituteCaptures(replacementTemplate, m.captures), replacement = preserveTrailingSemicolon(m.matchedText, raw);
-      replacement !== m.matchedText && (content = content.slice(0, m.startIndex) + replacement + content.slice(m.endIndex), modified = !0), changes.push({
-        file,
-        line: m.line,
-        column: m.column,
-        before: m.matchedText,
-        after: replacement
+    let writeAttempted = !1;
+    try {
+      let applied = await withFileMutationQueue(file, async () => {
+        let reason = protectedTargetWriteReason(file, cwd ?? dirname(file));
+        if (reason)
+          throw new Error(reason);
+        let source = await readFile9(file, "utf-8"), sourceHash = createHash2("sha256").update(source).digest("hex"), sorted = [...fileMatches].sort((a, b) => b.startIndex - a.startIndex), nextStart = source.length;
+        for (let match of sorted) {
+          if (match.sourceHash !== sourceHash || !Number.isInteger(match.startIndex) || !Number.isInteger(match.endIndex) || match.startIndex < 0 || match.endIndex > nextStart || match.startIndex > match.endIndex || source.slice(match.startIndex, match.endIndex) !== match.matchedText)
+            throw new Error("Source changed or match offsets are invalid. Search again before applying a rewrite.");
+          nextStart = match.startIndex;
+        }
+        let content = source, changes = [];
+        for (let match of sorted) {
+          let raw = substituteCaptures(replacementTemplate, match.captures), replacement = preserveTrailingSemicolon(match.matchedText, raw);
+          content = content.slice(0, match.startIndex) + replacement + content.slice(match.endIndex), changes.push({ file, line: match.line, column: match.column, before: match.matchedText, after: replacement });
+        }
+        let modified = content !== source;
+        return modified && (writeAttempted = !0, await writeFile(file, content, "utf-8")), { changes: changes.reverse(), modified };
       });
+      result.changes.push(...applied.changes), applied.modified && result.modifiedFiles.push(file);
+    } catch (error) {
+      result.failures.push({ file, reason: error instanceof Error ? error.message : String(error), writeAttempted }), result.skippedFiles = files.slice(files.indexOf(file) + 1);
+      break;
     }
-    modified && (await writeFile(file, content, "utf-8"), filesModified++);
   }
-  return changes.reverse(), { changes, filesModified };
+  return result.filesModified = result.modifiedFiles.length, result;
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/tools/code-rewrite.js
@@ -1861,7 +1894,7 @@ function createCodeRewriteTool(rootDirOrGetter, treeSitter, fileChangeCallback)
   return {
     name: "code_rewrite",
     label: "Code Rewrite",
-    description: "Transform code matching a structural pattern into a replacement. Use $NAME to capture and reuse single nodes, $$$NAME for sequences. Defaults to dry-run mode (preview only). Set dry_run=false to apply changes. For symbol renames, prefer lsp_rename instead (semantically correct).",
+    description: "Transform code matching a structural pattern into a replacement. Use $NAME to capture and reuse single nodes, $$$NAME for sequences. Defaults to dry-run mode (preview only). Set dry_run=false to apply changes. Apply rejects protected targets and stale source snapshots. Files apply sequentially; a later failure leaves earlier changes in place and reports skipped files. Search again after a stale-source failure. Inspect failed writes before retrying. For symbol renames, prefer lsp_rename instead (semantically correct).",
     parameters: RewriteParams,
     async execute(_toolCallId, params) {
       let rootDir = getRootDir(), { pattern: patternStr, replacement, language, path, dry_run } = params, isDryRun = dry_run !== !1, compiled;
@@ -1869,7 +1902,7 @@ function createCodeRewriteTool(rootDirOrGetter, treeSitter, fileChangeCallback)
         compiled = await compilePattern(patternStr, language, treeSitter);
       } catch (e) {
         return {
-          content: [{ type: "text", text: `Error: ${e.message}` }],
+          content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
           details: { matchCount: 0, filesModified: 0, dryRun: isDryRun }
         };
       }
@@ -1883,7 +1916,7 @@ function createCodeRewriteTool(rootDirOrGetter, treeSitter, fileChangeCallback)
           };
       }
       let matches = await searchFiles(compiled, rootDir, treeSitter, {
-        path,
+        path: path ? resolveToCwd(path, rootDir) : void 0,
         maxResults: 500
       });
       if (matches.length === 0)
@@ -1919,13 +1952,16 @@ function createCodeRewriteTool(rootDirOrGetter, treeSitter, fileChangeCallback)
           details: { matchCount: matches.length, filesModified: uniqueFiles.size, dryRun: !0 }
         };
       }
-      let result = await applyRewrites(matches, replacement);
-      if (fileChangeCallback && result.filesModified > 0) {
-        let modifiedFiles = new Set(result.changes.map((c) => c.file));
-        for (let file of modifiedFiles)
+      let result = await applyRewrites(matches, replacement, rootDir);
+      if (fileChangeCallback && result.filesModified > 0)
+        for (let file of result.modifiedFiles)
           fileChangeCallback.onFileModified(file);
-      }
       let lines = [];
+      if (result.failures.length) {
+        lines.push(`Rewrite stopped. ${result.filesModified} file(s) changed before failure; earlier changes remain. ${result.skippedFiles.length} file(s) skipped.`), result.failures.some((failure) => failure.writeAttempted) && lines.push("A failed write may have partially changed its target. Inspect that file before retrying.");
+        for (let failure of result.failures)
+          lines.push(`${relative8(rootDir, failure.file)}: ${failure.reason}`);
+      }
       lines.push(`Applied ${result.changes.length} change${result.changes.length !== 1 ? "s" : ""} across ${result.filesModified} file${result.filesModified !== 1 ? "s" : ""}:
 `);
       for (let c of result.changes) {
@@ -1938,7 +1974,7 @@ function createCodeRewriteTool(rootDirOrGetter, treeSitter, fileChangeCallback)
 
 [Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines]`), {
         content: [{ type: "text", text: output }],
-        details: { matchCount: matches.length, filesModified: result.filesModified, dryRun: !1 }
+        details: { matchCount: matches.length, filesModified: result.filesModified, dryRun: !1, failures: result.failures, skippedFiles: result.skippedFiles }
       };
     }
   };
@@ -2141,14 +2177,6 @@ function registerToolWithRuntime(pi, tool, ensure, host) {
   });
 }
 function lspExtension(pi) {
-  let origListeners = process.listeners("uncaughtException");
-  process.on("uncaughtException", (err) => {
-    if (err?.code !== "EPIPE") {
-      for (let listener of origListeners)
-        listener(err);
-      origListeners.length === 0 && console.error("[LSP] Uncaught exception:", err);
-    }
-  });
   let host = new LspRuntimeHost(), pendingProvider = null, latestCtx = null, projectConfig = null, sessionCwd = process.cwd(), withLatestCtx = (fn) => {
     let ctx = latestCtx;
     if (ctx)
@@ -2219,7 +2247,7 @@ function lspExtension(pi) {
     }
   }), ensureRuntime = async () => host.ensureServices(buildBindOptions(sessionCwd || process.cwd()));
   pi.on("session_start", async (_event, ctx) => {
-    latestCtx = ctx, sessionCwd = ctx.cwd, projectConfig = loadProjectConfig(ctx.cwd), await host.bindSession(buildBindOptions(ctx.cwd));
+    latestCtx = ctx, sessionCwd = ctx.cwd, projectConfig = ctx.isProjectTrusted() ? loadProjectConfig(ctx.cwd) : null, await host.bindSession(buildBindOptions(ctx.cwd));
     let statusText = pendingProvider?.getStatusText?.() ?? "";
     if (statusText ? ctx.ui.setStatus("lsp", ctx.ui.theme.fg("accent", `LSP: ${statusText}`)) : ctx.ui.setStatus("lsp", ctx.ui.theme.fg("dim", "LSP: idle")), projectConfig?.autoStart && projectConfig.autoStart.length > 0) {
       let langs = projectConfig.autoStart, generation = host.getGeneration();

package/dist/node-runtime/{subagent-executor-KZZQGAKV.js → subagent-executor-Q5F7DBVM.js}

@@ -141,7 +141,6 @@ import {
   resolveSkillsWithFallback,
   resolveStepBehavior,
   resolveSubagentIntercomTarget,
-  resolveSubagentRequestParams,
   resolveSubagentResultStatus,
   resolveSubagentRunId,
   resolveTopLevelParallelConcurrency,
@@ -179,7 +178,7 @@ import {
   writeNestedControlRequest,
   writeNestedEvent,
   writePrivateAtomicJson
-} from "./chunk-3XPLBUEM.js";
+} from "./chunk-RLGY2QIL.js";
 import {
   DEFAULT_CONTROL_CONFIG,
   buildControlEvent,
@@ -190,37 +189,45 @@ import {
   resolveControlConfig,
   shouldNotifyControlEvent
 } from "./chunk-OAR4TYZE.js";
+import {
+  createChildEventDecoder
+} from "./chunk-U5F4IC7R.js";
 import {
   READ_ONLY_WRITE_SPAWN_ERROR,
   resolveChildPermissions,
   snapshotParentPermissionMode
-} from "./chunk-OVX6X377.js";
-import "./chunk-YDO2F2IA.js";
+} from "./chunk-ZEVFBFNF.js";
+import "./chunk-YSB6URMT.js";
+import "./chunk-6ZZHGUSA.js";
 import "./chunk-53YJI7JU.js";
-import "./chunk-5ZQXRPMC.js";
-import "./chunk-AD6VXAO7.js";
+import "./chunk-IAZSK7KK.js";
+import "./chunk-TCT6PCUR.js";
 import {
   subagentCommunicationEnabled
-} from "./chunk-6XL67VVY.js";
-import "./chunk-UOEDI7RP.js";
-import "./chunk-2HMIRK7W.js";
+} from "./chunk-HUD2RFJW.js";
+import "./chunk-4KNKQGHM.js";
+import "./chunk-LHV3V67B.js";
 import "./chunk-URD2SLIT.js";
-import "./chunk-ZXSGTGJ6.js";
-import "./chunk-M3LZLQW2.js";
-import "./chunk-KKUTQQV7.js";
-import "./chunk-CSFI6YXL.js";
+import {
+  resolveSubagentRequestParams
+} from "./chunk-APVM5NEU.js";
+import "./chunk-F2V2F4ZG.js";
+import "./chunk-BDRGN3L2.js";
+import "./chunk-FY4A63RK.js";
+import "./chunk-RYRGL7P4.js";
+import "./chunk-ES6PBSIE.js";
 import {
   SessionManager
-} from "./chunk-2KIPT4HJ.js";
+} from "./chunk-EPR2F3GU.js";
 import "./chunk-FVDOXRUD.js";
 import "./chunk-UJOCPOMX.js";
 import "./chunk-IMLCWLPI.js";
-import "./chunk-UAEOTO52.js";
+import "./chunk-MNQXDFPV.js";
 import "./chunk-RQ2Q5IYR.js";
-import "./chunk-B4HP6ZWM.js";
-import "./chunk-GS42T6MX.js";
-import "./chunk-RDDAZOMU.js";
-import "./chunk-FQMM2EZ2.js";
+import "./chunk-RHCGYWO7.js";
+import "./chunk-QW3AAHWN.js";
+import "./chunk-JL4HYQXK.js";
+import "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 
@@ -1341,13 +1348,6 @@ function createJsonlWriter(filePath, source, deps = {}) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/shared/post-exit-stdio-guard.js
-function trySignalChild(child, signal) {
-  try {
-    return child.kill(signal);
-  } catch {
-    return !1;
-  }
-}
 function attachPostExitStdioGuard(child, options) {
   let { idleMs, hardMs } = options, exited = !1, stdoutEnded = !1, stderrEnded = !1, idleTimer, hardTimer, destroyUnendedStdio = () => {
     if (!stdoutEnded)
@@ -1778,7 +1778,35 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       env: spawnEnv,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: !0
-    }), jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout), processClosed = !1, settled = !1, detached = !1, intercomStarted = !1, assistantError, removeAbortListener, removeInterruptListener, activityTimer, timeoutTimer, timeoutTerminationTimer, timeoutHardKillTimer, turnBudgetSoftReached = !1, turnBudgetTerminationTimer, turnBudgetHardKillTimer, protocolHardKillTimer, clearTurnBudgetTimers = () => {
+    }), jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout), spawned = typeof proc.pid == "number" && proc.pid > 0;
+    proc.once("spawn", () => {
+      spawned = !0;
+    });
+    let processClosed = !1, settled = !1, detached = !1, intercomStarted = !1, assistantError, removeAbortListener, removeInterruptListener, activityTimer, timeoutTimer, timeoutTerminationTimer, timeoutHardKillTimer, turnBudgetSoftReached = !1, turnBudgetTerminationTimer, turnBudgetHardKillTimer, protocolHardKillTimer, cancellationHardKillTimer, interruptTerminationTimer, terminationCheckTimer, terminationUnconfirmedReported = !1, clearCancellationTimers = () => {
+      terminationCheckTimer && clearTimeout(terminationCheckTimer), terminationCheckTimer = void 0, cancellationHardKillTimer && clearTimeout(cancellationHardKillTimer), interruptTerminationTimer && clearTimeout(interruptTerminationTimer), cancellationHardKillTimer = void 0, interruptTerminationTimer = void 0;
+    }, recordProcessError = (error) => {
+      result2.error || (result2.error = error instanceof Error ? error.message : String(error)), progress.error = result2.error, !childExited && !processClosed && !settled && !detached && (progress.status = "running", fireUpdate());
+    }, signalChild = (signal) => {
+      if (childExited || processClosed || settled || detached)
+        return !1;
+      let sent = !1;
+      try {
+        sent = proc.kill(signal);
+      } catch (error) {
+        recordProcessError(error);
+      }
+      return !sent && !childExited && !processClosed && !settled && !detached && recordProcessError(`Subagent ${signal} could not be delivered; child exit is not confirmed.`), signal === "SIGKILL" && !childExited && !processClosed && !settled && !detached && !terminationCheckTimer && !terminationUnconfirmedReported && (terminationCheckTimer = setTimeout(() => {
+        if (terminationCheckTimer = void 0, childExited || processClosed || settled || detached)
+          return;
+        terminationUnconfirmedReported = !0;
+        let message = `Subagent termination unconfirmed after SIGKILL${proc.pid ? ` (diagnostic PID ${proc.pid})` : ""}. This foreground call still owns the child and waits for its exit. Verify the child process before starting replacement work.`;
+        progress.status = "running", progress.error = message, progress.activityState = "needs_attention", progress.durationMs = Date.now() - startTime, appendRecentOutput(progress, [message]), emitUpdateSnapshot(message);
+      }, 2e3), terminationCheckTimer.unref?.()), sent;
+    }, scheduleCancellationHardKill = (delayMs) => {
+      cancellationHardKillTimer || childExited || processClosed || settled || detached || (cancellationHardKillTimer = setTimeout(() => {
+        cancellationHardKillTimer = void 0, !childExited && !processClosed && !settled && !detached && signalChild("SIGKILL");
+      }, delayMs), cancellationHardKillTimer.unref?.());
+    }, clearTurnBudgetTimers = () => {
       turnBudgetTerminationTimer && (clearTimeout(turnBudgetTerminationTimer), turnBudgetTerminationTimer = void 0), turnBudgetHardKillTimer && (clearTimeout(turnBudgetHardKillTimer), turnBudgetHardKillTimer = void 0);
     }, clearTimeoutTimers = () => {
       timeoutTimer && (clearTimeout(timeoutTimer), timeoutTimer = void 0), timeoutTerminationTimer && (clearTimeout(timeoutTerminationTimer), timeoutTerminationTimer = void 0), timeoutHardKillTimer && (clearTimeout(timeoutHardKillTimer), timeoutHardKillTimer = void 0);
@@ -1800,9 +1828,11 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
         return;
       }
       childExited || finalDrainTimer || settled || processClosed || detached || (finalDrainTimer = setTimeout(() => {
-        settled || processClosed || detached || !trySignalChild(proc, "SIGTERM") || (forcedTerminationSignal = !0, !cleanTerminalAssistantStopReceived && !agentSettledReceived && !assistantError && (result2.error = result2.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`), finalHardKillTimer = setTimeout(() => {
-          settled || processClosed || detached || (forcedTerminationSignal = trySignalChild(proc, "SIGKILL") || forcedTerminationSignal);
-        }, HARD_KILL_MS), finalHardKillTimer.unref?.());
+        if (settled || processClosed || detached)
+          return;
+        forcedTerminationSignal = signalChild("SIGTERM") || forcedTerminationSignal, !cleanTerminalAssistantStopReceived && !agentSettledReceived && !assistantError && (result2.error = result2.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`), finalHardKillTimer = setTimeout(() => {
+          settled || processClosed || detached || (forcedTerminationSignal = signalChild("SIGKILL") || forcedTerminationSignal);
+        }, HARD_KILL_MS), finalHardKillTimer.unref?.();
       }, FINAL_STOP_GRACE_MS), finalDrainTimer.unref?.());
     };
     function armWatchdogTail() {
@@ -1836,7 +1866,7 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
         return;
       options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted: !0, runId: options.runId, agent: spec.childId, childIndex: options.index ?? 0 }), detachForIntercom();
     }), finish = (code) => {
-      settled || (settled = !0, clearFinalDrainTimers(), clearWatchdogTailTimer(), clearStdioGuard(), clearTimeoutTimers(), clearTurnBudgetTimers(), protocolHardKillTimer && (clearTimeout(protocolHardKillTimer), protocolHardKillTimer = void 0), activityTimer && (clearInterval(activityTimer), activityTimer = void 0), unsubscribeIntercomDetach?.(), removeAbortListener?.(), removeInterruptListener?.(), resolve7(code));
+      settled || (settled = !0, clearCancellationTimers(), clearFinalDrainTimers(), clearWatchdogTailTimer(), clearStdioGuard(), clearTimeoutTimers(), clearTurnBudgetTimers(), protocolHardKillTimer && (clearTimeout(protocolHardKillTimer), protocolHardKillTimer = void 0), activityTimer && (clearInterval(activityTimer), activityTimer = void 0), unsubscribeIntercomDetach?.(), removeAbortListener?.(), removeInterruptListener?.(), resolve7(code));
     }, drainPendingControlEvents = () => {
       if (pendingControlEvents.length === 0)
         return;
@@ -1895,10 +1925,10 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       if (!budget || result2.timedOut || result2.turnBudgetExceeded || interruptedByControl || processClosed || settled || detached)
         return;
       let message = turnBudgetExceededMessage(budget, turnCount);
-      result2.turnBudgetExceeded = !0, result2.wrapUpRequested = !0, result2.turnBudget = turnBudgetState(budget, turnCount, !0), result2.error = message, result2.finalOutput = message, progress.status = "failed", progress.error = message, progress.durationMs = Date.now() - startTime, fireUpdate(), trySignalChild(proc, "SIGINT"), turnBudgetTerminationTimer = setTimeout(() => {
-        processClosed || settled || detached || result2.timedOut || trySignalChild(proc, "SIGTERM");
+      result2.turnBudgetExceeded = !0, result2.wrapUpRequested = !0, result2.turnBudget = turnBudgetState(budget, turnCount, !0), result2.error = message, result2.finalOutput = message, progress.status = "failed", progress.error = message, progress.durationMs = Date.now() - startTime, fireUpdate(), signalChild("SIGINT"), turnBudgetTerminationTimer = setTimeout(() => {
+        processClosed || settled || detached || result2.timedOut || signalChild("SIGTERM");
       }, 1e3), turnBudgetTerminationTimer.unref?.(), turnBudgetHardKillTimer = setTimeout(() => {
-        processClosed || settled || detached || result2.timedOut || trySignalChild(proc, "SIGKILL");
+        processClosed || settled || detached || result2.timedOut || signalChild("SIGKILL");
       }, 4e3), turnBudgetHardKillTimer.unref?.();
     }, updateTurnBudget = (turnCount, terminalAssistantStop) => {
       let budget = options.turnBudget;
@@ -1945,11 +1975,19 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       progress.durationMs = Date.now() - startTime;
       let output = (result2.timedOut || result2.turnBudgetExceeded) && result2.finalOutput ? result2.finalOutput : getFinalOutput(result2.messages);
       emitUpdateSnapshot(output || "(running...)");
-    }, processLine = (line) => {
+    }, decodeChildEvent = createChildEventDecoder(), processLine = (line) => {
       if (!line.trim())
         return;
-      jsonlWriter.writeLine(line);
-      let evt;
+      let evt, assembled;
+      try {
+        assembled = decodeChildEvent(line);
+      } catch {
+        jsonlWriter.writeLine(line), shared.transcriptWriter?.writeStdoutLine(line);
+        return;
+      }
+      if (assembled === void 0)
+        return;
+      line = assembled, jsonlWriter.writeLine(line);
       try {
         evt = JSON.parse(line);
       } catch {
@@ -2035,15 +2073,15 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       let now = Date.now();
       updateActivityState(now) && (progress.durationMs = now - startTime, fireUpdate());
     }, 1e3), activityTimer.unref?.()), attemptTimeout && (timeoutTimer = setTimeout(() => {
-      processClosed || settled || detached || interruptedByControl || (result2.timedOut = !0, result2.error = attemptTimeout.message, result2.finalOutput = attemptTimeout.message, progress.status = "failed", progress.error = attemptTimeout.message, progress.durationMs = Date.now() - startTime, fireUpdate(), trySignalChild(proc, "SIGINT"), timeoutTerminationTimer = setTimeout(() => {
-        processClosed || settled || detached || trySignalChild(proc, "SIGTERM");
+      processClosed || settled || detached || interruptedByControl || (result2.timedOut = !0, result2.error = attemptTimeout.message, result2.finalOutput = attemptTimeout.message, progress.status = "failed", progress.error = attemptTimeout.message, progress.durationMs = Date.now() - startTime, fireUpdate(), signalChild("SIGINT"), timeoutTerminationTimer = setTimeout(() => {
+        processClosed || settled || detached || signalChild("SIGTERM");
       }, 1e3), timeoutTerminationTimer.unref?.(), timeoutHardKillTimer = setTimeout(() => {
-        processClosed || settled || detached || trySignalChild(proc, "SIGKILL");
+        processClosed || settled || detached || signalChild("SIGKILL");
       }, 4e3), timeoutHardKillTimer.unref?.());
     }, attemptTimeout.remainingMs), timeoutTimer.unref?.());
     let stderrTail = createBoundedByteTail(), stdoutReader = createBoundedLineReader({ onLine: processLine, onLimit: (limit) => {
-      result2.protocolError || (result2.protocolError = limit, result2.error = formatProtocolOutputLimit(limit), progress.status = "failed", progress.error = result2.error, progress.durationMs = Date.now() - startTime, fireUpdate(), childExited || (trySignalChild(proc, "SIGTERM"), protocolHardKillTimer = setTimeout(() => {
-        childExited || trySignalChild(proc, "SIGKILL");
+      result2.protocolError || (result2.protocolError = limit, result2.error = formatProtocolOutputLimit(limit), progress.status = "failed", progress.error = result2.error, progress.durationMs = Date.now() - startTime, fireUpdate(), childExited || (signalChild("SIGTERM"), protocolHardKillTimer = setTimeout(() => {
+        childExited || signalChild("SIGKILL");
       }, 3e3), protocolHardKillTimer.unref?.()));
     } }), stderrReader = createBoundedLineReader({
       stream: "stderr",
@@ -2051,12 +2089,14 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       onLine: (line) => shared.transcriptWriter?.writeStderrLine(line),
       onLimit: (limit) => shared.transcriptWriter?.writeStderrLine(formatProtocolOutputLimit(limit))
     }), clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2e3, hardMs: 8e3 });
-    if (proc.stdout.on("data", (chunk) => stdoutReader.push(chunk)), proc.stderr.on("data", (chunk) => {
+    proc.stdout.on("data", (chunk) => stdoutReader.push(chunk)), proc.stderr.on("data", (chunk) => {
       stderrTail.push(chunk), stderrReader.push(chunk);
-    }), proc.on("exit", () => {
-      childExited = !0, clearFinalDrainTimers();
-    }), proc.on("close", (code, signal) => {
-      clearFinalDrainTimers(), clearStdioGuard(), jsonlWriter.close().catch(() => {
+    });
+    let confirmChildExit = () => {
+      childExited = !0, terminationUnconfirmedReported && (progress.error = result2.error, progress.activityState = void 0), clearCancellationTimers(), clearFinalDrainTimers();
+    };
+    if (proc.on("exit", confirmChildExit), proc.on("close", (code, signal) => {
+      confirmChildExit(), clearFinalDrainTimers(), clearStdioGuard(), jsonlWriter.close().catch(() => {
       });
       let toolDiagnosticError = readChildToolDiagnosticError(toolDiagnosticPath);
       cleanupTempDir(tempDir), stdoutReader.end(), stderrReader.end();
@@ -2087,19 +2127,23 @@ async function runSingleAttempt(runtimeCwd, spec, task, model, options, shared)
       }
       !result2.error && closeError && (result2.error = closeError), processClosed = !0, finish(finalCode);
     }), proc.on("error", (error) => {
+      if (spawned) {
+        recordProcessError(error);
+        return;
+      }
       clearFinalDrainTimers(), clearStdioGuard(), jsonlWriter.close().catch(() => {
       }), cleanupTempDir(tempDir), stdoutReader.end(), stderrReader.end(), result2.error || (result2.error = error instanceof Error ? error.message : String(error)), finish(1);
     }), options.signal) {
       let kill = () => {
-        processClosed || detached || (proc.kill("SIGTERM"), setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3e3));
+        childExited || processClosed || settled || detached || (signalChild("SIGTERM"), scheduleCancellationHardKill(3e3));
       };
       options.signal.aborted ? kill() : (options.signal.addEventListener("abort", kill, { once: !0 }), removeAbortListener = () => options.signal?.removeEventListener("abort", kill));
     }
     if (options.interruptSignal) {
       let interrupt = () => {
-        processClosed || detached || settled || result2.timedOut || (interruptedByControl = !0, clearTimeoutTimers(), progress.status = "running", progress.durationMs = Date.now() - startTime, result2.interrupted = !0, result2.finalOutput = "Interrupted. Waiting for explicit next action.", progress.activityState = void 0, fireUpdate(), trySignalChild(proc, "SIGINT"), setTimeout(() => {
-          settled || processClosed || detached || trySignalChild(proc, "SIGTERM");
-        }, 1e3).unref?.());
+        processClosed || detached || settled || result2.timedOut || (interruptedByControl = !0, clearTimeoutTimers(), progress.status = "running", progress.durationMs = Date.now() - startTime, result2.interrupted = !0, result2.finalOutput = "Interrupted. Waiting for explicit next action.", progress.activityState = void 0, fireUpdate(), signalChild("SIGINT"), interruptTerminationTimer = setTimeout(() => {
+          childExited || settled || processClosed || detached || signalChild("SIGTERM");
+        }, 1e3), interruptTerminationTimer.unref?.(), scheduleCancellationHardKill(4e3));
       };
       options.interruptSignal.aborted ? interrupt() : (options.interruptSignal.addEventListener("abort", interrupt, { once: !0 }), removeInterruptListener = () => options.interruptSignal?.removeEventListener("abort", interrupt));
     }
@@ -3199,6 +3243,11 @@ function validateChainOutputBindingsWithContext(steps, dynamicFanoutConfig = {},
       available.add(name);
   }
 }
+function withChainHandoff(task, hasNextStep) {
+  return hasNextStep ? `${task}
+
+Your final output will be handed to the next agent. Briefly summarize results, relevant references, verification, and remaining work.` : task;
+}
 function resolveOutputReferences(template, outputs) {
   return template.replace(OUTPUT_REF_PATTERN, (rawReference, name) => {
     if (!SAFE_OUTPUT_NAME_PATTERN2.test(name))
@@ -3308,7 +3357,7 @@ async function runParallelChainTasks(input) {
     if (toolBudget.error)
       throw new Error(toolBudget.error);
     let taskCwd = input.worktreeSetup ? input.worktreeSetup.worktrees[taskIndex].agentCwd : resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd), outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(input.chainDir, behavior.output) : void 0;
-    taskStr = injectSingleOutputInstruction(taskStr, outputPath, taskChildConfig);
+    taskStr = withChainHandoff(injectSingleOutputInstruction(taskStr, outputPath, taskChildConfig), input.stepIndex < input.totalSteps - 1);
     let interruptController = new AbortController();
     input.foregroundControl && (input.foregroundControl.currentAgent = task.description || task.agent, input.foregroundControl.currentChildId = task.agent, input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex, input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), input.foregroundControl.interrupt = () => interruptController.signal.aborted ? !1 : (interruptController.abort(), input.foregroundControl.currentActivityState = void 0, input.foregroundControl.updatedAt = Date.now(), !0));
     let structuredRuntime = task.outputSchema ? createStructuredOutputRuntime(task.outputSchema, path6.join(input.chainDir, "structured-output")) : void 0, result2 = await runSync(input.ctx.cwd, normalizeChildSpec({
@@ -3394,7 +3443,17 @@ async function runParallelChainTasks(input) {
       } : void 0
     });
     return input.foregroundControl?.currentIndex === input.globalTaskIndex + taskIndex && (input.foregroundControl.interrupt = void 0, input.foregroundControl.updatedAt = Date.now()), result2.exitCode !== 0 && failFast && (aborted = !0), recordRun(task.agent, cleanTask, result2.exitCode, result2.progressSummary?.durationMs ?? 0), result2;
-  }, input.globalSemaphore);
+  }, input.globalSemaphore, {
+    signal: input.signal,
+    onAbort: (task) => ({
+      agent: task.agent,
+      task: "(cancelled)",
+      exitCode: 1,
+      messages: [],
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+      error: "Subagent launch cancelled."
+    })
+  });
 }
 async function executeChain(params) {
   let { chain: chainSteps, agents, ctx, signal, runId, cwd, shareEnabled, sessionDirForIndex, sessionFileForIndex, sessionFileForTask, thinkingOverrideForTask, artifactsDir, artifactConfig, includeProgress, clarify, onUpdate, onControlEvent, controlConfig, onDetachedExit, childIntercomTarget, orchestratorIntercomTarget, communicationEnabled, foregroundControl, intercomEvents, chainSkills: chainSkillsParam, chainDir: chainDirBase, modelScope } = params, chainSkills = chainSkillsParam ?? [], results = [], outputs = {}, dynamicChildren = {}, dynamicGroupStatuses = {}, allProgress = [], allArtifactPaths = [], chainAgents = chainSteps.map((step) => isParallelStep(step) ? `[${step.parallel.map((t) => t.description || t.label || t.agent || "child").join("+")}]` : isDynamicParallelStep(step) ? `expand:${step.parallel.description || step.parallel.label || step.parallel.agent || "child"}` : step.description || step.label || step.agent || "child"), totalSteps = chainSteps.length, makeDetailsInput = (overrides = {}) => ({
@@ -3833,7 +3892,7 @@ ${failureSummary}`;
         availableModels,
         preferredProvider: ctx.model?.provider
       }), outputPath = typeof behavior.output == "string" ? path6.isAbsolute(behavior.output) ? behavior.output : path6.join(chainDir, behavior.output) : void 0;
-      stepTask = injectSingleOutputInstruction(stepTask, outputPath, agentConfig);
+      stepTask = withChainHandoff(injectSingleOutputInstruction(stepTask, outputPath, agentConfig), stepIndex < totalSteps - 1);
       let validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
       if (validationError)
         return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
@@ -5970,7 +6029,7 @@ function resolveResumeTarget(params, state, options = {}) {
   }
   throw foregroundError && !isAsyncRunNotFound(asyncError) || foregroundError ? foregroundError : asyncError || new Error("Run not found. Provide id or runId.");
 }
-function getAsyncInterruptTarget(state, runId, location, options = {}) {
+function getAsyncInterruptTarget(state, runId, location) {
   if (location?.asyncDir)
     return {
       asyncId: location.resolvedId ?? runId ?? path15.basename(location.asyncDir),
@@ -5978,10 +6037,7 @@ function getAsyncInterruptTarget(state, runId, location, options = {}) {
     };
   if (runId) {
     let direct = state.asyncJobs.get(runId);
-    if (direct)
-      return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
-    if (options.fallbackToNewest === !1)
-      return;
+    return direct ? { asyncId: direct.asyncId, asyncDir: direct.asyncDir } : void 0;
   }
   let newest;
   for (let job of state.asyncJobs.values())
@@ -6008,6 +6064,12 @@ function interruptAsyncRun(state, runId, kill, location) {
   if (!target)
     return null;
   let status = reconcileAsyncRun(target.asyncDir, { kill }).status;
+  if (state.currentSessionId && status?.sessionId !== state.currentSessionId)
+    return {
+      content: [{ type: "text", text: `Async run '${target.asyncId}' was not found in the active session.` }],
+      isError: !0,
+      details: { mode: "management", results: [] }
+    };
   if (!status || status.state !== "running" || typeof status.pid != "number")
     return {
       content: [{ type: "text", text: `No running async run with an interrupt-capable pid was found for '${runId ?? "current"}'.` }],
@@ -6031,7 +6093,7 @@ function interruptAsyncRun(state, runId, kill, location) {
   }
 }
 function stopAsyncRun(state, runId, kill, location) {
-  let target = getAsyncInterruptTarget(state, runId, location, { fallbackToNewest: !1 });
+  let target = getAsyncInterruptTarget(state, runId, location);
   if (!target)
     return null;
   let status = reconcileAsyncRun(target.asyncDir, { kill }).status;
@@ -7541,7 +7603,17 @@ async function runForegroundParallelTasks(input) {
     }).finally(() => {
       input.foregroundControl?.currentIndex === index && (input.foregroundControl.interrupt = void 0, input.foregroundControl.updatedAt = Date.now());
     });
-  }, input.globalSemaphore);
+  }, input.globalSemaphore, {
+    signal: input.signal,
+    onAbort: (task) => ({
+      agent: task.agent,
+      task: task.task ?? "",
+      exitCode: 1,
+      messages: [],
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+      error: "Subagent launch cancelled."
+    })
+  });
 }
 async function runParallelPath(data, deps) {
   let { params, effectiveCwd, agents, ctx, signal, runId, sessionDirForIndex, sessionFileForIndex, sessionFileForTask, thinkingOverrideForTask, shareEnabled, artifactConfig, artifactsDir, backgroundRequestedWhileClarifying, onUpdate, sessionRoot, controlConfig, contextPolicy } = data, onControlEvent = createForegroundControlNotifier(data, deps), childIntercomTarget = data.intercomBridge.active ? resolveSubagentIntercomTarget : void 0, allProgress = [], allArtifactPaths = [], tasks = params.tasks, maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks), parallelConcurrency = resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency);
@@ -8155,7 +8227,14 @@ function createSubagentExecutor(deps) {
         };
       }
       if (action === "interrupt") {
-        let targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id, resolved;
+        let targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
+        if (targetRunId !== void 0 && !targetRunId.trim())
+          return {
+            content: [{ type: "text", text: "Explicit interrupt id must be non-empty." }],
+            isError: !0,
+            details: { mode: "management", results: [] }
+          };
+        let resolved;
         if (targetRunId)
           try {
             resolved = resolveSubagentRunId(targetRunId, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });

package/dist/node-runtime/{tavily-WEZFVFP7.js → tavily-KZBFYQB6.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   activityMonitor
-} from "./chunk-DAPBPCBP.js";
+} from "./chunk-IPP5BIV5.js";
 import {
   getWebSearchConfigPath
 } from "./chunk-VRB2IYGG.js";

package/dist/node-runtime/{theme-UOO5RVFN.js → theme-YLVZKKZD.js}

@@ -30,8 +30,8 @@ import {
   setThemeInstance,
   stopThemeWatcher,
   theme
-} from "./chunk-RDDAZOMU.js";
-import "./chunk-FQMM2EZ2.js";
+} from "./chunk-JL4HYQXK.js";
+import "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 export {

package/dist/node-runtime/{trust-manager-MMISNCYO.js → trust-manager-ZCU76D23.js}

@@ -4,9 +4,9 @@ import {
   getProjectTrustOptions,
   getProjectTrustParentPath,
   hasTrustRequiringProjectResources
-} from "./chunk-HTFRRDSF.js";
+} from "./chunk-F2SMQ6ES.js";
 import "./chunk-URD2SLIT.js";
-import "./chunk-FQMM2EZ2.js";
+import "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 export {