@letta-ai/letta-code 0.34.18 → 0.34.19

package/letta.js

@@ -5941,7 +5941,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.34.18",
+    version: "0.34.19",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -6216,7 +6216,7 @@ var init_package = __esm(() => {
     },
     lettaLifecycleProtocol: 1,
     lettaRuntimeGraphProtocol: 1,
-    lettaRuntimeGraphSha512: "sha512-cubBaizY8rbgiq9dfHU/uRyZBgkGvLfJc+8+ovpV1raZnQjE+tRsAKFAKP69UHWhNFRE49viVTyqmLIiSK8v8Q=="
+    lettaRuntimeGraphSha512: "sha512-RWgzMK/RLJluHmJEAXwWV7NZe1gpOgg3BYpp8+G8QfqsXUUmzZgQpQz5E9CHogeIwfcGzCaHAUIdboH6Ir7KyA=="
   };
 });
 
@@ -6488,6 +6488,7 @@ function telemetryChannel(value) {
     return;
   return [
     "slack",
+    "microsoftteams",
     "microsoftTeams",
     "telegram",
     "discord",
@@ -172634,6 +172635,16 @@ var init_message_queue_bridge = __esm(() => {
   pendingMessages = [];
 });
 
+// src/utils/subagent-scope.ts
+function subagentScopeMatches(parentAgentId, parentConversationId, scope) {
+  if (scope.agentId !== undefined && parentAgentId !== scope.agentId) {
+    return false;
+  }
+  if (scope.conversationId === undefined)
+    return true;
+  return parentConversationId === undefined || parentConversationId === scope.conversationId;
+}
+
 // src/utils/task-notifications.ts
 function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -172742,6 +172753,47 @@ function appendTaskNotificationEventsToBuffer(summaries, buffer, generateId, flu
   flush?.();
   return true;
 }
+function selectStopFailedNotifications(rows, seenIds, scope) {
+  const failures = [];
+  const stops = [];
+  for (const row of rows) {
+    if (!subagentScopeMatches(row.parentAgentId, row.parentConversationId, scope)) {
+      continue;
+    }
+    if (row.stopFailed && (row.status === "pending" || row.status === "running")) {
+      const key2 = `${row.id}:${row.stopOutcome?.attempt ?? 0}`;
+      if (!seenIds.has(key2)) {
+        seenIds.add(key2);
+        failures.push(`Background task "${row.description}" could not be stopped — still running remotely. Press Esc to retry.`);
+      }
+      continue;
+    }
+    if (row.stopOutcome?.kind === "stopped" && row.status === "error") {
+      const key2 = `${row.id}:${row.stopOutcome.attempt}`;
+      if (!seenIds.has(key2)) {
+        let surfacedEarlierFailure = false;
+        for (let attempt2 = 0;attempt2 < row.stopOutcome.attempt; attempt2 += 1) {
+          if (seenIds.has(`${row.id}:${attempt2}`)) {
+            surfacedEarlierFailure = true;
+            break;
+          }
+        }
+        if (surfacedEarlierFailure) {
+          seenIds.add(key2);
+          stops.push(`Background task "${row.description}" stopped.`);
+        }
+      }
+    }
+  }
+  const present = new Set(rows.map((row) => row.id));
+  for (const key2 of seenIds) {
+    const rowId = key2.slice(0, key2.lastIndexOf(":"));
+    if (!present.has(rowId)) {
+      seenIds.delete(key2);
+    }
+  }
+  return { failures, stops };
+}
 var init_task_notifications = __esm(() => {
   init_context();
   init_constants2();
@@ -210828,7 +210880,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.34.18"
+    version: "0.34.19"
   };
 });
 
@@ -214963,7 +215015,7 @@ Do not use this tool for root memory files (already loaded) or skills/ (use Skil
 var init_Memory = () => {};
 
 // src/tools/descriptions/Monitor.md
-var Monitor_default = 'Start a background monitor that streams events from a long-running script. Each stdout line is an event — you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you\'re waiting for the user to answer a question.\n\nPick by how many notifications you need:\n- **One** ("tell me when the server is ready / the build finishes") → use **Bash with `run_in_background`** and a command that exits when the condition is true, e.g. `until grep -q "Ready in" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits.\n- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") → Monitor with an unbounded command (`tail -f`, `inotifywait -m`, `while true`).\n- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") → Monitor with a command that emits lines and then exits.\n\nYour script\'s stdout is the event stream. Each line becomes a notification. Exit ends the watch.\n  # Each matching log line is an event\n  tail -f /var/log/app.log | grep --line-buffered "ERROR"\n  # Each file change is an event\n  inotifywait -m --format \'%e %f\' /watched/dir\n  # Node script that emits events as they arrive (e.g. WebSocket listener)\n  node watch-for-events.js\n\nFor open github.com pull requests, use WatchPR instead. It covers the whole PR surface and keeps watching after CI finishes. Use Monitor only when WatchPR does not apply.\n\n**Don\'t use an unbounded command for a single notification.** `tail -f`, `inotifywait -m`, and `while true` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash `run_in_background` with an `until` loop instead (one notification, ends in seconds). Note that `tail -f log | grep -m 1 ...` does *not* fix this: if the log goes quiet after the match, `tail` never receives SIGPIPE and the pipeline hangs anyway.\n\n- Every pipe stage must flush per line or matches sit in its buffer unseen: `grep` needs `--line-buffered`, `awk` needs `fflush()`. `head` cannot flush at all — `| head -N` delivers nothing until N matches accumulate, then ends the stream.\n- In poll loops, handle transient failures (`curl ... || true`) — one failed request shouldn\'t kill the monitor.\n- Poll intervals: 30s+ for remote APIs (rate limits), 0.5–1s for local checks.\n- Write a specific `description` — it appears in every notification ("errors in deploy.log" not "watching logs").\n- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications — for a command you run directly (e.g. `python train.py 2>&1 | grep --line-buffered ...`), merge stderr with `2>&1` so its failures reach your filter. (No effect on `tail -f` of an existing log — that file only contains what its writer redirected.)\n\n**Coverage — silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit — and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.\n  # Wrong — silent on crash, hang, or any non-success exit\n  tail -f run.log | grep --line-buffered "elapsed_steps="\n  # Right — one alternation covering progress + the failure signatures you\'d act on\n  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"\n\nFor poll loops checking job state, emit on every terminal status (`succeeded|failed|cancelled|timeout`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it — some extra noise is better than missing a crashloop.\n\n**Output volume**: Every stdout line is a conversation message, so the filter should be selective — but selective means "the lines you\'d act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.\n\nStdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.\n\nThe script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). Timeout → killed. Set `persistent: true` for session-length watches (log tails, long-lived event streams) — the monitor runs until you call TaskStop or the session ends. Use TaskStop to cancel early.\n\nWhen someone is waiting on the result, set `backup_after_seconds` (e.g. 900). If the monitor goes that long without an event, a durable Wake brings you back to check the real state, so a queued, hung, or dead watch can\'t leave them waiting in silence.\n\n**ws source** — open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.\n    ws: {url: \'wss://events.example.com/stream\', protocols: [\'v1\']},\n    description: \'deploy events\',\n\nEach text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as `[binary frame, N bytes]` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash — a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.\n\nPrefer this over `command: \'websocat wss://…\'` — it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.\n';
+var Monitor_default = 'Start a background monitor that streams events from a long-running script. Each stdout line is an event — you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you\'re waiting for the user to answer a question.\n\nPick by how many notifications you need:\n- **One** ("tell me when the server is ready / the build finishes") → use **Bash with `run_in_background`** and a command that exits when the condition is true, e.g. `until grep -q "Ready in" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits.\n- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") → Monitor with an unbounded command (`tail -f`, `inotifywait -m`, `while true`).\n- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") → Monitor with a command that emits lines and then exits.\n\nYour script\'s stdout is the event stream. Each line becomes a notification. Exit ends the watch.\n  # Each matching log line is an event\n  tail -f /var/log/app.log | grep --line-buffered "ERROR"\n  # Each file change is an event\n  inotifywait -m --format \'%e %f\' /watched/dir\n  # Node script that emits events as they arrive (e.g. WebSocket listener)\n  node watch-for-events.js\n\nFor open github.com pull requests, use WatchPR instead. It covers the whole PR surface and keeps watching after CI finishes. Use Monitor only when WatchPR does not apply.\n\n**Don\'t use an unbounded command for a single notification.** `tail -f`, `inotifywait -m`, and `while true` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash `run_in_background` with an `until` loop instead (one notification, ends in seconds). Note that `tail -f log | grep -m 1 ...` does *not* fix this: if the log goes quiet after the match, `tail` never receives SIGPIPE and the pipeline hangs anyway.\n\n- Every pipe stage must flush per line or matches sit in its buffer unseen: `grep` needs `--line-buffered`, `awk` needs `fflush()`. `head` cannot flush at all — `| head -N` delivers nothing until N matches accumulate, then ends the stream.\n- In poll loops, handle transient failures (`curl ... || true`) — one failed request shouldn\'t kill the monitor.\n- Poll intervals: 30s+ for remote APIs (rate limits), 0.5–1s for local checks.\n- Write a specific `description` — it appears in every notification ("errors in deploy.log" not "watching logs").\n- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications — for a command you run directly (e.g. `python train.py 2>&1 | grep --line-buffered ...`), merge stderr with `2>&1` so its failures reach your filter. (No effect on `tail -f` of an existing log — that file only contains what its writer redirected.)\n\n**Coverage — silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit — and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.\n  # Wrong — silent on crash, hang, or any non-success exit\n  tail -f run.log | grep --line-buffered "elapsed_steps="\n  # Right — one alternation covering progress + the failure signatures you\'d act on\n  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"\n\nFor poll loops checking job state, emit on every terminal status (`succeeded|failed|cancelled|timeout`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it — some extra noise is better than missing a crashloop.\n\n**Output volume**: Every stdout line is a conversation message, so the filter should be selective — but selective means "the lines you\'d act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.\n\nStdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.\n\nThe script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). Timeout → killed. Set `persistent: true` for session-length watches (log tails, long-lived event streams). In managed Cloud sandboxes, every monitor stops after at most 1 hour, including persistent monitors; elsewhere persistent monitors run until TaskStop or session end. For longer Cloud waits, schedule a Wake or cron (which does not keep the sandbox running between turns) and combine it with shorter monitors. Use TaskStop to cancel early.\n\nWhen someone is waiting on the result, set `backup_after_seconds` (e.g. 900). If the monitor goes that long without an event, a durable Wake brings you back to check the real state, so a queued, hung, or dead watch can\'t leave them waiting in silence.\n\n**ws source** — open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.\n    ws: {url: \'wss://events.example.com/stream\', protocols: [\'v1\']},\n    description: \'deploy events\',\n\nEach text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as `[binary frame, N bytes]` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash — a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.\n\nPrefer this over `command: \'websocat wss://…\'` — it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.\n';
 var init_Monitor = () => {};
 
 // src/tools/descriptions/Read.md
@@ -215486,6 +215538,8 @@ var init_Wake = () => {};
 // src/tools/descriptions/WatchPR.md
 var WatchPR_default = `Watch one open github.com pull request until it merges, closes, is stopped with TaskStop, or the session ends.
 
+In managed Cloud sandboxes, WatchPR also stops after a hard 1-hour limit and sends a timeout notification. For checks beyond that window, use Wake or cron (which does not keep the sandbox running between turns) and combine it with shorter watches. Local watches have no duration limit.
+
 Use WatchPR instead of writing a Monitor or shell polling loop when you need ongoing notifications about a PR. Start at most one watch per PR. It reports:
 
 - current-head check failures, recoveries, retries, and completion;
@@ -221142,12 +221196,55 @@ var init_disk_space = __esm(() => {
 var exports_approval_execution = {};
 __export(exports_approval_execution, {
   settleApprovalExecutionTasks: () => settleApprovalExecutionTasks,
+  overlayPartialResults: () => overlayPartialResults,
+  isUserAbortError: () => isUserAbortError,
   getResourceKey: () => getResourceKey,
   getDisplayableToolReturn: () => getDisplayableToolReturn,
   executeAutoAllowedTools: () => executeAutoAllowedTools,
-  executeApprovalBatch: () => executeApprovalBatch
+  executeApprovalBatch: () => executeApprovalBatch,
+  buildDeniedResults: () => buildDeniedResults,
+  buildCompanionResults: () => buildCompanionResults,
+  appendAbortPartials: () => appendAbortPartials,
+  ABORT_GRACE_MS: () => ABORT_GRACE_MS
 });
 import * as path16 from "node:path";
+function isUserAbortError(error5) {
+  return error5 instanceof APIUserAbortError || error5 instanceof Error && (error5.name === "AbortError" || error5.message === INTERRUPTED_BY_USER || error5.message === "The operation was aborted");
+}
+function overlayPartialResults(queued, partials) {
+  const realById = new Map((partials ?? []).map((r5) => [r5.tool_call_id, r5]));
+  const overlaid = (queued ?? []).map((r5) => realById.get(r5.tool_call_id) ?? r5);
+  const queuedIds = new Set((queued ?? []).map((r5) => r5.tool_call_id));
+  const extras = (partials ?? []).filter((r5) => !queuedIds.has(r5.tool_call_id));
+  return [...overlaid, ...extras];
+}
+function buildDeniedResults(autoDenied) {
+  return autoDenied.map((ad) => ({
+    type: "approval",
+    tool_call_id: ad.approval.toolCallId,
+    approve: false,
+    reason: ad.reason
+  }));
+}
+function buildCompanionResults(autoHandled, autoDenied) {
+  return [
+    ...autoHandled.map((ar) => ({
+      type: "tool",
+      tool_call_id: ar.toolCallId,
+      tool_return: ar.result.toolReturn,
+      status: ar.result.status,
+      stdout: ar.result.stdout,
+      stderr: ar.result.stderr
+    })),
+    ...buildDeniedResults(autoDenied)
+  ];
+}
+function appendAbortPartials(error5, extras) {
+  if (extras.length === 0 || !isUserAbortError(error5))
+    return;
+  const abortError = error5;
+  abortError.partialResults = [...abortError.partialResults ?? [], ...extras];
+}
 function getDisplayableToolReturn(content) {
   if (typeof content === "string") {
     return content;
@@ -221284,8 +221381,61 @@ async function executeSingleDecision(decision, onChunk, options) {
 async function executeApprovalBatch(decisions, onChunk, options) {
   return watchDiskSpaceDuring(options?.workingDirectory ?? getCurrentWorkingDirectory(), (text2) => deliverDiskSpaceReminder(text2, options?.parentScope), () => executeApprovalBatchUnwatched(decisions, onChunk, options));
 }
-async function settleApprovalExecutionTasks(tasks, partialResults = () => []) {
-  const settled = await Promise.allSettled(tasks);
+async function settleApprovalExecutionTasks(tasks, partialResults = () => [], options) {
+  const signal = options?.abortSignal;
+  if (!signal || signal.aborted) {
+    throwFirstSettledRejection(await Promise.allSettled(tasks), partialResults);
+    return;
+  }
+  const settled = new Array(tasks.length);
+  let remaining = tasks.length;
+  const tracked = tasks.map((task, index) => task.then(() => {
+    settled[index] = { status: "fulfilled", value: undefined };
+  }, (reason) => {
+    settled[index] = { status: "rejected", reason };
+  }).finally(() => {
+    remaining -= 1;
+  }));
+  let onAbort = () => {};
+  const aborted2 = new Promise((resolve20) => {
+    onAbort = resolve20;
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    await Promise.race([Promise.all(tracked).then(() => {
+      return;
+    }), aborted2]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+  if (remaining === 0) {
+    throwFirstSettledRejection(settled, partialResults);
+    return;
+  }
+  let graceTimer;
+  const graceExpired = new Promise((resolve20) => {
+    graceTimer = setTimeout(resolve20, ABORT_GRACE_MS);
+  });
+  try {
+    await Promise.race([
+      Promise.all(tracked).then(() => {
+        return;
+      }),
+      graceExpired
+    ]);
+  } finally {
+    clearTimeout(graceTimer);
+  }
+  if (remaining === 0) {
+    throwFirstSettledRejection(settled, partialResults);
+    return;
+  }
+  throwFirstSettledRejection(settled.filter((result2) => result2 !== undefined), partialResults);
+  const error5 = signal.reason instanceof Error ? signal.reason : new Error(INTERRUPTED_BY_USER);
+  Object.assign(error5, { partialResults: partialResults() });
+  throw error5;
+}
+function throwFirstSettledRejection(settled, partialResults) {
   for (const result2 of settled) {
     if (result2.status !== "rejected")
       continue;
@@ -221299,6 +221449,19 @@ async function executeApprovalBatchUnwatched(decisions, onChunk, options) {
     workingDirectory: options.workingDirectory
   })).contextId : undefined);
   const results = new Array(decisions.length).fill(null);
+  let batchDiscarded = false;
+  const guardedOnChunk = onChunk ? (chunk2) => {
+    if (!batchDiscarded)
+      onChunk(chunk2);
+  } : undefined;
+  const guardedOptions = options?.onStreamingOutput ? {
+    ...options,
+    onStreamingOutput: (toolCallId, chunk2, isStderr) => {
+      if (!batchDiscarded) {
+        options.onStreamingOutput?.(toolCallId, chunk2, isStderr);
+      }
+    }
+  } : options;
   const parallelIndices = [];
   const writeToolsByResource = new Map;
   const denyIndices = [];
@@ -221334,11 +221497,11 @@ async function executeApprovalBatchUnwatched(decisions, onChunk, options) {
     const decision = decisions[i4];
     if (decision) {
       let crossedEffectBoundary = false;
-      const result2 = await executeSingleDecision(decision, onChunk, {
-        ...options,
+      const result2 = await executeSingleDecision(decision, guardedOnChunk, {
+        ...guardedOptions,
         toolContextId,
         beforeToolExecution: async (toolCallId) => {
-          await options?.beforeToolExecution?.(toolCallId);
+          await guardedOptions?.beforeToolExecution?.(toolCallId);
           crossedEffectBoundary = true;
         }
       });
@@ -221348,15 +221511,20 @@ async function executeApprovalBatchUnwatched(decisions, onChunk, options) {
       }
     }
   };
-  await settleApprovalExecutionTasks([
-    ...parallelIndices.map(execute),
-    ...denyIndices.map(execute),
-    ...Array.from(writeToolsByResource.values()).map(async (indices) => {
-      for (const i4 of indices) {
-        await execute(i4);
-      }
-    })
-  ], () => results.filter((result2) => result2 !== null));
+  try {
+    await settleApprovalExecutionTasks([
+      ...parallelIndices.map(execute),
+      ...denyIndices.map(execute),
+      ...Array.from(writeToolsByResource.values()).map(async (indices) => {
+        for (const i4 of indices) {
+          await execute(i4);
+        }
+      })
+    ], () => results.filter((result2) => result2 !== null), { abortSignal: options?.abortSignal });
+  } catch (error5) {
+    batchDiscarded = true;
+    throw error5;
+  }
   return results.filter((r5) => r5 !== null);
 }
 async function executeAutoAllowedTools(autoAllowed, onChunk, options) {
@@ -221375,8 +221543,9 @@ async function executeAutoAllowedTools(autoAllowed, onChunk, options) {
     }
   }));
 }
-var PARALLEL_SAFE_TOOLS, FILE_PATH_TOOLS, GLOBAL_LOCK_TOOLS;
+var ABORT_GRACE_MS = 500, PARALLEL_SAFE_TOOLS, FILE_PATH_TOOLS, GLOBAL_LOCK_TOOLS;
 var init_approval_execution = __esm(async () => {
+  init_error();
   init_constants2();
   init_disk_space();
   init_runtime_context();
@@ -222374,14 +222543,23 @@ function scheduleCompletedSubagentCleanup(id2) {
     return;
   }
   clearCompletedSubagentCleanup(id2);
+  armCompletedSubagentCleanup(id2);
+}
+function armCompletedSubagentCleanup(id2) {
+  const agent = store2.agents.get(id2);
+  if (!agent)
+    return;
   const timer = setTimeout(() => {
+    completedSubagentCleanupTimers.delete(id2);
     const current = store2.agents.get(id2);
     if (!current || current.status !== "completed" && current.status !== "error") {
-      completedSubagentCleanupTimers.delete(id2);
+      return;
+    }
+    if (current.cancelPending) {
+      armCompletedSubagentCleanup(id2);
       return;
     }
     store2.agents.delete(id2);
-    completedSubagentCleanupTimers.delete(id2);
     notifyListeners();
   }, agent.result !== undefined ? publishedResultRetentionMs : completedSubagentRetentionMs);
   unrefTimer2(timer);
@@ -222471,6 +222649,7 @@ function completeSubagent(id2, result2) {
     ...agent,
     status: result2.success ? "completed" : "error",
     error: result2.error,
+    stopFailed: undefined,
     ...result2.result !== undefined ? { result: result2.result } : {},
     durationMs: Date.now() - agent.startTime,
     totalTokens: result2.totalTokens ?? agent.totalTokens,
@@ -222527,6 +222706,8 @@ function clearCompletedSubagents() {
   for (const [id2, agent] of store2.agents.entries()) {
     if (agent.result !== undefined)
       continue;
+    if (agent.cancelPending)
+      continue;
     if (agent.status === "completed" || agent.status === "error") {
       clearCompletedSubagentCleanup(id2);
       store2.agents.delete(id2);
@@ -222540,6 +222721,11 @@ function clearCompletedSubagents() {
 function clearSubagentsByIds(ids) {
   let removedAny = false;
   for (const id2 of ids) {
+    const agent = store2.agents.get(id2);
+    if (agent?.cancelPending) {
+      updateSubagent(id2, { silent: true });
+      continue;
+    }
     clearCompletedSubagentCleanup(id2);
     removedAny = store2.agents.delete(id2) || removedAny;
   }
@@ -222555,15 +222741,28 @@ function hasActiveSubagents() {
   }
   return false;
 }
-function interruptActiveSubagents(errorMessage) {
+function registerSubagentAbortHook(id2, hook) {
+  subagentAbortHooks.set(id2, hook);
+}
+function clearSubagentAbortHook(id2) {
+  subagentAbortHooks.delete(id2);
+}
+function interruptActiveSubagents(errorMessage, scope) {
   let anyInterrupted = false;
   for (const [id2, agent] of store2.agents.entries()) {
     if (agent.status === "pending" || agent.status === "running") {
+      if (scope && !subagentMatchesScope(agent, scope))
+        continue;
+      const hook = subagentAbortHooks.get(id2);
+      hook?.();
+      subagentAbortHooks.delete(id2);
       const updatedAgent = {
         ...agent,
         status: "error",
         error: errorMessage,
-        durationMs: Date.now() - agent.startTime
+        durationMs: Date.now() - agent.startTime,
+        ...hook ? { cancelPending: true, stopAttempts: (agent.stopAttempts ?? 0) + 1 } : {},
+        stopFailed: undefined
       };
       store2.agents.set(id2, updatedAgent);
       scheduleCompletedSubagentCleanup(id2);
@@ -222574,6 +222773,50 @@ function interruptActiveSubagents(errorMessage) {
     notifyListeners();
   }
 }
+function interruptStopFailedSubagents(errorMessage, scope) {
+  const interrupted = [];
+  for (const [id2, agent] of store2.agents.entries()) {
+    if (!agent.stopFailed)
+      continue;
+    if (agent.status !== "pending" && agent.status !== "running")
+      continue;
+    if (scope && !subagentMatchesScope(agent, scope))
+      continue;
+    const hook = subagentAbortHooks.get(id2);
+    hook?.();
+    subagentAbortHooks.delete(id2);
+    const updatedAgent = {
+      ...agent,
+      status: "error",
+      error: errorMessage,
+      durationMs: Date.now() - agent.startTime,
+      ...hook ? { cancelPending: true, stopAttempts: (agent.stopAttempts ?? 0) + 1 } : {},
+      stopFailed: undefined
+    };
+    store2.agents.set(id2, updatedAgent);
+    scheduleCompletedSubagentCleanup(id2);
+    interrupted.push(id2);
+  }
+  if (interrupted.length > 0) {
+    notifyListeners();
+  }
+  return interrupted;
+}
+function subagentMatchesScope(agent, scope) {
+  return subagentScopeMatches(agent.parentAgentId, agent.parentConversationId, scope);
+}
+function hasStopFailedSubagents(scope) {
+  for (const agent of store2.agents.values()) {
+    if (!agent.stopFailed)
+      continue;
+    if (agent.status !== "pending" && agent.status !== "running")
+      continue;
+    if (scope && !subagentMatchesScope(agent, scope))
+      continue;
+    return true;
+  }
+  return false;
+}
 function subscribe2(listener) {
   store2.listeners.add(listener);
   return () => {
@@ -222594,7 +222837,7 @@ function emitStreamEvent(subagentId, event) {
     listener(subagentId, event);
   }
 }
-var store2, cachedSnapshot, cachedLifecycleItems, DEFAULT_COMPLETED_SUBAGENT_RETENTION_MS = 30000, completedSubagentRetentionMs, DEFAULT_PUBLISHED_RESULT_RETENTION_MS, publishedResultRetentionMs, completedSubagentCleanupTimers, subagentCounter = 0, streamEventListeners;
+var store2, cachedSnapshot, cachedLifecycleItems, DEFAULT_COMPLETED_SUBAGENT_RETENTION_MS = 30000, completedSubagentRetentionMs, DEFAULT_PUBLISHED_RESULT_RETENTION_MS, publishedResultRetentionMs, completedSubagentCleanupTimers, subagentCounter = 0, subagentAbortHooks, streamEventListeners;
 var init_subagent_state = __esm(() => {
   store2 = {
     agents: new Map,
@@ -222610,6 +222853,7 @@ var init_subagent_state = __esm(() => {
   DEFAULT_PUBLISHED_RESULT_RETENTION_MS = 30 * 60000;
   publishedResultRetentionMs = DEFAULT_PUBLISHED_RESULT_RETENTION_MS;
   completedSubagentCleanupTimers = new Map;
+  subagentAbortHooks = new Map;
   streamEventListeners = new Set;
 });
 
@@ -223128,10 +223372,37 @@ var init_tool_registry = __esm(() => {
 });
 
 // src/tools/external-tool-background.ts
+function interruptedExternalToolResult(toolName2) {
+  return {
+    status: "error",
+    toolReturn: `External tool call interrupted by user: ${toolName2}. The remote tool may still finish; its outcome is unknown. Check the destination before retrying a write.`
+  };
+}
+function raceExternalOperationAbort(operation, signal, toolName2) {
+  if (signal.aborted) {
+    return Promise.resolve(interruptedExternalToolResult(toolName2));
+  }
+  return new Promise((resolve21, reject2) => {
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      cleanup();
+      resolve21(interruptedExternalToolResult(toolName2));
+    };
+    signal.addEventListener("abort", onAbort);
+    operation.then((result2) => {
+      cleanup();
+      resolve21(result2);
+    }, (error5) => {
+      cleanup();
+      reject2(error5);
+    });
+  });
+}
 function notificationText(toolReturn) {
   return scrubAmbientSecrets(String(toolReturn));
 }
 async function autoBackgroundExternalTool(toolName2, tool, operation, options) {
+  const signal = options?.signal;
   const runtime = options?.runtimeScope;
   const scope = options?.scope ?? (runtime?.agentId && runtime.conversationId ? {
     agentId: runtime.agentId,
@@ -223140,24 +223411,36 @@ async function autoBackgroundExternalTool(toolName2, tool, operation, options) {
   } : undefined);
   const canBackground = () => typeof options?.canBackground === "function" ? options.canBackground() : options?.canBackground !== false;
   if (tool?.autoBackground !== true || !canBackground() || !scope || !options?.enqueue && !isQueueBridgeConnected())
-    return operation;
+    return signal ? raceExternalOperationAbort(operation, signal, toolName2) : operation;
   const startedAt = Date.now();
   const settled = operation.then((result2) => ({ kind: "result", result: result2 }), (error5) => ({ kind: "error", error: error5 }));
   let timer;
+  let onAbort;
+  const abortSettled = signal ? new Promise((resolve21) => {
+    onAbort = () => resolve21({ kind: "aborted" });
+    signal?.addEventListener("abort", onAbort);
+  }) : undefined;
   const first = await Promise.race([
     settled,
     new Promise((resolve21) => {
       timer = setTimeout(() => resolve21({ kind: "yield" }), options?.yieldMs ?? DEFAULT_EXTERNAL_TOOL_YIELD_MS);
-    })
+    }),
+    ...abortSettled ? [abortSettled] : []
   ]);
   if (timer !== undefined)
     clearTimeout(timer);
+  if (onAbort !== undefined && signal) {
+    signal.removeEventListener("abort", onAbort);
+  }
+  if (first.kind === "aborted")
+    return interruptedExternalToolResult(toolName2);
   if (first.kind === "result")
     return first.result;
   if (first.kind === "error")
     throw first.error;
-  if (!canBackground())
-    return operation;
+  if (!canBackground()) {
+    return signal ? raceExternalOperationAbort(operation, signal, toolName2) : operation;
+  }
   const taskId = `external_${crypto.randomUUID()}`;
   const enqueue = options?.enqueue ?? addToMessageQueue;
   settled.then(async (outcome) => {
@@ -223207,14 +223490,15 @@ function hasActiveToolEndHandlers(events) {
     return false;
   return events.hasHandlers?.("tool_end") ?? true;
 }
-function listenerExternalToolBackgroundOptions(tool, events, runtimeScope) {
+function listenerExternalToolBackgroundOptions(tool, events, runtimeScope, signal) {
   const registration = tool ? listenerRegistrations.get(tool) : undefined;
   const notificationGuard = registration?.createNotificationGuard();
   return {
     canBackground: () => notificationGuard?.isCurrent() === true && !hasActiveToolEndHandlers(events),
     ...registration?.yieldMs !== undefined ? { yieldMs: registration.yieldMs } : {},
     ...notificationGuard ? { shouldEnqueue: notificationGuard.waitUntilCurrent } : {},
-    runtimeScope
+    runtimeScope,
+    ...signal ? { signal } : {}
   };
 }
 var listenerRegistrations;
@@ -228992,7 +229276,6 @@ var LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS, PROJECT_SKILLS_DIR, SKILLS_DIR = ".skil
 var init_skills5 = __esm(() => {
   init_skill_sources();
   LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS = new Set([
-    "curating-memory-palace",
     "image-generation",
     "managing-agent-webhooks",
     "managing-shared-memory",
@@ -230142,7 +230425,7 @@ function getExternalToolsAsClientTools() {
     parameters: tool.parameters
   }));
 }
-async function executeExternalTool(toolCallId, toolName2, input, executorOverride, toolDefinition) {
+async function executeExternalTool(toolCallId, toolName2, input, executorOverride, toolDefinition, signal) {
   const executor = executorOverride ?? getExternalToolExecutor();
   if (!executor) {
     return {
@@ -230154,7 +230437,7 @@ async function executeExternalTool(toolCallId, toolName2, input, executorOverrid
   let success = false;
   try {
     const tool = toolDefinition ?? getExternalToolDefinition(toolName2);
-    const result2 = await executor(toolCallId, toolName2, input, tool ? { tool } : undefined);
+    const result2 = await executor(toolCallId, toolName2, input, tool ? { tool, signal } : undefined);
     success = !result2.isError;
     return {
       toolReturn: clampToolReturnContent(normalizeExternalToolResultContent(result2.content), toolName2),
@@ -230921,7 +231204,7 @@ async function executeToolInner(name, args, options) {
     if (permissionDecision2?.decision !== undefined && permissionDecision2.decision !== "allow") {
       return createModPermissionToolResult(permissionDecision2);
     }
-    return runWithRuntimeContext(executionScope, () => autoBackgroundExternalTool(name, externalTool, executeExternalTool(options?.toolCallId ?? `ext-${Date.now()}`, name, eventArgs2, externalTool?.executor ?? activeExternalExecutor, externalTool), listenerExternalToolBackgroundOptions(externalTool, modEvents, executionScope)));
+    return runWithRuntimeContext(executionScope, () => autoBackgroundExternalTool(name, externalTool, executeExternalTool(options?.toolCallId ?? `ext-${Date.now()}`, name, eventArgs2, externalTool?.executor ?? activeExternalExecutor, externalTool, options?.signal), listenerExternalToolBackgroundOptions(externalTool, modEvents, executionScope, options?.signal)));
   }
   const internalName = resolveInternalToolName(name, activeRegistry);
   const tool = internalName ? activeRegistry.get(internalName) : undefined;
@@ -232383,12 +232666,12 @@ async function runCall(parsed, deps, agentId, stdout) {
   await printJson(stdout, result2);
   return result2.isError === true ? 2 : 0;
 }
-async function callCatalogTool(catalog, deps, agentId, toolName2, args) {
+async function callCatalogTool(catalog, deps, agentId, toolName2, args, options) {
   const tool = catalog.tools.find((candidate) => candidate.schema.name === toolName2);
   if (!tool) {
     throw new McpCliError("tool_not_found", `MCP tool '${toolName2}' is not available`);
   }
-  return tool.target.kind === "client" ? await tool.target.connection.callTool(tool.target.rawName, args) : mcpToolResultFromServer(await runUnifiedMcpTool({
+  return tool.target.kind === "client" ? await tool.target.connection.callTool(tool.target.rawName, args, options) : mcpToolResultFromServer(await runUnifiedMcpTool({
     client: await getServerClient(deps),
     agentId,
     mcpServerId: tool.target.serverId,
@@ -232417,7 +232700,7 @@ function createAgentMcpSession(agentId, deps = {}) {
     return catalog;
   };
   return {
-    callTool: async (toolName2, args) => callCatalogTool(await load(), deps, agentId, toolName2, args),
+    callTool: async (toolName2, args, options) => callCatalogTool(await load(), deps, agentId, toolName2, args, options),
     listTools: async () => (await load()).tools.map((tool) => tool.schema),
     close: async () => {
       closed = true;
@@ -232574,7 +232857,7 @@ async function createScriptToolScope(parentAgentId, signal) {
           isError: result2.status === "error"
         };
       }
-      return (await mcp()).callTool(toolName2, toolArgs);
+      return (await mcp()).callTool(toolName2, toolArgs, signal ? { signal } : {});
     },
     cleanup: async () => {
       await mcpSession?.then((session3) => session3.close()).catch(() => {
@@ -239866,6 +240149,9 @@ var init_monitor_event_stream = __esm(() => {
 // src/tools/impl/monitor.ts
 import { appendFileSync as appendFileSync7, readFileSync as readFileSync35, writeFileSync as writeFileSync27 } from "node:fs";
 import { WebSocket as WebSocket4 } from "ws";
+function getMonitorTimeoutEvent(timeoutMs) {
+  return isManagedCloudRuntime() && timeoutMs === MONITOR_MAX_TIMEOUT_MS ? "Monitor stopped at the 1-hour Cloud sandbox limit. Cloud monitors have a hard 1-hour limit to avoid keeping sandbox resources unnecessarily running. For later checks, schedule a Wake or cron, which does not keep the sandbox running between turns, and combine it with shorter monitors when needed." : "[Monitor timed out — re-arm if needed.]";
+}
 function buildMonitorResult(taskId, timeoutMs, persistent, outputFile) {
   const lifetime = persistent ? "persistent — runs until TaskStop or session end" : `timeout ${timeoutMs}ms`;
   return {
@@ -239975,8 +240261,8 @@ function normalizeMonitorArgs(args) {
   if (typeof normalized.description !== "string") {
     throw new Error("Monitor description is required");
   }
-  if (typeof normalized.timeout_ms !== "number" || !Number.isFinite(normalized.timeout_ms) || normalized.timeout_ms < MIN_TIMEOUT_MS || !normalized.persistent && normalized.timeout_ms > MAX_TIMEOUT_MS) {
-    throw new Error(`Monitor timeout_ms must be between ${MIN_TIMEOUT_MS} and ${MAX_TIMEOUT_MS}`);
+  if (typeof normalized.timeout_ms !== "number" || !Number.isFinite(normalized.timeout_ms) || normalized.timeout_ms < MIN_TIMEOUT_MS || !normalized.persistent && normalized.timeout_ms > MONITOR_MAX_TIMEOUT_MS) {
+    throw new Error(`Monitor timeout_ms must be between ${MIN_TIMEOUT_MS} and ${MONITOR_MAX_TIMEOUT_MS}`);
   }
   if (typeof normalized.persistent !== "boolean") {
     throw new Error("Monitor persistent must be a boolean");
@@ -240008,6 +240294,10 @@ function normalizeMonitorArgs(args) {
     }
     validateWebSocketSource(normalized.ws);
   }
+  if (isManagedCloudRuntime() && normalized.persistent) {
+    normalized.persistent = false;
+    normalized.timeout_ms = MONITOR_MAX_TIMEOUT_MS;
+  }
   return normalized;
 }
 function webSocketDisplayUrl(sourceUrl) {
@@ -240240,7 +240530,7 @@ function startCommandMonitor(args) {
 `);
       queueMonitorEvent({
         taskId,
-        event: "[Monitor timed out — re-arm if needed.]",
+        event: getMonitorTimeoutEvent(args.timeout_ms),
         scope,
         actingUserId,
         secrets: secrets2
@@ -240422,7 +240712,7 @@ function startWebSocketMonitor(args) {
         return;
       queueMonitorEvent({
         taskId,
-        event: "[Monitor timed out — re-arm if needed.]",
+        event: getMonitorTimeoutEvent(args.timeout_ms),
         scope,
         actingUserId,
         secrets: secrets2
@@ -240485,7 +240775,7 @@ function installMonitorProcessExitCleanup() {
   monitorProcessExitCleanupInstalled = true;
   process.once("exit", stopMonitorsForProcessExit);
 }
-var MIN_TIMEOUT_MS = 1000, MAX_TIMEOUT_MS = 3600000, DEFAULT_TIMEOUT_MS4 = 300000, MONITOR_OUTPUT_FILE_BYTES, WEBSOCKET_MAX_PAYLOAD_BYTES, WEBSOCKET_PROTOCOL_PATTERN, monitorProcessExitCleanupInstalled = false;
+var MIN_TIMEOUT_MS = 1000, MONITOR_MAX_TIMEOUT_MS = 3600000, DEFAULT_TIMEOUT_MS4 = 300000, MONITOR_OUTPUT_FILE_BYTES, WEBSOCKET_MAX_PAYLOAD_BYTES, WEBSOCKET_PROTOCOL_PATTERN, monitorProcessExitCleanupInstalled = false;
 var init_monitor = __esm(async () => {
   init_strip_ansi();
   init_runtime_context();
@@ -242270,7 +242560,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.34.18"
+        version: "0.34.19"
       },
       capabilities: null
     });
@@ -242689,6 +242979,22 @@ var init_codex_app_server = __esm(() => {
   DEFAULT_IDLE_TIMEOUT_MS = 5 * 60000;
 });
 
+// src/agent/parent-memory-note.ts
+import { statSync as statSync18 } from "node:fs";
+function buildParentMemoryNote(parentAgentId) {
+  const directory = getScopedMemoryFilesystemRoot(parentAgentId);
+  try {
+    if (!statSync18(directory).isDirectory())
+      return;
+  } catch {
+    return;
+  }
+  return `Your parent agent (${parentAgentId}) keeps its memory as Markdown files at \`${directory}\`; attached shared-memory repos sit next to it. If the task depends on context about the user, project, people or conventions, check there first: start with \`MEMORY.md\` and the directory indexes, then open only the files that look relevant. Don't edit or commit there unless asked.`;
+}
+var init_parent_memory_note = __esm(() => {
+  init_memory_filesystem2();
+});
+
 // src/cli/helpers/agent-info.ts
 function getRelativeTime(dateStr) {
   const date5 = new Date(dateStr);
@@ -242732,10 +243038,13 @@ function buildAgentInfo(options) {
     })();
     const memoryDirLine = showMemoryDir ? `
 - **Memory directory (also stored in \`MEMORY_DIR\` env var)**: \`${getScopedMemoryFilesystemRoot(agentInfo.id)}\`` : "";
+    const parentMemoryNote = options.parentAgentId && options.parentAgentId !== agentInfo.id ? buildParentMemoryNote(options.parentAgentId) : undefined;
+    const parentMemoryLine = parentMemoryNote ? `
+- ${parentMemoryNote}` : "";
     const convLine = conversationId ? `
 - **Conversation ID (also stored in \`CONVERSATION_ID\` env var)**: ${conversationId}` : "";
     return `${SYSTEM_REMINDER_OPEN} This is an automated message providing information about you.
-- **Agent ID (also stored in \`AGENT_ID\` env var)**: ${agentInfo.id}${convLine}${memoryDirLine}
+- **Agent ID (also stored in \`AGENT_ID\` env var)**: ${agentInfo.id}${convLine}${memoryDirLine}${parentMemoryLine}
 - **Agent name**: ${agentInfo.name || "(unnamed)"} (the user can change this with /rename)
 - **Agent description**: ${agentInfo.description || "(no description)"} (the user can change this with /description)
 - **Last message**: ${lastRunInfo}
@@ -242746,6 +243055,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
 }
 var init_agent_info = __esm(() => {
   init_memory_filesystem2();
+  init_parent_memory_note();
   init_paths();
   init_constants2();
   init_settings_manager();
@@ -243215,7 +243525,14 @@ async function buildAgentInfoReminder(context3) {
   if (!context3.systemInfoReminderEnabled || context3.state.hasSentAgentInfo) {
     return null;
   }
+  let parentAgentId;
+  try {
+    const scopeAgentId = await getMcpScopeAgentId(context3.agent.id);
+    if (scopeAgentId !== context3.agent.id)
+      parentAgentId = scopeAgentId;
+  } catch {}
   const reminder = buildAgentInfo({
+    parentAgentId,
     agentInfo: {
       id: context3.agent.id,
       name: context3.agent.name,
@@ -244822,6 +245139,18 @@ async function resolveExternalCodingAgentSecretEnv(parentAgentId, lookupParent)
   return { ...inherited, ...loadSecrets2(parentAgentId) };
 }
 async function runExternalCodingAgent(options, deps = {}) {
+  const parentMemoryNote = buildParentMemoryNote(options.parentAgentId);
+  options = {
+    ...options,
+    mcpReminder: [
+      parentMemoryNote ? `${SYSTEM_REMINDER_OPEN}
+${parentMemoryNote}
+${SYSTEM_REMINDER_CLOSE}` : undefined,
+      options.mcpReminder
+    ].filter(Boolean).join(`
+
+`) || undefined
+  };
   const startedAt = Date.now();
   const secretEnv = await (deps.resolveSecretEnv ?? resolveExternalCodingAgentSecretEnv)(options.parentAgentId);
   const env6 = {
@@ -244988,8 +245317,10 @@ async function runExternalCodingAgent(options, deps = {}) {
 }
 var EXTERNAL_CODING_AGENT_TYPES, EXTERNAL_AGENT_ID_PREFIXES, NATIVE_SESSION_ID_PATTERN, MISSING_EXECUTABLE_PREFIX = "Required executable '", CODEX_NOT_READY_PREFIX = "Codex executable is not ready", CLAUDE_NOT_SIGNED_IN_PREFIX = "claude-code authentication is not ready";
 var init_external_coding_agent = __esm(() => {
+  init_parent_memory_note();
   init_subagent_depth();
   init_subagent_process();
+  init_constants2();
   init_mcp_scope();
   init_engine3();
   init_runtime_context();
@@ -248836,6 +249167,184 @@ var init_subagent_computer = __esm(() => {
   LOCAL_COMPUTER_SELECTORS = new Set(["local", "self"]);
 });
 
+// src/tools/impl/kill-bash.ts
+function killBackgroundProcess(shell_id) {
+  const proc = backgroundProcesses.get(shell_id);
+  const retainsEntry = proc?.kind === "monitor" || proc?.kind === "workflow";
+  if (!proc || retainsEntry && proc.status !== "running") {
+    return false;
+  }
+  const previousStatus = proc.status;
+  const previousNotificationSuppression = proc.completionNotificationSuppressed;
+  try {
+    proc.completionNotificationSuppressed = true;
+    if (retainsEntry) {
+      proc.status = "failed";
+    }
+    proc.process.kill("SIGTERM");
+    if (proc.kind === "monitor")
+      cancelMonitorBackup(shell_id);
+    clearBackgroundProcessCleanup(shell_id);
+    if (retainsEntry) {
+      scheduleBackgroundProcessCleanup(shell_id);
+      notifyBackgroundProcessStateChanged(proc.runtimeScope);
+    } else {
+      backgroundProcesses.delete(shell_id);
+    }
+    return true;
+  } catch {
+    proc.status = previousStatus;
+    proc.completionNotificationSuppressed = previousNotificationSuppression;
+    return false;
+  }
+}
+var init_kill_bash = __esm(async () => {
+  init_process_manager();
+  await init_monitor_backup();
+});
+
+// src/tools/impl/task-stop.ts
+var exports_task_stop = {};
+__export(exports_task_stop, {
+  task_stop: () => task_stop
+});
+async function cancelRemoteRun(subagentId) {
+  const child = getSubagents().find((agent) => agent.id === subagentId);
+  const target2 = child?.conversationId === "default" ? child.agentId : child?.conversationId;
+  try {
+    if (!target2)
+      throw new Error("its conversation is not known yet");
+    const results = await getBackend().cancelConversation(target2);
+    const outcomes = Object.values(results);
+    if (outcomes.length === 0 || outcomes.some((status) => status !== "cancelled")) {
+      throw new Error("Cloud did not cancel every run");
+    }
+    return { killed: true, output: "Cancelled the remote run" };
+  } catch (error5) {
+    return {
+      killed: false,
+      output: `Couldn't cancel the remote run: ${getErrorMessage2(error5)}`
+    };
+  }
+}
+async function task_stop(args, deps = {}) {
+  validateRequiredParams(args, ["task_id"], "TaskStop");
+  const { task_id } = args;
+  const task = backgroundTasks.get(task_id);
+  if (task) {
+    if (task.status === "running" && task.abortController) {
+      const child = getSubagents().find((agent) => agent.id === task.subagentId);
+      const external3 = parseExternalCodingAgentId(child?.agentId ?? undefined);
+      let remote;
+      let remoteExternalStopped = false;
+      if (external3?.computer) {
+        try {
+          if (!task.runtimeScope)
+            throw new Error("its parent conversation is not known");
+          const result3 = await (deps.stopRemoteExternal ?? stopRemoteExternalCodingAgent)({
+            agentId: child?.agentId,
+            parentScope: {
+              agentId: task.runtimeScope.agentId,
+              conversationId: task.runtimeScope.conversationId,
+              actingUserId: task.actingUserId
+            }
+          });
+          remote = {
+            killed: result3.stopped,
+            output: result3.stopped ? "Stopped the remote external subagent" : "The remote external subagent was not running"
+          };
+          remoteExternalStopped = result3.stopped;
+        } catch (error5) {
+          remote = {
+            killed: false,
+            output: `Couldn't stop the remote external subagent: ${getErrorMessage2(error5)}`
+          };
+        }
+      } else if (task.remote) {
+        remote = await cancelRemoteRun(task.subagentId);
+      }
+      if (remote && !remote.killed)
+        return remote;
+      task.abortController.abort(remoteExternalStopped ? REMOTE_EXTERNAL_WORKER_STOPPED : undefined);
+      task.error = "Aborted by user";
+      await task.completion;
+      task.status = "failed";
+      scheduleBackgroundTaskCleanup(task_id);
+      return remote ?? { killed: true };
+    }
+    return { killed: false };
+  }
+  return { killed: killBackgroundProcess(task_id) };
+}
+var init_task_stop = __esm(async () => {
+  init_subagent_state();
+  init_backend2();
+  init_external_coding_agent();
+  init_process_manager();
+  init_remote_external_coding_agent();
+  await init_kill_bash();
+});
+
+// src/tools/impl/task-abort-hook.ts
+function buildBackgroundTaskAbortHook(taskId, abortController) {
+  const bgTask = backgroundTasks.get(taskId);
+  const remote = bgTask?.remote ?? false;
+  const failSafeAbort = () => !remote && abortController.abort();
+  const hook = () => {
+    init_task_stop().then(() => exports_task_stop).then((m4) => m4.task_stop({ task_id: taskId })).then((result3) => {
+      if (!result3.killed)
+        failSafeAbort();
+      settleInterruptedCancel(bgTask, remote, result3.killed, hook);
+    }).catch(() => {
+      failSafeAbort();
+      settleInterruptedCancel(bgTask, remote, false, hook);
+    });
+  };
+  return hook;
+}
+function settleInterruptedCancel(bgTask, remote, killed, hook) {
+  if (!bgTask)
+    return;
+  const taskLive = bgTask.status === "running";
+  if (remote && !killed && taskLive) {
+    restoreInterruptedSubagentRow(bgTask.subagentId, hook);
+    return;
+  }
+  const row = getSubagents().find((agent) => agent.id === bgTask.subagentId);
+  updateSubagent(bgTask.subagentId, {
+    cancelPending: undefined,
+    stopFailed: undefined,
+    stopOutcome: {
+      attempt: row?.stopAttempts ?? 0,
+      kind: killed ? "stopped" : "natural"
+    }
+  });
+}
+function restoreInterruptedSubagentRow(subagentId, hook) {
+  const row = getSubagents().find((agent) => agent.id === subagentId);
+  if (!row || row.status !== "error" || row.result !== undefined) {
+    if (row) {
+      updateSubagent(subagentId, {
+        cancelPending: undefined,
+        stopOutcome: { attempt: row.stopAttempts ?? 0, kind: "natural" }
+      });
+    }
+    return;
+  }
+  updateSubagent(subagentId, {
+    status: "running",
+    error: undefined,
+    cancelPending: undefined,
+    stopFailed: true,
+    stopOutcome: { attempt: row.stopAttempts ?? 0, kind: "failed" }
+  });
+  registerSubagentAbortHook(subagentId, hook);
+}
+var init_task_abort_hook = __esm(() => {
+  init_subagent_state();
+  init_process_manager();
+});
+
 // src/tools/impl/task-transcript.ts
 function buildTaskResultHeader(subagentType, subagentId, result3, status) {
   return [
@@ -248954,6 +249463,7 @@ function spawnBackgroundSubagentTask(args) {
     actingUserId
   };
   backgroundTasks.set(taskId, bgTask);
+  registerSubagentAbortHook(subagentId, buildBackgroundTaskAbortHook(taskId, abortController));
   writeTaskTranscriptStart(outputFile, description, subagentType);
   const parentAgentIdForSpawn = resolvedParentScope?.agentId;
   const workerMemoryDir = subagentType === "memory" && resolvedParentScope ? memoryScope?.primaryRoot ?? getScopedMemoryFilesystemRoot(resolvedParentScope.agentId) : undefined;
@@ -248985,6 +249495,7 @@ function spawnBackgroundSubagentTask(args) {
     const header = buildTaskResultHeader(subagentType, subagentId, result3, result3.success ? "success" : "error");
     writeTaskTranscriptResult(outputFile, result3, header, !!memoryTask);
     scheduleBackgroundTaskCleanup(taskId);
+    clearSubagentAbortHook(subagentId);
     completeSubagentFn(subagentId, {
       success: result3.success,
       error: result3.error,
@@ -249052,6 +249563,7 @@ Error: ${result3.error || "Subagent execution failed"}`;
 [Task failed]
 `);
     scheduleBackgroundTaskCleanup(taskId);
+    clearSubagentAbortHook(subagentId);
     completeSubagentFn(subagentId, { success: false, error: errorMessage4 });
     try {
       await onComplete?.({
@@ -249410,6 +249922,7 @@ var init_task = __esm(async () => {
   init_process_manager();
   init_remote_external_coding_agent();
   init_subagent_computer();
+  init_task_abort_hook();
   init_task_transcript();
   init_truncation();
   init_background_link();
@@ -250302,120 +250815,6 @@ var init_task_list = __esm(() => {
   init_store();
 });
 
-// src/tools/impl/kill-bash.ts
-function killBackgroundProcess(shell_id) {
-  const proc = backgroundProcesses.get(shell_id);
-  const retainsEntry = proc?.kind === "monitor" || proc?.kind === "workflow";
-  if (!proc || retainsEntry && proc.status !== "running") {
-    return false;
-  }
-  const previousStatus = proc.status;
-  const previousNotificationSuppression = proc.completionNotificationSuppressed;
-  try {
-    proc.completionNotificationSuppressed = true;
-    if (retainsEntry) {
-      proc.status = "failed";
-    }
-    proc.process.kill("SIGTERM");
-    if (proc.kind === "monitor")
-      cancelMonitorBackup(shell_id);
-    clearBackgroundProcessCleanup(shell_id);
-    if (retainsEntry) {
-      scheduleBackgroundProcessCleanup(shell_id);
-      notifyBackgroundProcessStateChanged(proc.runtimeScope);
-    } else {
-      backgroundProcesses.delete(shell_id);
-    }
-    return true;
-  } catch {
-    proc.status = previousStatus;
-    proc.completionNotificationSuppressed = previousNotificationSuppression;
-    return false;
-  }
-}
-var init_kill_bash = __esm(async () => {
-  init_process_manager();
-  await init_monitor_backup();
-});
-
-// src/tools/impl/task-stop.ts
-async function cancelRemoteRun(subagentId) {
-  const child = getSubagents().find((agent) => agent.id === subagentId);
-  const target2 = child?.conversationId === "default" ? child.agentId : child?.conversationId;
-  try {
-    if (!target2)
-      throw new Error("its conversation is not known yet");
-    const results = await getBackend().cancelConversation(target2);
-    const outcomes = Object.values(results);
-    if (outcomes.length === 0 || outcomes.some((status) => status !== "cancelled")) {
-      throw new Error("Cloud did not cancel every run");
-    }
-    return { killed: true, output: "Cancelled the remote run" };
-  } catch (error5) {
-    return {
-      killed: false,
-      output: `Couldn't cancel the remote run: ${getErrorMessage2(error5)}`
-    };
-  }
-}
-async function task_stop(args, deps = {}) {
-  validateRequiredParams(args, ["task_id"], "TaskStop");
-  const { task_id } = args;
-  const task2 = backgroundTasks.get(task_id);
-  if (task2) {
-    if (task2.status === "running" && task2.abortController) {
-      const child = getSubagents().find((agent) => agent.id === task2.subagentId);
-      const external3 = parseExternalCodingAgentId(child?.agentId ?? undefined);
-      let remote;
-      let remoteExternalStopped = false;
-      if (external3?.computer) {
-        try {
-          if (!task2.runtimeScope)
-            throw new Error("its parent conversation is not known");
-          const result3 = await (deps.stopRemoteExternal ?? stopRemoteExternalCodingAgent)({
-            agentId: child?.agentId,
-            parentScope: {
-              agentId: task2.runtimeScope.agentId,
-              conversationId: task2.runtimeScope.conversationId,
-              actingUserId: task2.actingUserId
-            }
-          });
-          remote = {
-            killed: result3.stopped,
-            output: result3.stopped ? "Stopped the remote external subagent" : "The remote external subagent was not running"
-          };
-          remoteExternalStopped = result3.stopped;
-        } catch (error5) {
-          remote = {
-            killed: false,
-            output: `Couldn't stop the remote external subagent: ${getErrorMessage2(error5)}`
-          };
-        }
-      } else if (task2.remote) {
-        remote = await cancelRemoteRun(task2.subagentId);
-      }
-      if (remote && !remote.killed)
-        return remote;
-      task2.abortController.abort(remoteExternalStopped ? REMOTE_EXTERNAL_WORKER_STOPPED : undefined);
-      task2.error = "Aborted by user";
-      await task2.completion;
-      task2.status = "failed";
-      scheduleBackgroundTaskCleanup(task_id);
-      return remote ?? { killed: true };
-    }
-    return { killed: false };
-  }
-  return { killed: killBackgroundProcess(task_id) };
-}
-var init_task_stop = __esm(async () => {
-  init_subagent_state();
-  init_backend2();
-  init_external_coding_agent();
-  init_process_manager();
-  init_remote_external_coding_agent();
-  await init_kill_bash();
-});
-
 // src/tools/impl/task-update.ts
 function validateStringArray(value, paramName) {
   if (value === undefined)
@@ -251470,6 +251869,8 @@ ${describeGitHubPullRequestSnapshot(initial2)}
   const controller = new AbortController;
   const secrets2 = {};
   let processState;
+  const persistent = !isManagedCloudRuntime();
+  let timeout;
   const events = createMonitorEventStream({
     emit(event) {
       queueMonitorEvent({
@@ -251508,6 +251909,7 @@ ${describeGitHubPullRequestSnapshot(initial2)}
   processState = {
     process: {
       kill() {
+        clearTimeout(timeout);
         events.cancel();
         controller.abort();
       }
@@ -251522,11 +251924,29 @@ ${describeGitHubPullRequestSnapshot(initial2)}
     kind: "monitor",
     description,
     monitorSource: "github_pull_request",
-    persistent: true,
+    persistent,
     secrets: secrets2
   };
   backgroundProcesses.set(taskId, processState);
   notifyBackgroundProcessStateChanged(scope);
+  if (!persistent) {
+    timeout = setTimeout(() => {
+      if (processState.status !== "running")
+        return;
+      events.finish();
+      if (processState.status !== "running")
+        return;
+      const event = getMonitorTimeoutEvent(MONITOR_MAX_TIMEOUT_MS);
+      output.append(`
+${event}
+`);
+      queueMonitorEvent({ taskId, event, scope, actingUserId, secrets: secrets2 });
+      processState.completionNotificationSuppressed = true;
+      markMonitorFinished(taskId, processState, "failed", null);
+      processState.process.kill();
+    }, MONITOR_MAX_TIMEOUT_MS);
+    unrefTimer(timeout);
+  }
   const wait = deps.wait ?? defaultWait;
   (async () => {
     let previous = initial2;
@@ -251590,12 +252010,12 @@ ${describeGitHubPullRequestSnapshot(initial2)}
     if (processState.status === "running") {
       markMonitorFinished(taskId, processState, "failed", null);
     }
-  });
+  }).finally(() => clearTimeout(timeout));
   return {
     content: [
       {
         type: "text",
-        text: `WatchPR started (task ${taskId}). It will keep watching after CI finishes and report new failures, reviews, comments, conflicts, head changes, merge-state changes, and watcher errors. It stops when the PR merges/closes, on TaskStop, or when this session ends.
+        text: `WatchPR started (task ${taskId}). It will keep watching after CI finishes and report new failures, reviews, comments, conflicts, head changes, merge-state changes, and watcher errors. It stops when the PR merges/closes, on TaskStop, or when this session ends.${persistent ? "" : " A hard 1-hour limit applies in this Cloud sandbox; use Wake or cron for later checks."}
 
 Current state:
 ${describeGitHubPullRequestSnapshot(initial2)}
@@ -251606,7 +252026,7 @@ Output file: ${outputFile}`
     taskId,
     url: ref5.url,
     headSha: initial2.headSha,
-    persistent: true
+    persistent
   };
 }
 var WATCH_POLL_MS = 30000, WATCH_MAX_POLL_MS;
@@ -252272,10 +252692,12 @@ async function createSdkSpawnerHandle(args, setStage = () => {}) {
     });
     throw error5;
   }
-  const toolScope = await createScriptToolScope(parentAgentId);
+  const backgroundStopController = args.wait ? undefined : new AbortController;
+  const toolScope = await createScriptToolScope(parentAgentId, args.wait ? args.signal : backgroundStopController?.signal);
   return {
     spawner,
     ...toolScope,
+    backgroundStopController,
     cleanup: async () => {
       await toolScope.cleanup();
       await client[Symbol.asyncDispose]?.().catch(() => {
@@ -252488,7 +252910,7 @@ async function workflow(args) {
   const taskId = getNextWorkflowId();
   const outputFile = createBackgroundOutputFile(taskId);
   const scope = resolveNotificationScope(args.parentScope);
-  const abortController = new AbortController;
+  const abortController = handle2.backgroundStopController ?? new AbortController;
   const processState = {
     process: {
       kill() {
@@ -253097,7 +253519,7 @@ var init_Monitor2 = __esm(() => {
       persistent: {
         type: "boolean",
         default: false,
-        description: "Run for the lifetime of the session (no timeout). Use for session-length watches like PR monitoring or log tails. Stop with TaskStop."
+        description: "Run until TaskStop or session end. In managed Cloud sandboxes, a hard 1-hour limit still applies; elsewhere there is no timeout. For longer waits in Cloud, use Wake/cron rather than keeping a monitor running."
       },
       backup_after_seconds: {
         type: "integer",
@@ -254260,7 +254682,7 @@ import {
   readFileSync as readFileSync38,
   renameSync as renameSync10,
   rmSync as rmSync18,
-  statSync as statSync18,
+  statSync as statSync19,
   writeFileSync as writeFileSync29
 } from "node:fs";
 import { join as join71 } from "node:path";
@@ -254579,11 +255001,11 @@ function createRecoveryLineageSidecarAccess(params) {
               ownerIsAlive = error5.code !== "ESRCH";
             }
           }
-          const ageMs = Date.now() - statSync18(join71(params.directory, file)).mtimeMs;
+          const ageMs = Date.now() - statSync19(join71(params.directory, file)).mtimeMs;
           if (!ownerIsCurrentWriter && (!ownerIsAlive && ageMs >= staleTemporaryAgeMs || ageMs >= maximumTemporaryAgeMs)) {
             const release = acquireDurableFileLock(join71(params.directory, mainFile), { waitMs: params.lockWaitMs });
             try {
-              const currentAgeMs = Date.now() - statSync18(join71(params.directory, file)).mtimeMs;
+              const currentAgeMs = Date.now() - statSync19(join71(params.directory, file)).mtimeMs;
               if (!ownerIsCurrentWriter && (!ownerIsAlive && currentAgeMs >= staleTemporaryAgeMs || currentAgeMs >= maximumTemporaryAgeMs)) {
                 rmSync18(join71(params.directory, file), { force: true });
                 params.syncDirectory(params.directory);
@@ -257075,7 +257497,7 @@ import {
   openSync as openSync7,
   readFileSync as readFileSync40,
   renameSync as renameSync11,
-  statSync as statSync19,
+  statSync as statSync20,
   unlinkSync as unlinkSync10,
   writeFileSync as writeFileSync31
 } from "node:fs";
@@ -257215,7 +257637,7 @@ function validateDurableStore(value) {
 function readDurableStore(path32) {
   if (!existsSync50(path32))
     return emptyDurableStore();
-  const size2 = statSync19(path32).size;
+  const size2 = statSync20(path32).size;
   if (size2 > MAX_INPUT_DISPOSITION_STORE_BYTES) {
     throw new Error("Accepted-input disposition store exceeds its size limit");
   }
@@ -264811,7 +265233,7 @@ function isBrowserDeviceMcpOAuthProtocolCommand(value) {
     return false;
   const record6 = value;
   if (record6.type === "browser_device_mcp_oauth") {
-    return Object.keys(record6).length === 6 && typeof record6.request_id === "string" && REQUEST_ID_PATTERN.test(record6.request_id) && typeof record6.handoff_key === "string" && HANDOFF_KEY_PATTERN2.test(record6.handoff_key) && typeof record6.service === "string" && SERVICE_PATTERN.test(record6.service) && typeof record6.server_url === "string" && record6.server_url.length > 0 && record6.server_url.length <= MAX_SERVER_URL_LENGTH && !hasControlCharacters(record6.server_url) && typeof record6.timeout_ms === "number" && Number.isSafeInteger(record6.timeout_ms) && record6.timeout_ms > 0 && record6.timeout_ms <= MAX_TIMEOUT_MS2;
+    return Object.keys(record6).length === 6 && typeof record6.request_id === "string" && REQUEST_ID_PATTERN.test(record6.request_id) && typeof record6.handoff_key === "string" && HANDOFF_KEY_PATTERN2.test(record6.handoff_key) && typeof record6.service === "string" && SERVICE_PATTERN.test(record6.service) && typeof record6.server_url === "string" && record6.server_url.length > 0 && record6.server_url.length <= MAX_SERVER_URL_LENGTH && !hasControlCharacters(record6.server_url) && typeof record6.timeout_ms === "number" && Number.isSafeInteger(record6.timeout_ms) && record6.timeout_ms > 0 && record6.timeout_ms <= MAX_TIMEOUT_MS;
   }
   return record6.type === "browser_device_mcp_oauth_cancel" && Object.keys(record6).length === 2 && typeof record6.operation_id === "string" && REQUEST_ID_PATTERN.test(record6.operation_id);
 }
@@ -264823,7 +265245,7 @@ function hasControlCharacters(value) {
   }
   return false;
 }
-var REQUEST_ID_PATTERN, HANDOFF_KEY_PATTERN2, SERVICE_PATTERN, MAX_SERVER_URL_LENGTH = 2048, MAX_TIMEOUT_MS2 = 285000;
+var REQUEST_ID_PATTERN, HANDOFF_KEY_PATTERN2, SERVICE_PATTERN, MAX_SERVER_URL_LENGTH = 2048, MAX_TIMEOUT_MS = 285000;
 var init_browser_device_mcp_oauth_protocol_inbound = __esm(() => {
   REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
   HANDOFF_KEY_PATTERN2 = /^[A-Za-z0-9_-]{43,128}$/;
@@ -266238,7 +266660,7 @@ __export(exports_memory_scanner, {
   readFileContent: () => readFileContent,
   getFileNodes: () => getFileNodes
 });
-import { readdirSync as readdirSync21, readFileSync as readFileSync42, statSync as statSync20 } from "node:fs";
+import { readdirSync as readdirSync21, readFileSync as readFileSync42, statSync as statSync21 } from "node:fs";
 import { join as join76, relative as relative7 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
@@ -266256,10 +266678,10 @@ function scanMemoryFilesystem(memoryRoot) {
       let aIsDir = false;
       let bIsDir = false;
       try {
-        aIsDir = statSync20(aPath).isDirectory();
+        aIsDir = statSync21(aPath).isDirectory();
       } catch {}
       try {
-        bIsDir = statSync20(bPath).isDirectory();
+        bIsDir = statSync21(bPath).isDirectory();
       } catch {}
       if (aIsDir !== bIsDir)
         return aIsDir ? -1 : 1;
@@ -266275,7 +266697,7 @@ function scanMemoryFilesystem(memoryRoot) {
       const fullPath = join76(dir, name);
       let isDir = false;
       try {
-        isDir = statSync20(fullPath).isDirectory();
+        isDir = statSync21(fullPath).isDirectory();
       } catch {
         return;
       }
@@ -266374,7 +266796,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     const isMemfsEnabledOnServer2 = overrides.isMemfsEnabledOnServer ?? actualIsMemfsEnabledOnServer;
     const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memory_scanner(), exports_memory_scanner));
     const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-    const { existsSync: existsSync52, statSync: statSync21 } = await import("node:fs");
+    const { existsSync: existsSync52, statSync: statSync22 } = await import("node:fs");
     const { join: join77, posix: posix3 } = await import("node:path");
     const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
     let memfsInitialized = existsSync52(join77(memoryRoot, ".git"));
@@ -266471,7 +266893,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
         if (imageMimeType) {
           let size2 = 0;
           try {
-            size2 = statSync21(node.fullPath).size;
+            size2 = statSync22(node.fullPath).size;
           } catch {}
           return {
             relative_path: node.relativePath,
@@ -276020,7 +276442,7 @@ ${lanes.join(`
             return process.memoryUsage().heapUsed;
           },
           getFileSize(path35) {
-            const stat12 = statSync21(path35);
+            const stat12 = statSync22(path35);
             if (stat12 == null ? undefined : stat12.isFile()) {
               return stat12.size;
             }
@@ -276063,7 +276485,7 @@ ${lanes.join(`
           }
         };
         return nodeSystem;
-        function statSync21(path35) {
+        function statSync22(path35) {
           try {
             return _fs.statSync(path35, statSyncOptions);
           } catch {
@@ -276115,7 +276537,7 @@ ${lanes.join(`
             activeSession.post("Profiler.stop", (err, { profile }) => {
               var _a10;
               if (!err) {
-                if ((_a10 = statSync21(profilePath)) == null ? undefined : _a10.isDirectory()) {
+                if ((_a10 = statSync22(profilePath)) == null ? undefined : _a10.isDirectory()) {
                   profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                 }
                 try {
@@ -276224,7 +276646,7 @@ ${lanes.join(`
               let stat12;
               if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                 const name = combinePaths(path35, entry);
-                stat12 = statSync21(name);
+                stat12 = statSync22(name);
                 if (!stat12) {
                   continue;
                 }
@@ -276248,7 +276670,7 @@ ${lanes.join(`
           return matchFiles(path35, extensions, excludes, includes2, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath6);
         }
         function fileSystemEntryExists(path35, entryKind) {
-          const stat12 = statSync21(path35);
+          const stat12 = statSync22(path35);
           if (!stat12) {
             return false;
           }
@@ -276282,7 +276704,7 @@ ${lanes.join(`
         }
         function getModifiedTime3(path35) {
           var _a10;
-          return (_a10 = statSync21(path35)) == null ? undefined : _a10.mtime;
+          return (_a10 = statSync22(path35)) == null ? undefined : _a10.mtime;
         }
         function setModifiedTime(path35, time3) {
           try {
@@ -437757,7 +438179,7 @@ import {
   mkdirSync as mkdirSync42,
   readdirSync as readdirSync23,
   readFileSync as readFileSync46,
-  statSync as statSync21,
+  statSync as statSync22,
   unlinkSync as unlinkSync13,
   writeFileSync as writeFileSync36
 } from "node:fs";
@@ -438586,7 +439008,7 @@ async function loadLocalMods(options) {
         recordLegacyExtensionLoadedDiagnostic(registry4, owner, source, options.onDiagnostic);
       }
       try {
-        const mtimeMs = statSync21(modPath).mtimeMs;
+        const mtimeMs = statSync22(modPath).mtimeMs;
         const sourceText = readFileSync46(modPath, "utf8");
         recordDeprecatedContextApiSourceDiagnostics(sourceText, (diagnostic) => {
           recordModDiagnostic(registry4, {
@@ -453387,7 +453809,7 @@ var init_deepagents = __esm(() => {
 });
 
 // node_modules/@letta-ai/trajectory/dist/adapters/listing-shared.js
-import { readdirSync as readdirSync25, statSync as statSync22 } from "node:fs";
+import { readdirSync as readdirSync25, statSync as statSync23 } from "node:fs";
 import { join as join83 } from "node:path";
 function sortListings(items3) {
   return items3.sort((left, right) => {
@@ -453411,7 +453833,7 @@ function safeReadDir(path42) {
 }
 function safeStat(path42) {
   try {
-    const stats = statSync22(path42);
+    const stats = statSync23(path42);
     return { mtimeMs: stats.mtimeMs, sizeBytes: stats.size };
   } catch {
     return;
@@ -468690,7 +469112,7 @@ var init_memory_tokens = __esm(() => {
 });
 
 // src/cli/subcommands/memory.ts
-import { cpSync, existsSync as existsSync64, mkdirSync as mkdirSync46, rmSync as rmSync22, statSync as statSync23 } from "node:fs";
+import { cpSync, existsSync as existsSync64, mkdirSync as mkdirSync46, rmSync as rmSync22, statSync as statSync24 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
 import { dirname as dirname35, join as join94 } from "node:path";
 import { parseArgs as parseArgs11 } from "node:util";
@@ -468765,7 +469187,7 @@ async function listBackups(agentId) {
     const path46 = join94(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat15 = statSync23(path46);
+      const stat15 = statSync24(path46);
       createdAt = stat15.mtime.toISOString();
     } catch {
       createdAt = null;
@@ -468892,7 +469314,7 @@ async function runMemorySubcommand(argv, deps = {}) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat15 = statSync23(backupPath);
+      const stat15 = statSync24(backupPath);
       if (!stat15.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
@@ -468915,7 +469337,7 @@ async function runMemorySubcommand(argv, deps = {}) {
         return 1;
       }
       if (existsSync64(out)) {
-        const stat15 = statSync23(out);
+        const stat15 = statSync24(out);
         if (stat15.isDirectory()) {
           const contents = await readdir12(out);
           if (contents.length > 0) {
@@ -468963,7 +469385,7 @@ var init_memory7 = __esm(() => {
 });
 
 // src/backend/local/transcript-search.ts
-import { existsSync as existsSync65, readdirSync as readdirSync27, readFileSync as readFileSync48, statSync as statSync24 } from "node:fs";
+import { existsSync as existsSync65, readdirSync as readdirSync27, readFileSync as readFileSync48, statSync as statSync25 } from "node:fs";
 import { join as join95 } from "node:path";
 function readJsonFile3(path46) {
   if (!existsSync65(path46))
@@ -469251,7 +469673,7 @@ function conversationDirectories(storageDir) {
   if (!existsSync65(conversationsDir))
     return [];
   try {
-    return readdirSync27(conversationsDir).map((entry) => join95(conversationsDir, entry)).filter((entryPath) => statSync24(entryPath).isDirectory());
+    return readdirSync27(conversationsDir).map((entry) => join95(conversationsDir, entry)).filter((entryPath) => statSync25(entryPath).isDirectory());
   } catch {
     return [];
   }
@@ -474465,7 +474887,7 @@ import {
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync50,
   rmSync as rmSync25,
-  statSync as statSync25,
+  statSync as statSync26,
   writeFileSync as writeFileSync41
 } from "node:fs";
 import { mkdir as mkdir16, readdir as readdir13 } from "node:fs/promises";
@@ -474923,7 +475345,7 @@ async function installSkillDirectory(params) {
   if (!existsSync69(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
-  if (!statSync25(sourceDir).isDirectory()) {
+  if (!statSync26(sourceDir).isDirectory()) {
     throw new Error(`Skill source is not a directory: ${sourceDir}`);
   }
   const name = getSkillName(sourceDir);
@@ -474982,7 +475404,7 @@ async function deleteSkillDirectory(params) {
   if (!existsSync69(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
   }
-  if (!statSync25(targetPath).isDirectory()) {
+  if (!statSync26(targetPath).isDirectory()) {
     throw new Error(`Skill path is not a directory: ${targetPath}`);
   }
   rmSync25(targetPath, { recursive: true, force: true });
@@ -476880,7 +477302,7 @@ function firstDefinedBoolean(...values4) {
 }
 function normalizeChatTarget(channel, value) {
   const trimmed = value.trim();
-  if (channel === "signal")
+  if (channel === "signal" || channel === "microsoftteams")
     return trimmed;
   const parts = trimmed.split(":").map((part) => part.trim()).filter(Boolean);
   if (parts.length === 2 && /^[a-z_-]+$/i.test(parts[0] ?? "")) {
@@ -484346,6 +484768,9 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       await exitHeadless(1, "headless_stop_reason_error");
     }
   } catch (error5) {
+    if (sigintSignal.aborted) {
+      await exitInterrupted();
+    }
     markIncompleteToolsAsCancelled(buffers, true, "stream_error");
     const errorDetails = formatErrorDetails2(error5, agent.id);
     trackHeadlessBoundaryError("headless_runtime_exception", error5, "headless_turn_execution");
@@ -484760,6 +485185,30 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
       lineResolver = resolve42;
     });
   }
+  const EXTERNAL_TOOL_WAIT_ABORTED = Symbol("externalToolWaitAborted");
+  async function getNextLineOrAbort(signal) {
+    if (signal?.aborted)
+      return EXTERNAL_TOOL_WAIT_ABORTED;
+    if (lineQueue.length > 0)
+      return lineQueue.shift() ?? null;
+    if (!signal)
+      return getNextLine();
+    return new Promise((resolve42) => {
+      const cleanup = () => signal.removeEventListener("abort", onAbort);
+      const onAbort = () => {
+        cleanup();
+        if (lineResolver === settle3)
+          lineResolver = null;
+        resolve42(EXTERNAL_TOOL_WAIT_ABORTED);
+      };
+      const settle3 = (line) => {
+        cleanup();
+        resolve42(line);
+      };
+      signal.addEventListener("abort", onAbort);
+      lineResolver = settle3;
+    });
+  }
   async function requestPermission(toolCallId, toolName2, toolInput) {
     const requestId = `perm-${toolCallId}`;
     const diffs = await computeDiffPreviews(toolName2, toolInput);
@@ -484920,7 +485369,14 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
         const toolsRequest = message2.request;
         const tools = toolsRequest.tools ?? [];
         registerExternalTools(tools);
-        setExternalToolExecutor(async (toolCallId, toolName2, input) => {
+        setExternalToolExecutor(async (toolCallId, toolName2, input, context3) => {
+          const signal = context3?.signal;
+          if (signal?.aborted) {
+            return {
+              content: [{ type: "text", text: INTERRUPTED_BY_USER }],
+              isError: true
+            };
+          }
           const execRequest = {
             type: "control_request",
             request_id: `ext-${toolCallId}`,
@@ -484932,25 +485388,48 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
             }
           };
           writeWireMessage(execRequest);
-          while (true) {
-            const line2 = await getNextLine();
-            if (line2 === null) {
-              return {
-                content: [{ type: "text", text: "stdin closed" }],
-                isError: true
-              };
-            }
-            if (!line2.trim())
-              continue;
-            try {
-              const msg = JSON.parse(line2);
-              if (msg.type === "control_response" && msg.response?.subtype === "external_tool_result" && msg.response?.tool_call_id === toolCallId) {
+          const deferredLines = [];
+          try {
+            while (true) {
+              const line2 = await getNextLineOrAbort(signal);
+              if (line2 === EXTERNAL_TOOL_WAIT_ABORTED) {
                 return {
-                  content: msg.response.content ?? [{ type: "text", text: "" }],
-                  isError: msg.response.is_error ?? false
+                  content: [{ type: "text", text: INTERRUPTED_BY_USER }],
+                  isError: true
                 };
               }
-            } catch {}
+              if (line2 === null) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: currentAbortController?.signal.aborted ? INTERRUPTED_BY_USER : "stdin closed"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              if (!line2.trim())
+                continue;
+              try {
+                const msg = JSON.parse(line2);
+                if (msg.type === "control_response" && msg.response?.subtype === "external_tool_result") {
+                  if (msg.response.tool_call_id === toolCallId) {
+                    return {
+                      content: msg.response.content ?? [
+                        { type: "text", text: "" }
+                      ],
+                      isError: msg.response.is_error ?? false
+                    };
+                  }
+                  continue;
+                }
+              } catch {}
+              deferredLines.push(line2);
+            }
+          } finally {
+            if (deferredLines.length > 0)
+              lineQueue.unshift(...deferredLines);
           }
         });
         const registerResponse = {
@@ -485370,10 +485849,18 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
               }
               const { executeApprovalBatch: executeApprovalBatch2 } = await init_approval_execution().then(() => exports_approval_execution);
               emitLocalToolCalls(decisions, sessionId);
-              const executedResults = await executeApprovalBatch2(decisions, undefined, {
-                toolContextId: turnToolContextId ?? undefined,
-                abortSignal: currentAbortController.signal
-              });
+              let executedResults;
+              try {
+                executedResults = await executeApprovalBatch2(decisions, undefined, {
+                  toolContextId: turnToolContextId ?? undefined,
+                  abortSignal: currentAbortController.signal
+                });
+              } catch (error5) {
+                if (currentAbortController?.signal.aborted) {
+                  break;
+                }
+                throw error5;
+              }
               emitLocalToolReturns(executedResults, sessionId);
               currentInput = responseState.prepare(executedResults, needsUserInput.length === 0);
               continue;
@@ -485491,6 +485978,7 @@ var LLM_API_ERROR_MAX_RETRIES2 = 3, EMPTY_RESPONSE_MAX_RETRIES2 = 2, HEADLESS_ST
 var init_headless = __esm(async () => {
   init_error();
   init_preloaded_skills();
+  init_constants2();
   init_headless_message_sender();
   init_headless_response_state();
   init_headless_startup_backend();
@@ -497448,7 +497936,6 @@ var init_SlashCommandAutocomplete = __esm(async () => {
     "creating-skills",
     "customizing-statusline",
     "initializing-memory",
-    "migrating-memory",
     "syncing-memory-filesystem"
   ]);
   _allCommands = Object.entries(commands).filter(([, { hidden }]) => !hidden).map(([cmd, { desc, order }]) => ({
@@ -498445,6 +498932,7 @@ function Input({
   queueMode = "immediate",
   deferModeSupported = false,
   interruptRequested = false,
+  hasStopFailedTasks = false,
   agentId,
   agentName,
   currentModel,
@@ -498744,7 +499232,7 @@ function Input({
         onBashInterrupt();
         return;
       }
-      if ((streaming3 || interruptRequested) && onInterrupt) {
+      if ((streaming3 || interruptRequested || hasStopFailedTasks) && onInterrupt) {
         onInterrupt();
         return;
       }
@@ -514750,6 +515238,7 @@ function AppView(props) {
     inputEnabled,
     inputVisible,
     interruptRequested,
+    hasStopFailedTasks,
     isAgentBusy,
     liveItems,
     liveTrajectoryElapsedBaseMs,
@@ -514978,6 +515467,7 @@ function AppView(props) {
                   queueMode,
                   deferModeSupported,
                   interruptRequested,
+                  hasStopFailedTasks,
                   agentId,
                   agentName,
                   currentModel: currentModelDisplay,
@@ -516136,6 +516626,12 @@ function useApprovalFlow(ctx) {
     startupApprovals
   ]);
   const sendAllResults = import_react113.useCallback(async (additionalDecision) => {
+    const approvalAbortController = new AbortController;
+    const approvalResultsSnapshot = [...approvalResults];
+    const autoHandledSnapshot = [...autoHandledResults];
+    const autoDeniedSnapshot = [...autoDeniedApprovals];
+    const pendingSnapshot = [...pendingApprovals];
+    const companionResults = buildCompanionResults(autoHandledSnapshot, autoDeniedSnapshot);
     try {
       if (userCancelledRef.current || abortControllerRef.current?.signal.aborted) {
         setStreaming(false);
@@ -516145,12 +516641,13 @@ function useApprovalFlow(ctx) {
         setApprovalResults([]);
         setAutoHandledResults([]);
         setAutoDeniedApprovals([]);
+        clearApprovalToolContext();
+        toolAbortControllerRef.current = null;
+        executingToolCallIdsRef.current = [];
+        interruptQueuedRef.current = false;
+        toolResultsInFlightRef.current = false;
         return;
       }
-      const approvalResultsSnapshot = [...approvalResults];
-      const autoHandledSnapshot = [...autoHandledResults];
-      const autoDeniedSnapshot = [...autoDeniedApprovals];
-      const pendingSnapshot = [...pendingApprovals];
       setPendingApprovals([]);
       setApprovalContexts([]);
       setApprovalResults([]);
@@ -516159,7 +516656,6 @@ function useApprovalFlow(ctx) {
       setStreaming(true);
       openTrajectorySegment();
       buffersRef.current.interrupted = false;
-      const approvalAbortController = new AbortController;
       toolAbortControllerRef.current = approvalAbortController;
       const allDecisions = [
         ...approvalResultsSnapshot,
@@ -516201,23 +516697,10 @@ function useApprovalFlow(ctx) {
           localToolMs: toolRunMs
         });
       }
-      const allResults = [
-        ...autoHandledSnapshot.map((ar) => ({
-          type: "tool",
-          tool_call_id: ar.toolCallId,
-          tool_return: ar.result.toolReturn,
-          status: ar.result.status,
-          stdout: ar.result.stdout,
-          stderr: ar.result.stderr
-        })),
-        ...autoDeniedSnapshot.map((ad) => ({
-          type: "approval",
-          tool_call_id: ad.approval.toolCallId,
-          approve: false,
-          reason: ad.reason
-        })),
-        ...executedResults
-      ];
+      if (toolAbortControllerRef.current !== approvalAbortController) {
+        return;
+      }
+      const allResults = [...companionResults, ...executedResults];
       if (true) {
         const expectedIds = new Set([
           ...autoHandledSnapshot.map((ar) => ar.toolCallId),
@@ -516236,9 +516719,7 @@ function useApprovalFlow(ctx) {
       const wasAborted = approvalAbortController.signal.aborted;
       const userCancelled = userCancelledRef.current;
       if (wasAborted || userCancelled) {
-        if (!interruptQueuedRef.current) {
-          queueApprovalResults(allResults);
-        }
+        queueApprovalResults(allResults);
         setStreaming(false);
         closeTrajectorySegment();
         syncTrajectoryElapsedBase();
@@ -516259,6 +516740,24 @@ function useApprovalFlow(ctx) {
         queueApprovalResults(null);
       }
     } catch (error5) {
+      if (toolAbortControllerRef.current !== approvalAbortController) {
+        return;
+      }
+      if (isUserAbortError(error5)) {
+        markIncompleteToolsAsCancelled(buffersRef.current, true, "user_interrupt");
+        const merged = overlayPartialResults(queuedApprovalResultsRef.current, [
+          ...error5.partialResults ?? [],
+          ...companionResults
+        ]);
+        if (merged.length > 0) {
+          queueApprovalResults(merged);
+        }
+        setStreaming(false);
+        closeTrajectorySegment();
+        syncTrajectoryElapsedBase();
+        refreshDerived();
+        return;
+      }
       markIncompleteToolsAsCancelled(buffersRef.current, true, "stream_error");
       const errorDetails = formatErrorDetails2(error5, agentId);
       appendError(errorDetails, {
@@ -516270,12 +516769,14 @@ function useApprovalFlow(ctx) {
       syncTrajectoryElapsedBase();
       refreshDerived();
     } finally {
-      clearApprovalToolContext();
-      setIsExecutingTool(false);
-      toolAbortControllerRef.current = null;
-      executingToolCallIdsRef.current = [];
-      interruptQueuedRef.current = false;
-      toolResultsInFlightRef.current = false;
+      if (toolAbortControllerRef.current === approvalAbortController) {
+        clearApprovalToolContext();
+        setIsExecutingTool(false);
+        toolAbortControllerRef.current = null;
+        executingToolCallIdsRef.current = [];
+        interruptQueuedRef.current = false;
+        toolResultsInFlightRef.current = false;
+      }
     }
   }, [
     agentId,
@@ -516603,7 +517104,10 @@ var init_use_approval_flow = __esm(async () => {
   init_debug();
   init_notifications();
   init_turn_input();
-  await init_manager2();
+  await __promiseAll([
+    init_approval_execution(),
+    init_manager2()
+  ]);
   import_react113 = __toESM(require_react(), 1);
 });
 
@@ -517902,6 +518406,7 @@ function useConversationLoop(ctx) {
     precomputedDiffsRef,
     prepareScopedToolExecutionContext,
     processingConversationRef,
+    queuedApprovalResultsRef,
     queueApprovalResults,
     queueSnapshotRef,
     quotaAutoSwapAttemptedRef,
@@ -518799,7 +519304,11 @@ ${feedback}
           const autoAllowedAbortController = abortControllerRef.current ?? new AbortController;
           const shouldTrackAutoAllowed = autoAllowedToolCallIds.length > 0;
           let autoAllowedResults = [];
-          let autoDeniedResults = [];
+          const autoDeniedResults = autoDenied.map((ac) => ({
+            approval: ac.approval,
+            reason: formatPermissionDenial(ac.permission)
+          }));
+          const prebuiltDeniedApprovalResults = buildDeniedResults(autoDeniedResults);
           if (shouldTrackAutoAllowed) {
             setIsExecutingTool(true);
             executingToolCallIdsRef.current = autoAllowedToolCallIds;
@@ -518816,29 +519325,35 @@ ${feedback}
               setToolCallsRunning(buffersRef.current, autoAllowedToolCallIds);
               refreshDerived();
             }
-            const approvalToolContextId = approvalToolContextIdRef.current ?? (await prepareScopedToolExecutionContext(tempModelOverrideRef.current ?? undefined)).preparedToolContext.contextId;
-            autoAllowedResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk2) => onChunk(buffersRef.current, chunk2), {
-              abortSignal: autoAllowedAbortController.signal,
-              onStreamingOutput: updateStreamingOutput,
-              toolContextId: approvalToolContextId
-            }) : [];
-            autoDeniedResults = autoDenied.map((ac) => {
-              const reason = formatPermissionDenial(ac.permission);
+            try {
+              const approvalToolContextId = approvalToolContextIdRef.current ?? (await prepareScopedToolExecutionContext(tempModelOverrideRef.current ?? undefined)).preparedToolContext.contextId;
+              autoAllowedResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk2) => onChunk(buffersRef.current, chunk2), {
+                abortSignal: autoAllowedAbortController.signal,
+                onStreamingOutput: updateStreamingOutput,
+                toolContextId: approvalToolContextId
+              }) : [];
+            } catch (error5) {
+              if (shouldTrackAutoAllowed && toolAbortControllerRef.current !== autoAllowedAbortController) {
+                return;
+              }
+              appendAbortPartials(error5, prebuiltDeniedApprovalResults);
+              throw error5;
+            }
+            if (shouldTrackAutoAllowed && toolAbortControllerRef.current !== autoAllowedAbortController) {
+              return;
+            }
+            for (const ad of autoDeniedResults) {
               onChunk(buffersRef.current, {
                 message_type: "tool_return_message",
                 id: "dummy",
                 date: new Date().toISOString(),
-                tool_call_id: ac.approval.toolCallId,
-                tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+                tool_call_id: ad.approval.toolCallId,
+                tool_return: `Error: request to call tool denied. User reason: ${ad.reason}`,
                 status: "error",
                 stdout: null,
                 stderr: null
               });
-              return {
-                approval: ac.approval,
-                reason
-              };
-            });
+            }
             const allResults = [
               ...autoAllowedResults.map((ar) => ({
                 type: "tool",
@@ -518848,12 +519363,7 @@ ${feedback}
                 stdout: ar.result.stdout,
                 stderr: ar.result.stderr
               })),
-              ...autoDeniedResults.map((ad) => ({
-                type: "approval",
-                tool_call_id: ad.approval.toolCallId,
-                approve: false,
-                reason: ad.reason
-              }))
+              ...prebuiltDeniedApprovalResults
             ];
             if (autoAllowedExecutionRef.current) {
               autoAllowedExecutionRef.current.results = allResults;
@@ -518951,7 +519461,7 @@ ${feedback}
               return;
             }
           } finally {
-            if (shouldTrackAutoAllowed) {
+            if (shouldTrackAutoAllowed && toolAbortControllerRef.current === autoAllowedAbortController) {
               setIsExecutingTool(false);
               toolAbortControllerRef.current = null;
               executingToolCallIdsRef.current = [];
@@ -519285,8 +519795,16 @@ ${feedback}
       }
     } catch (e2) {
       debugWarn("message_stream", "Unhandled conversation error: %s", e2 instanceof Error ? e2.stack ?? e2.message : String(e2));
-      markIncompleteToolsAsCancelled(buffersRef.current, true, e2 instanceof APIUserAbortError ? "user_interrupt" : "stream_error");
-      if (EAGER_CANCEL && e2 instanceof APIUserAbortError) {
+      if (abortControllerRef.current !== turnAbortController) {
+        return;
+      }
+      markIncompleteToolsAsCancelled(buffersRef.current, true, isUserAbortError(e2) ? "user_interrupt" : "stream_error");
+      if (EAGER_CANCEL && isUserAbortError(e2)) {
+        const partials = e2.partialResults;
+        const overlaid = partials ? overlayPartialResults(queuedApprovalResultsRef.current, partials) : [];
+        if (overlaid.length > 0) {
+          queueApprovalResults(overlaid);
+        }
         setStreaming(false);
         refreshDerived();
         return;
@@ -520045,18 +520563,23 @@ var init_use_feedback_handler = __esm(() => {
 });
 
 // src/cli/app/use-interrupt-handler.ts
-function hasActiveReflectionSubagentForAgent(agentId) {
+function hasActiveReflectionSubagentForAgent(agentId, conversationId) {
   return getSubagents().some((agent) => {
     if (agent.type.toLowerCase() !== "reflection")
       return false;
     if (agent.status !== "pending" && agent.status !== "running")
       return false;
-    return agent.parentAgentId === agentId;
+    if (agent.parentAgentId !== agentId)
+      return false;
+    return conversationId === undefined || agent.parentConversationId === undefined || agent.parentConversationId === conversationId;
   });
 }
-function interruptSubagentsAndReleaseReflection(agentId) {
-  const interruptedReflection = hasActiveReflectionSubagentForAgent(agentId);
-  interruptActiveSubagents(INTERRUPTED_BY_USER);
+function interruptSubagentsAndReleaseReflection(agentId, conversationId) {
+  const interruptedReflection = hasActiveReflectionSubagentForAgent(agentId, conversationId);
+  interruptActiveSubagents(INTERRUPTED_BY_USER, {
+    agentId,
+    conversationId
+  });
   if (interruptedReflection) {
     releaseReflectionLaunch(agentId);
   }
@@ -520158,7 +520681,7 @@ function useInterruptHandler(ctx) {
       autoAllowedExecutionRef.current = null;
       buffersRef.current.abortGeneration = (buffersRef.current.abortGeneration || 0) + 1;
       const toolsCancelled = markIncompleteToolsAsCancelled(buffersRef.current, true, "user_interrupt");
-      interruptSubagentsAndReleaseReflection(agentId);
+      interruptSubagentsAndReleaseReflection(agentId, conversationIdRef.current);
       if (!toolsCancelled) {
         appendError(INTERRUPT_MESSAGE, true);
       }
@@ -520188,6 +520711,16 @@ function useInterruptHandler(ctx) {
           bumpDequeueEpoch: () => setDequeueEpoch((e2) => e2 + 1)
         });
       }
+      const retried = interruptStopFailedSubagents(INTERRUPTED_BY_USER, {
+        agentId,
+        conversationId: conversationIdRef.current
+      });
+      if (retried.length > 0) {
+        if (retried.some((id2) => getSubagents().find((agent) => agent.id === id2)?.type.toLowerCase() === "reflection")) {
+          releaseReflectionLaunch(agentId);
+        }
+        appendError("Retrying stop of background task...", true);
+      }
       return;
     }
     if (waitingForQueueCancelRef.current) {
@@ -520198,7 +520731,7 @@ function useInterruptHandler(ctx) {
       setInterruptRequested(true);
       buffersRef.current.abortGeneration = (buffersRef.current.abortGeneration || 0) + 1;
       const toolsCancelled = markIncompleteToolsAsCancelled(buffersRef.current, true, "user_interrupt");
-      interruptSubagentsAndReleaseReflection(agentId);
+      interruptSubagentsAndReleaseReflection(agentId, conversationIdRef.current);
       abortControllerRef.current?.abort();
       pendingInterruptRecoveryConversationIdRef.current = conversationIdRef.current;
       userCancelledRef.current = true;
@@ -529463,6 +529996,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     precomputedDiffsRef,
     prepareScopedToolExecutionContext,
     processingConversationRef,
+    queuedApprovalResultsRef,
     queueApprovalResults,
     queueSnapshotRef,
     quotaAutoSwapAttemptedRef,
@@ -530219,6 +530753,18 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     deferredCommitAt
   ]);
   const { agents: subagents } = import_react123.useSyncExternalStore(subscribe2, getSnapshot2);
+  const hasStopFailedTasks = hasStopFailedSubagents({
+    agentId,
+    conversationId
+  });
+  const stopFailedNotifiedRef = import_react123.useRef(new Set);
+  import_react123.useEffect(() => {
+    const { failures, stops } = selectStopFailedNotifications(subagents, stopFailedNotifiedRef.current, { agentId, conversationId });
+    const messages = [...failures, ...stops];
+    if (messages.length > 0) {
+      appendTaskNotificationEvents(messages);
+    }
+  }, [subagents, conversationId, appendTaskNotificationEvents, agentId]);
   const estimatedLiveHeight = import_react123.useMemo(() => {
     const countLines4 = (text3) => {
       if (!text3)
@@ -530466,6 +531012,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
         inputEnabled,
         inputVisible,
         interruptRequested: interruptRequested || !!abortControllerRef.current?.signal.aborted,
+        hasStopFailedTasks,
         isAgentBusy,
         liveItems,
         liveTrajectoryElapsedBaseMs,
@@ -534743,4 +535290,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=25D231F0C01DA6C764756E2164756E21
+//# debugId=9CD2133B459655FB64756E2164756E21