@letta-ai/letta-code 0.30.18 → 0.30.19

package/letta.js

@@ -5488,7 +5488,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.30.18",
+    version: "0.30.19",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -149321,6 +149321,7 @@ Usage notes:
   - Write a clear, concise user-facing description of what this command does. This description may be shown directly in chat as part of a status row like \`Running command: <description>\` or \`Ran command: <description>\`. Describe the command's purpose, not its shell syntax. For simple commands, keep it brief (5-10 words). For complex commands (piped commands, obscure flags, or anything hard to understand at a glance), add enough context to clarify what it does.
   - If the output exceeds 30000 characters, output will be truncated before being returned to you.
   - You can use the \`run_in_background\` parameter to run the command in the background. Only use this if you don't need the result immediately and are OK being notified when the command completes later. You do not need to check the output right away - you'll be notified when it finishes. You do not need to use '&' at the end of the command when using this parameter.
+  - Pick between \`run_in_background\` and the Monitor tool by how many notifications you need. **One** ("tell me when the server is ready / the build finishes") → 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. **One per occurrence** ("tell me every time an ERROR line appears") → use Monitor: each stdout line is an event — you keep working and notifications arrive in the chat. Foreground \`sleep\` is blocked; background the wait (\`run_in_background\` or Monitor) instead of polling BashOutput, and keep working.
   
   - Avoid using Bash with the \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
     - File search: Use Glob (NOT find or ls)
@@ -149435,6 +149436,7 @@ var BashOutput_default = `# BashOutput
 - Returns stdout and stderr output along with shell status
 - Supports optional regex filtering to show only lines matching a pattern
 - Use this tool when you need to monitor or check the output of a long-running shell
+- If you are repeatedly calling this tool waiting for a recurring pattern to appear ("tell me every time an ERROR line appears"), stop polling and use the Monitor tool instead: each stdout line is an event — you keep working and notifications arrive in the chat
 - Shell IDs can be found using the /bg command
 - If the accumulated output exceeds 30,000 characters, it will be truncated before being returned to you
 `;
@@ -153572,6 +153574,53 @@ var init_worktree_ownership = __esm(() => {
   ]);
 });
 
+// src/tools/impl/foreground-sleep.ts
+function commandRunsForegroundSleep(command) {
+  const segments = splitShellSegmentsAllowCommandSubstitution(command) ?? splitShellSegments(command);
+  if (!segments) {
+    return false;
+  }
+  for (const segment of segments) {
+    for (const word of tokenizeShellWords(segment)) {
+      if (SHELL_KEYWORDS.has(word)) {
+        continue;
+      }
+      if (ASSIGNMENT_PREFIX.test(word)) {
+        continue;
+      }
+      if (word.split("/").pop() === "sleep") {
+        return true;
+      }
+      break;
+    }
+  }
+  return false;
+}
+var FOREGROUND_SLEEP_BLOCKED_MESSAGE = 'Foreground `sleep` is blocked — it stalls the session while nothing happens. Run the wait in the background and keep working: 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. For one notification per occurrence ("tell me every time an ERROR line appears"), use the Monitor tool instead. `sleep` inside `run_in_background` commands and Monitor scripts is fine.', SHELL_KEYWORDS, ASSIGNMENT_PREFIX;
+var init_foreground_sleep = __esm(() => {
+  SHELL_KEYWORDS = new Set([
+    "if",
+    "then",
+    "elif",
+    "else",
+    "fi",
+    "while",
+    "until",
+    "do",
+    "done",
+    "for",
+    "case",
+    "esac",
+    "{",
+    "}",
+    "(",
+    ")",
+    "!",
+    "time"
+  ]);
+  ASSIGNMENT_PREFIX = /^[A-Za-z_][A-Za-z0-9_]*=/;
+});
+
 // src/tools/impl/process_manager.ts
 var exports_process_manager = {};
 __export(exports_process_manager, {
@@ -155762,6 +155811,12 @@ Output file: ${outputFile}`
       status: "success"
     };
   }
