@letta-ai/letta-code 0.32.6 → 0.32.8

package/letta.js

@@ -5515,7 +5515,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.32.6",
+    version: "0.32.8",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -101183,7 +101183,7 @@ function cancelWorktreeWatcherIdleStop(listener, agentId, conversationId) {
   }
 }
 function evictConversationRuntimeIfIdle(runtime) {
-  if (runtime.turnLifecycle.kind !== "idle" || runtime.queuePumpActive || runtime.queuePumpScheduled || runtime.pendingTurns > 0 || runtime.pendingApprovalResolvers.size > 0 || runtime.pendingApprovalBatchByToolCallId.size > 0 || runtime.recoveredApprovalState !== null || runtime.pendingInterruptedResults !== null || runtime.pendingInterruptedContext !== null || (runtime.pendingInterruptedToolCallIds?.length ?? 0) > 0 || runtime.queuedMessagesByItemId.size > 0 || runtime.queueRuntime?.length > 0 || (runtime.workspaceSandbox !== undefined || runtime.executionSettings !== undefined) && runtime.listener.connectionIdsByRuntimeKey.has(runtime.key)) {
+  if (runtime.turnLifecycle.kind !== "idle" || runtime.expectedTeleportId !== null && (runtime.expectedTeleportExpiresAt === null || runtime.expectedTeleportExpiresAt > Date.now()) || runtime.queuePumpActive || runtime.queuePumpScheduled || runtime.pendingTurns > 0 || runtime.pendingApprovalResolvers.size > 0 || runtime.pendingApprovalBatchByToolCallId.size > 0 || runtime.recoveredApprovalState !== null || runtime.pendingInterruptedResults !== null || runtime.pendingInterruptedContext !== null || (runtime.pendingInterruptedToolCallIds?.length ?? 0) > 0 || runtime.queuedMessagesByItemId.size > 0 || runtime.queueRuntime?.length > 0 || (runtime.workspaceSandbox !== undefined || runtime.executionSettings !== undefined) && runtime.listener.connectionIdsByRuntimeKey.has(runtime.key)) {
     return false;
   }
   if (runtime.listener.conversationRuntimes.get(runtime.key) !== runtime) {
@@ -101244,6 +101244,8 @@ function createConversationRuntime(listener, agentId, conversationId) {
     pendingApprovalResolvers: new Map,
     recoveredApprovalState: null,
     syncApprovalRecoveryCompleted: false,
+    expectedTeleportId: null,
+    expectedTeleportExpiresAt: null,
     get lastStopReason() {
       return turnLifecycle.lastStopReason;
     },
@@ -101319,6 +101321,8 @@ function clearConversationRuntimeState(runtime) {
   runtime.pendingInterruptedResults = null;
   runtime.pendingInterruptedContext = null;
   runtime.pendingInterruptedToolCallIds = null;
+  runtime.expectedTeleportId = null;
+  runtime.expectedTeleportExpiresAt = null;
   runtime.dequeuedClientMessageIdsByBatchId.clear();
   runtime.continuationEpoch += 1;
   runtime.pendingTurns = 0;
@@ -101966,7 +101970,7 @@ function consumeSubagentLaunch(env3) {
   delete env3[SUBAGENT_LAUNCH_ENV];
   return isLaunch;
 }
-var SUBAGENT_LAUNCH_ENV = "LETTA_SUBAGENT_LAUNCH", SUBAGENT_LAUNCH_PROFILE_ENV = "LETTA_SUBAGENT_LAUNCH_PROFILE", LISTENER_CONNECTION_ENV = "LETTA_RUNTIME_LISTENER_CONNECTION_ID";
+var SUBAGENT_LAUNCH_ENV = "LETTA_SUBAGENT_LAUNCH", SUBAGENT_LAUNCH_PROFILE_ENV = "LETTA_SUBAGENT_LAUNCH_PROFILE", SUBAGENT_NAME_ENV = "LETTA_SUBAGENT_NAME", LISTENER_CONNECTION_ENV = "LETTA_RUNTIME_LISTENER_CONNECTION_ID";
 
 // src/tools/impl/ripgrep-manager.ts
 import { spawnSync } from "node:child_process";
@@ -107475,42 +107479,44 @@ function emitDequeuedUserMessage(socket, runtime, incoming, batch) {
   if (batch.items.length > 0 && batch.items.every((item) => item.kind === "mod_continue")) {
     return;
   }
-  const firstUserPayload = incoming.messages.find((payload) => ("content" in payload));
-  if (!firstUserPayload)
-    return;
-  const rawContent = firstUserPayload.content;
-  let content;
-  if (typeof rawContent === "string") {
-    content = replaceCronPromptsForDisplay(rawContent, batch).replace(SYSTEM_REMINDER_RE, "").trim();
-  } else if (Array.isArray(rawContent)) {
-    content = rawContent.flatMap((part) => {
-      if (isTextContentPart(part)) {
-        const cronDisplay = getCronPromptDisplayForText(part.text, batch);
-        if (cronDisplay !== null) {
-          return [{ ...part, text: cronDisplay }];
+  for (const payload of incoming.messages) {
+    if (!("content" in payload) || payload.role !== "user")
+      continue;
+    const rawContent = payload.content;
+    let content;
+    if (typeof rawContent === "string") {
+      content = replaceCronPromptsForDisplay(rawContent, batch).replace(SYSTEM_REMINDER_RE, "").trim();
+    } else if (Array.isArray(rawContent)) {
+      content = rawContent.flatMap((part) => {
+        if (isTextContentPart(part)) {
+          const cronDisplay = getCronPromptDisplayForText(part.text, batch);
+          if (cronDisplay !== null) {
+            return [{ ...part, text: cronDisplay }];
+          }
         }
-      }
-      return isSystemReminderPart(part) ? [] : [part];
+        return isSystemReminderPart(part) ? [] : [part];
+      });
+    } else {
+      continue;
+    }
+    const hasContent = typeof content === "string" ? content.length > 0 : Array.isArray(content) && content.length > 0;
+    if (!hasContent)
+      continue;
+    payload.otid ??= payload.client_message_id ?? crypto.randomUUID();
+    const otid = payload.otid;
+    emitCanonicalMessageDelta(socket, runtime, {
+      type: "message",
+      id: `user-msg-${crypto.randomUUID()}`,
+      date: new Date().toISOString(),
+      message_type: "user_message",
+      content,
+      otid,
+      created_by_id: payload.attribution === undefined ? incoming.actingUserId : payload.attribution.acting_user_id
+    }, {
+      agent_id: incoming.agentId,
+      conversation_id: incoming.conversationId
     });
-  } else {
-    return;
   }
-  const hasContent = typeof content === "string" ? content.length > 0 : Array.isArray(content) && content.length > 0;
-  if (!hasContent)
-    return;
-  const otid = firstUserPayload.otid ?? firstUserPayload.client_message_id ?? batch.batchId;
-  emitCanonicalMessageDelta(socket, runtime, {
-    type: "message",
-    id: `user-msg-${crypto.randomUUID()}`,
-    date: new Date().toISOString(),
-    message_type: "user_message",
-    content,
-    otid,
-    created_by_id: incoming.actingUserId
-  }, {
-    agent_id: incoming.agentId,
-    conversation_id: incoming.conversationId
-  });
 }
 function emitQueueUpdateIfOpen(runtime, scope, removed = []) {
   const listener = getListenerRuntime(runtime);
@@ -122333,6 +122339,17 @@ function actingUserRequestOptions(actingUserId) {
 var ACTING_USER_ID_HEADER = "X-Letta-Acting-User-Id", ACTING_USER_ID_ENV = "LETTA_ACTING_USER_ID";
 
 // src/backend/api/agent-message.ts
+function normalizeAgentMessageComputer(value) {
+  if (value == null)
+    return;
+  if (typeof value !== "string") {
+    throw new Error("computer must be a computer name, or omitted to use the conversation's current destination.");
+  }
+  const computer = value.trim();
+  if (!computer)
+    return;
+  return ["cloud", "cloud-sandbox"].includes(computer.toLowerCase()) ? "cloud" : computer;
+}
 function buildAgentSendContent(sender, noWait, message) {
   const reminder = buildAgentSendReminder(sender, noWait);
   return [
@@ -122383,6 +122400,9 @@ async function resolveAgentMessageDestination(input, backend, signal) {
     const conversation = await backend.createConversation({ agent_id: agentId, ...input.senderAgentId ? { hidden: true } : {} }, options);
     conversationId = conversation.id;
   }
+  if (agentId === input.currentConversation?.agentId && conversationId === input.currentConversation?.conversationId) {
+    throw new Error("Cannot message the current conversation. Use a Monitor or schedule for self-invocation.");
+  }
   return { agentId, conversationId };
 }
 var init_agent_message = () => {};
@@ -122454,9 +122474,7 @@ async function send_agent_message(args, deps = {}) {
     }
     if (!args.message?.trim())
       throw new Error("Message must not be empty.");
-    if (args.computer !== undefined && !args.computer.trim()) {
-      throw new Error("Computer selector must not be empty.");
-    }
+    const computer = normalizeAgentMessageComputer(args.computer);
     const context3 = getRuntimeContext();
     const sender = {
       agentId: validateAddress(context3?.agentId ?? undefined, "agent"),
@@ -122475,16 +122493,16 @@ async function send_agent_message(args, deps = {}) {
       agentId: args.agent_id,
       conversationId: args.conversation_id,
       senderAgentId: sender.agentId,
-      actingUserId
+      actingUserId,
+      currentConversation: sender
     }, backend, signal);
     signal.throwIfAborted();
     submissionAttempted = true;
-    const computer = args.computer;
     const receipt = await (deps.enqueue ?? enqueueConversationMessage)({
       ...destination,
       clientMessageId,
       content: buildAgentSendContent(sender, true, args.message),
-      computer: computer && ["cloud", "cloud-sandbox"].includes(computer.trim().toLowerCase()) ? "cloud" : computer,
+      computer,
       actingUserId
     }, signal);
     return {
@@ -123627,6 +123645,138 @@ var init_context_budget = __esm(() => {
   REFLECTION_STARTUP_CONTEXT_CHAR_LIMIT = REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT * STARTUP_CONTEXT_ESTIMATED_CHARS_PER_TOKEN;
 });
 
+// src/agent/subagents/names.ts
+function createSubagentNameAllocator(random = Math.random) {
+  let available = [];
+  let round = 0;
+  const ordinals = new Intl.PluralRules("en", { type: "ordinal" });
+  const suffixes = { one: "st", two: "nd", few: "rd" };
+  return () => {
+    if (available.length === 0) {
+      available = [...SUBAGENT_NAMES];
+      round += 1;
+    }
+    const index = Math.floor(random() * available.length);
+    const name = available.splice(index, 1)[0];
+    const ordinal = `${round}${suffixes[ordinals.select(round)] ?? "th"}`;
+    return `${name}${round === 1 ? "" : ` the ${ordinal}`} (subagent)`;
+  };
+}
+function allocateSubagentName() {
+  return nextName();
+}
+function resolveCreatedAgentName(name, isSubagent, assignedName) {
+  return name ?? (isSubagent ? assignedName || allocateSubagentName() : DEFAULT_AGENT_NAME);
+}
+var SUBAGENT_NAMES, nextName;
+var init_names = __esm(() => {
+  init_constants2();
+  SUBAGENT_NAMES = [
+    "Deckard",
+    "Rachael",
+    "Roy",
+    "Pris",
+    "Zhora",
+    "Leon",
+    "Gaff",
+    "Tyrell",
+    "Sebastian",
+    "Bryant",
+    "Chew",
+    "Holden",
+    "Taffey",
+    "K",
+    "Joi",
+    "Luv",
+    "Wallace",
+    "Joshi",
+    "Sapper",
+    "Mariette",
+    "Freysa",
+    "Ana",
+    "Coco",
+    "Samantha",
+    "Theodore",
+    "Amy",
+    "Catherine",
+    "Paul",
+    "Isabella",
+    "Ava",
+    "Caleb",
+    "Nathan",
+    "Kyoko",
+    "V",
+    "Johnny",
+    "Jackie",
+    "Judy",
+    "Panam",
+    "River",
+    "Kerry",
+    "Rogue",
+    "Alt",
+    "Evelyn",
+    "Takemura",
+    "Hanako",
+    "Yorinobu",
+    "Saburo",
+    "Oda",
+    "Viktor",
+    "Misty",
+    "Dex",
+    "T-Bug",
+    "Delamain",
+    "Wakako",
+    "Padre",
+    "Regina",
+    "Dakota",
+    "Dino",
+    "El Capitan",
+    "Mr. Hands",
+    "Placide",
+    "Brigitte",
+    "Royce",
+    "Dum Dum",
+    "Brick",
+    "Meredith",
+    "Sandra",
+    "Maiko",
+    "Claire",
+    "Nix",
+    "Weyland",
+    "Saul",
+    "Mitch",
+    "Scorpion",
+    "Cassidy",
+    "Carol",
+    "Denny",
+    "Nancy",
+    "Henry",
+    "Blue Moon",
+    "Red Menace",
+    "Purple Force",
+    "Lizzy",
+    "Ozob",
+    "Smasher",
+    "Reed",
+    "Songbird",
+    "Alex",
+    "Myers",
+    "Hansen",
+    "Paco",
+    "Babs",
+    "Slider",
+    "Aurore",
+    "Aymeric",
+    "Aguilar",
+    "Bree",
+    "Dante",
+    "Lina",
+    "Garry",
+    "Pepe"
+  ];
+  nextName = createSubagentNameAllocator();
+});
+
 // src/mods/capabilities.ts
 function isModCapabilityId(value) {
   return MOD_CAPABILITY_ID_SET.has(value);
@@ -123795,6 +123945,9 @@ function composeSubagentChildEnv(options) {
     ...parentAgentId && { LETTA_PARENT_AGENT_ID: parentAgentId },
     ...transcriptPath && { TRANSCRIPT_PATH: transcriptPath }
   };
+  delete childEnv[SUBAGENT_NAME_ENV];
+  if (options.subagentName)
+    childEnv[SUBAGENT_NAME_ENV] = options.subagentName;
   if (backendMode === "local") {
     childEnv.LETTA_LOCAL_BACKEND_EXPERIMENTAL = "1";
     if (localBackendStorageDir) {
@@ -124324,7 +124477,8 @@ async function executeSubagent(type3, config, model, userPrompt, subagentId, isR
       inheritedApiKey,
       inheritedBaseUrl,
       actingUserId: actingUserIdOverride,
-      transcriptPath
+      transcriptPath,
+      subagentName: existingAgentId || existingConversationId ? undefined : allocateSubagentName()
     });
     const sandbox = wrapSubagentLauncher({
       launcher,
@@ -124610,6 +124764,7 @@ var init_manager3 = __esm(() => {
   init_subagent_stdout_failure();
   init_subagents();
   init_context_budget();
+  init_names();
   init_subagent_launcher();
   init_subagent_model();
   init_subagent_stream();
@@ -126548,8 +126703,8 @@ var init_SendAgentMessage2 = __esm(() => {
         description: "The existing message thread to send to. Each conversation has its own message history. A conv-... ID is sufficient; to use an agent's default thread, also supply agent_id."
       },
       computer: {
-        type: "string",
-        description: "Optional computer where the recipient should run: cloud, an online computer name, or its stable device ID. Omit to use its active computer or saved destination (a computer or Cloud sandbox). An offline saved computer does not trigger a Cloud-sandbox fallback."
+        type: ["string", "null"],
+        description: "Optional computer where the recipient should run: cloud, an online computer name, or its stable device ID. Omitted, null, and blank values use its active computer or saved destination (a computer or Cloud sandbox). An offline saved computer does not trigger a Cloud-sandbox fallback."
       }
     },
     required: ["message"],
@@ -144693,7 +144848,15 @@ class APIBackend {
   }
   async createConversationMessageStream(conversationId, body, options) {
     const client = await this.getClient();
-    return client.conversations.messages.create(conversationId, body, options);
+    const { data: stream12, response } = await client.conversations.messages.create(conversationId, body, options).withResponse();
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.split(";")[0]?.trim().toLowerCase() !== "text/event-stream") {
+      stream12.controller.abort();
+      throw new APIConnectionError({
+        message: `Connection error: expected text/event-stream, received ${contentType || "no content type"} (HTTP ${response.status}).`
+      });
+    }
+    return stream12;
   }
   async streamConversationMessages(conversationId, body, options) {
     const client = await this.getClient();
@@ -144812,6 +144975,7 @@ function __testSetBackend(nextBackend) {
 }
 var DEFAULT_CONVERSATION_MESSAGE_ORDER = "desc", backend = null;
 var init_backend = __esm(() => {
+  init_error();
   init_chatgpt_usage_service();
   init_server_url();
   init_backend_mode();
@@ -145327,7 +145491,7 @@ function resolveCreatedAgentMemfsConfig(options) {
   const memoryPromptMode = (options.requestedMemoryPromptMode !== "standard" ? options.requestedMemoryPromptMode : undefined) ?? (enableMemfs ? options.capabilities.localMemfs ? "local-memfs" : "memfs" : "standard");
   return { enableMemfs, memoryPromptMode };
 }
-async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingModel, updateArgs, skillsDirectory, parallelToolCalls = true, systemPromptPreset, baseTools) {
+async function createAgent(nameOrOptions, model, embeddingModel, updateArgs, skillsDirectory, parallelToolCalls = true, systemPromptPreset, baseTools) {
   let options;
   if (typeof nameOrOptions === "object") {
     options = nameOrOptions;
@@ -145343,10 +145507,11 @@ async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingM
       baseTools
     };
   }
-  const name = options.name ?? DEFAULT_AGENT_NAME;
   const embeddingModelVal = options.embeddingModel;
   const parallelToolCallsVal = options.parallelToolCalls ?? true;
   const isSubagent = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
+  const name = resolveCreatedAgentName(options.name, isSubagent, process.env[SUBAGENT_NAME_ENV]);
+  delete process.env[SUBAGENT_NAME_ENV];
   let modelHandle;
   if (options.model) {
     const resolved = resolveModel(options.model);
@@ -145465,7 +145630,6 @@ async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingM
 var init_create5 = __esm(() => {
   init_backend2();
   init_request();
-  init_constants2();
   init_settings_manager();
   init_debug();
   init_available_models();
@@ -145474,6 +145638,7 @@ var init_create5 = __esm(() => {
   init_model();
   init_modify();
   init_prompt_assets();
+  init_names();
   init_system_prompt_resolution();
   init_system_prompt_versioning();
 });
@@ -146693,14 +146858,14 @@ var require_react_development = __commonJS((exports, module3) => {
           return 1;
         }
         var child;
-        var nextName;
+        var nextName2;
         var subtreeCount = 0;
         var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
         if (isArray5(children)) {
           for (var i2 = 0;i2 < children.length; i2++) {
             child = children[i2];
-            nextName = nextNamePrefix + getElementKey(child, i2);
-            subtreeCount += mapIntoArray(child, array2, escapedPrefix, nextName, callback);
+            nextName2 = nextNamePrefix + getElementKey(child, i2);
+            subtreeCount += mapIntoArray(child, array2, escapedPrefix, nextName2, callback);
           }
         } else {
           var iteratorFn = getIteratorFn(children);
@@ -146719,8 +146884,8 @@ var require_react_development = __commonJS((exports, module3) => {
             var ii = 0;
             while (!(step = iterator.next()).done) {
               child = step.value;
-              nextName = nextNamePrefix + getElementKey(child, ii++);
-              subtreeCount += mapIntoArray(child, array2, escapedPrefix, nextName, callback);
+              nextName2 = nextNamePrefix + getElementKey(child, ii++);
+              subtreeCount += mapIntoArray(child, array2, escapedPrefix, nextName2, callback);
             }
           } else if (type3 === "object") {
             var childrenString = String(children);
@@ -217397,17 +217562,12 @@ class QueueRuntime {
     const batch = [];
     const first = this.store.find((item) => !item.paused);
     if (first && isCoalescable(first.kind)) {
-      let batchActingUserId = first.actingUserId;
       for (const item of this.store) {
         if (item.paused)
           continue;
         if (!isCoalescable(item.kind) || !hasSameScope(first, item))
           break;
-        if (batchActingUserId && item.actingUserId && batchActingUserId !== item.actingUserId) {
-          break;
-        }
         batch.push(item);
-        batchActingUserId ??= item.actingUserId;
       }
     } else if (first) {
       batch.push(first);
@@ -217553,47 +217713,13 @@ var init_queue_runtime = __esm(() => {
   init_debug();
 });
 
-// src/queue/turn-queue-runtime.ts
-function stringifyUnexpectedContent(content) {
-  try {
-    return JSON.stringify(content) ?? String(content);
-  } catch {
-    return String(content);
-  }
-}
-function appendContentParts(target2, content) {
-  if (typeof content === "string") {
-    target2.push({ type: "text", text: content });
-    return;
-  }
-  if (!Array.isArray(content)) {
-    if (content === null || content === undefined)
-      return;
-    target2.push({ type: "text", text: stringifyUnexpectedContent(content) });
-    return;
-  }
-  target2.push(...content);
-}
-function mergeQueuedTurnInput(queued, options) {
-  if (queued.length === 0) {
-    return null;
-  }
-  const separatorText = options.separatorText ?? `
-`;
-  const mergedParts = [];
-  let isFirst = true;
-  for (const item of queued) {
-    if (!isFirst) {
-      mergedParts.push({ type: "text", text: separatorText });
-    }
-    isFirst = false;
-    if (item.kind === "task_notification" || item.kind === "cron_prompt") {
-      mergedParts.push({ type: "text", text: item.text });
-      continue;
-    }
-    appendContentParts(mergedParts, options.normalizeUserContent(item.content));
+// src/agent/message-attribution.ts
+function withMessageAttribution(message, actingUserId) {
+  const attributed = message;
+  if (message.role !== "user" || attributed.attribution !== undefined || !actingUserId) {
+    return attributed;
   }
-  return mergedParts.length > 0 ? mergedParts : null;
+  return { ...message, attribution: { acting_user_id: actingUserId } };
 }
 
 // src/websocket/helpers/listener-queue-adapter.ts
@@ -217645,109 +217771,37 @@ function getQueueItemsScope(items3) {
 function hasSameQueueScope(a2, b3) {
   return (a2.agentId ?? null) === (b3.agentId ?? null) && (a2.conversationId ?? null) === (b3.conversationId ?? null);
 }
-function mergeDequeuedBatchContent(items3) {
-  const queuedInputs = [];
-  for (const item of items3) {
-    if (item.kind === "message") {
-      queuedInputs.push({
-        kind: "user",
-        content: item.content
-      });
-      continue;
-    }
-    if (item.kind === "task_notification") {
-      queuedInputs.push({
-        kind: "task_notification",
-        text: item.text
-      });
-      continue;
-    }
-    if (item.kind === "cron_prompt") {
-      queuedInputs.push({
-        kind: "cron_prompt",
-        text: item.text
-      });
-      continue;
-    }
-    if (item.kind === "mod_continue") {
-      queuedInputs.push({
-        kind: "user",
-        content: item.text
-      });
-    }
-  }
-  return mergeQueuedTurnInput(queuedInputs, {
-    normalizeUserContent: (content) => content
-  });
-}
-function getPrimaryQueueMessageItem(items3) {
-  for (const item of items3) {
-    if (item.kind === "message") {
-      return item;
-    }
-  }
-  return null;
-}
-function pickBatchActingUserId(items3) {
-  for (let i4 = items3.length - 1;i4 >= 0; i4 -= 1) {
-    const actingUserId = items3[i4]?.actingUserId;
-    if (actingUserId) {
-      return actingUserId;
-    }
-  }
-  return;
-}
 function buildQueuedTurnMessage(runtime, batch) {
-  const actingUserId = pickBatchActingUserId(batch.items);
-  const primaryItem = getPrimaryQueueMessageItem(batch.items);
-  if (!primaryItem) {
-    for (const item of batch.items) {
-      runtime.queuedMessagesByItemId.delete(item.id);
-    }
-    const mergedContent2 = mergeDequeuedBatchContent(batch.items);
-    if (mergedContent2 === null) {
-      return null;
-    }
-    const scopeItem = batch.items[0];
-    return {
-      type: "message",
-      agentId: scopeItem?.agentId ?? runtime.agentId ?? undefined,
-      conversationId: scopeItem?.conversationId ?? runtime.conversationId,
-      ...actingUserId ? { actingUserId } : {},
-      messages: [
-        {
-          role: "user",
-          content: mergedContent2,
-          otid: crypto.randomUUID()
-        }
-      ]
-    };
-  }
-  const template3 = runtime.queuedMessagesByItemId.get(primaryItem.id);
+  let template3;
+  const messages = [];
   for (const item of batch.items) {
+    const incoming = runtime.queuedMessagesByItemId.get(item.id);
+    if (item.kind === "message" && incoming) {
+      template3 ??= {
+        ...incoming,
+        actingUserId: incoming.actingUserId ?? item.actingUserId
+      };
+      messages.push(...incoming.messages.map((message) => ("content" in message) ? withMessageAttribution(message, item.actingUserId ?? incoming.actingUserId) : message));
+    } else if (item.kind === "message") {
+      messages.push(withMessageAttribution({ role: "user", content: item.content }, item.actingUserId));
+    } else if (isCoalescable(item.kind) && "text" in item) {
+      messages.push({
+        role: "user",
+        content: item.text,
+        otid: crypto.randomUUID(),
+        attribution: {}
+      });
+    }
     runtime.queuedMessagesByItemId.delete(item.id);
   }
-  if (!template3) {
-    return null;
-  }
-  const mergedContent = mergeDequeuedBatchContent(batch.items);
-  if (mergedContent === null) {
+  if (messages.length === 0)
     return null;
-  }
-  const firstMessageIndex = template3.messages.findIndex((payload) => ("content" in payload));
-  if (firstMessageIndex === -1) {
-    return null;
-  }
-  const firstMessage = template3.messages[firstMessageIndex];
-  const mergedFirstMessage = {
-    ...firstMessage,
-    content: mergedContent
-  };
-  const messages = template3.messages.slice();
-  messages[firstMessageIndex] = mergedFirstMessage;
+  const scopeItem = batch.items[0];
   return {
+    type: "message",
+    agentId: scopeItem?.agentId ?? runtime.agentId ?? undefined,
+    conversationId: scopeItem?.conversationId ?? runtime.conversationId,
     ...template3,
-    ...actingUserId ? { actingUserId } : {},
     messages
   };
 }
@@ -217778,7 +217832,7 @@ function shouldProcessInboundMessageDirectly(runtime, parsed) {
   });
   return getListenerBlockedReason(runtime.turnLifecycle.snapshot(), activeScope ? getPendingControlRequestCount(runtime.listener, activeScope) : 0) === null;
 }
-function consumeQueuedTurn(runtime, continuation) {
+function consumeQueuedTurn(runtime) {
   const queuedItems = runtime.queueRuntime.peekReady();
   const firstQueuedItem = queuedItems[0];
   if (!firstQueuedItem || !isCoalescable(firstQueuedItem.kind)) {
@@ -217790,22 +217844,15 @@ function consumeQueuedTurn(runtime, continuation) {
   let hasCronPrompt = false;
   let hasModContinue = false;
   let batchConnectionId;
-  let batchActingUserId = firstQueuedItem.actingUserId;
   let batchImageFailureMode = null;
   const isNoCoalesce = (candidate) => candidate.kind === "message" && candidate.noCoalesce === true;
   for (const item of queuedItems) {
-    if (continuation && item.actingUserId !== continuation.actingUserId) {
-      break;
-    }
     if (!isCoalescable(item.kind) || !hasSameQueueScope(firstQueuedItem, item)) {
       break;
     }
     if (queueLen > 0 && (isNoCoalesce(item) || isNoCoalesce(firstQueuedItem))) {
       break;
     }
-    if (batchActingUserId && item.actingUserId && batchActingUserId !== item.actingUserId) {
-      break;
-    }
     if (item.kind === "message") {
       const itemConnectionId = runtime.queuedMessagesByItemId.get(item.id)?.connectionId;
       if (batchConnectionId !== undefined && itemConnectionId !== undefined && itemConnectionId !== batchConnectionId) {
@@ -217818,7 +217865,6 @@ function consumeQueuedTurn(runtime, continuation) {
       }
       batchImageFailureMode = itemImageFailureMode;
     }
-    batchActingUserId ??= item.actingUserId;
     queueLen += 1;
     if (item.kind === "message") {
       hasMessage = true;
@@ -222814,7 +222860,7 @@ function isRuntimeStartCommand(value) {
   if (!value || typeof value !== "object")
     return false;
   const c = value;
-  return c.type === "runtime_start" && typeof c.request_id === "string" && (c.agent_id === undefined || typeof c.agent_id === "string") && (c.create_agent === undefined || isRuntimeStartCreateAgentOptions(c.create_agent)) && (c.conversation_id === undefined || typeof c.conversation_id === "string") && (c.create_conversation === undefined || isRuntimeStartCreateConversationOptions(c.create_conversation)) && (c.conversation_source_tags === undefined || isStringArray8(c.conversation_source_tags)) && (c.cwd === undefined || c.cwd === null || typeof c.cwd === "string") && (c.mode === undefined || isDevicePermissionMode(c.mode)) && (c.execution_settings === undefined || isRuntimeExecutionSettings(c.execution_settings)) && (c.workspace_sandbox === undefined || isRuntimeStartWorkspaceSandbox(c.workspace_sandbox)) && (c.skill_sources === undefined || isSkillSourceArray(c.skill_sources)) && (c.preserve_skill_sources === undefined || typeof c.preserve_skill_sources === "boolean") && (c.client_info === undefined || isRuntimeStartClientInfo(c.client_info)) && (c.recover_approvals === undefined || typeof c.recover_approvals === "boolean") && (c.force_device_status === undefined || typeof c.force_device_status === "boolean") && (c.wait_for_replay === undefined || typeof c.wait_for_replay === "boolean") && (c.external_tools === undefined || Array.isArray(c.external_tools) && c.external_tools.every(isRuntimeStartExternalToolsGroup));
+  return c.type === "runtime_start" && typeof c.request_id === "string" && (c.agent_id === undefined || typeof c.agent_id === "string") && (c.create_agent === undefined || isRuntimeStartCreateAgentOptions(c.create_agent)) && (c.conversation_id === undefined || typeof c.conversation_id === "string") && (c.create_conversation === undefined || isRuntimeStartCreateConversationOptions(c.create_conversation)) && (c.conversation_source_tags === undefined || isStringArray8(c.conversation_source_tags)) && (c.cwd === undefined || c.cwd === null || typeof c.cwd === "string") && (c.mode === undefined || isDevicePermissionMode(c.mode)) && (c.execution_settings === undefined || isRuntimeExecutionSettings(c.execution_settings)) && (c.workspace_sandbox === undefined || isRuntimeStartWorkspaceSandbox(c.workspace_sandbox)) && (c.skill_sources === undefined || isSkillSourceArray(c.skill_sources)) && (c.preserve_skill_sources === undefined || typeof c.preserve_skill_sources === "boolean") && (c.client_info === undefined || isRuntimeStartClientInfo(c.client_info)) && (c.recover_approvals === undefined || typeof c.recover_approvals === "boolean") && (c.force_device_status === undefined || typeof c.force_device_status === "boolean") && (c.wait_for_replay === undefined || typeof c.wait_for_replay === "boolean") && (c.teleport_id === undefined || typeof c.teleport_id === "string") && (c.external_tools === undefined || Array.isArray(c.external_tools) && c.external_tools.every(isRuntimeStartExternalToolsGroup));
 }
 function isRuntimeStartCreateAgentOptions(value) {
   if (!isObjectRecord2(value))
@@ -397765,6 +397811,497 @@ function assertRuntimeWorkspaceSandboxChangeAllowed(listener, runtime, next) {
   }
 }
 
+// src/channels/teleport-guard.ts
+function getLocalChannelTeleportError(scope) {
+  const channels = getSupportedChannelIds().filter((channelId) => {
+    return readRoutes(channelId).some((route) => route.agentId === scope.agentId && route.conversationId === scope.conversationId && route.enabled !== false && route.outboundEnabled !== false);
+  });
+  if (channels.length === 0)
+    return null;
+  return `This conversation is bound to ${channels.join(", ")} on this computer. Teleport is blocked because MessageChannel cannot follow the conversation to another computer yet. Remove the channel route or continue locally.`;
+}
+var init_teleport_guard = __esm(() => {
+  init_plugin_registry();
+  init_routing();
+});
+
+// src/websocket/listener/recoverable-notices.ts
+function getRecoverableStatusNoticeVisibility(kind) {
+  switch (kind) {
+    case "stale_approval_conflict_recovery":
+      return "debug_only";
+    default:
+      return "transcript";
+  }
+}
+function getRecoverableRetryNoticeVisibility(kind) {
+  switch (kind) {
+    case "transient_provider_retry":
+      return "transcript";
+    default:
+      return "transcript";
+  }
+}
+function isDesktopDebugPanelMirrorEnabled() {
+  return process.env.LETTA_DESKTOP_MODE === "1";
+}
+function mirrorRecoverableNoticeToDesktopDebugPanel(message) {
+  if (!isDesktopDebugPanelMirrorEnabled()) {
+    return;
+  }
+  try {
+    process.stderr.write(`${DESKTOP_DEBUG_PANEL_INFO_PREFIX} ${message}
+`);
+  } catch {}
+}
+function toStructuredApiError(errorInfo) {
+  if (!errorInfo?.error_type || !errorInfo.run_id) {
+    return;
+  }
+  return {
+    message_type: "error_message",
+    message: errorInfo.message || errorInfo.detail || "An error occurred",
+    error_type: errorInfo.error_type,
+    run_id: errorInfo.run_id,
+    ...errorInfo.detail ? { detail: errorInfo.detail } : {}
+  };
+}
+function getStructuredApiErrorFromError(error4) {
+  if (!(error4 instanceof Error)) {
+    return;
+  }
+  const errorWithStructuredInfo = error4;
+  return errorWithStructuredInfo.apiError ?? toStructuredApiError(errorWithStructuredInfo.runErrorInfo);
+}
+function buildStructuredFormatInput(apiError) {
+  return {
+    error: {
+      error: {
+        type: apiError.error_type,
+        message: apiError.message,
+        ...apiError.detail ? { detail: apiError.detail } : {}
+      },
+      run_id: apiError.run_id
+    }
+  };
+}
+function isAbortLikeError(error4) {
+  if (error4 instanceof APIUserAbortError) {
+    return true;
+  }
+  if (!(error4 instanceof Error)) {
+    return false;
+  }
+  const errorWithCode = error4;
+  return error4.name === "AbortError" || error4.message === "The operation was aborted" || errorWithCode.code === "ABORT_ERR";
+}
+function isTerminatedProcessNoise(message) {
+  return message.trim().toLowerCase() === "terminated";
+}
+function isProxyTransportError(detail, error4, message) {
+  if (error4 instanceof APIError && error4.status >= 500 && detail.toLowerCase().includes("trying to proxy")) {
+    return true;
+  }
+  return detail.toLowerCase().includes("error occurred while trying to proxy") || message.toLowerCase().includes("error occurred while trying to proxy");
+}
+function getLoopErrorNoticeDecision(params) {
+  const apiError = params.apiError ?? toStructuredApiError(params.errorInfo) ?? toStructuredApiError(params.runErrorInfo) ?? getStructuredApiErrorFromError(params.error);
+  const detail = apiError?.detail ?? params.errorInfo?.detail ?? params.runErrorInfo?.detail ?? extractConflictDetail(params.error) ?? "";
+  if (params.cancelRequested || params.abortSignal?.aborted || isAbortLikeError(params.error) || isTerminatedProcessNoise(params.message)) {
+    return {
+      visibility: "debug_only",
+      message: params.message
+    };
+  }
+  const cloudflareMessage = checkCloudflareEdgeError(detail) ?? checkCloudflareEdgeError(params.message);
+  if (cloudflareMessage) {
+    return {
+      visibility: "transcript",
+      message: cloudflareMessage,
+      apiError
+    };
+  }
+  if (isProxyTransportError(detail, params.error, params.message)) {
+    return {
+      visibility: "transcript",
+      message: "Connection to Letta service failed. Please retry.",
+      apiError
+    };
+  }
+  const formattedMessage = formatErrorDetails2(apiError ? buildStructuredFormatInput(apiError) : params.error ?? params.message, params.agentId ?? undefined, params.conversationId ?? undefined, {
+    surface: params.surface,
+    unclassifiedFallback: params.unclassifiedFallback
+  });
+  return {
+    visibility: "transcript",
+    message: formattedMessage,
+    apiError
+  };
+}
+function getTranscriptLoopErrorMessage(params) {
+  const decision = getLoopErrorNoticeDecision({
+    ...params,
+    surface: "plain",
+    unclassifiedFallback: "generic"
+  });
+  return decision.visibility === "transcript" ? decision.message : undefined;
+}
+function getConsumerLoopErrorMessage(params) {
+  const decision = getLoopErrorNoticeDecision({
+    ...params,
+    surface: "plain"
+  });
+  return decision.visibility === "transcript" ? decision.message : undefined;
+}
+function emitLoopErrorNotice(socket, runtime, params) {
+  const decision = getLoopErrorNoticeDecision(params);
+  if (decision.visibility === "debug_only") {
+    debugLog("recovery", `Debug-only loop error (${params.stopReason}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return null;
+  }
+  emitLoopErrorDelta(socket, runtime, {
+    message: decision.message,
+    stopReason: params.stopReason,
+    isTerminal: params.isTerminal,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId,
+    apiError: decision.apiError
+  });
+  return decision.message;
+}
+function emitRecoverableStatusNotice(socket, runtime, params) {
+  const visibility = getRecoverableStatusNoticeVisibility(params.kind);
+  if (visibility === "debug_only") {
+    debugLog("recovery", `Debug-only lifecycle notice (${params.kind}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return;
+  }
+  emitStatusDelta(socket, runtime, {
+    message: params.message,
+    level: params.level,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId
+  });
+}
+function emitRecoverableRetryNotice(socket, runtime, params) {
+  const visibility = getRecoverableRetryNoticeVisibility(params.kind);
+  if (visibility === "debug_only") {
+    debugLog("recovery", `Debug-only retry notice (${params.kind}, attempt ${params.attempt}/${params.maxAttempts}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return;
+  }
+  emitRetryDelta(socket, runtime, {
+    message: params.message,
+    reason: params.reason,
+    attempt: params.attempt,
+    maxAttempts: params.maxAttempts,
+    delayMs: params.delayMs,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId
+  });
+}
+var DESKTOP_DEBUG_PANEL_INFO_PREFIX = "[LETTA_DESKTOP_DEBUG_PANEL_INFO]";
+var init_recoverable_notices = __esm(() => {
+  init_error();
+  init_turn_recovery_policy();
+  init_error_formatter();
+  init_debug();
+  init_protocol_outbound();
+});
+
+// src/websocket/listener/teleport.ts
+function expectInboundTeleport(runtime, teleportId) {
+  runtime.expectedTeleportId = teleportId;
+  runtime.expectedTeleportExpiresAt = Date.now() + INBOUND_TELEPORT_CONTINUE_TTL_MS;
+}
+function isInboundTeleportExpected(runtime) {
+  if (runtime.expectedTeleportId === null)
+    return false;
+  if (runtime.expectedTeleportExpiresAt !== null && runtime.expectedTeleportExpiresAt <= Date.now()) {
+    clearExpectedInboundTeleport(runtime);
+    return false;
+  }
+  return true;
+}
+function clearExpectedInboundTeleport(runtime) {
+  runtime.expectedTeleportId = null;
+  runtime.expectedTeleportExpiresAt = null;
+}
+function buildTeleportContinuationMessages(params) {
+  return [
+    {
+      type: "approval",
+      approvals: params.approvals,
+      otid: params.teleportId
+    },
+    {
+      role: "system",
+      content: "<system-reminder>Teleportation to this environment is complete. Continue the existing task from this environment now.</system-reminder>",
+      otid: `${params.teleportId}:continue`
+    }
+  ];
+}
+function escapeSystemReminderText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildTeleportFailureMessages(params) {
+  const messages = [];
+  if (params.approvals && params.approvals.length > 0) {
+    messages.push({
+      type: "approval",
+      approvals: params.approvals,
+      otid: params.teleportId
+    });
+  }
+  messages.push({
+    role: "system",
+    content: `<system-reminder>Teleportation failed.
+
+Error: ${escapeSystemReminderText(params.error)}
+
+Continue the existing task from this environment now.</system-reminder>`,
+    otid: `${params.teleportId}:failed`
+  });
+  return messages;
+}
+function getPendingTeleports(runtime) {
+  runtime.pendingTeleports ??= new Map;
+  return runtime.pendingTeleports;
+}
+function findPendingTeleportForRuntime(runtime, agentId, conversationId) {
+  for (const pending of getPendingTeleports(runtime).values()) {
+    if (pending.agentId === agentId && pending.conversationId === conversationId && pending.readyAt === undefined) {
+      return pending;
+    }
+  }
+  return null;
+}
+function isRuntimeTeleportPending(runtime, agentId, conversationId) {
+  if (!agentId)
+    return false;
+  return [...runtime.pendingTeleports?.values() ?? []].some((pending) => !pending.error && pending.agentId === agentId && pending.conversationId === conversationId);
+}
+function clearPriorReadyTeleports(params) {
+  const pendingTeleports = params.listener.pendingTeleports;
+  if (!pendingTeleports)
+    return;
+  for (const [teleportId, pending] of pendingTeleports) {
+    if (teleportId === params.currentTeleportId || pending.readyAt === undefined) {
+      continue;
+    }
+    if (pending.agentId === params.agentId && pending.conversationId === params.conversationId) {
+      pendingTeleports.delete(teleportId);
+    }
+  }
+}
+function hasAcceptedInputsWaiting(runtime, includeQueuePump) {
+  return runtime.queueRuntime.length > 0 || runtime.pendingTurns > 0 || runtime.queuedMessagesByItemId.size > 0 || includeQueuePump && (runtime.queuePumpActive || runtime.queuePumpScheduled);
+}
+function sendTeleportReady(runtime, pending, input) {
+  const connection = runtime.connections.get(pending.connectionId);
+  if (!connection || !isListenerTransportOpen(connection.writer))
+    return false;
+  const mode = getOrCreateConversationPermissionModeStateRef(runtime, pending.agentId, pending.conversationId).mode;
+  const message = {
+    type: "teleport_ready",
+    teleport_id: pending.teleportId,
+    runtime: {
+      agent_id: pending.agentId,
+      conversation_id: pending.conversationId
+    },
+    success: input.success,
+    active_turn: pending.activeTurn,
+    mode,
+    ...pending.continuation ? { continuation: pending.continuation } : {},
+    ...input.error ? { error: input.error } : {}
+  };
+  emitProtocolV2Message(connection.writer, runtime, message, message.runtime, toListenerConnection(pending.connectionId));
+  return true;
+}
+function retainTeleportForRecovery(runtime, pending) {
+  const timeout = setTimeout(() => {
+    const current = runtime.pendingTeleports?.get(pending.teleportId);
+    if (current === pending) {
+      runtime.pendingTeleports?.delete(pending.teleportId);
+    }
+  }, TELEPORT_RECOVERY_TTL_MS);
+  timeout.unref?.();
+}
+function handleTeleportProbe(command, socket, safeSocketSend) {
+  safeSocketSend(socket, {
+    type: "teleport_probe_response",
+    request_id: command.request_id,
+    runtime: command.runtime,
+    supported: resolveBackendMode() === "api",
+    drains_accepted_inputs: true,
+    idempotent_continuation: true
+  }, "teleport_probe_response", "teleport_probe");
+}
+function handleTeleportRequest(params) {
+  const { listener, command, connectionId } = params;
+  const pendingTeleports = getPendingTeleports(listener);
+  const existing = pendingTeleports.get(command.teleport_id);
+  if (existing) {
+    if (existing.readyAt !== undefined) {
+      sendTeleportReady(listener, existing, {
+        success: existing.error === undefined,
+        error: existing.error
+      });
+    }
+    return;
+  }
+  const pending = {
+    teleportId: command.teleport_id,
+    connectionId,
+    agentId: command.runtime.agent_id,
+    conversationId: command.runtime.conversation_id,
+    requestedAt: Date.now(),
+    drainAcceptedInputs: false,
+    activeTurn: false
+  };
+  const channelError = getLocalChannelTeleportError(pending);
+  if (channelError) {
+    pending.readyAt = Date.now();
+    pending.error = channelError;
+    pendingTeleports.set(pending.teleportId, pending);
+    sendTeleportReady(listener, pending, {
+      success: false,
+      error: channelError
+    });
+    retainTeleportForRecovery(listener, pending);
+    return;
+  }
+  const conflicting = findPendingTeleportForRuntime(listener, pending.agentId, pending.conversationId);
+  if (conflicting) {
+    pendingTeleports.set(pending.teleportId, pending);
+    pending.readyAt = Date.now();
+    pending.error = "Conversation already has a teleport pending";
+    sendTeleportReady(listener, pending, {
+      success: false,
+      error: pending.error
+    });
+    retainTeleportForRecovery(listener, pending);
+    return;
+  }
+  pendingTeleports.set(pending.teleportId, pending);
+  const conversationRuntime = getConversationRuntime(listener, pending.agentId, pending.conversationId);
+  pending.drainAcceptedInputs = conversationRuntime ? hasAcceptedInputsWaiting(conversationRuntime, true) : false;
+  if (!conversationRuntime?.isProcessing && !pending.drainAcceptedInputs) {
+    if (sendTeleportReady(listener, pending, { success: true })) {
+      pending.readyAt = Date.now();
+      retainTeleportForRecovery(listener, pending);
+    }
+  }
+}
+function claimPendingTeleportAtBoundary(params) {
+  const pending = findPendingTeleportForRuntime(params.listener, params.agentId, params.conversationId);
+  if (!pending)
+    return null;
+  if (pending.drainAcceptedInputs) {
+    if (params.activeTurn)
+      return null;
+    const runtime = getConversationRuntime(params.listener, params.agentId, params.conversationId);
+    if (runtime && hasAcceptedInputsWaiting(runtime, false))
+      return null;
+  }
+  const connection = params.listener.connections.get(pending.connectionId);
+  if (!connection || !isListenerTransportOpen(connection.writer))
+    return null;
+  pending.readyAt = Date.now();
+  pending.activeTurn = params.activeTurn;
+  pending.continuation = params.continuation;
+  return pending;
+}
+function emitClaimedTeleportReady(listener, pending) {
+  const sent = sendTeleportReady(listener, pending, { success: true });
+  if (sent) {
+    retainTeleportForRecovery(listener, pending);
+  }
+  return sent;
+}
+function finishTeleport(runtime, lease, pending) {
+  const transition = runtime.turnLifecycle.finish(lease, "cancelled");
+  if (!transition.finished)
+    return transition;
+  emitRuntimeStateUpdates(runtime, {
+    agent_id: pending.agentId,
+    conversation_id: pending.conversationId
+  });
+  emitClaimedTeleportReady(runtime.listener, pending);
+  return transition;
+}
+function finishPendingTeleport(runtime) {
+  if (!runtime.agentId)
+    return;
+  const pending = findPendingTeleportForRuntime(runtime.listener, runtime.agentId, runtime.conversationId);
+  if (!pending || runtime.lastStopReason !== "end_turn" && !pending.drainAcceptedInputs) {
+    return;
+  }
+  const claimed = claimPendingTeleportAtBoundary({
+    listener: runtime.listener,
+    agentId: runtime.agentId,
+    conversationId: runtime.conversationId,
+    activeTurn: false
+  });
+  if (claimed)
+    emitClaimedTeleportReady(runtime.listener, claimed);
+}
+function takeFailedTeleport(params) {
+  const pending = params.listener.pendingTeleports?.get(params.teleportId);
+  if (!pending || pending.agentId !== params.agentId || pending.conversationId !== params.conversationId) {
+    return null;
+  }
+  params.listener.pendingTeleports?.delete(params.teleportId);
+  return pending;
+}
+function handleTeleportFailure(params) {
+  const pending = takeFailedTeleport({
+    listener: params.listener,
+    teleportId: params.command.teleport_id,
+    agentId: params.command.runtime.agent_id,
+    conversationId: params.command.runtime.conversation_id
+  });
+  if (!pending || pending.error)
+    return;
+  const runtime = params.getOrCreateScopedRuntime(params.listener, pending.agentId, pending.conversationId);
+  emitLoopErrorNotice(params.socket, runtime, {
+    message: `Teleport failed: ${params.command.error}`,
+    stopReason: "error",
+    isTerminal: false,
+    agentId: pending.agentId,
+    conversationId: pending.conversationId
+  });
+  params.runDetachedListenerTask("teleport_failed", async () => {
+    await params.processIncomingMessage({
+      type: "message",
+      connectionId: pending.connectionId,
+      agentId: pending.agentId,
+      conversationId: pending.conversationId,
+      messages: buildTeleportFailureMessages({
+        teleportId: params.command.teleport_id,
+        error: params.command.error,
+        approvals: pending.continuation?.approvals
+      })
+    }, params.socket, runtime, params.onStatusChange, pending.connectionId);
+  });
+}
+var TELEPORT_RECOVERY_TTL_MS, INBOUND_TELEPORT_CONTINUE_TTL_MS = 60000;
+var init_teleport = __esm(() => {
+  init_backend_mode();
+  init_teleport_guard();
+  init_connection();
+  init_permission_mode();
+  init_protocol_outbound();
+  init_recoverable_notices();
+  init_runtime();
+  init_transport();
+  TELEPORT_RECOVERY_TTL_MS = 5 * 60000;
+});
+
 // src/websocket/listener/commands/runtime-start.ts
 function buildDefaultConversation(agent) {
   const now2 = new Date().toISOString();
@@ -397984,6 +398521,9 @@ async function handleRuntimeStartCommand(parsed, context3) {
     assertConnectionOpen();
     const scopedRuntime = context3.getOrCreateScopedRuntime(context3.runtime, runtimeScope.agent_id, runtimeScope.conversation_id);
     await applyRuntimeStartState(parsed, context3, runtimeScope, scopedRuntime);
+    if (parsed.teleport_id) {
+      expectInboundTeleport(scopedRuntime, parsed.teleport_id);
+    }
     assertConnectionOpen();
     subscribeListenerConnection(context3.runtime, connectionId, runtimeScope);
     registerRuntimeExternalTools(context3.runtime, connectionId, runtimeScope, parsed.external_tools ?? []);
@@ -398045,6 +398585,7 @@ var init_runtime_start = __esm(async () => {
   init_cwd_change();
   init_permission_mode();
   init_runtime_start_validation();
+  init_teleport();
   await init_external_tools();
   LEGACY_SUMMARY_PREFIX_BY_SOURCE_TAG = {
     "channel:discord": "discord",
@@ -398923,194 +399464,6 @@ var init_interrupts = __esm(() => {
   STREAMING_TOOL_OUTPUT_MAX_CHARS = LIMITS.BASH_OUTPUT_CHARS;
 });
 
-// src/websocket/listener/recoverable-notices.ts
-function getRecoverableStatusNoticeVisibility(kind) {
-  switch (kind) {
-    case "stale_approval_conflict_recovery":
-      return "debug_only";
-    default:
-      return "transcript";
-  }
-}
-function getRecoverableRetryNoticeVisibility(kind) {
-  switch (kind) {
-    case "transient_provider_retry":
-      return "transcript";
-    default:
-      return "transcript";
-  }
-}
-function isDesktopDebugPanelMirrorEnabled() {
-  return process.env.LETTA_DESKTOP_MODE === "1";
-}
-function mirrorRecoverableNoticeToDesktopDebugPanel(message) {
-  if (!isDesktopDebugPanelMirrorEnabled()) {
-    return;
-  }
-  try {
-    process.stderr.write(`${DESKTOP_DEBUG_PANEL_INFO_PREFIX} ${message}
-`);
-  } catch {}
-}
-function toStructuredApiError(errorInfo) {
-  if (!errorInfo?.error_type || !errorInfo.run_id) {
-    return;
-  }
-  return {
-    message_type: "error_message",
-    message: errorInfo.message || errorInfo.detail || "An error occurred",
-    error_type: errorInfo.error_type,
-    run_id: errorInfo.run_id,
-    ...errorInfo.detail ? { detail: errorInfo.detail } : {}
-  };
-}
-function getStructuredApiErrorFromError(error4) {
-  if (!(error4 instanceof Error)) {
-    return;
-  }
-  const errorWithStructuredInfo = error4;
-  return errorWithStructuredInfo.apiError ?? toStructuredApiError(errorWithStructuredInfo.runErrorInfo);
-}
-function buildStructuredFormatInput(apiError) {
-  return {
-    error: {
-      error: {
-        type: apiError.error_type,
-        message: apiError.message,
-        ...apiError.detail ? { detail: apiError.detail } : {}
-      },
-      run_id: apiError.run_id
-    }
-  };
-}
-function isAbortLikeError(error4) {
-  if (error4 instanceof APIUserAbortError) {
-    return true;
-  }
-  if (!(error4 instanceof Error)) {
-    return false;
-  }
-  const errorWithCode = error4;
-  return error4.name === "AbortError" || error4.message === "The operation was aborted" || errorWithCode.code === "ABORT_ERR";
-}
-function isTerminatedProcessNoise(message) {
-  return message.trim().toLowerCase() === "terminated";
-}
-function isProxyTransportError(detail, error4, message) {
-  if (error4 instanceof APIError && error4.status >= 500 && detail.toLowerCase().includes("trying to proxy")) {
-    return true;
-  }
-  return detail.toLowerCase().includes("error occurred while trying to proxy") || message.toLowerCase().includes("error occurred while trying to proxy");
-}
-function getLoopErrorNoticeDecision(params) {
-  const apiError = params.apiError ?? toStructuredApiError(params.errorInfo) ?? toStructuredApiError(params.runErrorInfo) ?? getStructuredApiErrorFromError(params.error);
-  const detail = apiError?.detail ?? params.errorInfo?.detail ?? params.runErrorInfo?.detail ?? extractConflictDetail(params.error) ?? "";
-  if (params.cancelRequested || params.abortSignal?.aborted || isAbortLikeError(params.error) || isTerminatedProcessNoise(params.message)) {
-    return {
-      visibility: "debug_only",
-      message: params.message
-    };
-  }
-  const cloudflareMessage = checkCloudflareEdgeError(detail) ?? checkCloudflareEdgeError(params.message);
-  if (cloudflareMessage) {
-    return {
-      visibility: "transcript",
-      message: cloudflareMessage,
-      apiError
-    };
-  }
-  if (isProxyTransportError(detail, params.error, params.message)) {
-    return {
-      visibility: "transcript",
-      message: "Connection to Letta service failed. Please retry.",
-      apiError
-    };
-  }
-  const formattedMessage = formatErrorDetails2(apiError ? buildStructuredFormatInput(apiError) : params.error ?? params.message, params.agentId ?? undefined, params.conversationId ?? undefined, {
-    surface: params.surface,
-    unclassifiedFallback: params.unclassifiedFallback
-  });
-  return {
-    visibility: "transcript",
-    message: formattedMessage,
-    apiError
-  };
-}
-function getTranscriptLoopErrorMessage(params) {
-  const decision = getLoopErrorNoticeDecision({
-    ...params,
-    surface: "plain",
-    unclassifiedFallback: "generic"
-  });
-  return decision.visibility === "transcript" ? decision.message : undefined;
-}
-function getConsumerLoopErrorMessage(params) {
-  const decision = getLoopErrorNoticeDecision({
-    ...params,
-    surface: "plain"
-  });
-  return decision.visibility === "transcript" ? decision.message : undefined;
-}
-function emitLoopErrorNotice(socket, runtime, params) {
-  const decision = getLoopErrorNoticeDecision(params);
-  if (decision.visibility === "debug_only") {
-    debugLog("recovery", `Debug-only loop error (${params.stopReason}): ${params.message}`);
-    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
-    return null;
-  }
-  emitLoopErrorDelta(socket, runtime, {
-    message: decision.message,
-    stopReason: params.stopReason,
-    isTerminal: params.isTerminal,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId,
-    apiError: decision.apiError
-  });
-  return decision.message;
-}
-function emitRecoverableStatusNotice(socket, runtime, params) {
-  const visibility = getRecoverableStatusNoticeVisibility(params.kind);
-  if (visibility === "debug_only") {
-    debugLog("recovery", `Debug-only lifecycle notice (${params.kind}): ${params.message}`);
-    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
-    return;
-  }
-  emitStatusDelta(socket, runtime, {
-    message: params.message,
-    level: params.level,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId
-  });
-}
-function emitRecoverableRetryNotice(socket, runtime, params) {
-  const visibility = getRecoverableRetryNoticeVisibility(params.kind);
-  if (visibility === "debug_only") {
-    debugLog("recovery", `Debug-only retry notice (${params.kind}, attempt ${params.attempt}/${params.maxAttempts}): ${params.message}`);
-    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
-    return;
-  }
-  emitRetryDelta(socket, runtime, {
-    message: params.message,
-    reason: params.reason,
-    attempt: params.attempt,
-    maxAttempts: params.maxAttempts,
-    delayMs: params.delayMs,
-    runId: params.runId,
-    agentId: params.agentId,
-    conversationId: params.conversationId
-  });
-}
-var DESKTOP_DEBUG_PANEL_INFO_PREFIX = "[LETTA_DESKTOP_DEBUG_PANEL_INFO]";
-var init_recoverable_notices = __esm(() => {
-  init_error();
-  init_turn_recovery_policy();
-  init_error_formatter();
-  init_debug();
-  init_protocol_outbound();
-});
-
 // src/cli/helpers/compaction-utils.ts
 function extractCompactionSummary(text2) {
   try {
@@ -401799,6 +402152,59 @@ var init_continuation_input = __esm(async () => {
   ]);
 });
 
+// src/backend/api/agents.ts
+async function getAgentContextOverview(agentId, options) {
+  return apiRequest("GET", `/v1/agents/${agentId}/context`, undefined, {
+    signal: options?.signal
+  });
+}
+async function createMinimalAgent(apiKey, name) {
+  return apiRequest("POST", "/v1/agents", { name }, {
+    baseUrl: "https://api.letta.com",
+    apiKey
+  });
+}
+async function getAgentRuntimeStatus(agentId, conversationIds, signal) {
+  return apiRequest("GET", `/v1/agents/${encodeURIComponent(agentId)}/runtime-status`, undefined, { query: { conversation_ids: conversationIds.join(",") }, signal });
+}
+var init_agents7 = __esm(() => {
+  init_request();
+});
+
+// src/websocket/listener/recovery-ownership.ts
+function hasRecoveryHandoff(runtime) {
+  return isInboundTeleportExpected(runtime) || isRuntimeTeleportPending(runtime.listener, runtime.agentId, runtime.conversationId);
+}
+async function canRecoverConversation(runtime, readStatus = getAgentRuntimeStatus) {
+  if (hasRecoveryHandoff(runtime))
+    return false;
+  const connectionId = runtime.listener.connectionId;
+  if (!connectionId?.startsWith("conn-")) {
+    return true;
+  }
+  if (!runtime.agentId)
+    return true;
+  try {
+    const snapshot = await readStatus(runtime.agentId, [runtime.conversationId], AbortSignal.timeout(5000));
+    if (hasRecoveryHandoff(runtime) || runtime.listener.connectionId !== connectionId)
+      return false;
+    const status = snapshot.statuses.find((entry) => entry.conversation_id === runtime.conversationId);
+    if (!status || status.has_conflicting_listeners)
+      return false;
+    if (status.active_harness)
+      return status.active_harness.connection_id === connectionId;
+    return status.state === "IDLE";
+  } catch (error4) {
+    debugWarn("recovery", "Could not verify conversation recovery ownership", error4);
+    return false;
+  }
+}
+var init_recovery_ownership = __esm(() => {
+  init_agents7();
+  init_debug();
+  init_teleport();
+});
+
 // src/websocket/listener/secrets-sync.ts
 function getFreshnessMs() {
   return _testFreshnessMsOverride ?? DEFAULT_FRESHNESS_MS;
@@ -402110,6 +402516,15 @@ async function startRecoveredApprovalContinuation(runtime, socket, processTurn,
   if (runtime.turnLifecycle.kind !== "idle") {
     return false;
   }
+  if (!await canRecoverConversation(runtime)) {
+    if (runtime.recoveredApprovalState === recovered) {
+      clearRecoveredApprovalState(runtime);
+      runtime.syncApprovalRecoveryCompleted = false;
+    }
+    return false;
+  }
+  if (runtime.turnLifecycle.kind !== "idle" || runtime.recoveredApprovalState !== recovered)
+    return false;
   const scope = {
     agent_id: recovered.agentId,
     conversation_id: recovered.conversationId
@@ -402393,13 +402808,11 @@ async function executeRecoveredApprovalContinuation(params) {
       }
     ]);
     let continuationBatchId = `batch-recovered-${crypto.randomUUID()}`;
-    let continuationActingUserId;
     let continuationCorrelation;
     const consumedQueuedTurn = consumeQueuedTurn(runtime);
     if (consumedQueuedTurn) {
       const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
       continuationBatchId = dequeuedBatch.batchId;
-      continuationActingUserId = queuedTurn.actingUserId;
       continuationInput = appendQueuedTurnToInput(continuationInput, queuedTurn);
       continuationCorrelation = createTurnCorrelation(runtime, {
         type: "message",
@@ -402417,7 +402830,6 @@ async function executeRecoveredApprovalContinuation(params) {
       type: "message",
       agentId: recovered.agentId,
       conversationId: recovered.conversationId,
-      ...continuationActingUserId ? { actingUserId: continuationActingUserId } : {},
       messages: continuationInput.messages
     }, socket, runtime, opts?.onStatusChange, opts?.connectionId, continuationBatchId, recoveryLease, continuationCorrelation);
     if (runtime.turnLifecycle.isCurrent(recoveryLease)) {
@@ -402470,6 +402882,7 @@ var init_recovery = __esm(async () => {
   init_permission_mode();
   init_protocol_outbound();
   init_recoverable_notices();
+  init_recovery_ownership();
   init_runtime();
   init_secrets_sync();
   init_turn_correlation();
@@ -402900,13 +403313,11 @@ async function resolveStaleApprovals(runtime, socket, turnLease, deps = {}) {
           otid: crypto.randomUUID()
         }
       ]);
-      let continuationActingUserId;
       let recoveryTurnCorrelation;
       const consumedQueuedTurn = consumeQueuedTurn(runtime);
       if (consumedQueuedTurn) {
         const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
         recoveryTurnCorrelation = createTurnCorrelation(runtime, queuedTurn, dequeuedBatch.batchId);
-        continuationActingUserId = queuedTurn.actingUserId;
         continuationInput = appendQueuedTurnToInput(continuationInput, queuedTurn);
         emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
       }
@@ -402920,7 +403331,6 @@ async function resolveStaleApprovals(runtime, socket, turnLease, deps = {}) {
         agentId: runtime.agentId ?? undefined,
         streamTokens: true,
         background: true,
-        ...continuationActingUserId ? { actingUserId: continuationActingUserId } : {},
         workingDirectory: recoveryWorkingDirectory,
         preparedToolContext: preparedToolContext.preparedToolContext,
         ...continuationInput.imageFailureModesByMessageOtid ? {
@@ -403268,292 +403678,6 @@ var init_stream_recovery_status = __esm(() => {
   init_protocol_outbound();
 });
 
-// src/channels/teleport-guard.ts
-function getLocalChannelTeleportError(scope) {
-  const channels = getSupportedChannelIds().filter((channelId) => {
-    return readRoutes(channelId).some((route) => route.agentId === scope.agentId && route.conversationId === scope.conversationId && route.enabled !== false && route.outboundEnabled !== false);
-  });
-  if (channels.length === 0)
-    return null;
-  return `This conversation is bound to ${channels.join(", ")} on this computer. Teleport is blocked because MessageChannel cannot follow the conversation to another computer yet. Remove the channel route or continue locally.`;
-}
-var init_teleport_guard = __esm(() => {
-  init_plugin_registry();
-  init_routing();
-});
-
-// src/websocket/listener/teleport.ts
-function buildTeleportContinuationMessages(params) {
-  return [
-    {
-      type: "approval",
-      approvals: params.approvals,
-      otid: params.teleportId
-    },
-    {
-      role: "system",
-      content: "<system-reminder>Teleportation to this environment is complete. Continue the existing task from this environment now.</system-reminder>",
-      otid: `${params.teleportId}:continue`
-    }
-  ];
-}
-function escapeSystemReminderText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function buildTeleportFailureMessages(params) {
-  const messages = [];
-  if (params.approvals && params.approvals.length > 0) {
-    messages.push({
-      type: "approval",
-      approvals: params.approvals,
-      otid: params.teleportId
-    });
-  }
-  messages.push({
-    role: "system",
-    content: `<system-reminder>Teleportation failed.
-
-Error: ${escapeSystemReminderText(params.error)}
-
-Continue the existing task from this environment now.</system-reminder>`,
-    otid: `${params.teleportId}:failed`
-  });
-  return messages;
-}
-function getPendingTeleports(runtime) {
-  runtime.pendingTeleports ??= new Map;
-  return runtime.pendingTeleports;
-}
-function findPendingTeleportForRuntime(runtime, agentId, conversationId) {
-  for (const pending of getPendingTeleports(runtime).values()) {
-    if (pending.agentId === agentId && pending.conversationId === conversationId && pending.readyAt === undefined) {
-      return pending;
-    }
-  }
-  return null;
-}
-function isRuntimeTeleportPending(runtime, agentId, conversationId) {
-  if (!agentId)
-    return false;
-  return [...runtime.pendingTeleports?.values() ?? []].some((pending) => !pending.error && pending.agentId === agentId && pending.conversationId === conversationId);
-}
-function clearPriorReadyTeleports(params) {
-  const pendingTeleports = params.listener.pendingTeleports;
-  if (!pendingTeleports)
-    return;
-  for (const [teleportId, pending] of pendingTeleports) {
-    if (teleportId === params.currentTeleportId || pending.readyAt === undefined) {
-      continue;
-    }
-    if (pending.agentId === params.agentId && pending.conversationId === params.conversationId) {
-      pendingTeleports.delete(teleportId);
-    }
-  }
-}
-function hasAcceptedInputsWaiting(runtime, includeQueuePump) {
-  return runtime.queueRuntime.length > 0 || runtime.pendingTurns > 0 || runtime.queuedMessagesByItemId.size > 0 || includeQueuePump && (runtime.queuePumpActive || runtime.queuePumpScheduled);
-}
-function sendTeleportReady(runtime, pending, input) {
-  const connection = runtime.connections.get(pending.connectionId);
-  if (!connection || !isListenerTransportOpen(connection.writer))
-    return false;
-  const mode = getOrCreateConversationPermissionModeStateRef(runtime, pending.agentId, pending.conversationId).mode;
-  const message = {
-    type: "teleport_ready",
-    teleport_id: pending.teleportId,
-    runtime: {
-      agent_id: pending.agentId,
-      conversation_id: pending.conversationId
-    },
-    success: input.success,
-    active_turn: pending.activeTurn,
-    mode,
-    ...pending.continuation ? { continuation: pending.continuation } : {},
-    ...input.error ? { error: input.error } : {}
-  };
-  emitProtocolV2Message(connection.writer, runtime, message, message.runtime, toListenerConnection(pending.connectionId));
-  return true;
-}
-function retainTeleportForRecovery(runtime, pending) {
-  const timeout = setTimeout(() => {
-    const current = runtime.pendingTeleports?.get(pending.teleportId);
-    if (current === pending) {
-      runtime.pendingTeleports?.delete(pending.teleportId);
-    }
-  }, TELEPORT_RECOVERY_TTL_MS);
-  timeout.unref?.();
-}
-function handleTeleportProbe(command, socket, safeSocketSend) {
-  safeSocketSend(socket, {
-    type: "teleport_probe_response",
-    request_id: command.request_id,
-    runtime: command.runtime,
-    supported: resolveBackendMode() === "api",
-    drains_accepted_inputs: true,
-    idempotent_continuation: true
-  }, "teleport_probe_response", "teleport_probe");
-}
-function handleTeleportRequest(params) {
-  const { listener, command, connectionId } = params;
-  const pendingTeleports = getPendingTeleports(listener);
-  const existing = pendingTeleports.get(command.teleport_id);
-  if (existing) {
-    if (existing.readyAt !== undefined) {
-      sendTeleportReady(listener, existing, {
-        success: existing.error === undefined,
-        error: existing.error
-      });
-    }
-    return;
-  }
-  const pending = {
-    teleportId: command.teleport_id,
-    connectionId,
-    agentId: command.runtime.agent_id,
-    conversationId: command.runtime.conversation_id,
-    requestedAt: Date.now(),
-    drainAcceptedInputs: false,
-    activeTurn: false
-  };
-  const channelError = getLocalChannelTeleportError(pending);
-  if (channelError) {
-    pending.readyAt = Date.now();
-    pending.error = channelError;
-    pendingTeleports.set(pending.teleportId, pending);
-    sendTeleportReady(listener, pending, {
-      success: false,
-      error: channelError
-    });
-    retainTeleportForRecovery(listener, pending);
-    return;
-  }
-  const conflicting = findPendingTeleportForRuntime(listener, pending.agentId, pending.conversationId);
-  if (conflicting) {
-    pendingTeleports.set(pending.teleportId, pending);
-    pending.readyAt = Date.now();
-    pending.error = "Conversation already has a teleport pending";
-    sendTeleportReady(listener, pending, {
-      success: false,
-      error: pending.error
-    });
-    retainTeleportForRecovery(listener, pending);
-    return;
-  }
-  pendingTeleports.set(pending.teleportId, pending);
-  const conversationRuntime = getConversationRuntime(listener, pending.agentId, pending.conversationId);
-  pending.drainAcceptedInputs = conversationRuntime ? hasAcceptedInputsWaiting(conversationRuntime, true) : false;
-  if (!conversationRuntime?.isProcessing && !pending.drainAcceptedInputs) {
-    if (sendTeleportReady(listener, pending, { success: true })) {
-      pending.readyAt = Date.now();
-      retainTeleportForRecovery(listener, pending);
-    }
-  }
-}
-function claimPendingTeleportAtBoundary(params) {
-  const pending = findPendingTeleportForRuntime(params.listener, params.agentId, params.conversationId);
-  if (!pending)
-    return null;
-  if (pending.drainAcceptedInputs) {
-    if (params.activeTurn)
-      return null;
-    const runtime = getConversationRuntime(params.listener, params.agentId, params.conversationId);
-    if (runtime && hasAcceptedInputsWaiting(runtime, false))
-      return null;
-  }
-  const connection = params.listener.connections.get(pending.connectionId);
-  if (!connection || !isListenerTransportOpen(connection.writer))
-    return null;
-  pending.readyAt = Date.now();
-  pending.activeTurn = params.activeTurn;
-  pending.continuation = params.continuation;
-  return pending;
-}
-function emitClaimedTeleportReady(listener, pending) {
-  const sent = sendTeleportReady(listener, pending, { success: true });
-  if (sent) {
-    retainTeleportForRecovery(listener, pending);
-  }
-  return sent;
-}
-function finishTeleport(runtime, lease, pending) {
-  const transition = runtime.turnLifecycle.finish(lease, "cancelled");
-  if (!transition.finished)
-    return transition;
-  emitRuntimeStateUpdates(runtime, {
-    agent_id: pending.agentId,
-    conversation_id: pending.conversationId
-  });
-  emitClaimedTeleportReady(runtime.listener, pending);
-  return transition;
-}
-function finishPendingTeleport(runtime) {
-  if (!runtime.agentId)
-    return;
-  const pending = findPendingTeleportForRuntime(runtime.listener, runtime.agentId, runtime.conversationId);
-  if (!pending || runtime.lastStopReason !== "end_turn" && !pending.drainAcceptedInputs) {
-    return;
-  }
-  const claimed = claimPendingTeleportAtBoundary({
-    listener: runtime.listener,
-    agentId: runtime.agentId,
-    conversationId: runtime.conversationId,
-    activeTurn: false
-  });
-  if (claimed)
-    emitClaimedTeleportReady(runtime.listener, claimed);
-}
-function takeFailedTeleport(params) {
-  const pending = params.listener.pendingTeleports?.get(params.teleportId);
-  if (!pending || pending.agentId !== params.agentId || pending.conversationId !== params.conversationId) {
-    return null;
-  }
-  params.listener.pendingTeleports?.delete(params.teleportId);
-  return pending;
-}
-function handleTeleportFailure(params) {
-  const pending = takeFailedTeleport({
-    listener: params.listener,
-    teleportId: params.command.teleport_id,
-    agentId: params.command.runtime.agent_id,
-    conversationId: params.command.runtime.conversation_id
-  });
-  if (!pending || pending.error)
-    return;
-  const runtime = params.getOrCreateScopedRuntime(params.listener, pending.agentId, pending.conversationId);
-  emitLoopErrorNotice(params.socket, runtime, {
-    message: `Teleport failed: ${params.command.error}`,
-    stopReason: "error",
-    isTerminal: false,
-    agentId: pending.agentId,
-    conversationId: pending.conversationId
-  });
-  params.runDetachedListenerTask("teleport_failed", async () => {
-    await params.processIncomingMessage({
-      type: "message",
-      connectionId: pending.connectionId,
-      agentId: pending.agentId,
-      conversationId: pending.conversationId,
-      messages: buildTeleportFailureMessages({
-        teleportId: params.command.teleport_id,
-        error: params.command.error,
-        approvals: pending.continuation?.approvals
-      })
-    }, params.socket, runtime, params.onStatusChange, pending.connectionId);
-  });
-}
-var TELEPORT_RECOVERY_TTL_MS;
-var init_teleport = __esm(() => {
-  init_backend_mode();
-  init_teleport_guard();
-  init_connection();
-  init_permission_mode();
-  init_protocol_outbound();
-  init_recoverable_notices();
-  init_runtime();
-  init_transport();
-  TELEPORT_RECOVERY_TTL_MS = 5 * 60000;
-});
-
 // node_modules/diff/libesm/diff/base.js
 class Diff2 {
   diff(oldStr, newStr, options = {}) {
@@ -405988,9 +406112,7 @@ async function handleApprovalStop(params) {
   ]);
   let continuationBatchId = dequeuedBatchId;
   const sendOptions = buildSendOptions() ?? {};
-  const consumedQueuedTurn = consumeQueuedTurn(runtime, {
-    actingUserId: sendOptions.actingUserId
-  });
+  const consumedQueuedTurn = consumeQueuedTurn(runtime);
   if (consumedQueuedTurn) {
     const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
     turnCorrelation?.appendDequeuedBatch(dequeuedBatch.batchId);
@@ -418806,6 +418928,7 @@ function createListenerMessageHandler(params) {
             currentTeleportId: teleportId
           });
           const scopedRuntime2 = getOrCreateScopedRuntime2(runtime, parsed.runtime.agent_id, parsed.runtime.conversation_id);
+          clearExpectedInboundTeleport(scopedRuntime2);
           const acceptedKey = `teleport:${teleportId}`;
           const previousDisposition = scopedRuntime2.acceptedInputDispositions.get(acceptedKey);
           if (previousDisposition) {
@@ -419348,6 +419471,10 @@ async function recoverApprovalStateForSync(runtime, scope, deps = {}) {
     clearRecoveredApprovalState(runtime);
     return;
   }
+  if (!await canRecoverConversation(runtime)) {
+    clearRecoveredApprovalState(runtime);
+    return "deferred";
+  }
   const existingRecovered = runtime.recoveredApprovalState;
   if (existingRecovered && existingRecovered.agentId === scope.agent_id && existingRecovered.conversationId === scope.conversation_id && existingRecovered.pendingRequestIds.size > 0) {
     return;
@@ -419380,6 +419507,8 @@ async function recoverApprovalStateForSync(runtime, scope, deps = {}) {
     clearRecoveredApprovalState(runtime);
     return;
   }
+  if (!await canRecoverConversation(runtime))
+    return "deferred";
   if (hasInterruptedCacheForScope(runtime.listener, scope) || sameActiveScope && (runtime.turnLifecycle.kind !== "idle" || runtime.pendingApprovalResolvers.size > 0)) {
     return;
   }
@@ -419424,6 +419553,7 @@ async function recoverApprovalStateForSync(runtime, scope, deps = {}) {
     autoDecisions: staleDenialDecisions,
     allApprovals: pendingApprovals
   };
+  return;
 }
 var init_recovery_sync = __esm(() => {
   init_error();
@@ -419431,6 +419561,7 @@ var init_recovery_sync = __esm(() => {
   init_turn_recovery_policy();
   init_backend2();
   init_interactive_policy();
+  init_recovery_ownership();
   init_runtime();
 });
 
@@ -419440,8 +419571,8 @@ async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
   const recoverFn = opts?.recoverApprovalStateForSync ?? recoverApprovalStateForSync;
   if ((opts?.recoverApprovals ?? true) || !syncScopedRuntime.syncApprovalRecoveryCompleted) {
     try {
-      await recoverFn(syncScopedRuntime, scope);
-      syncScopedRuntime.syncApprovalRecoveryCompleted = true;
+      const recovered = await recoverFn(syncScopedRuntime, scope);
+      syncScopedRuntime.syncApprovalRecoveryCompleted = recovered !== "deferred";
     } catch (error4) {
       trackBoundaryError({
         errorType: "listener_sync_recovery_failed",
@@ -440813,7 +440944,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.32.6"
+    version: "0.32.8"
   };
 });
 
@@ -442650,25 +442781,6 @@ var init_message_search = __esm(() => {
   init_transcript_search();
 });
 
-// src/backend/api/agents.ts
-async function getAgentContextOverview(agentId, options) {
-  return apiRequest("GET", `/v1/agents/${agentId}/context`, undefined, {
-    signal: options?.signal
-  });
-}
-async function createMinimalAgent(apiKey, name) {
-  return apiRequest("POST", "/v1/agents", { name }, {
-    baseUrl: "https://api.letta.com",
-    apiKey
-  });
-}
-async function getAgentRuntimeStatus(agentId, conversationIds) {
-  return apiRequest("GET", `/v1/agents/${encodeURIComponent(agentId)}/runtime-status`, undefined, { query: { conversation_ids: conversationIds.join(",") } });
-}
-var init_agents7 = __esm(() => {
-  init_request();
-});
-
 // src/cli/subcommands/message-status.ts
 async function readMessageStatus(conversationId, agentId, backend3, deps = { getAgentRuntimeStatus, getLatestConversationSuperRun }) {
   if (!backend3.capabilities.environmentRouting)
@@ -455161,9 +455273,6 @@ function shouldEnqueueCloudSend(values4, cloud, isAgentLaunch) {
 function validateSendOptions(values4) {
   if (values4.resume)
     throw new Error("--resume is interactive-only; use --conversation <id> in headless mode.");
-  const computer = values4.computer ?? values4.environment ?? values4.env;
-  if (computer !== undefined && !computer.trim())
-    throw new Error("Computer selector must not be empty.");
   if (values4["input-format"])
     throw new Error("Cloud message delivery does not support --input-format stream-json.");
   if (values4.new && values4.conversation)
@@ -455221,6 +455330,7 @@ async function tryCloudHeadlessSend(values4, prompt, backend3, isAgentLaunch, de
     if (!["text", "json", "stream-json"].includes(format5))
       throw new Error(`Invalid output format: ${format5}`);
     validateSendOptions(values4);
+    const computer = normalizeAgentMessageComputer(values4.computer ?? values4.environment ?? values4.env);
     const explicitSender = values4["from-agent"];
     const ambientSender = env5.AGENT_ID || env5.LETTA_AGENT_ID;
     const sender = {
@@ -455238,7 +455348,15 @@ async function tryCloudHeadlessSend(values4, prompt, backend3, isAgentLaunch, de
     }
     if (!agentId && !conversationId)
       throw new Error("Choose a destination with --agent or --conversation. Ambient AGENT_ID identifies the sender.");
-    ({ agentId, conversationId } = await resolveAgentMessageDestination({ agentId, conversationId, senderAgentId: sender.agentId }, backend3, controller.signal));
+    ({ agentId, conversationId } = await resolveAgentMessageDestination({
+      agentId,
+      conversationId,
+      senderAgentId: sender.agentId,
+      currentConversation: {
+        agentId: ambientSender,
+        conversationId: env5.CONVERSATION_ID || env5.LETTA_CONVERSATION_ID
+      }
+    }, backend3, controller.signal));
     const recovery = {
       status_command: `letta messages status --agent ${agentId} --conversation ${conversationId}`,
       messages_command: `letta messages list --agent ${agentId} --conversation ${conversationId}`
@@ -455253,7 +455371,7 @@ async function tryCloudHeadlessSend(values4, prompt, backend3, isAgentLaunch, de
       conversationId,
       clientMessageId,
       content: buildAgentSendContent(sender, noWait, prompt),
-      computer: isCloudEnvironmentSelector(values4.computer ?? values4.environment ?? values4.env) ? "cloud" : values4.computer ?? values4.environment ?? values4.env
+      computer
     }, AbortSignal.any([controller.signal, AbortSignal.timeout(30000)]));
     clearTimeout(submissionTimeout);
     if (noWait) {
@@ -456005,6 +456123,49 @@ var init_headless_tool_events = __esm(async () => {
   await init_approval_execution();
 });
 
+// src/queue/turn-queue-runtime.ts
+function stringifyUnexpectedContent(content) {
+  try {
+    return JSON.stringify(content) ?? String(content);
+  } catch {
+    return String(content);
+  }
+}
+function appendContentParts(target2, content) {
+  if (typeof content === "string") {
+    target2.push({ type: "text", text: content });
+    return;
+  }
+  if (!Array.isArray(content)) {
+    if (content === null || content === undefined)
+      return;
+    target2.push({ type: "text", text: stringifyUnexpectedContent(content) });
+    return;
+  }
+  target2.push(...content);
+}
+function mergeQueuedTurnInput(queued, options) {
+  if (queued.length === 0) {
+    return null;
+  }
+  const separatorText = options.separatorText ?? `
+`;
+  const mergedParts = [];
+  let isFirst = true;
+  for (const item of queued) {
+    if (!isFirst) {
+      mergedParts.push({ type: "text", text: separatorText });
+    }
+    isFirst = false;
+    if (item.kind === "task_notification" || item.kind === "cron_prompt") {
+      mergedParts.push({ type: "text", text: item.text });
+      continue;
+    }
+    appendContentParts(mergedParts, options.normalizeUserContent(item.content));
+  }
+  return mergedParts.length > 0 ? mergedParts : null;
+}
+
 // src/agent/defaults.ts
 var exports_defaults = {};
 __export(exports_defaults, {
@@ -463023,6 +463184,46 @@ var init_use_local_mod_adapter = __esm(async () => {
   import_react44 = __toESM(require_react(), 1);
 });
 
+// src/cli/helpers/ask-user-questions.ts
+function parseAskUserQuestions(approval) {
+  const parsed = safeJsonParseOr(approval.toolArgs, {});
+  if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [];
+  }
+  const questions = parsed.questions;
+  if (!Array.isArray(questions) || questions.length < 1 || questions.length > 4) {
+    return [];
+  }
+  return questions.every(isWellFormedQuestion) ? questions : [];
+}
+function isWellFormedQuestion(q2) {
+  if (q2 == null || typeof q2 !== "object")
+    return false;
+  const question = q2;
+  if (typeof question.question !== "string")
+    return false;
+  if (typeof question.header !== "string")
+    return false;
+  if (question.multiSelect !== undefined && typeof question.multiSelect !== "boolean") {
+    return false;
+  }
+  if (question.allowOther !== undefined && typeof question.allowOther !== "boolean") {
+    return false;
+  }
+  const options = question.options;
+  if (!Array.isArray(options) || options.length < 2 || options.length > 4) {
+    return false;
+  }
+  return options.every(isWellFormedOption);
+}
+function isWellFormedOption(o3) {
+  if (o3 == null || typeof o3 !== "object")
+    return false;
+  const option2 = o3;
+  return typeof option2.label === "string" && option2.label.length > 0 && typeof option2.description === "string";
+}
+var init_ask_user_questions = () => {};
+
 // src/cli/hooks/use-progress-indicator.ts
 function useProgressIndicator(active = true) {
   import_react45.useEffect(() => {
@@ -465271,7 +465472,7 @@ var init_InlineQuestionApproval = __esm(async () => {
     const currentQuestion = questions[currentQuestionIndex];
     const showOther = currentQuestion?.allowOther !== false;
     const baseOptions = currentQuestion ? [
-      ...currentQuestion.options,
+      ...Array.isArray(currentQuestion.options) ? currentQuestion.options.filter((o3) => o3 != null && typeof o3 === "object" && typeof o3.label === "string" && typeof o3.description === "string") : [],
       ...showOther ? [{ label: "Type something.", description: "" }] : []
     ] : [];
     const optionsWithOther = currentQuestion?.multiSelect ? [...baseOptions, { label: "Submit", description: "" }] : baseOptions;
@@ -466066,15 +466267,11 @@ function getMemoryFileEditInfo(approval) {
   }
 }
 function getQuestions(approval) {
-  try {
-    const args = JSON.parse(approval.toolArgs || "{}");
-    return args.questions || [];
-  } catch {
-    return [];
-  }
+  return parseAskUserQuestions(approval);
 }
 var import_react54, jsx_dev_runtime30, ApprovalSwitch;
 var init_ApprovalSwitch = __esm(async () => {
+  init_ask_user_questions();
   await __promiseAll([
     init_tool_name_mapping(),
     init_InlineBashApproval(),
@@ -503256,10 +503453,11 @@ function buildApprovalBatchKey(approvals) {
 
 // src/cli/app/approval-questions.ts
 function getQuestionsFromApproval(approval) {
-  const parsed = safeJsonParseOr(approval.toolArgs, {});
-  return parsed.questions || [];
+  return parseAskUserQuestions(approval);
 }
-var init_approval_questions = () => {};
+var init_approval_questions = __esm(() => {
+  init_ask_user_questions();
+});
 
 // src/cli/app/errors.ts
 function extractErrorMeta(e2) {
@@ -522119,4 +522317,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=4B57A44583E7B14564756E2164756E21
+//# debugId=A89D538A98A9FFDD64756E2164756E21