@ashx-j/lunr 0.2.26 → 0.2.27

package/dist/node-runtime/{subagent-executor-LPZ4BHWE.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-2CFDTH5B.js";
+} from "./chunk-RLGY2QIL.js";
 import {
   DEFAULT_CONTROL_CONFIG,
   buildControlEvent,
@@ -197,35 +196,38 @@ import {
   READ_ONLY_WRITE_SPAWN_ERROR,
   resolveChildPermissions,
   snapshotParentPermissionMode
-} from "./chunk-PTFBPO3C.js";
-import "./chunk-YWOJIGFY.js";
+} from "./chunk-ZEVFBFNF.js";
+import "./chunk-YSB6URMT.js";
+import "./chunk-6ZZHGUSA.js";
 import "./chunk-53YJI7JU.js";
-import "./chunk-5ZQXRPMC.js";
-import "./chunk-XHIRAZ26.js";
-import "./chunk-5Q4A37RB.js";
+import "./chunk-IAZSK7KK.js";
+import "./chunk-TCT6PCUR.js";
 import {
   subagentCommunicationEnabled
-} from "./chunk-I74LN5JG.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-WIF24I7G.js";
-import "./chunk-M3LZLQW2.js";
+import {
+  resolveSubagentRequestParams
+} from "./chunk-APVM5NEU.js";
+import "./chunk-F2V2F4ZG.js";
+import "./chunk-BDRGN3L2.js";
 import "./chunk-FY4A63RK.js";
-import "./chunk-KKUTQQV7.js";
-import "./chunk-CSFI6YXL.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";
 
@@ -1346,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)
@@ -1783,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);
@@ -1805,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() {
@@ -1841,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;
@@ -1900,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;
@@ -2048,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",
@@ -2064,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();
@@ -2100,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));
     }
@@ -3412,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 = {}) => ({
@@ -5988,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),
@@ -5996,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())
@@ -6026,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"}'.` }],
@@ -6049,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;
@@ -7559,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);
@@ -8173,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 {

package/dist/node-runtime/{update-cli-HNMOTNGX.js → update-cli-F3XXJANQ.js}

@@ -2,18 +2,18 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   checkForUpdate,
   isPublishedInstall
-} from "./chunk-KWA4OC2J.js";
+} from "./chunk-H6YBCWKG.js";
 import "./chunk-DVGWF6A2.js";
 import {
   SettingsManager
-} from "./chunk-I74LN5JG.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-FY4A63RK.js";
 import "./chunk-UJOCPOMX.js";
 import "./chunk-IMLCWLPI.js";
-import "./chunk-B4HP6ZWM.js";
+import "./chunk-RHCGYWO7.js";
 import {
   APP_NAME,
   NPM_CLI_PACKAGE,
@@ -23,7 +23,7 @@ import {
   getPackageDir,
   spawnProcess,
   waitForChildProcess
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 

package/dist/node-runtime/{usage-service-LFB2SWYV.js → usage-service-CPAGBED5.js}

@@ -15,7 +15,7 @@ import {
   pickPlanWindow,
   planUsageAuthError,
   registerUsageServiceBridge
-} from "./chunk-2MI5OPMN.js";
+} from "./chunk-HNNHHJAB.js";
 import "./chunk-IMLCWLPI.js";
 import "./chunk-BRJX2PRC.js";
 export {

package/dist/node-runtime/{video-extract-OOZHR7SU.js → video-extract-UPKYIBW3.js}

@@ -11,11 +11,11 @@ import {
 } from "./chunk-3WFAEVKS.js";
 import {
   extractHeadingTitle
-} from "./chunk-UQUCFAJ3.js";
-import "./chunk-NAY6UUQZ.js";
+} from "./chunk-2VIW3IMF.js";
+import "./chunk-WDIVLMOH.js";
 import {
   activityMonitor
-} from "./chunk-DAPBPCBP.js";
+} from "./chunk-IPP5BIV5.js";
 import {
   getWebSearchConfigPath,
   mapFfmpegError,