@letta-ai/letta-code 0.30.19 → 0.30.20

package/letta.js

@@ -5488,7 +5488,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.30.19",
+    version: "0.30.20",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -143838,22 +143838,17 @@ function getResumeRefreshArgs(presetUpdateArgs, agent2) {
   const updateArgs = {};
   for (const field of RESUME_REFRESH_FIELDS) {
     const value = presetUpdateArgs[field];
-    if (field === "max_output_tokens" && (typeof value === "number" || value === null)) {
-      updateArgs[field] = value;
-    } else if (field === "parallel_tool_calls" && typeof value === "boolean") {
+    if (typeof value === "boolean") {
       updateArgs[field] = value;
     }
   }
   if (Object.keys(updateArgs).length === 0) {
     return { updateArgs, needsUpdate: false };
   }
-  const currentMaxTokens = agent2.llm_config?.max_tokens;
-  const wantMaxTokens = updateArgs.max_output_tokens;
   const currentParallel = agent2.model_settings?.parallel_tool_calls;
   const wantParallel = updateArgs.parallel_tool_calls;
-  const maxTokensMatch = wantMaxTokens === undefined || currentMaxTokens === wantMaxTokens;
   const parallelMatch = wantParallel === undefined || currentParallel === wantParallel;
-  return { updateArgs, needsUpdate: !(maxTokensMatch && parallelMatch) };
+  return { updateArgs, needsUpdate: !parallelMatch };
 }
 function findModelByHandle(handle) {
   const pickPreferred = (candidates2) => candidates2.find((m2) => m2.isDefault) ?? candidates2.find((m2) => m2.isFeatured) ?? candidates2.find((m2) => m2.updateArgs?.reasoning_effort === "medium") ?? candidates2.find((m2) => m2.updateArgs?.reasoning_effort === "high") ?? candidates2[0] ?? null;
@@ -143922,10 +143917,7 @@ var init_model = __esm(() => {
     "medium",
     "high"
   ];
-  RESUME_REFRESH_FIELDS = [
-    "max_output_tokens",
-    "parallel_tool_calls"
-  ];
+  RESUME_REFRESH_FIELDS = ["parallel_tool_calls"];
 });
 
 // src/utils/error.ts
@@ -144020,7 +144012,7 @@ function generateFrontmatter(data) {
 var fork_default = `---
 name: fork
 description: Fork of the parent agent with full context and tools. Recommended to run in background (run_in_background: true).
-tools: Bash, TaskOutput, Edit, KillBash, LS, MultiEdit, Read, TodoWrite, Write
+tools: all
 model: inherit
 fork: true
 background: true
@@ -144035,7 +144027,7 @@ var init_fork = () => {};
 var general_purpose_default = `---
 name: general-purpose
 description: Full-capability agent for research, planning, and implementation
-tools: Bash, TaskOutput, Edit, KillBash, LS, MultiEdit, Read, TodoWrite, Write
+tools: Bash, TaskCreate, TaskGet, TaskList, TaskOutput, TaskUpdate, Edit, KillBash, Read, Write
 model: inherit
 ---
 
@@ -144051,7 +144043,7 @@ You DO have access to the full conversation history before you were launched.
 
 ## Instructions
 
-- You have access to all tools (Read, Write, Edit, Bash, TodoWrite, etc.) — use Bash with \`rg\` / \`find\` for searching
+- You have access to all tools (Read, Write, Edit, Bash, TaskCreate/TaskUpdate, etc.) — use Bash with \`rg\` / \`find\` for searching
 - Break down complex tasks into steps
 - Search the codebase to understand existing patterns
 - Follow existing code conventions and style
@@ -149439,6 +149431,7 @@ var BashOutput_default = `# BashOutput
 - 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
+- Once the shell finishes you already have its output file path — it was returned when the command started, and repeated in the \`<task-notification>\` you receive on completion. For the full transcript at that point, prefer \`Read\` on that path over calling this tool again; reserve \`BashOutput\` for a shell that's still running.
 `;
 var init_BashOutput = () => {};
 
@@ -150199,15 +150192,15 @@ Returns the full task record including the assigned \`taskId\`.
 var init_TaskCreate = () => {};
 
 // src/tools/descriptions/TaskGet.md
-var TaskGet_default = '# TaskGet\n\nFetch a single task by its `taskId`.\n\nReturns the full task record, including `subject`, `description`, `status`, `owner`, dependency edges (`blocks`, `blockedBy`), and `metadata`.\n\n## Notes\n\n- Works on soft-deleted tasks (`status: "deleted"`) too — `TaskGet` returns the record even though `TaskList` hides it by default.\n- Errors if the task ID doesn\'t exist.\n\n## Example\n\n```\nTaskGet({ taskId: "task_3" })\n```\n';
+var TaskGet_default = '# TaskGet\n\nFetch a single task by its `taskId`.\n\nReturns the full task record, including `subject`, `description`, `status`, `owner`, dependency edges (`blocks`, `blockedBy`), and `metadata`.\n\n## Notes\n\n- Errors if the task ID doesn\'t exist or was deleted.\n\n## Example\n\n```\nTaskGet({ taskId: "task_3" })\n```\n';
 var init_TaskGet = () => {};
 
 // src/tools/descriptions/TaskList.md
-var TaskList_default = '# TaskList\n\nList all tasks in the current session, in creation order.\n\nSoft-deleted tasks (`status: "deleted"`) are excluded from the output. Use `TaskGet` with a specific ID to retrieve a deleted task.\n\n## When to use\n\n- Check current progress without scrolling back through the transcript\n- Verify state before committing to a sequence of `TaskUpdate` calls\n- Confirm task IDs before wiring `addBlocks` / `addBlockedBy` dependencies\n\n## Returns\n\n```\n{ "tasks": [TaskRecord, ...] }\n```\n\nEach `TaskRecord` includes `taskId`, `subject`, `description`, `activeForm`, `status`, `owner`, `blocks`, `blockedBy`, `metadata`, `createdAt`, `updatedAt`.\n';
+var TaskList_default = '# TaskList\n\nList all tasks in the current session, in creation order.\n\nTasks removed with `status: "deleted"` are excluded from the output and cannot be retrieved.\n\n## When to use\n\n- Check current progress without scrolling back through the transcript\n- Verify state before committing to a sequence of `TaskUpdate` calls\n- Confirm task IDs before wiring `addBlocks` / `addBlockedBy` dependencies\n\n## Returns\n\n```\n{ "tasks": [TaskRecord, ...] }\n```\n\nEach `TaskRecord` includes `taskId`, `subject`, `description`, `activeForm`, `status`, `owner`, `blocks`, `blockedBy`, `metadata`, `createdAt`, `updatedAt`.\n';
 var init_TaskList = () => {};
 
 // src/tools/descriptions/TaskOutput.md
-var TaskOutput_default = "# TaskOutput\n\n- Retrieves output from a running or completed task (background shell, monitor, agent, or remote session)\n- Required: `task_id` (the task to query), `block` (whether to wait for completion), `timeout` (max wait time in ms; capped at 600000)\n- Returns the task output along with status information\n- Use `block=true` to wait until the task finishes (or `timeout` elapses)\n- Use `block=false` for an immediate, non-blocking check of current status\n- Task IDs can be found using the /tasks command\n- Works with all task types: background shells, monitors, async agents, and remote sessions\n";
+var TaskOutput_default = "# TaskOutput\n\n- Retrieves output from a running or completed task (background shell, monitor, agent, or remote session)\n- Required: `task_id` (the task to query), `block` (whether to wait for completion), `timeout` (max wait time in ms; capped at 600000)\n- Returns the task output along with status information\n- Use `block=true` to wait until the task finishes (or `timeout` elapses)\n- Use `block=false` for an immediate, non-blocking check of current status\n- Task IDs can be found using the /tasks command\n- Works with all task types: background shells, monitors, async agents, and remote sessions\n- Once a task completes you already have its output file path — it was returned when the task started, and repeated in the `<task-notification>` you receive on completion. For the full transcript at that point, prefer `Read` on that path over calling this tool again; reserve `TaskOutput` for blocking/waiting on a task that hasn't finished yet or for a quick status check.\n";
 var init_TaskOutput = () => {};
 
 // src/tools/descriptions/TaskStop.md
@@ -150215,7 +150208,81 @@ var TaskStop_default = "# TaskStop\n\n- Stops a running background task or monit
 var init_TaskStop = () => {};
 
 // src/tools/descriptions/TaskUpdate.md
-var TaskUpdate_default = "# TaskUpdate\n\nPartially update a single task. Only the fields you pass will change; everything else stays intact.\n\n## Status transitions\n\nUse the `status` field to move a task through its lifecycle:\n\n- `pending` — not started\n- `in_progress` — actively being worked on (keep only ONE task in this state at a time)\n- `completed` — finished\n- `deleted` — soft-delete; excluded from `TaskList` but still fetchable via `TaskGet`\n\nMark a task `completed` **only** when it's fully done — tests pass, implementation is complete, no unresolved errors. If blocked, leave it `in_progress` and create a new task for the blocker (then wire it up via `addBlockedBy`).\n\n## Editable fields\n\n- `subject`, `description`, `activeForm` — full replacements\n- `owner` — assign a string owner (free-form)\n- `addBlocks` — append task IDs that **this task blocks** (they can't start until this one finishes)\n- `addBlockedBy` — append task IDs that **block this task** (they must finish first)\n- `metadata` — merged into existing metadata (existing keys preserved; matching keys overwritten)\n\n## Best practices\n\n- Update status in real-time as you work — don't batch status changes at the end\n- Exactly ONE task should be `in_progress` at any given time\n- Only use `status: \"deleted\"` when a task is no longer relevant; prefer completion when possible\n- When adding dependencies, call `TaskList` first to verify the referenced IDs exist\n\n## Example\n\n```\nTaskUpdate({\n  taskId: \"task_3\",\n  status: \"in_progress\",\n  owner: \"agent-abc123\"\n})\n\nTaskUpdate({\n  taskId: \"task_3\",\n  addBlockedBy: [\"task_1\", \"task_2\"]\n})\n\nTaskUpdate({\n  taskId: \"task_3\",\n  status: \"completed\"\n})\n```\n\nReturns the updated task record.\n";
+var TaskUpdate_default = `Use this tool to update a task in the task list.
+
+## When to Use This Tool
+
+**Mark tasks as resolved:**
+- When you have completed the work described in a task
+- When a task is no longer needed or has been superseded
+- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
+- After resolving, call TaskList to find your next task
+
+- ONLY mark a task as completed when you have FULLY accomplished it
+- If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+- When blocked, create a new task describing what needs to be resolved
+- Never mark a task as completed if:
+  - Tests are failing
+  - Implementation is partial
+  - You encountered unresolved errors
+  - You couldn't find necessary files or dependencies
+
+**Delete tasks:**
+- When a task is no longer relevant or was created in error
+- Setting status to \`deleted\` permanently removes the task
+
+**Update task details:**
+- When requirements change or become clearer
+- When establishing dependencies between tasks
+
+## Fields You Can Update
+
+- **status**: The task status (see Status Workflow below)
+- **subject**: Change the task title (imperative form, e.g., "Run tests")
+- **description**: Change the task description
+- **activeForm**: Present continuous form shown in spinner when in_progress (e.g., "Running tests")
+- **owner**: Change the task owner (agent name)
+- **metadata**: Merge metadata keys into the task (set a key to null to delete it)
+- **addBlocks**: Mark tasks that cannot start until this one completes
+- **addBlockedBy**: Mark tasks that must complete before this one can start
+
+## Status Workflow
+
+Status progresses: \`pending\` → \`in_progress\` → \`completed\`
+
+Use \`deleted\` to permanently remove a task.
+
+## Staleness
+
+Make sure to read a task's latest state using \`TaskGet\` before updating it.
+
+## Examples
+
+Mark task as in progress when starting work:
+\`\`\`json
+{"taskId": "1", "status": "in_progress"}
+\`\`\`
+
+Mark task as completed after finishing work:
+\`\`\`json
+{"taskId": "1", "status": "completed"}
+\`\`\`
+
+Delete a task:
+\`\`\`json
+{"taskId": "1", "status": "deleted"}
+\`\`\`
+
+Claim a task by setting owner:
+\`\`\`json
+{"taskId": "1", "owner": "my-name"}
+\`\`\`
+
+Set up task dependencies:
+\`\`\`json
+{"taskId": "2", "addBlockedBy": ["1"]}
+\`\`\`
+`;
 var init_TaskUpdate = () => {};
 
 // src/tools/descriptions/TodoWrite.md
@@ -153181,6 +153248,7 @@ function createConversationRuntime(listener, agentId, conversationId) {
     currentToolsetPreference: "auto",
     currentLoadedTools: [],
     currentAvailableSkills: [],
+    transientChannelRuntimeTools: false,
     pendingApprovalBatchByToolCallId: new Map,
     approvalMessageIdByToolCallId: new Map,
     pendingInterruptedResults: null,
@@ -164072,15 +164140,12 @@ function formatWithLineNumbers(content, offset, limit3, workingDirectory) {
   let linesWereTruncatedInLength = false;
   const formattedLines = selectedLines.map((line, index) => {
     const lineNumber = actualStartLine + index + 1;
-    const maxLineNumber = actualStartLine + selectedLines.length;
-    const padding = Math.max(1, maxLineNumber.toString().length);
-    const paddedNumber = lineNumber.toString().padStart(padding);
     if (line.length > LIMITS.READ_MAX_CHARS_PER_LINE) {
       linesWereTruncatedInLength = true;
       const truncated = line.slice(0, LIMITS.READ_MAX_CHARS_PER_LINE);
-      return `${paddedNumber}→${truncated}... [line truncated]`;
+      return `${lineNumber}	${truncated}... [line truncated]`;
     }
-    return `${paddedNumber}→${line}`;
+    return `${lineNumber}	${line}`;
   });
   let result = formattedLines.join(`
 `);
@@ -173847,6 +173912,92 @@ var init_context_budget = __esm(() => {
   REFLECTION_STARTUP_CONTEXT_CHAR_LIMIT = REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT * STARTUP_CONTEXT_ESTIMATED_CHARS_PER_TOKEN;
 });
 
+// src/mods/capabilities.ts
+function isModCapabilityId(value) {
+  return MOD_CAPABILITY_ID_SET.has(value);
+}
+function resolveProcessModCapabilities(configuredCapabilities, env3 = process.env) {
+  if (env3[LETTA_MOD_CAPABILITY_PROFILE_ENV] === PROVIDERS_ONLY_MOD_CAPABILITY_PROFILE) {
+    return cloneModCapabilities(PROVIDERS_ONLY_MOD_CAPABILITIES);
+  }
+  return resolveModCapabilities(configuredCapabilities);
+}
+function cloneModCapabilities(capabilities) {
+  return {
+    tools: capabilities.tools,
+    commands: capabilities.commands,
+    events: {
+      lifecycle: capabilities.events.lifecycle,
+      tools: capabilities.events.tools,
+      turns: capabilities.events.turns,
+      compact: capabilities.events.compact,
+      llm: capabilities.events.llm
+    },
+    permissions: capabilities.permissions,
+    providers: capabilities.providers,
+    ui: {
+      panels: capabilities.ui.panels
+    }
+  };
+}
+function resolveModCapabilities(capabilities) {
+  return cloneModCapabilities(capabilities ?? DEFAULT_MOD_CAPABILITIES);
+}
+var MOD_CAPABILITY_IDS, MOD_CAPABILITY_ID_SET, DEFAULT_MOD_CAPABILITIES, DISABLED_MOD_CAPABILITIES, PROVIDERS_ONLY_MOD_CAPABILITIES, LETTA_MOD_CAPABILITY_PROFILE_ENV = "LETTA_MOD_CAPABILITY_PROFILE", PROVIDERS_ONLY_MOD_CAPABILITY_PROFILE = "providers-only";
+var init_capabilities = __esm(() => {
+  MOD_CAPABILITY_IDS = [
+    "tools",
+    "commands",
+    "providers",
+    "permissions",
+    "events.lifecycle",
+    "events.turns",
+    "events.tools",
+    "events.compact",
+    "events.llm",
+    "ui.panels"
+  ];
+  MOD_CAPABILITY_ID_SET = new Set(MOD_CAPABILITY_IDS);
+  DEFAULT_MOD_CAPABILITIES = {
+    tools: true,
+    commands: true,
+    events: {
+      lifecycle: true,
+      tools: true,
+      turns: true,
+      compact: true,
+      llm: true
+    },
+    permissions: true,
+    providers: true,
+    ui: {
+      panels: true
+    }
+  };
+  DISABLED_MOD_CAPABILITIES = {
+    tools: false,
+    commands: false,
+    events: {
+      lifecycle: false,
+      tools: false,
+      turns: false,
+      compact: false,
+      llm: false
+    },
+    permissions: false,
+    providers: false,
+    ui: {
+      panels: false
+    }
+  };
+  PROVIDERS_ONLY_MOD_CAPABILITIES = {
+    ...DISABLED_MOD_CAPABILITIES,
+    events: { ...DISABLED_MOD_CAPABILITIES.events },
+    providers: true,
+    ui: { ...DISABLED_MOD_CAPABILITIES.ui }
+  };
+});
+
 // src/agent/subagents/subagent-launcher.ts
 function resolveSubagentWorkingDirectory(env3 = process.env, fallbackCwd = getCurrentWorkingDirectory(), options3 = {}) {
   if (options3.subagentType === "reflection" && options3.launchProfile === "memory-subagent" && options3.memoryScope) {
@@ -173918,7 +174069,9 @@ function composeSubagentChildEnv(options3) {
     ...inheritedApiKey && { LETTA_API_KEY: inheritedApiKey },
     ...inheritedBaseUrl && { LETTA_BASE_URL: inheritedBaseUrl },
     LETTA_CODE_AGENT_ROLE: "subagent",
-    ...subagentType === "reflection" && { [LETTA_DISABLE_MODS_ENV]: "1" },
+    ...subagentType === "reflection" && {
+      [LETTA_MOD_CAPABILITY_PROFILE_ENV]: PROVIDERS_ONLY_MOD_CAPABILITY_PROFILE
+    },
     ...parentAgentId && { LETTA_PARENT_AGENT_ID: parentAgentId },
     ...transcriptPath && { TRANSCRIPT_PATH: transcriptPath }
   };
@@ -173951,6 +174104,7 @@ function resolveSubagentInheritedPrimaryRoot(options3) {
 var init_subagent_launcher = __esm(() => {
   init_backend2();
   init_paths();
+  init_capabilities();
   init_runtime_context();
   init_shell_env();
 });
@@ -174630,11 +174784,11 @@ ${SYSTEM_REMINDER_CLOSE}
 `;
   }
   return `${SYSTEM_REMINDER_OPEN}
-You have been forked from the primary conversational thread to run as an independent subagent. The fork only exists so you can see the parent agent's conversation trajectory in-context as reference — you are NOT the primary agent and do not share its full toolset.
+You have been forked from the primary conversational thread to run as an independent subagent. The fork only exists so you can see the parent agent's conversation trajectory in-context as reference — you are NOT the primary agent.
 
 **Your sole task is the one described in the user message below. Ignore any existing ongoing tasks from the inherited trajectory.** Do not attempt to continue, finish, or act on anything the primary agent was in the middle of doing.
 
-You have a scoped toolset that may differ from the primary agent's. Stay within it; don't assume you have the primary's full tool access.
+You inherit the primary agent's toolset.
 
 You CANNOT ask questions mid-execution — all instructions are provided upfront.
 Your final message will be returned to the caller.
@@ -174744,7 +174898,8 @@ __export(exports_task, {
   waitForBackgroundSubagentConversationId: () => waitForBackgroundSubagentConversationId,
   waitForBackgroundSubagentAgentId: () => waitForBackgroundSubagentAgentId,
   task: () => task,
-  spawnBackgroundSubagentTask: () => spawnBackgroundSubagentTask
+  spawnBackgroundSubagentTask: () => spawnBackgroundSubagentTask,
+  inheritForkToolset: () => inheritForkToolset
 });
 async function resolveCompletionSummary(defaultSummary, completionSummary, result) {
   if (!completionSummary) {
@@ -175024,6 +175179,13 @@ Error: ${errorMessage}`,
   });
   return { taskId, outputFile, subagentId };
 }
+async function inheritForkToolset(agentId, parentConversationId, forkConversationId) {
+  const parentToolset = settingsManager.getToolsetPreference(agentId, parentConversationId);
+  if (parentToolset === "auto")
+    return;
+  settingsManager.setToolsetPreference(agentId, parentToolset, forkConversationId);
+  await settingsManager.flush();
+}
 async function task(args) {
   const { command = "run", model, toolCallId, signal } = args;
   if (command === "refresh") {
@@ -175074,6 +175236,7 @@ async function task(args) {
         ...parentConvId === "default" ? { agentId: parentAgentId } : {},
         hidden: true
       });
+      await inheritForkToolset(parentAgentId, parentConvId, forkedConv.id);
       effectiveAgentId = parentAgentId;
       effectiveConversationId = forkedConv.id;
     } catch (error54) {
@@ -175172,6 +175335,7 @@ var init_task = __esm(() => {
   init_backend2();
   init_hooks2();
   init_runtime_context();
+  init_settings_manager();
   init_message_queue_bridge();
   init_task_notifications();
   init_process_manager();
@@ -175184,15 +175348,7 @@ function nextTaskId() {
   return `task_${taskIdCounter2++}`;
 }
 function cloneMetadata(meta3) {
-  if (!meta3)
-    return {};
-  const out = {};
-  for (const [k, v] of Object.entries(meta3)) {
-    if (typeof k === "string" && typeof v === "string") {
-      out[k] = v;
-    }
-  }
-  return out;
+  return meta3 ? { ...meta3 } : {};
 }
 function dedupe(values2) {
   return Array.from(new Set(values2));
@@ -175219,14 +175375,12 @@ function getTask(taskId) {
   const t2 = tasks.get(taskId);
   return t2 ? { ...t2 } : undefined;
 }
-function listTasks(options3 = {}) {
+function listTasks() {
   const out = [];
   for (const id2 of insertionOrder) {
     const t2 = tasks.get(id2);
     if (!t2)
       continue;
-    if (!options3.includeDeleted && t2.status === "deleted")
-      continue;
     out.push({ ...t2 });
   }
   return out;
@@ -175253,13 +175407,23 @@ function updateTask(input) {
     existing.blockedBy = dedupe([...existing.blockedBy, ...input.addBlockedBy]);
   }
   if (input.metadata) {
-    existing.metadata = {
-      ...existing.metadata,
-      ...cloneMetadata(input.metadata)
-    };
+    for (const [key, value] of Object.entries(input.metadata)) {
+      if (value === null) {
+        delete existing.metadata[key];
+      } else {
+        existing.metadata[key] = value;
+      }
+    }
   }
   existing.updatedAt = Date.now();
-  return { ...existing };
+  const updated = { ...existing };
+  if (existing.status === "deleted") {
+    tasks.delete(input.taskId);
+    const orderIndex = insertionOrder.indexOf(input.taskId);
+    if (orderIndex !== -1)
+      insertionOrder.splice(orderIndex, 1);
+  }
+  return updated;
 }
 var tasks, insertionOrder, taskIdCounter2 = 1, TaskNotFoundError;
 var init_store = __esm(() => {
@@ -175396,11 +175560,6 @@ async function task_update(args) {
     if (typeof args.metadata !== "object" || args.metadata === null || Array.isArray(args.metadata)) {
       throw new Error("TaskUpdate: 'metadata' must be an object");
     }
-    for (const [k, v] of Object.entries(args.metadata)) {
-      if (typeof v !== "string") {
-        throw new Error(`TaskUpdate: metadata['${k}'] must be a string, received ${typeof v}`);
-      }
-    }
   }
   const addBlocks = validateStringArray(args.addBlocks, "addBlocks");
   const addBlockedBy = validateStringArray(args.addBlockedBy, "addBlockedBy");
@@ -176829,60 +176988,55 @@ var init_TaskStop2 = __esm(() => {
 var TaskUpdate_default2;
 var init_TaskUpdate2 = __esm(() => {
   TaskUpdate_default2 = {
-    type: "object",
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    additionalProperties: false,
     properties: {
-      taskId: {
-        type: "string",
-        description: 'The ID of the task to update (e.g. "task_1").'
+      activeForm: {
+        description: 'Present continuous form shown in spinner when in_progress (e.g. "Running tests")',
+        type: "string"
       },
-      status: {
-        anyOf: [
-          {
-            type: "string",
-            enum: ["pending", "in_progress", "completed"]
-          },
-          {
-            type: "string",
-            const: "deleted"
-          }
-        ],
-        description: "New status. Use 'deleted' to soft-delete the task (it will be excluded from TaskList but remains fetchable via TaskGet)."
+      addBlockedBy: {
+        description: "Task IDs that block this task",
+        items: { type: "string" },
+        type: "array"
       },
-      subject: {
-        type: "string",
-        description: "Replacement subject."
+      addBlocks: {
+        description: "Task IDs that this task blocks",
+        items: { type: "string" },
+        type: "array"
       },
       description: {
-        type: "string",
-        description: "Replacement description."
+        description: "New description for the task",
+        type: "string"
       },
-      activeForm: {
-        type: "string",
-        description: "Replacement active form."
+      metadata: {
+        additionalProperties: {},
+        description: "Metadata keys to merge into the task. Set a key to null to delete it.",
+        propertyNames: { type: "string" },
+        type: "object"
       },
       owner: {
-        type: "string",
-        description: "Assign an owner (free-form string, e.g. agent id or human name)."
+        description: "New owner for the task",
+        type: "string"
       },
-      addBlocks: {
-        type: "array",
-        items: { type: "string" },
-        description: "Task IDs to append to this task's 'blocks' list (tasks that cannot start until this one finishes)."
+      status: {
+        anyOf: [
+          { enum: ["pending", "in_progress", "completed"], type: "string" },
+          { const: "deleted", type: "string" }
+        ],
+        description: "New status for the task"
       },
-      addBlockedBy: {
-        type: "array",
-        items: { type: "string" },
-        description: "Task IDs to append to this task's 'blockedBy' list (tasks that must finish before this one can start)."
+      subject: {
+        description: "New subject for the task",
+        type: "string"
       },
-      metadata: {
-        type: "object",
-        description: "Metadata keys to merge into the existing metadata bag (existing keys are preserved; matching keys are overwritten).",
-        additionalProperties: { type: "string" }
+      taskId: {
+        description: "The ID of the task to update",
+        type: "string"
       }
     },
     required: ["taskId"],
-    additionalProperties: false,
-    $schema: "http://json-schema.org/draft-07/schema#"
+    type: "object"
   };
 });
 
@@ -231516,6 +231670,52 @@ var init_engine_javascript = __esm(() => {
 });
 
 // src/cli/components/SyntaxHighlightedCommand.tsx
+function getShikiHighlighter() {
+  if (shikiHighlighter === null) {
+    shikiHighlighter = createHighlighterCoreSync({
+      themes: [catppuccin_mocha_default, catppuccin_latte_default],
+      langs: [
+        shellscript_default,
+        c_default,
+        cpp_default,
+        csharp_default,
+        css_default,
+        diff_default,
+        docker_default,
+        go_default,
+        graphql_default,
+        html_default,
+        ini_default,
+        java_default,
+        javascript_default,
+        json_default,
+        kotlin_default,
+        less_default,
+        lua_default,
+        make_default,
+        markdown_default,
+        perl_default,
+        php_default,
+        python_default,
+        r_default,
+        ruby_default,
+        rust_default,
+        scala_default,
+        scss_default,
+        sql_default,
+        swift_default,
+        toml_default,
+        tsx_default,
+        typescript_default,
+        wasm_default,
+        xml_default,
+        yaml_default
+      ],
+      engine: createJavaScriptRegexEngine()
+    });
+  }
+  return shikiHighlighter;
+}
 function clipStyledSpans(spans, maxColumns) {
   if (maxColumns <= 0) {
     return { spans: [], clipped: spans.length > 0 };
@@ -231594,7 +231794,7 @@ function highlightFullBash(command) {
 }
 function highlightCode(code2, language) {
   try {
-    const result = shikiHighlighter.codeToTokens(code2, {
+    const result = getShikiHighlighter().codeToTokens(code2, {
       lang: language,
       theme: colors.shellSyntax === colors.shellSyntaxLight ? "catppuccin-latte" : "catppuccin-mocha"
     });
@@ -231606,7 +231806,7 @@ function highlightCode(code2, language) {
     return;
   }
 }
-var import_react23, jsx_dev_runtime4, shikiHighlighter, BASH_LANGUAGE = "bash", FIRST_LINE_PROMPT = "$", PROMPT_COLUMN_WIDTH = 2, EXT_TO_LANG, HEREDOC_RE, REDIRECT_FILE_RE, SyntaxHighlightedCommand;
+var import_react23, jsx_dev_runtime4, shikiHighlighter = null, BASH_LANGUAGE = "bash", FIRST_LINE_PROMPT = "$", PROMPT_COLUMN_WIDTH = 2, EXT_TO_LANG, HEREDOC_RE, REDIRECT_FILE_RE, SyntaxHighlightedCommand;
 var init_SyntaxHighlightedCommand = __esm(async () => {
   init_bash2();
   init_c();
@@ -231654,47 +231854,6 @@ var init_SyntaxHighlightedCommand = __esm(async () => {
   ]);
   import_react23 = __toESM(require_react(), 1);
   jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
-  shikiHighlighter = createHighlighterCoreSync({
-    themes: [catppuccin_mocha_default, catppuccin_latte_default],
-    langs: [
-      shellscript_default,
-      c_default,
-      cpp_default,
-      csharp_default,
-      css_default,
-      diff_default,
-      docker_default,
-      go_default,
-      graphql_default,
-      html_default,
-      ini_default,
-      java_default,
-      javascript_default,
-      json_default,
-      kotlin_default,
-      less_default,
-      lua_default,
-      make_default,
-      markdown_default,
-      perl_default,
-      php_default,
-      python_default,
-      r_default,
-      ruby_default,
-      rust_default,
-      scala_default,
-      scss_default,
-      sql_default,
-      swift_default,
-      toml_default,
-      tsx_default,
-      typescript_default,
-      wasm_default,
-      xml_default,
-      yaml_default
-    ],
-    engine: createJavaScriptRegexEngine()
-  });
   EXT_TO_LANG = {
     ts: "typescript",
     tsx: "typescript",
@@ -266212,7 +266371,7 @@ function addTask(input) {
   return withLock(() => {
     const data = readCronFile();
     const agentId = input.agent_id;
-    const conversationId = input.conversation_id ?? "default";
+    const conversationId = input.conversation_id ?? "new";
     const activeCount = data.tasks.filter((t2) => t2.agent_id === agentId && t2.status === "active").length;
     if (activeCount >= MAX_ACTIVE_TASKS_PER_AGENT) {
       throw new Error(`Agent ${agentId} has ${activeCount} active tasks (max ${MAX_ACTIVE_TASKS_PER_AGENT}). Delete some before adding more.`);
@@ -267771,6 +267930,7 @@ var init_cron = __esm(async () => {
 // src/backend/api/environments.ts
 var exports_environments2 = {};
 __export(exports_environments2, {
+  teleportToEnvironment: () => teleportToEnvironment,
   sendEnvironmentMessage: () => sendEnvironmentMessage,
   resolveEnvironmentConnectionId: () => resolveEnvironmentConnectionId,
   resolveAgentSandboxConnectionId: () => resolveAgentSandboxConnectionId,
@@ -267780,6 +267940,7 @@ __export(exports_environments2, {
   describeEnvironment: () => describeEnvironment,
   createAgentSandbox: () => createAgentSandbox
 });
+import { randomUUID as randomUUID25 } from "node:crypto";
 async function listEnvironments(options3 = {}) {
   return apiRequest("GET", "/v1/environments", undefined, {
     query: {
@@ -267861,6 +268022,12 @@ async function resolveAgentSandboxConnectionId(agentId, options3 = {}) {
   }
   throw new Error(`Timed out waiting for cloud sandbox ${sandbox.connectionName} to register${lastError instanceof Error ? `: ${lastError.message}` : ""}`);
 }
+async function teleportToEnvironment(agentId, conversationId, targetConnectionId, request = apiRequest) {
+  return request("POST", `/v1/environments/runtimes/${encodeURIComponent(agentId)}/${encodeURIComponent(conversationId)}/teleport`, {
+    targetConnectionId,
+    idempotencyKey: randomUUID25()
+  });
+}
 var init_environments2 = __esm(() => {
   init_request();
 });
@@ -267984,6 +268151,27 @@ var init_cron_runner = __esm(() => {
   init_environments2();
 });
 
+// src/cli/subcommands/cron-scope.ts
+function resolveCronAgentId(fromArgs) {
+  return fromArgs || process.env.LETTA_AGENT_ID || "";
+}
+function resolveConversationAlias(fromArgs) {
+  if (fromArgs !== "self")
+    return fromArgs;
+  const current = process.env.LETTA_CONVERSATION_ID?.trim();
+  if (current)
+    return current;
+  console.error("Error: --conversation self requires an active conversation (LETTA_CONVERSATION_ID is not set).");
+  return null;
+}
+function resolveCronAddConversationTarget(fromArgs) {
+  const resolved = resolveConversationAlias(fromArgs);
+  return resolved === undefined ? "new" : resolved;
+}
+function resolveCronConversationFilter(fromArgs) {
+  return resolveConversationAlias(fromArgs);
+}
+
 // src/cli/subcommands/cron-task-ref.ts
 async function ensureSettingsForCloud() {
   const { settingsManager: settingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), exports_settings_manager));
@@ -268057,7 +268245,9 @@ Add options:
   --once                 Fire once (with --at); default for --at
   --cron <expr>          Raw 5-field cron expression
   --agent <id>           Agent ID (defaults to LETTA_AGENT_ID)
-  --conversation <id>    Conversation ID (defaults to LETTA_CONVERSATION_ID or "default")
+  --conversation <id>    Conversation target (omit or "new" for a fresh
+                         conversation per fire; "self" for the current
+                         conversation; "default" for the agent default)
   --runner <runner>      Where the schedule lives and fires (normally omit:
                          the default keeps the schedule running where it was
                          created):
@@ -268097,12 +268287,6 @@ function parseCronArgs(argv) {
     allowPositionals: true
   });
 }
-function getAgentId3(fromArgs) {
-  return fromArgs || process.env.LETTA_AGENT_ID || "";
-}
-function getConversationId3(fromArgs) {
-  return fromArgs || process.env.LETTA_CONVERSATION_ID || "default";
-}
 async function probeCloudScheduleSupport(agentId) {
   try {
     await listCloudSchedules(agentId, { limit: 1 });
@@ -268183,12 +268367,14 @@ async function handleAdd(values2) {
     console.error("Error: --prompt is required.");
     return 1;
   }
-  const agentId = getAgentId3(values2.agent);
+  const agentId = resolveCronAgentId(values2.agent);
   if (!agentId) {
     console.error("Error: --agent or LETTA_AGENT_ID required.");
     return 1;
   }
-  const conversationId = getConversationId3(values2.conversation);
+  const conversationId = resolveCronAddConversationTarget(values2.conversation);
+  if (conversationId === null)
+    return 1;
   const everyValue = values2.every;
   const atValue = values2.at;
   const cronValue = values2.cron;
@@ -268378,7 +268564,9 @@ async function handleList(values2) {
     return 1;
   }
   const agentId = values2.agent || process.env.LETTA_AGENT_ID || undefined;
-  const conversationId = values2.conversation || undefined;
+  const conversationId = resolveCronConversationFilter(values2.conversation);
+  if (conversationId === null)
+    return 1;
   const includeLocal = values2.runner !== "cloud";
   const includeCloud = values2.runner !== "local";
   const output = [];
@@ -268434,7 +268622,7 @@ async function handleGet(values2, positionals) {
     console.error("Error: task ID or name required. Usage: letta cron get <id|name>");
     return 1;
   }
-  const agentId = getAgentId3(values2.agent);
+  const agentId = resolveCronAgentId(values2.agent);
   if (values2.runner !== "cloud") {
     const task2 = getTask2(taskRef);
     if (task2) {
@@ -268516,7 +268704,7 @@ async function handleRuns(values2) {
     console.error(`Error: task ${id2} not found.`);
     return 1;
   }
-  const agentId = getAgentId3(values2.agent);
+  const agentId = resolveCronAgentId(values2.agent);
   if (!agentId) {
     console.error(`Error: task ${id2} not found locally, and --agent or LETTA_AGENT_ID is required to look up Cloud schedule runs.`);
     return 1;
@@ -268555,7 +268743,7 @@ async function handleDelete(values2, positionals) {
       return 0;
     }
   }
-  const agentId = getAgentId3(values2.agent);
+  const agentId = resolveCronAgentId(values2.agent);
   if (values2.runner !== "local") {
     if (!agentId) {
       console.error(`Error: task ${taskRef} not found locally, and --agent or LETTA_AGENT_ID is required to delete Cloud schedules.`);
@@ -268604,7 +268792,7 @@ async function handleDelete(values2, positionals) {
   return 1;
 }
 async function handleDeleteAll(values2) {
-  const agentId = getAgentId3(values2.agent);
+  const agentId = resolveCronAgentId(values2.agent);
   if (!agentId) {
     console.error("Error: --agent or LETTA_AGENT_ID required with --all.");
     return 1;
@@ -273068,7 +273256,7 @@ var init_dream_targets = __esm(() => {
 
 // src/agent/memory-worktree.ts
 import { execFile as execFileCb4 } from "node:child_process";
-import { randomUUID as randomUUID25 } from "node:crypto";
+import { randomUUID as randomUUID26 } from "node:crypto";
 import { existsSync as existsSync42 } from "node:fs";
 import { mkdir as mkdir13 } from "node:fs/promises";
 import { dirname as dirname26, isAbsolute as isAbsolute25, join as join60, resolve as resolve31 } from "node:path";
@@ -273112,7 +273300,7 @@ function normalizeGitPath(path32, cwd2) {
 }
 function buildReflectionWorktreeId(now = new Date) {
   const timestamp = now.toISOString().replace(/[^0-9]/g, "").slice(0, 14);
-  return `${timestamp}-${randomUUID25().slice(0, 8)}`;
+  return `${timestamp}-${randomUUID26().slice(0, 8)}`;
 }
 function summarizeReflectionCommitSubject(subject) {
   const summary = subject.trim().replace(/^[a-z]+(?:\([^)]+\))?!?:\s*/i, "").trim();
@@ -273397,6 +273585,23 @@ var init_memory_worktree = __esm(() => {
   };
 });
 
+// src/backend/api/reflection.ts
+function agentPath(agentId) {
+  return `/v1/agents/${encodeURIComponent(agentId)}`;
+}
+async function retrieveCloudReflectionConfig(agentId, request = apiRequest) {
+  return request("GET", `${agentPath(agentId)}/reflection`);
+}
+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/memory-subagent-completion.ts
 async function handleMemorySubagentCompletion(args, deps) {
   const { agentId, conversationId, subagentType, success: success2, error: error54 } = args;
@@ -273456,20 +273661,6 @@ 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);
@@ -273587,7 +273778,7 @@ ${instructions}
 }
 
 // src/telemetry/reflection-threshold-feedback.ts
-import { randomUUID as randomUUID26 } from "node:crypto";
+import { randomUUID as randomUUID27 } from "node:crypto";
 async function resolveFeedbackApiKey() {
   const settings3 = await settingsManager.getSettingsWithSecureTokens();
   return process.env.LETTA_API_KEY || settings3.env?.LETTA_API_KEY;
@@ -273599,7 +273790,7 @@ function getFeedbackDeviceId() {
       return deviceId;
     }
   } catch {}
-  return randomUUID26();
+  return randomUUID27();
 }
 function getAlertDeviceType() {
   switch (process.platform) {
@@ -273721,6 +273912,8 @@ function getReflectionFinalizationContext(agentId) {
 }
 function getReflectionLaunchSkippedMessage(reason, surface = "cli") {
   switch (reason) {
+    case "cutover":
+      return "Reflection is managed by Letta Cloud for this agent.";
     case "already_active":
       return surface === "listener" ? "A reflection agent is already running for this conversation." : "A reflection agent is already running in the background.";
     case "memfs_disabled":
@@ -274008,7 +274201,18 @@ async function finalizeReflectionMemoryWorktreeLaunch(params) {
     integrationConversationId: integrationRun?.conversationId
   };
 }
-async function launchReflectionSubagent(options3) {
+async function isReflectionCutover(agentId) {
+  try {
+    if (!await isLettaCloud())
+      return false;
+    const config3 = await retrieveCloudReflectionConfig(agentId);
+    return config3.cutover === true;
+  } catch (error54) {
+    debugWarn("memory", `Failed to check Cloud reflection cutover: ${error54 instanceof Error ? error54.message : String(error54)}`);
+    return false;
+  }
+}
+async function launchReflectionSubagent(options3, dependencies4 = {}) {
   const {
     agentId,
     conversationId,
@@ -274023,6 +274227,10 @@ async function launchReflectionSubagent(options3) {
   if (!memfsEnabled) {
     return { launched: false, reason: "memfs_disabled" };
   }
+  if (await (dependencies4.isCutover ?? isReflectionCutover)(agentId)) {
+    debugLog("memory", `Skipping reflection launch (${triggerSource}) because server-side reflection owns this agent`);
+    return { launched: false, reason: "cutover" };
+  }
   if (!tryReserveReflectionLaunch(agentId)) {
     debugLog("memory", `Skipping reflection launch (${triggerSource}) because one is already active`);
     if (reservedReflectionAgentIds.has(agentId)) {
@@ -274160,6 +274368,7 @@ var init_reflection_launcher = __esm(() => {
   init_memory_worktree();
   init_subagent_state();
   init_backend2();
+  init_reflection2();
   init_memory_reminder();
   init_memory_subagent_completion();
   init_reflection_completion();
@@ -276828,7 +277037,7 @@ var init_auth = __esm(() => {
 });
 
 // src/websocket/listener/manual-instance-lock.ts
-import { createHash as createHash7, randomUUID as randomUUID27 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID28 } from "node:crypto";
 import { link as link3, mkdir as mkdir14, readFile as readFile20, rm as rm9, unlink as unlink5, writeFile as writeFile15 } from "node:fs/promises";
 import { homedir as homedir36 } from "node:os";
 import path32 from "node:path";
@@ -276879,7 +277088,7 @@ function parseLockRecord(raw2, expectedScopeHash) {
   }
 }
 async function publishInitializedFile(targetPath, contents) {
-  const candidatePath = path32.join(path32.dirname(targetPath), `.manual-listener-lock-${randomUUID27()}.candidate`);
+  const candidatePath = path32.join(path32.dirname(targetPath), `.manual-listener-lock-${randomUUID28()}.candidate`);
   let publicationError;
   try {
     await writeFile15(candidatePath, contents, { flag: "wx" });
@@ -276956,7 +277165,7 @@ async function acquireManualListenerLock(scope, overrides = {}) {
   const deps = {
     lockRoot: getDefaultLockRoot(),
     processId: process.pid,
-    ownerToken: randomUUID27(),
+    ownerToken: randomUUID28(),
     isProcessAlive: defaultIsProcessAlive2,
     ...overrides
   };
@@ -277467,18 +277676,10 @@ function isExternalToolCallResponseCommand(value) {
   return Array.isArray(value.result.content) && value.result.content.every(isRecord7) && (value.result.is_error === undefined || typeof value.result.is_error === "boolean");
 }
 
-// src/websocket/listener/protocol-inbound.ts
-function isExperimentId(value) {
-  return typeof value === "string" && EXPERIMENT_IDS.has(value);
-}
+// src/websocket/listener/protocol-validation.ts
 function isStringArray8(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function isClientToolsetConfig(value) {
-  if (!isObjectRecord2(value))
-    return false;
-  return (value.base === undefined || typeof value.base === "string" && TOOLSET_PREFERENCES.has(value.base)) && (value.include === undefined || isStringArray8(value.include));
-}
 function isStringRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
 }
@@ -277486,12 +277687,43 @@ function isObjectRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isRuntimeScope2(value) {
-  if (!value || typeof value !== "object") {
+  if (!value || typeof value !== "object")
     return false;
-  }
   const candidate = value;
   return typeof candidate.agent_id === "string" && candidate.agent_id.length > 0 && typeof candidate.conversation_id === "string" && candidate.conversation_id.length > 0;
 }
+
+// src/websocket/listener/teleport-protocol-inbound.ts
+function isTeleportContinuePayload(value) {
+  if (!isObjectRecord2(value) || !isObjectRecord2(value.source))
+    return false;
+  return value.kind === "teleport_continue" && typeof value.teleport_id === "string" && value.teleport_id.length > 0 && typeof value.source.device_id === "string" && typeof value.source.connection_name === "string" && (value.continuation === undefined || isObjectRecord2(value.continuation) && Array.isArray(value.continuation.approvals));
+}
+function parseTeleportCommand(value) {
+  if (!isObjectRecord2(value) || !isRuntimeScope2(value.runtime))
+    return null;
+  if (value.type === "teleport_probe" && typeof value.request_id === "string") {
+    return value;
+  }
+  if (value.type === "teleport_request" && typeof value.request_id === "string" && typeof value.teleport_id === "string" && isObjectRecord2(value.target) && typeof value.target.connection_id === "string" && typeof value.target.device_id === "string" && typeof value.target.connection_name === "string") {
+    return value;
+  }
+  if (value.type === "teleport_failed" && typeof value.teleport_id === "string" && typeof value.error === "string") {
+    return value;
+  }
+  return null;
+}
+var init_teleport_protocol_inbound = () => {};
+
+// src/websocket/listener/protocol-inbound.ts
+function isExperimentId(value) {
+  return typeof value === "string" && EXPERIMENT_IDS.has(value);
+}
+function isClientToolsetConfig(value) {
+  if (!isObjectRecord2(value))
+    return false;
+  return (value.base === undefined || typeof value.base === "string" && TOOLSET_PREFERENCES.has(value.base)) && (value.include === undefined || isStringArray8(value.include));
+}
 function isInputCommand(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -277513,6 +277745,9 @@ function isInputCommand(value) {
   if (payload.kind === "approval_response") {
     return isValidApprovalResponseBody(payload);
   }
+  if (payload.kind === "teleport_continue") {
+    return isTeleportContinuePayload(payload);
+  }
   return false;
 }
 function legacyEnvironmentMessageToInputCommand(value) {
@@ -277602,6 +277837,15 @@ function getInvalidInputReason(value) {
     }
     return null;
   }
+  if (payload.kind === "teleport_continue") {
+    if (!isTeleportContinuePayload(payload)) {
+      return {
+        runtime: candidate.runtime,
+        reason: "Protocol violation: input.kind=teleport_continue requires teleport_id, source, and optional continuation.approvals[]"
+      };
+    }
+    return null;
+  }
   return {
     runtime: candidate.runtime,
     reason: `Unsupported input payload kind: ${String(payload.kind)}`
@@ -278234,6 +278478,9 @@ function parseServerMessage(data) {
     if (legacyInput) {
       return legacyInput;
     }
+    const teleportCommand = parseTeleportCommand(parsed);
+    if (teleportCommand)
+      return teleportCommand;
     if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isRuntimeStartCommand(parsed) || isRuntimeExternalToolsUpdateCommand(parsed) || isExternalToolCallResponseCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isGrepInFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isGetTreeCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isFileOpsCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isMemoryCommitDiffCommand(parsed) || isReadMemoryFileCommand(parsed) || isWriteMemoryFileCommand(parsed) || isDeleteMemoryFileCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isListConnectProvidersCommand(parsed) || isConnectProviderCommand(parsed) || isDisconnectProviderCommand(parsed) || isChatGPTUsageReadCommand(parsed) || isUpdateModelCommand(parsed) || isUpdateToolsetCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronRunsCommand(parsed) || isCronTriggerCommand(parsed) || isCronUpdateCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isAppServerInfoCommand(parsed) || isCreateAgentCommand(parsed) || isAgentListCommand(parsed) || isAgentRetrieveCommand(parsed) || isAgentCreateCommand(parsed) || isAgentUpdateCommand(parsed) || isAgentDeleteCommand(parsed) || isConversationListCommand(parsed) || isConversationRetrieveCommand(parsed) || isConversationCreateCommand(parsed) || isConversationUpdateCommand(parsed) || isConversationRecompileCommand(parsed) || isConversationForkCommand(parsed) || isConversationMessagesListCommand(parsed) || isConversationCompactCommand(parsed) || isGetCwdMapCommand(parsed) || isGetExperimentsCommand(parsed) || isSetExperimentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isChannelsListCommand(parsed) || isChannelAccountsListCommand(parsed) || isChannelAccountCreateCommand(parsed) || isChannelAccountUpdateCommand(parsed) || isChannelAccountBindCommand(parsed) || isChannelAccountUnbindCommand(parsed) || isChannelAccountDeleteCommand(parsed) || isChannelAccountStartCommand(parsed) || isChannelAccountStopCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelTargetsListCommand(parsed) || isChannelTargetBindCommand(parsed) || isChannelRouteUpdateCommand(parsed) || isChannelRouteRemoveCommand(parsed) || isExecuteCommandCommand(parsed) || isRemoveQueueItemCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed) || isSecretListCommand(parsed) || isSecretApplyCommand(parsed)) {
       return parsed;
     }
@@ -278256,6 +278503,7 @@ var init_protocol_inbound = __esm(() => {
   init_skill_sources();
   init_channel_service_validation();
   init_approval();
+  init_teleport_protocol_inbound();
   EXPERIMENT_IDS = new Set([
     "conversation_titles",
     "desktop_conversation_bootstrap",
@@ -279937,80 +280185,6 @@ var init_toolset_labels = __esm(() => {
   };
 });
 
-// src/mods/capabilities.ts
-function isModCapabilityId(value) {
-  return MOD_CAPABILITY_ID_SET.has(value);
-}
-function cloneModCapabilities(capabilities) {
-  return {
-    tools: capabilities.tools,
-    commands: capabilities.commands,
-    events: {
-      lifecycle: capabilities.events.lifecycle,
-      tools: capabilities.events.tools,
-      turns: capabilities.events.turns,
-      compact: capabilities.events.compact,
-      llm: capabilities.events.llm
-    },
-    permissions: capabilities.permissions,
-    providers: capabilities.providers,
-    ui: {
-      panels: capabilities.ui.panels
-    }
-  };
-}
-function resolveModCapabilities(capabilities) {
-  return cloneModCapabilities(capabilities ?? DEFAULT_MOD_CAPABILITIES);
-}
-var MOD_CAPABILITY_IDS, MOD_CAPABILITY_ID_SET, DEFAULT_MOD_CAPABILITIES, DISABLED_MOD_CAPABILITIES;
-var init_capabilities = __esm(() => {
-  MOD_CAPABILITY_IDS = [
-    "tools",
-    "commands",
-    "providers",
-    "permissions",
-    "events.lifecycle",
-    "events.turns",
-    "events.tools",
-    "events.compact",
-    "events.llm",
-    "ui.panels"
-  ];
-  MOD_CAPABILITY_ID_SET = new Set(MOD_CAPABILITY_IDS);
-  DEFAULT_MOD_CAPABILITIES = {
-    tools: true,
-    commands: true,
-    events: {
-      lifecycle: true,
-      tools: true,
-      turns: true,
-      compact: true,
-      llm: true
-    },
-    permissions: true,
-    providers: true,
-    ui: {
-      panels: true
-    }
-  };
-  DISABLED_MOD_CAPABILITIES = {
-    tools: false,
-    commands: false,
-    events: {
-      lifecycle: false,
-      tools: false,
-      turns: false,
-      compact: false,
-      llm: false
-    },
-    permissions: false,
-    providers: false,
-    ui: {
-      panels: false
-    }
-  };
-});
-
 // src/mods/disabled-mod-adapter.ts
 function createDisabledModRegistry() {
   return {
@@ -451180,8 +451354,12 @@ function createModAdapter(options3) {
     }
     return createDisabledModAdapter();
   }
+  const effectiveEngineOptions = {
+    ...engineOptions,
+    capabilities: resolveProcessModCapabilities(engineOptions.capabilities)
+  };
   let disposed = false;
-  const initialHasModSources = hasModSources(engineOptions);
+  const initialHasModSources = hasModSources(effectiveEngineOptions);
   let loadState = {
     hadModPanels: false,
     hasModSources: initialHasModSources,
@@ -451191,7 +451369,7 @@ function createModAdapter(options3) {
   let diagnosticsWriteTimer = null;
   const getBackend2 = () => resolveBackend?.();
   const engine4 = createModEngine({
-    ...engineOptions,
+    ...effectiveEngineOptions,
     getBackend: getBackend2,
     onDiagnostic: () => scheduleDiagnosticsWrite()
   });
@@ -451261,7 +451439,7 @@ function createModAdapter(options3) {
     const previousHadModPanels = Object.keys(previousSnapshot.ui.panels).length > 0 || loadState.hadModPanels;
     loadState = {
       hadModPanels: previousHadModPanels,
-      hasModSources: hasModSources(engineOptions),
+      hasModSources: hasModSources(effectiveEngineOptions),
       isLoading: true
     };
     publish();
@@ -451317,6 +451495,7 @@ function createModAdapter(options3) {
 }
 var RUNTIME_DIAGNOSTICS_WRITE_DELAY_MS = 30000;
 var init_mod_adapter = __esm(async () => {
+  init_capabilities();
   init_disabled_mod_adapter();
   init_mod_diagnostics_file();
   init_permission_registry();
@@ -457300,6 +457479,151 @@ var init_send = __esm(async () => {
   BUSY_RUN_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
+// src/websocket/listener/teleport.ts
+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 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,
+    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: 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: true });
+    }
+    return;
+  }
+  const pending = {
+    teleportId: command.teleport_id,
+    connectionId,
+    agentId: command.runtime.agent_id,
+    conversationId: command.runtime.conversation_id,
+    requestedAt: Date.now()
+  };
+  const conflicting = findPendingTeleportForRuntime(listener, pending.agentId, pending.conversationId);
+  if (conflicting) {
+    pendingTeleports.set(pending.teleportId, pending);
+    pending.readyAt = Date.now();
+    sendTeleportReady(listener, pending, {
+      success: false,
+      error: "Conversation already has a teleport pending"
+    });
+    retainTeleportForRecovery(listener, pending);
+    return;
+  }
+  pendingTeleports.set(pending.teleportId, pending);
+  const conversationRuntime = getConversationRuntime(listener, pending.agentId, pending.conversationId);
+  if (!conversationRuntime?.isProcessing) {
+    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;
+  const connection = params.listener.connections.get(pending.connectionId);
+  if (!connection || !isListenerTransportOpen(connection.writer))
+    return null;
+  pending.readyAt = Date.now();
+  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.lastStopReason !== "end_turn" || !runtime.agentId)
+    return;
+  const pending = claimPendingTeleportAtBoundary({
+    listener: runtime.listener,
+    agentId: runtime.agentId,
+    conversationId: runtime.conversationId
+  });
+  if (pending)
+    emitClaimedTeleportReady(runtime.listener, pending);
+}
+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;
+}
+var TELEPORT_RECOVERY_TTL_MS;
+var init_teleport = __esm(() => {
+  init_connection();
+  init_permission_mode();
+  init_protocol_outbound();
+  init_runtime();
+  init_transport();
+  TELEPORT_RECOVERY_TTL_MS = 5 * 60000;
+});
+
 // node_modules/diff/libesm/diff/base.js
 class Diff2 {
   diff(oldStr, newStr, options3 = {}) {
@@ -459691,6 +460015,27 @@ async function handleApprovalStop(params) {
   if (shouldInterrupt()) {
     return interruptTermination();
   }
+  const pendingTeleport = claimPendingTeleportAtBoundary({
+    listener: runtime.listener,
+    agentId,
+    conversationId,
+    continuation: { approvals: persistedExecutionResults }
+  });
+  if (pendingTeleport) {
+    clearPendingApprovalBatchIds(runtime, decisions.map((decision) => decision.approval));
+    return {
+      kind: "teleport",
+      pendingTeleport,
+      turnInput,
+      dequeuedBatchId,
+      pendingNormalizationInterruptedToolCallIds: [],
+      turnToolContextId,
+      lastExecutionResults,
+      lastExecutingToolCallIds,
+      lastNeedsUserInputToolCallIds,
+      lastApprovalContinuationAccepted: false
+    };
+  }
   let nextTurnInput = createTurnInputState([
     {
       type: "approval",
@@ -459790,6 +460135,7 @@ var init_turn_approval = __esm(async () => {
   init_protocol_outbound();
   init_secrets_sync();
   init_skill_injection();
+  init_teleport();
   init_transport();
   init_turn_input_state();
   init_turn_status();
@@ -459866,9 +460212,53 @@ var init_memory_git_sync = __esm(() => {
   init_debug();
 });
 
+// src/websocket/listener/channel-runtime-tools.ts
+async function publishChannelRuntimeToolsForTurn(listener, runtime) {
+  const handler = listener.serviceCommandHandler;
+  if (!handler)
+    return false;
+  try {
+    const response = await handler({ kind: "publish_runtime_tools", runtime });
+    if (response.kind === "runtime_tools_published") {
+      return response.transient;
+    }
+    debugWarn("listen", `ChannelGateway returned an unexpected tool publication response: ${response.kind}`);
+  } catch (error54) {
+    debugWarn("listen", `Failed to publish channel tools for ${runtime.agent_id}/${runtime.conversation_id}: ${error54 instanceof Error ? error54.message : String(error54)}`);
+  }
+  return false;
+}
+async function releaseChannelRuntimeToolsForTurn(listener, runtime) {
+  const handler = listener.serviceCommandHandler;
+  if (!handler)
+    return;
+  try {
+    const response = await handler({ kind: "release_runtime_tools", runtime });
+    if (response.kind === "runtime_tools_released")
+      return;
+    debugWarn("listen", `ChannelGateway returned an unexpected tool release response: ${response.kind}`);
+  } catch (error54) {
+    debugWarn("listen", `Failed to release channel tools for ${runtime.agent_id}/${runtime.conversation_id}: ${error54 instanceof Error ? error54.message : String(error54)}`);
+  }
+}
+var init_channel_runtime_tools = __esm(() => {
+  init_debug();
+});
+
 // src/websocket/listener/turn-cleanup.ts
 async function runListenerTurnCleanup(params) {
-  const { runtime, agentId, normalizedAgentId, conversationId } = params;
+  const { runtime, agentId, normalizedAgentId, conversationId, finalized } = params;
+  if (runtime.transientChannelRuntimeTools) {
+    if (agentId) {
+      await releaseChannelRuntimeToolsForTurn(runtime.listener, {
+        agent_id: agentId,
+        conversation_id: conversationId
+      });
+    }
+    runtime.transientChannelRuntimeTools = false;
+  }
+  if (!finalized)
+    return;
   pruneConversationPermissionModeStateIfDefault(runtime.listener, normalizedAgentId, conversationId);
   persistPermissionModeMapForRuntime(runtime.listener);
   emitDeviceStatusIfOpen(runtime, {
@@ -459889,6 +460279,7 @@ async function runListenerTurnCleanup(params) {
 var init_turn_cleanup = __esm(() => {
   init_memory_git_sync();
   init_settings_manager();
+  init_channel_runtime_tools();
   init_permission_mode();
   init_protocol_outbound();
 });
@@ -461219,6 +461610,13 @@ async function prepareListenerTurn(params) {
     inboundUserTranscriptLines = buildInboundUserTranscriptLines(currentInput);
   }
   const modAdapters = await ensureListenerModAdaptersForAgent(runtime.listener, agentId);
+  runtime.transientChannelRuntimeTools = await publishChannelRuntimeToolsForTurn(runtime.listener, {
+    agent_id: agentId,
+    conversation_id: conversationId
+  });
+  if (isInterrupted()) {
+    return { kind: "interrupted" };
+  }
   const listenerOptions = connectionId ? runtime.listener.connections.get(connectionId)?.options : runtime.listener.connections.values().next().value?.options;
   const environmentDeviceId = listenerOptions?.deviceId;
   const preparedToolContext = await prepareToolExecutionContextForScope({
@@ -461275,6 +461673,7 @@ var init_turn_setup = __esm(async () => {
   init_interactive_policy();
   init_debug();
   init_shell_context();
+  init_channel_runtime_tools();
   init_interrupts();
   init_turn_input_state();
   init_turn_transcript();
@@ -461294,6 +461693,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     await handleIncomingMessageInner(msg, socket, runtime, onStatusChange, connectionId, dequeuedBatchId, existingTurnLease);
   } finally {
     notifyTurnFinished(msg);
+    finishPendingTeleport(runtime);
   }
 }
 async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange, connectionId, dequeuedBatchId = `batch-direct-${crypto.randomUUID()}`, existingTurnLease) {
@@ -461303,12 +461703,8 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
   const normalizedAgentId = normalizeCwdAgentId(agentId);
   const turnWorkingDirectory = getConversationWorkingDirectory(runtime.listener, normalizedAgentId, conversationId);
   const turnPermissionModeState = getOrCreateConversationPermissionModeStateRef(runtime.listener, normalizedAgentId, conversationId);
+  let postStopApprovalRecoveryRetries = 0, llmApiErrorRetries = 0, emptyResponseRetries = 0, lastApprovalContinuationAccepted = false, activeDequeuedBatchId = dequeuedBatchId;
   const msgRunIds = [];
-  let postStopApprovalRecoveryRetries = 0;
-  let llmApiErrorRetries = 0;
-  let emptyResponseRetries = 0;
-  let lastApprovalContinuationAccepted = false;
-  let activeDequeuedBatchId = dequeuedBatchId;
   let lastExecutionResults = null;
   let lastExecutingToolCallIds = [];
   let lastNeedsUserInputToolCallIds = [];
@@ -461319,15 +461715,12 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
   if (connectionId) {
     runtime.activeConnectionId = connectionId;
   }
-  if (!runtime.turnLifecycle.isCurrent(turnLease)) {
+  if (!runtime.turnLifecycle.isCurrent(turnLease))
     throw new Error("Cannot continue a turn with a stale lifecycle lease");
-  }
   const turnAbortSignal = turnLease.signal;
   let finalizedByThisInvocation = false;
   const noteFinalization = (transition) => {
-    if (transition.finished) {
-      finalizedByThisInvocation = true;
-    }
+    finalizedByThisInvocation ||= transition.finished;
     return transition;
   };
   const finishTurn = (options3) => noteFinalization(finishListenerTurn(runtime, turnLease, {
@@ -461825,6 +462218,11 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       lastExecutingToolCallIds = approvalResult.lastExecutingToolCallIds;
       lastNeedsUserInputToolCallIds = approvalResult.lastNeedsUserInputToolCallIds;
       lastApprovalContinuationAccepted = approvalResult.lastApprovalContinuationAccepted;
+      if (approvalResult.kind === "teleport") {
+        const pending = approvalResult.pendingTeleport;
+        noteFinalization(finishTeleport(runtime, turnLease, pending));
+        return;
+      }
       if (approvalResult.kind === "interrupted") {
         if (runtime.turnLifecycle.isCurrent(turnLease)) {
           populateInterruptQueue(runtime, {
@@ -461948,14 +462346,13 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       runtime.activeConnectionId = null;
     }
     try {
-      if (finalizedByThisInvocation) {
-        await runListenerTurnCleanup({
-          runtime,
-          agentId,
-          normalizedAgentId,
-          conversationId
-        });
-      }
+      await runListenerTurnCleanup({
+        runtime,
+        agentId,
+        normalizedAgentId,
+        conversationId,
+        finalized: finalizedByThisInvocation
+      });
     } finally {
       releaseListenerTurnContext({ runtime, agentId, conversationId });
     }
@@ -461981,6 +462378,7 @@ var init_turn = __esm(async () => {
   init_recoverable_notices();
   init_runtime();
   init_skill_injection();
+  init_teleport();
   init_turn_cleanup();
   init_turn_context();
   init_turn_input_state();
@@ -466494,6 +466892,46 @@ function createListenerMessageHandler(params) {
       })) {
         return;
       }
+      if (parsed.type === "teleport_probe") {
+        handleTeleportProbe(parsed, socket, safeSocketSend);
+        return;
+      }
+      if (parsed.type === "teleport_request") {
+        handleTeleportRequest({
+          listener: runtime,
+          command: parsed,
+          connectionId
+        });
+        return;
+      }
+      if (parsed.type === "teleport_failed") {
+        const pending = takeFailedTeleport({
+          listener: runtime,
+          teleportId: parsed.teleport_id,
+          agentId: parsed.runtime.agent_id,
+          conversationId: parsed.runtime.conversation_id
+        });
+        const approvals = pending?.continuation?.approvals;
+        if (pending && approvals && approvals.length > 0) {
+          const scopedRuntime = getOrCreateScopedRuntime2(runtime, pending.agentId, pending.conversationId);
+          runDetachedListenerTask("teleport_failed", async () => {
+            await processIncomingMessage({
+              type: "message",
+              connectionId: pending.connectionId,
+              agentId: pending.agentId,
+              conversationId: pending.conversationId,
+              messages: [
+                {
+                  type: "approval",
+                  approvals,
+                  otid: crypto.randomUUID()
+                }
+              ]
+            }, socket, scopedRuntime, opts.onStatusChange, pending.connectionId);
+          });
+        }
+        return;
+      }
       if (parsed.type === "external_tool_call_response") {
         handleExternalToolCallResponseCommand(runtime, connectionId, parsed);
         return;
@@ -466575,6 +467013,42 @@ function createListenerMessageHandler(params) {
           acknowledgeInput(false, "Runtime is no longer active");
           return;
         }
+        if (parsed.payload.kind === "teleport_continue") {
+          const scopedRuntime2 = getOrCreateScopedRuntime2(runtime, parsed.runtime.agent_id, parsed.runtime.conversation_id);
+          const acceptedKey = `teleport:${parsed.payload.teleport_id}`;
+          const previousDisposition = scopedRuntime2.acceptedInputDispositions.get(acceptedKey);
+          if (previousDisposition) {
+            acknowledgeInput(true, undefined, previousDisposition);
+            return;
+          }
+          const approvals = parsed.payload.continuation?.approvals;
+          if (!approvals || approvals.length === 0) {
+            acknowledgeInput(true);
+            return;
+          }
+          if (scopedRuntime2.isProcessing) {
+            acknowledgeInput(false, "Destination runtime is already processing");
+            return;
+          }
+          scopedRuntime2.acceptedInputDispositions.set(acceptedKey, "started");
+          acknowledgeInput(true, undefined, "started");
+          runDetachedListenerTask("teleport_continue", async () => {
+            await processIncomingMessage({
+              type: "message",
+              connectionId,
+              agentId: parsed.runtime.agent_id,
+              conversationId: parsed.runtime.conversation_id,
+              messages: [
+                {
+                  type: "approval",
+                  approvals,
+                  otid: crypto.randomUUID()
+                }
+              ]
+            }, socket, scopedRuntime2, opts.onStatusChange, connectionId);
+          });
+          return;
+        }
         if (parsed.payload.kind === "approval_response") {
           const handled = await handleApprovalResponseInput2(runtime, {
             runtime: parsed.runtime,
@@ -466930,6 +467404,7 @@ var init_message_router = __esm(async () => {
   init_protocol_outbound();
   init_recoverable_notices();
   init_runtime();
+  init_teleport();
   await __promiseAll([
     init_commands2(),
     init_cron3(),
@@ -469163,7 +469638,7 @@ function createToolLifecycleTracker(onEvent) {
 }
 
 // src/websocket/app-server-openai-turn.ts
-import { randomUUID as randomUUID28 } from "node:crypto";
+import { randomUUID as randomUUID29 } from "node:crypto";
 function runBridgeTurn(params) {
   return runTurnImpl(params);
 }
@@ -469182,7 +469657,7 @@ async function ensureListenerRuntime(onLog) {
   if (active && !active.intentionallyClosed)
     return active;
   bridgeRuntimeStart ??= startLocalChannelListener({
-    connectionId: `openai-api-${randomUUID28()}`,
+    connectionId: `openai-api-${randomUUID29()}`,
     deviceId: settingsManager.getOrCreateDeviceId(),
     connectionName: "openai-api",
     onConnected: () => {},
@@ -469391,11 +469866,11 @@ var init_app_server_openai_turn = __esm(async () => {
 });
 
 // src/websocket/app-server-openai-responses.ts
-import { randomUUID as randomUUID29 } from "node:crypto";
+import { randomUUID as randomUUID30 } from "node:crypto";
 function createStoredResponseId(state) {
   const cursor = Buffer.from(JSON.stringify({
     version: 1,
-    nonce: randomUUID29(),
+    nonce: randomUUID30(),
     agent_id: state.agentId,
     conversation_id: state.conversationId
   })).toString("base64url");
@@ -469440,7 +469915,7 @@ function toBridgeMessages(messages, stateful) {
     return { messages: [], correlationOtid: null };
   }
   if (stateful) {
-    const otid = randomUUID29();
+    const otid = randomUUID30();
     return {
       messages: [{ role: "user", content: lastUserContent, otid }],
       correlationOtid: otid
@@ -469462,7 +469937,7 @@ function toBridgeMessages(messages, stateful) {
     bridgeMessages.push({
       role: message.role,
       content,
-      otid: randomUUID29()
+      otid: randomUUID30()
     });
   }
   return {
@@ -469594,7 +470069,7 @@ class ResponseOutputBuilder {
     this.finishText();
     const result = {
       type: "function_call_output",
-      id: `fco_${randomUUID29()}`,
+      id: `fco_${randomUUID30()}`,
       call_id: event2.tool_call_id,
       output: [{ type: "input_text", text: event2.output }],
       status: event2.success ? "completed" : "incomplete"
@@ -469679,7 +470154,7 @@ class ResponseOutputBuilder {
       return this.message;
     const item = {
       type: "message",
-      id: `msg_${randomUUID29()}`,
+      id: `msg_${randomUUID30()}`,
       status: "in_progress",
       role: "assistant",
       content: [{ type: "output_text", text: "", annotations: [] }]
@@ -469706,7 +470181,7 @@ class ResponseOutputBuilder {
       return this.reasoning;
     const item = {
       type: "reasoning",
-      id: `rs_${randomUUID29()}`,
+      id: `rs_${randomUUID30()}`,
       status: "in_progress",
       summary: [{ type: "summary_text", text: "" }]
     };
@@ -469737,7 +470212,7 @@ class ResponseOutputBuilder {
     }
     const item = {
       type: "function_call",
-      id: `fc_${randomUUID29()}`,
+      id: `fc_${randomUUID30()}`,
       call_id: callId,
       name,
       arguments: "",
@@ -469842,7 +470317,7 @@ async function handleResponses(request, response, options3) {
     sendOpenAiError(response, 500, "failed to create a conversation for this response", "server_error");
     return;
   }
-  const responseId = body3.store === true ? createStoredResponseId({ agentId: agent2.id, conversationId }) : `resp_${randomUUID29()}`;
+  const responseId = body3.store === true ? createStoredResponseId({ agentId: agent2.id, conversationId }) : `resp_${randomUUID30()}`;
   const createdAt = Math.floor(Date.now() / 1000);
   let sequenceNumber = 0;
   let clientClosed = false;
@@ -469932,7 +470407,7 @@ var init_app_server_openai_responses = __esm(async () => {
 });
 
 // src/websocket/app-server-openai.ts
-import { randomUUID as randomUUID30 } from "node:crypto";
+import { randomUUID as randomUUID31 } from "node:crypto";
 function isOpenAiCompatPath(pathname) {
   return pathname === MODELS_PATH || pathname === CHAT_COMPLETIONS_PATH || pathname === RESPONSES_PATH;
 }
@@ -470001,7 +470476,7 @@ async function handleChatCompletions(request, response, options3) {
       turnMessages.push({
         role: "user",
         content: userContent,
-        otid: randomUUID30()
+        otid: randomUUID31()
       });
     } else {
       for (const message of body3.messages) {
@@ -470018,7 +470493,7 @@ async function handleChatCompletions(request, response, options3) {
         }
         if (content.length === 0)
           continue;
-        turnMessages.push({ role: message.role, content, otid: randomUUID30() });
+        turnMessages.push({ role: message.role, content, otid: randomUUID31() });
       }
     }
     correlationOtid = turnMessages.at(-1)?.otid ?? null;
@@ -470027,7 +470502,7 @@ async function handleChatCompletions(request, response, options3) {
       return;
     }
   }
-  const completionId = `chatcmpl-${randomUUID30()}`;
+  const completionId = `chatcmpl-${randomUUID31()}`;
   const created = Math.floor(Date.now() / 1000);
   const streaming3 = body3.stream === true;
   let clientClosed = false;
@@ -471309,7 +471784,7 @@ var init_listen = __esm(async () => {
 });
 
 // src/backend/local/transcript-migration.ts
-import { randomUUID as randomUUID31 } from "node:crypto";
+import { randomUUID as randomUUID32 } from "node:crypto";
 import {
   copyFileSync as copyFileSync3,
   existsSync as existsSync52,
@@ -471349,7 +471824,7 @@ function writeSessionEntryJsonl(path44, messages, input) {
     ...messages.map((message) => {
       const entry = {
         type: "message",
-        id: randomUUID31().slice(0, 8),
+        id: randomUUID32().slice(0, 8),
         parentId,
         timestamp: message.metadata?.created_at ?? new Date(message.timestamp).toISOString(),
         message
@@ -471885,7 +472360,7 @@ Examples:
   letta memory tokens --memory-dir ~/.letta/agents/agent-123/memory --format json
 `.trim());
 }
-function getAgentId4(agentFromArgs, agentIdFromArgs) {
+function getAgentId3(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
 function parseMemoryArgs(argv) {
@@ -471958,7 +472433,7 @@ async function runMemorySubcommand(argv) {
     printUsage8();
     return 0;
   }
-  const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
+  const agentId = getAgentId3(parsed.values.agent, parsed.values["agent-id"]);
   if (action3 === "tokens") {
     return runMemoryTokensAction({
       memoryDir: parsed.values["memory-dir"],
@@ -472525,7 +473000,7 @@ function parseOrder(value) {
   }
   return;
 }
-function getAgentId5(agentFromArgs, agentIdFromArgs) {
+function getAgentId4(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
 function pageItems4(page) {
@@ -472686,7 +473161,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
       }
       const allAgents = parsed.values["all-agents"] ?? false;
       const explicitAgentId = parsed.values.agent || parsed.values["agent-id"] || "";
-      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
       const conversationId = parsed.values.conversation || parsed.values["conversation-id"];
       if (conversationId === "default") {
         if (!agentId) {
@@ -472717,7 +473192,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
       return 0;
     }
     if (action3 === "list") {
-      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
       const orderRaw = parsed.values.order;
       const order = parseOrder(orderRaw);
       if (orderRaw !== undefined && !order) {
@@ -472767,7 +473242,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
         console.error("Missing conversation id. Pass --conversation <id> or --conversation-id <id>.");
         return 1;
       }
-      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
       if (conversationId === "default" && !agentId) {
         console.error('Conversation "default" requires an agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.');
         return 1;
@@ -474261,6 +474736,10 @@ function resolveSandboxSession(env5, fallback) {
   }
   return session;
 }
+async function initializeSandboxSettings() {
+  await settingsManager.initialize();
+  await settingsManager.loadLocalProjectSettings();
+}
 async function runSandboxSubcommand(argv, deps = {}) {
   let parsed;
   try {
@@ -474281,7 +474760,7 @@ async function runSandboxSubcommand(argv, deps = {}) {
     return 1;
   }
   try {
-    await (deps.initializeSettings ?? (() => settingsManager.initialize()))();
+    await (deps.initializeSettings ?? initializeSandboxSettings)();
     if (!await (deps.isCloud ?? isLettaCloud)()) {
       throw new Error("Sandbox file transfer is only available on Letta Cloud");
     }
@@ -477590,6 +478069,155 @@ var init_skills4 = __esm(() => {
   };
 });
 
+// src/cli/subcommands/teleport.ts
+import { parseArgs as parseArgs17 } from "node:util";
+function printUsage15() {
+  console.log(`
+Usage:
+  letta teleport list
+  letta teleport cloud
+  letta teleport <environment>
+
+Notes:
+  - Operates on the current agent/conversation from LETTA_AGENT_ID /
+    LETTA_CONVERSATION_ID (or AGENT_ID / CONVERSATION_ID), falling back to the
+    last active session.
+  - Requires a Letta Cloud agent and a non-virtual conversation.
+  - list: prints accessible online remote environments as JSON.
+  - cloud: teleports to the agent's Cloud sandbox.
+  - <environment>: teleports to a specific remote environment by name,
+    device-id, connection-id, or environment id.
+  - Desktop Local is not a teleport target yet. Use the Desktop environment
+    picker to switch back to Local.
+  - Output is JSON only.
+`.trim());
+}
+function parseTeleportArgs(argv) {
+  return parseArgs17({
+    args: argv,
+    options: TELEPORT_OPTIONS,
+    strict: true,
+    allowPositionals: true
+  });
+}
+function getEnvironmentSession2(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 resolveTeleportSession(env5, fallback) {
+  const session = getEnvironmentSession2(env5) ?? fallback;
+  if (!session) {
+    throw new Error("No active agent conversation found");
+  }
+  if (isLocalAgentId(session.agentId)) {
+    throw new Error("Teleport requires a Letta Cloud agent");
+  }
+  if (!session.conversationId || session.conversationId === "default" || session.conversationId === "new") {
+    throw new Error("Teleport requires an active conversation");
+  }
+  return session;
+}
+function formatTeleportApiError(error54) {
+  if (error54 instanceof ApiRequestError) {
+    try {
+      const body3 = JSON.parse(error54.responseText);
+      if (typeof body3.message === "string" && body3.message.length > 0) {
+        return body3.message;
+      }
+      if (typeof body3.errorCode === "string" && body3.errorCode.length > 0) {
+        return body3.errorCode;
+      }
+    } catch {}
+    return `API error (${error54.status}): ${error54.responseText}`;
+  }
+  if (error54 instanceof Error) {
+    return error54.message;
+  }
+  return String(error54);
+}
+function formatEnvironmentForList(environment2) {
+  return {
+    deviceId: environment2.deviceId,
+    connectionName: environment2.connectionName,
+    connectionId: environment2.connectionId ?? null
+  };
+}
+function isTeleportableRemoteEnvironment(environment2) {
+  return environment2.organizationId !== "local" && !environment2.connectionId?.startsWith("local-");
+}
+function assertTeleportableRemoteEnvironment(environment2) {
+  if (!isTeleportableRemoteEnvironment(environment2)) {
+    throw new Error("Desktop Local is not a teleport target yet. Use the Desktop environment picker to switch back to Local.");
+  }
+}
+async function initializeTeleportSettings() {
+  await settingsManager.initialize();
+  await settingsManager.loadLocalProjectSettings();
+}
+async function runTeleportSubcommand(argv, deps = {}) {
+  let parsed;
+  try {
+    parsed = parseTeleportArgs(argv);
+  } catch (error54) {
+    console.error(`Error: ${error54 instanceof Error ? error54.message : error54}`);
+    printUsage15();
+    return 1;
+  }
+  const [action3] = parsed.positionals;
+  if (parsed.values.help || !action3 || action3 === "help") {
+    printUsage15();
+    return 0;
+  }
+  try {
+    await (deps.initializeSettings ?? initializeTeleportSettings)();
+    if (action3 === "list") {
+      const list = deps.listEnvironments ?? listEnvironments;
+      const result2 = await list({ limit: 100, onlineOnly: true });
+      const connections = result2.connections.filter((environment2) => isEnvironmentOnline(environment2) && isTeleportableRemoteEnvironment(environment2)).map(formatEnvironmentForList);
+      console.log(JSON.stringify({ ...result2, connections }, null, 2));
+      return 0;
+    }
+    const session = resolveTeleportSession(process.env, (deps.getLastSession ?? (() => settingsManager.getEffectiveLastSession()))());
+    let targetConnectionId;
+    if (action3 === "cloud") {
+      const resolve35 = deps.resolveAgentSandboxConnectionId ?? resolveAgentSandboxConnectionId;
+      const result2 = await resolve35(session.agentId, {
+        conversationId: session.conversationId
+      });
+      targetConnectionId = result2.connectionId;
+    } else if (action3 === "back") {
+      throw new Error("Teleport back is not supported yet. Use the Desktop environment picker to switch back to Local.");
+    } else {
+      const resolve35 = deps.resolveEnvironmentConnectionId ?? resolveEnvironmentConnectionId;
+      const resolved = await resolve35(action3);
+      assertTeleportableRemoteEnvironment(resolved.environment);
+      targetConnectionId = resolved.connectionId;
+    }
+    const teleport = deps.teleportToEnvironment ?? teleportToEnvironment;
+    const result = await teleport(session.agentId, session.conversationId, targetConnectionId);
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  } catch (error54) {
+    console.error(`Error: ${formatTeleportApiError(error54)}`);
+    return 1;
+  }
+}
+var TELEPORT_OPTIONS;
+var init_teleport2 = __esm(() => {
+  init_environments2();
+  init_request();
+  init_settings_manager();
+  TELEPORT_OPTIONS = {
+    help: { type: "boolean", short: "h" }
+  };
+});
+
 // src/cli/subcommands/trajectories/readers.ts
 import { readdir as readdir15, readFile as readFile26, stat as stat16 } from "node:fs/promises";
 import { join as join74 } from "node:path";
@@ -477975,8 +478603,8 @@ var init_review = () => {};
 
 // src/cli/subcommands/trajectories.ts
 import { readFile as readFile29 } from "node:fs/promises";
-import { parseArgs as parseArgs17 } from "node:util";
-function printUsage15() {
+import { parseArgs as parseArgs18 } from "node:util";
+function printUsage16() {
   console.log(`
 Usage:
   letta trajectories export [options]
@@ -478114,7 +478742,7 @@ ${results.length} session(s) matched "${keyword}"`);
   return 0;
 }
 function parseTrajectoriesArgs(argv) {
-  return parseArgs17({
+  return parseArgs18({
     args: argv,
     options: TRAJECTORIES_OPTIONS,
     strict: true,
@@ -478127,12 +478755,12 @@ async function runTrajectoriesSubcommand(argv) {
     parsed = parseTrajectoriesArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage15();
+    printUsage16();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || action3 === "help" || !action3) {
-    printUsage15();
+    printUsage16();
     return parsed.values.help || action3 === "help" ? 0 : 1;
   }
   const asJson = Boolean(parsed.values.json);
@@ -478164,7 +478792,7 @@ async function runTrajectoriesSubcommand(argv) {
   }
   if (action3 !== "export") {
     console.error(`Unknown command: ${action3}`);
-    printUsage15();
+    printUsage16();
     return 1;
   }
   const options3 = {
@@ -479457,20 +480085,9 @@ function listEligibleProactiveSlackAccounts(params) {
   if (!registry2) {
     return [];
   }
-  loadRoutes("slack");
-  const seen = new Set;
   const eligible = [];
-  for (const route of getRoutesForChannel("slack")) {
-    if (route.agentId !== params.agentId || route.conversationId !== params.conversationId || !route.enabled || route.outboundEnabled === false) {
-      continue;
-    }
-    const accountId = route.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID;
-    if (seen.has(accountId)) {
-      continue;
-    }
-    seen.add(accountId);
-    const account = getChannelAccount("slack", accountId);
-    if (!account || !isSlackChannelAccount(account) || account.agentId !== params.agentId) {
+  for (const account of listChannelAccounts("slack")) {
+    if (!account.enabled || !isSlackChannelAccount(account) || account.agentId !== params.agentId) {
       continue;
     }
     const adapter = registry2.getAdapter("slack", account.accountId);
@@ -479486,8 +480103,7 @@ function listEligibleProactiveSlackAccounts(params) {
 }
 function resolveEligibleProactiveSlackAccount(params) {
   const eligible = listEligibleProactiveSlackAccounts({
-    agentId: params.agentId,
-    conversationId: params.conversationId
+    agentId: params.agentId
   });
   if (params.accountId) {
     const matched = eligible.find(({ account }) => account.accountId === params.accountId);
@@ -479507,10 +480123,65 @@ function resolveEligibleProactiveSlackAccount(params) {
 var init_proactive_accounts = __esm(() => {
   init_accounts();
   init_registry();
-  init_routing();
   init_types8();
 });
 
+// src/channels/slack/proactive-route.ts
+function bindProactiveSlackThreadRoute(params) {
+  loadRoutes("slack");
+  const existing = getRouteRaw("slack", params.chatId, params.accountId, params.rootMessageId);
+  if (existing) {
+    if (existing.agentId === params.agentId && existing.conversationId === params.conversationId) {
+      return;
+    }
+    throw new Error(`Slack thread ${params.accountId}/${params.chatId}/${params.rootMessageId} is already routed to ${existing.agentId}/${existing.conversationId}`);
+  }
+  const now = new Date().toISOString();
+  try {
+    addRoute("slack", {
+      accountId: params.accountId,
+      chatId: params.chatId,
+      chatType: "channel",
+      threadId: params.rootMessageId,
+      agentId: params.agentId,
+      conversationId: params.conversationId,
+      enabled: true,
+      outboundEnabled: true,
+      createdAt: now,
+      updatedAt: now
+    });
+  } catch (error54) {
+    removeRouteInMemory("slack", params.chatId, params.accountId, params.rootMessageId);
+    throw error54;
+  }
+}
+function createProactiveSlackTransport(params) {
+  return {
+    sendMessage: async (message) => {
+      const result = await params.adapter.sendMessage(message);
+      const isRootChannelPost = params.target.chatType === "channel" && !message.threadId?.trim() && !message.replyToMessageId?.trim() && !message.reaction;
+      if (isRootChannelPost && result.messageId.trim()) {
+        try {
+          bindProactiveSlackThreadRoute({
+            accountId: params.accountId,
+            chatId: params.target.chatId,
+            rootMessageId: result.messageId,
+            agentId: params.agentId,
+            conversationId: params.conversationId
+          });
+        } catch (error54) {
+          console.error(`[Channels] Failed to bind proactive Slack thread: ${error54 instanceof Error ? error54.message : String(error54)}`);
+          throw new Error(`Slack accepted message ${result.messageId}, but its thread route could not be persisted: ${error54 instanceof Error ? error54.message : String(error54)}`);
+        }
+      }
+      return result;
+    }
+  };
+}
+var init_proactive_route = __esm(() => {
+  init_routing();
+});
+
 // src/tools/impl/message-channel.ts
 function createLocalMessageChannelResolver() {
   return {
@@ -479546,7 +480217,6 @@ function createLocalMessageChannelResolver() {
       }
       const eligibleAccount = resolveEligibleProactiveSlackAccount({
         agentId: params.scope.agentId,
-        conversationId: params.scope.conversationId,
         accountId: params.accountId
       });
       if (typeof eligibleAccount === "string")
@@ -479564,7 +480234,13 @@ function createLocalMessageChannelResolver() {
       return {
         accountId: eligibleAccount.account.accountId,
         target: target2,
-        transport: eligibleAccount.adapter,
+        transport: createProactiveSlackTransport({
+          adapter: eligibleAccount.adapter,
+          accountId: eligibleAccount.account.accountId,
+          target: target2,
+          agentId: params.scope.agentId,
+          conversationId: params.scope.conversationId
+        }),
         messageActions
       };
     }
@@ -479593,6 +480269,7 @@ var init_message_channel = __esm(() => {
   init_plugin_registry();
   init_registry();
   init_proactive_accounts();
+  init_proactive_route();
 });
 
 // src/channels/channel-rich-draft-streamer.ts
@@ -480660,6 +481337,38 @@ class ChannelGateway {
       });
     });
   }
+  async publishRuntimeTools(runtime, sources = []) {
+    return await this.enqueueRegistration(async () => {
+      if (this.states.has(runtimeKey(runtime)))
+        return false;
+      const tool2 = await this.hooks.buildExternalTool(runtime, sources);
+      const response = await this.client.runtimeExternalToolsUpdate({
+        updates: [
+          {
+            runtimes: [runtime],
+            external_tools: tool2 ? [{ tools: [tool2] }] : []
+          }
+        ]
+      });
+      if (!response.success) {
+        throw new Error(response.error ?? "Failed to publish channel runtime tools");
+      }
+      return tool2 !== null;
+    });
+  }
+  async releaseRuntimeTools(runtime, routedSources = []) {
+    await this.enqueueRegistration(async () => {
+      if (routedSources.length > 0 || this.states.has(runtimeKey(runtime))) {
+        return;
+      }
+      const response = await this.client.runtimeExternalToolsUpdate({
+        updates: [{ runtimes: [runtime], external_tools: [] }]
+      });
+      if (!response.success) {
+        throw new Error(response.error ?? "Failed to release channel runtime tools");
+      }
+    });
+  }
   async submitApprovalResponse(runtime, response) {
     const result = await this.client.submitInput({
       runtime,
@@ -481268,29 +481977,37 @@ var init_message_tool = __esm(() => {
 });
 
 // src/channels/message-channel-gateway-tool.ts
-async function buildGatewayMessageChannelTool(sources) {
-  if (sources.length === 0)
-    return null;
+async function buildGatewayMessageChannelTool(sources, runtime) {
   const seen = new Set;
-  const channels = sources.map((source2) => ({
+  const channelScopes = (sources.length > 0 ? sources.map((source2) => ({
     channelId: source2.channel,
     accountId: source2.accountId ?? null
-  })).filter(({ channelId, accountId }) => {
+  })) : runtime ? listEligibleProactiveSlackAccounts({
+    agentId: runtime.agent_id
+  }).map(({ account }) => ({
+    channelId: "slack",
+    accountId: account.accountId
+  })) : []).filter(({ channelId, accountId }) => {
     const key2 = `${channelId}:${accountId ?? ""}`;
     if (seen.has(key2))
       return false;
     seen.add(key2);
     return true;
   });
+  if (channelScopes.length === 0)
+    return null;
   return buildMessageChannelExternalToolDefinition({
-    channels: await resolveLocalMessageChannelToolChannels({ channels }),
-    scoped: true,
+    channels: await resolveLocalMessageChannelToolChannels({
+      channels: channelScopes
+    }),
+    scoped: sources.length > 0,
     allowProactiveTargets: true
   });
 }
 var init_message_channel_gateway_tool = __esm(() => {
   init_message_channel_tool_definition();
   init_message_tool();
+  init_proactive_accounts();
 });
 
 // src/channels/custom/scaffolding.ts
@@ -482102,7 +482819,9 @@ function groupSourcesByRuntime(sources) {
   }
   return [...sourcesByRuntime.values()];
 }
-function toolScopeKey(sources) {
+function toolScopeKey(sources, runtime) {
+  if (sources.length === 0)
+    return `proactive:${runtime.agent_id}`;
   return JSON.stringify([
     ...new Set(sources.map((source2) => `${source2.channel}:${source2.accountId ?? ""}`))
   ].sort());
@@ -482111,13 +482830,20 @@ async function buildDesiredRegistrations(registry2, channelNames, buildTool, kno
   for (const channel of channelNames)
     loadRoutes(channel);
   const groupedSources = groupSourcesByRuntime(registry2.resolveRoutedTurnSources());
+  const sourcesByRuntime = new Map(groupedSources.map((entry) => [runtimeKey2(entry.runtime), entry]));
+  for (const runtime of knownRuntimes) {
+    const key2 = runtimeKey2(runtime);
+    if (!sourcesByRuntime.has(key2)) {
+      sourcesByRuntime.set(key2, { runtime, sources: [] });
+    }
+  }
   const desired = new Map;
   const toolsByScope = new Map;
-  await Promise.all(groupedSources.map(async ({ runtime, sources }) => {
-    const scopeKey = toolScopeKey(sources);
+  await Promise.all([...sourcesByRuntime.values()].map(async ({ runtime, sources }) => {
+    const scopeKey = toolScopeKey(sources, runtime);
     let toolPromise = toolsByScope.get(scopeKey);
     if (!toolPromise) {
-      toolPromise = buildTool(sources);
+      toolPromise = buildTool(sources, runtime);
       toolsByScope.set(scopeKey, toolPromise);
     }
     const tool2 = await toolPromise;
@@ -482129,18 +482855,6 @@ async function buildDesiredRegistrations(registry2, channelNames, buildTool, kno
       signature: JSON.stringify(externalTools)
     });
   }));
-  for (const runtime of knownRuntimes) {
-    const key2 = runtimeKey2(runtime);
-    if (desired.has(key2))
-      continue;
-    const externalTools = [];
-    desired.set(key2, {
-      runtime,
-      sources: [],
-      externalTools,
-      signature: JSON.stringify(externalTools)
-    });
-  }
   return desired;
 }
 function buildUpdateGroups(desired, publishedSignatures) {
@@ -482467,8 +483181,8 @@ async function startLocalChannelGateway(options3) {
         dispose: () => streamer.dispose()
       } : null;
     },
-    buildExternalTool: async (runtime) => {
-      return buildGatewayMessageChannelTool(registry2.resolveTurnSourcesForScope(runtime.agent_id, runtime.conversation_id));
+    buildExternalTool: async (runtime, sources) => {
+      return buildGatewayMessageChannelTool(sources, runtime);
     },
     executeExternalTool: async (request2, sources, idempotencyScope) => {
       if (request2.tool_name !== "MessageChannel" || !request2.runtime) {
@@ -482743,7 +483457,17 @@ async function startLocalChannelGateway(options3) {
     executeCommand: async (command) => {
       let result;
       try {
-        result = await executeGatewayServiceCommand(command);
+        if (command.kind === "publish_runtime_tools") {
+          const sources = registry2.resolveTurnSourcesForScope(command.runtime.agent_id, command.runtime.conversation_id);
+          const transient = await gateway.publishRuntimeTools(command.runtime, sources);
+          result = { kind: "runtime_tools_published", transient };
+        } else if (command.kind === "release_runtime_tools") {
+          const sources = registry2.resolveTurnSourcesForScope(command.runtime.agent_id, command.runtime.conversation_id);
+          await gateway.releaseRuntimeTools(command.runtime, sources);
+          result = { kind: "runtime_tools_released" };
+        } else {
+          result = await executeGatewayServiceCommand(command);
+        }
       } catch (error54) {
         routedRuntimeRegistrationRefresher.requestRefresh();
         throw error54;
@@ -482789,14 +483513,14 @@ var exports_channel_gateway = {};
 __export(exports_channel_gateway, {
   runChannelGatewaySubcommand: () => runChannelGatewaySubcommand
 });
-import { parseArgs as parseArgs18 } from "node:util";
+import { parseArgs as parseArgs19 } 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 } = parseArgs18({
+    ({ values: values2 } = parseArgs19({
       args: argv,
       strict: true,
       allowPositionals: false,
@@ -482936,6 +483660,7 @@ function subcommandNeedsEarlyBackendMode(command) {
     case "server":
     case "shared-memory":
     case "skills":
+    case "teleport":
       return true;
     default:
       return false;
@@ -482969,6 +483694,8 @@ async function runSubcommand(argv) {
       return runModsSubcommand(rest3);
     case "sandbox":
       return runSandboxSubcommand(rest3);
+    case "teleport":
+      return runTeleportSubcommand(rest3);
     case "server":
       return runServerSubcommand(rest3);
     case "remote":
@@ -483017,6 +483744,7 @@ var init_router = __esm(async () => {
   init_sandbox2();
   init_shared_memory();
   init_skills4();
+  init_teleport2();
   init_trajectories();
   await __promiseAll([
     init_cron2(),
@@ -483311,7 +484039,7 @@ function resolveListMessagesRoute(listReq, sessionConvId, sessionAgentId) {
 }
 
 // src/agent/bootstrap-handler.ts
-import { randomUUID as randomUUID32 } from "node:crypto";
+import { randomUUID as randomUUID33 } from "node:crypto";
 async function handleBootstrapSessionState(params) {
   const {
     bootstrapReq,
@@ -483360,7 +484088,7 @@ async function handleBootstrapSessionState(params) {
         response: payload
       },
       session_id: sessionContext.sessionId,
-      uuid: randomUUID32()
+      uuid: randomUUID33()
     };
   } catch (err) {
     return {
@@ -483371,14 +484099,14 @@ async function handleBootstrapSessionState(params) {
         error: err instanceof Error ? err.message : "bootstrap_session_state failed"
       },
       session_id: sessionContext.sessionId,
-      uuid: randomUUID32()
+      uuid: randomUUID33()
     };
   }
 }
 var init_bootstrap_handler = () => {};
 
 // src/agent/list-messages-handler.ts
-import { randomUUID as randomUUID33 } from "node:crypto";
+import { randomUUID as randomUUID34 } from "node:crypto";
 async function handleListMessages(params) {
   const {
     listReq,
@@ -483418,7 +484146,7 @@ async function handleListMessages(params) {
         response: payload
       },
       session_id: sessionId,
-      uuid: randomUUID33()
+      uuid: randomUUID34()
     };
   } catch (err) {
     return {
@@ -483429,7 +484157,7 @@ async function handleListMessages(params) {
         error: err instanceof Error ? err.message : "list_messages failed"
       },
       session_id: sessionId,
-      uuid: randomUUID33()
+      uuid: randomUUID34()
     };
   }
 }
@@ -483616,6 +484344,105 @@ var init_local_backend_mod_events = __esm(() => {
   init_local_backend();
 });
 
+// src/headless-environment-response.ts
+function pageItems5(page) {
+  if (Array.isArray(page))
+    return page;
+  if (page && typeof page === "object") {
+    const maybePage = page;
+    if (typeof maybePage.getPaginatedItems === "function") {
+      return maybePage.getPaginatedItems();
+    }
+    if (Array.isArray(maybePage.items)) {
+      return maybePage.items;
+    }
+  }
+  return [];
+}
+function extractMessageText(message) {
+  const content = message.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+        return part.text;
+      }
+      return "";
+    }).filter(Boolean).join(`
+`);
+  }
+  return "";
+}
+function isAssistantMessage2(message) {
+  return message.message_type === "assistant_message";
+}
+function isUserMessage(message) {
+  return message.message_type === "user_message";
+}
+function messageRunId(message) {
+  if (!message)
+    return null;
+  const runId = message.run_id;
+  return typeof runId === "string" && runId.length > 0 ? runId : null;
+}
+function messageSequenceId(message) {
+  const sequenceId = message.seq_id;
+  return typeof sequenceId === "number" ? sequenceId : null;
+}
+async function waitForEnvironmentAssistantMessage(params) {
+  const timeoutMs = params.timeoutMs ?? 10 * 60000;
+  const pollIntervalMs = params.pollIntervalMs ?? 1000;
+  const deadline = Date.now() + timeoutMs;
+  let inputSequenceId = null;
+  while (Date.now() < deadline) {
+    const page = params.conversationId === "default" ? await params.backend.listAgentMessages(params.agentId, {
+      conversation_id: "default",
+      limit: 50,
+      order: "desc"
+    }) : await params.backend.listConversationMessages(params.conversationId, {
+      limit: 50,
+      order: "desc"
+    });
+    const messages = pageItems5(page);
+    if (inputSequenceId === null) {
+      const inputMessage = messages.find((message) => isUserMessage(message) && message.otid === params.otid);
+      inputSequenceId = inputMessage ? messageSequenceId(inputMessage) : null;
+    }
+    if (inputSequenceId !== null) {
+      const anchorSequenceId = inputSequenceId;
+      const newerMessages = messages.filter((message) => {
+        const sequenceId = messageSequenceId(message);
+        return sequenceId !== null && sequenceId > anchorSequenceId;
+      });
+      const nextUserSequenceId = newerMessages.reduce((closest, message) => {
+        if (!isUserMessage(message))
+          return closest;
+        const sequenceId = messageSequenceId(message);
+        if (sequenceId === null)
+          return closest;
+        return closest === null || sequenceId < closest ? sequenceId : closest;
+      }, null);
+      const assistant = newerMessages.filter((message) => {
+        const sequenceId = messageSequenceId(message);
+        return isAssistantMessage2(message) && sequenceId !== null && (nextUserSequenceId === null || sequenceId < nextUserSequenceId);
+      }).sort((a2, b3) => (messageSequenceId(b3) ?? 0) - (messageSequenceId(a2) ?? 0))[0];
+      const runId = messageRunId(assistant);
+      if (runId) {
+        const run = await params.backend.retrieveRun(runId);
+        if ((run.status === "completed" || run.status === "failed" || run.status === "cancelled") && run.stop_reason !== "requires_approval") {
+          const text2 = assistant ? extractMessageText(assistant).trim() : "";
+          if (text2.length > 0) {
+            return { text: text2, stopReason: run.stop_reason ?? null };
+          }
+        }
+      }
+    }
+    await new Promise((resolve35) => setTimeout(resolve35, pollIntervalMs));
+  }
+  throw new Error("Timed out waiting for environment turn completion");
+}
+
 // src/headless-memfs-policy.ts
 function resolveHeadlessMemfsPolicy(options3) {
   const isFreshStatelessSubagent = options3.isSubagentRole && options3.newAgentRequested;
@@ -495053,7 +495880,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.30.19"
+    version: "0.30.20"
   };
 });
 
@@ -496092,7 +496919,7 @@ __export(exports_headless, {
   decideInterruptAction: () => decideInterruptAction,
   __headlessTestUtils: () => __headlessTestUtils
 });
-import { randomUUID as randomUUID34 } from "node:crypto";
+import { randomUUID as randomUUID35 } from "node:crypto";
 function trackHeadlessBoundaryError(errorType, error54, context3) {
   trackBoundaryError({
     errorType,
@@ -496114,7 +496941,7 @@ async function reportStartupErrorAndExit(errorType, error54, context3, outputFor
       message,
       stop_reason: "error",
       session_id: "startup",
-      uuid: `startup-error-${randomUUID34()}`
+      uuid: `startup-error-${randomUUID35()}`
     };
     await writeWireMessageAsync(errorMsg);
   } else {
@@ -496238,7 +497065,7 @@ async function emitHeadlessTurnStartCancellationOutput(options3) {
       message: options3.reason,
       stop_reason: "cancelled",
       session_id: options3.sessionId,
-      uuid: `error-turn-start-cancel-${randomUUID34()}`
+      uuid: `error-turn-start-cancel-${randomUUID35()}`
     };
     await writeWireMessageAsync(errorMsg);
     const resultMsg = {
@@ -496253,7 +497080,7 @@ async function emitHeadlessTurnStartCancellationOutput(options3) {
       conversation_id: options3.conversationId,
       run_ids: [],
       usage: null,
-      uuid: `result-turn-start-cancel-${randomUUID34()}`,
+      uuid: `result-turn-start-cancel-${randomUUID35()}`,
       stop_reason: "cancelled"
     };
     await writeWireMessageAsync(resultMsg);
@@ -496282,7 +497109,7 @@ function writeBidirectionalTurnStartCancellation(options3) {
     message: options3.reason,
     stop_reason: "cancelled",
     session_id: options3.sessionId,
-    uuid: `error-turn-start-cancel-${randomUUID34()}`
+    uuid: `error-turn-start-cancel-${randomUUID35()}`
   };
   writeWireMessage(errorMsg);
   const resultMsg = {
@@ -496297,7 +497124,7 @@ function writeBidirectionalTurnStartCancellation(options3) {
     conversation_id: options3.conversationId,
     run_ids: [],
     usage: null,
-    uuid: `result-turn-start-cancel-${randomUUID34()}`,
+    uuid: `result-turn-start-cancel-${randomUUID35()}`,
     stop_reason: "cancelled"
   };
   writeWireMessage(resultMsg);
@@ -496369,103 +497196,6 @@ async function writeFinalHeadlessStdout(text2) {
     process.stdout.write(text2, () => resolve37());
   });
 }
-function pageItems5(page) {
-  if (Array.isArray(page))
-    return page;
-  if (page && typeof page === "object") {
-    const maybePage = page;
-    if (typeof maybePage.getPaginatedItems === "function") {
-      return maybePage.getPaginatedItems();
-    }
-    if (Array.isArray(maybePage.items)) {
-      return maybePage.items;
-    }
-  }
-  return [];
-}
-function extractMessageText(message) {
-  const content = message.content;
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
-        return part.text;
-      }
-      return "";
-    }).filter(Boolean).join(`
-`);
-  }
-  return "";
-}
-function isAssistantMessage2(message) {
-  return message.message_type === "assistant_message";
-}
-function messageTime(message) {
-  const date6 = message.date ?? message.created_at;
-  return date6 ? new Date(date6).getTime() : 0;
-}
-function agentLastRunCompletionMs(agent2) {
-  const raw2 = agent2.last_run_completion;
-  if (typeof raw2 !== "string" || raw2.length === 0)
-    return null;
-  const ms = new Date(raw2).getTime();
-  return Number.isFinite(ms) ? ms : null;
-}
-function agentLastStopReason(agent2) {
-  const raw2 = agent2.last_stop_reason;
-  return typeof raw2 === "string" && raw2.length > 0 ? raw2 : null;
-}
-async function waitForEnvironmentAssistantMessage(params) {
-  const timeoutMs = params.timeoutMs ?? 10 * 60000;
-  const pollIntervalMs = params.pollIntervalMs ?? 1000;
-  const deadline = Date.now() + timeoutMs;
-  let lastText = "";
-  let postCompletionStableCount = 0;
-  let observedCompletion = false;
-  let observedStopReason = null;
-  while (Date.now() < deadline) {
-    const freshAgent = await params.backend.retrieveAgent(params.agentId);
-    const completionMs = agentLastRunCompletionMs(freshAgent);
-    const baselineCompletionMs = params.baselineLastRunCompletionMs ?? null;
-    const wasObservedCompletion = observedCompletion;
-    if (completionMs !== null && (baselineCompletionMs === null || completionMs > baselineCompletionMs) && completionMs >= params.startedAtMs - 5000) {
-      observedCompletion = true;
-      observedStopReason = agentLastStopReason(freshAgent);
-      if (!wasObservedCompletion) {
-        postCompletionStableCount = 0;
-      }
-    }
-    const page = params.conversationId === "default" ? await params.backend.listAgentMessages(params.agentId, {
-      conversation_id: "default",
-      limit: 50,
-      order: "desc"
-    }) : await params.backend.listConversationMessages(params.conversationId, {
-      limit: 50,
-      order: "desc"
-    });
-    const messages = pageItems5(page);
-    const assistant = messages.filter((message) => isAssistantMessage2(message) && messageTime(message) >= params.startedAtMs - 2000).sort((a2, b3) => messageTime(b3) - messageTime(a2))[0];
-    const text2 = assistant ? extractMessageText(assistant).trim() : "";
-    if (text2.length > 0) {
-      if (text2 === lastText) {
-        if (observedCompletion)
-          postCompletionStableCount += 1;
-      } else {
-        lastText = text2;
-        postCompletionStableCount = observedCompletion ? 1 : 0;
-      }
-      if (observedCompletion && postCompletionStableCount >= 2) {
-        return { text: text2, stopReason: observedStopReason };
-      }
-    }
-    await new Promise((resolve37) => setTimeout(resolve37, pollIntervalMs));
-  }
-  if (observedCompletion && lastText) {
-    return { text: lastText, stopReason: observedStopReason };
-  }
-  throw new Error("Timed out waiting for environment turn completion");
-}
 function buildEnvironmentResponseMetadata(params) {
   return {
     source: params.source,
@@ -497247,7 +497977,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       const approvalInput = {
         type: "approval",
         approvals: denialResults,
-        otid: randomUUID34()
+        otid: randomUUID35()
       };
       const approvalMessages = [approvalInput];
       {
@@ -497260,7 +497990,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
               type: "text",
               text: sc.content
             })),
-            otid: randomUUID34()
+            otid: randomUUID35()
           });
         }
       }
@@ -497293,7 +498023,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
           message: `Failed to resolve pending approvals on resume: ${approvalError instanceof Error ? approvalError.message : String(approvalError)}`,
           stop_reason: "error",
           session_id: sessionId,
-          uuid: `error-pre-loop-approval-${randomUUID34()}`
+          uuid: `error-pre-loop-approval-${randomUUID35()}`
         };
         writeWireMessage(errorMsg);
       } else {
@@ -497432,8 +498162,7 @@ ${loadedContents.join(`
       }
       await exitHeadless(1, "headless_environment_unsupported");
     }
-    const startedAtMs = Date.now();
-    const baselineLastRunCompletionMs = agentLastRunCompletionMs(agent2);
+    const otid = randomUUID35();
     await sendEnvironmentMessage(connectionId, {
       agentId: agent2.id,
       conversationId,
@@ -497441,8 +498170,8 @@ ${loadedContents.join(`
         {
           role: "user",
           content: contentParts,
-          client_message_id: randomUUID34(),
-          otid: randomUUID34()
+          client_message_id: randomUUID35(),
+          otid
         }
       ]
     });
@@ -497450,8 +498179,7 @@ ${loadedContents.join(`
       backend: backend3,
       agentId: agent2.id,
       conversationId,
-      startedAtMs,
-      baselineLastRunCompletionMs
+      otid
     });
     const resultText2 = environmentResult.text;
     const stats2 = sessionStats.getSnapshot();
@@ -497499,7 +498227,7 @@ ${loadedContents.join(`
     {
       role: "user",
       content: contentParts,
-      otid: randomUUID34()
+      otid: randomUUID35()
     }
   ];
   const recoveredApprovalResults = queuedRecoveredApprovalResults ?? [];
@@ -497508,7 +498236,7 @@ ${loadedContents.join(`
       {
         type: "approval",
         approvals: recoveredApprovalResults,
-        otid: randomUUID34()
+        otid: randomUUID35()
       },
       ...currentInput
     ];
@@ -497555,7 +498283,7 @@ ${loadedContents.join(`
           message: `Maximum turns limit reached (${buffers.usage.stepCount}/${maxTurns} steps)`,
           stop_reason: "max_steps",
           session_id: sessionId,
-          uuid: `error-max-turns-${randomUUID34()}`
+          uuid: `error-max-turns-${randomUUID35()}`
         };
         await writeWireMessageAsync(errorMsg);
       } else {
@@ -497572,7 +498300,7 @@ ${loadedContents.join(`
         message: "Interrupted by SIGINT",
         stop_reason: "cancelled",
         session_id: sessionId,
-        uuid: `error-interrupted-${randomUUID34()}`
+        uuid: `error-interrupted-${randomUUID35()}`
       };
       await writeWireMessageAsync(errorMsg);
     } else {
@@ -497601,7 +498329,7 @@ ${loadedContents.join(`
                 type: "text",
                 text: sc.content
               })),
-              otid: randomUUID34()
+              otid: randomUUID35()
             }
           ];
         }
@@ -497647,7 +498375,7 @@ ${loadedContents.join(`
               recovery_type: "approval_pending",
               message: "Detected pending approval conflict on send; resolving before retry",
               session_id: sessionId,
-              uuid: `recovery-pre-stream-${randomUUID34()}`
+              uuid: `recovery-pre-stream-${randomUUID35()}`
             };
             writeWireMessage(recoveryMsg);
           } else {
@@ -497680,7 +498408,7 @@ ${loadedContents.join(`
                 max_attempts: CONVERSATION_BUSY_MAX_RETRIES,
                 delay_ms: retryDelayMs,
                 session_id: sessionId,
-                uuid: `retry-conversation-busy-${randomUUID34()}`
+                uuid: `retry-conversation-busy-${randomUUID35()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -497704,7 +498432,7 @@ ${loadedContents.join(`
                   type: "status",
                   message: "Anthropic API error; falling back to Bedrock...",
                   session_id: sessionId,
-                  uuid: `fallback-${randomUUID34()}`
+                  uuid: `fallback-${randomUUID35()}`
                 }));
               } else {
                 console.error("Anthropic API error; falling back to Bedrock...");
@@ -497728,7 +498456,7 @@ ${loadedContents.join(`
               max_attempts: LLM_API_ERROR_MAX_RETRIES2,
               delay_ms: delayMs,
               session_id: sessionId,
-              uuid: `retry-pre-stream-${randomUUID34()}`
+              uuid: `retry-pre-stream-${randomUUID35()}`
             };
             writeWireMessage(retryMsg);
           } else {
@@ -497754,7 +498482,7 @@ ${loadedContents.join(`
               stop_reason: "error",
               run_id: errorInfo.run_id,
               session_id: sessionId,
-              uuid: randomUUID34(),
+              uuid: randomUUID35(),
               ...errorInfo.error_type && errorInfo.run_id && {
                 api_error: {
                   message_type: "error_message",
@@ -497776,7 +498504,7 @@ ${loadedContents.join(`
               message: "Detected pending approval conflict; auto-denying stale approval and retrying",
               run_id: recoveryRunId ?? undefined,
               session_id: sessionId,
-              uuid: `recovery-${recoveryRunId || randomUUID34()}`
+              uuid: `recovery-${recoveryRunId || randomUUID35()}`
             };
             writeWireMessage(recoveryMsg);
             approvalPendingRecovery = true;
@@ -497794,7 +498522,7 @@ ${loadedContents.join(`
                 type: "stream_event",
                 event: chunk,
                 session_id: sessionId,
-                uuid: uuid5 || randomUUID34()
+                uuid: uuid5 || randomUUID35()
               };
               writeWireMessage(streamEvent);
             } else {
@@ -497802,7 +498530,7 @@ ${loadedContents.join(`
                 type: "message",
                 ...chunk,
                 session_id: sessionId,
-                uuid: uuid5 || randomUUID34()
+                uuid: uuid5 || randomUUID35()
               };
               writeWireMessage(msg);
             }
@@ -497845,7 +498573,7 @@ ${loadedContents.join(`
             {
               role: "user",
               content: continueMessage,
-              otid: randomUUID34()
+              otid: randomUUID35()
             }
           ];
           const continueTurnStartEmission = await emitHeadlessTurnStart({
@@ -497917,7 +498645,7 @@ ${loadedContents.join(`
         const approvalInputWithOtid = {
           type: "approval",
           approvals: executedResults,
-          otid: randomUUID34()
+          otid: randomUUID35()
         };
         currentInput = [approvalInputWithOtid];
         continue;
@@ -497947,7 +498675,7 @@ ${loadedContents.join(`
                   type: "status",
                   message: "Anthropic API error; falling back to Bedrock...",
                   session_id: sessionId,
-                  uuid: `fallback-${randomUUID34()}`
+                  uuid: `fallback-${randomUUID35()}`
                 }));
               } else {
                 console.error("Anthropic API error; falling back to Bedrock...");
@@ -497970,7 +498698,7 @@ ${loadedContents.join(`
               delay_ms: delayMs,
               run_id: lastRunId ?? undefined,
               session_id: sessionId,
-              uuid: `retry-${lastRunId || randomUUID34()}`
+              uuid: `retry-${lastRunId || randomUUID35()}`
             };
             writeWireMessage(retryMsg);
           } else {
@@ -497991,7 +498719,7 @@ ${loadedContents.join(`
             message: "Tool call ID mismatch; fetching actual pending approvals and resyncing",
             run_id: lastRunId ?? undefined,
             session_id: sessionId,
-            uuid: `recovery-${lastRunId || randomUUID34()}`
+            uuid: `recovery-${lastRunId || randomUUID35()}`
           };
           writeWireMessage(recoveryMsg);
         } else {
@@ -498008,7 +498736,7 @@ ${loadedContents.join(`
               stop_reason: stopReason,
               run_id: lastRunId ?? undefined,
               session_id: sessionId,
-              uuid: `error-${lastRunId || randomUUID34()}`
+              uuid: `error-${lastRunId || randomUUID35()}`
             };
             await writeWireMessageAsync(errorMsg);
           } else {
@@ -498050,7 +498778,7 @@ ${loadedContents.join(`
               const nudgeMessage = {
                 role: "system",
                 content: `<system-reminder>The previous response was empty. Please provide a response with either text content or a tool call.</system-reminder>`,
-                otid: randomUUID34()
+                otid: randomUUID35()
               };
               currentInput = [...currentInput, nudgeMessage];
             }
@@ -498063,7 +498791,7 @@ ${loadedContents.join(`
                 delay_ms: delayMs,
                 run_id: lastRunId ?? undefined,
                 session_id: sessionId,
-                uuid: `retry-empty-${lastRunId || randomUUID34()}`
+                uuid: `retry-empty-${lastRunId || randomUUID35()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -498090,7 +498818,7 @@ ${loadedContents.join(`
                 delay_ms: delayMs,
                 run_id: lastRunId ?? undefined,
                 session_id: sessionId,
-                uuid: `retry-${lastRunId || randomUUID34()}`
+                uuid: `retry-${lastRunId || randomUUID35()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -498120,7 +498848,7 @@ ${loadedContents.join(`
                 delay_ms: delayMs,
                 run_id: lastRunId ?? undefined,
                 session_id: sessionId,
-                uuid: `retry-${lastRunId || randomUUID34()}`
+                uuid: `retry-${lastRunId || randomUUID35()}`
               };
               writeWireMessage(retryMsg);
             } else {
@@ -498169,7 +498897,7 @@ ${loadedContents.join(`
           stop_reason: stopReason,
           run_id: lastRunId ?? undefined,
           session_id: sessionId,
-          uuid: `error-${lastRunId || randomUUID34()}`
+          uuid: `error-${lastRunId || randomUUID35()}`
         };
         await writeWireMessageAsync(errorMsg);
       } else {
@@ -498188,7 +498916,7 @@ ${loadedContents.join(`
         stop_reason: "error",
         run_id: lastKnownRunId ?? undefined,
         session_id: sessionId,
-        uuid: `error-${lastKnownRunId || randomUUID34()}`
+        uuid: `error-${lastKnownRunId || randomUUID35()}`
       };
       await writeWireMessageAsync(errorMsg);
     } else {
@@ -498385,7 +499113,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
       const approvalInput = {
         type: "approval",
         approvals: denialResults,
-        otid: randomUUID34()
+        otid: randomUUID35()
       };
       const approvalMessages = [approvalInput];
       {
@@ -498398,7 +499126,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
               type: "text",
               text: sc.content
             })),
-            otid: randomUUID34()
+            otid: randomUUID35()
           });
         }
       }
@@ -498456,7 +499184,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
         reason,
         cleared_count: clearedCount,
         session_id: sessionId,
-        uuid: `q-clr-${randomUUID34()}`
+        uuid: `q-clr-${randomUUID35()}`
       })
     }
   });
@@ -498486,7 +499214,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
       reason: "runtime_busy",
       queue_len: Math.max(1, queueLen),
       session_id: sessionId,
-      uuid: `q-blk-${randomUUID34()}`
+      uuid: `q-blk-${randomUUID35()}`
     });
   }
   function enqueueForTracking(input) {
@@ -498558,7 +499286,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
           request_id: interruptRequestId
         },
         session_id: sessionId,
-        uuid: randomUUID34()
+        uuid: randomUUID35()
       };
       writeWireMessage(interruptResponse);
       return;
@@ -498695,7 +499423,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
       const approvalInput = {
         type: "approval",
         approvals: denialResults,
-        otid: randomUUID34()
+        otid: randomUUID35()
       };
       const approvalStream = await sendScopedApprovalMessages({
         agentId: agent2.id,
@@ -498734,7 +499462,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
         message: "Invalid JSON input",
         stop_reason: "error",
         session_id: sessionId,
-        uuid: randomUUID34()
+        uuid: randomUUID35()
       };
       writeWireMessage(errorMsg2);
       continue;
@@ -498760,7 +499488,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
             }
           },
           session_id: sessionId,
-          uuid: randomUUID34()
+          uuid: randomUUID35()
         };
         writeWireMessage(initResponse);
       } else if (subtype === "interrupt") {
@@ -498777,7 +499505,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
             request_id: requestId ?? ""
           },
           session_id: sessionId,
-          uuid: randomUUID34()
+          uuid: randomUUID35()
         };
         writeWireMessage(interruptResponse);
       } else if (subtype === "register_external_tools") {
@@ -498825,7 +499553,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
             response: { registered: tools.length }
           },
           session_id: sessionId,
-          uuid: randomUUID34()
+          uuid: randomUUID35()
         };
         writeWireMessage(registerResponse);
       } else if (subtype === "bootstrap_session_state") {
@@ -498881,7 +499609,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
               response: recovery
             },
             session_id: sessionId,
-            uuid: randomUUID34()
+            uuid: randomUUID35()
           };
           writeWireMessage(recoveryResponse);
         } catch (error54) {
@@ -498893,7 +499621,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
               error: error54 instanceof Error ? error54.message : String(error54)
             },
             session_id: sessionId,
-            uuid: randomUUID34()
+            uuid: randomUUID35()
           };
           writeWireMessage(recoveryError);
         }
@@ -498906,7 +499634,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
             error: `Unknown control request subtype: ${subtype}`
           },
           session_id: sessionId,
-          uuid: randomUUID34()
+          uuid: randomUUID35()
         };
         writeWireMessage(errorResponse);
       }
@@ -498961,7 +499689,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
       try {
         const buffers = createBuffers(agent2.id);
         const startTime = performance.now();
-        const userOtid = randomUUID34();
+        const userOtid = randomUUID35();
         const userTranscriptText = extractTelemetryInputText(userContent);
         if (userTranscriptText.length > 0) {
           const userLineId = `user-${userOtid}`;
@@ -499082,7 +499810,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
                 recovery_type: "approval_pending",
                 message: "Detected pending approval conflict on send; resolving before retry",
                 session_id: sessionId,
-                uuid: `recovery-bidir-${randomUUID34()}`
+                uuid: `recovery-bidir-${randomUUID35()}`
               };
               writeWireMessage(recoveryMsg);
               await resolveAllPendingApprovals();
@@ -499105,7 +499833,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
                 max_attempts: LLM_API_ERROR_MAX_RETRIES2,
                 delay_ms: delayMs,
                 session_id: sessionId,
-                uuid: `retry-bidir-${randomUUID34()}`
+                uuid: `retry-bidir-${randomUUID35()}`
               };
               writeWireMessage(retryMsg);
               await new Promise((resolve37) => setTimeout(resolve37, delayMs));
@@ -499127,7 +499855,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
                 stop_reason: "error",
                 run_id: errorInfo.run_id,
                 session_id: sessionId,
-                uuid: randomUUID34(),
+                uuid: randomUUID35(),
                 ...errorInfo.error_type && errorInfo.run_id && {
                   api_error: {
                     message_type: "error_message",
@@ -499155,7 +499883,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
                 type: "stream_event",
                 event: chunk,
                 session_id: sessionId,
-                uuid: uuid5 || randomUUID34()
+                uuid: uuid5 || randomUUID35()
               };
               writeWireMessage(streamEvent);
             } else {
@@ -499163,7 +499891,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
                 type: "message",
                 ...chunk,
                 session_id: sessionId,
-                uuid: uuid5 || randomUUID34()
+                uuid: uuid5 || randomUUID35()
               };
               writeWireMessage(msg);
             }
@@ -499229,7 +499957,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
             const approvalInputWithOtid = {
               type: "approval",
               approvals: executedResults,
-              otid: randomUUID34()
+              otid: randomUUID35()
             };
             currentInput = [approvalInputWithOtid];
             continue;
@@ -499292,7 +500020,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
           message: errorDetails,
           stop_reason: "error",
           session_id: sessionId,
-          uuid: randomUUID34()
+          uuid: randomUUID35()
         };
         writeWireMessage(errorMsg2);
         const errorResultMsg = {
@@ -499335,7 +500063,7 @@ async function runBidirectionalMode(agent2, conversationId, _outputFormat, inclu
       message: `Unknown message type: ${message.type}`,
       stop_reason: "error",
       session_id: sessionId,
-      uuid: randomUUID34()
+      uuid: randomUUID35()
     };
     writeWireMessage(errorMsg);
   }
@@ -499426,8 +500154,7 @@ var init_headless = __esm(async () => {
     shouldTrackTelemetryForQueuedMessage,
     contentToTaskNotificationText,
     toBidirectionalQueuedInput,
-    prepareHeadlessToolExecutionContext,
-    waitForEnvironmentAssistantMessage
+    prepareHeadlessToolExecutionContext
   };
 });
 
@@ -500824,7 +501551,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 { randomInt as randomInt2, randomUUID as randomUUID36 } from "node:crypto";
 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";
@@ -501198,7 +501925,7 @@ async function startReflectionArenaRun(options3) {
   }
   let releaseReservation = true;
   try {
-    const runId = randomUUID35().slice(0, 8);
+    const runId = randomUUID36().slice(0, 8);
     const labels = shuffledLabels();
     const prepared = await Promise.all([
       prepareReflectionMemoryWorktreeLaunch({
@@ -524911,7 +525638,7 @@ var init_ToolCallMessageRich = __esm(async () => {
       let shellSemanticKind = null;
       let hasShellDescription = false;
       if (!isQuestionTool(rawName)) {
-        const parseArgs19 = () => {
+        const parseArgs20 = () => {
           if (!argsText.trim()) {
             return { formatted: null, parseable: true };
           }
@@ -524925,7 +525652,7 @@ var init_ToolCallMessageRich = __esm(async () => {
             return { formatted: null, parseable: false };
           }
         };
-        const { formatted, parseable } = parseArgs19();
+        const { formatted, parseable } = parseArgs20();
         const argsComplete = parseable || line.phase === "running" || line.phase === "finished" || !isStreaming;
         if (!argsComplete) {
           args = "(…)";
@@ -526396,12 +527123,12 @@ var init_ExitStats = __esm(async () => {
 });
 
 // src/cli/app/ids.ts
-import { randomUUID as randomUUID36 } from "node:crypto";
+import { randomUUID as randomUUID37 } from "node:crypto";
 function uid(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 function createClientOtid() {
-  return randomUUID36();
+  return randomUUID37();
 }
 function appendOptimisticUserLine(buffers, text2, otid) {
   if (!text2) {
@@ -527141,7 +527868,7 @@ function updateCommandResult(buffersRef, refreshDerived, cmdId, input, output, s
   buffersRef.current.byId.set(cmdId, line);
   refreshDerived();
 }
-function parseArgs19(msg) {
+function parseArgs20(msg) {
   return msg.trim().split(/\s+/).filter(Boolean);
 }
 function formatConnectUsage() {
@@ -527497,7 +528224,7 @@ ${formatBedrockUsage2()}`, false);
   }
 }
 async function handleConnect(ctx, msg) {
-  const parts = parseArgs19(msg);
+  const parts = parseArgs20(msg);
   const providerToken = parts[1];
   if (!providerToken) {
     addCommandResult(ctx.buffersRef, ctx.refreshDerived, msg, formatConnectUsage(), false);
@@ -543425,7 +544152,7 @@ var init_notifications = __esm(() => {
 });
 
 // src/cli/app/use-approval-flow.ts
-import { randomUUID as randomUUID37 } from "node:crypto";
+import { randomUUID as randomUUID38 } from "node:crypto";
 function useApprovalFlow(ctx) {
   const {
     abortControllerRef,
@@ -543937,7 +544664,7 @@ function useApprovalFlow(ctx) {
             {
               type: "approval",
               approvals: allResults,
-              otid: randomUUID37()
+              otid: randomUUID38()
             }
           ]);
         } catch (error54) {
@@ -545336,7 +546063,7 @@ var init_system_reminders = __esm(() => {
 });
 
 // src/cli/app/use-conversation-loop.ts
-import { randomUUID as randomUUID38 } from "node:crypto";
+import { randomUUID as randomUUID39 } from "node:crypto";
 function sleep10(ms) {
   return new Promise((resolve40) => setTimeout(resolve40, ms));
 }
@@ -545640,16 +546367,16 @@ function useConversationLoop(ctx) {
         currentInput = [
           ...lastSentInputRef.current.map((m4) => ({
             ...m4,
-            otid: randomUUID38()
+            otid: randomUUID39()
           })),
           ...currentInput.map((m4) => m4.type === "message" && m4.role === "user" ? {
             ...m4,
-            otid: randomUUID38(),
+            otid: randomUUID39(),
             content: [
               { type: "text", text: INTERRUPT_RECOVERY_ALERT },
               ...typeof m4.content === "string" ? [{ type: "text", text: m4.content }] : Array.isArray(m4.content) ? m4.content : []
             ]
-          } : { ...m4, otid: randomUUID38() })
+          } : { ...m4, otid: randomUUID39() })
         ];
         pendingInterruptRecoveryConversationIdRef.current = null;
         lastSentInputRef.current = [
@@ -545688,7 +546415,7 @@ function useConversationLoop(ctx) {
                 type: "text",
                 text: sc.content
               })),
-              otid: randomUUID38()
+              otid: randomUUID39()
             }
           ];
         }
@@ -546068,7 +546795,7 @@ ${feedback}
             });
             buffersRef.current.order.push(statusId);
             refreshDerived();
-            const hookMessageOtid = randomUUID38();
+            const hookMessageOtid = randomUUID39();
             setTimeout(() => {
               processConversation([
                 {
@@ -546095,7 +546822,7 @@ ${feedback}
             turnEndContinue = undefined;
           }
           if (turnEndContinue) {
-            const continueOtid = randomUUID38();
+            const continueOtid = randomUUID39();
             setTimeout(() => {
               processConversation([
                 {
@@ -546449,7 +547176,7 @@ ${feedback}
                 {
                   type: "approval",
                   approvals: allResults,
-                  otid: randomUUID38()
+                  otid: randomUUID39()
                 }
               ], {
                 allowReentry: true,
@@ -546633,7 +547360,7 @@ ${feedback}
                 type: "message",
                 role: "system",
                 content: `<system-reminder>The previous response was empty. Please provide a response with either text content or a tool call.</system-reminder>`,
-                otid: randomUUID38()
+                otid: randomUUID39()
               }
             ];
           }
@@ -546927,7 +547654,7 @@ var init_use_conversation_loop = __esm(async () => {
 });
 
 // src/cli/app/use-conversation-switching.ts
-import { randomUUID as randomUUID39 } from "node:crypto";
+import { randomUUID as randomUUID40 } from "node:crypto";
 function useConversationSwitching(ctx) {
   const {
     abortControllerRef,
@@ -547002,7 +547729,7 @@ function useConversationSwitching(ctx) {
         {
           role: "user",
           content: question,
-          otid: randomUUID39()
+          otid: randomUUID40()
         }
       ];
       let approvalRecoveryRetries = 0;
@@ -552518,7 +553245,7 @@ var init_conversation_switch_alert = __esm(() => {
 });
 
 // src/cli/app/use-submit-handler.ts
-import { randomUUID as randomUUID40 } from "node:crypto";
+import { randomUUID as randomUUID41 } from "node:crypto";
 import { existsSync as existsSync70, readFileSync as readFileSync45, renameSync as renameSync8, writeFileSync as writeFileSync39 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
 import { join as join91 } from "node:path";
@@ -552939,7 +553666,7 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
               content: buildTextParts(`${SYSTEM_REMINDER_OPEN}
 ${prompt}
 ${SYSTEM_REMINDER_CLOSE}`),
-              otid: randomUUID40()
+              otid: randomUUID41()
             }
           ]);
         } catch (error54) {
@@ -553003,7 +553730,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
                 type: "message",
                 role: "user",
                 content: buildTextParts(buildModCommandPrompt(result2)),
-                otid: randomUUID40()
+                otid: randomUUID41()
               }
             ]);
           } else if (result2.type === "output") {
@@ -553048,7 +553775,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
 ${SYSTEM_REMINDER_OPEN}
 ${request2}
 ${SYSTEM_REMINDER_CLOSE}`),
-              otid: randomUUID40()
+              otid: randomUUID41()
             }
           ]);
         } catch (error54) {
@@ -553317,7 +554044,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
 ${SYSTEM_REMINDER_OPEN}
 ${request2}
 ${SYSTEM_REMINDER_CLOSE}`),
-              otid: randomUUID40()
+              otid: randomUUID41()
             }
           ]);
         } catch (error54) {
@@ -554161,7 +554888,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
               type: "message",
               role: "user",
               content: buildTextParts(skillMessage),
-              otid: randomUUID40()
+              otid: randomUUID41()
             }
           ]);
         } catch (error54) {
@@ -554199,7 +554926,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
               type: "message",
               role: "user",
               content: rememberParts,
-              otid: randomUUID40()
+              otid: randomUUID41()
             }
           ]);
         } catch (error54) {
@@ -554615,7 +555342,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
               type: "message",
               role: "user",
               content: buildTextParts(initMessage),
-              otid: randomUUID40()
+              otid: randomUUID41()
             }
           ]);
         } catch (error54) {
@@ -554782,7 +555509,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                 type: "message",
                 role: "user",
                 content: buildTextParts(wrapSkillPrompt2(matchedSkill.id, skillContent, userRequest)),
-                otid: randomUUID40()
+                otid: randomUUID41()
               }
             ]);
           } catch (error54) {
@@ -554933,7 +555660,7 @@ ${SYSTEM_REMINDER_CLOSE}
       initialInput.push({
         type: "approval",
         approvals: eagerRecoveryDenials,
-        otid: randomUUID40()
+        otid: randomUUID41()
       });
     }
     const queuedApprovalInput = consumeQueuedApprovalInputForCurrentConversation();
@@ -558628,6 +559355,7 @@ USAGE
   letta memory ...      Memory filesystem subcommands
   letta agents ...      Agents subcommands (JSON-only)
   letta environments ... List available remote environments (JSON-only)
+  letta teleport ...    Move the current conversation between environments
   letta messages ...    Messages subcommands (JSON-only)
   letta mods ...        List and manage local mods
   letta sandbox ...     Transfer files to or from the current Cloud sandbox
@@ -558654,6 +559382,7 @@ SUBCOMMANDS
   letta agents list [--query <text> | --name <name> | --tags <tags>]
   letta environments list [--online-only]
   letta environments current
+  letta teleport list|cloud|<environment>
   letta messages search --query <text> [--all-agents]
   letta messages list [--agent <id>]
   letta messages transcript --conversation <id> [--out <path>]
@@ -562341,4 +563070,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=447A31644C59E2F264756E2164756E21
+//# debugId=70AA6EC305780C2964756E2164756E21