+  if (commandRunsForegroundSleep(command)) {
+    return {
+      content: [{ type: "text", text: FOREGROUND_SLEEP_BLOCKED_MESSAGE }],
+      status: "error"
+    };
+  }
   const effectiveTimeout = Math.min(Math.max(timeout, 1), 600000);
   try {
     const { stdout, stderr, exitCode } = await spawnCommand(command, {
@@ -155833,6 +155888,7 @@ var init_bash = __esm(() => {
   init_message_queue_bridge();
   init_task_notifications();
   init_worktree_ownership();
+  init_foreground_sleep();
   init_process_manager();
   init_shell_env();
   init_shell_launchers();
@@ -157525,7 +157581,6 @@ function notifyStreamObserversRuntimeStopped(listener) {
 // src/websocket/listener/protocol-outbound.ts
 var exports_protocol_outbound = {};
 __export(exports_protocol_outbound, {
-  scheduleQueueEmit: () => scheduleQueueEmit,
   isSystemReminderPart: () => isSystemReminderPart,
   emitSubagentStateUpdate: () => emitSubagentStateUpdate,
   emitSubagentStateIfOpen: () => emitSubagentStateIfOpen,
@@ -157734,6 +157789,9 @@ function isStreamChannelMessage(type3) {
   return STREAM_CHANNEL_MESSAGE_TYPES.has(type3);
 }
 function classifyOutboundFrame(message) {
+  if (message.type === "update_queue" && (message.removed?.length ?? 0) > 0) {
+    return "critical";
+  }
   return COALESCABLE_STATUS_MESSAGE_TYPES.has(message.type) ? "status" : "critical";
 }
 function emitProtocolV2Message(socket, runtime, message, scope, routing) {
@@ -157851,7 +157909,7 @@ function emitDeviceStatusIfOpen(runtime, scope) {
     emitDeviceStatusUpdate(transport, runtime, scope);
   }
 }
-function emitQueueUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS) {
+function emitQueueUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS, removed = []) {
   const listener = getListenerRuntime(runtime);
   if (!listener) {
     return;
@@ -157859,7 +157917,8 @@ function emitQueueUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS) {
   const resolvedScope = getScopeForRuntime(runtime, scope);
   const message = {
     type: "update_queue",
-    queue: buildQueueSnapshot(runtime, resolvedScope)
+    queue: buildQueueSnapshot(runtime, resolvedScope),
+    removed: [...removed]
   };
   emitProtocolV2Message(socket, runtime, message, resolvedScope, routing);
 }
@@ -157955,11 +158014,11 @@ function emitDequeuedUserMessage(socket, runtime, incoming, batch) {
     conversation_id: incoming.conversationId
   });
 }
-function emitQueueUpdateIfOpen(runtime, scope) {
+function emitQueueUpdateIfOpen(runtime, scope, removed = []) {
   const listener = getListenerRuntime(runtime);
   const transport = listener?.transport ?? listener?.socket;
   if (transport && isListenerTransportOpen(transport)) {
-    emitQueueUpdate(transport, runtime, scope);
+    emitQueueUpdate(transport, runtime, scope, TO_SUBSCRIBERS, removed);
   }
 }
 function emitDeviceStatusUpdateIfChanged(socket, runtime, scope, options3, routing = TO_SUBSCRIBERS) {
@@ -158035,18 +158094,6 @@ function emitSubagentStateIfOpen(runtime, scope) {
     emitSubagentStateUpdate(transport, runtime, scope);
   }
 }
-function scheduleQueueEmit(runtime, scope) {
-  runtime.pendingQueueEmitScope = scope;
-  if (runtime.queueEmitScheduled)
-    return;
-  runtime.queueEmitScheduled = true;
-  queueMicrotask(() => {
-    runtime.queueEmitScheduled = false;
-    const emitScope = runtime.pendingQueueEmitScope;
-    runtime.pendingQueueEmitScope = undefined;
-    emitQueueUpdateIfOpen(runtime, emitScope);
-  });
-}
 function createLifecycleMessageBase(messageType, runId) {
   return {
     id: `lifecycle-${crypto.randomUUID()}`,
@@ -239488,7 +239535,7 @@ var init_utils5 = __esm(() => {
   init_media();
   TELEGRAM_LIFECYCLE_ERROR_DEDUPE_TTL_MS = 6 * 60 * 60 * 1000;
   TELEGRAM_LIFECYCLE_ERROR_REPORT_TTL_MS = 6 * 60 * 60 * 1000;
-  TELEGRAM_TYPING_MAX_MS = 5 * 60 * 1000;
+  TELEGRAM_TYPING_MAX_MS = 6 * 60 * 60 * 1000;
 });
 
 // src/channels/telegram/account-display.ts
@@ -240160,9 +240207,22 @@ async function stopTelegramBotQuietly(telegramBot, options3) {
 }
 var DEFAULT_TELEGRAM_INIT_TIMEOUT_MS = 15000, DEFAULT_TELEGRAM_START_TIMEOUT_MS = 20000, TELEGRAM_FAILED_START_STOP_TIMEOUT_MS = 5000;
 
+// src/channels/typing-controller-timers.ts
+var SYSTEM_TYPING_CONTROLLER_TIMERS;
+var init_typing_controller_timers = __esm(() => {
+  SYSTEM_TYPING_CONTROLLER_TIMERS = {
+    setInterval: (callback, delayMs) => setInterval(callback, delayMs),
+    clearInterval: (handle2) => clearInterval(handle2),
+    setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+    clearTimeout: (handle2) => clearTimeout(handle2)
+  };
+});
+
 // src/channels/telegram/typing-controller.ts
 function createTelegramTypingController(deps) {
-  const typingByChatId = new Map;
+  const timers = deps.timers ?? SYSTEM_TYPING_CONTROLLER_TIMERS;
+  const typingByTarget = new Map;
+  const lastOutboundAtByTarget = new Map;
   function getChatId(source2) {
     if (source2.channel !== "telegram")
       return null;
@@ -240182,59 +240242,93 @@ function createTelegramTypingController(deps) {
       source2.conversationId
     ].join(":");
   }
-  function clearChat(chatId) {
-    const entry = typingByChatId.get(chatId);
+  function getTargetKey(source2) {
+    const chatId = getChatId(source2);
+    if (!chatId)
+      return null;
+    return targetKey(chatId, source2.threadId);
+  }
+  function targetKey(chatId, threadId) {
+    return [chatId, threadId ?? ""].join(":");
+  }
+  function clearTarget(targetKey2) {
+    const entry = typingByTarget.get(targetKey2);
     if (!entry)
       return;
-    clearInterval(entry.timer);
-    clearTimeout(entry.timeout);
-    typingByChatId.delete(chatId);
+    timers.clearInterval(entry.timer);
+    timers.clearTimeout(entry.timeout);
+    typingByTarget.delete(targetKey2);
+    lastOutboundAtByTarget.delete(targetKey2);
+  }
+  function touchWatchdog(targetKey2) {
+    const entry = typingByTarget.get(targetKey2);
+    if (!entry)
+      return;
+    timers.clearTimeout(entry.timeout);
+    entry.timeout = timers.setTimeout(() => clearTarget(targetKey2), TELEGRAM_TYPING_MAX_MS);
+    entry.timeout.unref?.();
   }
   function start(source2) {
     const chatId = getChatId(source2);
+    const targetKey2 = getTargetKey(source2);
     const sourceKey = getSourceKey(source2);
-    if (!chatId || !sourceKey)
+    if (!chatId || !targetKey2 || !sourceKey)
       return;
-    const existing = typingByChatId.get(chatId);
+    const threadId = source2.threadId ?? null;
+    const existing = typingByTarget.get(targetKey2);
     if (existing) {
       existing.sourceKeys.add(sourceKey);
+      touchWatchdog(targetKey2);
       return;
     }
-    deps.sendTypingAction(chatId);
-    const timer = setInterval(() => {
-      deps.sendTypingAction(chatId);
+    deps.sendTypingAction(chatId, threadId);
+    const timer = timers.setInterval(() => {
+      const lastOutboundAt = lastOutboundAtByTarget.get(targetKey2) ?? 0;
+      if (Date.now() - lastOutboundAt < OUTBOUND_TYPING_SUPPRESSION_MS)
+        return;
+      deps.sendTypingAction(chatId, threadId);
     }, TELEGRAM_TYPING_REFRESH_MS);
-    const timeout = setTimeout(() => clearChat(chatId), TELEGRAM_TYPING_MAX_MS);
+    const timeout = timers.setTimeout(() => clearTarget(targetKey2), TELEGRAM_TYPING_MAX_MS);
     timer.unref?.();
     timeout.unref?.();
-    typingByChatId.set(chatId, {
+    typingByTarget.set(targetKey2, {
       sourceKeys: new Set([sourceKey]),
       timer,
       timeout
     });
   }
+  function markOutbound(chatId, threadId) {
+    const key2 = targetKey(chatId, threadId);
+    if (!typingByTarget.has(key2))
+      return;
+    lastOutboundAtByTarget.set(key2, Date.now());
+    touchWatchdog(key2);
+  }
   function stop(source2) {
-    const chatId = getChatId(source2);
+    const targetKey2 = getTargetKey(source2);
     const sourceKey = getSourceKey(source2);
-    if (!chatId || !sourceKey)
+    if (!targetKey2 || !sourceKey)
       return;
-    const entry = typingByChatId.get(chatId);
+    const entry = typingByTarget.get(targetKey2);
     if (!entry)
       return;
     entry.sourceKeys.delete(sourceKey);
     if (entry.sourceKeys.size === 0)
-      clearChat(chatId);
+      clearTarget(targetKey2);
   }
   function clearAll() {
-    for (const entry of typingByChatId.values()) {
-      clearInterval(entry.timer);
-      clearTimeout(entry.timeout);
+    for (const entry of typingByTarget.values()) {
+      timers.clearInterval(entry.timer);
+      timers.clearTimeout(entry.timeout);
     }
-    typingByChatId.clear();
+    typingByTarget.clear();
+    lastOutboundAtByTarget.clear();
   }
-  return { clearAll, clearChat, getChatId, start, stop };
+  return { clearAll, getChatId, markOutbound, start, stop };
 }
+var OUTBOUND_TYPING_SUPPRESSION_MS = 1000;
 var init_typing_controller = __esm(() => {
+  init_typing_controller_timers();
   init_utils5();
 });
 
@@ -240283,12 +240377,14 @@ function createTelegramAdapter(config3) {
   async function dispatchInbound(inbound) {
     await debouncer.enqueue({ inbound });
   }
-  async function sendTypingAction(chatId) {
+  async function sendTypingAction(chatId, threadId) {
     if (!running)
       return;
     try {
       const telegramBot = await ensureBot();
-      await telegramBot.api.sendChatAction(chatId, "typing");
+      await telegramBot.api.sendChatAction(chatId, "typing", {
+        ...threadId ? { message_thread_id: Number(threadId) } : {}
+      });
     } catch (error54) {
       console.warn(`[Telegram] Failed to send typing action for chat ${chatId}:`, error54 instanceof Error ? error54.message : error54);
     }
@@ -240665,7 +240761,7 @@ function createTelegramAdapter(config3) {
         } else {
           await telegramBot.api.setMessageReaction(msg.chatId, Number(targetMessageId), []);
         }
-        typing.clearChat(msg.chatId);
+        typing.markOutbound(msg.chatId, resolveTelegramOutboundThreadId(msg));
         return { messageId: targetMessageId };
       }
       if (msg.mediaPath) {
@@ -240692,14 +240788,14 @@ function createTelegramAdapter(config3) {
               return await telegramBot.api.sendDocument(msg.chatId, inputFile, options3);
           }
         })();
-        typing.clearChat(msg.chatId);
+        typing.markOutbound(msg.chatId, resolveTelegramOutboundThreadId(msg));
         return { messageId: String(result2.message_id) };
       }
       if (msg.richMessage) {
         const raw2 = telegramBot.api.raw;
         try {
           const result2 = await raw2.sendRichMessage(buildTelegramRichMessagePayload(msg));
-          typing.clearChat(msg.chatId);
+          typing.markOutbound(msg.chatId, resolveTelegramOutboundThreadId(msg));
           return { messageId: String(result2.message_id) };
         } catch (error54) {
           if (!shouldFallbackTelegramRichMessage(error54)) {
@@ -240722,7 +240818,7 @@ function createTelegramAdapter(config3) {
         opts.parse_mode = msg.parseMode;
       }
       const result = await telegramBot.api.sendMessage(msg.chatId, msg.text, opts);
-      typing.clearChat(msg.chatId);
+      typing.markOutbound(msg.chatId, threadId);
       return { messageId: String(result.message_id) };
     },
     async sendDirectReply(chatId, text2, options3) {
@@ -240737,11 +240833,13 @@ function createTelegramAdapter(config3) {
         ...threadId ? { message_thread_id: Number(threadId) } : {},
         ...reply_parameters ? { reply_parameters } : {}
       });
+      typing.markOutbound(chatId, threadId);
     },
     async handleTurnLifecycleEvent(event2) {
       if (!running)
         return;
       if (event2.type === "queued") {
+        typing.start(event2.source);
         return;
       }
       if (event2.type === "processing") {
@@ -240781,7 +240879,7 @@ function createTelegramAdapter(config3) {
         ...threadId ? { message_thread_id: Number(threadId) } : {},
         ...reply_parameters ? { reply_parameters } : {}
       });
-      typing.clearChat(event2.source.chatId);
+      typing.stop(event2.source);
     },
     onMessage: undefined
   };
@@ -246743,6 +246841,126 @@ var init_utils7 = __esm(() => {
   init_lifecycle_error();
 });
 
+// src/channels/discord/typing-controller.ts
+function createDiscordTypingController(deps) {
+  const timers = deps.timers ?? SYSTEM_TYPING_CONTROLLER_TIMERS;
+  const typingByChannelId = new Map;
+  const lastTypingOutputAtByChannelId = new Map;
+  function getChannelId(source2) {
+    if (source2.channel !== "discord")
+      return null;
+    const channelId = source2.threadId ?? source2.chatId;
+    return isNonEmptyString8(channelId) ? channelId : null;
+  }
+  function getSourceKey(source2) {
+    const channelId = getChannelId(source2);
+    if (!channelId)
+      return null;
+    return [
+      source2.accountId ?? "",
+      channelId,
+      source2.messageId ?? "",
+      source2.agentId,
+      source2.conversationId
+    ].join(":");
+  }
+  function clearChannel(channelId) {
+    const entry = typingByChannelId.get(channelId);
+    if (!entry)
+      return;
+    timers.clearInterval(entry.timer);
+    timers.clearTimeout(entry.timeout);
+    typingByChannelId.delete(channelId);
+    lastTypingOutputAtByChannelId.delete(channelId);
+  }
+  function touchWatchdog(channelId) {
+    const entry = typingByChannelId.get(channelId);
+    if (!entry)
+      return;
+    timers.clearTimeout(entry.timeout);
+    entry.timeout = timers.setTimeout(() => {
+      clearChannel(channelId);
+    }, DISCORD_TYPING_MAX_MS);
+    entry.timeout.unref?.();
+  }
+  async function start(source2) {
+    const channelId = getChannelId(source2);
+    const sourceKey = getSourceKey(source2);
+    if (!channelId || !sourceKey)
+      return;
+    const existing = typingByChannelId.get(channelId);
+    if (existing) {
+      existing.sourceKeys.add(sourceKey);
+      touchWatchdog(channelId);
+      return;
+    }
+    let entry;
+    const timer = timers.setInterval(() => {
+      if (Date.now() - (lastTypingOutputAtByChannelId.get(channelId) ?? 0) < OUTBOUND_TYPING_SUPPRESSION_MS2)
+        return;
+      deps.sendTypingAction(channelId).then((ok) => {
+        if (typingByChannelId.get(channelId) !== entry)
+          return;
+        if (!ok) {
+          clearChannel(channelId);
+        }
+      });
+    }, DISCORD_TYPING_REFRESH_MS);
+    timer.unref?.();
+    entry = {
+      sourceKeys: new Set([sourceKey]),
+      timer,
+      timeout: timers.setTimeout(() => {
+        clearChannel(channelId);
+      }, DISCORD_TYPING_MAX_MS)
+    };
+    entry.timeout.unref?.();
+    typingByChannelId.set(channelId, entry);
+    if (!await deps.sendTypingAction(channelId)) {
+      const current = typingByChannelId.get(channelId);
+      if (current === entry && current.sourceKeys.size === 1 && current.sourceKeys.has(sourceKey)) {
+        clearChannel(channelId);
+      }
+      return;
+    }
+    touchWatchdog(channelId);
+  }
+  function stop(source2) {
+    const channelId = getChannelId(source2);
+    const sourceKey = getSourceKey(source2);
+    if (!channelId || !sourceKey)
+      return;
+    const entry = typingByChannelId.get(channelId);
+    if (!entry)
+      return;
+    entry.sourceKeys.delete(sourceKey);
+    if (entry.sourceKeys.size === 0) {
+      clearChannel(channelId);
+    }
+  }
+  function markOutbound(channelId) {
+    if (!typingByChannelId.has(channelId))
+      return;
+    lastTypingOutputAtByChannelId.set(channelId, Date.now());
+    touchWatchdog(channelId);
+  }
+  function clearAll() {
+    for (const entry of typingByChannelId.values()) {
+      timers.clearInterval(entry.timer);
+      timers.clearTimeout(entry.timeout);
+    }
+    typingByChannelId.clear();
+    lastTypingOutputAtByChannelId.clear();
+  }
+  return { clearAll, markOutbound, start, stop };
+}
+var OUTBOUND_TYPING_SUPPRESSION_MS2 = 1000, DISCORD_TYPING_REFRESH_MS = 8000, DISCORD_TYPING_MAX_MS;
+var init_typing_controller2 = __esm(() => {
+  init_typing_controller_timers();
+  init_utils7();
+  DISCORD_TYPING_MAX_MS = 6 * 60 * 60 * 1000;
+});
+
 // src/channels/discord/adapter.ts
 import { basename as basename16 } from "node:path";
 function createDiscordAdapter(config3) {
@@ -246753,7 +246971,22 @@ function createDiscordAdapter(config3) {
   const lifecycleStateByMessageKey = new Map;
   const lifecycleOperationByMessageKey = new Map;
   const lifecycleErrorReplyKeys = new Map;
-  const typingByChannelId = new Map;
+  const typing = createDiscordTypingController({
+    sendTypingAction: async (channelId) => {
+      if (!running || !client)
+        return false;
+      try {
+        const channel = await client.channels.fetch(channelId);
+        if (!isDiscordTypingChannel(channel))
+          return false;
+        await channel.sendTyping();
+        return true;
+      } catch (error54) {
+        console.warn(`[Discord] Failed to send typing indicator for ${channelId}:`, error54 instanceof Error ? error54.message : error54);
+        return false;
+      }
+    }
+  });
   function pruneSeenIngressMessageKeys(now = Date.now()) {
     for (const [key2, expiresAt] of seenIngressMessageKeys) {
       if (expiresAt <= now) {
@@ -246799,24 +247032,6 @@ function createDiscordAdapter(config3) {
       source2.conversationId
     ].join(":");
   }
-  function getTypingChannelId(source2) {
-    if (source2.channel !== "discord")
-      return null;
-    const channelId = source2.threadId ?? source2.chatId;
-    return isNonEmptyString8(channelId) ? channelId : null;
-  }
-  function getTypingSourceKey(source2) {
-    const channelId = getTypingChannelId(source2);
-    if (!channelId)
-      return null;
-    return [
-      source2.accountId ?? "",
-      channelId,
-      source2.messageId ?? "",
-      source2.agentId,
-      source2.conversationId
-    ].join(":");
-  }
   function pruneLifecycleState(now = Date.now()) {
     for (const [key2, entry] of lifecycleStateByMessageKey) {
       if (entry.updatedAt + LIFECYCLE_STATE_TTL_MS <= now) {
@@ -246894,83 +247109,6 @@ function createDiscordAdapter(config3) {
       ...reply ?? {}
     });
   }
-  async function sendTypingAction(channelId) {
-    if (!running || !client)
-      return false;
-    try {
-      const channel = await client.channels.fetch(channelId);
-      if (!isDiscordTypingChannel(channel))
-        return false;
-      await channel.sendTyping();
-      return true;
-    } catch (error54) {
-      console.warn(`[Discord] Failed to send typing indicator for ${channelId}:`, error54 instanceof Error ? error54.message : error54);
-      return false;
-    }
-  }
-  async function startTypingForSource(source2) {
-    const channelId = getTypingChannelId(source2);
-    const sourceKey = getTypingSourceKey(source2);
-    if (!channelId || !sourceKey)
-      return;
-    const existing = typingByChannelId.get(channelId);
-    if (existing) {
-      existing.sourceKeys.add(sourceKey);
-      return;
-    }
-    if (!await sendTypingAction(channelId)) {
-      return;
-    }
-    const timer = setInterval(() => {
-      sendTypingAction(channelId).then((ok) => {
-        if (!ok) {
-          clearTypingForChannel(channelId);
-        }
-      });
-    }, DISCORD_TYPING_REFRESH_MS);
-    const timeout = setTimeout(() => {
-      clearTypingForChannel(channelId);
-    }, DISCORD_TYPING_MAX_MS);
-    if (typeof timer.unref === "function") {
-      timer.unref?.();
-    }
-    if (typeof timeout.unref === "function") {
-      timeout.unref?.();
-    }
-    typingByChannelId.set(channelId, {
-      sourceKeys: new Set([sourceKey]),
-      timer,
-      timeout
-    });
-  }
-  function stopTypingForSource(source2) {
-    const channelId = getTypingChannelId(source2);
-    const sourceKey = getTypingSourceKey(source2);
-    if (!channelId || !sourceKey)
-      return;
-    const entry = typingByChannelId.get(channelId);
-    if (!entry)
-      return;
-    entry.sourceKeys.delete(sourceKey);
-    if (entry.sourceKeys.size === 0) {
-      clearTypingForChannel(channelId);
-    }
-  }
-  function clearTypingForChannel(channelId) {
-    const entry = typingByChannelId.get(channelId);
-    if (!entry)
-      return;
-    clearInterval(entry.timer);
-    clearTimeout(entry.timeout);
-    typingByChannelId.delete(channelId);
-  }
-  function clearAllTyping() {
-    for (const entry of typingByChannelId.values()) {
-      clearInterval(entry.timer);
-      clearTimeout(entry.timeout);
-    }
-    typingByChannelId.clear();
-  }
   function scheduleLifecycleTransition(source2, nextState) {
     const key2 = getLifecycleMessageKey(source2);
     if (!key2)
@@ -247273,7 +247411,7 @@ function createDiscordAdapter(config3) {
     async stop() {
       if (!running || !client)
         return;
-      clearAllTyping();
+      typing.clearAll();
       client.destroy();
       client = null;
       running = false;
@@ -247291,6 +247429,7 @@ function createDiscordAdapter(config3) {
       if (!running)
         return;
       if (event2.type === "queued") {
+        await typing.start(event2.source);
         if (config3.acknowledgeMessageReaction) {
           await scheduleLifecycleTransition(event2.source, "queued");
         }
@@ -247298,12 +247437,12 @@ function createDiscordAdapter(config3) {
       }
       if (event2.type === "processing") {
         for (const source2 of event2.sources) {
-          await startTypingForSource(source2);
+          await typing.start(source2);
         }
         return;
       }
       for (const source2 of event2.sources) {
-        stopTypingForSource(source2);
+        typing.stop(source2);
       }
       const nextState = event2.outcome === "completed" ? "completed" : event2.outcome === "cancelled" ? "cancelled" : "error";
       if (config3.acknowledgeMessageReaction) {
@@ -247350,7 +247489,7 @@ function createDiscordAdapter(config3) {
         } else {
           await message.react(emoji3);
         }
-        clearTypingForChannel(targetChannelId2);
+        typing.markOutbound(targetChannelId2);
         return { messageId: targetMessageId };
       }
       if (msg.mediaPath) {
@@ -247370,7 +247509,7 @@ function createDiscordAdapter(config3) {
             }
           ]
         });
-        clearTypingForChannel(targetChannelId2);
+        typing.markOutbound(targetChannelId2);
         return { messageId: result.id };
       }
       const targetChannelId = msg.threadId ?? msg.chatId;
@@ -247388,7 +247527,7 @@ function createDiscordAdapter(config3) {
         });
         lastMessageId = result.id;
       }
-      clearTypingForChannel(targetChannelId);
+      typing.markOutbound(targetChannelId);
       return { messageId: lastMessageId };
     },
     async sendDirectReply(chatId, text2, options3) {
@@ -247403,7 +247542,7 @@ function createDiscordAdapter(config3) {
         content: text2,
         ...reply ?? {}
       });
-      clearTypingForChannel(chatId);
+      typing.markOutbound(chatId);
     },
     async prepareInboundMessage(msg, options3) {
       if (!options3?.isFirstRouteTurn || msg.channel !== "discord" || msg.chatType !== "channel" || !isNonEmptyString8(msg.threadId) || !client) {
@@ -247448,13 +247587,13 @@ function createDiscordAdapter(config3) {
   };
   return adapter;
 }
-var DISCORD_SPLIT_THRESHOLD = 1900, INGRESS_DEDUPE_TTL_MS = 60000, INGRESS_DEDUPE_MAX = 2000, LIFECYCLE_STATE_TTL_MS, LIFECYCLE_STATE_MAX = 2000, INITIAL_THREAD_HISTORY_LIMIT = 20, DISCORD_TYPING_REFRESH_MS = 8000, DISCORD_TYPING_MAX_MS;
+var DISCORD_SPLIT_THRESHOLD = 1900, INGRESS_DEDUPE_TTL_MS = 60000, INGRESS_DEDUPE_MAX = 2000, LIFECYCLE_STATE_TTL_MS, LIFECYCLE_STATE_MAX = 2000, INITIAL_THREAD_HISTORY_LIMIT = 20;
 var init_adapter4 = __esm(() => {
   init_media3();
   init_runtime4();
+  init_typing_controller2();
   init_utils7();
   LIFECYCLE_STATE_TTL_MS = 6 * 60 * 60 * 1000;
-  DISCORD_TYPING_MAX_MS = 5 * 60 * 1000;
 });
 
 // src/channels/discord/message-actions.ts
@@ -249396,7 +249535,7 @@ function createWhatsAppTypingController(options3) {
   return { start, stop, isActive, clearChat, clearOwner, clearAll };
 }
 var DEFAULT_REFRESH_MS = 12000, DEFAULT_MAX_LIFETIME_MS;
-var init_typing_controller2 = __esm(() => {
+var init_typing_controller3 = __esm(() => {
   DEFAULT_MAX_LIFETIME_MS = 5 * 60000;
 });
 
@@ -250105,7 +250244,7 @@ var init_adapter5 = __esm(() => {
   init_runtime5();
   init_session2();
   init_state();
-  init_typing_controller2();
+  init_typing_controller3();
   STABLE_OPEN_RESET_MS = RECONNECT_WINDOW_MS;
   CLAIM_CONNECTION_STATE = { claimedConnectionState: true };
 });
@@ -253263,15 +253402,143 @@ var init_registry_commands = __esm(() => {
   init_types8();
 });
 
+// src/channels/control-request-coordinator.ts
+function getChannelControlRequestScopeKey(params) {
+  return [
+    params.channel,
+    params.accountId ?? "default",
+    params.chatId,
+    params.threadId ?? ""
+  ].join(":");
+}
+function cloneEvent(event2) {
+  return structuredClone(event2);
+}
+
+class ChannelControlRequestCoordinator {
+  options;
+  pendingById = new Map;
+  requestIdByScope = new Map;
+  constructor(options3) {
+    this.options = options3;
+  }
+  restore(events) {
+    for (const event2 of events) {
+      this.remember(event2, false);
+    }
+  }
+  has(requestId) {
+    return this.pendingById.has(requestId);
+  }
+  getAll() {
+    return Array.from(this.pendingById.values()).map((pending) => ({
+      event: cloneEvent(pending.event),
+      deliveredThisProcess: pending.deliveredThisProcess
+    }));
+  }
+  async register(event2) {
+    const scopeKey = getChannelControlRequestScopeKey(event2.source);
+    const existingRequestId = this.requestIdByScope.get(scopeKey);
+    if (existingRequestId && existingRequestId !== event2.requestId) {
+      await this.clear(existingRequestId);
+    }
+    this.remember(event2, false);
+    await this.options.persist(cloneEvent(event2));
+    await this.deliver(event2.requestId);
+  }
+  async redeliver(requestId) {
+    return this.deliver(requestId);
+  }
+  async handleNativeResponse(input) {
+    const pending = this.pendingById.get(input.requestId);
+    if (!pending)
+      return "expired";
+    const source2 = pending.event.source;
+    if (source2.channel !== input.channel || (source2.accountId ?? "default") !== (input.accountId ?? "default") || source2.chatId !== input.chatId || (source2.threadId ?? null) !== (input.threadId ?? null) || source2.senderId && source2.senderId !== input.senderId) {
+      return "forbidden";
+    }
+    const result = await this.options.deliverResponse(cloneEvent(pending.event), input.response);
+    if (result === "handled" || result === "expired") {
+      await this.clear(input.requestId);
+    }
+    return result;
+  }
+  async tryHandleInbound(input) {
+    if (input.bypass)
+      return false;
+    const requestId = this.requestIdByScope.get(getChannelControlRequestScopeKey(input));
+    if (!requestId)
+      return false;
+    const pending = this.pendingById.get(requestId);
+    if (!pending) {
+      this.requestIdByScope.delete(getChannelControlRequestScopeKey(input));
+      return false;
+    }
+    if (pending.event.source.senderId && pending.event.source.senderId !== input.senderId) {
+      return false;
+    }
+    if (input.channel === "slack" && pending.event.kind === "generic_tool_approval") {
+      return false;
+    }
+    const parsed = parseChannelControlRequestResponse(pending.event, input.text);
+    if (parsed.type === "reprompt") {
+      await this.options.deliverReprompt(cloneEvent(pending.event), input, parsed.message);
+      return true;
+    }
+    const result = await this.options.deliverResponse(cloneEvent(pending.event), parsed.response);
+    if (result === "unavailable") {
+      await this.options.deliverReprompt(cloneEvent(pending.event), input, "I’m reconnecting to Letta Code right now, so I couldn’t use that reply yet. Please send it again in a moment.");
+      return true;
+    }
+    await this.clear(requestId);
+    if (result === "expired") {
+      await this.options.deliverReprompt(cloneEvent(pending.event), input, "That approval prompt expired before I could use your reply. Please ask the agent to try again.");
+    }
+    return true;
+  }
+  async clear(requestId) {
+    const pending = this.pendingById.get(requestId);
+    if (pending) {
+      this.pendingById.delete(requestId);
+      const scopeKey = getChannelControlRequestScopeKey(pending.event.source);
+      if (this.requestIdByScope.get(scopeKey) === requestId) {
+        this.requestIdByScope.delete(scopeKey);
+      }
+    }
+    await this.options.remove(requestId);
+  }
+  clearAll() {
+    this.pendingById.clear();
+    this.requestIdByScope.clear();
+  }
+  remember(event2, deliveredThisProcess) {
+    const nextEvent = cloneEvent(event2);
+    this.pendingById.set(event2.requestId, {
+      event: nextEvent,
+      deliveredThisProcess
+    });
+    this.requestIdByScope.set(getChannelControlRequestScopeKey(event2.source), event2.requestId);
+  }
+  async deliver(requestId) {
+    const pending = this.pendingById.get(requestId);
+    if (!pending)
+      return false;
+    await this.options.deliverPrompt(cloneEvent(pending.event));
+    pending.deliveredThisProcess = true;
+    return true;
+  }
+}
+var init_control_request_coordinator = () => {};
+
 // src/channels/pending-control-requests.ts
 import { existsSync as existsSync38, mkdirSync as mkdirSync27, readFileSync as readFileSync28, writeFileSync as writeFileSync20 } from "node:fs";
 import { dirname as dirname24 } from "node:path";
-function cloneEvent(event2) {
+function cloneEvent2(event2) {
   return structuredClone(event2);
 }
 function cloneStore(nextStore) {
   return {
-    requests: nextStore.requests.map((event2) => cloneEvent(event2))
+    requests: nextStore.requests.map((event2) => cloneEvent2(event2))
   };
 }
 function isChannelControlRequestEvent(value) {
@@ -253300,7 +253567,7 @@ function ensureStoreLoaded() {
     const text2 = readFileSync28(storePath, "utf-8");
     const parsed = JSON.parse(text2);
     store2 = {
-      requests: Array.isArray(parsed.requests) ? parsed.requests.filter(isChannelControlRequestEvent).map(cloneEvent) : []
+      requests: Array.isArray(parsed.requests) ? parsed.requests.filter(isChannelControlRequestEvent).map(cloneEvent2) : []
     };
   } catch {
     store2 = EMPTY_STORE();
@@ -253320,11 +253587,11 @@ function saveStore() {
 }
 function listPendingControlRequests() {
   ensureStoreLoaded();
-  return store2.requests.map((event2) => cloneEvent(event2));
+  return store2.requests.map((event2) => cloneEvent2(event2));
 }
 function upsertPendingControlRequest(event2) {
   ensureStoreLoaded();
-  const nextEvent = cloneEvent(event2);
+  const nextEvent = cloneEvent2(event2);
   const existingIndex = store2.requests.findIndex((candidate) => candidate.requestId === event2.requestId);
   if (existingIndex >= 0) {
     store2.requests[existingIndex] = nextEvent;
@@ -253332,7 +253599,7 @@ function upsertPendingControlRequest(event2) {
     store2.requests.push(nextEvent);
   }
   saveStore();
-  return cloneEvent(nextEvent);
+  return cloneEvent2(nextEvent);
 }
 function removePendingControlRequest(requestId) {
   ensureStoreLoaded();
@@ -253351,181 +253618,102 @@ var init_pending_control_requests = __esm(() => {
 });
 
 // src/channels/registry-controls.ts
-function getChannelApprovalScopeKey(params) {
-  return [
-    params.channel,
-    params.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID,
-    params.chatId,
-    params.threadId ?? ""
-  ].join(":");
-}
-
 class ChannelControlRequests {
   deps;
-  pendingById = new Map;
-  requestIdByScope = new Map;
+  coordinator;
   constructor(deps) {
     this.deps = deps;
-    this.primePersistedRequests();
+    this.coordinator = new ChannelControlRequestCoordinator({
+      deliverPrompt: async (event2) => {
+        const adapter = this.getAdapter(event2);
+        if (!adapter)
+          throw new Error("Channel adapter is unavailable");
+        if (adapter.handleControlRequestEvent) {
+          await adapter.handleControlRequestEvent(event2);
+          return;
+        }
+        await adapter.sendDirectReply(event2.source.chatId, formatChannelControlRequestPrompt(event2), { replyToMessageId: event2.source.threadId ?? event2.source.messageId });
+      },
+      deliverReprompt: async (_event, input, message) => {
+        const adapter = this.deps.getAdapter(input.channel, input.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
+        if (!adapter)
+          return;
+        await adapter.sendDirectReply(input.chatId, message, buildDirectReplyOptions(input));
+      },
+      deliverResponse: async (event2, response) => {
+        const handler = this.deps.getApprovalResponseHandler();
+        if (!handler)
+          return "unavailable";
+        const handled = await handler({
+          runtime: {
+            agent_id: event2.source.agentId,
+            conversation_id: event2.source.conversationId
+          },
+          response
+        });
+        return handled ? "handled" : "expired";
+      },
+      persist: (event2) => {
+        upsertPendingControlRequest(event2);
+      },
+      remove: (requestId) => {
+        removePendingControlRequest(requestId);
+      }
+    });
+    this.coordinator.restore(listPendingControlRequests());
   }
   has(requestId) {
-    return this.pendingById.has(requestId);
+    return this.coordinator.has(requestId);
   }
   getAll() {
-    return Array.from(this.pendingById.values()).map((pending) => ({
-      event: structuredClone(pending.event),
-      deliveredThisProcess: pending.deliveredThisProcess
-    }));
-  }
-  primePersistedRequests() {
-    for (const event2 of listPendingControlRequests()) {
-      this.pendingById.set(event2.requestId, {
-        event: event2,
-        deliveredThisProcess: false
-      });
-      this.requestIdByScope.set(getChannelApprovalScopeKey({
-        channel: event2.source.channel,
-        accountId: event2.source.accountId,
-        chatId: event2.source.chatId,
-        threadId: event2.source.threadId
-      }), event2.requestId);
-    }
+    return this.coordinator.getAll();
   }
   async handleNativeResponse(input) {
-    const pending = this.pendingById.get(input.requestId);
-    if (!pending)
-      return "expired";
-    const source2 = pending.event.source;
-    const matchesTarget = source2.channel === input.channel && (source2.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID) === (input.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID) && source2.chatId === input.chatId && (source2.threadId ?? null) === (input.threadId ?? null);
-    if (!matchesTarget || source2.senderId && source2.senderId !== input.senderId) {
-      return "forbidden";
-    }
-    const approvalResponseHandler = this.deps.getApprovalResponseHandler();
-    if (!approvalResponseHandler)
-      return "unavailable";
-    const handled = await approvalResponseHandler({
-      runtime: {
-        agent_id: source2.agentId,
-        conversation_id: source2.conversationId
-      },
-      response: input.response
-    });
-    this.clear(input.requestId);
-    return handled ? "handled" : "expired";
+    return this.coordinator.handleNativeResponse(input);
   }
-  async deliver(requestId) {
-    const pending = this.pendingById.get(requestId);
-    if (!pending)
-      return false;
-    const event2 = pending.event;
-    const adapter = this.deps.getAdapter(event2.source.channel, event2.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
-    if (!adapter)
-      return false;
+  async register(event2) {
     try {
-      if (adapter.handleControlRequestEvent) {
-        await adapter.handleControlRequestEvent(event2);
-      } else {
-        await adapter.sendDirectReply(event2.source.chatId, formatChannelControlRequestPrompt(event2), { replyToMessageId: event2.source.threadId ?? event2.source.messageId });
-      }
-      pending.deliveredThisProcess = true;
-      return true;
+      await this.coordinator.register(event2);
     } catch (error54) {
       console.error(`[Channels] Failed to deliver control request prompt for ${event2.source.channel}/${event2.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID}:`, error54 instanceof Error ? error54.message : error54);
-      return false;
     }
   }
-  async register(event2) {
-    const scopeKey = getChannelApprovalScopeKey({
-      channel: event2.source.channel,
-      accountId: event2.source.accountId,
-      chatId: event2.source.chatId,
-      threadId: event2.source.threadId
-    });
-    const existingRequestId = this.requestIdByScope.get(scopeKey);
-    if (existingRequestId)
-      this.clear(existingRequestId);
-    this.pendingById.set(event2.requestId, {
-      event: event2,
-      deliveredThisProcess: false
-    });
-    this.requestIdByScope.set(scopeKey, event2.requestId);
-    upsertPendingControlRequest(event2);
-    await this.deliver(event2.requestId);
-  }
   async redeliver(requestId) {
-    return this.deliver(requestId);
+    try {
+      return await this.coordinator.redeliver(requestId);
+    } catch (error54) {
+      const pending = this.coordinator.getAll().find((candidate) => candidate.event.requestId === requestId);
+      console.error(`[Channels] Failed to deliver control request prompt for ${pending?.event.source.channel ?? "unknown"}/${pending?.event.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID}:`, error54 instanceof Error ? error54.message : error54);
+      return false;
+    }
   }
   clear(requestId) {
-    removePendingControlRequest(requestId);
-    const pending = this.pendingById.get(requestId);
-    if (!pending)
-      return;
-    this.pendingById.delete(requestId);
-    const scopeKey = getChannelApprovalScopeKey({
-      channel: pending.event.source.channel,
-      accountId: pending.event.source.accountId,
-      chatId: pending.event.source.chatId,
-      threadId: pending.event.source.threadId
-    });
-    if (this.requestIdByScope.get(scopeKey) === requestId) {
-      this.requestIdByScope.delete(scopeKey);
-    }
+    this.coordinator.clear(requestId);
   }
   clearAll() {
-    this.pendingById.clear();
-    this.requestIdByScope.clear();
+    this.coordinator.clearAll();
   }
-  async tryHandleInbound(adapter, msg) {
+  async tryHandleInbound(_adapter, msg) {
     const channelCommand = parseChannelSlashCommand(msg.text) ?? (msg.channel === "slack" && msg.isMention === true ? parseChannelBangCommand(msg.text) : null);
-    if (channelCommand)
-      return false;
-    const scopeKey = getChannelApprovalScopeKey({
+    return this.coordinator.tryHandleInbound({
       channel: msg.channel,
       accountId: msg.accountId,
       chatId: msg.chatId,
-      threadId: msg.threadId
-    });
-    const requestId = this.requestIdByScope.get(scopeKey);
-    if (!requestId)
-      return false;
-    const pending = this.pendingById.get(requestId);
-    if (!pending) {
-      this.requestIdByScope.delete(scopeKey);
-      return false;
-    }
-    if (pending.event.source.senderId && pending.event.source.senderId !== msg.senderId) {
-      return false;
-    }
-    if (msg.channel === "slack" && pending.event.kind === "generic_tool_approval") {
-      return false;
-    }
-    const parsed = parseChannelControlRequestResponse(pending.event, msg.text);
-    if (parsed.type === "reprompt") {
-      await adapter.sendDirectReply(msg.chatId, parsed.message, buildDirectReplyOptions(msg));
-      return true;
-    }
-    const approvalResponseHandler = this.deps.getApprovalResponseHandler();
-    if (!approvalResponseHandler) {
-      await adapter.sendDirectReply(msg.chatId, "I’m reconnecting to Letta Code right now, so I couldn’t use that reply yet. Please send it again in a moment.", buildDirectReplyOptions(msg));
-      return true;
-    }
-    const handled = await approvalResponseHandler({
-      runtime: {
-        agent_id: pending.event.source.agentId,
-        conversation_id: pending.event.source.conversationId
-      },
-      response: parsed.response
+      messageId: msg.messageId,
+      threadId: msg.threadId,
+      senderId: msg.senderId,
+      text: msg.text,
+      bypass: Boolean(channelCommand)
     });
-    this.clear(requestId);
-    if (!handled) {
-      await adapter.sendDirectReply(msg.chatId, "That approval prompt expired before I could use your reply. Please ask the agent to try again.", buildDirectReplyOptions(msg));
-    }
-    return true;
+  }
+  getAdapter(event2) {
+    return this.deps.getAdapter(event2.source.channel, event2.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
   }
 }
 var init_registry_controls = __esm(() => {
   init_accounts();
   init_commands();
+  init_control_request_coordinator();
   init_pending_control_requests();
   init_registry_presentation();
 });
@@ -266897,7 +267085,60 @@ var init_queue = __esm(async () => {
   await init_image_policy();
 });
 
+// src/websocket/listener/queue-update-outbound.ts
+function queueEmitScopeKey(scope) {
+  return JSON.stringify([
+    scope?.agent_id ?? null,
+    scope?.conversation_id ?? null
+  ]);
+}
+function appendQueueRemovals(target2, removed) {
+  const known = new Set(target2.map((transition) => `${transition.client_message_id}:${transition.disposition}`));
+  for (const transition of removed) {
+    const key2 = `${transition.client_message_id}:${transition.disposition}`;
+    if (known.has(key2))
+      continue;
+    known.add(key2);
+    target2.push(transition);
+  }
+}
+function scheduleQueueEmit(runtime, scope, removed = []) {
+  runtime.pendingQueueEmitScope = scope;
+  let pendingByScope = pendingQueueEmitsByRuntime.get(runtime);
+  if (!pendingByScope) {
+    pendingByScope = new Map;
+    pendingQueueEmitsByRuntime.set(runtime, pendingByScope);
+  }
+  const key2 = queueEmitScopeKey(scope);
+  const pending = pendingByScope.get(key2) ?? { scope, removed: [] };
+  appendQueueRemovals(pending.removed, removed);
+  pendingByScope.set(key2, pending);
+  if (runtime.queueEmitScheduled)
+    return;
+  runtime.queueEmitScheduled = true;
+  queueMicrotask(() => {
+    runtime.queueEmitScheduled = false;
+    runtime.pendingQueueEmitScope = undefined;
+    const pendingEmits = pendingQueueEmitsByRuntime.get(runtime);
+    pendingQueueEmitsByRuntime.delete(runtime);
+    for (const pendingEmit of pendingEmits?.values() ?? []) {
+      emitQueueUpdateIfOpen(runtime, pendingEmit.scope, pendingEmit.removed);
+    }
+  });
+}
+var pendingQueueEmitsByRuntime;
+var init_queue_update_outbound = __esm(() => {
+  init_protocol_outbound();
+  pendingQueueEmitsByRuntime = new WeakMap;
+});
+
 // src/websocket/listener/conversation-runtime.ts
+function queueRemovalTransition(item, disposition) {
+  return {
+    client_message_id: item.clientMessageId ?? `cm-${item.id}`,
+    disposition
+  };
+}
 function ensureConversationQueueRuntime(listener, runtime) {
   if (runtime.queueRuntime) {
     return runtime;
@@ -266910,7 +267151,7 @@ function ensureConversationQueueRuntime(listener, runtime) {
       },
       onDequeued: (batch) => {
         runtime.pendingTurns = batch.queueLenAfter;
-        scheduleQueueEmit(listener, getQueueItemsScope(batch.items));
+        scheduleQueueEmit(listener, getQueueItemsScope(batch.items), batch.items.map((item) => queueRemovalTransition(item, "dequeued")));
       },
       onBlocked: () => {
         scheduleQueueEmit(listener, {
@@ -266920,13 +267161,23 @@ function ensureConversationQueueRuntime(listener, runtime) {
       },
       onCleared: (_reason, _clearedCount, items3) => {
         runtime.pendingTurns = 0;
-        scheduleQueueEmit(listener, getQueueItemsScope(items3));
+        scheduleQueueEmit(listener, getQueueItemsScope(items3), items3.map((item) => queueRemovalTransition(item, "cancelled")));
         evictConversationRuntimeIfIdle(runtime);
       },
       onDropped: (item, _reason, queueLen) => {
         runtime.pendingTurns = queueLen;
         runtime.queuedMessagesByItemId.delete(item.id);
-        scheduleQueueEmit(listener, getQueueItemScope(item));
+        scheduleQueueEmit(listener, getQueueItemScope(item), [
+          queueRemovalTransition(item, "cancelled")
+        ]);
+        evictConversationRuntimeIfIdle(runtime);
+      },
+      onRemoved: (item, queueLen) => {
+        runtime.pendingTurns = queueLen;
+        runtime.queuedMessagesByItemId.delete(item.id);
+        scheduleQueueEmit(listener, getQueueItemScope(item), [
+          queueRemovalTransition(item, "cancelled")
+        ]);
         evictConversationRuntimeIfIdle(runtime);
       }
     }
@@ -266938,7 +267189,7 @@ function getOrCreateScopedRuntime(listener, agentId, conversationId) {
 }
 var init_conversation_runtime = __esm(async () => {
   init_queue_runtime();
-  init_protocol_outbound();
+  init_queue_update_outbound();
   init_runtime();
   await init_queue();
 });
@@ -267544,8 +267795,9 @@ async function sendEnvironmentMessage(connectionId, body3) {
 async function getEnvironmentConnection(deviceId) {
   return apiRequest("GET", `/v1/environments/${encodeURIComponent(deviceId)}`);
 }
-async function createAgentSandbox(agentId) {
-  return apiRequest("POST", `/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, {});
+async function createAgentSandbox(agentId, options3 = {}, request = apiRequest) {
+  const conversationId = options3.conversationId === "default" ? undefined : options3.conversationId;
+  return request("POST", `/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, conversationId ? { conversationId } : {});
 }
 function isEnvironmentOnline(environment2) {
   return typeof environment2.connectionId === "string" && environment2.connectionId.length > 0 && typeof environment2.lastHeartbeat === "number" && Date.now() - environment2.lastHeartbeat < 120000;
@@ -267585,7 +267837,9 @@ async function resolveEnvironmentConnectionId(selector) {
 async function resolveAgentSandboxConnectionId(agentId, options3 = {}) {
   const timeoutMs = options3.timeoutMs ?? 3 * 60000;
   const pollIntervalMs = options3.pollIntervalMs ?? 2000;
-  const sandbox = await createAgentSandbox(agentId);
+  const sandbox = await createAgentSandbox(agentId, {
+    conversationId: options3.conversationId
+  });
   const deviceId = sandbox.deviceId || `sandbox-${agentId}`;
   const deadline = Date.now() + timeoutMs;
   let lastEnvironment = null;
@@ -273202,6 +273456,99 @@ var init_memory_subagent_completion = __esm(() => {
   init_system_prompt_warning();
 });
 
+// src/backend/api/reflection.ts
+function agentPath(agentId) {
+  return `/v1/agents/${encodeURIComponent(agentId)}`;
+}
+async function updateCloudReflectionConfig(agentId, input, request = apiRequest) {
+  await request("PATCH", `${agentPath(agentId)}/reflection`, { ...input });
+}
+async function updateCloudReflectionConversationProgress(agentId, conversationId, input, request = apiRequest) {
+  await request("PATCH", `${agentPath(agentId)}/conversations/${encodeURIComponent(conversationId)}/reflection`, { ...input });
+}
+var init_reflection2 = __esm(() => {
+  init_request();
+});
+
+// src/cli/helpers/reflection-completion.ts
+function errorMessage(error54) {
+  return error54 instanceof Error ? error54.message : String(error54);
+}
+function logCloudSyncWarning(message) {
+  debugWarn("memory", message);
+}
+async function isCloudReflectionAgent() {
+  const backend3 = getBackend();
+  return backend3.capabilities.remoteMemfs && !backend3.capabilities.localMemfs && await isLettaCloud();
+}
+async function syncReflectionCompletionToCloud(params, dependencies4 = {}) {
+  const logWarning = dependencies4.logWarning ?? logCloudSyncWarning;
+  try {
+    if (!await (dependencies4.isCloud ?? isCloudReflectionAgent)()) {
+      return;
+    }
+  } catch (error54) {
+    logWarning(`Failed to detect Cloud reflection state: ${errorMessage(error54)}`);
+    return;
+  }
+  let settings3;
+  try {
+    settings3 = (dependencies4.getSettings ?? getReflectionSettings)(params.agentId);
+  } catch (error54) {
+    logWarning(`Failed to resolve Cloud reflection config: ${errorMessage(error54)}`);
+    return;
+  }
+  try {
+    await (dependencies4.updateConfig ?? updateCloudReflectionConfig)(params.agentId, {
+      enabled: settings3.trigger !== "off",
+      min_turn_count: settings3.stepCount
+    });
+  } catch (error54) {
+    logWarning(`Failed to sync Cloud reflection config: ${errorMessage(error54)}`);
+    return;
+  }
+  for (const checkpoint2 of params.checkpoints) {
+    try {
+      await (dependencies4.updateProgress ?? updateCloudReflectionConversationProgress)(params.agentId, checkpoint2.conversationId, {
+        reflected_through_message_id: checkpoint2.reflectedThroughMessageId
+      });
+    } catch (error54) {
+      logWarning(`Failed to sync Cloud reflection progress for ${checkpoint2.conversationId}: ${errorMessage(error54)}`);
+    }
+  }
+}
+async function finalizeAutoReflectionCompletion(agentId, conversationId, payloadPath, endSnapshotLine, reflectedThroughMessageId, success2) {
+  await finalizeAutoReflectionPayload(agentId, conversationId, payloadPath, endSnapshotLine, success2);
+  if (!success2) {
+    return;
+  }
+  await syncReflectionCompletionToCloud({
+    agentId,
+    checkpoints: reflectedThroughMessageId ? [{ conversationId, reflectedThroughMessageId }] : []
+  });
+}
+async function finalizeMultiReflectionCompletion(agentId, manifest, success2) {
+  await finalizeMultiReflectionPayload(agentId, manifest, success2);
+  if (!success2) {
+    return;
+  }
+  await syncReflectionCompletionToCloud({
+    agentId,
+    checkpoints: manifest.transcripts.filter((slice) => slice.mode === "unreflected").map((slice) => ({
+      conversationId: slice.conversation_id,
+      reflectedThroughMessageId: slice.end_message_id
+    }))
+  });
+}
+var init_reflection_completion = __esm(() => {
+  init_memory_filesystem2();
+  init_backend2();
+  init_reflection2();
+  init_memory_reminder();
+  init_reflection_transcript();
+  init_debug();
+});
+
 // src/cli/helpers/reflection-integration.ts
 function buildReflectionIntegrationConversationTitle(reflectionSubagentId) {
   return reflectionSubagentId ? `Reflection integration (reflection ${reflectionSubagentId})` : "Reflection integration";
@@ -273766,7 +274113,7 @@ async function launchReflectionSubagent(options3) {
             recompileQueuedByConversation,
             logRecompileFailure: (message) => debugWarn("memory", message)
           });
-          await finalizeAutoReflectionPayload(agentId, conversationId, autoPayload.payloadPath, autoPayload.endSnapshotLine, completionSuccess);
+          await finalizeAutoReflectionCompletion(agentId, conversationId, autoPayload.payloadPath, autoPayload.endSnapshotLine, autoPayload.endMessageId, completionSuccess);
           await onCompletionMessage?.(completionMessage, {
             success: completionSuccess,
             error: error54,
@@ -273815,6 +274162,7 @@ var init_reflection_launcher = __esm(() => {
   init_backend2();
   init_memory_reminder();
   init_memory_subagent_completion();
+  init_reflection_completion();
   init_reflection_transcript();
   init_telemetry();
   init_reflection_threshold_feedback();
@@ -276319,7 +276667,7 @@ var init_identity2 = __esm(() => {
 function getListenerOAuthDeps() {
   return listenerOAuthDepsOverride ?? defaultListenerOAuthDeps;
 }
-function errorMessage(error54) {
+function errorMessage2(error54) {
   return error54 instanceof Error ? error54.message : String(error54);
 }
 function getListenerServerUrl(settings3) {
@@ -276402,7 +276750,7 @@ async function resolveListenerAuth(deviceId, connectionName, options3) {
     } catch (refreshError) {
       const retryable = !(refreshError instanceof OAuthRefreshError) || refreshError.retryable;
       if (retryable && isAccessTokenStillValid(settings3, apiKey)) {
-        console.warn(`Token refresh failed; using the current access token: ${errorMessage(refreshError)}`);
+        console.warn(`Token refresh failed; using the current access token: ${errorMessage2(refreshError)}`);
         return { serverUrl, apiKey };
       }
       if (retryable) {
@@ -276411,7 +276759,7 @@ async function resolveListenerAuth(deviceId, connectionName, options3) {
       if (!allowInteractiveOAuth) {
         throw new ListenerReauthenticationRequiredError(refreshError);
       }
-      console.warn(`Token refresh failed: ${errorMessage(refreshError)}`);
+      console.warn(`Token refresh failed: ${errorMessage2(refreshError)}`);
       apiKey = undefined;
     }
   }
@@ -276466,13 +276814,13 @@ var init_auth = __esm(() => {
   };
   ListenerAuthRetryableError = class ListenerAuthRetryableError extends Error {
     constructor(refreshError) {
-      super(`Could not refresh listener credentials: ${errorMessage(refreshError)}`);
+      super(`Could not refresh listener credentials: ${errorMessage2(refreshError)}`);
       this.name = "ListenerAuthRetryableError";
     }
   };
   ListenerReauthenticationRequiredError = class ListenerReauthenticationRequiredError extends Error {
     constructor(refreshError) {
-      const detail = refreshError ? `: ${errorMessage(refreshError)}` : "";
+      const detail = refreshError ? `: ${errorMessage2(refreshError)}` : "";
       super(`Saved Letta API credentials require reauthentication${detail}. Run letta to sign in again, or set LETTA_API_KEY.`);
       this.name = "ListenerReauthenticationRequiredError";
     }
@@ -329122,8 +329470,8 @@ ${lanes.join(`
       }
       function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors) {
         const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1;
-        const errorMessage2 = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
-        return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : errorMessage2, ignoreErrors);
+        const errorMessage3 = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
+        return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : errorMessage3, ignoreErrors);
       }
       function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, ignoreErrors = false, isForAugmentation = false) {
         return isStringLiteralLike(moduleReferenceExpression) ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, !ignoreErrors ? moduleReferenceExpression : undefined, isForAugmentation) : undefined;
@@ -340149,8 +340497,8 @@ ${lanes.join(`
             if (moduleSymbol.flags & targetMeaning) {
               links.resolvedType = resolveImportSymbolType(node, links, moduleSymbol, targetMeaning);
             } else {
-              const errorMessage2 = targetMeaning === 111551 ? Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
-              error210(node, errorMessage2, node.argument.literal.text);
+              const errorMessage3 = targetMeaning === 111551 ? Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
+              error210(node, errorMessage3, node.argument.literal.text);
               links.resolvedSymbol = unknownSymbol;
               links.resolvedType = errorType;
             }
@@ -341247,7 +341595,7 @@ ${lanes.join(`
       function elaborateElementwise(iterator2, source2, target2, relation, containingMessageChain, errorOutputContainer) {
         let reportedError = false;
         for (const value of iterator2) {
-          const { errorNode: prop, innerExpression: next, nameType, errorMessage: errorMessage2 } = value;
+          const { errorNode: prop, innerExpression: next, nameType, errorMessage: errorMessage3 } = value;
           let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source2, target2, nameType);
           if (!targetPropType || targetPropType.flags & 8388608)
             continue;
@@ -341270,9 +341618,9 @@ ${lanes.join(`
                 const sourceIsOptional = !!(propName && (getPropertyOfType(source2, propName) || unknownSymbol).flags & 16777216);
                 targetPropType = removeMissingType(targetPropType, targetIsOptional);
                 sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
-                const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage3, containingMessageChain, resultObj);
                 if (result && specificSource !== sourcePropType) {
-                  checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                  checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage3, containingMessageChain, resultObj);
                 }
               }
               if (resultObj.errors) {
@@ -341305,7 +341653,7 @@ ${lanes.join(`
         const iterationType = nonTupleOrArrayLikeTargetParts !== neverType2 ? getIterationTypeOfIterable(13, 0, nonTupleOrArrayLikeTargetParts, undefined) : undefined;
         let reportedError = false;
         for (let status = iterator2.next();!status.done; status = iterator2.next()) {
-          const { errorNode: prop, innerExpression: next, nameType, errorMessage: errorMessage2 } = status.value;
+          const { errorNode: prop, innerExpression: next, nameType, errorMessage: errorMessage3 } = status.value;
           let targetPropType = iterationType;
           const targetIndexedPropType = tupleOrArrayLikeTargetParts !== neverType2 ? getBestMatchIndexedAccessTypeOrUndefined(source2, tupleOrArrayLikeTargetParts, nameType) : undefined;
           if (targetIndexedPropType && !(targetIndexedPropType.flags & 8388608)) {
@@ -341332,9 +341680,9 @@ ${lanes.join(`
                 const sourceIsOptional = !!(propName && (getPropertyOfType(source2, propName) || unknownSymbol).flags & 16777216);
                 targetPropType = removeMissingType(targetPropType, targetIsOptional);
                 sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
-                const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage3, containingMessageChain, resultObj);
                 if (result && specificSource !== sourcePropType) {
-                  checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                  checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage3, containingMessageChain, resultObj);
                 }
               }
             }
@@ -350198,9 +350546,9 @@ ${lanes.join(`
           return;
         }
         const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1;
-        const errorMessage2 = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed;
+        const errorMessage3 = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed;
         const specifier = getJSXRuntimeImportSpecifier(file3, runtimeImportSpecifier);
-        const mod = resolveExternalModule(specifier || location, runtimeImportSpecifier, errorMessage2, location);
+        const mod = resolveExternalModule(specifier || location, runtimeImportSpecifier, errorMessage3, location);
         const result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : undefined;
         if (links) {
           links.jsxImplicitImportContainer = result || false;
@@ -359522,7 +359870,7 @@ ${lanes.join(`
               if (baseDeclarationFlags & 2 || derivedDeclarationFlags & 2) {
                 continue;
               }
-              let errorMessage2;
+              let errorMessage3;
               const basePropertyFlags = base3.flags & 98308;
               const derivedPropertyFlags = derived.flags & 98308;
               if (basePropertyFlags && derivedPropertyFlags) {
@@ -359551,14 +359899,14 @@ ${lanes.join(`
                   continue;
                 } else {
                   Debug.assert(!!(derived.flags & 98304));
-                  errorMessage2 = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+                  errorMessage3 = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
                 }
               } else if (base3.flags & 98304) {
-                errorMessage2 = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+                errorMessage3 = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
               } else {
-                errorMessage2 = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
+                errorMessage3 = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
               }
-              error210(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, typeToString(baseType), symbolToString(base3), typeToString(type3));
+              error210(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage3, typeToString(baseType), symbolToString(base3), typeToString(type3));
             }
           }
         for (const [errorNode, memberInfo] of notImplementedInfo) {
@@ -360404,10 +360752,10 @@ ${lanes.join(`
         }
         return false;
       }
-      function checkGrammarModuleElementContext(node, errorMessage2) {
+      function checkGrammarModuleElementContext(node, errorMessage3) {
         const isInAppropriateContext = node.parent.kind === 308 || node.parent.kind === 269 || node.parent.kind === 268;
         if (!isInAppropriateContext) {
-          grammarErrorOnFirstToken(node, errorMessage2);
+          grammarErrorOnFirstToken(node, errorMessage3);
         }
         return !isInAppropriateContext;
       }
@@ -386967,14 +387315,14 @@ ${lanes.join(`
       return output;
     }
     function formatDiagnostic2(diagnostic, host) {
-      const errorMessage2 = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;
+      const errorMessage3 = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;
       if (diagnostic.file) {
         const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
         const fileName = diagnostic.file.fileName;
         const relativeFileName = convertToRelativePath(fileName, host.getCurrentDirectory(), (fileName2) => host.getCanonicalFileName(fileName2));
-        return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage2;
+        return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage3;
       }
-      return errorMessage2;
+      return errorMessage3;
     }
     var ForegroundColorEscapeSequences = /* @__PURE__ */ ((ForegroundColorEscapeSequences2) => {
       ForegroundColorEscapeSequences2["Grey"] = "\x1B[90m";
@@ -455052,9 +455400,9 @@ async function drainStream(stream12, buffers, refresh, abortSignal, onFirstMessa
       }
     }
   } catch (e2) {
-    const errorMessage2 = e2 instanceof Error ? e2.message : String(e2);
+    const errorMessage3 = e2 instanceof Error ? e2.message : String(e2);
     const sdkDiagnostic = consumeLastSDKDiagnostic();
-    const errorMessageWithDiagnostic = sdkDiagnostic ? `${errorMessage2} [${sdkDiagnostic}]` : errorMessage2;
+    const errorMessageWithDiagnostic = sdkDiagnostic ? `${errorMessage3} [${sdkDiagnostic}]` : errorMessage3;
     debugWarn("drainStream", "Stream error caught: %s last_chunk=%s stream=%s", errorMessageWithDiagnostic, lastChunkDebugSummary, summarizeStreamForDebug(stream12));
     if (e2 instanceof Error && e2.stack) {
       debugWarn("drainStream", "Stream error stack: %s", e2.stack);
@@ -461397,10 +461745,10 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
           });
           break;
         }
-        const errorMessage2 = errorDetail2 || `Unexpected stop reason: ${stopReason}`;
+        const errorMessage3 = errorDetail2 || `Unexpected stop reason: ${stopReason}`;
         const terminalRunId = runId || runtime.activeRunId || runErrorInfo2?.run_id;
         const noticeParams = {
-          message: errorMessage2,
+          message: errorMessage3,
           agentId,
           conversationId,
           runErrorInfo: runErrorInfo2 ?? undefined,
@@ -461423,7 +461771,7 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
           isTerminal: true,
           runId: terminalRunId
         });
-        runtime.lastTerminalLoopErrorMessage = formattedError ?? errorMessage2;
+        runtime.lastTerminalLoopErrorMessage = formattedError ?? errorMessage3;
         runtime.lastTerminalLoopErrorRunId = terminalRunId ?? null;
         break;
       }
@@ -461548,10 +461896,10 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       });
       return;
     }
-    const errorMessage2 = error54 instanceof Error ? error54.message : String(error54);
+    const errorMessage3 = error54 instanceof Error ? error54.message : String(error54);
     const terminalRunId = runtime.activeRunId;
     const noticeParams = {
-      message: errorMessage2,
+      message: errorMessage3,
       agentId,
       conversationId,
       error: error54,
@@ -461574,7 +461922,7 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       isTerminal: true,
       runId: terminalRunId
     });
-    runtime.lastTerminalLoopErrorMessage = formattedError ?? errorMessage2;
+    runtime.lastTerminalLoopErrorMessage = formattedError ?? errorMessage3;
     runtime.lastTerminalLoopErrorRunId = terminalRunId ?? null;
     if (isDebugEnabled()) {
       console.error("[Listen] Error handling message:", error54);
@@ -464194,16 +464542,16 @@ async function handleExecuteCommand(command, socket, conversationRuntime, opts)
       error: error54,
       context: "listener_command_execution"
     });
-    const errorMessage2 = error54 instanceof Error ? error54.message : String(error54);
+    const errorMessage3 = error54 instanceof Error ? error54.message : String(error54);
     emitSlashCommandEnd(socket, conversationRuntime, scope, {
       command_id: command.command_id,
       input,
-      output: `Failed: ${errorMessage2}`,
+      output: `Failed: ${errorMessage3}`,
       success: false
     });
     emitExecuteCommandResponse(socket, command, {
       success: false,
-      output: `Failed: ${errorMessage2}`
+      output: `Failed: ${errorMessage3}`
     });
   }
 }
@@ -473812,8 +474160,168 @@ var init_mods = __esm(async () => {
   };
 });
 
-// src/cli/subcommands/app-server.ts
+// src/backend/api/sandbox-files.ts
+async function throwResponseError(response) {
+  const text2 = await response.text();
+  throw new ApiRequestError(`API error (${response.status}): ${text2}`, response.status, text2);
+}
+async function request(path46, init, deps) {
+  const config3 = await deps.getConfig();
+  const headers = new Headers(getLettaCodeHeaders(config3.apiKey));
+  new Headers(init.headers).forEach((value, key2) => {
+    headers.set(key2, value);
+  });
+  if (init.body instanceof FormData) {
+    headers.delete("Content-Type");
+  }
+  const response = await deps.fetch(new URL(path46, config3.baseUrl), {
+    ...init,
+    headers
+  });
+  if (!response.ok)
+    await throwResponseError(response);
+  return response;
+}
+async function ensureConversationSandbox(agentId, conversationId, deps = defaultDeps) {
+  const response = await request(`/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, {
+    method: "POST",
+    body: JSON.stringify({ conversationId })
+  }, deps);
+  return await response.json();
+}
+async function uploadFileToSandbox(sandboxId, file3, deps = defaultDeps) {
+  const form = new FormData;
+  form.append("file", file3.blob, file3.name);
+  const response = await request(`/v1/sandboxes/${encodeURIComponent(sandboxId)}/files`, {
+    method: "POST",
+    body: form
+  }, deps);
+  return await response.json();
+}
+async function downloadFileFromSandbox(sandboxId, path46, deps = defaultDeps) {
+  const query2 = new URLSearchParams({ path: path46 });
+  const response = await request(`/v1/sandboxes/${encodeURIComponent(sandboxId)}/files?${query2}`, { method: "GET" }, deps);
+  return new Uint8Array(await response.arrayBuffer());
+}
+var defaultDeps;
+var init_sandbox_files = __esm(() => {
+  init_http_headers();
+  init_request();
+  defaultDeps = {
+    fetch: globalThis.fetch,
+    getConfig: getApiRequestConfig
+  };
+});
+
+// src/cli/subcommands/sandbox.ts
+import { readFile as readFile25, stat as stat15, writeFile as writeFile18 } from "node:fs/promises";
+import { basename as basename28, resolve as resolve33 } from "node:path";
 import { parseArgs as parseArgs13 } from "node:util";
+function printUsage11() {
+  console.log(`
+Usage:
+  letta sandbox upload <local-path>
+  letta sandbox download <sandbox-path> [--to <local-path>]
+
+Notes:
+  - Requires an active conversation for a Letta Cloud agent.
+  - Uploads are stored under /root/downloads in the conversation sandbox.
+  - Downloads are limited to files under /root/downloads.
+  - Output is JSON only.
+`.trim());
+}
+function parseSandboxArgs(argv) {
+  return parseArgs13({
+    args: argv,
+    options: SANDBOX_OPTIONS,
+    strict: true,
+    allowPositionals: true
+  });
+}
+function getEnvironmentSession(env5) {
+  const agentId = (env5.LETTA_AGENT_ID || env5.AGENT_ID || "").trim();
+  const conversationId = (env5.LETTA_CONVERSATION_ID || env5.CONVERSATION_ID || "").trim();
+  if (!agentId && !conversationId)
+    return null;
+  if (!agentId || !conversationId) {
+    throw new Error("Both agent and conversation context are required when either is set");
+  }
+  return { agentId, conversationId };
+}
+function resolveSandboxSession(env5, fallback) {
+  const session = getEnvironmentSession(env5) ?? fallback;
+  if (!session) {
+    throw new Error("No active agent conversation found");
+  }
+  if (isLocalAgentId(session.agentId)) {
+    throw new Error("Sandbox file transfer requires a Letta Cloud agent");
+  }
+  if (!session.conversationId || session.conversationId === "default" || session.conversationId === "new") {
+    throw new Error("Sandbox file transfer requires an active conversation");
+  }
+  return session;
+}
+async function runSandboxSubcommand(argv, deps = {}) {
+  let parsed;
+  try {
+    parsed = parseSandboxArgs(argv);
+  } catch (error54) {
+    console.error(`Error: ${error54 instanceof Error ? error54.message : error54}`);
+    printUsage11();
+    return 1;
+  }
+  const [action3, path46] = parsed.positionals;
+  if (parsed.values.help || !action3 || action3 === "help") {
+    printUsage11();
+    return 0;
+  }
+  if (action3 !== "upload" && action3 !== "download" || !path46) {
+    console.error("Error: expected upload or download with a file path");
+    printUsage11();
+    return 1;
+  }
+  try {
+    await (deps.initializeSettings ?? (() => settingsManager.initialize()))();
+    if (!await (deps.isCloud ?? isLettaCloud)()) {
+      throw new Error("Sandbox file transfer is only available on Letta Cloud");
+    }
+    const session = resolveSandboxSession(process.env, (deps.getLastSession ?? (() => settingsManager.getEffectiveLastSession()))());
+    const ensureSandbox = deps.ensureSandbox ?? ensureConversationSandbox;
+    if (action3 === "upload") {
+      const localPath2 = resolve33(path46);
+      const fileStat = await (deps.statLocalPath ?? stat15)(localPath2);
+      if (!fileStat.isFile())
+        throw new Error(`${localPath2} is not a file`);
+      const data2 = await (deps.readLocalFile ?? readFile25)(localPath2);
+      const sandbox2 = await ensureSandbox(session.agentId, session.conversationId);
+      const result = await (deps.uploadFile ?? uploadFileToSandbox)(sandbox2.sandboxId, { blob: new Blob([data2]), name: basename28(localPath2) });
+      console.log(JSON.stringify(result, null, 2));
+      return 0;
+    }
+    const sandbox = await ensureSandbox(session.agentId, session.conversationId);
+    const data = await (deps.downloadFile ?? downloadFileFromSandbox)(sandbox.sandboxId, path46);
+    const localPath = resolve33(parsed.values.to ?? basename28(path46));
+    await (deps.writeLocalFile ?? writeFile18)(localPath, data);
+    console.log(JSON.stringify({ path: localPath, sandboxPath: path46, size: data.byteLength }, null, 2));
+    return 0;
+  } catch (error54) {
+    console.error(`Error: ${error54 instanceof Error ? error54.message : error54}`);
+    return 1;
+  }
+}
+var SANDBOX_OPTIONS;
+var init_sandbox2 = __esm(() => {
+  init_memory_filesystem2();
+  init_sandbox_files();
+  init_settings_manager();
+  SANDBOX_OPTIONS = {
+    help: { type: "boolean", short: "h" },
+    to: { type: "string" }
+  };
+});
+
+// src/cli/subcommands/app-server.ts
+import { parseArgs as parseArgs14 } from "node:util";
 function printAppServerHelp() {
   console.log(`Usage: letta server --listen [url]
 
@@ -473839,7 +474347,7 @@ Examples:
   letta server --listen ws://127.0.0.1:4500 --openai-api`);
 }
 async function waitForShutdown(close) {
-  return await new Promise((resolve33) => {
+  return await new Promise((resolve34) => {
     let shuttingDown = false;
     const shutdown = (signal) => {
       if (shuttingDown)
@@ -473848,10 +474356,10 @@ async function waitForShutdown(close) {
       close().then(() => {
         console.log(`
 Stopped App Server (${signal}).`);
-        resolve33(0);
+        resolve34(0);
       }).catch((error54) => {
         console.error(error54 instanceof Error ? `Error: ${error54.message}` : String(error54));
-        resolve33(1);
+        resolve34(1);
       });
     };
     process.once("SIGINT", shutdown);
@@ -473861,7 +474369,7 @@ Stopped App Server (${signal}).`);
 async function runAppServerSubcommand(argv) {
   let parsed;
   try {
-    parsed = parseArgs13({
+    parsed = parseArgs14({
       args: argv,
       allowPositionals: false,
       options: {
@@ -474413,7 +474921,7 @@ __export(exports_setup, {
   runSetup: () => runSetup
 });
 async function runSetup(options3 = {}) {
-  return new Promise((resolve33) => {
+  return new Promise((resolve34) => {
     let settled = false;
     let instance2;
     const settle = (result) => {
@@ -474422,7 +474930,7 @@ async function runSetup(options3 = {}) {
       }
       settled = true;
       instance2.unmount();
-      resolve33(result);
+      resolve34(result);
     };
     instance2 = render_default(import_react36.default.createElement(SetupUI, {
       initialMode: options3.initialMode,
@@ -474446,7 +474954,7 @@ var init_setup6 = __esm(async () => {
 });
 
 // src/cli/subcommands/setup.ts
-function printUsage11() {
+function printUsage12() {
   console.log(`
 Usage:
   letta setup
@@ -474457,12 +474965,12 @@ Re-run the interactive setup menu to choose local mode or sign in with Letta.
 async function runSetupSubcommand(argv) {
   const [arg, ...rest3] = argv;
   if (arg === "help" || arg === "--help" || arg === "-h") {
-    printUsage11();
+    printUsage12();
     return 0;
   }
   if (arg || rest3.length > 0) {
     console.error(`Unexpected arguments: ${[arg, ...rest3].filter(Boolean).join(" ")}`);
-    printUsage11();
+    printUsage12();
     return 1;
   }
   await settingsManager.initialize();
@@ -474477,8 +474985,8 @@ var init_setup7 = __esm(async () => {
 // src/cli/subcommands/shared-memory.ts
 import { existsSync as existsSync57 } from "node:fs";
 import { join as join72 } from "node:path";
-import { parseArgs as parseArgs14 } from "node:util";
-function printUsage12() {
+import { parseArgs as parseArgs15 } from "node:util";
+function printUsage13() {
   console.log(`
 Usage:
   letta shared-memory list [--agent <id>]
@@ -474513,7 +475021,7 @@ Examples:
 `.trim());
 }
 function parseSharedMemoryArgs(argv) {
-  return parseArgs14({
+  return parseArgs15({
     args: argv,
     options: SHARED_MEMORY_OPTIONS,
     strict: true,
@@ -474529,12 +475037,12 @@ function parseLimit4(value, fallback) {
   const parsed = Number.parseInt(value, 10);
   return Number.isNaN(parsed) || parsed <= 0 ? fallback : parsed;
 }
-async function listOrgRepositories(request) {
+async function listOrgRepositories(request2) {
   const repositories = [];
   const limit3 = 50;
   let offset = 0;
   for (;; ) {
-    const page = await request("GET", `/v1/repositories?limit=${limit3}&offset=${offset}`);
+    const page = await request2("GET", `/v1/repositories?limit=${limit3}&offset=${offset}`);
     repositories.push(...page.repositories);
     if (!page.has_next_page)
       break;
@@ -474542,8 +475050,8 @@ async function listOrgRepositories(request) {
   }
   return repositories;
 }
-async function listAgentRepositories(request, agentId) {
-  const response = await request("GET", `/v1/agents/${encodeURIComponent(agentId)}/repositories`);
+async function listAgentRepositories(request2, agentId) {
+  const response = await request2("GET", `/v1/agents/${encodeURIComponent(agentId)}/repositories`);
   return response.repositories.filter((repository) => !repository.is_primary && repository.name !== "memory");
 }
 function resolveRepositoryReference(repositories, reference) {
@@ -474552,9 +475060,9 @@ function resolveRepositoryReference(repositories, reference) {
     return null;
   return repositories.find((repository) => repository.id === trimmed) ?? repositories.find((repository) => repository.name === trimmed) ?? null;
 }
-async function waitForAttachedRepository(request, agentId, repositoryId, poll) {
+async function waitForAttachedRepository(request2, agentId, repositoryId, poll) {
   for (let attempt = 0;attempt < poll.attempts; attempt += 1) {
-    const attached = await listAgentRepositories(request, agentId);
+    const attached = await listAgentRepositories(request2, agentId);
     if (attached.some((repository) => repository.id === repositoryId)) {
       return true;
     }
@@ -474589,12 +475097,12 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
     parsed = parseSharedMemoryArgs(argv);
   } catch (error54) {
     console.error(error54 instanceof Error ? error54.message : String(error54));
-    printUsage12();
+    printUsage13();
     return 1;
   }
   const [action3, reference] = parsed.positionals;
   if (parsed.values.help || !action3 || action3 === "help") {
-    printUsage12();
+    printUsage13();
     return 0;
   }
   if (isLocalBackendEnvEnabled()) {
@@ -474602,16 +475110,16 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
     return 1;
   }
   await (deps.initializeSettings ?? (() => settingsManager.initialize()))();
-  const request = deps.request ?? apiRequest;
+  const request2 = deps.request ?? apiRequest;
   const syncRepositories = deps.syncRepositories ?? syncAttachedAgentRepositories;
   const recompileAgent = deps.recompileAgent ?? defaultRecompileAgent;
   try {
     if (action3 === "list") {
       const agentId = resolveSharedMemoryAgentId(parsed.values.agent, parsed.values["agent-id"]);
-      const repositories = await listOrgRepositories(request);
+      const repositories = await listOrgRepositories(request2);
       let attachedIds = new Set;
       if (agentId && !isLocalAgentId(agentId)) {
-        const attached = await listAgentRepositories(request, agentId);
+        const attached = await listAgentRepositories(request2, agentId);
         attachedIds = new Set(attached.map((repository) => repository.id));
       }
       console.log(JSON.stringify({
@@ -474628,7 +475136,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
         console.error("Usage: letta shared-memory create --name <name>");
         return 1;
       }
-      const repository = await request("POST", "/v1/repositories", { name });
+      const repository = await request2("POST", "/v1/repositories", { name });
       console.log(JSON.stringify(repository, null, 2));
       return 0;
     }
@@ -474637,7 +475145,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
         console.error(`Usage: letta shared-memory ${action3} <name-or-id>`);
         return 1;
       }
-      const repositories = await listOrgRepositories(request);
+      const repositories = await listOrgRepositories(request2);
       const repository = resolveRepositoryReference(repositories, reference);
       if (!repository) {
         console.error(`Repository not found: ${reference}. Run \`letta shared-memory list\` to see available repositories.`);
@@ -474649,7 +475157,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
         if (parsed.values.path) {
           query2.set("path", parsed.values.path);
         }
-        const versions2 = await request("GET", `/v1/repositories/${encodeURIComponent(repository.id)}/versions?${query2}`);
+        const versions2 = await request2("GET", `/v1/repositories/${encodeURIComponent(repository.id)}/versions?${query2}`);
         console.log(JSON.stringify({ repository: repository.name, ...versions2 }, null, 2));
         return 0;
       }
@@ -474657,8 +475165,8 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
       if (!agentId)
         return 1;
       if (action3 === "attach") {
-        await request("POST", `/v1/agents/${encodeURIComponent(agentId)}/repositories`, { repository_id: repository.id });
-        const visible = await waitForAttachedRepository(request, agentId, repository.id, deps.attachPoll ?? DEFAULT_ATTACH_POLL);
+        await request2("POST", `/v1/agents/${encodeURIComponent(agentId)}/repositories`, { repository_id: repository.id });
+        const visible = await waitForAttachedRepository(request2, agentId, repository.id, deps.attachPoll ?? DEFAULT_ATTACH_POLL);
         if (!visible) {
           console.error(`Attach accepted but ${repository.name} did not appear in the agent's repository list. Retry \`letta shared-memory sync\` shortly.`);
           return 1;
@@ -474677,7 +475185,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
         }, null, 2));
         return mounted ? 0 : 1;
       }
-      await request("DELETE", `/v1/agents/${encodeURIComponent(agentId)}/repositories/${encodeURIComponent(repository.id)}`);
+      await request2("DELETE", `/v1/agents/${encodeURIComponent(agentId)}/repositories/${encodeURIComponent(repository.id)}`);
       const detachRecompileError = await recompileAndReportFailure(recompileAgent, agentId);
       console.log(JSON.stringify({
         detached: true,
@@ -474696,7 +475204,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
       return result.failed > 0 ? 1 : 0;
     }
     console.error(`Unknown action: ${action3}`);
-    printUsage12();
+    printUsage13();
     return 1;
   } catch (error54) {
     console.error(error54 instanceof Error ? error54.message : String(error54));
@@ -476202,9 +476710,9 @@ import {
 } from "node:fs";
 import { mkdir as mkdir15, readdir as readdir14 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
-import { basename as basename28, dirname as dirname33, join as join73, normalize as normalize5, resolve as resolve33, sep as sep7 } from "node:path";
-import { parseArgs as parseArgs15, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
-function printUsage13() {
+import { basename as basename29, dirname as dirname33, join as join73, normalize as normalize5, resolve as resolve34, sep as sep7 } from "node:path";
+import { parseArgs as parseArgs16, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
+function printUsage14() {
   console.log(`
 Usage:
   letta install <thing> [--agent <id> | -n <agent name>] [--force]
@@ -476231,7 +476739,7 @@ Options:
 `.trim());
 }
 function parseSkillsArgs(argv) {
-  return parseArgs15({
+  return parseArgs16({
     args: argv,
     options: SKILLS_OPTIONS,
     strict: true,
@@ -476397,7 +476905,7 @@ function parseDirectSkillFileUrlSpecifier(input) {
   if (url2.protocol !== "https:" && !(url2.protocol === "http:" && isLocalhostHostname(url2.hostname))) {
     return null;
   }
-  if (basename28(url2.pathname).toLowerCase() !== "skill.md")
+  if (basename29(url2.pathname).toLowerCase() !== "skill.md")
     return null;
   return { url: url2.toString() };
 }
@@ -476628,8 +477136,8 @@ async function downloadClawHubSkillSource(location) {
   return { tmpDir, sourceDir };
 }
 function assertInside(parent, child) {
-  const parentPath = resolve33(parent);
-  const childPath = resolve33(child);
+  const parentPath = resolve34(parent);
+  const childPath = resolve34(child);
   if (childPath !== parentPath && !childPath.startsWith(`${parentPath}${sep7}`)) {
     throw new Error(`Resolved path is outside target directory: ${child}`);
   }
@@ -476645,12 +477153,12 @@ function getSkillName(sourceDir) {
   const skillMd = readFileSync39(join73(sourceDir, "SKILL.md"), "utf8");
   const { frontmatter } = parseFrontmatter(skillMd);
   const frontmatterName = frontmatter.name;
-  const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename28(sourceDir);
+  const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename29(sourceDir);
   return sanitizeSkillName(name);
 }
 async function installSkillDirectory(params) {
-  const sourceDir = resolve33(params.sourceDir);
-  const memoryDir = resolve33(params.memoryDir);
+  const sourceDir = resolve34(params.sourceDir);
+  const memoryDir = resolve34(params.memoryDir);
   const skillMdPath = join73(sourceDir, "SKILL.md");
   if (!existsSync58(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
@@ -476671,12 +477179,12 @@ async function installSkillDirectory(params) {
   await mkdir15(skillsDir, { recursive: true });
   cpSync2(sourceDir, targetPath, {
     recursive: true,
-    filter: (source2) => basename28(source2) !== ".git"
+    filter: (source2) => basename29(source2) !== ".git"
   });
   return { name, path: normalize5(targetPath) };
 }
 async function listSkillDirectories(params) {
-  const memoryDir = resolve33(params.memoryDir);
+  const memoryDir = resolve34(params.memoryDir);
   const skillsDir = join73(memoryDir, "skills");
   if (!existsSync58(skillsDir))
     return [];
@@ -476706,7 +477214,7 @@ async function listSkillDirectories(params) {
   return skills.sort((a2, b3) => a2.name.localeCompare(b3.name));
 }
 async function deleteSkillDirectory(params) {
-  const memoryDir = resolve33(params.memoryDir);
+  const memoryDir = resolve34(params.memoryDir);
   const skillsDir = join73(memoryDir, "skills");
   const name = sanitizeSkillName(params.name);
   const targetPath = join73(skillsDir, name);
@@ -476758,7 +477266,7 @@ async function installSkill(specifier, agentId, force) {
       downloaded = await downloadClawHubSkillSource(source2.location);
     }
     tmpDir = downloaded.tmpDir;
-    const sourceDir = resolve33(downloaded.sourceDir);
+    const sourceDir = resolve34(downloaded.sourceDir);
     assertInside(tmpDir, sourceDir);
     if (!existsSync58(sourceDir)) {
       const missingPath = source2.type === "git" ? source2.location.subdir ?? "." : source2.type === "direct-file" ? source2.location.url : source2.location.slug;
@@ -476879,17 +477387,17 @@ async function runInstall(argv, options3 = {}) {
     parsed = parseSkillsArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   const [specifier] = parsed.positionals;
   if (parsed.values.help || !specifier || specifier === "help") {
-    printUsage13();
+    printUsage14();
     return 0;
   }
   if (parsed.positionals.length > 1) {
     console.error(`Unexpected argument: ${parsed.positionals[1]}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   if (specifier.startsWith("npm:")) {
@@ -476941,7 +477449,7 @@ async function runInstall(argv, options3 = {}) {
       return 1;
     }
   }
-  const maybeLocalPath = resolve33(specifier);
+  const maybeLocalPath = resolve34(specifier);
   if (isLocalLettaModPackageDirectory(maybeLocalPath)) {
     if (hasInstallAgentScope(parsed.values)) {
       console.error("Agent-scoped mod package install is not supported yet.");
@@ -476980,16 +477488,16 @@ async function runList2(argv) {
     parsed = parseSkillsArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage13();
+    printUsage14();
     return 0;
   }
   if (parsed.positionals.length > 0) {
     console.error(`Unexpected argument: ${parsed.positionals[0]}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   try {
@@ -477010,17 +477518,17 @@ async function runDelete(argv) {
     parsed = parseSkillsArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   const [skillName] = parsed.positionals;
   if (parsed.values.help || !skillName || skillName === "help") {
-    printUsage13();
+    printUsage14();
     return 0;
   }
   if (parsed.positionals.length > 1) {
     console.error(`Unexpected argument: ${parsed.positionals[1]}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   const agentId = getExplicitAgentId2(parsed.values);
@@ -477060,11 +477568,11 @@ async function runSkillsSubcommand(argv) {
     case "help":
     case "--help":
     case "-h":
-      printUsage13();
+      printUsage14();
       return 0;
     default:
       console.error(`Unknown action: ${action3}`);
-      printUsage13();
+      printUsage14();
       return 1;
   }
 }
@@ -477083,26 +477591,26 @@ var init_skills4 = __esm(() => {
 });
 
 // src/cli/subcommands/trajectories/readers.ts
-import { readdir as readdir15, readFile as readFile25, stat as stat15 } from "node:fs/promises";
+import { readdir as readdir15, readFile as readFile26, stat as stat16 } from "node:fs/promises";
 import { join as join74 } from "node:path";
 async function loadSessionTranscript(item) {
-  const stats = await stat15(item.path);
+  const stats = await stat16(item.path);
   if (stats.isDirectory()) {
     return assembleEventDirectory(item.path);
   }
   if (item.path.endsWith(".db")) {
     return exportHermesSession(item.path, item.id);
   }
-  return readFile25(item.path, "utf-8");
+  return readFile26(item.path, "utf-8");
 }
 async function assembleEventDirectory(sessionDir) {
   const eventsSubdir = join74(sessionDir, "events");
-  const eventsDir = (await stat15(eventsSubdir).catch(() => null))?.isDirectory() ? eventsSubdir : sessionDir;
+  const eventsDir = (await stat16(eventsSubdir).catch(() => null))?.isDirectory() ? eventsSubdir : sessionDir;
   const names = (await readdir15(eventsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a2, b3) => Number.parseInt(a2, 10) - Number.parseInt(b3, 10) || a2.localeCompare(b3));
   if (names.length === 0) {
     throw new Error(`No event files found in ${eventsDir}`);
   }
-  const events = await Promise.all(names.map(async (name) => JSON.parse(await readFile25(join74(eventsDir, name), "utf-8"))));
+  const events = await Promise.all(names.map(async (name) => JSON.parse(await readFile26(join74(eventsDir, name), "utf-8"))));
   return JSON.stringify(events);
 }
 async function openReadOnlyDatabase(path46) {
@@ -477175,12 +477683,12 @@ import { createHash as createHash12 } from "node:crypto";
 import {
   mkdir as mkdir16,
   readdir as readdir16,
-  readFile as readFile26,
+  readFile as readFile27,
   rm as rm10,
-  stat as stat16,
-  writeFile as writeFile18
+  stat as stat17,
+  writeFile as writeFile19
 } from "node:fs/promises";
-import { basename as basename29, join as join75 } from "node:path";
+import { basename as basename30, join as join75 } from "node:path";
 function fileTimestamp(startedAt) {
   if (!startedAt)
     return "unknown-date";
@@ -477241,7 +477749,7 @@ function collectStats(records) {
 }
 async function prepareOutDir(outDir) {
   try {
-    const existing = await stat16(outDir);
+    const existing = await stat17(outDir);
     if (!existing.isDirectory()) {
       throw new Error(`--out ${outDir} exists and is not a directory`);
     }
@@ -477300,7 +477808,7 @@ async function runTrajectoryExport(options3) {
       usedFiles.add(file3);
       const body3 = JSON.stringify(records);
       await mkdir16(join75(options3.outDir, source2), { recursive: true });
-      await writeFile18(join75(options3.outDir, file3), body3, "utf-8");
+      await writeFile19(join75(options3.outDir, file3), body3, "utf-8");
       counts.exported += 1;
       manifest2.sessions.push({
         source: source2,
@@ -477348,13 +477856,13 @@ async function runTrajectoryExport(options3) {
     if (!supported.includes(explicit.source)) {
       throw new Error(`Unknown source "${explicit.source}" in --transcript. The installed trajectory package supports: ${supported.join(", ")}.`);
     }
-    await exportTranscript(explicit.source, basename29(explicit.path).replace(/\.[^.]+$/, ""), explicit.path, () => readFile26(explicit.path, "utf-8"));
+    await exportTranscript(explicit.source, basename30(explicit.path).replace(/\.[^.]+$/, ""), explicit.path, () => readFile27(explicit.path, "utf-8"));
   }
   for (const checkpoint2 of options3.deepagents ?? []) {
-    await exportCheckpoint(checkpoint2, `${basename29(checkpoint2.path)}-${checkpoint2.threadId}`);
+    await exportCheckpoint(checkpoint2, `${basename30(checkpoint2.path)}-${checkpoint2.threadId}`);
   }
   manifest2.sessions.sort((a2, b3) => (a2.startedAt ?? "").localeCompare(b3.startedAt ?? ""));
-  await writeFile18(join75(options3.outDir, MANIFEST_NAME), JSON.stringify(manifest2, null, 2), "utf-8");
+  await writeFile19(join75(options3.outDir, MANIFEST_NAME), JSON.stringify(manifest2, null, 2), "utf-8");
   return manifest2;
 }
 var MANIFEST_NAME = "manifest.json", FIRST_PROMPT_MAX_CHARS = 200, LIST_PAGE_LIMIT = 1000;
@@ -477365,12 +477873,12 @@ var init_export = __esm(() => {
 });
 
 // src/cli/subcommands/trajectories/review.ts
-import { readFile as readFile27 } from "node:fs/promises";
+import { readFile as readFile28 } from "node:fs/promises";
 import { isAbsolute as isAbsolute27, join as join76 } from "node:path";
 async function readManifest(dir) {
   let raw2;
   try {
-    raw2 = await readFile27(join76(dir, "manifest.json"), "utf-8");
+    raw2 = await readFile28(join76(dir, "manifest.json"), "utf-8");
   } catch {
     throw new Error(`No manifest at ${join76(dir, "manifest.json")}. Run: letta trajectories export --out ${dir}`);
   }
@@ -477383,7 +477891,7 @@ async function resolveSessionFile(dir, target2) {
   if (target2.endsWith(".json")) {
     const direct = isAbsolute27(target2) ? target2 : join76(dir, target2);
     try {
-      await readFile27(direct, "utf-8");
+      await readFile28(direct, "utf-8");
       return direct;
     } catch {}
   }
@@ -477435,7 +477943,7 @@ async function searchSessions(dir, keyword, options3 = {}) {
   for (const session of filterSessions(manifest2.sessions, options3)) {
     let records;
     try {
-      records = JSON.parse(await readFile27(join76(dir, session.file), "utf-8"));
+      records = JSON.parse(await readFile28(join76(dir, session.file), "utf-8"));
     } catch {
       continue;
     }
@@ -477466,9 +477974,9 @@ var TOOL_RESULT_MAX_CHARS = 500, REASONING_MAX_CHARS = 300, TOOL_ARGS_MAX_CHARS
 var init_review = () => {};
 
 // src/cli/subcommands/trajectories.ts
-import { readFile as readFile28 } from "node:fs/promises";
-import { parseArgs as parseArgs16 } from "node:util";
-function printUsage14() {
+import { readFile as readFile29 } from "node:fs/promises";
+import { parseArgs as parseArgs17 } from "node:util";
+function printUsage15() {
   console.log(`
 Usage:
   letta trajectories export [options]
@@ -477573,7 +478081,7 @@ async function runView(flags, target2, options3) {
     return 1;
   }
   const path46 = await resolveSessionFile(flags.dir, target2);
-  const records = JSON.parse(await readFile28(path46, "utf-8"));
+  const records = JSON.parse(await readFile29(path46, "utf-8"));
   console.log(renderSession(records, options3));
   return 0;
 }
@@ -477606,7 +478114,7 @@ ${results.length} session(s) matched "${keyword}"`);
   return 0;
 }
 function parseTrajectoriesArgs(argv) {
-  return parseArgs16({
+  return parseArgs17({
     args: argv,
     options: TRAJECTORIES_OPTIONS,
     strict: true,
@@ -477619,12 +478127,12 @@ async function runTrajectoriesSubcommand(argv) {
     parsed = parseTrajectoriesArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage14();
+    printUsage15();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || action3 === "help" || !action3) {
-    printUsage14();
+    printUsage15();
     return parsed.values.help || action3 === "help" ? 0 : 1;
   }
   const asJson = Boolean(parsed.values.json);
@@ -477656,7 +478164,7 @@ async function runTrajectoriesSubcommand(argv) {
   }
   if (action3 !== "export") {
     console.error(`Unknown command: ${action3}`);
-    printUsage14();
+    printUsage15();
     return 1;
   }
   const options3 = {
@@ -477799,7 +478307,7 @@ function waitForSocketOpen(socket) {
   if (socket.readyState === WEBSOCKET_OPEN_STATE) {
     return Promise.resolve();
   }
-  return new Promise((resolve34, reject) => {
+  return new Promise((resolve35, reject) => {
     let detachOpen = () => {};
     let detachError = () => {};
     const cleanup = () => {
@@ -477808,7 +478316,7 @@ function waitForSocketOpen(socket) {
     };
     detachOpen = onceSocketEvent(socket, "open", () => {
       cleanup();
-      resolve34();
+      resolve35();
     });
     detachError = onceSocketEvent(socket, "error", (event2) => {
       cleanup();
@@ -477921,13 +478429,13 @@ class AppServerClient {
   }
   requestRaw(command, options3) {
     const timeoutMs = options3.timeoutMs ?? this.requestTimeoutMs;
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(command.request_id);
         reject(new Error(`Timed out waiting for ${command.request_id}`));
       }, timeoutMs);
       this.pending.set(command.request_id, {
-        resolve: (message) => resolve34(message),
+        resolve: (message) => resolve35(message),
         reject,
         predicate: options3.predicate,
         timeout
@@ -477950,13 +478458,13 @@ class AppServerClient {
     } : commandOrType;
     const options3 = isTypeRequest ? maybeOptions : bodyOrOptions;
     const timeoutMs = options3.timeoutMs ?? this.requestTimeoutMs;
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(command.request_id);
         reject(new Error(`Timed out waiting for ${command.request_id}`));
       }, timeoutMs);
       this.pending.set(command.request_id, {
-        resolve: (message) => resolve34(message),
+        resolve: (message) => resolve35(message),
         reject,
         predicate: options3.predicate,
         timeout
@@ -478825,44 +479333,44 @@ function trimmedOrNull(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
-function effectiveTextThreadId(request, route) {
-  const requestThreadId = trimmedOrNull(request.threadId);
+function effectiveTextThreadId(request2, route) {
+  const requestThreadId = trimmedOrNull(request2.threadId);
   const routeThreadId = trimmedOrNull(route.threadId);
-  if (request.channel === "telegram") {
+  if (request2.channel === "telegram") {
     if (requestThreadId)
       return requestThreadId;
     if (route.chatType === "direct")
       return null;
     return route.chatId.trim().startsWith("-") ? routeThreadId : null;
   }
-  if (request.channel === "discord") {
+  if (request2.channel === "discord") {
     return route.chatType === "direct" ? route.chatId : requestThreadId ?? routeThreadId;
   }
-  if (request.channel === "slack") {
-    const isDirect = route.chatType === "direct" || request.chatId.startsWith("D");
+  if (request2.channel === "slack") {
+    const isDirect = route.chatType === "direct" || request2.chatId.startsWith("D");
     if (isDirect)
       return requestThreadId ?? routeThreadId;
-    return request.replyToMessageId ? null : requestThreadId ?? routeThreadId;
+    return request2.replyToMessageId ? null : requestThreadId ?? routeThreadId;
   }
   return null;
 }
-function effectiveTextReplyId(request, route) {
-  const isSlackDirect = request.channel === "slack" && (route.chatType === "direct" || request.chatId.startsWith("D"));
-  return isSlackDirect ? null : trimmedOrNull(request.replyToMessageId);
+function effectiveTextReplyId(request2, route) {
+  const isSlackDirect = request2.channel === "slack" && (route.chatType === "direct" || request2.chatId.startsWith("D"));
+  return isSlackDirect ? null : trimmedOrNull(request2.replyToMessageId);
 }
-function messageIdempotencyKey(request, route) {
-  if (request.action !== "send" && request.action !== "send-rich" || request.mediaPath) {
+function messageIdempotencyKey(request2, route) {
+  if (request2.action !== "send" && request2.action !== "send-rich" || request2.mediaPath) {
     return null;
   }
   return JSON.stringify({
-    action: request.action,
-    channel: request.channel,
+    action: request2.action,
+    channel: request2.channel,
     chatId: route.chatId,
     accountId: route.accountId ?? null,
     chatType: route.chatType ?? null,
-    threadId: effectiveTextThreadId(request, route),
-    message: request.message ?? null,
-    replyToMessageId: effectiveTextReplyId(request, route)
+    threadId: effectiveTextThreadId(request2, route),
+    message: request2.message ?? null,
+    replyToMessageId: effectiveTextReplyId(request2, route)
   });
 }
 async function executeMessageChannel(input, options3) {
@@ -478899,8 +479407,8 @@ async function executeMessageChannel(input, options3) {
         channelTurnSources: options3.channelTurnSources
       });
       const requestThreadId = normalized.action === "download-file" ? normalized.threadId : inferredThreadId ?? (normalized.channel === "telegram" && context4.route.chatType === "direct" ? normalized.threadId : context4.route.threadId ?? normalized.threadId);
-      const request2 = buildMessageChannelRequest(normalized, normalized.chatId, requestThreadId);
-      return await dispatchWithIdempotency(request2, context4, options3.idempotencyScope);
+      const request3 = buildMessageChannelRequest(normalized, normalized.chatId, requestThreadId);
+      return await dispatchWithIdempotency(request3, context4, options3.idempotencyScope);
     }
     if (normalized.channel !== "slack") {
       return `Error: Explicit MessageChannel targets are not supported on ${normalized.channel}.`;
@@ -478921,8 +479429,8 @@ async function executeMessageChannel(input, options3) {
       transport: proactive.transport,
       messageActions: proactive.messageActions
     };
-    const request = buildMessageChannelRequest(normalized, proactive.target.chatId, proactive.target.threadId);
-    return await dispatchWithIdempotency(request, context3, options3.idempotencyScope);
+    const request2 = buildMessageChannelRequest(normalized, proactive.target.chatId, proactive.target.threadId);
+    return await dispatchWithIdempotency(request2, context3, options3.idempotencyScope);
   } catch (error54) {
     if (error54 instanceof MessageChannelDuplicateActionError)
       throw error54;
@@ -478933,9 +479441,9 @@ async function executeMessageChannel(input, options3) {
 async function executeMessageChannelExternalTool(input, options3) {
   return createMessageChannelExternalToolResult(await executeMessageChannel(input, options3));
 }
-function dispatchWithIdempotency(request, context3, scope) {
-  const dispatch = () => dispatchMessageChannelAction({ request, context: context3 });
-  const key2 = messageIdempotencyKey(request, context3.route);
+function dispatchWithIdempotency(request2, context3, scope) {
+  const dispatch = () => dispatchMessageChannelAction({ request: request2, context: context3 });
+  const key2 = messageIdempotencyKey(request2, context3.route);
   return scope ? scope.execute(key2, dispatch) : dispatch();
 }
 var init_message_channel_executor = __esm(() => {
@@ -479971,7 +480479,7 @@ var init_progress_builder = __esm(() => {
 function runtimeKey(runtime) {
   return `${runtime.agent_id}:${runtime.conversation_id}`;
 }
-function sourceKey(source2) {
+function sourceRouteKey(source2) {
   return [
     source2.channel,
     source2.accountId ?? "",
@@ -479979,12 +480487,26 @@ function sourceKey(source2) {
     source2.threadId ?? ""
   ].join(":");
 }
-function uniqueSources(sources) {
+function sourceLifecycleKey(source2) {
+  return [
+    sourceRouteKey(source2),
+    source2.messageId ?? "",
+    source2.agentId,
+    source2.conversationId
+  ].join(":");
+}
+function uniqueSourcesBy(sources, getKey) {
   const byKey = new Map;
   for (const source2 of sources)
-    byKey.set(sourceKey(source2), source2);
+    byKey.set(getKey(source2), source2);
   return [...byKey.values()];
 }
+function uniqueRoutedSources(sources) {
+  return uniqueSourcesBy(sources, sourceRouteKey);
+}
+function uniqueLifecycleSources(sources) {
+  return uniqueSourcesBy(sources, sourceLifecycleKey);
+}
 function channelTagsForSources(sources) {
   return [...new Set(sources.map((source2) => `channel:${source2.channel}`))];
 }
@@ -480014,11 +480536,11 @@ class ChannelGateway {
   constructor(client, hooks) {
     this.client = client;
     this.hooks = hooks;
-    this.disposers.push(client.onMessage((message) => this.handleMessage(message)), client.onExternalToolCall((request) => {
-      const state = request.runtime ? this.states.get(runtimeKey(request.runtime)) : undefined;
+    this.disposers.push(client.onMessage((message) => this.handleMessage(message)), client.onExternalToolCall((request2) => {
+      const state = request2.runtime ? this.states.get(runtimeKey(request2.runtime)) : undefined;
       const active = state?.active;
-      const sources = active?.sources ?? state?.routedSources ?? [];
-      return hooks.executeExternalTool(request, sources, active?.idempotencyScope ?? null);
+      const sources = active?.routingSources ?? state?.routedSources ?? [];
+      return hooks.executeExternalTool(request2, sources, active?.idempotencyScope ?? null);
     }));
   }
   close() {
@@ -480044,12 +480566,12 @@ class ChannelGateway {
       return true;
     }
     state.pendingSourcesByClientMessageId.set(delivery.clientMessageId, {
-      sources: uniqueSources(delivery.sources),
+      sources: uniqueLifecycleSources(delivery.sources),
       disposition: "submitting"
     });
     try {
       await this.enqueueRegistration(async () => {
-        state.routedSources = uniqueSources([
+        state.routedSources = uniqueRoutedSources([
           ...state.routedSources,
           ...delivery.sources
         ]);
@@ -480087,8 +480609,8 @@ class ChannelGateway {
         const pending = state.pendingSourcesByClientMessageId.get(delivery.clientMessageId);
         if (pending) {
           pending.disposition = "queued";
-          pending.acceptedAtQueueRevision = state.queueRevision;
         }
+        this.reconcileExplicitQueueRemovals(state);
       }
       await Promise.all(queuedEvents);
       return true;
@@ -480104,7 +480626,8 @@ class ChannelGateway {
     if (!state.active) {
       recoveredTurn = {
         batchId: `channel-recovered-${crypto.randomUUID()}`,
-        sources: uniqueSources(sources),
+        routingSources: uniqueRoutedSources(sources),
+        lifecycleSources: uniqueLifecycleSources(sources),
         progress: createChannelTurnProgressBuilder(),
         richDraft: null,
         idempotencyScope: createMessageChannelIdempotencyScope()
@@ -480145,7 +480668,7 @@ class ChannelGateway {
     return result.accepted;
   }
   setRoutedSources(runtime, sources) {
-    this.getState(runtime).routedSources = uniqueSources(sources);
+    this.getState(runtime).routedSources = uniqueRoutedSources(sources);
   }
   getKnownRuntimes() {
     return [...this.states.values()].map((state) => state.runtime);
@@ -480182,7 +480705,6 @@ class ChannelGateway {
       state = {
         runtime,
         pendingSourcesByClientMessageId: new Map,
-        queueRevision: 0,
         active: null,
         registrationSignature: null,
         registration: null,
@@ -480299,43 +480821,81 @@ class ChannelGateway {
   }
   handleQueueUpdate(message) {
     const state = this.getState(message.runtime);
-    state.queueRevision += 1;
-    const nextQueued = new Set(message.queue.map((entry) => entry.client_message_id));
-    const removed = [];
+    for (const transition of message.removed) {
+      const pending = state.pendingSourcesByClientMessageId.get(transition.client_message_id);
+      if (pending) {
+        pending.removalDisposition = transition.disposition;
+      }
+    }
+    this.reconcileExplicitQueueRemovals(state);
+  }
+  reconcileExplicitQueueRemovals(state) {
+    const dequeued = [];
+    const cancelled = [];
     for (const [
       clientMessageId,
       pending
     ] of state.pendingSourcesByClientMessageId) {
-      if (pending.disposition === "queued" && state.queueRevision > (pending.acceptedAtQueueRevision ?? -1) && !nextQueued.has(clientMessageId)) {
-        removed.push({ clientMessageId, sources: pending.sources });
-        state.pendingSourcesByClientMessageId.delete(clientMessageId);
-      }
-    }
-    if (!state.active && removed.length > 0) {
-      const first = removed[0];
-      if (first) {
-        this.activateSources(state, first.clientMessageId, removed.flatMap((entry) => entry.sources));
+      if (pending.disposition !== "queued" || !pending.removalDisposition) {
+        continue;
       }
+      const target2 = pending.removalDisposition === "dequeued" ? dequeued : cancelled;
+      target2.push({ clientMessageId, sources: pending.sources });
+      state.pendingSourcesByClientMessageId.delete(clientMessageId);
+    }
+    const firstDequeued = dequeued[0];
+    if (firstDequeued) {
+      this.activateSources(state, firstDequeued.clientMessageId, dequeued.flatMap((entry) => entry.sources));
+    }
+    for (const entry of cancelled) {
+      this.enqueueHook(state, () => this.hooks.onLifecycle({
+        type: "finished",
+        batchId: `channel-${entry.clientMessageId}`,
+        sources: entry.sources,
+        outcome: "cancelled",
+        stopReason: "cancelled"
+      }));
     }
   }
   activateSources(state, clientMessageId, sources) {
     if (state.active) {
+      const knownLifecycleKeys = new Set(state.active.lifecycleSources.map(sourceLifecycleKey));
+      const addedLifecycleSources = uniqueLifecycleSources(sources).filter((source2) => !knownLifecycleKeys.has(sourceLifecycleKey(source2)));
+      if (addedLifecycleSources.length === 0)
+        return;
+      state.active.lifecycleSources = uniqueLifecycleSources([
+        ...state.active.lifecycleSources,
+        ...addedLifecycleSources
+      ]);
+      state.active.routingSources = uniqueRoutedSources([
+        ...state.active.routingSources,
+        ...sources
+      ]);
+      const processingEvent2 = {
+        type: "processing",
+        batchId: state.active.batchId,
+        sources: addedLifecycleSources
+      };
+      this.enqueueHook(state, () => this.hooks.onLifecycle(processingEvent2));
       return;
     }
+    const routingSources = uniqueRoutedSources(sources);
+    const lifecycleSources = uniqueLifecycleSources(sources);
     state.active = {
       batchId: `channel-${clientMessageId}`,
-      sources: uniqueSources(sources),
+      routingSources,
+      lifecycleSources,
       progress: createChannelTurnProgressBuilder(),
       richDraft: this.hooks.createRichDraft?.({
         batchId: `channel-${clientMessageId}`,
-        sources
+        sources: routingSources
       }) ?? null,
       idempotencyScope: createMessageChannelIdempotencyScope()
     };
     const processingEvent = {
       type: "processing",
       batchId: state.active.batchId,
-      sources: state.active.sources
+      sources: state.active.lifecycleSources
     };
     this.enqueueHook(state, () => this.hooks.onLifecycle(processingEvent));
   }
@@ -480353,7 +480913,7 @@ class ChannelGateway {
       this.enqueueHook(state, () => this.hooks.onProgress({
         type: "progress",
         batchId: active.batchId,
-        sources: active.sources,
+        sources: active.routingSources,
         ...update2
       }));
     }
@@ -480373,7 +480933,7 @@ class ChannelGateway {
     this.enqueueHook(state, () => this.hooks.onLifecycle({
       type: "finished",
       batchId: active.batchId,
-      sources: active.sources,
+      sources: active.lifecycleSources,
       outcome: lifecycleOutcome(terminal.stopReason),
       stopReason: terminal.stopReason,
       ...terminal.runId ?? active.runId ? { runId: terminal.runId ?? active.runId } : {},
@@ -480389,9 +480949,9 @@ class ChannelGateway {
     }));
     if (!state)
       return;
-    const sources = state.active?.sources ?? [];
+    const sources = state.active?.routingSources ?? [];
     state.replayedControlRequestIds.add(message.request_id);
-    const sourceScopes = new Map(sources.map((source3) => [sourceKey(source3), source3]));
+    const sourceScopes = new Map(sources.map((source3) => [sourceRouteKey(source3), source3]));
     if (sourceScopes.size !== 1)
       return;
     const source2 = [...sourceScopes.values()][0];
@@ -481644,12 +482204,12 @@ function createRoutedRuntimeRegistrationRefresher(options3) {
     });
     return run;
   };
-  const waitForRetry = () => new Promise((resolve34) => {
-    resolveRetry = resolve34;
+  const waitForRetry = () => new Promise((resolve35) => {
+    resolveRetry = resolve35;
     retryTimer = setTimeout(() => {
       retryTimer = null;
       resolveRetry = null;
-      resolve34();
+      resolve35();
     }, retryDelayMs);
     retryTimer.unref?.();
   });
@@ -481814,16 +482374,16 @@ async function executeChannelServiceCommand(command) {
   await Promise.all(detachedTasks);
   return responses;
 }
-async function executeGatewayServiceCommand(request) {
-  if (request.kind === "protocol") {
+async function executeGatewayServiceCommand(request2) {
+  if (request2.kind === "protocol") {
     return {
       kind: "protocol",
-      messages: await executeChannelServiceCommand(request.command)
+      messages: await executeChannelServiceCommand(request2.command)
     };
   }
   return {
     kind: "text",
-    text: await handleChannelsSlashCommand(request.runtime, request.args)
+    text: await handleChannelsSlashCommand(request2.runtime, request2.args)
   };
 }
 function gatewayClientMessageId(delivery) {
@@ -481910,17 +482470,17 @@ async function startLocalChannelGateway(options3) {
     buildExternalTool: async (runtime) => {
       return buildGatewayMessageChannelTool(registry2.resolveTurnSourcesForScope(runtime.agent_id, runtime.conversation_id));
     },
-    executeExternalTool: async (request, sources, idempotencyScope) => {
-      if (request.tool_name !== "MessageChannel" || !request.runtime) {
-        throw new Error(`Unsupported gateway tool: ${request.tool_name}`);
+    executeExternalTool: async (request2, sources, idempotencyScope) => {
+      if (request2.tool_name !== "MessageChannel" || !request2.runtime) {
+        throw new Error(`Unsupported gateway tool: ${request2.tool_name}`);
       }
       return await executeLocalMessageChannelExternalTool({
-        ...request.input,
-        channel: String(request.input.channel ?? ""),
-        action: String(request.input.action ?? ""),
+        ...request2.input,
+        channel: String(request2.input.channel ?? ""),
+        action: String(request2.input.action ?? ""),
         parentScope: {
-          agentId: request.runtime.agent_id,
-          conversationId: request.runtime.conversation_id
+          agentId: request2.runtime.agent_id,
+          conversationId: request2.runtime.conversation_id
         },
         channelTurnSources: sources
       }, idempotencyScope);
@@ -482229,14 +482789,14 @@ var exports_channel_gateway = {};
 __export(exports_channel_gateway, {
   runChannelGatewaySubcommand: () => runChannelGatewaySubcommand
 });
-import { parseArgs as parseArgs17 } from "node:util";
+import { parseArgs as parseArgs18 } from "node:util";
 function isGatewayCommandEnvelope(value) {
   return Boolean(value && typeof value === "object" && "type" in value && value.type === "command" && "requestId" in value && typeof value.requestId === "string" && "command" in value && value.command && typeof value.command === "object");
 }
 async function runChannelGatewaySubcommand(argv) {
   let values2;
   try {
-    ({ values: values2 } = parseArgs17({
+    ({ values: values2 } = parseArgs18({
       args: argv,
       strict: true,
       allowPositionals: false,
@@ -482275,7 +482835,7 @@ async function runChannelGatewaySubcommand(argv) {
       await ensureChannelRuntimeInstalled2(channelName);
     }
   }
-  return await new Promise((resolve34) => {
+  return await new Promise((resolve35) => {
     let closing2 = false;
     let closeGateway = null;
     const finish = (code2) => {
@@ -482283,10 +482843,10 @@ async function runChannelGatewaySubcommand(argv) {
         return;
       closing2 = true;
       if (!closeGateway) {
-        resolve34(code2);
+        resolve35(code2);
         return;
       }
-      closeGateway().finally(() => resolve34(code2));
+      closeGateway().finally(() => resolve35(code2));
     };
     startLocalChannelGateway({
       appServerUrl,
@@ -482334,7 +482894,7 @@ async function runChannelGatewaySubcommand(argv) {
         gateway.close();
     }).catch((error54) => {
       console.error(error54 instanceof Error ? error54.message : String(error54));
-      resolve34(1);
+      resolve35(1);
     });
   });
 }
@@ -482372,6 +482932,7 @@ function subcommandNeedsEarlyBackendMode(command) {
     case "messages":
     case "mods":
     case "remote":
+    case "sandbox":
     case "server":
     case "shared-memory":
     case "skills":
@@ -482406,6 +482967,8 @@ async function runSubcommand(argv) {
       return runEnvironmentsSubcommand(rest3);
     case "mods":
       return runModsSubcommand(rest3);
+    case "sandbox":
+      return runSandboxSubcommand(rest3);
     case "server":
       return runServerSubcommand(rest3);
     case "remote":
@@ -482451,6 +483014,7 @@ var init_router = __esm(async () => {
   init_local_backend2();
   init_memory7();
   init_messages10();
+  init_sandbox2();
   init_shared_memory();
   init_skills4();
   init_trajectories();
@@ -482528,10 +483092,10 @@ async function detectAndEnableKittyProtocol() {
     detectionComplete = true;
     return;
   }
-  return new Promise((resolve34) => {
+  return new Promise((resolve35) => {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
       detectionComplete = true;
-      resolve34();
+      resolve35();
       return;
     }
     const originalRawMode = process.stdin.isRaw;
@@ -482564,7 +483128,7 @@ async function detectAndEnableKittyProtocol() {
         console.error("[kitty] protocol query unsupported; enabled anyway (best-effort)");
       }
       detectionComplete = true;
-      resolve34();
+      resolve35();
     };
     const handleData = (data) => {
       if (timeoutId === undefined) {
@@ -483201,9 +483765,9 @@ function writeWireMessage(msg) {
 async function writeWireMessageAsync(msg) {
   const line = `${JSON.stringify(stampWireMessage(msg))}
 `;
-  return await new Promise((resolve34, reject) => {
+  return await new Promise((resolve35, reject) => {
     if (process.stdout.destroyed || process.stdout.writableEnded) {
-      resolve34(false);
+      resolve35(false);
       return;
     }
     process.stdout.write(line, (error54) => {
@@ -483211,7 +483775,7 @@ async function writeWireMessageAsync(msg) {
         reject(error54);
         return;
       }
-      resolve34(true);
+      resolve35(true);
     });
   });
 }
@@ -484462,8 +485026,8 @@ async function parseErrorResponse2(input) {
     const errorClass = OAUTH_ERRORS[error54] || ServerError;
     return new errorClass(error_description || "", error_uri);
   } catch (error54) {
-    const errorMessage2 = `${statusCode2 ? `HTTP ${statusCode2}: ` : ""}Invalid OAuth error response: ${error54}. Raw body: ${body3}`;
-    return new ServerError(errorMessage2);
+    const errorMessage3 = `${statusCode2 ? `HTTP ${statusCode2}: ` : ""}Invalid OAuth error response: ${error54}. Raw body: ${body3}`;
+    return new ServerError(errorMessage3);
   }
 }
 async function auth(provider, options3) {
@@ -485094,8 +485658,8 @@ class Protocol {
     this._taskStore = _options?.taskStore;
     this._taskMessageQueue = _options?.taskMessageQueue;
     if (this._taskStore) {
-      this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
-        const task2 = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+      this.setRequestHandler(GetTaskRequestSchema, async (request2, extra) => {
+        const task2 = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
         if (!task2) {
           throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
         }
@@ -485103,9 +485667,9 @@ class Protocol {
           ...task2
         };
       });
-      this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+      this.setRequestHandler(GetTaskPayloadRequestSchema, async (request2, extra) => {
         const handleTaskResult = async () => {
-          const taskId = request.params.taskId;
+          const taskId = request2.params.taskId;
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -485118,8 +485682,8 @@ class Protocol {
                   if (queuedMessage.type === "response") {
                     resolver(message);
                   } else {
-                    const errorMessage2 = message;
-                    const error54 = new McpError(errorMessage2.error.code, errorMessage2.error.message, errorMessage2.error.data);
+                    const errorMessage3 = message;
+                    const error54 = new McpError(errorMessage3.error.code, errorMessage3.error.message, errorMessage3.error.data);
                     resolver(error54);
                   }
                 } else {
@@ -485156,9 +485720,9 @@ class Protocol {
         };
         return await handleTaskResult();
       });
-      this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+      this.setRequestHandler(ListTasksRequestSchema, async (request2, extra) => {
         try {
-          const { tasks: tasks2, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+          const { tasks: tasks2, nextCursor } = await this._taskStore.listTasks(request2.params?.cursor, extra.sessionId);
           return {
             tasks: tasks2,
             nextCursor,
@@ -485168,20 +485732,20 @@ class Protocol {
           throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error54 instanceof Error ? error54.message : String(error54)}`);
         }
       });
-      this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+      this.setRequestHandler(CancelTaskRequestSchema, async (request2, extra) => {
         try {
-          const task2 = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          const task2 = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
           if (!task2) {
-            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request2.params.taskId}`);
           }
           if (isTerminal(task2.status)) {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task2.status}`);
           }
-          await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
-          const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          await this._taskStore.updateTaskStatus(request2.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+          this._clearTaskQueue(request2.params.taskId);
+          const cancelledTask = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
           if (!cancelledTask) {
-            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request2.params.taskId}`);
           }
           return {
             _meta: {},
@@ -485297,14 +485861,14 @@ class Protocol {
     }
     Promise.resolve().then(() => handler(notification)).catch((error54) => this._onerror(new Error(`Uncaught error in notification handler: ${error54}`)));
   }
-  _onrequest(request, extra) {
-    const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
+  _onrequest(request2, extra) {
+    const handler = this._requestHandlers.get(request2.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
-    const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const relatedTaskId = request2.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
     if (handler === undefined) {
       const errorResponse = {
         jsonrpc: "2.0",
-        id: request.id,
+        id: request2.id,
         error: {
           code: ErrorCode.MethodNotFound,
           message: "Method not found"
@@ -485322,17 +485886,17 @@ class Protocol {
       return;
     }
     const abortController = new AbortController;
-    this._requestHandlerAbortControllers.set(request.id, abortController);
-    const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : undefined;
-    const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : undefined;
+    this._requestHandlerAbortControllers.set(request2.id, abortController);
+    const taskCreationParams = isTaskAugmentedRequestParams(request2.params) ? request2.params.task : undefined;
+    const taskStore = this._taskStore ? this.requestTaskStore(request2, capturedTransport?.sessionId) : undefined;
     const fullExtra = {
       signal: abortController.signal,
       sessionId: capturedTransport?.sessionId,
-      _meta: request.params?._meta,
+      _meta: request2.params?._meta,
       sendNotification: async (notification) => {
         if (abortController.signal.aborted)
           return;
-        const notificationOptions = { relatedRequestId: request.id };
+        const notificationOptions = { relatedRequestId: request2.id };
         if (relatedTaskId) {
           notificationOptions.relatedTask = { taskId: relatedTaskId };
         }
@@ -485342,7 +485906,7 @@ class Protocol {
         if (abortController.signal.aborted) {
           throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
         }
-        const requestOptions = { ...options3, relatedRequestId: request.id };
+        const requestOptions = { ...options3, relatedRequestId: request2.id };
         if (relatedTaskId && !requestOptions.relatedTask) {
           requestOptions.relatedTask = { taskId: relatedTaskId };
         }
@@ -485353,7 +485917,7 @@ class Protocol {
         return await this.request(r5, resultSchema, requestOptions);
       },
       authInfo: extra?.authInfo,
-      requestId: request.id,
+      requestId: request2.id,
       requestInfo: extra?.requestInfo,
       taskId: relatedTaskId,
       taskStore,
@@ -485363,16 +485927,16 @@ class Protocol {
     };
     Promise.resolve().then(() => {
       if (taskCreationParams) {
-        this.assertTaskHandlerCapability(request.method);
+        this.assertTaskHandlerCapability(request2.method);
       }
-    }).then(() => handler(request, fullExtra)).then(async (result) => {
+    }).then(() => handler(request2, fullExtra)).then(async (result) => {
       if (abortController.signal.aborted) {
         return;
       }
       const response = {
         result,
         jsonrpc: "2.0",
-        id: request.id
+        id: request2.id
       };
       if (relatedTaskId && this._taskMessageQueue) {
         await this._enqueueTaskMessage(relatedTaskId, {
@@ -485389,7 +485953,7 @@ class Protocol {
       }
       const errorResponse = {
         jsonrpc: "2.0",
-        id: request.id,
+        id: request2.id,
         error: {
           code: Number.isSafeInteger(error54["code"]) ? error54["code"] : ErrorCode.InternalError,
           message: error54.message ?? "Internal error",
@@ -485406,8 +485970,8 @@ class Protocol {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error54) => this._onerror(new Error(`Failed to send response: ${error54}`))).finally(() => {
-      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
-        this._requestHandlerAbortControllers.delete(request.id);
+      if (this._requestHandlerAbortControllers.get(request2.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request2.id);
       }
     });
   }
@@ -485481,11 +486045,11 @@ class Protocol {
   async close() {
     await this._transport?.close();
   }
-  async* requestStream(request, resultSchema, options3) {
+  async* requestStream(request2, resultSchema, options3) {
     const { task: task2 } = options3 ?? {};
     if (!task2) {
       try {
-        const result = await this.request(request, resultSchema, options3);
+        const result = await this.request(request2, resultSchema, options3);
         yield { type: "result", result };
       } catch (error54) {
         yield {
@@ -485497,7 +486061,7 @@ class Protocol {
     }
     let taskId;
     try {
-      const createResult = await this.request(request, CreateTaskResultSchema, options3);
+      const createResult = await this.request(request2, CreateTaskResultSchema, options3);
       if (createResult.task) {
         taskId = createResult.task.taskId;
         yield { type: "taskCreated", task: createResult.task };
@@ -485530,7 +486094,7 @@ class Protocol {
           return;
         }
         const pollInterval = task3.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve34) => setTimeout(resolve34, pollInterval));
+        await new Promise((resolve35) => setTimeout(resolve35, pollInterval));
         options3?.signal?.throwIfAborted();
       }
     } catch (error54) {
@@ -485540,9 +486104,9 @@ class Protocol {
       };
     }
   }
-  request(request, resultSchema, options3) {
+  request(request2, resultSchema, options3) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task: task2, relatedTask } = options3 ?? {};
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       const earlyReject = (error54) => {
         reject(error54);
       };
@@ -485552,9 +486116,9 @@ class Protocol {
       }
       if (this._options?.enforceStrictCapabilities === true) {
         try {
-          this.assertCapabilityForMethod(request.method);
+          this.assertCapabilityForMethod(request2.method);
           if (task2) {
-            this.assertTaskCapability(request.method);
+            this.assertTaskCapability(request2.method);
           }
         } catch (e2) {
           earlyReject(e2);
@@ -485564,16 +486128,16 @@ class Protocol {
       options3?.signal?.throwIfAborted();
       const messageId2 = this._requestMessageId++;
       const jsonrpcRequest = {
-        ...request,
+        ...request2,
         jsonrpc: "2.0",
         id: messageId2
       };
       if (options3?.onprogress) {
         this._progressHandlers.set(messageId2, options3.onprogress);
         jsonrpcRequest.params = {
-          ...request.params,
+          ...request2.params,
           _meta: {
-            ...request.params?._meta || {},
+            ...request2.params?._meta || {},
             progressToken: messageId2
           }
         };
@@ -485620,7 +486184,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve34(parseResult.data);
+            resolve35(parseResult.data);
           }
         } catch (error54) {
           reject(error54);
@@ -485749,8 +486313,8 @@ class Protocol {
   setRequestHandler(requestSchema, handler) {
     const method = getMethodLiteral(requestSchema);
     this.assertRequestHandlerCapability(method);
-    this._requestHandlers.set(method, (request, extra) => {
-      const parsed = parseWithCompat(requestSchema, request);
+    this._requestHandlers.set(method, (request2, extra) => {
+      const parsed = parseWithCompat(requestSchema, request2);
       return Promise.resolve(handler(parsed, extra));
     });
   }
@@ -485811,31 +486375,31 @@ class Protocol {
         interval = task2.pollInterval;
       }
     } catch {}
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve34, interval);
+      const timeoutId = setTimeout(resolve35, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
       }, { once: true });
     });
   }
-  requestTaskStore(request, sessionId) {
+  requestTaskStore(request2, sessionId) {
     const taskStore = this._taskStore;
     if (!taskStore) {
       throw new Error("No task store configured");
     }
     return {
       createTask: async (taskParams) => {
-        if (!request) {
+        if (!request2) {
           throw new Error("No request provided");
         }
-        return await taskStore.createTask(taskParams, request.id, {
-          method: request.method,
-          params: request.params
+        return await taskStore.createTask(taskParams, request2.id, {
+          method: request2.method,
+          params: request2.params
         }, sessionId);
       },
       getTask: async (taskId) => {
@@ -488801,7 +489365,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref6];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve34.call(this, root2, ref6);
+    let _sch = resolve35.call(this, root2, ref6);
     if (_sch === undefined) {
       const schema5 = (_a8 = root2.localRefs) === null || _a8 === undefined ? undefined : _a8[ref6];
       const { schemaId } = this.opts;
@@ -488828,7 +489392,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s22) {
     return s1.schema === s22.schema && s1.root === s22.root && s1.baseId === s22.baseId;
   }
-  function resolve34(root2, ref6) {
+  function resolve35(root2, ref6) {
     let sch;
     while (typeof (sch = this.refs[ref6]) == "string")
       ref6 = sch;
@@ -489414,7 +489978,7 @@ var require_fast_uri = __commonJS((exports, module3) => {
     }
     return uri;
   }
-  function resolve34(baseURI, relativeURI, options3) {
+  function resolve35(baseURI, relativeURI, options3) {
     const schemelessOptions = options3 ? Object.assign({ scheme: "null" }, options3) : { scheme: "null" };
     const resolved = resolveComponent(parse9(baseURI, schemelessOptions), parse9(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -489679,7 +490243,7 @@ var require_fast_uri = __commonJS((exports, module3) => {
   var fastUri = {
     SCHEMES,
     normalize: normalize6,
-    resolve: resolve34,
+    resolve: resolve35,
     resolveComponent,
     equal: equal3,
     serialize,
@@ -492584,8 +493148,8 @@ class ExperimentalClientTasks {
   async cancelTask(taskId, options3) {
     return this._client.cancelTask({ taskId }, options3);
   }
-  requestStream(request, resultSchema, options3) {
-    return this._client.requestStream(request, resultSchema, options3);
+  requestStream(request2, resultSchema, options3) {
+    return this._client.requestStream(request2, resultSchema, options3);
   }
 }
 var init_client8 = __esm(() => {
@@ -492736,11 +493300,11 @@ var init_client9 = __esm(() => {
       }
       const method = methodValue;
       if (method === "elicitation/create") {
-        const wrappedHandler = async (request, extra) => {
-          const validatedRequest = safeParse4(ElicitRequestSchema, request);
+        const wrappedHandler = async (request2, extra) => {
+          const validatedRequest = safeParse4(ElicitRequestSchema, request2);
           if (!validatedRequest.success) {
-            const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage2}`);
+            const errorMessage3 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage3}`);
           }
           const { params } = validatedRequest.data;
           params.mode = params.mode ?? "form";
@@ -492751,19 +493315,19 @@ var init_client9 = __esm(() => {
           if (params.mode === "url" && !supportsUrlMode) {
             throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
           }
-          const result = await Promise.resolve(handler(request, extra));
+          const result = await Promise.resolve(handler(request2, extra));
           if (params.task) {
             const taskValidationResult = safeParse4(CreateTaskResultSchema, result);
             if (!taskValidationResult.success) {
-              const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-              throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
+              const errorMessage3 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage3}`);
             }
             return taskValidationResult.data;
           }
           const validationResult = safeParse4(ElicitResultSchema, result);
           if (!validationResult.success) {
-            const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage2}`);
+            const errorMessage3 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage3}`);
           }
           const validatedResult = validationResult.data;
           const requestedSchema = params.mode === "form" ? params.requestedSchema : undefined;
@@ -492779,19 +493343,19 @@ var init_client9 = __esm(() => {
         return super.setRequestHandler(requestSchema, wrappedHandler);
       }
       if (method === "sampling/createMessage") {
-        const wrappedHandler = async (request, extra) => {
-          const validatedRequest = safeParse4(CreateMessageRequestSchema, request);
+        const wrappedHandler = async (request2, extra) => {
+          const validatedRequest = safeParse4(CreateMessageRequestSchema, request2);
           if (!validatedRequest.success) {
-            const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage2}`);
+            const errorMessage3 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage3}`);
           }
           const { params } = validatedRequest.data;
-          const result = await Promise.resolve(handler(request, extra));
+          const result = await Promise.resolve(handler(request2, extra));
           if (params.task) {
             const taskValidationResult = safeParse4(CreateTaskResultSchema, result);
             if (!taskValidationResult.success) {
-              const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-              throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
+              const errorMessage3 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage3}`);
             }
             return taskValidationResult.data;
           }
@@ -492799,8 +493363,8 @@ var init_client9 = __esm(() => {
           const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema;
           const validationResult = safeParse4(resultSchema, result);
           if (!validationResult.success) {
-            const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage2}`);
+            const errorMessage3 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage3}`);
           }
           return validationResult.data;
         };
@@ -493498,7 +494062,7 @@ class SSEClientTransport {
   }
   _startOrAuth() {
     const fetchImpl = this?._eventSourceInit?.fetch ?? this._fetch ?? fetch;
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       this._eventSource = new EventSource2(this._url.href, {
         ...this._eventSourceInit,
         fetch: async (url2, init) => {
@@ -493519,7 +494083,7 @@ class SSEClientTransport {
       this._abortController = new AbortController;
       this._eventSource.onerror = (event2) => {
         if (event2.code === 401 && this._authProvider) {
-          this._authThenStart().then(resolve34, reject);
+          this._authThenStart().then(resolve35, reject);
           return;
         }
         const error54 = new SseError(event2.code, event2.message, event2);
@@ -493540,7 +494104,7 @@ class SSEClientTransport {
           this.close();
           return;
         }
-        resolve34();
+        resolve35();
       });
       this._eventSource.onmessage = (event2) => {
         const messageEvent2 = event2;
@@ -493713,7 +494277,7 @@ class StdioClientTransport {
     if (this._process) {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       this._process = import_cross_spawn2.default(this._serverParams.command, this._serverParams.args ?? [], {
         env: {
           ...getDefaultEnvironment(),
@@ -493729,7 +494293,7 @@ class StdioClientTransport {
         this.onerror?.(error54);
       });
       this._process.on("spawn", () => {
-        resolve34();
+        resolve35();
       });
       this._process.on("close", (_code) => {
         this._process = undefined;
@@ -493781,20 +494345,20 @@ class StdioClientTransport {
     if (this._process) {
       const processToClose = this._process;
       this._process = undefined;
-      const closePromise = new Promise((resolve34) => {
+      const closePromise = new Promise((resolve35) => {
         processToClose.once("close", () => {
-          resolve34();
+          resolve35();
         });
       });
       try {
         processToClose.stdin?.end();
       } catch {}
-      await Promise.race([closePromise, new Promise((resolve34) => setTimeout(resolve34, 2000).unref())]);
+      await Promise.race([closePromise, new Promise((resolve35) => setTimeout(resolve35, 2000).unref())]);
       if (processToClose.exitCode === null) {
         try {
           processToClose.kill("SIGTERM");
         } catch {}
-        await Promise.race([closePromise, new Promise((resolve34) => setTimeout(resolve34, 2000).unref())]);
+        await Promise.race([closePromise, new Promise((resolve35) => setTimeout(resolve35, 2000).unref())]);
       }
       if (processToClose.exitCode === null) {
         try {
@@ -493805,15 +494369,15 @@ class StdioClientTransport {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve34) => {
+    return new Promise((resolve35) => {
       if (!this._process?.stdin) {
         throw new Error("Not connected");
       }
       const json3 = serializeMessage(message);
       if (this._process.stdin.write(json3)) {
-        resolve34();
+        resolve35();
       } else {
-        this._process.stdin.once("drain", resolve34);
+        this._process.stdin.once("drain", resolve35);
       }
     });
   }
@@ -494489,7 +495053,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.30.18"
+    version: "0.30.19"
   };
 });
 
@@ -494634,10 +495198,10 @@ async function startOAuthCallbackServerOnPort(port) {
   let completed = false;
   let settle;
   let reject;
-  const codePromise = new Promise((resolve34, rejectPromise) => {
+  const codePromise = new Promise((resolve35, rejectPromise) => {
     settle = (code2) => {
       completed = true;
-      resolve34(code2);
+      resolve35(code2);
     };
     reject = (error54) => {
       completed = true;
@@ -494647,8 +495211,8 @@ async function startOAuthCallbackServerOnPort(port) {
   codePromise.catch(() => {
     return;
   });
-  server2 = createServer3((request, response) => {
-    const url2 = new URL(request.url ?? "/", "http://127.0.0.1");
+  server2 = createServer3((request2, response) => {
+    const url2 = new URL(request2.url ?? "/", "http://127.0.0.1");
     if (url2.pathname !== "/callback") {
       response.writeHead(404).end("Not found");
       return;
@@ -494675,9 +495239,9 @@ async function startOAuthCallbackServerOnPort(port) {
     settle?.(code2);
     server2.close();
   });
-  await new Promise((resolve34, rejectListen) => {
+  await new Promise((resolve35, rejectListen) => {
     server2.once("error", rejectListen);
-    server2.listen(port, "127.0.0.1", resolve34);
+    server2.listen(port, "127.0.0.1", resolve35);
   });
   server2.unref();
   const address = server2.address();
@@ -494912,7 +495476,7 @@ var init_mcp_runtime = __esm(async () => {
 
 // src/skills/builtin/creating-skills/scripts/validate-skill.ts
 import { existsSync as existsSync61, readFileSync as readFileSync40 } from "node:fs";
-import { basename as basename30, join as join79, resolve as resolve34 } from "node:path";
+import { basename as basename31, join as join79, resolve as resolve35 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function parseQuotedScalar(value) {
   if (value.startsWith('"')) {
@@ -495072,7 +495636,7 @@ function validateSkill(skillPath) {
         message: `Name is too long (${trimmedName.length} characters). Maximum is ${MAX_SKILL_NAME_LENGTH} characters.`
       };
     }
-    const dirName = basename30(skillPath);
+    const dirName = basename31(skillPath);
     if (trimmedName !== dirName) {
       warnings.push(`Name '${trimmedName}' doesn't match directory name '${dirName}'. For portability, these should match.`);
     }
@@ -495107,7 +495671,7 @@ function validateSkill(skillPath) {
 }
 function isMainModule() {
   const entrypoint = process.argv[1];
-  return entrypoint ? resolve34(entrypoint) === fileURLToPath11(import.meta.url) : false;
+  return entrypoint ? resolve35(entrypoint) === fileURLToPath11(import.meta.url) : false;
 }
 var ALLOWED_PROPERTIES, MAX_SKILL_NAME_LENGTH = 64;
 var init_validate_skill = __esm(() => {
@@ -495176,8 +495740,8 @@ __export(exports_import, {
   extractSkillsFromAf: () => extractSkillsFromAf
 });
 import { createReadStream as createReadStream2 } from "node:fs";
-import { access as access2, chmod, mkdir as mkdir17, readFile as readFile29, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname34, isAbsolute as isAbsolute28, relative as relative14, resolve as resolve35, sep as sep8, win32 as win325 } from "node:path";
+import { access as access2, chmod, mkdir as mkdir17, readFile as readFile30, writeFile as writeFile20 } from "node:fs/promises";
+import { dirname as dirname34, isAbsolute as isAbsolute28, relative as relative14, resolve as resolve36, sep as sep8, win32 as win325 } from "node:path";
 function validateImportedSkillName(name) {
   const trimmedName = name.trim();
   if (trimmedName !== name || trimmedName.length === 0 || trimmedName.length > MAX_SKILL_NAME_LENGTH || trimmedName === "." || trimmedName === ".." || !IMPORTED_SKILL_NAME_PATTERN.test(trimmedName)) {
@@ -495186,8 +495750,8 @@ function validateImportedSkillName(name) {
   return trimmedName;
 }
 function assertPathInside(parent, child) {
-  const parentPath = resolve35(parent);
-  const childPath = resolve35(child);
+  const parentPath = resolve36(parent);
+  const childPath = resolve36(child);
   const relativePath = relative14(parentPath, childPath);
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep8}`) || isAbsolute28(relativePath)) {
     throw new Error(`Imported skill file path escapes skill directory: ${child}`);
@@ -495205,7 +495769,7 @@ function validateImportedSkillFilePath(filePath) {
 }
 function resolveImportedSkillFilePath(skillDir, filePath) {
   const safeFilePath = validateImportedSkillFilePath(filePath);
-  const fullPath = resolve35(skillDir, safeFilePath);
+  const fullPath = resolve36(skillDir, safeFilePath);
   assertPathInside(skillDir, fullPath);
   return fullPath;
 }
@@ -495239,7 +495803,7 @@ async function importAgentFromFile(options3) {
   if (!getBackend().capabilities.agentFileImportExport) {
     throw new Error("Agent file import is not supported by this backend yet");
   }
-  const resolvedPath = resolve35(options3.filePath);
+  const resolvedPath = resolve36(options3.filePath);
   try {
     await access2(resolvedPath);
   } catch {
@@ -495277,14 +495841,14 @@ async function importAgentFromFile(options3) {
 }
 async function extractSkillsFromAf(afPath, destDir) {
   const extracted = [];
-  const content = await readFile29(afPath, "utf-8");
+  const content = await readFile30(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
   }
   for (const skill2 of afData.skills) {
     const skillName = validateImportedSkillName(skill2.name);
-    const skillDir = resolve35(destDir, skillName);
+    const skillDir = resolve36(destDir, skillName);
     await mkdir17(skillDir, { recursive: true });
     if (skill2.files) {
       await writeSkillFiles(skillDir, skill2.files);
@@ -495306,7 +495870,7 @@ async function writeSkillFiles(skillDir, files) {
 async function writeSkillFile(skillDir, filePath, content) {
   const fullPath = resolveImportedSkillFilePath(skillDir, filePath);
   await mkdir17(dirname34(fullPath), { recursive: true });
-  await writeFile19(fullPath, content, "utf-8");
+  await writeFile20(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
     try {
@@ -495359,7 +495923,7 @@ function parseRegistryHandle(handle2) {
 async function importAgentFromRegistry(options3) {
   const { tmpdir: tmpdir11 } = await import("node:os");
   const { join: join80 } = await import("node:path");
-  const { writeFile: writeFile20, unlink: unlink6 } = await import("node:fs/promises");
+  const { writeFile: writeFile21, unlink: unlink6 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options3.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
   const response = await fetch(rawUrl);
@@ -495371,7 +495935,7 @@ async function importAgentFromRegistry(options3) {
   }
   const afContent = await response.text();
   const tempPath = join80(tmpdir11(), `letta-import-${author}-${name}-${Date.now()}.af`);
-  await writeFile20(tempPath, afContent, "utf-8");
+  await writeFile21(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
       filePath: tempPath,
@@ -495784,10 +496348,10 @@ async function sendScopedApprovalMessages(params) {
   });
 }
 async function flushAndExit(code2) {
-  const flushWritable = (stream12) => new Promise((resolve36) => {
+  const flushWritable = (stream12) => new Promise((resolve37) => {
     if (stream12.destroyed || stream12.writableEnded)
-      return resolve36();
-    stream12.write("", () => resolve36());
+      return resolve37();
+    stream12.write("", () => resolve37());
   });
   await closeClientMcpServers();
   await Promise.allSettled([
@@ -495797,12 +496361,12 @@ async function flushAndExit(code2) {
   process.exit(code2);
 }
 async function writeFinalHeadlessStdout(text2) {
-  await new Promise((resolve36) => {
+  await new Promise((resolve37) => {
     if (process.stdout.destroyed || process.stdout.writableEnded) {
-      resolve36();
+      resolve37();
       return;
     }
-    process.stdout.write(text2, () => resolve36());
+    process.stdout.write(text2, () => resolve37());
   });
 }
 function pageItems5(page) {
@@ -495895,7 +496459,7 @@ async function waitForEnvironmentAssistantMessage(params) {
         return { text: text2, stopReason: observedStopReason };
       }
     }
-    await new Promise((resolve36) => setTimeout(resolve36, pollIntervalMs));
+    await new Promise((resolve37) => setTimeout(resolve37, pollIntervalMs));
   }
   if (observedCompletion && lastText) {
     return { text: lastText, stopReason: observedStopReason };
@@ -496813,7 +497377,7 @@ ${loadedContents.join(`
   if (usesRemoteEnvironment) {
     const environmentSelector = String(explicitEnvironmentSelector);
     const useCloudSandbox = isCloudEnvironmentSelector(environmentSelector);
-    const environmentRouting = useCloudSandbox ? await resolveAgentSandboxConnectionId(agent2.id) : await resolveEnvironmentConnectionId(environmentSelector);
+    const environmentRouting = useCloudSandbox ? await resolveAgentSandboxConnectionId(agent2.id, { conversationId }) : await resolveEnvironmentConnectionId(environmentSelector);
     const { connectionId, environment: environment2 } = environmentRouting;
     const responseEnvironment = buildEnvironmentResponseMetadata({
       source: useCloudSandbox ? "cloud-sandbox" : "explicit",
@@ -497122,7 +497686,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
             }
-            await new Promise((resolve36) => setTimeout(resolve36, retryDelayMs));
+            await new Promise((resolve37) => setTimeout(resolve37, retryDelayMs));
             continue;
           }
         }
@@ -497171,7 +497735,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`Transient API error before streaming (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve36) => setTimeout(resolve36, delayMs));
+          await new Promise((resolve37) => setTimeout(resolve37, delayMs));
           conversationBusyRetries = 0;
           continue;
         }
@@ -497413,7 +497977,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve36) => setTimeout(resolve36, delayMs));
+          await new Promise((resolve37) => setTimeout(resolve37, delayMs));
           currentInput = refreshInputOtidsForNewRequest(currentInput);
           continue;
         }
@@ -497505,7 +498069,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Empty LLM response, retrying (attempt ${attempt} of ${EMPTY_RESPONSE_MAX_RETRIES2})...`);
             }
-            await new Promise((resolve36) => setTimeout(resolve36, delayMs));
+            await new Promise((resolve37) => setTimeout(resolve37, delayMs));
             currentInput = refreshInputOtidsForNewRequest(currentInput);
             continue;
           }
@@ -497533,7 +498097,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve36) => setTimeout(resolve36, delayMs));
+            await new Promise((resolve37) => setTimeout(resolve37, delayMs));
             currentInput = refreshInputOtidsForNewRequest(currentInput);
             continue;
           }
@@ -497563,7 +498127,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve36) => setTimeout(resolve36, delayMs));
+            await new Promise((resolve37) => setTimeout(resolve37, delayMs));
             currentInput = refreshInputOtidsForNewRequest(currentInput);
             continue;
           }
@@ -497572,7 +498136,7 @@ ${loadedContents.join(`
       markIncompleteToolsAsCancelled(buffers, true, "stream_error");
       const errorLines = toLines(buffers).filter((line) => line.kind === "error");
       const errorMessages2 = errorLines.map((line) => ("text" in line) ? line.text : "").filter(Boolean);
-      let errorMessage2 = errorMessages2.length > 0 ? errorMessages2.join("; ") : fallbackError || `Unexpected stop reason: ${stopReason}`;
+      let errorMessage3 = errorMessages2.length > 0 ? errorMessages2.join("; ") : fallbackError || `Unexpected stop reason: ${stopReason}`;
       let finalRun = null;
       if (lastRunId) {
         try {
@@ -497585,10 +498149,10 @@ ${loadedContents.join(`
                 run_id: lastRunId
               }
             };
-            errorMessage2 = formatErrorDetails2(errorObject, agent2.id);
+            errorMessage3 = formatErrorDetails2(errorObject, agent2.id);
           }
         } catch (_e) {
-          errorMessage2 = `${errorMessage2}
+          errorMessage3 = `${errorMessage3}
 (Unable to fetch additional error details from server)`;
         }
       }
@@ -497597,11 +498161,11 @@ ${loadedContents.join(`
           await backend3.cancelRun(finalRun.agent_id || agent2.id, lastRunId);
         } catch {}
       }
-      trackHeadlessBoundaryError("headless_turn_failed", errorMessage2, "headless_turn_execution");
+      trackHeadlessBoundaryError("headless_turn_failed", errorMessage3, "headless_turn_execution");
       if (outputFormat === "stream-json") {
         const errorMsg = {
           type: "error",
-          message: errorMessage2,
+          message: errorMessage3,
           stop_reason: stopReason,
           run_id: lastRunId ?? undefined,
           session_id: sessionId,
@@ -497609,7 +498173,7 @@ ${loadedContents.join(`
         };
         await writeWireMessageAsync(errorMsg);
       } else {
-        console.error(`Error: ${errorMessage2}`);
+        console.error(`Error: ${errorMessage3}`);
       }
       await exitHeadless(1, "headless_stop_reason_error");
     }
@@ -497958,9 +498522,9 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
     const syntheticUserLine = serializeQueuedMessageAsUserLine(queuedMessage);
     maybeNotifyBlocked(syntheticUserLine);
     if (lineResolver) {
-      const resolve36 = lineResolver;
+      const resolve37 = lineResolver;
       lineResolver = null;
-      resolve36(syntheticUserLine);
+      resolve37(syntheticUserLine);
       return;
     }
     lineQueue.push(syntheticUserLine);
@@ -497980,9 +498544,9 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
       if (action3 === "abort-active") {
         currentAbortController.abort();
         if (lineResolver) {
-          const resolve36 = lineResolver;
+          const resolve37 = lineResolver;
           lineResolver = null;
-          resolve36(null);
+          resolve37(null);
         }
       } else if (action3 === "latch") {
         pendingInterrupt = true;
@@ -498002,9 +498566,9 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
     if (lineResolver) {
       if (parsedLine?.type === "user")
         turnStarting = true;
-      const resolve36 = lineResolver;
+      const resolve37 = lineResolver;
       lineResolver = null;
-      resolve36(line);
+      resolve37(line);
     } else {
       lineQueue.push(line);
     }
@@ -498013,17 +498577,17 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
     setMessageQueueAdder(null);
     msgQueueRuntime.clear("shutdown");
     if (lineResolver) {
-      const resolve36 = lineResolver;
+      const resolve37 = lineResolver;
       lineResolver = null;
-      resolve36(null);
+      resolve37(null);
     }
   });
   async function getNextLine() {
     if (lineQueue.length > 0) {
       return lineQueue.shift() ?? null;
     }
-    return new Promise((resolve36) => {
-      lineResolver = resolve36;
+    return new Promise((resolve37) => {
+      lineResolver = resolve37;
     });
   }
   async function requestPermission(toolCallId, toolName, toolInput) {
@@ -498085,9 +498649,9 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
     }
     return result;
   }
-  async function recoverPendingApprovalsFromControlRequest(request) {
-    const targetAgentId = request.agent_id ?? agent2.id;
-    const targetConversationId = request.conversation_id ?? conversationId;
+  async function recoverPendingApprovalsFromControlRequest(request2) {
+    const targetAgentId = request2.agent_id ?? agent2.id;
+    const targetConversationId = request2.conversation_id ?? conversationId;
     if (targetAgentId !== agent2.id) {
       throw new Error(`recover_pending_approvals agent mismatch: ${targetAgentId} != ${agent2.id}`);
     }
@@ -498544,7 +499108,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
                 uuid: `retry-bidir-${randomUUID34()}`
               };
               writeWireMessage(retryMsg);
-              await new Promise((resolve36) => setTimeout(resolve36, delayMs));
+              await new Promise((resolve37) => setTimeout(resolve37, delayMs));
               continue;
             }
             throw preStreamError;
@@ -499255,7 +499819,7 @@ var BYTES_PER_TOKEN = 4;
 
 // src/cli/helpers/window-title-config.ts
 import { homedir as homedir44 } from "node:os";
-import { basename as basename31, resolve as resolve36 } from "node:path";
+import { basename as basename32, resolve as resolve37 } from "node:path";
 function isWindowTitleField(value) {
   return WINDOW_TITLE_FIELDS.includes(value);
 }
@@ -499413,8 +499977,8 @@ function terminalTitleProjectName(data) {
   const directory = titleDirectory(data);
   if (!directory)
     return null;
-  const resolved = resolve36(directory);
-  const name = basename31(resolved) || formatDirectoryDisplay(resolved) || resolved;
+  const resolved = resolve37(directory);
+  const name = basename32(resolved) || formatDirectoryDisplay(resolved) || resolved;
   return truncateTerminalTitlePart(name, 24);
 }
 function titleDirectory(data) {
@@ -499423,7 +499987,7 @@ function titleDirectory(data) {
 function formatDirectoryDisplay(directory) {
   if (!directory)
     return null;
-  const resolved = resolve36(directory);
+  const resolved = resolve37(directory);
   const home = homedir44();
   if (resolved === home)
     return "~";
@@ -500137,7 +500701,7 @@ var init_queued_message_parts = __esm(() => {
 // src/cli/helpers/reflection-arena-hf-upload.ts
 import { execFile as execFileCb5 } from "node:child_process";
 import { existsSync as existsSync63 } from "node:fs";
-import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir18, writeFile as writeFile20 } from "node:fs/promises";
+import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir18, writeFile as writeFile21 } from "node:fs/promises";
 import { homedir as homedir45 } from "node:os";
 import { join as join81 } from "node:path";
 import { promisify as promisify15 } from "node:util";
@@ -500176,7 +500740,7 @@ async function runGit6(cwd2, args, env5) {
 }
 async function writeGitAskpass(repoRoot) {
   const askpassPath = join81(repoRoot, "hf-askpass.sh");
-  await writeFile20(askpassPath, [
+  await writeFile21(askpassPath, [
     "#!/bin/sh",
     'case "$1" in',
     "  *Username*) printf '%s\\n' 'hf_user' ;;",
@@ -500261,7 +500825,7 @@ var init_reflection_arena_hf_upload = __esm(() => {
 // src/cli/helpers/reflection-arena.ts
 import { execFile as execFileCb6 } from "node:child_process";
 import { randomInt as randomInt2, randomUUID as randomUUID35 } from "node:crypto";
-import { appendFile as appendFile3, mkdir as mkdir19, readFile as readFile30, writeFile as writeFile21 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir19, readFile as readFile31, writeFile as writeFile22 } from "node:fs/promises";
 import { homedir as homedir46 } from "node:os";
 import { join as join82 } from "node:path";
 import { promisify as promisify16 } from "node:util";
@@ -500325,11 +500889,11 @@ function getReflectionArenaRunPath(runId) {
 }
 async function saveReflectionArenaRun(run) {
   await mkdir19(getReflectionArenaRunsDir(), { recursive: true });
-  await writeFile21(getReflectionArenaRunPath(run.runId), `${JSON.stringify(run, null, 2)}
+  await writeFile22(getReflectionArenaRunPath(run.runId), `${JSON.stringify(run, null, 2)}
 `, "utf-8");
 }
 async function loadReflectionArenaRun(runId) {
-  const raw2 = await readFile30(getReflectionArenaRunPath(runId), "utf-8");
+  const raw2 = await readFile31(getReflectionArenaRunPath(runId), "utf-8");
   return JSON.parse(raw2);
 }
 async function updateReflectionArenaRun(runId, update2) {
@@ -500521,7 +501085,7 @@ async function appendChoiceRecord(run) {
 }
 async function readTranscriptPayloadForTelemetry(payloadPath) {
   try {
-    const transcript = await readFile30(payloadPath, "utf-8");
+    const transcript = await readFile31(payloadPath, "utf-8");
     return {
       transcriptPayload: transcript.slice(0, REFLECTION_ARENA_TELEMETRY_TRANSCRIPT_MAX_CHARS),
       transcriptPayloadChars: transcript.length,
@@ -500787,6 +501351,7 @@ async function finalizeReflectionArenaChoice(options3) {
   }
   const discarded = [];
   let integration;
+  let completionSuccess = false;
   let memoryBaseCommit = null;
   let memoryCandidateCommit = null;
   if (options3.choice !== "tie") {
@@ -500813,6 +501378,7 @@ async function finalizeReflectionArenaChoice(options3) {
       logRecompileFailure: (message) => debugWarn("memory", message)
     });
     integration = finalized.integration;
+    completionSuccess = finalized.completionSuccess;
   }
   for (const candidate of run.candidates) {
     if (options3.choice !== "tie" && candidate.label === options3.choice) {
@@ -500824,7 +501390,7 @@ async function finalizeReflectionArenaChoice(options3) {
       knownNoChanges: candidateIsConfirmedNoOp(candidate)
     });
   }
-  await finalizeAutoReflectionPayload(run.agentId, run.conversationId, run.payloadPath, run.endSnapshotLine, integration ? reflectionIntegrationConsumesTranscript(integration) : false);
+  await finalizeAutoReflectionCompletion(run.agentId, run.conversationId, run.payloadPath, run.endSnapshotLine, run.endMessageId, completionSuccess);
   const completedRun = {
     ...run,
     choice: {
@@ -500865,6 +501431,7 @@ var init_reflection_arena = __esm(() => {
   init_memory_worktree();
   init_app_urls();
   init_reflection_arena_hf_upload();
+  init_reflection_completion();
   init_reflection_launcher();
   init_reflection_transcript();
   init_telemetry();
@@ -501168,8 +501735,8 @@ async function pushToMemoryRepositoryWithTimeout(agentId) {
   try {
     return await Promise.race([
       pushToMemoryRepository(agentId),
-      new Promise((resolve37) => {
-        timeout = setTimeout(() => resolve37("timeout"), INITIAL_PUSH_TIMEOUT_MS);
+      new Promise((resolve38) => {
+        timeout = setTimeout(() => resolve38("timeout"), INITIAL_PUSH_TIMEOUT_MS);
       })
     ]);
   } finally {
@@ -507483,11 +508050,11 @@ var init_HelpDialog = __esm(async () => {
 
 // src/hooks/writer.ts
 import { homedir as homedir49 } from "node:os";
-import { resolve as resolve37 } from "node:path";
+import { resolve as resolve38 } from "node:path";
 function isProjectSettingsPathCollidingWithGlobal2(workingDirectory) {
   const home = process.env.HOME || homedir49();
-  const globalSettingsPath = resolve37(home, ".letta", "settings.json");
-  const projectSettingsPath = resolve37(workingDirectory, ".letta", "settings.json");
+  const globalSettingsPath = resolve38(home, ".letta", "settings.json");
+  const projectSettingsPath = resolve38(workingDirectory, ".letta", "settings.json");
   return globalSettingsPath === projectSettingsPath;
 }
 function loadHooksFromLocation(location, workingDirectory = process.cwd()) {
@@ -513781,7 +514348,7 @@ var init_InstallGithubAppFlow = __esm(async () => {
     const solidLine = SOLID_LINE11.repeat(Math.max(terminalWidth, 10));
     const [step, setStep] = import_react84.useState("checking");
     const [status, setStatus] = import_react84.useState("Checking GitHub CLI prerequisites...");
-    const [errorMessage2, setErrorMessage] = import_react84.useState("");
+    const [errorMessage3, setErrorMessage] = import_react84.useState("");
     const [currentRepo, setCurrentRepo] = import_react84.useState(null);
     const [repoChoiceIndex, setRepoChoiceIndex] = import_react84.useState(0);
     const [repoInput, setRepoInput] = import_react84.useState("");
@@ -514349,14 +514916,14 @@ var init_InstallGithubAppFlow = __esm(async () => {
           color: "red",
           children: [
             "Error: ",
-            errorMessage2.split(`
+            errorMessage3.split(`
 `)[0] || "Unknown error"
           ]
         }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime62.jsxDEV(Box_default, {
           height: 1
         }, undefined, false, undefined, this),
-        errorMessage2.split(`
+        errorMessage3.split(`
 `).slice(1).filter((line) => line.trim().length > 0).map((line, idx) => /* @__PURE__ */ jsx_dev_runtime62.jsxDEV(Text2, {
           dimColor: true,
           children: line
@@ -518766,14 +519333,14 @@ function MessageSearch({
       resultsCache.current.set(cacheKey, emptyResults);
       return emptyResults;
     }
-    const request = fetchSearchResults(query2, mode, range3).then((searchResults) => {
+    const request2 = fetchSearchResults(query2, mode, range3).then((searchResults) => {
       resultsCache.current.set(cacheKey, searchResults);
       return searchResults;
     }).finally(() => {
       pendingResultsCache.current.delete(cacheKey);
     });
-    pendingResultsCache.current.set(cacheKey, request);
-    return request;
+    pendingResultsCache.current.set(cacheKey, request2);
+    return request2;
   }, [agentId, conversationId, fetchSearchResults, getCacheKey]);
   const prefetchSearchResults = import_react89.useCallback((query2, mode, range3) => {
     const { prefetch } = buildSearchTargetPlan(mode, range3, {
@@ -520170,7 +520737,7 @@ var init_PersonalitySelector = __esm(async () => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile31 } from "node:fs/promises";
+import { readFile as readFile32 } from "node:fs/promises";
 import { homedir as homedir51 } from "node:os";
 import { join as join88 } from "node:path";
 async function parseAwsCredentials() {
@@ -520178,11 +520745,11 @@ async function parseAwsCredentials() {
   const configPath = join88(homedir51(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile31(credentialsPath, "utf-8");
+    const content = await readFile32(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile31(configPath, "utf-8");
+    const content = await readFile32(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -524344,7 +524911,7 @@ var init_ToolCallMessageRich = __esm(async () => {
       let shellSemanticKind = null;
       let hasShellDescription = false;
       if (!isQuestionTool(rawName)) {
-        const parseArgs18 = () => {
+        const parseArgs19 = () => {
           if (!argsText.trim()) {
             return { formatted: null, parseable: true };
           }
@@ -524358,7 +524925,7 @@ var init_ToolCallMessageRich = __esm(async () => {
             return { formatted: null, parseable: false };
           }
         };
-        const { formatted, parseable } = parseArgs18();
+        const { formatted, parseable } = parseArgs19();
         const argsComplete = parseable || line.phase === "running" || line.phase === "finished" || !isStreaming;
         if (!argsComplete) {
           args = "(…)";
@@ -526574,7 +527141,7 @@ function updateCommandResult(buffersRef, refreshDerived, cmdId, input, output, s
   buffersRef.current.byId.set(cmdId, line);
   refreshDerived();
 }
-function parseArgs18(msg) {
+function parseArgs19(msg) {
   return msg.trim().split(/\s+/).filter(Boolean);
 }
 function formatConnectUsage() {
@@ -526930,7 +527497,7 @@ ${formatBedrockUsage2()}`, false);
   }
 }
 async function handleConnect(ctx, msg) {
-  const parts = parseArgs18(msg);
+  const parts = parseArgs19(msg);
   const providerToken = parts[1];
   if (!providerToken) {
     addCommandResult(ctx.buffersRef, ctx.refreshDerived, msg, formatConnectUsage(), false);
@@ -536772,13 +537339,13 @@ var init_cleanLastNewline = () => {};
 function processLine(node, line, state) {
   const lineInfo = typeof state.lineInfo === "function" ? state.lineInfo(line) : state.lineInfo[line - 1];
   if (lineInfo == null) {
-    const errorMessage2 = `processLine: line ${line}, contains no state.lineInfo`;
-    console.error(errorMessage2, {
+    const errorMessage3 = `processLine: line ${line}, contains no state.lineInfo`;
+    console.error(errorMessage3, {
       node,
       line,
       state
     });
-    throw new Error(errorMessage2);
+    throw new Error(errorMessage3);
   }
   node.tagName = "div";
   node.properties["data-line"] = lineInfo.lineNumber;
@@ -540250,9 +540817,9 @@ var instanceId = -1, DiffHunksRenderer = class {
           let deletionLineContent = deletionLine != null ? deletionLines[deletionLine.lineIndex] : undefined;
           let additionLineContent = additionLine != null ? additionLines[additionLine.lineIndex] : undefined;
           if (deletionLineContent == null && additionLineContent == null) {
-            const errorMessage2 = "DiffHunksRenderer.processDiffResult: deletionLine and additionLine are null, something is wrong";
-            console.error(errorMessage2, { file: fileDiff.name });
-            throw new Error(errorMessage2);
+            const errorMessage3 = "DiffHunksRenderer.processDiffResult: deletionLine and additionLine are null, something is wrong";
+            console.error(errorMessage3, { file: fileDiff.name });
+            throw new Error(errorMessage3);
           }
           const lineType = type3 === "change" ? additionLine != null ? "change-addition" : "change-deletion" : type3;
           const lineDecoration = this.getUnifiedLineDecoration({
@@ -540294,9 +540861,9 @@ var instanceId = -1, DiffHunksRenderer = class {
             lineIndex: additionLine?.lineIndex
           });
           if (deletionLineContent == null && additionLineContent == null) {
-            const errorMessage2 = "DiffHunksRenderer.processDiffResult: deletionLine and additionLine are null, something is wrong";
-            console.error(errorMessage2, { file: fileDiff.name });
-            throw new Error(errorMessage2);
+            const errorMessage3 = "DiffHunksRenderer.processDiffResult: deletionLine and additionLine are null, something is wrong";
+            console.error(errorMessage3, { file: fileDiff.name });
+            throw new Error(errorMessage3);
           }
           const missingSide = (() => {
             if (type3 === "change") {
@@ -541289,7 +541856,7 @@ __export(exports_generate_diff_viewer, {
 import { execFile as execFileCb8 } from "node:child_process";
 import { chmodSync as chmodSync8, existsSync as existsSync68, mkdirSync as mkdirSync48, writeFileSync as writeFileSync38 } from "node:fs";
 import { homedir as homedir52 } from "node:os";
-import { isAbsolute as isAbsolute29, join as join89, resolve as resolve38 } from "node:path";
+import { isAbsolute as isAbsolute29, join as join89, resolve as resolve39 } from "node:path";
 import { promisify as promisify18 } from "node:util";
 async function runGit8(cwd2, args) {
   try {
@@ -541487,7 +542054,7 @@ function escapeHtml3(value) {
 function resolveTargetPath(targetPath) {
   if (!targetPath?.trim())
     return process.cwd();
-  return isAbsolute29(targetPath) ? targetPath : resolve38(process.cwd(), targetPath);
+  return isAbsolute29(targetPath) ? targetPath : resolve39(process.cwd(), targetPath);
 }
 function shouldSkipOpen() {
   return Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -544771,7 +545338,7 @@ var init_system_reminders = __esm(() => {
 // src/cli/app/use-conversation-loop.ts
 import { randomUUID as randomUUID38 } from "node:crypto";
 function sleep10(ms) {
-  return new Promise((resolve39) => setTimeout(resolve39, ms));
+  return new Promise((resolve40) => setTimeout(resolve40, ms));
 }
 function makeExecutionPhaseHook(setExecutionPhase) {
   return ({ chunk }) => {
@@ -545222,7 +545789,7 @@ function useConversationLoop(ctx) {
                   cancelled = true;
                   break;
                 }
-                await new Promise((resolve39) => setTimeout(resolve39, 100));
+                await new Promise((resolve40) => setTimeout(resolve40, 100));
               }
               buffersRef.current.byId.delete(statusId);
               buffersRef.current.order = buffersRef.current.order.filter((id2) => id2 !== statusId);
@@ -545286,7 +545853,7 @@ function useConversationLoop(ctx) {
                 cancelled = true;
                 break;
               }
-              await new Promise((resolve39) => setTimeout(resolve39, 100));
+              await new Promise((resolve40) => setTimeout(resolve40, 100));
             }
             if (retryStatusId) {
               buffersRef.current.byId.delete(retryStatusId);
@@ -546080,7 +546647,7 @@ ${feedback}
           });
           buffersRef.current.order.push(statusId);
           refreshDerived();
-          await new Promise((resolve39) => setTimeout(resolve39, delayMs));
+          await new Promise((resolve40) => setTimeout(resolve40, delayMs));
           buffersRef.current.byId.delete(statusId);
           buffersRef.current.order = buffersRef.current.order.filter((id2) => id2 !== statusId);
           refreshDerived();
@@ -546140,7 +546707,7 @@ ${feedback}
               cancelled = true;
               break;
             }
-            await new Promise((resolve39) => setTimeout(resolve39, 100));
+            await new Promise((resolve40) => setTimeout(resolve40, 100));
           }
           if (retryStatusId) {
             buffersRef.current.byId.delete(retryStatusId);
@@ -547876,7 +548443,7 @@ The deployment target for this project is CITATION-DOGFOOD-OK.
 
 // src/mods/learning-harness.ts
 import { spawn as spawn13 } from "node:child_process";
-import { access as access3, copyFile as copyFile2, mkdir as mkdir20, readFile as readFile32, writeFile as writeFile22 } from "node:fs/promises";
+import { access as access3, copyFile as copyFile2, mkdir as mkdir20, readFile as readFile33, writeFile as writeFile23 } from "node:fs/promises";
 import path47 from "node:path";
 function slugify2(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -548124,14 +548691,14 @@ async function existingPath(filePath) {
   return await fileExists(filePath) ? filePath : undefined;
 }
 async function writeJsonArtifact(filePath, value) {
-  await writeFile22(filePath, `${JSON.stringify(value, null, 2)}
+  await writeFile23(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function writeCommandArtifacts(prefix, command, args, result) {
-  await writeFile22(`${prefix}.command.txt`, `${renderCommand(command, args)}
+  await writeFile23(`${prefix}.command.txt`, `${renderCommand(command, args)}
 `, "utf8");
-  await writeFile22(`${prefix}.stdout`, result.stdout, "utf8");
-  await writeFile22(`${prefix}.stderr`, result.stderr, "utf8");
+  await writeFile23(`${prefix}.stdout`, result.stdout, "utf8");
+  await writeFile23(`${prefix}.stderr`, result.stderr, "utf8");
   await writeJsonArtifact(`${prefix}.result.json`, result);
 }
 async function prepareMemoryFiles(memoryDir, memoryFiles) {
@@ -548139,7 +548706,7 @@ async function prepareMemoryFiles(memoryDir, memoryFiles) {
   for (const [relativePath, content] of Object.entries(memoryFiles ?? {})) {
     const filePath = safeJoin(memoryDir, relativePath);
     await mkdir20(path47.dirname(filePath), { recursive: true });
-    await writeFile22(filePath, content, "utf8");
+    await writeFile23(filePath, content, "utf8");
   }
 }
 function renderEvaluationPrompt(prompt, memoryDir) {
@@ -548802,7 +549369,7 @@ function renderProposerGuide(params) {
 `;
 }
 async function writeHistoryArtifacts(params) {
-  await writeFile22(params.historyPath, renderHistoryIndex({
+  await writeFile23(params.historyPath, renderHistoryIndex({
     attempts: params.attempts,
     historyManifestPath: params.historyManifestPath,
     proposerGuidePath: params.proposerGuidePath,
@@ -548810,11 +549377,11 @@ async function writeHistoryArtifacts(params) {
     spec: params.spec
   }), "utf8");
   await writeJsonArtifact(params.historyManifestPath, buildHistoryManifest(params));
-  await writeFile22(params.proposerGuidePath, renderProposerGuide(params), "utf8");
+  await writeFile23(params.proposerGuidePath, renderProposerGuide(params), "utf8");
 }
 async function defaultCommandRunner(command, args, options3) {
   const startedAt = Date.now();
-  return new Promise((resolve39) => {
+  return new Promise((resolve40) => {
     const child = spawn13(command, args, {
       cwd: options3.cwd,
       env: options3.env,
@@ -548841,7 +549408,7 @@ async function defaultCommandRunner(command, args, options3) {
     });
     child.on("close", (exitCode) => {
       clearTimeout(timeout);
-      resolve39({
+      resolve40({
         args,
         command,
         cwd: options3.cwd,
@@ -548901,7 +549468,7 @@ function createScenarioSuiteEvaluator(params) {
               outputFormat
             })
           ];
-          await writeFile22(hasConfiguredScenarios ? path47.join(scenarioDir, "prompt.md") : path47.join(context3.runDir, "eval-prompt.md"), evalPrompt, "utf8");
+          await writeFile23(hasConfiguredScenarios ? path47.join(scenarioDir, "prompt.md") : path47.join(context3.runDir, "eval-prompt.md"), evalPrompt, "utf8");
           const scenarioEvalResult = await context3.runner(context3.cliCommand, evalArgs, {
             cwd: context3.repoRoot,
             env: {
@@ -549093,7 +549660,7 @@ async function runModLearningCandidate(params) {
         outputFormat: "json"
       })
     ];
-    await writeFile22(path47.join(runDir, "generation-prompt.md"), generationPrompt, "utf8");
+    await writeFile23(path47.join(runDir, "generation-prompt.md"), generationPrompt, "utf8");
     generationResult = await params.runner(params.cliCommand, generationArgs, {
       cwd: repoRoot,
       env: {
@@ -549172,7 +549739,7 @@ async function runModLearningCandidate(params) {
     spec: options3.spec
   };
   await writeJsonArtifact(path47.join(runDir, "report.json"), report);
-  await writeFile22(reportPath, renderMarkdownReport(report), "utf8");
+  await writeFile23(reportPath, renderMarkdownReport(report), "utf8");
   await writeCandidateManifest(report);
   emitProgress("done", params.candidateCount > 1 ? `Optimization iteration ${params.candidateIndex}/${params.candidateCount} complete` : "mod optimization complete", {
     attempts: [...params.previousAttempts, summarizeAttempt(report)],
@@ -549350,7 +549917,7 @@ async function runModLearning(options3) {
     spec: normalizedOptions.spec
   });
   await writeJsonArtifact(path47.join(runDir, "report.json"), report);
-  await writeFile22(reportPath, renderMarkdownReport(report), "utf8");
+  await writeFile23(reportPath, renderMarkdownReport(report), "utf8");
   normalizedOptions.onProgress?.({
     candidateCount,
     candidateIndex: selectedCandidateIndex,
@@ -549368,7 +549935,7 @@ async function runModLearning(options3) {
   return report;
 }
 async function readModLearningEnv(envPath) {
-  return JSON.parse(await readFile32(envPath, "utf8"));
+  return JSON.parse(await readFile33(envPath, "utf8"));
 }
 var init_learning_harness = __esm(async () => {
   await init_mod_engine();
@@ -549936,7 +550503,7 @@ var init_mods2 = __esm(async () => {
 });
 
 // src/cli/helpers/chdir-command.ts
-import { realpath as realpath5, stat as stat17 } from "node:fs/promises";
+import { realpath as realpath5, stat as stat18 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
 import path49 from "node:path";
 function parseChdirCommand(input) {
@@ -549975,7 +550542,7 @@ async function resolveChdirTarget(pathArg, currentWorkingDirectory) {
   const expanded = expandHome(pathArg);
   const resolved = path49.isAbsolute(expanded) ? expanded : path49.resolve(currentWorkingDirectory, expanded);
   const normalized = await realpath5(resolved);
-  const stats = await stat17(normalized);
+  const stats = await stat18(normalized);
   if (!stats.isDirectory()) {
     throw new Error(`Not a directory: ${normalized}`);
   }
@@ -551619,7 +552186,7 @@ __export(exports_worktree_diff_list, {
   listWorktreeDiffOptions: () => listWorktreeDiffOptions
 });
 import { execFile as execFileCb9 } from "node:child_process";
-import { basename as basename32 } from "node:path";
+import { basename as basename33 } from "node:path";
 import { promisify as promisify19 } from "node:util";
 async function runGit9(cwd2, args) {
   try {
@@ -551668,7 +552235,7 @@ function parseWorktreeList(output, currentPath) {
       if (current?.path) {
         worktrees.push({
           path: current.path,
-          name: basename32(current.path),
+          name: basename33(current.path),
           branch: current.branch ?? "detached",
           head: current.head ?? "",
           isCurrent: current.path === currentPath,
@@ -551694,7 +552261,7 @@ function parseWorktreeList(output, currentPath) {
   if (current?.path) {
     worktrees.push({
       path: current.path,
-      name: basename32(current.path),
+      name: basename33(current.path),
       branch: current.branch ?? "detached",
       head: current.head ?? "",
       isCurrent: current.path === currentPath,
@@ -551763,15 +552330,15 @@ var exports_export = {};
 __export(exports_export, {
   packageSkills: () => packageSkills
 });
-import { readdir as readdir17, readFile as readFile33 } from "node:fs/promises";
-import { relative as relative17, resolve as resolve39 } from "node:path";
+import { readdir as readdir17, readFile as readFile34 } from "node:fs/promises";
+import { relative as relative17, resolve as resolve40 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
   const skillNames = new Set;
   const dirsToCheck = skillsDir ? [skillsDir] : [
     agentId && getAgentSkillsDir(agentId),
-    resolve39(process.cwd(), ".skills"),
-    resolve39(process.env.HOME || "~", ".letta", "skills")
+    resolve40(process.cwd(), ".skills"),
+    resolve40(process.env.HOME || "~", ".letta", "skills")
   ].filter((dir) => Boolean(dir));
   for (const baseDir of dirsToCheck) {
     try {
@@ -551781,10 +552348,10 @@ async function packageSkills(agentId, skillsDir) {
           continue;
         if (skillNames.has(entry.name))
           continue;
-        const skillDir = resolve39(baseDir, entry.name);
-        const skillMdPath = resolve39(skillDir, "SKILL.md");
+        const skillDir = resolve40(baseDir, entry.name);
+        const skillMdPath = resolve40(skillDir, "SKILL.md");
         try {
-          await readFile33(skillMdPath, "utf-8");
+          await readFile34(skillMdPath, "utf-8");
         } catch {
           console.warn(`Skipping invalid skill ${entry.name}: missing SKILL.md`);
           continue;
@@ -551812,11 +552379,11 @@ async function readSkillFiles(skillDir) {
   async function walk(dir) {
     const entries = await readdir17(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = resolve39(dir, entry.name);
+      const fullPath = resolve40(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        const content = await readFile33(fullPath, "utf-8");
+        const content = await readFile34(fullPath, "utf-8");
         const relativePath = relative17(skillDir, fullPath).replace(/\\/g, "/");
         files[relativePath] = content;
       }
@@ -552470,7 +553037,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
             agentId,
             allowDisabledModelInvocation: true
           });
-          const request = args ? `The user ran \`/mods generate-env ${args}\`. Use the loaded skill to help them generate, review, validate, or improve a mod learning env JSON.` : "The user ran `/mods generate-env` without arguments. Use the loaded skill's bare behavior for mod learning env generation.";
+          const request2 = args ? `The user ran \`/mods generate-env ${args}\`. Use the loaded skill to help them generate, review, validate, or improve a mod learning env JSON.` : "The user ran `/mods generate-env` without arguments. Use the loaded skill's bare behavior for mod learning env generation.";
           cmd.finish("Running mod env generation...", true);
           await processConversationWithQueuedApprovals([
             {
@@ -552479,7 +553046,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
               content: buildTextParts(`${wrapSkillContent2("generating-mod-envs", skillContent)}
 
 ${SYSTEM_REMINDER_OPEN}
-${request}
+${request2}
 ${SYSTEM_REMINDER_CLOSE}`),
               otid: randomUUID40()
             }
@@ -552739,7 +553306,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
             agentId,
             allowDisabledModelInvocation: true
           });
-          const request = args ? `The user ran \`/statusline ${args}\`. Use the loaded skill to help them create, edit, or migrate their Letta Code statusline mod.` : "The user ran `/statusline` without arguments. Use the loaded skill's bare `/statusline` behavior.";
+          const request2 = args ? `The user ran \`/statusline ${args}\`. Use the loaded skill to help them create, edit, or migrate their Letta Code statusline mod.` : "The user ran `/statusline` without arguments. Use the loaded skill's bare `/statusline` behavior.";
           cmd.finish("Running statusline setup...", true);
           await processConversationWithQueuedApprovals([
             {
@@ -552748,7 +553315,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
               content: buildTextParts(`${wrapSkillContent2("customizing-statusline", skillContent)}
 
 ${SYSTEM_REMINDER_OPEN}
-${request}
+${request2}
 ${SYSTEM_REMINDER_CLOSE}`),
               otid: randomUUID40()
             }
@@ -553907,7 +554474,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                           recompileQueuedByConversation: queuedSystemPromptRecompileByConversationRef.current,
                           logRecompileFailure: (message2) => debugWarn("memory", message2)
                         });
-                        await finalizeMultiReflectionPayload(agentId, autoReflectionPayload.manifest, completionSuccess);
+                        await finalizeMultiReflectionCompletion(agentId, autoReflectionPayload.manifest, completionSuccess);
                         appendTaskNotificationEvents([completionMessage]);
                       } finally {
                         releaseReflectionReservation();
@@ -554002,7 +554569,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                   recompileQueuedByConversation: queuedSystemPromptRecompileByConversationRef.current,
                   logRecompileFailure: (message2) => debugWarn("memory", message2)
                 });
-                await finalizeMultiReflectionPayload(agentId, reflectionPayload.manifest, completionSuccess);
+                await finalizeMultiReflectionCompletion(agentId, reflectionPayload.manifest, completionSuccess);
                 appendTaskNotificationEvents([completionMessage]);
               } finally {
                 releaseReflectionReservation();
@@ -554452,6 +555019,7 @@ var init_use_submit_handler = __esm(async () => {
   init_paste_registry();
   init_reasoning_tab_toggle();
   init_reflection_arena();
+  init_reflection_completion();
   init_reflection_launcher();
   init_reflection_transcript();
   init_skill_name_frontmatter_repair();
@@ -558056,13 +558624,13 @@ USAGE
   # maintenance
   letta update          Manually check for updates and install if available
   letta upgrade         Alias for \`letta update\`
-  letta --update        Alias for \`letta update\`
-  letta --upgrade       Alias for \`letta update\`
+  letta --update/--upgrade Aliases for \`letta update\`
   letta memory ...      Memory filesystem subcommands
   letta agents ...      Agents subcommands (JSON-only)
   letta environments ... List available remote environments (JSON-only)
   letta messages ...    Messages subcommands (JSON-only)
   letta mods ...        List and manage local mods
+  letta sandbox ...     Transfer files to or from the current Cloud sandbox
   letta server ...      Run a remote environment, channels, or the App Server
   letta connect ...     Connect providers from terminal
   letta backend ...     Show or set the default backend
@@ -558647,9 +559215,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
         process.exit(1);
       }
     } else {
-      const { resolve: resolve40 } = await import("node:path");
+      const { resolve: resolve41 } = await import("node:path");
       const { existsSync: existsSync71 } = await import("node:fs");
-      const resolvedPath = resolve40(fromAfFile);
+      const resolvedPath = resolve41(fromAfFile);
       if (!existsSync71(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
@@ -561773,4 +562341,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=EFFF93D118B173E664756E2164756E21
+//# debugId=447A31644C59E2F264756E2164756E21