@letta-ai/letta-code 0.31.11 → 0.31.13

package/letta.js

@@ -5400,10 +5400,10 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.31.11",
+    version: "0.31.13",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
-    packageManager: "bun@1.3.10",
+    packageManager: "bun@1.3.14",
     bin: {
       letta: "letta.js"
     },
@@ -5522,6 +5522,7 @@ var init_package = __esm(() => {
     },
     license: "Apache-2.0",
     engines: {
+      bun: ">=1.3.2",
       node: ">=22.19.0"
     },
     publishConfig: {
@@ -6670,14 +6671,6 @@ function consumeLastSDKDiagnostic() {
 function clearLastSDKDiagnostic() {
   lastSDKDiagnostic = null;
 }
-function getNodeRoutingHeader() {
-  const raw = process.env.LETTA_NODE;
-  if (raw === undefined || raw.trim() === "") {
-    return {};
-  }
-  const enabled = NODE_HEADER_ENABLED_VALUES.has(raw.trim().toLowerCase());
-  return { "x-letta-node": enabled ? "1" : "0" };
-}
 function getRuntimeEnvironmentDeviceId() {
   return process.env[RUNTIME_ENVIRONMENT_DEVICE_ID_ENV]?.trim() || settingsManager.getOrCreateDeviceId();
 }
@@ -6686,7 +6679,6 @@ function getClientDefaultHeaders() {
     "X-Letta-Source": "letta-code",
     "User-Agent": `letta-code/${package_default.version}`,
     "X-Letta-Environment-Device-Id": getRuntimeEnvironmentDeviceId(),
-    ...getNodeRoutingHeader(),
     ...process.env.LETTA_MEMFS_BACKEND === "hosted" ? { "x-letta-memfs-backend": "hosted" } : {}
   };
 }
@@ -6779,7 +6771,7 @@ If you experience this issue multiple times, move ~/.letta to ~/.letta_backup, a
   };
   return client;
 }
-var SDK_DIAGNOSTIC_MAX_LEN = 400, SDK_DIAGNOSTIC_MAX_LINES = 4, lastSDKDiagnostic = null, _cachedApiKey, _testClientOverride = null, sdkLogger, NODE_HEADER_ENABLED_VALUES, RUNTIME_ENVIRONMENT_DEVICE_ID_ENV = "LETTA_RUNTIME_ENVIRONMENT_DEVICE_ID";
+var SDK_DIAGNOSTIC_MAX_LEN = 400, SDK_DIAGNOSTIC_MAX_LINES = 4, lastSDKDiagnostic = null, _cachedApiKey, _testClientOverride = null, sdkLogger, RUNTIME_ENVIRONMENT_DEVICE_ID_ENV = "LETTA_RUNTIME_ENVIRONMENT_DEVICE_ID";
 var init_client2 = __esm(() => {
   init_letta_client();
   init_oauth();
@@ -6809,7 +6801,6 @@ var init_client2 = __esm(() => {
       console.debug(...args);
     }
   };
-  NODE_HEADER_ENABLED_VALUES = new Set(["1", "true", "yes"]);
 });
 
 // src/utils/text-files.ts
@@ -7968,7 +7959,7 @@ Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
 - [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
-- [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
+- [ ] Moving machines: ask the user to connect another computer (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
 var init_onboarding = () => {};
 
@@ -8021,7 +8012,7 @@ Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
 - [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
-- [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
+- [ ] Moving machines: ask the user to connect another computer (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
 var init_onboarding_local = () => {};
 
@@ -88360,8 +88351,9 @@ Usage notes:
   - You can specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). If not specified, commands will timeout after 120000ms (2 minutes).
   - Write a clear, concise user-facing description of what this command does. This description may be shown directly in chat as part of a status row like \`Running command: <description>\` or \`Ran command: <description>\`. Describe the command's purpose, not its shell syntax. For simple commands, keep it brief (5-10 words). For complex commands (piped commands, obscure flags, or anything hard to understand at a glance), add enough context to clarify what it does.
   - If the output exceeds 30000 characters, output will be truncated before being returned to you.
-  - You can use the \`run_in_background\` parameter to run the command in the background. Only use this if you don't need the result immediately and are OK being notified when the command completes later. You do not need to check the output right away - you'll be notified when it finishes. You do not need to use '&' at the end of the command when using this parameter.
-  - Pick between \`run_in_background\` and the Monitor tool by how many notifications you need. **One** ("tell me when the server is ready / the build finishes") → Bash with \`run_in_background\` and a command that exits when the condition is true, e.g. \`until grep -q "Ready in" dev.log; do sleep 0.5; done\`. You get a single completion notification when it exits. **One per occurrence** ("tell me every time an ERROR line appears") → use Monitor: each stdout line is an event — you keep working and notifications arrive in the chat. Foreground \`sleep\` is blocked; background the wait (\`run_in_background\` or Monitor) instead of polling BashOutput, and keep working.
+  - Ordinary commands wait briefly for a result, then automatically continue in the background if they are still running. You will receive a task ID and one completion notification, so do not predict command duration, set \`run_in_background\` merely because a command may be slow, or poll for completion.
+  - Set \`run_in_background\` only when you want the command to return a task ID immediately. You do not need to use '&' at the end of the command.
+  - Pick between Bash and the Monitor tool by how many notifications you need. **One** ("tell me when the server is ready / the build finishes") → Bash with a command that exits when the condition is true, e.g. \`until grep -q "Ready in" dev.log; do sleep 0.5; done\`. Bash automatically yields and sends one completion notification. **One per occurrence** ("tell me every time an ERROR line appears") → use Monitor: each stdout line is an event while you keep working.
   
   - Avoid using Bash with the \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
     - File search: Use Glob (NOT find or ls)
@@ -88487,61 +88479,7 @@ var EnterWorktree_default = "# EnterWorktree\n\nCreate a fresh isolated git work
 var init_EnterWorktree = () => {};
 
 // src/tools/descriptions/ExecCommand.md
-var ExecCommand_default = `Runs a command in a PTY, returning output or a session ID for ongoing interaction.
-
-For ordinary one-shot commands, omit \`yield_time_ms\` and let the default wait for completion; set \`yield_time_ms\` only when intentionally returning early from a long-running or interactive command.
-
-Provide the required \`description\` field as a clear, concise user-facing status label for what the command does. It may be shown directly in chat with no prefix, so make it grammatical by itself and avoid tense-dependent wording. Use an imperative or purpose phrase like \`Find debug log entries\` or \`Search recent logs for errors\`. Describe the command's purpose, not its shell syntax. Keep it brief for simple commands; add only enough context to clarify commands that are hard to parse at a glance.
-
-# Committing changes with git
-
-Only create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:
-
-Git Safety Protocol:
-- NEVER update the git config
-- NEVER run destructive/irreversible git commands (like push --force, hard reset, etc) unless the user explicitly requests them 
-- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it
-- NEVER run force push to main/master, warn the user if they request it
-- CRITICAL: Always create NEW commits rather than amending, unless the user explicitly requests a git amend. When a pre-commit hook fails, the commit did NOT happen  -- so --amend would modify the PREVIOUS commit, which may result in destroying work or losing previous changes. Instead, after hook failure, fix the issue, re-stage, and create a NEW commit
-- When staging files, prefer adding specific files by name rather than using "git add -A" or "git add .", which can accidentally include sensitive files (.env, credentials) or large binaries
-- NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
-
-1. Run the following shell commands in parallel:
-  - Run a git status command to see all untracked files. IMPORTANT: Never use the -uall flag as it can cause memory issues on large repos.
-  - Run a git diff command to see both staged and unstaged changes that will be committed.
-  - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.
-2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:
-  - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. "add" means a wholly new feature, "update" means an enhancement to an existing feature, "fix" means a bug fix, etc.).
-  - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files
-  - Draft a concise (1-2 sentences) commit message that focuses on the "why" rather than the "what"
-  - Ensure it accurately reflects the changes and their purpose
-3. Run the following commands:
-   - Add relevant untracked files to the staging area.
-   - Create the commit with a message ending with:
-   👾 Generated with [Letta Code](https://letta.com)
-
-   Co-Authored-By: Letta Code <noreply@letta.com>
-   - Run git status after the commit completes to verify success.
-   Note: git status depends on the commit completing, so run it sequentially after the commit.
-4. If the commit fails due to pre-commit hook: fix the issue and create a NEW commit
-
-Important notes:
-- NEVER run additional commands to read or explore code, besides git commands
-- DO NOT push to the remote repository unless the user explicitly asks you to do so
-- IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.
-- IMPORTANT: Do not use --no-edit with git rebase commands, as the --no-edit flag is not a valid option for git rebase.
-- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit
-- In order to ensure good formatting, ALWAYS pass the commit message as a single-quoted string with embedded newlines, a la this example:
-<example>
-git commit -m 'Commit message here.
-
-👾 Generated with [Letta Code](https://letta.com)
-
-Co-Authored-By: Letta Code <noreply@letta.com>'
-</example>
-
-Use single quotes (not double quotes) and do NOT wrap the message in \`$(...)\` or backticks — single-quoting preserves the message verbatim (including \`$VAR\`, backticks, and other special characters) without needing escapes.
-`;
+var ExecCommand_default = "Runs a command in a PTY, returning output or a session ID for ongoing interaction.\n\nFor ordinary one-shot commands, omit `yield_time_ms` and let the default wait for completion; set `yield_time_ms` only when intentionally returning early from a long-running or interactive command.\n\nIf a command is still running when this tool yields, you will receive a notification when it completes. Do not poll the session just to check whether it has finished. Use `write_stdin` only when you need to send input, interrupt the process, or obtain output before you can continue.\n\nProvide the required `description` field as a clear, concise user-facing status label for what the command does. It may be shown directly in chat with no prefix, so make it grammatical by itself and avoid tense-dependent wording. Use an imperative or purpose phrase like `Find debug log entries` or `Search recent logs for errors`. Describe the command's purpose, not its shell syntax. Keep it brief for simple commands; add only enough context to clarify commands that are hard to parse at a glance.\n\n# Committing changes with git\n\nOnly create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:\n\nGit Safety Protocol:\n- NEVER update the git config\n- NEVER run destructive/irreversible git commands (like push --force, hard reset, etc) unless the user explicitly requests them \n- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it\n- NEVER run force push to main/master, warn the user if they request it\n- CRITICAL: Always create NEW commits rather than amending, unless the user explicitly requests a git amend. When a pre-commit hook fails, the commit did NOT happen  -- so --amend would modify the PREVIOUS commit, which may result in destroying work or losing previous changes. Instead, after hook failure, fix the issue, re-stage, and create a NEW commit\n- When staging files, prefer adding specific files by name rather than using \"git add -A\" or \"git add .\", which can accidentally include sensitive files (.env, credentials) or large binaries\n- NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.\n\n1. Run the following shell commands in parallel:\n  - Run a git status command to see all untracked files. IMPORTANT: Never use the -uall flag as it can cause memory issues on large repos.\n  - Run a git diff command to see both staged and unstaged changes that will be committed.\n  - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.\n2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:\n  - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. \"add\" means a wholly new feature, \"update\" means an enhancement to an existing feature, \"fix\" means a bug fix, etc.).\n  - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files\n  - Draft a concise (1-2 sentences) commit message that focuses on the \"why\" rather than the \"what\"\n  - Ensure it accurately reflects the changes and their purpose\n3. Run the following commands:\n   - Add relevant untracked files to the staging area.\n   - Create the commit with a message ending with:\n   👾 Generated with [Letta Code](https://letta.com)\n\n   Co-Authored-By: Letta Code <noreply@letta.com>\n   - Run git status after the commit completes to verify success.\n   Note: git status depends on the commit completing, so run it sequentially after the commit.\n4. If the commit fails due to pre-commit hook: fix the issue and create a NEW commit\n\nImportant notes:\n- NEVER run additional commands to read or explore code, besides git commands\n- DO NOT push to the remote repository unless the user explicitly asks you to do so\n- IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.\n- IMPORTANT: Do not use --no-edit with git rebase commands, as the --no-edit flag is not a valid option for git rebase.\n- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit\n- In order to ensure good formatting, ALWAYS pass the commit message as a single-quoted string with embedded newlines, a la this example:\n<example>\ngit commit -m 'Commit message here.\n\n👾 Generated with [Letta Code](https://letta.com)\n\nCo-Authored-By: Letta Code <noreply@letta.com>'\n</example>\n\nUse single quotes (not double quotes) and do NOT wrap the message in `$(...)` or backticks — single-quoting preserves the message verbatim (including `$VAR`, backticks, and other special characters) without needing escapes.\n";
 var init_ExecCommand = () => {};
 
 // src/tools/descriptions/ExitWorktree.md
@@ -89615,8 +89553,7 @@ The user has the ability to modify \`content\`. If modified, this will be stated
 var init_WriteFileGemini = () => {};
 
 // src/tools/descriptions/WriteStdin.md
-var WriteStdin_default = `Writes characters to an existing unified exec session and returns recent output.
-`;
+var WriteStdin_default = "Writes characters to an existing unified exec session and returns recent output.\n\nUse this tool to send input, interrupt a process, or inspect new output from a long-lived interactive process such as a dev server or REPL. Do not call it with empty `chars` merely to wait for completion; `exec_command` sends a notification when a yielded process completes. If the process needs a completion deadline, create a one-shot scheduled check instead of blocking or polling.\n";
 var init_WriteStdin = () => {};
 
 // src/tools/descriptions/WriteTodosGemini.md
@@ -92790,53 +92727,6 @@ var init_worktree_ownership = __esm(() => {
   ]);
 });
 
-// src/tools/impl/foreground-sleep.ts
-function commandRunsForegroundSleep(command) {
-  const segments = splitShellSegmentsAllowCommandSubstitution(command) ?? splitShellSegments(command);
-  if (!segments) {
-    return false;
-  }
-  for (const segment of segments) {
-    for (const word of tokenizeShellWords(segment)) {
-      if (SHELL_KEYWORDS.has(word)) {
-        continue;
-      }
-      if (ASSIGNMENT_PREFIX.test(word)) {
-        continue;
-      }
-      if (word.split("/").pop() === "sleep") {
-        return true;
-      }
-      break;
-    }
-  }
-  return false;
-}
-var FOREGROUND_SLEEP_BLOCKED_MESSAGE = 'Foreground `sleep` is blocked — it stalls the session while nothing happens. Run the wait in the background and keep working: use Bash with `run_in_background` and a command that exits when the condition is true, e.g. `until grep -q "Ready in" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits. For one notification per occurrence ("tell me every time an ERROR line appears"), use the Monitor tool instead. `sleep` inside `run_in_background` commands and Monitor scripts is fine.', SHELL_KEYWORDS, ASSIGNMENT_PREFIX;
-var init_foreground_sleep = __esm(() => {
-  SHELL_KEYWORDS = new Set([
-    "if",
-    "then",
-    "elif",
-    "else",
-    "fi",
-    "while",
-    "until",
-    "do",
-    "done",
-    "for",
-    "case",
-    "esac",
-    "{",
-    "}",
-    "(",
-    ")",
-    "!",
-    "time"
-  ]);
-  ASSIGNMENT_PREFIX = /^[A-Za-z_][A-Za-z0-9_]*=/;
-});
-
 // src/tools/impl/process_manager.ts
 var exports_process_manager = {};
 __export(exports_process_manager, {
@@ -95651,6 +95541,7 @@ __export(exports_bash, {
   getBackgroundLauncher: () => getBackgroundLauncher,
   bash: () => bash
 });
+import { rmSync as rmSync4 } from "node:fs";
 function rebuildCachedLauncher(command, secretEnv) {
   if (!cachedWorkingLauncher)
     return null;
@@ -95799,7 +95690,8 @@ async function bash(args) {
     signal,
     onOutput,
     secretEnv,
-    parentScope
+    parentScope,
+    foregroundYieldMs = DEFAULT_FOREGROUND_YIELD_MS
   } = args;
   const userCwd = getCurrentWorkingDirectory();
   const sanitizeOutput = (text) => scrubSecretsFromString(text, secretEnv ?? {});
@@ -95825,194 +95717,184 @@ async function bash(args) {
   const recoveredFrom = consumeWorkingDirectoryRecovery();
   const recoveryNote = recoveredFrom ? `Note: working directory ${recoveredFrom} no longer exists; running in ${userCwd} instead.
 ` : "";
-  if (run_in_background) {
-    try {
-      assertBackgroundProcessCapacity();
-    } catch (error4) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: error4 instanceof Error ? error4.message : String(error4)
-          }
-        ],
-        status: "error"
-      };
-    }
-    const bgEnv = secretEnv ? { ...getShellEnv(), ...secretEnv } : getShellEnv();
-    const bgCommand = withStrictShellPrelude(command, bgEnv);
-    const bashId = getNextBashId();
-    const outputFile = createBackgroundOutputFile(bashId);
-    const launcher = getBackgroundLauncher(bgCommand, bgEnv, secretEnv);
-    const [executable] = launcher;
-    if (!executable) {
-      return {
-        content: [{ type: "text", text: "No shell available" }],
-        status: "error"
-      };
-    }
-    noteExpectedWorktreeForLauncher(launcher, userCwd);
-    const sandboxed = applyShellSandbox(launcher, userCwd, bgEnv);
-    let bgProcess;
-    let outputWriteFailed = false;
-    const runningProcess = startShellProcess(sandboxed.launcher, {
-      cwd: userCwd,
-      env: sandboxed.env,
-      timeoutMs: timeout > 0 ? timeout : 0,
-      sourceCommand: command,
-      captureOutput: false,
-      onOutput(text, stream10) {
-        const sanitizedText = sanitizeOutput(text);
-        appendBackgroundProcessOutput(bgProcess, stream10, sanitizedText);
-        const wrote = appendToOutputFile(outputFile, stream10 === "stderr" ? `[stderr] ${sanitizedText}` : sanitizedText);
-        if (!wrote && bgProcess.status === "running") {
-          outputWriteFailed = true;
-          appendBackgroundProcessOutput(bgProcess, "stderr", "[output file write failed; output may be incomplete]");
-          bgProcess.status = "failed";
-          try {
-            runningProcess.process.kill("SIGTERM");
-          } catch {}
+  try {
+    assertBackgroundProcessCapacity();
+  } catch (error4) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: error4 instanceof Error ? error4.message : String(error4)
         }
-      }
-    });
-    bgProcess = {
-      process: runningProcess.process,
-      command,
-      stdout: [],
-      stderr: [],
-      status: "running",
-      exitCode: null,
-      lastReadIndex: { stdout: 0, stderr: 0 },
-      startTime: new Date,
-      outputFile,
-      totalStdoutLines: 0,
-      totalStderrLines: 0,
-      runtimeScope: parentScope,
-      secrets: secretEnv
+      ],
+      status: "error"
     };
-    backgroundProcesses.set(bashId, bgProcess);
-    const notificationScope = resolveNotificationScope(parentScope);
-    runningProcess.completion.then(({ exitCode }) => {
-      bgProcess.status = exitCode === 0 && !outputWriteFailed ? "completed" : "failed";
-      bgProcess.exitCode = exitCode;
-      appendToOutputFile(outputFile, `
+  }
+  const bgEnv = secretEnv ? { ...getShellEnv(), ...secretEnv } : getShellEnv();
+  const bgCommand = withStrictShellPrelude(command, bgEnv);
+  const bashId = getNextBashId();
+  const outputFile = createBackgroundOutputFile(bashId);
+  const launcher = getBackgroundLauncher(bgCommand, bgEnv, secretEnv);
+  const [executable] = launcher;
+  if (!executable) {
+    return {
+      content: [{ type: "text", text: "No shell available" }],
+      status: "error"
+    };
+  }
+  noteExpectedWorktreeForLauncher(launcher, userCwd);
+  const sandboxed = applyShellSandbox(launcher, userCwd, bgEnv);
+  let bgProcess;
+  let outputWriteFailed = false;
+  const foregroundOutput = { stdout: "", stderr: "" };
+  const effectiveTimeout = run_in_background ? timeout > 0 ? timeout : 0 : Math.min(Math.max(timeout, 1), 600000);
+  const runningProcess = startShellProcess(sandboxed.launcher, {
+    cwd: userCwd,
+    env: sandboxed.env,
+    timeoutMs: effectiveTimeout,
+    sourceCommand: command,
+    signal: run_in_background ? undefined : signal,
+    captureOutput: false,
+    onOutput(text, stream10) {
+      const sanitizedText = sanitizeOutput(text);
+      if (!run_in_background) {
+        foregroundOutput[stream10] += text;
+        onOutput?.(text, stream10);
+      }
+      appendBackgroundProcessOutput(bgProcess, stream10, sanitizedText);
+      const wrote = appendToOutputFile(outputFile, stream10 === "stderr" ? `[stderr] ${sanitizedText}` : sanitizedText);
+      if (!wrote && bgProcess.status === "running") {
+        outputWriteFailed = true;
+        appendBackgroundProcessOutput(bgProcess, "stderr", "[output file write failed; output may be incomplete]");
+        bgProcess.status = "failed";
+        try {
+          runningProcess.process.kill("SIGTERM");
+        } catch {}
+      }
+    }
+  });
+  bgProcess = {
+    process: runningProcess.process,
+    command,
+    stdout: [],
+    stderr: [],
+    status: "running",
+    exitCode: null,
+    lastReadIndex: { stdout: 0, stderr: 0 },
+    startTime: new Date,
+    outputFile,
+    totalStdoutLines: 0,
+    totalStderrLines: 0,
+    runtimeScope: parentScope,
+    secrets: secretEnv
+  };
+  backgroundProcesses.set(bashId, bgProcess);
+  const notificationScope = resolveNotificationScope(parentScope);
+  const settled = runningProcess.completion.then(({ exitCode }) => {
+    bgProcess.status = exitCode === 0 && !outputWriteFailed ? "completed" : "failed";
+    bgProcess.exitCode = exitCode;
+    appendToOutputFile(outputFile, `
 [exit code: ${exitCode}]
 `);
-      scrubCompletedBackgroundOutput(bgProcess);
-      notifyBackgroundCompletion({
-        bashId,
-        description,
-        outputFile,
-        bgProcess,
-        scope: notificationScope,
-        status: exitCode === 0 && !outputWriteFailed ? "completed" : "failed",
-        detail: outputWriteFailed ? "Output file write failed; output may be incomplete" : exitCode === null ? "Terminated by signal before exiting" : `Exit code: ${exitCode}`
-      });
-      scheduleBackgroundProcessCleanup(bashId);
-    }, (error4) => {
-      const err = error4;
-      const message = sanitizeOutput(err.killed ? `Command timed out after ${timeout}ms` : err.message);
-      bgProcess.status = "failed";
-      appendBackgroundProcessOutput(bgProcess, "stderr", message);
-      appendToOutputFile(outputFile, err.killed ? `
+    scrubCompletedBackgroundOutput(bgProcess);
+    return {
+      status: exitCode === 0 && !outputWriteFailed ? "completed" : "failed",
+      detail: outputWriteFailed ? "Output file write failed; output may be incomplete" : exitCode === null ? "Terminated by signal before exiting" : `Exit code: ${exitCode}`,
+      exitCode
+    };
+  }, (error4) => {
+    const err = error4;
+    const message = sanitizeOutput(err.killed ? `Command timed out after ${timeout}ms` : err.message);
+    bgProcess.status = "failed";
+    appendBackgroundProcessOutput(bgProcess, "stderr", message);
+    appendToOutputFile(outputFile, err.killed ? `
 [timeout after ${timeout}ms]
 ` : `
 [error] ${message}
 `);
-      scrubCompletedBackgroundOutput(bgProcess);
+    scrubCompletedBackgroundOutput(bgProcess);
+    return {
+      status: "failed",
+      detail: err.killed ? message : `Error: ${message}`,
+      error: err
+    };
+  });
+  const notifyWhenSettled = () => {
+    settled.then(({ status, detail }) => {
       notifyBackgroundCompletion({
         bashId,
         description,
         outputFile,
         bgProcess,
         scope: notificationScope,
-        status: "failed",
-        detail: err.killed ? message : `Error: ${message}`
+        status,
+        detail
       });
       scheduleBackgroundProcessCleanup(bashId);
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `${recoveryNote}Command running in background with ID: ${bashId}
-Output file: ${outputFile}`
+  };
+  if (!run_in_background) {
+    const outcome = await Promise.race([
+      settled.then((result) => ({ type: "settled", result })),
+      new Promise((resolve11) => {
+        const timer = setTimeout(() => resolve11({ type: "yield" }), Math.max(0, foregroundYieldMs));
+        if (typeof timer === "object" && timer !== null && "unref" in timer) {
+          timer.unref();
         }
-      ],
-      status: "success"
-    };
-  }
-  if (commandRunsForegroundSleep(command)) {
-    return {
-      content: [{ type: "text", text: FOREGROUND_SLEEP_BLOCKED_MESSAGE }],
-      status: "error"
-    };
-  }
-  const effectiveTimeout = Math.min(Math.max(timeout, 1), 600000);
-  try {
-    const { stdout, stderr, exitCode } = await spawnCommand(command, {
-      cwd: userCwd,
-      env: getShellEnv(),
-      timeout: effectiveTimeout,
-      signal,
-      onOutput,
-      secretEnv
-    });
-    let output = stdout;
-    if (stderr)
-      output = output ? `${output}
-${stderr}` : stderr;
-    const { content: truncatedOutput } = truncateByChars(output || "(Command completed with no output)", LIMITS.BASH_OUTPUT_CHARS, "Bash", { workingDirectory: userCwd, toolName: "Bash", secrets: secretEnv });
-    if (exitCode !== 0 && exitCode !== null) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${recoveryNote}Exit code: ${exitCode}
+      })
+    ]);
+    if (outcome.type === "settled") {
+      backgroundProcesses.delete(bashId);
+      rmSync4(outputFile, { force: true });
+      const { result } = outcome;
+      const output = [foregroundOutput.stdout, foregroundOutput.stderr].filter(Boolean).join(`
+`);
+      const { content: truncatedOutput } = truncateByChars(output || "(Command completed with no output)", LIMITS.BASH_OUTPUT_CHARS, "Bash", { workingDirectory: userCwd, toolName: "Bash", secrets: secretEnv });
+      if (result.status === "failed") {
+        const isAbort = signal?.aborted || "error" in result && (result.error.name === "AbortError" || result.error.code === "ABORT_ERR");
+        return {
+          content: [
+            {
+              type: "text",
+              text: isAbort ? INTERRUPTED_BY_USER : `${recoveryNote}${result.detail}
 ${truncatedOutput}`
-          }
-        ],
-        status: "error"
+            }
+          ],
+          status: "error"
+        };
+      }
+      return {
+        content: [{ type: "text", text: `${recoveryNote}${truncatedOutput}` }],
+        status: "success"
       };
     }
-    return {
-      content: [{ type: "text", text: `${recoveryNote}${truncatedOutput}` }],
-      status: "success"
-    };
-  } catch (error4) {
-    const err = error4;
-    const isAbort = signal?.aborted || err.code === "ABORT_ERR" || err.name === "AbortError" || err.message === "The operation was aborted";
-    let errorMessage = "";
-    if (isAbort) {
-      errorMessage = INTERRUPTED_BY_USER;
-    } else {
-      if (err.killed && err.signal === "SIGTERM")
-        errorMessage = `Command timed out after ${effectiveTimeout}ms
-`;
-      if (err.code && typeof err.code === "number")
-        errorMessage += `Exit code: ${err.code}
-`;
-      if (err.stderr)
-        errorMessage += err.stderr;
-      else if (err.message)
-        errorMessage += err.message;
-      if (err.stdout)
-        errorMessage = `${err.stdout}
-${errorMessage}`;
-    }
-    const { content: truncatedError } = truncateByChars(errorMessage.trim() || "Command failed with unknown error", LIMITS.BASH_OUTPUT_CHARS, "Bash", { workingDirectory: userCwd, toolName: "Bash", secrets: secretEnv });
+    backgroundProcesses.set(bashId, bgProcess);
+    notifyWhenSettled();
     return {
       content: [
         {
           type: "text",
-          text: isAbort ? truncatedError : `${recoveryNote}${truncatedError}`
+          text: `${recoveryNote}Command is still running with task ID: ${bashId}
+Output file: ${outputFile}
+You will be notified when it completes. Do not poll unless you need intermediate output.`
         }
       ],
-      status: "error"
+      status: "success"
     };
   }
+  notifyWhenSettled();
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${recoveryNote}Command running in background with ID: ${bashId}
+Output file: ${outputFile}`
+      }
+    ],
+    status: "success"
+  };
 }
-var cachedWorkingLauncher = null, NOTIFICATION_TAIL_LINES = 50;
+var cachedWorkingLauncher = null, DEFAULT_FOREGROUND_YIELD_MS = 1e4, NOTIFICATION_TAIL_LINES = 50;
 var init_bash = __esm(() => {
   init_constants2();
   init_runtime_context();
@@ -96020,7 +95902,6 @@ var init_bash = __esm(() => {
   init_message_queue_bridge();
   init_task_notifications();
   init_worktree_ownership();
-  init_foreground_sleep();
   init_process_manager();
   init_shell_env();
   init_shell_launchers();
@@ -96883,98 +96764,6 @@ var init_connection = __esm(() => {
   resumeStateByRuntime = new WeakMap;
 });
 
-// src/cli/helpers/git-context.ts
-import { execFileSync } from "node:child_process";
-function runGit(args, cwd) {
-  try {
-    return execFileSync("git", args, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-function truncateLines(value, maxLines) {
-  const lines = value.split(`
-`);
-  if (lines.length <= maxLines) {
-    return value;
-  }
-  return lines.slice(0, maxLines).join(`
-`) + `
-... and ${lines.length - maxLines} more changes`;
-}
-function formatGitUser(name, email) {
-  if (!name && !email) {
-    return null;
-  }
-  if (name && email) {
-    return `${name} <${email}>`;
-  }
-  return name || email;
-}
-function gatherGitContextSnapshot(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const recentCommitLimit = options.recentCommitLimit ?? 3;
-  if (!runGit(["rev-parse", "--git-dir"], cwd)) {
-    return {
-      isGitRepo: false,
-      branch: null,
-      status: null,
-      recentCommits: null,
-      gitUser: null
-    };
-  }
-  const branch = runGit(["branch", "--show-current"], cwd);
-  const fullStatus = runGit(["status", "--short"], cwd);
-  const status = typeof fullStatus === "string" && options.statusLineLimit ? truncateLines(fullStatus, options.statusLineLimit) : fullStatus;
-  const recentCommits = options.recentCommitFormat ? runGit([
-    "log",
-    `--format=${options.recentCommitFormat}`,
-    "-n",
-    String(recentCommitLimit)
-  ], cwd) : runGit(["log", "--oneline", "-n", String(recentCommitLimit)], cwd);
-  const userConfig = runGit(["config", "--get-regexp", "^user\\.(name|email)$"], cwd);
-  let userName = null;
-  let userEmail = null;
-  if (userConfig) {
-    for (const line of userConfig.split(`
-`)) {
-      if (line.startsWith("user.name "))
-        userName = line.slice("user.name ".length);
-      else if (line.startsWith("user.email "))
-        userEmail = line.slice("user.email ".length);
-    }
-  }
-  const gitUser = formatGitUser(userName, userEmail);
-  return {
-    isGitRepo: true,
-    branch,
-    status,
-    recentCommits,
-    gitUser
-  };
-}
-function getGitContext(cwd) {
-  if (!runGit(["rev-parse", "--git-dir"], cwd)) {
-    return null;
-  }
-  const branch = runGit(["branch", "--show-current"], cwd);
-  const branchList = runGit([
-    "branch",
-    "--sort=-committerdate",
-    "--format=%(refname:short)",
-    "--no-color"
-  ], cwd);
-  const recentBranches = branchList ? branchList.split(`
-`).map((b) => b.trim()).filter((b) => b.length > 0 && b !== branch).slice(0, 10) : [];
-  return { branch, recent_branches: recentBranches };
-}
-var init_git_context = () => {};
-
 // src/cli/helpers/memory-reminder.ts
 function isValidStepCount(value) {
   return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
@@ -97415,6 +97204,169 @@ var init_constants3 = __esm(() => {
   SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
 });
 
+// src/cli/helpers/git-context.ts
+import { execFile as execFile2, execFileSync } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+function runGit(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function runGitAsync(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      windowsHide: true
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function truncateLines(value, maxLines) {
+  const lines = value.split(`
+`);
+  if (lines.length <= maxLines) {
+    return value;
+  }
+  return lines.slice(0, maxLines).join(`
+`) + `
+... and ${lines.length - maxLines} more changes`;
+}
+function formatGitUser(name, email) {
+  if (!name && !email) {
+    return null;
+  }
+  if (name && email) {
+    return `${name} <${email}>`;
+  }
+  return name || email;
+}
+function gatherGitContextSnapshot(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const recentCommitLimit = options.recentCommitLimit ?? 3;
+  if (!runGit(["rev-parse", "--git-dir"], cwd)) {
+    return {
+      isGitRepo: false,
+      branch: null,
+      status: null,
+      recentCommits: null,
+      gitUser: null
+    };
+  }
+  const branch = runGit(["branch", "--show-current"], cwd);
+  const fullStatus = runGit(["status", "--short"], cwd);
+  const status = typeof fullStatus === "string" && options.statusLineLimit ? truncateLines(fullStatus, options.statusLineLimit) : fullStatus;
+  const recentCommits = options.recentCommitFormat ? runGit([
+    "log",
+    `--format=${options.recentCommitFormat}`,
+    "-n",
+    String(recentCommitLimit)
+  ], cwd) : runGit(["log", "--oneline", "-n", String(recentCommitLimit)], cwd);
+  const userConfig = runGit(["config", "--get-regexp", "^user\\.(name|email)$"], cwd);
+  let userName = null;
+  let userEmail = null;
+  if (userConfig) {
+    for (const line of userConfig.split(`
+`)) {
+      if (line.startsWith("user.name "))
+        userName = line.slice("user.name ".length);
+      else if (line.startsWith("user.email "))
+        userEmail = line.slice("user.email ".length);
+    }
+  }
+  const gitUser = formatGitUser(userName, userEmail);
+  return {
+    isGitRepo: true,
+    branch,
+    status,
+    recentCommits,
+    gitUser
+  };
+}
+async function getGitContextAsync(cwd) {
+  if (!await runGitAsync(["rev-parse", "--git-dir"], cwd)) {
+    return null;
+  }
+  const branch = await runGitAsync(["branch", "--show-current"], cwd);
+  const branchList = await runGitAsync([
+    "branch",
+    "--sort=-committerdate",
+    "--format=%(refname:short)",
+    "--no-color"
+  ], cwd);
+  const recentBranches = branchList ? branchList.split(`
+`).map((b) => b.trim()).filter((b) => b.length > 0 && b !== branch).slice(0, 10) : [];
+  return { branch, recent_branches: recentBranches };
+}
+var execFileAsync;
+var init_git_context = __esm(() => {
+  execFileAsync = promisify3(execFile2);
+});
+
+// src/websocket/listener/device-git-context.ts
+class DeviceGitContextCache {
+  load;
+  now;
+  entries = new Map;
+  pending = new Map;
+  constructor(load = getGitContextAsync, now = Date.now) {
+    this.load = load;
+    this.now = now;
+  }
+  read(cwd) {
+    const cached2 = this.entries.get(cwd);
+    if (cached2 && cached2.expiresAt > this.now()) {
+      return cached2.value;
+    }
+    return cached2?.value ?? null;
+  }
+  async refresh(cwd, options = {}) {
+    const cached2 = this.entries.get(cwd);
+    if (!options.force && cached2 && cached2.expiresAt > this.now()) {
+      return cached2.value;
+    }
+    const pending = this.pending.get(cwd);
+    if (pending) {
+      return pending;
+    }
+    const load = this.load(cwd).then((value) => {
+      this.entries.set(cwd, {
+        expiresAt: this.now() + GIT_CONTEXT_CACHE_TTL_MS,
+        value
+      });
+      this.prune();
+      return value;
+    }).finally(() => {
+      this.pending.delete(cwd);
+    });
+    this.pending.set(cwd, load);
+    return load;
+  }
+  prune() {
+    if (this.entries.size <= MAX_GIT_CONTEXT_CACHE_ENTRIES) {
+      return;
+    }
+    const oldestKey = this.entries.keys().next().value;
+    if (oldestKey) {
+      this.entries.delete(oldestKey);
+    }
+  }
+}
+var GIT_CONTEXT_CACHE_TTL_MS = 15000, MAX_GIT_CONTEXT_CACHE_ENTRIES = 64, deviceGitContextCache;
+var init_device_git_context = __esm(() => {
+  init_git_context();
+  deviceGitContextCache = new DeviceGitContextCache;
+});
+
 // src/websocket/listener/device-status-cache.ts
 function recordDeviceStatus(transport, scope, status) {
   shouldEmitDeviceStatus(transport, scope, status, true);
@@ -97443,6 +97395,7 @@ var SUPPORTED_REMOTE_COMMANDS;
 var init_listener_constants = __esm(() => {
   SUPPORTED_REMOTE_COMMANDS = [
     "clear",
+    "clear-messages",
     "doctor",
     "init",
     "remember",
@@ -97505,7 +97458,7 @@ function terminateStalledTransport(transport, state, reason) {
     state.pollTimer = null;
   }
   recordOutboundQueuePerf("queue:killed", 1);
-  console.error(`[Listen Wire] Terminating stalled transport (${reason})`);
+  debugWarn("Listen Wire", `Terminating stalled transport (${reason})`);
   if (getListenerTransportKind(transport) === "websocket") {
     const ws = transport;
     try {
@@ -97886,7 +97839,7 @@ function notifyStreamObservers(listener, message, runtimeScope) {
     try {
       observer(observed);
     } catch (error4) {
-      console.error("[Listen V2] Stream observer failed", error4);
+      debugWarn("Listen V2", "Stream observer failed", error4);
     }
   }
 }
@@ -97901,11 +97854,14 @@ function notifyStreamObserversRuntimeStopped(listener) {
     try {
       observer(observed);
     } catch (error4) {
-      console.error("[Listen V2] Stream observer failed on stop", error4);
+      debugWarn("Listen V2", "Stream observer failed on stop", error4);
     }
   }
   listener.streamObservers.clear();
 }
+var init_stream_observers = __esm(() => {
+  init_debug();
+});
 
 // src/websocket/listener/inbound-queue.ts
 function getInboundClientMessageId(incoming) {
@@ -98010,6 +97966,7 @@ var init_turn_correlation = __esm(() => {
 // src/websocket/listener/protocol-outbound.ts
 var exports_protocol_outbound = {};
 __export(exports_protocol_outbound, {
+  refreshDeviceGitContext: () => refreshDeviceGitContext,
   isSystemReminderPart: () => isSystemReminderPart,
   emitSubagentStateUpdate: () => emitSubagentStateUpdate,
   emitSubagentStateIfOpen: () => emitSubagentStateIfOpen,
@@ -98048,25 +98005,6 @@ function getProtocolPerfKey(message) {
   }
   return message.type;
 }
-function getCachedDeviceGitContext(cwd) {
-  const now = Date.now();
-  const cached2 = gitContextCache.get(cwd);
-  if (cached2 && cached2.expiresAt > now) {
-    return cached2.value;
-  }
-  const value = getGitContext(cwd);
-  gitContextCache.set(cwd, {
-    expiresAt: now + GIT_CONTEXT_CACHE_TTL_MS,
-    value
-  });
-  if (gitContextCache.size > MAX_GIT_CONTEXT_CACHE_ENTRIES) {
-    const oldestKey = gitContextCache.keys().next().value;
-    if (oldestKey) {
-      gitContextCache.delete(oldestKey);
-    }
-  }
-  return value;
-}
 function getListenerRuntime(runtime) {
   if (!runtime)
     return null;
@@ -98081,6 +98019,18 @@ function getScopeForRuntime(runtime, scope) {
   }
   return scope ?? {};
 }
+function getDeviceStatusWorkingDirectory(runtime, params) {
+  const listener = getListenerRuntime(runtime);
+  if (!listener) {
+    return process.cwd();
+  }
+  const scope = getScopeForRuntime(runtime, params);
+  const conversationRuntime = getConversationRuntime(listener, resolveScopedAgentId(listener, scope), resolveScopedConversationId(listener, scope));
+  return conversationRuntime?.activeWorkingDirectory ?? getConversationWorkingDirectory(listener, resolveScopedAgentId(listener, scope), resolveScopedConversationId(listener, scope));
+}
+async function refreshDeviceGitContext(runtime, params) {
+  await deviceGitContextCache.refresh(getDeviceStatusWorkingDirectory(runtime, params));
+}
 function emitRuntimeStateUpdates(runtime, scope) {
   emitLoopStatusIfOpen(runtime, scope);
   emitDeviceStatusIfOpen(runtime, scope);
@@ -98096,7 +98046,7 @@ function buildDeviceStatus(runtime, params) {
       is_processing: false,
       current_permission_mode: permissionMode.getMode(),
       current_working_directory: fallbackCwd,
-      git_context: getCachedDeviceGitContext(fallbackCwd),
+      git_context: deviceGitContextCache.read(fallbackCwd),
       letta_code_version: process.env.npm_package_version || null,
       current_toolset: null,
       current_toolset_preference: "auto",
@@ -98149,7 +98099,7 @@ function buildDeviceStatus(runtime, params) {
     is_processing: !!conversationRuntime?.isProcessing,
     current_permission_mode: conversationPermissionModeState.mode,
     current_working_directory: resolvedCwd,
-    git_context: getCachedDeviceGitContext(resolvedCwd),
+    git_context: deviceGitContextCache.read(resolvedCwd),
     letta_code_version: process.env.npm_package_version || null,
     current_toolset: conversationRuntime?.currentToolset ?? (toolsetPreference === "auto" ? null : toolsetPreference),
     current_toolset_preference: conversationRuntime?.currentToolset === null ? toolsetPreference : conversationRuntime?.currentToolsetPreference ?? toolsetPreference,
@@ -98253,7 +98203,7 @@ function emitProtocolV2Message(socket, runtime, message, scope, routing) {
         try {
           payload = JSON.stringify(outbound);
         } catch (error4) {
-          console.error(`[Listen V2] Failed to emit ${message.type} (seq=${eventSeq})`, error4);
+          debugWarn("Listen V2", `Failed to emit ${message.type} (seq=${eventSeq})`, error4);
           safeEmitWsEvent("send", "lifecycle", {
             type: "_ws_send_error",
             message_type: message.type,
@@ -98266,15 +98216,13 @@ function emitProtocolV2Message(socket, runtime, message, scope, routing) {
           payload,
           perfKey: getProtocolPerfKey(message),
           onSent: () => {
-            if (isDebugEnabled()) {
-              console.log(`[Listen V2] Emitting ${message.type} (seq=${eventSeq})`);
-            }
+            debugLog("Listen V2", `Emitting ${message.type} (seq=${eventSeq})`);
             safeEmitWsEvent("send", "protocol", outbound);
           }
         };
       },
       onSendError: (error4) => {
-        console.error(`[Listen V2] Failed to emit ${message.type}`, error4);
+        debugWarn("Listen V2", `Failed to emit ${message.type}`, error4);
         safeEmitWsEvent("send", "lifecycle", {
           type: "_ws_send_error",
           message_type: message.type,
@@ -98580,11 +98528,10 @@ function emitStreamDelta(socket, runtime, delta2, scope, subagentId) {
   };
   emitProtocolV2Message(socket, runtime, message, scope, TO_SUBSCRIBERS);
 }
-var GIT_CONTEXT_CACHE_TTL_MS = 15000, MAX_GIT_CONTEXT_CACHE_ENTRIES = 64, FROZEN_SUPPORTED_COMMANDS, gitContextCache;
+var FROZEN_SUPPORTED_COMMANDS;
 var init_protocol_outbound = __esm(() => {
   init_memory_filesystem2();
   init_subagent_state();
-  init_git_context();
   init_memory_reminder();
   init_system_prompt_warning();
   init_constants2();
@@ -98597,16 +98544,17 @@ var init_protocol_outbound = __esm(() => {
   init_connection();
   init_constants3();
   init_cwd();
+  init_device_git_context();
   init_device_status_cache();
   init_listener_constants();
   init_outbound_wire();
   init_permission_mode();
   init_protocol_outbound_routing();
   init_runtime();
+  init_stream_observers();
   init_transport();
   init_turn_correlation();
   FROZEN_SUPPORTED_COMMANDS = [...SUPPORTED_REMOTE_COMMANDS];
-  gitContextCache = new Map;
 });
 
 // src/websocket/listener/cwd-change.ts
@@ -98651,10 +98599,13 @@ async function switchConversationWorkingDirectory(params) {
   }
   if (params.emitStatus !== false) {
     const statusTransport = params.statusSocket ?? getOrCreateProcessTransport(runtime);
-    emitDeviceStatusUpdate(statusTransport, params.statusRuntime ?? conversationRuntime ?? runtime, {
+    const statusRuntime = params.statusRuntime ?? conversationRuntime ?? runtime;
+    const statusScope = {
       agent_id: agentId,
       conversation_id: conversationId
-    });
+    };
+    await refreshDeviceGitContext(statusRuntime, statusScope);
+    emitDeviceStatusUpdate(statusTransport, statusRuntime, statusScope);
   }
 }
 var init_cwd_change = __esm(() => {
@@ -98685,7 +98636,7 @@ function startWorktreeWatcher(params) {
   }).catch((err) => {
     if (err.name === "AbortError")
       return;
-    console.error("[WorktreeWatcher] watch loop error:", err);
+    debugWarn("WorktreeWatcher", "watch loop error:", err);
   });
   return state;
 }
@@ -98741,7 +98692,7 @@ async function runWatchLoop(params) {
         agentId,
         conversationId
       }).catch((err) => {
-        console.error("[WorktreeWatcher] failed to handle new worktree:", err);
+        debugWarn("WorktreeWatcher", "failed to handle new worktree:", err);
       });
     }, DEBOUNCE_MS);
   }
@@ -98761,7 +98712,7 @@ async function handleNewWorktree(params) {
     return;
   }
   clearExpectedWorktreePath(conversationRuntime);
-  console.log(`[WorktreeWatcher] New worktree detected: ${newWorktreePath} — switching CWD`);
+  debugLog("WorktreeWatcher", `New worktree detected: ${newWorktreePath} — switching CWD`);
   await switchConversationWorkingDirectory({
     runtime,
     agentId,
@@ -98794,6 +98745,7 @@ async function safeReaddir(dir) {
 }
 var WORKTREES_DIR = ".letta/worktrees", DEBOUNCE_MS = 500;
 var init_worktree_watcher = __esm(() => {
+  init_debug();
   init_cwd();
   init_cwd_change();
   init_runtime();
@@ -99839,6 +99791,7 @@ function formatExecOutput(params) {
   }
   if (params.sessionId !== null) {
     sections.push(`Process running with session ID ${params.sessionId}`);
+    sections.push("You will be notified when the process completes. Do not poll unless you need the output before continuing.");
   }
   sections.push(`Original token count: ${params.originalTokenCount}`);
   sections.push("Output:");
@@ -99909,7 +99862,7 @@ function createSessionOutputAppender(params) {
       appendSessionOutput(params.session, `
 [output file write failed; output may be incomplete]
 `, "stderr");
-      markSessionFailed(params.session);
+      markSessionFailed(params.session, "Output file write failed; output may be incomplete");
       const bgProc = backgroundProcesses.get(params.session.id);
       if (bgProc) {
         try {
@@ -99919,19 +99872,61 @@ function createSessionOutputAppender(params) {
     }
   };
 }
-function markSessionFailed(session) {
+function notifyExecCompletion(session) {
+  if (!session.notificationArmed || session.completionDelivered || session.activeWriteStdinCalls > 0) {
+    return;
+  }
+  const backgroundProcess = backgroundProcesses.get(session.id);
+  if (backgroundProcess?.completionNotificationSuppressed) {
+    session.completionDelivered = true;
+    return;
+  }
+  session.completionDelivered = true;
+  const status = session.status === "completed" ? "completed" : "failed";
+  const unreadOutput = session.output.slice(session.readOffset) || "(no new output)";
+  const { content: result } = truncateByChars(scrubSecretsFromString([
+    `$ ${session.command}`,
+    `Session ID: ${session.id}`,
+    session.completionDetail,
+    unreadOutput
+  ].filter(Boolean).join(`
+
+`), session.secrets), LIMITS.BASH_NOTIFICATION_CHARS, "exec_command", { useMiddleTruncation: true });
+  const durationMs = backgroundProcess?.startTime ? Math.max(0, Date.now() - backgroundProcess.startTime.getTime()) : undefined;
+  addToMessageQueue({
+    kind: "task_notification",
+    text: formatTaskNotification({
+      taskId: `exec_${session.id}`,
+      status,
+      summary: `Exec command "${session.description?.trim() || session.command}" ${status}`,
+      result,
+      outputFile: session.outputFile,
+      usage: durationMs === undefined ? undefined : { durationMs }
+    }),
+    agentId: session.notificationScope?.agentId,
+    conversationId: session.notificationScope?.conversationId
+  });
+}
+function markSessionFailed(session, detail) {
+  if (session.status !== "running")
+    return;
   session.status = "failed";
+  session.completionDetail = detail;
   const bgProcess = backgroundProcesses.get(session.id);
   if (bgProcess) {
     bgProcess.status = "failed";
     scrubCompletedBackgroundOutput(bgProcess);
     scheduleBackgroundProcessCleanup(session.id);
   }
+  notifyExecCompletion(session);
   scheduleExecSessionCleanup(session.id);
 }
 function markSessionClosed(session, code2) {
+  if (session.status !== "running")
+    return;
   session.status = code2 === 0 && !session.outputWriteFailed ? "completed" : "failed";
   session.exitCode = code2;
+  session.completionDetail = code2 === null ? "Terminated by signal before exiting" : `Exit code: ${code2}`;
   const bgProcess = backgroundProcesses.get(session.id);
   if (bgProcess) {
     bgProcess.status = session.status;
@@ -99939,6 +99934,7 @@ function markSessionClosed(session, code2) {
     scrubCompletedBackgroundOutput(bgProcess);
     scheduleBackgroundProcessCleanup(session.id);
   }
+  notifyExecCompletion(session);
   scheduleExecSessionCleanup(session.id);
 }
 async function waitForSessionOutput(params) {
@@ -99986,13 +99982,19 @@ async function startExecSession(args) {
   const session = {
     id: id2,
     command: args.cmd,
+    description: args.description,
     output: "",
+    outputFile,
     chunks: [],
     readOffset: 0,
     status: "running",
     exitCode: null,
     tty: args.tty ?? false,
-    secrets: args.secretEnv ?? {}
+    secrets: args.secretEnv ?? {},
+    notificationScope: resolveNotificationScope(args.parentScope),
+    notificationArmed: false,
+    completionDelivered: false,
+    activeWriteStdinCalls: 0
   };
   execSessions.set(id2, session);
   const appendOutput = createSessionOutputAppender({
@@ -100041,7 +100043,7 @@ async function startExecSession(args) {
     if (error4 instanceof ShellExecutionError) {
       appendOutput(error4.message, "stderr");
     }
-    markSessionFailed(session);
+    markSessionFailed(session, `Error: ${error4 instanceof Error ? error4.message : String(error4)}`);
   });
   return session;
 }
@@ -100060,6 +100062,9 @@ async function exec_command(args) {
     onOutput: args.onOutput
   });
   const sessionId = session.status === "running" ? session.id : null;
+  if (sessionId !== null) {
+    session.notificationArmed = true;
+  }
   const formattedOutput = formatExecOutput({
     chunkId: generateChunkId(),
     wallTimeMs,
@@ -100093,19 +100098,35 @@ async function write_stdin(args) {
       throw new Error("stdin is closed for this session; rerun exec_command with tty=true to keep stdin open");
     }
   }
-  if (chars && session.tty) {
-    backgroundProcess.process.write(chars);
-    await sleep9(100, args.signal);
+  session.activeWriteStdinCalls++;
+  let output;
+  let wallTimeMs;
+  let waitCompleted = false;
+  try {
+    if (chars && session.tty) {
+      backgroundProcess.process.write(chars);
+      await sleep9(100, args.signal);
+    }
+    const startOffset = session.readOffset;
+    const yieldTimeMs = clampWriteStdinYieldTime(args.yield_time_ms, chars);
+    ({ output, wallTimeMs } = await waitForSessionOutput({
+      session,
+      startOffset,
+      yieldTimeMs,
+      signal: args.signal,
+      onOutput: args.onOutput
+    }));
+    waitCompleted = true;
+  } finally {
+    session.activeWriteStdinCalls--;
+    if (session.status !== "running") {
+      if (waitCompleted) {
+        session.completionDelivered = true;
+      } else {
+        notifyExecCompletion(session);
+      }
+    }
   }
-  const startOffset = session.readOffset;
-  const yieldTimeMs = clampWriteStdinYieldTime(args.yield_time_ms, chars);
-  const { output, wallTimeMs } = await waitForSessionOutput({
-    session,
-    startOffset,
-    yieldTimeMs,
-    signal: args.signal,
-    onOutput: args.onOutput
-  });
   const nextSessionId = session.status === "running" ? session.id : null;
   const formattedOutput = formatExecOutput({
     chunkId: generateChunkId(),
@@ -100128,6 +100149,8 @@ var DEFAULT_EXEC_YIELD_TIME_MS = 1e4, DEFAULT_WRITE_STDIN_YIELD_TIME_MS = 250, M
 var init_exec_command = __esm(() => {
   init_runtime_context();
   init_secret_substitution();
+  init_message_queue_bridge();
+  init_task_notifications();
   init_worktree_ownership();
   init_process_manager();
   init_shell();
@@ -100302,9 +100325,9 @@ var init_exit_worktree = __esm(() => {
 });
 
 // src/tools/impl/glob.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import * as path20 from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 function applyFileLimit(files, workingDirectory) {
   const totalFiles = files.length;
   if (totalFiles <= LIMITS.GLOB_MAX_FILES) {
@@ -100342,7 +100365,7 @@ async function glob(args) {
     baseDir
   ];
   try {
-    const { stdout } = await execFileAsync(rgPath, rgArgs, {
+    const { stdout } = await execFileAsync2(rgPath, rgArgs, {
       maxBuffer: 50 * 1024 * 1024,
       cwd: userCwd,
       signal
@@ -100366,12 +100389,12 @@ async function glob(args) {
     throw new Error(`Glob failed: ${err.message || "Unknown error"}`);
   }
 }
-var execFileAsync;
+var execFileAsync2;
 var init_glob = __esm(() => {
   init_runtime_context();
   init_ripgrep_manager();
   init_truncation();
-  execFileAsync = promisify3(execFile2);
+  execFileAsync2 = promisify4(execFile3);
 });
 
 // src/tools/impl/glob-gemini.ts
@@ -100390,9 +100413,9 @@ var init_glob_gemini = __esm(() => {
 });
 
 // src/tools/impl/grep.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import * as path21 from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 function applyOffsetAndLimit(items3, offset, limit3) {
   const sliced = items3.slice(offset);
   if (limit3 > 0) {
@@ -100454,7 +100477,7 @@ async function grep(args) {
   else
     rgArgs.push(userCwd);
   try {
-    const { stdout } = await execFileAsync2(rgPath, rgArgs, {
+    const { stdout } = await execFileAsync3(rgPath, rgArgs, {
       maxBuffer: 10 * 1024 * 1024,
       cwd: userCwd,
       signal
@@ -100549,12 +100572,12 @@ Found 0 total occurrences across 0 files.`,
     throw new Error(`Grep failed: ${message}`);
   }
 }
-var execFileAsync2;
+var execFileAsync3;
 var init_grep = __esm(() => {
   init_runtime_context();
   init_ripgrep_manager();
   init_truncation();
-  execFileAsync2 = promisify4(execFile3);
+  execFileAsync3 = promisify5(execFile4);
 });
 
 // src/tools/impl/grep-files.ts
@@ -104406,13 +104429,13 @@ var exports_image_resize_sips = {};
 __export(exports_image_resize_sips, {
   convertHeicToJpegWithSips: () => convertHeicToJpegWithSips
 });
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { mkdtemp, readFile as readFile10, rm as rm5, writeFile as writeFile8 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
 import { join as join23 } from "node:path";
-function execFileAsync3(file, args) {
+function execFileAsync4(file, args) {
   return new Promise((resolve19, reject) => {
-    execFile4(file, args, (error4) => {
+    execFile5(file, args, (error4) => {
       if (error4) {
         reject(error4);
         return;
@@ -104427,7 +104450,7 @@ async function convertHeicToJpegWithSips(buffer) {
   const outputPath = join23(workDir, "output.jpg");
   try {
     await writeFile8(inputPath, buffer);
-    await execFileAsync3("/usr/bin/sips", [
+    await execFileAsync4("/usr/bin/sips", [
       "-s",
       "format",
       "jpeg",
@@ -114801,10 +114824,13 @@ function buildSubagentArgs(type3, config, model, userPrompt, existingAgentId, ex
     args.push("--backend", options.backendMode);
   }
   if (options.environment) {
-    args.push("--environment", options.environment);
+    args.push("--computer", options.environment);
   }
   if (isDeployingExisting) {
     if (existingConversationId) {
+      if (existingConversationId === "default" && existingAgentId) {
+        args.push("--agent", existingAgentId);
+      }
       args.push("--conv", existingConversationId);
     } else if (existingAgentId) {
       args.push("--agent", existingAgentId, "--new");
@@ -116176,7 +116202,7 @@ For commands that are harder to parse at a glance (piped commands, obscure flags
       },
       run_in_background: {
         type: "boolean",
-        description: "Set to true to run this command in the background. Use TaskOutput to read the output later."
+        description: "Set to true only when the command should return a task ID immediately. Ordinary commands already yield automatically if they are still running after a brief wait, and completion is delivered without polling."
       }
     },
     required: ["command", "description"],
@@ -116747,7 +116773,7 @@ var init_Monitor2 = __esm(() => {
     properties: {
       description: {
         type: "string",
-        description: "Short human-readable description of what you are monitoring (shown in notifications)."
+        description: "Clear, concise user-facing description of the update you are waiting for. This may be shown directly in chat, so make it grammatical by itself. Describe the expected event, not the polling command or monitor implementation. Prefer `CI results and review comments for the auth fix`, `Deployment completion or failure`, or `New errors in the API logs` over internal labels like `PR checks and state transitions`."
       },
       timeout_ms: {
         type: "number",
@@ -126691,12 +126717,12 @@ import {
   mkdirSync as mkdirSync15,
   readFileSync as readFileSync13,
   renameSync as renameSync3,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { homedir as homedir21, platform as platform3 } from "node:os";
 import { dirname as dirname21, isAbsolute as isAbsolute21, join as join32 } from "node:path";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 function getAgentRootDir(agentId) {
   return join32(homedir21(), ".letta", "agents", agentId);
 }
@@ -126836,7 +126862,7 @@ async function syncRepoMount(args) {
         timeoutMs: GIT_CLONE_TIMEOUT_MS
       });
     } catch (err) {
-      rmSync4(args.directory, { recursive: true, force: true });
+      rmSync5(args.directory, { recursive: true, force: true });
       throw err;
     }
   } else if (!existsSync25(join32(args.directory, ".git"))) {
@@ -126974,7 +127000,7 @@ async function runGit3(cwd, args, token, options) {
   const timeoutMs = options?.timeoutMs ?? GIT_DEFAULT_TIMEOUT_MS;
   let result;
   try {
-    result = await execFile5("git", allArgs, {
+    result = await execFile6("git", allArgs, {
       cwd,
       env: buildNonInteractiveGitEnv2(),
       maxBuffer: 10485760,
@@ -127572,7 +127598,7 @@ async function cloneMemoryRepo(agentId) {
     const tmpDir = `${dir}-git-clone-tmp`;
     try {
       if (existsSync25(tmpDir)) {
-        rmSync4(tmpDir, { recursive: true, force: true });
+        rmSync5(tmpDir, { recursive: true, force: true });
       }
       mkdirSync15(tmpDir, { recursive: true });
       await runGitWithRetry(tmpDir, ["clone", url, "."], token, {
@@ -127590,7 +127616,7 @@ async function cloneMemoryRepo(agentId) {
       debugLog("memfs-git", "Migrated existing memory directory to git repo");
     } finally {
       if (existsSync25(tmpDir)) {
-        rmSync4(tmpDir, { recursive: true, force: true });
+        rmSync5(tmpDir, { recursive: true, force: true });
       }
     }
   }
@@ -127885,7 +127911,7 @@ async function addGitMemoryTag(agentId, prefetchedAgent) {
     debugWarn("memfs-git", `Failed to add git-memory tag: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-var execFile5, RETRYABLE_GIT_HTTP_ERROR_RE, RETRYABLE_GIT_NETWORK_ERROR_RE, MISSING_CWD_GIT_ERROR_RE, NON_FAST_FORWARD_PUSH_ERROR_RE, UNRELATED_HISTORY_PULL_ERROR_RE, NO_UPSTREAM_PULL_ERROR_RE, AGENT_DISPLAY_NAME_TIMEOUT_MS = 3000, HOSTED_BACKEND_HEADER2 = "x-letta-memfs-backend", HOSTED_BACKEND_VALUE2 = "hosted", GIT_DEFAULT_TIMEOUT_MS = 60000, GIT_CLONE_TIMEOUT_MS = 180000, gitConfig = (dir, args) => withSerializedGitConfigMutation(dir, () => runGit3(dir, args)), MEMORY_REPOSITORY_CONFIG_KEY = "letta.memoryRepository.url", MEMORY_REPOSITORY_PUSH_LOG = "memory-repository-push.log";
+var execFile6, RETRYABLE_GIT_HTTP_ERROR_RE, RETRYABLE_GIT_NETWORK_ERROR_RE, MISSING_CWD_GIT_ERROR_RE, NON_FAST_FORWARD_PUSH_ERROR_RE, UNRELATED_HISTORY_PULL_ERROR_RE, NO_UPSTREAM_PULL_ERROR_RE, AGENT_DISPLAY_NAME_TIMEOUT_MS = 3000, HOSTED_BACKEND_HEADER2 = "x-letta-memfs-backend", HOSTED_BACKEND_VALUE2 = "hosted", GIT_DEFAULT_TIMEOUT_MS = 60000, GIT_CLONE_TIMEOUT_MS = 180000, gitConfig = (dir, args) => withSerializedGitConfigMutation(dir, () => runGit3(dir, args)), MEMORY_REPOSITORY_CONFIG_KEY = "letta.memoryRepository.url", MEMORY_REPOSITORY_PUSH_LOG = "memory-repository-push.log";
 var init_memory_git = __esm(() => {
   init_client2();
   init_memfs_git_proxy();
@@ -127896,7 +127922,7 @@ var init_memory_git = __esm(() => {
   init_memory_git_config_lock();
   init_memory_git_hooks();
   init_memory_git_signing();
-  execFile5 = promisify5(execFileCb2);
+  execFile6 = promisify6(execFileCb2);
   RETRYABLE_GIT_HTTP_ERROR_RE = /(?:\bHTTP\s+(?:520|521|522|523|524)\b|The requested URL returned error:\s*(?:520|521|522|523|524))/i;
   RETRYABLE_GIT_NETWORK_ERROR_RE = /(remote end hung up unexpectedly|connection reset by peer|operation timed out|timed out|SIGTERM|ETIMEDOUT)/i;
   MISSING_CWD_GIT_ERROR_RE = /(Unable to read current working directory: No such file or directory|\buv_cwd\b|\bcwd\b.*\bENOENT\b)/i;
@@ -128573,7 +128599,7 @@ import {
   readdirSync as readdirSync9,
   readFileSync as readFileSync14,
   readSync,
-  rmSync as rmSync5,
+  rmSync as rmSync6,
   statSync as statSync8,
   writeFileSync as writeFileSync12
 } from "node:fs";
@@ -129121,7 +129147,7 @@ class LocalStore {
         this.persistedMessageByMessageIdByConversationKey.delete(key);
         this.lastSessionEntryIdByConversationKey.delete(key);
         if (this.storageDir) {
-          rmSync5(join33(this.storageDir, "conversations", encodePathSegment(key)), {
+          rmSync6(join33(this.storageDir, "conversations", encodePathSegment(key)), {
             recursive: true,
             force: true
           });
@@ -129129,7 +129155,7 @@ class LocalStore {
       }
     }
     if (this.storageDir) {
-      rmSync5(join33(this.storageDir, "agents", `${encodePathSegment(agentId)}.json`), { force: true });
+      rmSync6(join33(this.storageDir, "agents", `${encodePathSegment(agentId)}.json`), { force: true });
     }
   }
   retrieveAgentRecord(agentId) {
@@ -129440,7 +129466,7 @@ class LocalStore {
         continue;
       this.compiledSystemPromptByConversationKey.delete(key);
       if (this.storageDir) {
-        rmSync5(join33(this.storageDir, "conversations", encodePathSegment(key), "system-prompt.json"), { force: true });
+        rmSync6(join33(this.storageDir, "conversations", encodePathSegment(key), "system-prompt.json"), { force: true });
       }
     }
   }
@@ -135626,7 +135652,7 @@ var init_local_backend = __esm(() => {
 });
 
 // src/backend/backend.ts
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync6 } from "node:fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync7 } from "node:fs";
 import { homedir as homedir22, tmpdir as tmpdir6 } from "node:os";
 import { join as join34 } from "node:path";
 function toApiConversationMessageListBody(body) {
@@ -135657,6 +135683,7 @@ class APIBackend {
   }
   getApiClientOverride;
   forkConversationOverride;
+  retrieveAgentInflightByKey = new Map;
   constructor(deps = {}) {
     this.getApiClientOverride = deps.getClient;
     this.forkConversationOverride = deps.forkConversation;
@@ -135670,7 +135697,24 @@ class APIBackend {
   }
   async retrieveAgent(agentId, options) {
     const client = await this.getClient();
-    return client.agents.retrieve(agentId, options);
+    if (options !== undefined) {
+      return client.agents.retrieve(agentId, options);
+    }
+    const inflight2 = this.retrieveAgentInflightByKey.get(agentId);
+    if (inflight2)
+      return inflight2;
+    const request = client.agents.retrieve(agentId, undefined);
+    this.retrieveAgentInflightByKey.set(agentId, request);
+    request.then(() => {
+      if (this.retrieveAgentInflightByKey.get(agentId) === request) {
+        this.retrieveAgentInflightByKey.delete(agentId);
+      }
+    }, () => {
+      if (this.retrieveAgentInflightByKey.get(agentId) === request) {
+        this.retrieveAgentInflightByKey.delete(agentId);
+      }
+    });
+    return request;
   }
   async listAgentSecrets(agentId) {
     const client = await this.getClient();
@@ -135829,7 +135873,7 @@ function configureEphemeralLocalBackend() {
     executionMode: localBackendExecutionMode()
   });
   process.once("exit", () => {
-    rmSync6(stateStorageDir, { recursive: true, force: true });
+    rmSync7(stateStorageDir, { recursive: true, force: true });
   });
 }
 function isLocalBackendEnabled() {
@@ -136554,7 +136598,7 @@ __export(exports_personality, {
 import { execFile as execFileCb3 } from "node:child_process";
 import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
 import { dirname as dirname22, join as join35 } from "node:path";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify7 } from "node:util";
 function ensureTrailingNewline2(content) {
   return `${content.trimEnd()}
 `;
@@ -136704,7 +136748,7 @@ async function applyPersonalityToMemory(params) {
   const isLocalMemfs = getBackend().capabilities.localMemfs;
   const blockDefinitions = getPersonalityBlockDefinitions(params.personalityId, isLocalMemfs ? "local" : "cloud");
   const repoDir = isLocalMemfs ? getScopedMemoryFilesystemRoot(params.agentId) : getMemoryRepoDir(params.agentId);
-  const statusResult = await execFile6("git", ["status", "--porcelain"], {
+  const statusResult = await execFile7("git", ["status", "--porcelain"], {
     cwd: repoDir,
     timeout: 1e4
   });
@@ -136768,7 +136812,7 @@ async function applyPersonalityToMemory(params) {
     commitMessage
   };
 }
-var execFile6, PRIMARY_PERSONA_RELATIVE_PATH = "system/persona.md", LEGACY_PERSONA_RELATIVE_PATH = "memory/system/persona.md", PRIMARY_HUMAN_RELATIVE_PATH = "system/human.md", LEGACY_HUMAN_RELATIVE_PATH = "memory/system/human.md";
+var execFile7, PRIMARY_PERSONA_RELATIVE_PATH = "system/persona.md", LEGACY_PERSONA_RELATIVE_PATH = "memory/system/persona.md", PRIMARY_HUMAN_RELATIVE_PATH = "system/human.md", LEGACY_HUMAN_RELATIVE_PATH = "memory/system/human.md";
 var init_personality = __esm(() => {
   init_backend2();
   init_settings_manager();
@@ -136776,7 +136820,7 @@ var init_personality = __esm(() => {
   init_memory_filesystem2();
   init_memory_git();
   init_personality_presets();
-  execFile6 = promisify6(execFileCb3);
+  execFile7 = promisify7(execFileCb3);
 });
 
 // src/cli/args.ts
@@ -137024,14 +137068,15 @@ var init_args = __esm(() => {
         description: "Inject agent-to-agent system reminder (headless mode)"
       }
     },
-    environment: {
+    computer: {
       parser: { type: "string" },
       mode: "headless",
       help: {
         argLabel: "<selector>",
-        description: "Route headless message through 'cloud' sandbox or an environment by name, device ID, or connection ID"
+        description: "Route headless message through 'cloud' or a computer by name, device ID, or connection ID"
       }
     },
+    environment: { parser: { type: "string" }, mode: "headless" },
     env: { parser: { type: "string" }, mode: "headless" },
     skills: {
       parser: { type: "string" },
@@ -148669,7 +148714,7 @@ Learn more about this warning here: https://reactjs.org/link/legacy-context`, so
 
 ` + ("" + errorBoundaryMessage);
             console["error"](combinedMessage);
-          } else {}
+          }
         } catch (e2) {
           setTimeout(function() {
             throw e2;
@@ -164542,7 +164587,7 @@ var CAPTURING_REGEX_SOURCE, RegexSource = class {
               let localIncludedRule = repository[reference.ruleName];
               if (localIncludedRule) {
                 ruleId = _RuleFactory.getCompiledRuleId(localIncludedRule, helper, repository);
-              } else {}
+              }
               break;
             case 3:
             case 4:
@@ -164554,11 +164599,11 @@ var CAPTURING_REGEX_SOURCE, RegexSource = class {
                   let externalIncludedRule = externalGrammar.repository[externalGrammarInclude];
                   if (externalIncludedRule) {
                     ruleId = _RuleFactory.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);
-                  } else {}
+                  }
                 } else {
                   ruleId = _RuleFactory.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);
                 }
-              } else {}
+              }
               break;
           }
         } else {
@@ -175257,7 +175302,7 @@ import {
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync10,
   renameSync as renameSync4,
-  rmSync as rmSync7,
+  rmSync as rmSync8,
   statSync as statSync10
 } from "node:fs";
 import { arch as arch2, homedir as homedir23, platform as platform5 } from "node:os";
@@ -175634,8 +175679,8 @@ async function downloadFd() {
       chmodSync5(FD_LOCAL_PATH, 493);
     }
   } finally {
-    rmSync7(archivePath, { force: true });
-    rmSync7(extractDir, { recursive: true, force: true });
+    rmSync8(archivePath, { force: true });
+    rmSync8(extractDir, { recursive: true, force: true });
   }
   return FD_LOCAL_PATH;
 }
@@ -179445,12 +179490,12 @@ __export(exports_auto_update, {
   buildInstallArgs: () => buildInstallArgs
 });
 import {
-  execFile as execFile7
+  execFile as execFile8
 } from "node:child_process";
 import { accessSync, constants as constants4, realpathSync as realpathSync4 } from "node:fs";
 import { readdir as readdir7, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname23, join as join41 } from "node:path";
-import { promisify as promisify7 } from "node:util";
+import { promisify as promisify8 } from "node:util";
 function debugLog2(...args) {
   if (DEBUG) {
     console.error("[auto-update]", ...args);
@@ -179513,7 +179558,7 @@ function buildUpdateExecOptions(timeout, platform6 = process.platform) {
   };
 }
 async function runUpdateCommand(command, args, timeout) {
-  return execFileAsync4(command, args, buildUpdateExecOptions(timeout));
+  return execFileAsync5(command, args, buildUpdateExecOptions(timeout));
 }
 function getResolvedEntrypoint() {
   const argv = process.argv[1] || "";
@@ -179836,11 +179881,11 @@ async function manualUpdate(options) {
 To update manually: ${installCmd}`
   };
 }
-var execFileAsync4, DEBUG, DEFAULT_UPDATE_PACKAGE_NAME = "@letta-ai/letta-code", DEFAULT_UPDATE_REGISTRY_BASE_URL = "https://registry.npmjs.org", UPDATE_PACKAGE_NAME_ENV = "LETTA_UPDATE_PACKAGE_NAME", UPDATE_REGISTRY_BASE_URL_ENV = "LETTA_UPDATE_REGISTRY_BASE_URL", UPDATE_INSTALL_REGISTRY_URL_ENV = "LETTA_UPDATE_INSTALL_REGISTRY_URL", DESKTOP_MANAGED_ENV = "LETTA_CODE_DESKTOP_MANAGED", INSTALL_ARG_PREFIX, VALID_PACKAGE_MANAGERS, NPM_PREFIX_TIMEOUT_MS = 5000, UPDATE_INSTALL_TIMEOUT_MS = 60000;
+var execFileAsync5, DEBUG, DEFAULT_UPDATE_PACKAGE_NAME = "@letta-ai/letta-code", DEFAULT_UPDATE_REGISTRY_BASE_URL = "https://registry.npmjs.org", UPDATE_PACKAGE_NAME_ENV = "LETTA_UPDATE_PACKAGE_NAME", UPDATE_REGISTRY_BASE_URL_ENV = "LETTA_UPDATE_REGISTRY_BASE_URL", UPDATE_INSTALL_REGISTRY_URL_ENV = "LETTA_UPDATE_INSTALL_REGISTRY_URL", DESKTOP_MANAGED_ENV = "LETTA_CODE_DESKTOP_MANAGED", INSTALL_ARG_PREFIX, VALID_PACKAGE_MANAGERS, NPM_PREFIX_TIMEOUT_MS = 5000, UPDATE_INSTALL_TIMEOUT_MS = 60000;
 var init_auto_update = __esm(() => {
   init_error_reporting();
   init_version();
-  execFileAsync4 = promisify7(execFile7);
+  execFileAsync5 = promisify8(execFile8);
   DEBUG = process.env.LETTA_DEBUG_AUTOUPDATE === "1";
   INSTALL_ARG_PREFIX = {
     npm: ["install", "-g"],
@@ -181215,7 +181260,7 @@ __export(exports_transcription, {
   isTranscriptionConfigured: () => isTranscriptionConfigured
 });
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync22, rmSync as rmSync8 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync22, rmSync as rmSync9 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
 import { basename as basename12, extname as extname5, join as join43 } from "node:path";
 function audioMimeTypeForPath(localPath) {
@@ -181260,12 +181305,12 @@ function prepareOpenAiTranscriptionFile(localPath) {
       convertedPath
     ], { stdio: "ignore", timeout: TRANSCRIPTION_TIMEOUT_MS });
   } catch (error4) {
-    rmSync8(tempDir, { recursive: true, force: true });
+    rmSync9(tempDir, { recursive: true, force: true });
     throw new Error(`Unsupported audio format ${extname5(localPath).replace(/^\./, "") || "unknown"}; ffmpeg conversion failed. ffmpeg is required to transcribe this audio format; install ffmpeg on the channel listener machine. ${error4 instanceof Error ? error4.message : String(error4)}`);
   }
   return {
     localPath: convertedPath,
-    cleanup: () => rmSync8(tempDir, { recursive: true, force: true })
+    cleanup: () => rmSync9(tempDir, { recursive: true, force: true })
   };
 }
 function isTranscriptionConfigured() {
@@ -187269,6 +187314,11 @@ function createSlackAdapter(config) {
       throw error4;
     }
   }
+  async function listCustomEmojis() {
+    const client = await ensureWriteClient();
+    const response = await client.emoji.list();
+    return Object.keys(response.emoji ?? {}).sort((left, right) => left.localeCompare(right));
+  }
   async function downloadAttachment(params) {
     const slackApp = await ensureApp();
     return await downloadSlackAttachmentById({
@@ -187484,6 +187534,7 @@ function createSlackAdapter(config) {
       await Promise.all(status.getUniqueSources(event.sources).map((source) => status.activate(source, SLACK_ASSISTANT_WORKING_STATUS, activity)));
     },
     sendMessage,
+    listCustomEmojis,
     downloadAttachment,
     sendDirectReply,
     handleControlRequestEvent,
@@ -187631,10 +187682,27 @@ async function reactInSlack(context3) {
   });
   return request.remove ? `Reaction removed on slack (message_id: ${result2.messageId})` : `Reaction added on slack (message_id: ${result2.messageId})`;
 }
+async function listSlackCustomEmojis(context3) {
+  const listCustomEmojis = context3.adapter.listCustomEmojis;
+  if (typeof listCustomEmojis !== "function") {
+    return "Error: Running Slack adapter does not support custom emoji discovery.";
+  }
+  try {
+    const names2 = await listCustomEmojis.call(context3.adapter);
+    if (names2.length === 0) {
+      return "This Slack workspace has no custom emoji available to the app.";
+    }
+    return `Available custom Slack emoji (${names2.length}): ${names2.map((name) => `:${name}:`).join(", ")}`;
+  } catch (error4) {
+    const message = error4 instanceof Error ? error4.message : String(error4);
+    return `Error: Could not list custom Slack emoji. ${message}`;
+  }
+}
 function createSlackMessageActionAdapter(options = {}) {
   const actions = [
     "send",
     ...options.react ? ["react"] : [],
+    ...options.listCustomEmojis ? ["list-custom-emojis"] : [],
     ...options.uploadFile ? ["upload-file"] : [],
     ...options.downloadFile ? ["download-file"] : []
   ];
@@ -187673,6 +187741,8 @@ function createSlackMessageActionAdapter(options = {}) {
           return await sendSlackMessage(context3);
         case "react":
           return options.react ? await reactInSlack(context3) : 'Error: Action "react" is not supported on slack.';
+        case "list-custom-emojis":
+          return options.listCustomEmojis ? await listSlackCustomEmojis(context3) : 'Error: Action "list-custom-emojis" is not supported on slack.';
         case "download-file":
           return options.downloadFile ? await options.downloadFile(context3) : 'Error: Action "download-file" is not supported on slack.';
         default:
@@ -188063,6 +188133,7 @@ var init_message_actions2 = __esm(() => {
   init_target_resolution();
   slackMessageActions = createSlackMessageActionAdapter({
     react: true,
+    listCustomEmojis: true,
     uploadFile: true,
     downloadFile: downloadSlackFile,
     resolveMessageTarget: async (params) => await resolveSlackMessageTarget({
@@ -188100,7 +188171,7 @@ async function runSlackSetup() {
     console.log(`  5. Add the /cancel slash command if you want Slack-native cancellation
 `);
     console.log("Recommended bot token scopes:");
-    console.log("  app_mentions:read, channels:history, chat:write, commands, groups:history, im:history, users:read");
+    console.log("  app_mentions:read, channels:history, chat:write, commands, emoji:read, groups:history, im:history, users:read");
     console.log(`  reactions:read, reactions:write, files:read, files:write
 `);
     await ensureSlackRuntimeInstalled();
@@ -190871,7 +190942,7 @@ var init_state = __esm(() => {
 });
 
 // src/channels/whatsapp/session.ts
-import { mkdirSync as mkdirSync24, readFileSync as readFileSync25, rmSync as rmSync9, writeFileSync as writeFileSync18 } from "node:fs";
+import { mkdirSync as mkdirSync24, readFileSync as readFileSync25, rmSync as rmSync10, writeFileSync as writeFileSync18 } from "node:fs";
 import { homedir as homedir26 } from "node:os";
 import { join as join48 } from "node:path";
 function shouldDropLine(line) {
@@ -190983,7 +191054,7 @@ function acquireWhatsAppSessionLease(accountId, options = {}) {
           if (activeSessionLeases.get(accountId) === lockDir) {
             activeSessionLeases.delete(accountId);
           }
-          rmSync9(lockDir, { recursive: true, force: true });
+          rmSync10(lockDir, { recursive: true, force: true });
         }
       };
     } catch (error4) {
@@ -190992,7 +191063,7 @@ function acquireWhatsAppSessionLease(accountId, options = {}) {
       }
       const owner = readLeaseOwner(lockDir);
       if (owner.pid && !isProcessAlive(owner.pid)) {
-        rmSync9(lockDir, { recursive: true, force: true });
+        rmSync10(lockDir, { recursive: true, force: true });
         continue;
       }
       const ownerLabel = owner.pid ? `PID ${owner.pid}${owner.command ? ` (${owner.command})` : ""}` : "an unknown live process";
@@ -199870,26 +199941,26 @@ function defineLazyProperty(object3, propertyName, valueGetter) {
 }
 
 // node_modules/default-browser-id/index.js
-import { promisify as promisify8 } from "node:util";
+import { promisify as promisify9 } from "node:util";
 import process15 from "node:process";
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 async function defaultBrowserId() {
   if (process15.platform !== "darwin") {
     throw new Error("macOS only");
   }
-  const { stdout } = await execFileAsync5("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const { stdout } = await execFileAsync6("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
   const match3 = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
   return match3?.groups.id ?? "com.apple.Safari";
 }
-var execFileAsync5;
+var execFileAsync6;
 var init_default_browser_id = __esm(() => {
-  execFileAsync5 = promisify8(execFile8);
+  execFileAsync6 = promisify9(execFile9);
 });
 
 // node_modules/run-applescript/index.js
 import process16 from "node:process";
-import { promisify as promisify9 } from "node:util";
-import { execFile as execFile9, execFileSync as execFileSync6 } from "node:child_process";
+import { promisify as promisify10 } from "node:util";
+import { execFile as execFile10, execFileSync as execFileSync6 } from "node:child_process";
 async function runAppleScript(script4, { humanReadableOutput = true, signal } = {}) {
   if (process16.platform !== "darwin") {
     throw new Error("macOS only");
@@ -199899,12 +199970,12 @@ async function runAppleScript(script4, { humanReadableOutput = true, signal } =
   if (signal) {
     execOptions.signal = signal;
   }
-  const { stdout } = await execFileAsync6("osascript", ["-e", script4, outputArguments], execOptions);
+  const { stdout } = await execFileAsync7("osascript", ["-e", script4, outputArguments], execOptions);
   return stdout.trim();
 }
-var execFileAsync6;
+var execFileAsync7;
 var init_run_applescript = __esm(() => {
-  execFileAsync6 = promisify9(execFile9);
+  execFileAsync7 = promisify10(execFile10);
 });
 
 // node_modules/bundle-name/index.js
@@ -199917,9 +199988,9 @@ var init_bundle_name = __esm(() => {
 });
 
 // node_modules/default-browser/windows.js
-import { promisify as promisify10 } from "node:util";
-import { execFile as execFile10 } from "node:child_process";
-async function defaultBrowser(_execFileAsync = execFileAsync7) {
+import { promisify as promisify11 } from "node:util";
+import { execFile as execFile11 } from "node:child_process";
+async function defaultBrowser(_execFileAsync = execFileAsync8) {
   const { stdout } = await _execFileAsync("reg", [
     "QUERY",
     " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
@@ -199937,9 +200008,9 @@ async function defaultBrowser(_execFileAsync = execFileAsync7) {
   }
   return browser;
 }
-var execFileAsync7, windowsBrowserProgIds, UnknownBrowserError;
+var execFileAsync8, windowsBrowserProgIds, UnknownBrowserError;
 var init_windows = __esm(() => {
-  execFileAsync7 = promisify10(execFile10);
+  execFileAsync8 = promisify11(execFile11);
   windowsBrowserProgIds = {
     AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
     MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
@@ -199956,9 +200027,9 @@ var init_windows = __esm(() => {
 });
 
 // node_modules/default-browser/index.js
-import { promisify as promisify11 } from "node:util";
+import { promisify as promisify12 } from "node:util";
 import process17 from "node:process";
-import { execFile as execFile11 } from "node:child_process";
+import { execFile as execFile12 } from "node:child_process";
 async function defaultBrowser2() {
   if (process17.platform === "darwin") {
     const id2 = await defaultBrowserId();
@@ -199966,7 +200037,7 @@ async function defaultBrowser2() {
     return { name, id: id2 };
   }
   if (process17.platform === "linux") {
-    const { stdout } = await execFileAsync8("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const { stdout } = await execFileAsync9("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
     const id2 = stdout.trim();
     const name = titleize(id2.replace(/.desktop$/, "").replace("-", " "));
     return { name, id: id2 };
@@ -199976,12 +200047,12 @@ async function defaultBrowser2() {
   }
   throw new Error("Only macOS, Linux, and Windows are supported");
 }
-var execFileAsync8, titleize = (string3) => string3.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x4) => x4.toUpperCase());
+var execFileAsync9, titleize = (string3) => string3.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x4) => x4.toUpperCase());
 var init_default_browser = __esm(() => {
   init_default_browser_id();
   init_bundle_name();
   init_windows();
-  execFileAsync8 = promisify11(execFile11);
+  execFileAsync9 = promisify12(execFile12);
 });
 
 // node_modules/open/index.js
@@ -199995,14 +200066,14 @@ import process18 from "node:process";
 import { Buffer as Buffer6 } from "node:buffer";
 import path31 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
-import { promisify as promisify12 } from "node:util";
+import { promisify as promisify13 } from "node:util";
 import childProcess from "node:child_process";
 import fs13, { constants as fsConstants2 } from "node:fs/promises";
 async function getWindowsDefaultBrowserFromWsl() {
   const powershellPath = await powerShellPath();
   const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
   const encodedCommand = Buffer6.from(rawCommand, "utf16le").toString("base64");
-  const { stdout } = await execFile12(powershellPath, [
+  const { stdout } = await execFile13(powershellPath, [
     "-NoProfile",
     "-NonInteractive",
     "-ExecutionPolicy",
@@ -200038,7 +200109,7 @@ function detectPlatformBinary({ [platform6]: platformBinary }, { wsl }) {
   }
   return detectArchBinary(platformBinary);
 }
-var execFile12, __dirname2, localXdgOpenPath, platform6, arch3, pTryEach = async (array2, mapper) => {
+var execFile13, __dirname2, localXdgOpenPath, platform6, arch3, pTryEach = async (array2, mapper) => {
   let latestError;
   for (const item of array2) {
     try {
@@ -200217,7 +200288,7 @@ var init_open = __esm(() => {
   init_wsl_utils();
   init_default_browser();
   init_is_inside_container();
-  execFile12 = promisify12(childProcess.execFile);
+  execFile13 = promisify13(childProcess.execFile);
   __dirname2 = path31.dirname(fileURLToPath8(import.meta.url));
   localXdgOpenPath = path31.join(__dirname2, "xdg-open");
   ({ platform: platform6, arch: arch3 } = process18);
@@ -207662,7 +207733,7 @@ import {
   mkdirSync as mkdirSync28,
   readFileSync as readFileSync30,
   renameSync as renameSync6,
-  rmSync as rmSync10,
+  rmSync as rmSync11,
   statSync as statSync14,
   writeFileSync as writeFileSync21
 } from "node:fs";
@@ -207808,7 +207879,7 @@ function isLockStale(lockDir) {
 }
 function stealLock(lockDir) {
   try {
-    rmSync10(lockDir, { recursive: true, force: true });
+    rmSync11(lockDir, { recursive: true, force: true });
   } catch {}
 }
 function acquireLock() {
@@ -207830,7 +207901,7 @@ function acquireLock() {
           try {
             const current = readLockOwner(lockDir);
             if (current && current.token === token2) {
-              rmSync10(lockDir, { recursive: true, force: true });
+              rmSync11(lockDir, { recursive: true, force: true });
             }
           } catch {}
         }
@@ -208335,11 +208406,12 @@ function safeAppendCronRunLogForTask(task2, entry) {
   try {
     appendCronRunLogForTask(task2, entry);
   } catch (err) {
-    console.error(`[Cron] Error writing run log for task ${task2.id}:`, err instanceof Error ? err.message : err);
+    debugWarn("Cron", `Error writing run log for task ${task2.id}:`, err instanceof Error ? err.message : err);
   }
 }
 var DEFAULT_CRON_RUN_LOG_MAX_BYTES = 2000000, DEFAULT_CRON_RUN_LOG_KEEP_LINES = 2000;
 var init_run_log = __esm(() => {
+  init_debug();
   init_cron_file();
 });
 
@@ -208876,7 +208948,7 @@ function scheduleQueuePump(runtime, socket, opts, processQueuedTurn) {
       error: error4,
       context: "listener_queue_pump"
     });
-    console.error("[Listen] Error in queue pump:", error4);
+    debugWarn("Listen", "Error in queue pump:", error4);
     emitListenerStatus(runtime.listener, opts.onStatusChange, opts.connectionId);
     evictConversationRuntimeIfIdle(runtime);
   });
@@ -208884,6 +208956,7 @@ function scheduleQueuePump(runtime, socket, opts, processQueuedTurn) {
 var init_queue = __esm(async () => {
   init_queue_runtime();
   init_error_reporting();
+  init_debug();
   init_protocol_outbound();
   init_runtime();
   init_transport();
@@ -209138,6 +209211,13 @@ function formatCronPrompt(task2, timing2) {
 var init_prompt = () => {};
 
 // src/cron/scheduler.ts
+function logScheduler(opts, message) {
+  if (opts.onLog) {
+    opts.onLog(`[Cron] ${message}`);
+    return;
+  }
+  debugWarn("Cron", message);
+}
 function minuteKey(date) {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}T${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
 }
@@ -209402,7 +209482,7 @@ async function runCronTaskNow(taskId) {
 }
 function tick2(state, socket, opts, processQueuedTurn) {
   if (!verifySchedulerLease(state.token)) {
-    console.error("[Cron] Scheduler lease lost. Stopping.");
+    logScheduler(opts, "Scheduler lease lost. Stopping.");
     stopScheduler();
     return;
   }
@@ -209439,7 +209519,7 @@ function tick2(state, socket, opts, processQueuedTurn) {
           return;
         const schedulerNow = new Date;
         fireCronTask(freshTask, { intendedOccurrence, schedulerNow }, socket, opts, processQueuedTurn, "automatic").catch((err) => {
-          console.error(`[Cron] Error firing task ${taskId}:`, err);
+          logScheduler(opts, `Error firing task ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
           setLastRunOutcome(freshTask.id, {
             outcome: "failed",
             reason: "scheduler_error",
@@ -209477,12 +209557,12 @@ function startScheduler(socket, opts, processQueuedTurn, _retryCount = 0) {
     token2 = claimSchedulerLease();
   } catch (err) {
     if (_retryCount < MAX_LEASE_RETRIES) {
-      console.warn(`[Cron] Could not claim scheduler lease (attempt ${_retryCount + 1}/${MAX_LEASE_RETRIES + 1}): ${err instanceof Error ? err.message : err}`);
-      console.warn("[Cron] Cron tasks will not fire until the scheduler starts. Retrying...");
+      logScheduler(opts, `Could not claim scheduler lease (attempt ${_retryCount + 1}/${MAX_LEASE_RETRIES + 1}): ${err instanceof Error ? err.message : err}`);
+      logScheduler(opts, "Cron tasks will not fire until the scheduler starts. Retrying...");
       setTimeout(() => startScheduler(socket, opts, processQueuedTurn, _retryCount + 1), LEASE_RETRY_MS);
     } else {
-      console.error(`[Cron] Failed to claim scheduler lease after ${MAX_LEASE_RETRIES + 1} attempts. Cron tasks will not fire.`);
-      console.error("[Cron] Another process may hold the lease. Restart Letta Code to retry.");
+      logScheduler(opts, `Failed to claim scheduler lease after ${MAX_LEASE_RETRIES + 1} attempts. Cron tasks will not fire.`);
+      logScheduler(opts, "Another process may hold the lease. Restart Letta Code to retry.");
     }
     return;
   }
@@ -209511,7 +209591,7 @@ function startScheduler(socket, opts, processQueuedTurn, _retryCount = 0) {
         state.lastMtime = 0;
       }
     } catch (err) {
-      console.error("[Cron] GC error:", err);
+      logScheduler(opts, `GC error: ${err instanceof Error ? err.message : String(err)}`);
     }
   }, GC_INTERVAL_MS);
   schedulerState = state;
@@ -209534,6 +209614,7 @@ function stopScheduler() {
 var schedulerState = null, listenerFireContext = null, TICK_INTERVAL_MS = 60000, GC_INTERVAL_MS, LEASE_RETRY_MS = 30000, MAX_LEASE_RETRIES = 3, NEW_CONVERSATION_TARGET = "new";
 var init_scheduler = __esm(async () => {
   init_backend2();
+  init_debug();
   init_connection();
   init_protocol_outbound();
   init_runtime();
@@ -209602,10 +209683,10 @@ async function resolveDesktopEnvironmentConnectionId(list = listEnvironments) {
   const response = await list({ limit: 100, onlineOnly: true });
   const matches3 = response.connections.filter((environment3) => environment3.listenerInstanceId?.startsWith("desktop-direct-cloud:") === true && isEnvironmentOnline(environment3));
   if (matches3.length === 0) {
-    throw new Error("Desktop Local is unavailable. Open Letta Desktop, enable Remote Access, and wait for its environment to come online.");
+    throw new Error("Desktop Local is unavailable. Open Letta Desktop, enable Remote Access, and wait for its computer connection to come online.");
   }
   if (matches3.length > 1) {
-    throw new Error(`Multiple Desktop environments are online. Run \`letta teleport list\` and choose one by name, device ID, or connection ID. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
+    throw new Error(`Multiple Desktop computers are online. Run \`letta teleport list\` and choose one by name, device ID, or connection ID. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
   }
   const environment2 = matches3[0];
   if (!environment2?.connectionId) {
@@ -209616,28 +209697,28 @@ async function resolveDesktopEnvironmentConnectionId(list = listEnvironments) {
 async function resolveEnvironmentConnectionId(selector) {
   const trimmed = selector.trim();
   if (!trimmed) {
-    throw new Error("Environment selector must not be empty");
+    throw new Error("Computer selector must not be empty");
   }
   const response = await listEnvironments({ limit: 100 });
   const matches3 = response.connections.filter((environment3) => {
     return environment3.connectionId === trimmed || environment3.id === trimmed || environment3.deviceId === trimmed || environment3.connectionName === trimmed;
   });
   if (matches3.length === 0) {
-    throw new Error(`Environment "${trimmed}" not found. Run \`letta environments list\` to discover available environments.`);
+    throw new Error(`Computer "${trimmed}" not found. Run \`letta computers list\` to discover available computers.`);
   }
   const onlineMatches = matches3.filter(isEnvironmentOnline);
   if (onlineMatches.length === 0) {
-    throw new Error(`Environment "${trimmed}" is offline. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
+    throw new Error(`Computer "${trimmed}" is offline. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
   }
   if (onlineMatches.length > 1) {
-    throw new Error(`Environment "${trimmed}" is ambiguous. Matched: ${onlineMatches.map(describeEnvironment).join(", ")}`);
+    throw new Error(`Computer "${trimmed}" is ambiguous. Matched: ${onlineMatches.map(describeEnvironment).join(", ")}`);
   }
   const environment2 = onlineMatches[0];
   if (!environment2) {
-    throw new Error(`Environment "${trimmed}" is offline`);
+    throw new Error(`Computer "${trimmed}" is offline`);
   }
   if (!environment2.connectionId) {
-    throw new Error(`Environment "${trimmed}" has no active connection id`);
+    throw new Error(`Computer "${trimmed}" has no active connection id`);
   }
   return { connectionId: environment2.connectionId, environment: environment2 };
 }
@@ -209908,8 +209989,8 @@ Add options:
                                    the fallback when Cloud scheduling cannot
                                    reach this computer)
   --computer <id>        (cloud runner only) Override execution with a
-                         connected external environment (deviceId from
-                         \`letta environments list\`). Falls back to the Cloud
+                         connected external computer (deviceId from
+                         \`letta computers list\`). Falls back to the Cloud
                          sandbox if the computer is offline at fire time.
                          Managed sandboxes and Desktop-local connections are
                          not currently valid Cloud schedule targets.
@@ -210096,7 +210177,7 @@ async function handleAdd(values3) {
       targetDeviceId = inferredDeviceId;
     } else if (resolution.kind === "local-fallback") {
       runner = "local";
-      localFallbackNote = `This schedule is local to this computer (${resolution.reason}): it only fires while a Letta session is running here. For a schedule that fires regardless, pass --runner cloud (runs in the agent's cloud sandbox) or --computer <deviceId> (runs on a connected computer, from \`letta environments list\`).`;
+      localFallbackNote = `This schedule is local to this computer (${resolution.reason}): it only fires while a Letta session is running here. For a schedule that fires regardless, pass --runner cloud (runs in the agent's cloud sandbox) or --computer <deviceId> (runs on a connected computer, from \`letta computers list\`).`;
     }
   }
   if (runner === "cloud") {
@@ -210544,25 +210625,27 @@ import { parseArgs as parseArgs6 } from "node:util";
 function printUsage5() {
   console.log(`
 Usage:
-  letta environments list [options]
-  letta environments current
+  letta computers list [options]
+  letta computers current
 
-Aliases:
+Legacy aliases:
+  letta environments list
+  letta environments current
   letta envs list
   letta envs current
 
 List options:
   --limit <n>       Max results (default: 50)
-  --after <id>      Pagination cursor from a previous environment id
-  --online-only     Only include environments with a fresh active connection
+  --after <id>      Pagination cursor from a previous computer id
+  --online-only     Only include computers with a fresh active connection
 
 Notes:
   - Output is JSON only.
   - Uses CLI auth; override with LETTA_API_KEY/LETTA_BASE_URL if needed.
-  - Use letta environments current to get this machine's connectionId.
-  - Use --environment cloud to route through the target agent's cloud sandbox.
-  - Use --environment <name|device-id|connection-id> with headless messaging
-    to route a message through a specific registered environment.
+  - Use letta computers current to get this computer's connectionId.
+  - Use --computer cloud to route through the target agent's cloud sandbox.
+  - Use --computer <name|device-id|connection-id> with headless messaging
+    to route a message through a specific registered computer.
 `.trim());
 }
 function parseLimit2(value, fallback) {
@@ -210649,7 +210732,7 @@ async function runEnvironmentsSubcommand(argv, deps = {}) {
       currentVersion
     });
     if (!current2) {
-      console.error("No online environment found for this device. Start one with `letta server` and try again.");
+      console.error("No online computer found for this device. Start one with `letta server` and try again.");
       return 1;
     }
     console.log(JSON.stringify(formatEnvironmentForCli(current2, {
@@ -212471,7 +212554,7 @@ function ListenerStatusUI(props) {
           bold: true,
           color: "green",
           children: [
-            "The name of your environment is: ",
+            "The name of your computer is: ",
             envName
           ]
         }, undefined, true, undefined, this)
@@ -212504,7 +212587,7 @@ function ListenerStatusUI(props) {
         children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
           dimColor: true,
           children: [
-            'Connect to this environment by visiting any agent and clicking the "cloud" button at the bottom left of the messenger input and swapping your environment to ',
+            'Connect to this computer by visiting any agent and clicking the "cloud" button at the bottom left of the messenger input and swapping your computer to ',
             envName
           ]
         }, undefined, true, undefined, this)
@@ -215280,7 +215363,7 @@ async function awaitMemoryPushBounded(commandName, agentId, memoryRoot) {
   });
   const warnOnFailure = (result2) => {
     if (result2.status === "push_failed" || result2.status === "conflict") {
-      console.warn(`[${commandName}] push failed for ${agentId}: ${result2.summary}`);
+      warnMemoryCommand(`[${commandName}] push failed for ${agentId}: ${result2.summary}`);
     }
   };
   let timer;
@@ -215290,15 +215373,15 @@ async function awaitMemoryPushBounded(commandName, agentId, memoryRoot) {
   try {
     const result2 = await Promise.race([syncPromise, capPromise]);
     if (result2 === "timed_out") {
-      console.warn(`[${commandName}] push still in flight after ${MEMORY_PUSH_AWAIT_CAP_MS}ms for ${agentId}; responding now, push continues in background`);
+      warnMemoryCommand(`[${commandName}] push still in flight after ${MEMORY_PUSH_AWAIT_CAP_MS}ms for ${agentId}; responding now, push continues in background`);
       syncPromise.then(warnOnFailure).catch((err) => {
-        console.warn(`[${commandName}] background push failed for ${agentId}:`, err instanceof Error ? err.message : err);
+        warnMemoryCommand(`[${commandName}] background push failed for ${agentId}:`, err instanceof Error ? err.message : err);
       });
       return;
     }
     warnOnFailure(result2);
   } catch (err) {
-    console.warn(`[${commandName}] push failed for ${agentId}:`, err instanceof Error ? err.message : err);
+    warnMemoryCommand(`[${commandName}] push failed for ${agentId}:`, err instanceof Error ? err.message : err);
   } finally {
     if (timer)
       clearTimeout(timer);
@@ -215523,15 +215606,15 @@ function handleMemoryProtocolCommand(parsed, context3) {
     runDetachedListenerTask("memory_history", async () => {
       const { getScopedMemoryFilesystemRoot: getScopedMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
       const { execFile: execFileCb4 } = await import("node:child_process");
-      const { promisify: promisify13 } = await import("node:util");
-      const execFileAsync9 = promisify13(execFileCb4);
+      const { promisify: promisify14 } = await import("node:util");
+      const execFileAsync10 = promisify14(execFileCb4);
       const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
       const limit3 = parsed.limit ?? 50;
       const gitArgs = ["log", `--max-count=${limit3}`, "--format=%H|%s|%aI|%an"];
       if (parsed.file_path) {
         gitArgs.push("--", parsed.file_path);
       }
-      const { stdout } = await execFileAsync9("git", gitArgs, {
+      const { stdout } = await execFileAsync10("git", gitArgs, {
         cwd: memoryRoot,
         timeout: 1e4
       });
@@ -215559,11 +215642,11 @@ function handleMemoryProtocolCommand(parsed, context3) {
     runDetachedListenerTask("memory_file_at_ref", async () => {
       const { getScopedMemoryFilesystemRoot: getScopedMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
       const { execFile: execFileCb4 } = await import("node:child_process");
-      const { promisify: promisify13 } = await import("node:util");
-      const execFileAsync9 = promisify13(execFileCb4);
+      const { promisify: promisify14 } = await import("node:util");
+      const execFileAsync10 = promisify14(execFileCb4);
       const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
       try {
-        const { stdout } = await execFileAsync9("git", ["show", `${parsed.ref}:${parsed.file_path}`], { cwd: memoryRoot, timeout: 1e4 });
+        const { stdout } = await execFileAsync10("git", ["show", `${parsed.ref}:${parsed.file_path}`], { cwd: memoryRoot, timeout: 1e4 });
         safeSocketSend(socket, {
           type: "memory_file_at_ref_response",
           request_id: parsed.request_id,
@@ -215590,11 +215673,11 @@ function handleMemoryProtocolCommand(parsed, context3) {
     runDetachedListenerTask("memory_commit_diff", async () => {
       const { getScopedMemoryFilesystemRoot: getScopedMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
       const { execFile: execFileCb4 } = await import("node:child_process");
-      const { promisify: promisify13 } = await import("node:util");
-      const execFileAsync9 = promisify13(execFileCb4);
+      const { promisify: promisify14 } = await import("node:util");
+      const execFileAsync10 = promisify14(execFileCb4);
       const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
       try {
-        const { stdout } = await execFileAsync9("git", ["show", parsed.sha, "--format=", "--no-color"], { cwd: memoryRoot, timeout: 1e4 });
+        const { stdout } = await execFileAsync10("git", ["show", parsed.sha, "--format=", "--no-color"], { cwd: memoryRoot, timeout: 1e4 });
         safeSocketSend(socket, {
           type: "memory_commit_diff_response",
           request_id: parsed.request_id,
@@ -215676,7 +215759,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
         }, "listener_read_memory_file_send_failed", "listener_read_memory_file");
       } catch (err) {
         trackListenerError("listener_read_memory_file_failed", err, "listener_memory_read");
-        console.error(`[Listen] read_memory_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
+        warnMemoryCommand(`[Listen] read_memory_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
         sendFailure(err instanceof Error ? err.message : "Failed to read memory file");
       }
     });
@@ -215775,7 +215858,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
         }, "listener_write_memory_file_send_failed", "listener_write_memory_file");
       } catch (err) {
         trackListenerError("listener_write_memory_file_failed", err, "listener_memory_write");
-        console.error(`[Listen] write_memory_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
+        warnMemoryCommand(`[Listen] write_memory_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
         sendFailure(err instanceof Error ? err.message : "Failed to write memory file");
       }
     });
@@ -215888,7 +215971,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
         }, "listener_delete_memory_file_send_failed", "listener_delete_memory_file");
       } catch (err) {
         trackListenerError("listener_delete_memory_file_failed", err, "listener_memory_delete");
-        console.error(`[Listen] delete_memory_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
+        warnMemoryCommand(`[Listen] delete_memory_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
         sendFailure(err instanceof Error ? err.message : "Failed to delete memory file");
       }
     });
@@ -215896,10 +215979,12 @@ function handleMemoryProtocolCommand(parsed, context3) {
   }
   return false;
 }
-var WIKI_LINK_REGEX, IMAGE_MIME_BY_EXTENSION, MEMORY_PUSH_AWAIT_CAP_MS = 8000;
+var warnMemoryCommand, WIKI_LINK_REGEX, IMAGE_MIME_BY_EXTENSION, MEMORY_PUSH_AWAIT_CAP_MS = 8000;
 var init_memory6 = __esm(() => {
   init_error_reporting();
+  init_debug();
   init_protocol_inbound();
+  warnMemoryCommand = debugWarn.bind(null, "memory-commands");
   WIKI_LINK_REGEX = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
   IMAGE_MIME_BY_EXTENSION = {
     ".gif": "image/gif",
@@ -300568,7 +300653,7 @@ ${lanes.join(`
             if (!links2.hasReportedStatementInAmbientContext) {
               return links2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
             }
-          } else {}
+          }
         }
         return false;
       }
@@ -310032,7 +310117,7 @@ ${lanes.join(`
               ], 2));
               setParentRecursive(requireStatement, false);
               statements = insertStatementAfterCustomPrologue(statements.slice(), requireStatement);
-            } else {}
+            }
           }
         }
         if (statements !== visited2.statements) {
@@ -385581,7 +385666,7 @@ import {
   existsSync as existsSync47,
   mkdirSync as mkdirSync33,
   readFileSync as readFileSync35,
-  rmSync as rmSync11,
+  rmSync as rmSync12,
   writeFileSync as writeFileSync25
 } from "node:fs";
 import path37 from "node:path";
@@ -386184,7 +386269,7 @@ function removeManagedModPackage(params) {
   assertSafePackageRemovalRoot(match3.metadata);
   registry.packagesValue.splice(match3.index, 1);
   writePackageRegistry(registry.registryPath, registry.registry);
-  rmSync11(match3.metadata.packageRoot, { force: true, recursive: true });
+  rmSync12(match3.metadata.packageRoot, { force: true, recursive: true });
   return {
     package: mutationItem(match3.metadata, match3.index, match3.metadata.enabled),
     registryPath: registry.registryPath,
@@ -387698,7 +387783,7 @@ async function syncMemfsForAgent(agentId) {
       debugLog("memfs-sync", `Agent ${agentId} does not have memfs tag (self-hosted), skipping`);
       return;
     }
-    console.warn(`[memfs-sync] Agent ${agentId} is missing the memfs tag on Letta Cloud — repairing (auto-enabling memfs).`);
+    debugWarn("memfs-sync", `Agent ${agentId} is missing the memfs tag on Letta Cloud — repairing (auto-enabling memfs).`);
     await applyMemfsFlags2(agentId, true, {
       pullOnExistingRepo: true,
       agentTags: agent.tags ?? []
@@ -390483,7 +390568,7 @@ function markAsFinished(b3, id2) {
     if (updatedLine.kind === "assistant" && "text" in updatedLine && updatedLine.text) {
       b3.lastAssistantMessage = updatedLine.text;
     }
-  } else {}
+  }
 }
 function handleOtidTransition(b3, newOtid) {
   if (b3.lastOtid && b3.lastOtid !== newOtid) {
@@ -390501,7 +390586,7 @@ function markCurrentLineAsFinished(b3) {
   const prev = b3.byId.get(b3.lastOtid);
   if (prev && (prev.kind === "assistant" || prev.kind === "reasoning")) {
     markAsFinished(b3, b3.lastOtid);
-  } else {}
+  }
 }
 function markIncompleteToolsAsCancelled(b3, setInterruptedFlag = true, reason = "internal_cancel", skipMarkCurrentLine = false) {
   if (setInterruptedFlag) {
@@ -393285,8 +393370,15 @@ function isChatGPTByokHandleInModels(handle2, models3) {
   const entry = models3.find((m4) => m4.handle === handle2);
   return entry?.providerType === "chatgpt_oauth" && entry?.providerCategory === "byok";
 }
-async function resolveAgentModelHandle2(agentId) {
+async function resolveScopedModelHandle(agentId, conversationId) {
   try {
+    if (conversationId !== "default") {
+      const conversation = await getBackend().retrieveConversation(conversationId);
+      const conversationRecord = conversation;
+      if (typeof conversationRecord.model === "string" && conversationRecord.model.length > 0) {
+        return conversationRecord.model;
+      }
+    }
     const agent = await getBackend().retrieveAgent(agentId);
     const record3 = agent;
     if (typeof record3.model === "string" && record3.model.length > 0) {
@@ -393298,7 +393390,7 @@ async function resolveAgentModelHandle2(agentId) {
   }
 }
 async function rotateChatGPTPlanOnQuotaLimit(params) {
-  const { agentId, error: error4 } = params;
+  const { agentId, conversationId, error: error4, exhaustedProviders } = params;
   const parsedDetail = parseChatGPTUsageLimitDetail(error4);
   if (!parsedDetail)
     return null;
@@ -393313,9 +393405,9 @@ async function rotateChatGPTPlanOnQuotaLimit(params) {
   }
   if (!models3)
     return null;
-  let currentHandle = params.currentHandle;
+  let currentHandle = await resolveScopedModelHandle(agentId, conversationId);
   if (!currentHandle || !isChatGPTByokHandleInModels(currentHandle, models3)) {
-    currentHandle = await resolveAgentModelHandle2(agentId);
+    currentHandle = params.currentHandle;
   }
   if (!currentHandle || !isChatGPTByokHandleInModels(currentHandle, models3)) {
     return null;
@@ -393335,9 +393427,15 @@ async function rotateChatGPTPlanOnQuotaLimit(params) {
   if (!toProvider)
     return null;
   try {
-    await updateAgentLLMConfig(agentId, toHandle, {
-      provider_type: "chatgpt_oauth"
-    });
+    if (conversationId === "default") {
+      await updateAgentLLMConfig(agentId, toHandle, {
+        provider_type: "chatgpt_oauth"
+      });
+    } else {
+      await updateConversationLLMConfig(conversationId, toHandle, {
+        provider_type: "chatgpt_oauth"
+      });
+    }
   } catch {
     return null;
   }
@@ -393356,14 +393454,13 @@ function formatPlanRotationNotice(params) {
   })})` : "";
   return `${fromProvider} hit its usage limit${resetSuffix} — switched to ${toProvider}`;
 }
-var CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN = 3, exhaustedProviders;
+var CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN = 3;
 var init_chatgpt_plan_rotation = __esm(() => {
   init_available_models();
   init_model_handles();
   init_modify();
   init_turn_recovery_policy();
   init_backend2();
-  exhaustedProviders = new Set;
 });
 
 // src/websocket/listener/skill-injection.ts
@@ -397871,12 +397968,12 @@ function rowToolCalls(row, index, diagnostics2) {
   }
   return calls;
 }
-function contentText2(content) {
+function contentText(content) {
   if (typeof content === "string") {
     if (content.startsWith(CONTENT_JSON_PREFIX)) {
       const encoded = content.slice(CONTENT_JSON_PREFIX.length);
       try {
-        return contentText2(JSON.parse(encoded));
+        return contentText(JSON.parse(encoded));
       } catch {
         return encoded;
       }
@@ -397962,7 +398059,7 @@ var init_hermes = __esm(() => {
           });
         };
         if (row.role === "user") {
-          const content = contentText2(row.content);
+          const content = contentText(row.content);
           if (content) {
             emit({
               type: "message",
@@ -397982,7 +398079,7 @@ var init_hermes = __esm(() => {
               ...timestamp ? { timestamp } : {}
             });
           }
-          const content = contentText2(row.content);
+          const content = contentText(row.content);
           if (content) {
             emit({
               type: "message",
@@ -398005,7 +398102,7 @@ var init_hermes = __esm(() => {
         if (row.role === "tool") {
           emit({
             type: "tool_result",
-            content: contentText2(row.content),
+            content: contentText(row.content),
             ...typeof row.tool_call_id === "string" && row.tool_call_id ? { callId: row.tool_call_id } : {},
             ...timestamp ? { timestamp } : {}
           });
@@ -401366,11 +401463,11 @@ import { randomUUID as randomUUID27 } from "node:crypto";
 import { existsSync as existsSync53 } from "node:fs";
 import { mkdir as mkdir13 } from "node:fs/promises";
 import { dirname as dirname28, isAbsolute as isAbsolute26, join as join68, resolve as resolve34 } from "node:path";
-import { promisify as promisify13 } from "node:util";
+import { promisify as promisify14 } from "node:util";
 async function runGit4(cwd2, args) {
   try {
     const allArgs = [...GIT_DISABLE_COMMIT_SIGNING_ARGS, ...args];
-    const { stdout, stderr } = await execFile13("git", allArgs, {
+    const { stdout, stderr } = await execFile14("git", allArgs, {
       cwd: cwd2,
       env: {
         ...process.env,
@@ -401734,11 +401831,11 @@ async function finalizeReflectionMemoryWorktreeImpl(worktree, options) {
 async function finalizeReflectionMemoryWorktree(worktree, options) {
   return await finalizeReflectionMemoryWorktreeImpl(worktree, options);
 }
-var execFile13, GIT_TIMEOUT_MS = 30000, HARNESS_GIT_ENV;
+var execFile14, GIT_TIMEOUT_MS = 30000, HARNESS_GIT_ENV;
 var init_memory_worktree = __esm(() => {
   init_memory_git_signing();
   init_debug();
-  execFile13 = promisify13(execFileCb4);
+  execFile14 = promisify14(execFileCb4);
   HARNESS_GIT_ENV = {
     GIT_AUTHOR_NAME: "Letta Code",
     GIT_AUTHOR_EMAIL: "noreply@letta.com",
@@ -402835,7 +402932,7 @@ function notifyTurnStarted(msg) {
     try {
       hooksByOtid.get(otid)?.onStarted?.();
     } catch (error4) {
-      console.error("[Listen V2] Turn observer onStarted failed", error4);
+      debugWarn("Listen V2", "Turn observer onStarted failed", error4);
     }
   }
 }
@@ -402844,12 +402941,13 @@ function notifyTurnFinished(msg) {
     try {
       hooksByOtid.get(otid)?.onFinished();
     } catch (error4) {
-      console.error("[Listen V2] Turn observer onFinished failed", error4);
+      debugWarn("Listen V2", "Turn observer onFinished failed", error4);
     }
   }
 }
 var hooksByOtid;
 var init_turn_observers = __esm(() => {
+  init_debug();
   hooksByOtid = new Map;
 });
 
@@ -404261,6 +404359,7 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
   const turnWorkingDirectory = getConversationWorkingDirectory(runtime.listener, agentId, conversationId);
   const turnPermissionModeState = getOrCreateConversationPermissionModeStateRef(runtime.listener, agentId, conversationId);
   let postStopApprovalRecoveryRetries = 0, llmApiErrorRetries = 0, emptyResponseRetries = 0, chatgptPlanSwaps = 0, lastApprovalContinuationAccepted = false, activeDequeuedBatchId = dequeuedBatchId;
+  const chatgptExhaustedProviders = new Set;
   const turnCorrelation = existingTurnCorrelation ?? createTurnCorrelation(runtime, msg, activeDequeuedBatchId);
   const msgRunIds = [];
   let lastExecutionResults = null;
@@ -404627,8 +404726,10 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
         if (agentId && chatgptPlanSwaps < CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN) {
           const rotation = await rotateChatGPTPlanOnQuotaLimit({
             agentId,
+            conversationId,
             currentHandle: null,
-            error: quotaError
+            error: quotaError,
+            exhaustedProviders: chatgptExhaustedProviders
           });
           if (rotation) {
             chatgptPlanSwaps += 1;
@@ -405486,7 +405587,7 @@ function handleTerminalSpawn(msg, socket, cwd2, connectionId = "legacy") {
       alive = false;
     }
     if (alive) {
-      console.log(`[Terminal] Reusing session (age=${Date.now() - existing.spawnedAt}ms), pid=${existing.pid}`);
+      debugLog("Terminal", `Reusing session (age=${Date.now() - existing.spawnedAt}ms), pid=${existing.pid}`);
       sendTerminalMessage(socket, {
         type: "terminal_spawned",
         terminal_id,
@@ -405498,18 +405599,18 @@ function handleTerminalSpawn(msg, socket, cwd2, connectionId = "legacy") {
   }
   killTerminal(terminal_id, connectionId);
   const shell2 = getDefaultShell();
-  console.log(`[Terminal] Spawning PTY (${IS_BUN ? "bun" : "node-pty"}): shell=${shell2}, cwd=${cwd2}, cols=${cols}, rows=${rows}`);
+  debugLog("Terminal", `Spawning PTY (${IS_BUN ? "bun" : "node-pty"}): shell=${shell2}, cwd=${cwd2}, cols=${cols}, rows=${rows}`);
   try {
     const session = IS_BUN ? spawnBun(shell2, cwd2, cols, rows, terminal_id, connectionId, socket) : spawnNodePty(shell2, cwd2, cols, rows, terminal_id, connectionId, socket);
     terminals.set(terminalKey, session);
-    console.log(`[Terminal] Session stored for terminal_id=${terminal_id}, pid=${session.pid}`);
+    debugLog("Terminal", `Session stored for terminal_id=${terminal_id}, pid=${session.pid}`);
     sendTerminalMessage(socket, {
       type: "terminal_spawned",
       terminal_id,
       pid: session.pid
     });
   } catch (error4) {
-    console.error("[Terminal] Failed to spawn PTY:", error4);
+    debugWarn("Terminal", "Failed to spawn PTY:", error4);
     sendTerminalMessage(socket, {
       type: "terminal_exited",
       terminal_id,
@@ -405527,7 +405628,7 @@ function handleTerminalResize(msg, connectionId = "legacy") {
 function handleTerminalKill(msg, connectionId = "legacy") {
   const session = terminals.get(getTerminalKey(connectionId, msg.terminal_id));
   if (session && Date.now() - session.spawnedAt < 2000) {
-    console.log(`[Terminal] Ignoring kill for recently spawned session (age=${Date.now() - session.spawnedAt}ms)`);
+    debugLog("Terminal", `Ignoring kill for recently spawned session (age=${Date.now() - session.spawnedAt}ms)`);
     return;
   }
   killTerminal(msg.terminal_id, connectionId);
@@ -405536,7 +405637,7 @@ function killTerminal(terminalId, connectionId) {
   const terminalKey = getTerminalKey(connectionId, terminalId);
   const session = terminals.get(terminalKey);
   if (session) {
-    console.log(`[Terminal] killTerminal: terminalId=${terminalId}, pid=${session.pid}`);
+    debugLog("Terminal", `killTerminal: terminalId=${terminalId}, pid=${session.pid}`);
     session.kill();
     terminals.delete(terminalKey);
   }
@@ -405555,6 +405656,7 @@ function killAllTerminals() {
 }
 var IS_BUN, FLUSH_INTERVAL_MS = 16, MAX_BUFFER_BYTES, terminals;
 var init_terminal_handler = __esm(() => {
+  init_debug();
   IS_BUN = typeof Bun !== "undefined";
   MAX_BUFFER_BYTES = 64 * 1024;
   terminals = new Map;
@@ -405664,7 +405766,7 @@ var init_connection_lifecycle = __esm(async () => {
 });
 
 // src/websocket/listener/connection-state-sync.ts
-function emitInitialConnectionState(runtime, transport, connectionId, options = {}) {
+async function emitInitialConnectionState(runtime, transport, connectionId, options = {}) {
   if (options.emitInitialState === false)
     return;
   const routing = toListenerConnection(connectionId);
@@ -405677,17 +405779,19 @@ function emitInitialConnectionState(runtime, transport, connectionId, options =
       agent_id: conversationRuntime.agentId,
       conversation_id: conversationRuntime.conversationId
     };
+    await refreshDeviceGitContext(conversationRuntime, scope);
     emitDeviceStatusUpdate(transport, conversationRuntime, scope, routing);
     emitLoopStatusUpdate(transport, conversationRuntime, scope, routing);
   }
 }
-function replaySubscribedConnectionState(listener, transport, runtime, scope, forceDeviceStatus) {
+async function replaySubscribedConnectionState(listener, transport, runtime, scope, options = {}) {
+  await (options.refreshGitContext ?? refreshDeviceGitContext)(listener, scope);
   const connection = findListenerConnectionByTransport(listener, transport);
   if (connection) {
     replayPendingApprovalRequestsToConnection(runtime, connection.id);
   }
   emitStateSync(transport, listener, scope, {
-    forceDeviceStatus,
+    forceDeviceStatus: options.forceDeviceStatus,
     ...connection ? { routing: toListenerConnection(connection.id) } : {}
   });
 }
@@ -405698,7 +405802,7 @@ var init_connection_state_sync = __esm(() => {
 });
 
 // src/websocket/listener/grep-in-files.ts
-import { execFile as execFile14 } from "node:child_process";
+import { execFile as execFile15 } from "node:child_process";
 import { createRequire as createRequire6 } from "node:module";
 import * as path43 from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
@@ -405754,7 +405858,7 @@ async function runGrepInFiles(args) {
 }
 function runRipgrep(rgArgs) {
   return new Promise((resolve35, reject2) => {
-    const child = execFile14(rgPath, rgArgs, {
+    const child = execFile15(rgPath, rgArgs, {
       maxBuffer: 50 * 1024 * 1024
     }, (error4, stdout, _stderr) => {
       if (error4 && error4.code !== 1) {
@@ -406222,10 +406326,10 @@ function createFileCommandSession(params) {
       return true;
     }
     if (isListInDirectoryCommand(parsed)) {
-      console.log(`[Listen] Received list_in_directory command: path=${parsed.path}`);
+      logFileCommand(`[Listen] Received list_in_directory command: path=${parsed.path}`);
       runDetachedListenerTask("list_in_directory", async () => {
         try {
-          console.log(`[Listen] Reading directory: ${parsed.path}`);
+          logFileCommand(`[Listen] Reading directory: ${parsed.path}`);
           const { folders: allFolders, files: allFiles } = await listDirectoryDirect(parsed.path, parsed.path, !!parsed.include_files);
           const total = allFolders.length + allFiles.length;
           const offset = parsed.offset ?? 0;
@@ -406247,11 +406351,11 @@ function createFileCommandSession(params) {
           if (parsed.include_files) {
             response.files = files;
           }
-          console.log(`[Listen] Sending list_in_directory_response: ${folders.length} folders, ${files?.length ?? 0} files`);
+          logFileCommand(`[Listen] Sending list_in_directory_response: ${folders.length} folders, ${files?.length ?? 0} files`);
           safeSocketSend(socket, response, "listener_list_directory_send_failed", "listener_list_in_directory");
         } catch (err) {
           trackListenerError3("listener_list_directory_failed", err, "listener_file_browser");
-          console.error(`[Listen] list_in_directory error: ${err instanceof Error ? err.message : "Unknown error"}`);
+          warnFileCommand(`[Listen] list_in_directory error: ${err instanceof Error ? err.message : "Unknown error"}`);
           safeSocketSend(socket, {
             type: "list_in_directory_response",
             path: parsed.path,
@@ -406266,14 +406370,14 @@ function createFileCommandSession(params) {
       return true;
     }
     if (isGetTreeCommand(parsed)) {
-      console.log(`[Listen] Received get_tree command: path=${parsed.path}, depth=${parsed.depth}`);
+      logFileCommand(`[Listen] Received get_tree command: path=${parsed.path}, depth=${parsed.depth}`);
       runDetachedListenerTask("get_tree", async () => {
         try {
           const { entries: results, hasMoreDepth } = await getTreeDirect({
             root: parsed.path,
             depth: parsed.depth
           });
-          console.log(`[Listen] Sending get_tree_response: ${results.length} entries, has_more_depth=${hasMoreDepth}`);
+          logFileCommand(`[Listen] Sending get_tree_response: ${results.length} entries, has_more_depth=${hasMoreDepth}`);
           safeSocketSend(socket, {
             type: "get_tree_response",
             path: parsed.path,
@@ -406284,7 +406388,7 @@ function createFileCommandSession(params) {
           }, "listener_get_tree_send_failed", "listener_get_tree");
         } catch (err) {
           trackListenerError3("listener_get_tree_failed", err, "listener_file_browser");
-          console.error(`[Listen] get_tree error: ${err instanceof Error ? err.message : "Unknown error"}`);
+          warnFileCommand(`[Listen] get_tree error: ${err instanceof Error ? err.message : "Unknown error"}`);
           safeSocketSend(socket, {
             type: "get_tree_response",
             path: parsed.path,
@@ -406300,7 +406404,7 @@ function createFileCommandSession(params) {
     }
     if (isReadFileCommand(parsed)) {
       const encoding = parsed.encoding ?? "utf8";
-      console.log(`[Listen] Received read_file command: path=${parsed.path}, encoding=${encoding}, request_id=${parsed.request_id}`);
+      logFileCommand(`[Listen] Received read_file command: path=${parsed.path}, encoding=${encoding}, request_id=${parsed.request_id}`);
       runDetachedListenerTask("read_file", async () => {
         try {
           let content;
@@ -406315,7 +406419,7 @@ function createFileCommandSession(params) {
           } else {
             content = await readUtf8TextStrict(parsed.path);
           }
-          console.log(`[Listen] read_file success: ${parsed.path} (${content.length} bytes, ${encoding})`);
+          logFileCommand(`[Listen] read_file success: ${parsed.path} (${content.length} bytes, ${encoding})`);
           safeSocketSend(socket, {
             type: "read_file_response",
             request_id: parsed.request_id,
@@ -406326,7 +406430,7 @@ function createFileCommandSession(params) {
           }, "listener_read_file_send_failed", "listener_read_file");
         } catch (err) {
           trackListenerError3("listener_read_file_failed", err, "listener_file_read");
-          console.error(`[Listen] read_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
+          warnFileCommand(`[Listen] read_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
           safeSocketSend(socket, {
             type: "read_file_response",
             request_id: parsed.request_id,
@@ -406341,7 +406445,7 @@ function createFileCommandSession(params) {
       return true;
     }
     if (isWriteFileCommand(parsed)) {
-      console.log(`[Listen] Received write_file command: path=${parsed.path}, request_id=${parsed.request_id}`);
+      logFileCommand(`[Listen] Received write_file command: path=${parsed.path}, request_id=${parsed.request_id}`);
       runDetachedListenerTask("write_file", async () => {
         try {
           const { edit: edit3 } = await Promise.resolve().then(() => (init_edit2(), exports_edit));
@@ -406369,7 +406473,7 @@ function createFileCommandSession(params) {
               });
             }
           }
-          console.log(`[Listen] write_file success: ${parsed.path} (${parsed.content.length} bytes)`);
+          logFileCommand(`[Listen] write_file success: ${parsed.path} (${parsed.content.length} bytes)`);
           safeSocketSend(socket, {
             type: "write_file_response",
             request_id: parsed.request_id,
@@ -406377,7 +406481,7 @@ function createFileCommandSession(params) {
             success: true
           }, "listener_write_file_send_failed", "listener_write_file");
         } catch (err) {
-          console.error(`[Listen] write_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
+          warnFileCommand(`[Listen] write_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
           safeSocketSend(socket, {
             type: "write_file_response",
             request_id: parsed.request_id,
@@ -406452,11 +406556,11 @@ function createFileCommandSession(params) {
       return true;
     }
     if (isEditFileCommand(parsed)) {
-      console.log(`[Listen] Received edit_file command: file_path=${parsed.file_path}, request_id=${parsed.request_id}`);
+      logFileCommand(`[Listen] Received edit_file command: file_path=${parsed.file_path}, request_id=${parsed.request_id}`);
       runDetachedListenerTask("edit_file", async () => {
         try {
           const { edit: edit3 } = await Promise.resolve().then(() => (init_edit2(), exports_edit));
-          console.log(`[Listen] Executing edit: old_string="${parsed.old_string.slice(0, 50)}${parsed.old_string.length > 50 ? "..." : ""}"`);
+          logFileCommand(`[Listen] Executing edit: old_string="${parsed.old_string.slice(0, 50)}${parsed.old_string.length > 50 ? "..." : ""}"`);
           const result2 = await edit3({
             file_path: parsed.file_path,
             old_string: parsed.old_string,
@@ -406464,7 +406568,7 @@ function createFileCommandSession(params) {
             replace_all: parsed.replace_all,
             expected_replacements: parsed.expected_replacements
           });
-          console.log(`[Listen] edit_file success: ${result2.replacements} replacement(s) at line ${result2.startLine}`);
+          logFileCommand(`[Listen] edit_file success: ${result2.replacements} replacement(s) at line ${result2.startLine}`);
           if (result2.replacements > 0) {
             try {
               const contentAfter = await readUtf8TextStrict(parsed.file_path);
@@ -406489,7 +406593,7 @@ function createFileCommandSession(params) {
           }, "listener_edit_file_send_failed", "listener_edit_file");
         } catch (err) {
           trackListenerError3("listener_edit_file_failed", err, "listener_file_edit");
-          console.error(`[Listen] edit_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
+          warnFileCommand(`[Listen] edit_file error: ${err instanceof Error ? err.message : "Unknown error"}`);
           safeSocketSend(socket, {
             type: "edit_file_response",
             request_id: parsed.request_id,
@@ -406509,9 +406613,9 @@ function createFileCommandSession(params) {
           try {
             const content = parsed.document_content;
             await writeUtf8Text(parsed.path, content);
-            console.log(`[Listen] file_ops: wrote ${content.length} bytes to ${parsed.path}`);
+            logFileCommand(`[Listen] file_ops: wrote ${content.length} bytes to ${parsed.path}`);
           } catch (err) {
-            console.error(`[Listen] file_ops error: ${err instanceof Error ? err.message : "Unknown error"}`);
+            warnFileCommand(`[Listen] file_ops error: ${err instanceof Error ? err.message : "Unknown error"}`);
           }
         });
       }
@@ -406521,13 +406625,16 @@ function createFileCommandSession(params) {
   };
   return { handle: handle2, dispose };
 }
-var import_picomatch2, DIR_LISTING_IGNORED_NAMES, RECURSIVE_IGNORED_NAMES, PROTECTED_HOME_NAMES, MAX_SEARCH_VISITED_ENTRIES = 50000, MAX_TREE_ENTRIES = 5000, MAX_SEARCH_RESULTS = 200, MAX_BASE64_READ_BYTES, ignoreConfigCache;
+var import_picomatch2, logFileCommand, warnFileCommand, DIR_LISTING_IGNORED_NAMES, RECURSIVE_IGNORED_NAMES, PROTECTED_HOME_NAMES, MAX_SEARCH_VISITED_ENTRIES = 50000, MAX_TREE_ENTRIES = 5000, MAX_SEARCH_RESULTS = 200, MAX_BASE64_READ_BYTES, ignoreConfigCache;
 var init_file_commands = __esm(() => {
   init_error_reporting();
+  init_debug();
   init_text_files();
   init_grep_in_files();
   init_protocol_inbound();
   import_picomatch2 = __toESM(require_picomatch(), 1);
+  logFileCommand = debugLog.bind(null, "file-commands");
+  warnFileCommand = debugWarn.bind(null, "file-commands");
   DIR_LISTING_IGNORED_NAMES = new Set([".DS_Store", ".git", "Thumbs.db"]);
   RECURSIVE_IGNORED_NAMES = new Set([
     ...DIR_LISTING_IGNORED_NAMES,
@@ -407471,6 +407578,13 @@ async function handleExecuteCommand(command, socket, conversationRuntime, opts)
           actingUserId: command.runtime.acting_user_id
         });
         break;
+      case "clear-messages":
+        output = await handleClearCommand(socket, conversationRuntime, {
+          ...opts,
+          actingUserId: command.runtime.acting_user_id,
+          resetAllAgentMessages: true
+        });
+        break;
       case "doctor":
         output = await handleDoctorCommand(socket, conversationRuntime, opts);
         break;
@@ -407625,7 +407739,7 @@ async function handleUpgradeLettaCodeCommand(opts) {
     if (opts.onLog) {
       opts.onLog(line);
     } else {
-      console.log(line);
+      debugLog("upgrade-letta-code", message);
     }
   };
   log2(`command received (connectionName=${opts.connectionName ?? "unknown"}, execPath=${process.execPath}, entrypoint=${process.argv[1] ?? "unknown"})`);
@@ -407651,11 +407765,11 @@ function scheduleRemoteRestart(connectionName, log2) {
     log2(`restart skipped (entrypoint=${entrypoint ?? "missing"}, connectionName=${connectionName ?? "missing"})`);
     return;
   }
-  log2(`scheduling remote listener restart for env ${connectionName}`);
+  log2(`scheduling remote listener restart for computer ${connectionName}`);
   setTimeout(async () => {
     await flushRemoteSettingsWrites();
-    log2(`spawning replacement listener: ${process.execPath} ${entrypoint} remote --env-name ${connectionName}`);
-    const child = spawn9(process.execPath, [entrypoint, "remote", "--env-name", connectionName], {
+    log2(`spawning replacement listener: ${process.execPath} ${entrypoint} remote --computer-name ${connectionName}`);
+    const child = spawn9(process.execPath, [entrypoint, "remote", "--computer-name", connectionName], {
       cwd: process.cwd(),
       detached: true,
       env: process.env,
@@ -407769,7 +407883,10 @@ async function handleClearCommand(_socket, conversationRuntime, opts) {
   if (!agentId) {
     throw new Error("No agent ID available for /clear command");
   }
-  if (conversationRuntime.conversationId === "default" && !backend3.capabilities.localModelCatalog) {
+  if (opts.resetAllAgentMessages && backend3.capabilities.localModelCatalog) {
+    throw new Error("/clear-messages is not supported by the local backend.");
+  }
+  if (!backend3.capabilities.localModelCatalog && (opts.resetAllAgentMessages || conversationRuntime.conversationId === "default")) {
     const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
     const client = await getClient2();
     await client.agents.messages.reset(agentId, {
@@ -407782,7 +407899,7 @@ async function handleClearCommand(_socket, conversationRuntime, opts) {
   clearConversationRuntimeState(conversationRuntime);
   conversationRuntime.conversationId = conversation.id;
   emitListenerStatus(conversationRuntime.listener, opts.onStatusChange, opts.connectionId);
-  return "Agent's in-context messages cleared & moved to conversation history";
+  return opts.resetAllAgentMessages ? "All agent messages reset" : "Agent's in-context messages cleared & moved to conversation history";
 }
 async function handleDoctorCommand(socket, conversationRuntime, opts) {
   const agentId = conversationRuntime.agentId;
@@ -408052,7 +408169,7 @@ function getCwdScopeKeyFromRuntimeKey(runtimeKey) {
   const conversationId = runtimeKey.slice(markerIndex + marker.length);
   return conversationId === "default" ? runtimeKey : `conversation:${conversationId}`;
 }
-function applyScopeUpdates(socket, runtime) {
+async function applyScopeUpdates(socket, runtime) {
   for (const [runtimeKey, state] of runtime.reminderStateByConversation) {
     const scopeKey = getCwdScopeKeyFromRuntimeKey(runtimeKey);
     if (!scopeKey || runtime.workingDirectoryByConversation.has(scopeKey)) {
@@ -408066,10 +408183,12 @@ function applyScopeUpdates(socket, runtime) {
     if (runtime.workingDirectoryByConversation.has(scopeKey) || conversationRuntime.activeWorkingDirectory) {
       continue;
     }
-    emitDeviceStatusUpdate(socket, conversationRuntime, {
+    const scope = {
       agent_id: conversationRuntime.agentId,
       conversation_id: conversationRuntime.conversationId
-    });
+    };
+    await refreshDeviceGitContext(conversationRuntime, scope);
+    emitDeviceStatusUpdate(socket, conversationRuntime, scope);
   }
 }
 async function handleSetBootWorkingDirectoryCommand(command, context3) {
@@ -408082,7 +408201,7 @@ async function handleSetBootWorkingDirectoryCommand(command, context3) {
       settingsManager.loadLocalProjectSettings(normalizedPath)
     ]);
     if (setBootWorkingDirectory(runtime, normalizedPath)) {
-      applyScopeUpdates(socket, runtime);
+      await applyScopeUpdates(socket, runtime);
     }
     safeSocketSend(socket, {
       type: "set_boot_working_directory_response",
@@ -409161,8 +409280,8 @@ var init_connect_providers = __esm(() => {
 });
 
 // src/websocket/listener/commands/git-branches.ts
-import { execFile as execFile15 } from "node:child_process";
-import { promisify as promisify14 } from "node:util";
+import { execFile as execFile16 } from "node:child_process";
+import { promisify as promisify15 } from "node:util";
 function handleGitBranchCommand(parsed, context3) {
   const { socket, runtime, safeSocketSend, runDetachedListenerTask } = context3;
   if (isSearchBranchesCommand(parsed)) {
@@ -409170,8 +409289,8 @@ function handleGitBranchCommand(parsed, context3) {
       try {
         const cwd2 = parsed.cwd ?? getBootWorkingDirectory(runtime);
         const maxResults = parsed.max_results ?? 20;
-        const execFileAsync9 = promisify14(execFile15);
-        const { stdout } = await execFileAsync9("git", ["branch", "-a", "--format=%(refname:short)\t%(HEAD)"], {
+        const execFileAsync10 = promisify15(execFile16);
+        const { stdout } = await execFileAsync10("git", ["branch", "-a", "--format=%(refname:short)\t%(HEAD)"], {
           cwd: cwd2,
           encoding: "utf-8",
           timeout: 5000
@@ -409210,14 +409329,16 @@ function handleGitBranchCommand(parsed, context3) {
     runDetachedListenerTask("checkout_branch", async () => {
       try {
         const cwd2 = parsed.cwd ?? getBootWorkingDirectory(runtime);
-        const execFileAsync9 = promisify14(execFile15);
+        const execFileAsync10 = promisify15(execFile16);
         const args = parsed.create ? ["checkout", "-b", parsed.branch] : ["checkout", parsed.branch];
-        await execFileAsync9("git", args, {
+        await execFileAsync10("git", args, {
           cwd: cwd2,
           encoding: "utf-8",
           timeout: 1e4
         });
-        const gitCtx = getGitContext(cwd2);
+        const gitCtx = await deviceGitContextCache.refresh(cwd2, {
+          force: true
+        });
         safeSocketSend(socket, {
           type: "checkout_branch_response",
           request_id: parsed.request_id,
@@ -409240,8 +409361,8 @@ function handleGitBranchCommand(parsed, context3) {
   return false;
 }
 var init_git_branches = __esm(() => {
-  init_git_context();
   init_cwd();
+  init_device_git_context();
   init_protocol_inbound();
   init_protocol_outbound();
 });
@@ -409786,6 +409907,13 @@ var init_split_stream_lifecycle = __esm(() => {
 });
 
 // src/websocket/listener/message-router.ts
+function logV2Command(opts, message) {
+  if (opts.onLog) {
+    opts.onLog(`[Listen V2] ${message}`);
+    return;
+  }
+  debugLog("Listen V2", message);
+}
 function createListenerMessageHandler(params) {
   const {
     runtime,
@@ -409835,7 +409963,7 @@ function createListenerMessageHandler(params) {
       if (!parsed) {
         return;
       }
-      console.log(`[Listen V2] Received ${summarizeV2Command(parsed)}`);
+      logV2Command(opts, `Received ${summarizeV2Command(parsed)}`);
       if (parsedScope) {
         subscribeListenerConnection(runtime, connectionId, parsedScope);
       }
@@ -409911,7 +410039,7 @@ function createListenerMessageHandler(params) {
       }
       if (parsed.type === "sync") {
         if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
-          console.log(`[Listen V2] Dropping sync: runtime mismatch or closed`);
+          logV2Command(opts, "Dropping sync: runtime mismatch or closed");
           if (parsed.request_id) {
             safeSocketSend(socket, {
               type: "sync_response",
@@ -409965,7 +410093,7 @@ function createListenerMessageHandler(params) {
           }, "input_accepted_response", "input");
         };
         if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
-          console.log(`[Listen V2] Dropping input: runtime mismatch or closed`);
+          logV2Command(opts, "Dropping input: runtime mismatch or closed");
           acknowledgeInput(false, "Runtime is no longer active");
           return;
         }
@@ -410684,7 +410812,7 @@ async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
       }
     }
   }
-  replaySubscribedConnectionState(listenerRuntime, socket, syncScopedRuntime, scope, opts?.forceDeviceStatus);
+  await replaySubscribedConnectionState(listenerRuntime, socket, syncScopedRuntime, scope, opts);
   (opts?.scheduleWarmupsAfterSync ?? scheduleListenerWarmupsAfterSync)(listenerRuntime, scope);
 }
 function getParsedRuntimeScope(parsed) {
@@ -410808,7 +410936,7 @@ async function startConnectedListenerRuntime(runtime, transport, opts, processQu
   runtime.hasSuccessfulConnection = true;
   runtime.everConnected = true;
   await opts.onConnected(opts.connectionId);
-  emitInitialConnectionState(runtime, transport, opts.connectionId, options);
+  await emitInitialConnectionState(runtime, transport, opts.connectionId, options);
   for (const conversationRuntime of runtime.conversationRuntimes.values()) {
     replayPendingApprovalRequestsToConnection(conversationRuntime, opts.connectionId);
   }
@@ -411266,6 +411394,7 @@ var init_lifecycle = __esm(async () => {
   init_recovery_sync();
   init_runtime();
   init_split_stream_lifecycle();
+  init_stream_observers();
   init_transport();
   init_worktree_watcher();
   await __promiseAll([
@@ -414034,7 +414163,7 @@ function PromptEnvName(props) {
     flexDirection: "column",
     children: [
       /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
-        children: "Enter environment name (or press Enter for hostname): "
+        children: "Enter computer name (or press Enter for hostname): "
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(build_default, {
         value,
@@ -414111,14 +414240,14 @@ function shouldAcquireStandaloneListenerLock() {
   return shouldAcquireManualListenerLock(getSpawnerListenerInstanceId(), process.env.LETTA_DESKTOP_MODE === "1");
 }
 function printListenUsage() {
-  console.log(`Usage: letta server [--env-name <name>] [--channels <list>] [--skills <path>] [--debug]
+  console.log(`Usage: letta server [--computer-name <name>] [--channels <list>] [--skills <path>] [--debug]
 `);
-  console.log(`Register this letta-code instance to receive messages from Letta Cloud.
+  console.log(`Register this computer to receive messages from Letta Cloud.
 `);
   console.log("Options:");
-  console.log("  --env-name <name>  Friendly name for this environment (uses hostname if not provided)");
+  console.log("  --computer-name <name>  Friendly name for this computer (uses hostname if not provided)");
   console.log("  --channels <list>  Comma-separated channel names to enable (e.g. telegram)");
-  console.log("  --skills <path>     Use this directory for environment-provided skills");
+  console.log("  --skills <path>     Use this directory for computer-provided skills");
   console.log("  --install-channel-runtimes  Install missing runtime deps for the selected channels before startup");
   console.log("  --debug            Plain-text mode: log all WebSocket events instead of interactive UI");
   console.log(`  -h, --help         Show this help message
@@ -414126,13 +414255,13 @@ function printListenUsage() {
   console.log("Examples:");
   console.log("  letta channels configure telegram          # Configure Telegram first");
   console.log("  letta server                              # Uses hostname as default");
-  console.log('  letta server --env-name "work-laptop"');
+  console.log('  letta server --computer-name "work-laptop"');
   console.log("  letta server --channels telegram           # Enable Telegram channel");
   console.log("  letta server --channels telegram --install-channel-runtimes");
   console.log(`  letta server --debug                       # Log all WS events
 `);
   console.log("Once connected, this instance will listen for incoming messages from cloud agents.");
-  console.log("Messages will be executed locally using your letta-code environment.");
+  console.log("Messages will be executed locally on this computer.");
   console.log("Telegram flow: configure the bot, start the listener with --channels telegram,");
   console.log("then message the bot from Telegram and run /channels telegram pair <code> in the target conversation.");
 }
@@ -414152,6 +414281,8 @@ async function runListenSubcommand(argv) {
     return 1;
   }
   const debugMode = !!values3.debug;
+  if (debugMode)
+    process.env.LETTA_DEBUG = "1";
   const skillsDirectory = values3.skills ?? process.env.LETTA_SKILLS_DIRECTORY;
   if (values3.help) {
     printListenUsage();
@@ -414221,8 +414352,9 @@ async function runListenSubcommand(argv) {
   const restoreAgentScope = restoreEnabledChannels ? resolveChannelRestoreAgentScope(scopedRestoreAgentScope) : null;
   const channelNames = values3.channels ? values3.channels.split(",").map((s3) => s3.trim()).filter(Boolean) : [];
   let connectionName;
-  if (values3["env-name"]) {
-    connectionName = values3["env-name"];
+  const explicitComputerName = values3["computer-name"] ?? values3["env-name"];
+  if (explicitComputerName) {
+    connectionName = explicitComputerName;
     settingsManager.setListenerEnvName(connectionName);
   } else {
     const savedName = settingsManager.getListenerEnvName();
@@ -414246,12 +414378,17 @@ async function runListenSubcommand(argv) {
   const sessionLog = new RemoteSessionLog;
   sessionLog.init();
   console.log(`Log file: ${sessionLog.path}`);
+  const logListenerMessage = (message) => {
+    sessionLog.log(message);
+    if (debugMode)
+      console.log(`[${formatTimestamp3()}] ${message}`);
+  };
   try {
     const deviceId = settingsManager.getOrCreateDeviceId();
     const startupMode = await resolveListenerStartupMode(channelNames, channelNames.length > 0 || restoreEnabledChannels);
     if (startupMode.kind === "unsupported-self-hosted") {
       console.error(`Self-hosted listener registration is not available for ${startupMode.serverUrl}.`);
-      console.error("Start with --channels to run local channel adapters, or unset LETTA_BASE_URL to use Letta API remote environments.");
+      console.error("Start with --channels to run local channel adapters, or unset LETTA_BASE_URL to use Letta API remote computers.");
       await flushListenerTelemetryEnd("listener_self_hosted_no_channels");
       return 1;
     }
@@ -414283,8 +414420,8 @@ async function runListenSubcommand(argv) {
           });
         } catch (lockError) {
           if (lockError instanceof ManualListenerAlreadyRunningError) {
-            console.error(`A letta server for environment "${connectionName}" is already running on this machine (pid ${lockError.holderPid}).`);
-            console.error("Stop that process, or choose a different logical listener with --env-name.");
+            console.error(`A letta server for computer "${connectionName}" is already running on this machine (pid ${lockError.holderPid}).`);
+            console.error("Stop that process, or choose a different logical listener with --computer-name.");
             console.error(`Lock: ${lockError.lockPath}`);
             await flushListenerTelemetryEnd("listener_already_running");
             return 1;
@@ -414373,15 +414510,16 @@ async function runListenSubcommand(argv) {
       const connectionId2 = `local-${deviceId}`;
       const startupLabel = startupMode.backend === "local" ? "local backend" : `self-hosted server ${startupMode.serverUrl}`;
       sessionLog.log(`Starting local channel listener for ${startupLabel}`);
-      sessionLog.log("Skipping environment registration");
+      sessionLog.log("Skipping computer registration");
       console.log(`Starting local channel listener for ${startupLabel}`);
-      console.log(`Skipping environment registration. Press Ctrl+C to stop.
+      console.log(`Skipping computer registration. Press Ctrl+C to stop.
 `);
       const { startLocalChannelListener: startLocalChannelListener2 } = await init_listen_client().then(() => exports_listen_client);
       await startLocalChannelListener2({
         connectionId: connectionId2,
         deviceId,
         connectionName,
+        onLog: logListenerMessage,
         onWsEvent: process.env.LETTA_LOG_WS_EVENTS === "1" ? (direction, label, event) => {
           sessionLog.wsEvent(direction, label, event);
         } : undefined,
@@ -414482,10 +414620,7 @@ async function runListenSubcommand(argv) {
             sessionLog.log(`status: ${status}`);
             console.log(`[${formatTimestamp3()}] status: ${status}`);
           },
-          onLog: (message) => {
-            sessionLog.log(message);
-            console.log(`[${formatTimestamp3()}] ${message}`);
-          },
+          onLog: logListenerMessage,
           onConnected: async () => {
             sessionLog.log("Connected. Awaiting instructions.");
             await startChannelGateway();
@@ -414497,7 +414632,7 @@ async function runListenSubcommand(argv) {
             console.log(`[${formatTimestamp3()}] Reconnecting (attempt ${attempt2}, retry in ${Math.round(nextRetryIn / 1000)}s)`);
           },
           onNeedsReregister: async () => {
-            console.log(`[${formatTimestamp3()}] Environment expired, re-registering...`);
+            console.log(`[${formatTimestamp3()}] Computer connection expired, re-registering...`);
             try {
               const result2 = await reregister();
               await startDebugClient(result2.connectionId, result2.wsUrl, result2.supportsSplitStatusChannels, result2.supportsPairedListenerGenerations);
@@ -414550,10 +414685,7 @@ async function runListenSubcommand(argv) {
             clearRetryStatusCallback?.();
             updateStatusCallback?.(status);
           },
-          onLog: (message) => {
-            sessionLog.log(message);
-            console.log(`[${formatTimestamp3()}] ${message}`);
-          },
+          onLog: logListenerMessage,
           onConnected: async () => {
             sessionLog.log("Connected. Awaiting instructions.");
             await startChannelGateway();
@@ -414565,7 +414697,7 @@ async function runListenSubcommand(argv) {
             updateRetryStatusCallback?.(attempt2, nextRetryIn);
           },
           onNeedsReregister: async () => {
-            sessionLog.log("Environment expired, re-registering...");
+            sessionLog.log("Computer connection expired, re-registering...");
             try {
               const result2 = await reregister();
               await startNormalClient(result2.connectionId, result2.wsUrl, result2.supportsSplitStatusChannels, result2.supportsPairedListenerGenerations);
@@ -414634,6 +414766,7 @@ var init_listen = __esm(async () => {
   jsx_dev_runtime13 = __toESM(require_jsx_dev_runtime(), 1);
   activeListenerProcessAnchors = new Set;
   LISTEN_OPTIONS = {
+    "computer-name": { type: "string" },
     "env-name": { type: "string" },
     channels: { type: "string" },
     skills: { type: "string" },
@@ -419021,7 +419154,7 @@ function finalize(ctx, schema5) {
     result2.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result2.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id2 = ctx.external.registry.get(schema5)?.id;
     if (!id2)
@@ -419236,7 +419369,7 @@ var formatMap2, stringProcessor = (schema5, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -431950,7 +432083,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.31.11"
+    version: "0.31.13"
   };
 });
 
@@ -432238,7 +432371,6 @@ async function replaceClientMcpServers(agentId, configs, options = {}) {
   const generation2 = ++runtime.generation;
   await closeActiveServers(runtime);
   runtime.agentId = agentId;
-  const usedToolNames = new Set;
   const states2 = await Promise.all(configs.map(async (config2) => {
     let oauth;
     try {
@@ -432257,20 +432389,8 @@ async function replaceClientMcpServers(agentId, configs, options = {}) {
         await connection.close();
         return { config: config2, status: "failed", tools: [], error: "Superseded" };
       }
-      const tools = connection.tools.map((tool) => {
-        const name = uniqueToolName(formatClientMcpToolName(config2.name, tool.name), usedToolNames);
-        const definition = {
-          name,
-          label: tool.title ?? tool.name,
-          description: tool.description ?? `Tool ${tool.name} from MCP server ${config2.name}`,
-          parameters: tool.inputSchema,
-          executor: async (_toolCallId, _toolName, input) => toExternalToolResult(await connection.callTool(tool.name, input))
-        };
-        return definition;
-      });
-      registerExternalTools(tools);
-      runtime.active.set(config2.name, { connection, tools });
-      return { config: config2, status: "connected", tools };
+      runtime.active.set(config2.name, { connection });
+      return { config: config2, status: "connected", tools: connection.tools };
     } catch (error5) {
       return {
         config: config2,
@@ -432318,23 +432438,11 @@ async function closeActiveServers(runtime) {
   runtime.pendingOAuth.clear();
   runtime.active.clear();
   runtime.states = [];
-  for (const server2 of active)
-    unregisterExternalTools(server2.tools);
   await Promise.allSettled([
     ...pendingOAuth.map((oauth) => oauth.close()),
     ...active.map((server2) => server2.connection.close())
   ]);
 }
-function uniqueToolName(base2, used) {
-  let name = base2;
-  let suffix = 2;
-  while (used.has(name)) {
-    name = `${base2}_${suffix}`;
-    suffix++;
-  }
-  used.add(name);
-  return name;
-}
 function formatClientMcpToolName(serverName, toolName) {
   return `mcp__${normalizeMcpName(serverName)}__${normalizeMcpName(toolName)}`;
 }
@@ -432342,35 +432450,10 @@ function normalizeMcpName(value) {
   const normalized = value.replace(/[^a-zA-Z0-9_-]/g, "_");
   return normalized || "tool";
 }
-function toExternalToolResult(result2) {
-  return {
-    content: result2.content.map((item) => normalizeContent2(item)),
-    isError: result2.isError === true
-  };
-}
-function normalizeContent2(item) {
-  if (isRecord17(item)) {
-    if (item.type === "text" && typeof item.text === "string") {
-      return { type: "text", text: item.text };
-    }
-    if ((item.type === "image" || item.type === "audio") && typeof item.data === "string") {
-      return {
-        type: item.type,
-        data: item.data,
-        ...typeof item.mimeType === "string" ? { mimeType: item.mimeType } : {}
-      };
-    }
-  }
-  return { type: "text", text: JSON.stringify(item) };
-}
-function isRecord17(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 var CLIENT_MCP_RUNTIME_KEY;
-var init_mcp_runtime = __esm(async () => {
+var init_mcp_runtime = __esm(() => {
   init_mcp_client();
   init_mcp_oauth();
-  await init_manager4();
   CLIENT_MCP_RUNTIME_KEY = Symbol.for("@letta/clientMcpRuntime");
 });
 
@@ -432611,8 +432694,8 @@ function formatServerMcpToolName(serverName, alias, toolName) {
   const rawName = toolName.startsWith(sourcePrefix) ? toolName.slice(sourcePrefix.length) : toolName;
   return formatClientMcpToolName(alias, rawName);
 }
-var init_mcp_tool_names = __esm(async () => {
-  await init_mcp_runtime();
+var init_mcp_tool_names = __esm(() => {
+  init_mcp_runtime();
 });
 
 // src/cli/subcommands/mcp.ts
@@ -433139,7 +433222,7 @@ async function runMcpSubcommand(argv, deps = {}) {
   }
 }
 var SENSITIVE_NAME;
-var init_mcp = __esm(async () => {
+var init_mcp = __esm(() => {
   init_oauth();
   init_backend2();
   init_client2();
@@ -433147,13 +433230,11 @@ var init_mcp = __esm(async () => {
   init_unified_mcp();
   init_mcp_client();
   init_mcp_oauth();
+  init_mcp_runtime();
   init_settings_manager();
   init_mcp_io();
   init_mcp_search();
-  await __promiseAll([
-    init_mcp_runtime(),
-    init_mcp_tool_names()
-  ]);
+  init_mcp_tool_names();
   SENSITIVE_NAME = /token|key|secret|password|signature|credential|auth/i;
 });
 
@@ -433236,7 +433317,7 @@ var init_memory_tokens = __esm(() => {
 });
 
 // src/cli/subcommands/memory.ts
-import { cpSync, existsSync as existsSync57, mkdirSync as mkdirSync39, rmSync as rmSync12, statSync as statSync19 } from "node:fs";
+import { cpSync, existsSync as existsSync57, mkdirSync as mkdirSync39, rmSync as rmSync13, statSync as statSync19 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
 import { dirname as dirname31, join as join72 } from "node:path";
 import { parseArgs as parseArgs11 } from "node:util";
@@ -433373,10 +433454,10 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       const { execFile: execFileCb5 } = await import("node:child_process");
-      const { promisify: promisify15 } = await import("node:util");
-      const execFile16 = promisify15(execFileCb5);
+      const { promisify: promisify16 } = await import("node:util");
+      const execFile17 = promisify16(execFileCb5);
       const dir = getScopedMemoryFilesystemRoot(agentId);
-      const { stdout } = await execFile16("git", ["diff"], { cwd: dir });
+      const { stdout } = await execFile17("git", ["diff"], { cwd: dir });
       if (stdout.trim()) {
         console.log(stdout);
         return 2;
@@ -433443,7 +433524,7 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       const root2 = getMemoryRoot(agentId);
-      rmSync12(root2, { recursive: true, force: true });
+      rmSync13(root2, { recursive: true, force: true });
       cpSync(backupPath, root2, { recursive: true });
       console.log(JSON.stringify({ restoredFrom: backupPath }, null, 2));
       return 0;
@@ -434229,12 +434310,12 @@ import {
   readdirSync as readdirSync22,
   readFileSync as readFileSync39,
   renameSync as renameSync7,
-  rmSync as rmSync13,
+  rmSync as rmSync14,
   writeFileSync as writeFileSync29
 } from "node:fs";
 import { tmpdir as tmpdir10 } from "node:os";
 import path46 from "node:path";
-function isRecord18(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPathInsideOrEqual2(childPath, parentPath) {
@@ -434250,7 +434331,7 @@ function readPackageJson(packageJsonPath) {
   } catch (error5) {
     throw new Error(`Could not read package.json: ${error5 instanceof Error ? error5.message : String(error5)}`);
   }
-  if (!isRecord18(parsed)) {
+  if (!isRecord17(parsed)) {
     throw new Error("package.json must be an object");
   }
   return parsed;
@@ -434260,7 +434341,7 @@ function formatRepository(repository) {
     const trimmed2 = repository.trim();
     return trimmed2 || undefined;
   }
-  if (!isRecord18(repository))
+  if (!isRecord17(repository))
     return;
   const url2 = repository.url;
   if (typeof url2 !== "string")
@@ -434450,7 +434531,7 @@ function copyPackageInternalNodeModules(params) {
 }
 function restoreRegistry(registryPath, previousContents) {
   if (previousContents === null) {
-    rmSync13(registryPath, { force: true });
+    rmSync14(registryPath, { force: true });
     return;
   }
   mkdirSync40(path46.dirname(registryPath), { recursive: true });
@@ -434459,17 +434540,17 @@ function restoreRegistry(registryPath, previousContents) {
 function removeIfExists(targetPath) {
   if (!targetPath)
     return;
-  rmSync13(targetPath, { force: true, recursive: true });
+  rmSync14(targetPath, { force: true, recursive: true });
 }
 function restoreDestination(params) {
-  rmSync13(params.destinationRoot, { force: true, recursive: true });
+  rmSync14(params.destinationRoot, { force: true, recursive: true });
   if (params.backupRoot && existsSync59(params.backupRoot)) {
     renameSync7(params.backupRoot, params.destinationRoot);
   }
 }
 function restoreDestinationIfNeeded(params) {
   if (!params.backupRoot || !existsSync59(params.backupRoot)) {
-    rmSync13(params.destinationRoot, { force: true, recursive: true });
+    rmSync14(params.destinationRoot, { force: true, recursive: true });
     return;
   }
   restoreDestination(params);
@@ -434511,7 +434592,7 @@ function installPreparedManagedModPackage(params) {
     }
     if (existsSync59(destinationRoot)) {
       backupRoot = makeSiblingTempDirectory(destinationRoot, "backup");
-      rmSync13(backupRoot, { force: true, recursive: true });
+      rmSync14(backupRoot, { force: true, recursive: true });
       renameSync7(destinationRoot, backupRoot);
       destinationNeedsRollback = true;
     }
@@ -434790,7 +434871,7 @@ function hasRuntimeDependencies(packageJson) {
   if (!packageJson)
     return false;
   const dependencies4 = packageJson.dependencies;
-  return isRecord18(dependencies4) && Object.keys(dependencies4).length > 0;
+  return isRecord17(dependencies4) && Object.keys(dependencies4).length > 0;
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path46.join(packageDirectory, "package.json");
@@ -434962,7 +435043,7 @@ async function installNpmManagedModPackage(params) {
       packageDirectory
     });
   } finally {
-    rmSync13(tempRoot, { force: true, recursive: true });
+    rmSync14(tempRoot, { force: true, recursive: true });
   }
 }
 async function installGitManagedModPackage(params) {
@@ -434994,7 +435075,7 @@ async function installGitManagedModPackage(params) {
       packageInfo
     });
   } finally {
-    rmSync13(tempRoot, { force: true, recursive: true });
+    rmSync14(tempRoot, { force: true, recursive: true });
   }
 }
 async function updateNpmManagedModPackage(params) {
@@ -435025,7 +435106,7 @@ async function updateNpmManagedModPackage(params) {
       previousVersion: existing.version
     };
   } finally {
-    rmSync13(tempRoot, { force: true, recursive: true });
+    rmSync14(tempRoot, { force: true, recursive: true });
   }
 }
 async function updateGitManagedModPackage(params) {
@@ -435067,7 +435148,7 @@ async function updateGitManagedModPackage(params) {
       previousVersion: existing.version
     };
   } finally {
-    rmSync13(tempRoot, { force: true, recursive: true });
+    rmSync14(tempRoot, { force: true, recursive: true });
   }
 }
 var SKIPPED_PACKAGE_COPY_NAMES, spawnNpmInstallProcessOverride = null, spawnGitInstallProcess, platformOverride2 = null;
@@ -435086,7 +435167,7 @@ import {
   existsSync as existsSync60,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync41,
-  rmSync as rmSync14,
+  rmSync as rmSync15,
   writeFileSync as writeFileSync30
 } from "node:fs";
 import path47 from "node:path";
@@ -435195,7 +435276,7 @@ function scaffoldLocalModPackage(options) {
     writeFileSync30(readmePath, createReadme(packageName));
     writeFileSync30(modGuidePath, createModGuide(packageName, manifestEntry));
   } catch (error5) {
-    rmSync14(outputDirectory, { force: true, recursive: true });
+    rmSync15(outputDirectory, { force: true, recursive: true });
     throw error5;
   }
   return {
@@ -436028,10 +436109,10 @@ function printServerHelp() {
   letta server [remote options]
   letta server --listen [url] [App Server options]
 
-Run the local agent server as a remote environment, with messaging channels, or as an App Server.
+Run the local agent server as a remote computer, with messaging channels, or as an App Server.
 
-Remote environment options:
-  --env-name <name>  Friendly name for this environment (uses hostname if not provided)
+Remote computer options:
+  --computer-name <name>  Friendly name for this computer (uses hostname if not provided)
   --channels <list>  Comma-separated channel names to enable (e.g. telegram)
   --install-channel-runtimes  Install missing runtime dependencies for selected channels
   --debug  Log WebSocket events instead of showing the interactive status UI
@@ -436052,7 +436133,7 @@ Common options:
 
 Examples:
   letta server
-  letta server --env-name "work-laptop"
+  letta server --computer-name "work-laptop"
   letta server --channels telegram
   letta server --listen
   letta server --listen ws://127.0.0.1:4500
@@ -436091,7 +436172,7 @@ function resolveServerCommand(argv) {
     }
   }
   if (foundListen) {
-    const conflictingOption = argv.find((arg) => arg === "--env-name" || arg.startsWith("--env-name=") || arg === "--channels" || arg.startsWith("--channels="));
+    const conflictingOption = argv.find((arg) => arg === "--computer-name" || arg.startsWith("--computer-name=") || arg === "--env-name" || arg.startsWith("--env-name=") || arg === "--channels" || arg.startsWith("--channels="));
     if (conflictingOption) {
       throw new Error(`${conflictingOption.split("=")[0]} cannot be used with --listen`);
     }
@@ -438298,7 +438379,7 @@ import {
   existsSync as existsSync62,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync40,
-  rmSync as rmSync15,
+  rmSync as rmSync16,
   statSync as statSync21,
   writeFileSync as writeFileSync31
 } from "node:fs";
@@ -438567,15 +438648,15 @@ function resolveSkillSourceSpecifier(input) {
   }
   return null;
 }
-async function execFile16(command, args, options = {}) {
+async function execFile17(command, args, options = {}) {
   const { execFile: execFileCb5 } = await import("node:child_process");
-  const { promisify: promisify15 } = await import("node:util");
-  return promisify15(execFileCb5)(command, args, options);
+  const { promisify: promisify16 } = await import("node:util");
+  return promisify16(execFileCb5)(command, args, options);
 }
 async function resolveBranchAndSubdir(location) {
   if (!location.subdir)
     return location;
-  const { stdout } = await execFile16("git", ["ls-remote", "--heads", location.repoUrl], {
+  const { stdout } = await execFile17("git", ["ls-remote", "--heads", location.repoUrl], {
     timeout: 60000
   });
   const branches = stdout.split(`
@@ -438602,7 +438683,7 @@ async function cloneSkillSource(location) {
     args.push("--branch", resolvedLocation.branch);
   }
   args.push(resolvedLocation.repoUrl, tmpDir);
-  await execFile16("git", args, { timeout: 120000 });
+  await execFile17("git", args, { timeout: 120000 });
   const sourceDir = resolvedLocation.subdir ? join76(tmpDir, resolvedLocation.subdir) : tmpDir;
   return { tmpDir, sourceDir };
 }
@@ -438665,7 +438746,7 @@ async function downloadDirectSkillFileSource(location, options = {}) {
     writeFileSync31(join76(sourceDir, "SKILL.md"), skillText, "utf8");
     return { tmpDir, sourceDir };
   } catch (error5) {
-    rmSync15(tmpDir, { recursive: true, force: true });
+    rmSync16(tmpDir, { recursive: true, force: true });
     throw error5;
   }
 }
@@ -438715,7 +438796,7 @@ async function downloadClawHubSkillSource(location) {
     throw new Error(`ClawHub download failed for ${location.slug}@${version2}: ${response.status}`);
   }
   writeFileSync31(zipPath, Buffer.from(await response.arrayBuffer()));
-  const { stdout } = await execFile16("unzip", ["-Z1", zipPath], {
+  const { stdout } = await execFile17("unzip", ["-Z1", zipPath], {
     timeout: 30000
   });
   const members = stdout.split(`
@@ -438724,7 +438805,7 @@ async function downloadClawHubSkillSource(location) {
     throw new Error(`ClawHub download was empty for ${location.slug}@${version2}`);
   }
   members.forEach(assertSafeZipMember);
-  await execFile16("unzip", ["-q", zipPath, "-d", sourceDir], {
+  await execFile17("unzip", ["-q", zipPath, "-d", sourceDir], {
     timeout: 30000
   });
   return { tmpDir, sourceDir };
@@ -438768,7 +438849,7 @@ async function installSkillDirectory(params) {
     if (!params.force) {
       throw new Error(`Skill "${name}" already exists at ${targetPath}. Re-run with --force to replace it.`);
     }
-    rmSync15(targetPath, { recursive: true, force: true });
+    rmSync16(targetPath, { recursive: true, force: true });
   }
   await mkdir14(skillsDir, { recursive: true });
   cpSync2(sourceDir, targetPath, {
@@ -438819,7 +438900,7 @@ async function deleteSkillDirectory(params) {
   if (!statSync21(targetPath).isDirectory()) {
     throw new Error(`Skill path is not a directory: ${targetPath}`);
   }
-  rmSync15(targetPath, { recursive: true, force: true });
+  rmSync16(targetPath, { recursive: true, force: true });
   return { name, path: normalize5(targetPath) };
 }
 async function loadSkillMemorySyncFn() {
@@ -438883,7 +438964,7 @@ async function installSkill(specifier, agentId, force) {
     };
   } finally {
     if (tmpDir)
-      rmSync15(tmpDir, { recursive: true, force: true });
+      rmSync16(tmpDir, { recursive: true, force: true });
   }
 }
 async function getAgentMemoryDir(agentId) {
@@ -439192,19 +439273,19 @@ Usage:
   letta teleport list
   letta teleport cloud
   letta teleport local
-  letta teleport <environment>
+  letta teleport <computer>
 
 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 an active conversation.
-  - list: prints accessible online remote environments as JSON.
+  - list: prints accessible online remote computers as JSON.
   - cloud: teleports to the agent's Cloud sandbox.
-  - local: teleports to the one online Desktop environment. Desktop Remote
+  - local: teleports to the one online Desktop computer. Desktop Remote
     Access must be enabled; if several are online, choose one explicitly.
-  - <environment>: teleports to a specific remote environment by name,
-    device-id, connection-id, or environment id.
+  - <computer>: teleports to a specific remote computer by name,
+    device-id, connection-id, or computer id.
   - Output is JSON only.
 `.trim());
 }
@@ -439269,7 +439350,7 @@ function isTeleportableRemoteEnvironment(environment2) {
 }
 function assertTeleportableRemoteEnvironment(environment2) {
   if (!isTeleportableRemoteEnvironment(environment2)) {
-    throw new Error("The Desktop-local connection is not Cloud-routable. Use `letta teleport local` to resolve its Remote Access environment.");
+    throw new Error("The Desktop-local connection is not Cloud-routable. Use `letta teleport local` to resolve its Remote Access computer.");
   }
 }
 async function initializeTeleportSettings() {
@@ -439312,7 +439393,7 @@ async function runTeleportSubcommand(argv, deps = {}) {
       const result3 = await resolve38();
       targetConnectionId = result3.connectionId;
     } else if (action3 === "back") {
-      throw new Error("Teleport back is not supported. Use `letta teleport local` or choose an explicit environment.");
+      throw new Error("Teleport back is not supported. Use `letta teleport local` or choose an explicit computer.");
     } else {
       const resolve38 = deps.resolveEnvironmentConnectionId ?? resolveEnvironmentConnectionId;
       const resolved = await resolve38(action3);
@@ -441276,7 +441357,9 @@ function bindProactiveSlackThreadRoute(params) {
   }
 }
 function createProactiveSlackTransport(params) {
+  const listCustomEmojis = params.adapter.listCustomEmojis?.bind(params.adapter);
   return {
+    ...listCustomEmojis ? { listCustomEmojis } : {},
     sendMessage: async (message) => {
       const result2 = await params.adapter.sendMessage(message);
       const isRootChannelPost = params.target.chatType === "channel" && !message.threadId?.trim() && !message.replyToMessageId?.trim() && !message.reaction;
@@ -443120,6 +443203,7 @@ Replies to routed Slack threads stay in the current thread automatically.` : "";
 Replies to routed Telegram topics stay in the current topic automatically.` : "";
   const slackCapabilities = discovery.activeChannels.includes("slack") ? [
     hasAction("react") ? 'action="react" with emoji + messageId' : "",
+    hasAction("list-custom-emojis") ? 'action="list-custom-emojis" to discover the workspace custom emoji names available for reactions' : "",
     hasAction("upload-file") ? 'action="upload-file" with media' : "",
     hasAction("download-file") ? 'action="download-file" with attachmentId + messageId' : ""
   ].filter(Boolean) : [];
@@ -443249,7 +443333,7 @@ var init_message_channel_gateway_tool = __esm(() => {
 });
 
 // src/channels/custom/scaffolding.ts
-import { existsSync as existsSync63, mkdirSync as mkdirSync42, rmSync as rmSync16, writeFileSync as writeFileSync32 } from "node:fs";
+import { existsSync as existsSync63, mkdirSync as mkdirSync42, rmSync as rmSync17, writeFileSync as writeFileSync32 } from "node:fs";
 function removeUserPlugin(channelId) {
   if (FIRST_PARTY_SET.has(channelId)) {
     return;
@@ -443262,7 +443346,7 @@ function removeUserPlugin(channelId) {
     return;
   }
   try {
-    rmSync16(channelDir, { recursive: true, force: true });
+    rmSync17(channelDir, { recursive: true, force: true });
   } catch (err) {
     console.error(`[channels] Failed to remove plugin folder ${channelDir}:`, err);
   }
@@ -444885,6 +444969,7 @@ function subcommandNeedsEarlyBackendMode(command) {
     case "channel-gateway":
     case "agents":
     case "connect":
+    case "computers":
     case "environments":
     case "envs":
     case "feedback":
@@ -444929,6 +445014,7 @@ async function runSubcommand(argv) {
       return runMessagesSubcommand(rest4);
     case "mcp":
       return runMcpSubcommand(rest4);
+    case "computers":
     case "environments":
     case "envs":
       return runEnvironmentsSubcommand(rest4);
@@ -444983,6 +445069,7 @@ var init_router = __esm(async () => {
   init_environments3();
   init_feedback3();
   init_local_backend2();
+  init_mcp();
   init_memory7();
   init_messages10();
   init_sandbox2();
@@ -444994,13 +445081,57 @@ var init_router = __esm(async () => {
   await __promiseAll([
     init_cron2(),
     init_listen(),
-    init_mcp(),
     init_mods(),
     init_server(),
     init_setup7()
   ]);
 });
 
+// src/utils/version.ts
+function parseSemver(version2) {
+  const match3 = version2.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match3)
+    return null;
+  const [, major, minor, patch2] = match3;
+  return [
+    parseInt(major ?? "0", 10),
+    parseInt(minor ?? "0", 10),
+    parseInt(patch2 ?? "0", 10)
+  ];
+}
+function compareSemver(a2, b3) {
+  const aParts = parseSemver(a2);
+  const bParts = parseSemver(b3);
+  if (!aParts || !bParts)
+    return null;
+  for (let i4 = 0;i4 < 3; i4++) {
+    const a3 = aParts[i4] ?? 0;
+    const b4 = bParts[i4] ?? 0;
+    if (a3 < b4)
+      return -1;
+    if (a3 > b4)
+      return 1;
+  }
+  return 0;
+}
+function isVersionBelow(version2, minimum3) {
+  const result2 = compareSemver(version2, minimum3);
+  return result2 === -1;
+}
+
+// src/runtime-version.ts
+function assertSupportedBunRuntime(bunVersion = process.versions.bun) {
+  if (!bunVersion || !isVersionBelow(bunVersion, MINIMUM_BUN_VERSION)) {
+    return;
+  }
+  throw new Error(`Letta Code cannot run on Bun ${bunVersion}. Bun ${MINIMUM_BUN_VERSION} or newer is required because older versions can stop reading child-process output. Upgrade Bun, or install Letta Code from npm to run it with Node.`);
+}
+var MINIMUM_BUN_VERSION;
+var init_runtime_version = __esm(() => {
+  init_package();
+  MINIMUM_BUN_VERSION = package_default.engines.bun.replace(/^>=/, "");
+});
+
 // src/startup-auto-update.ts
 function startStartupAutoUpdateCheck(checkAndAutoUpdate2, logError = console.error) {
   return checkAndAutoUpdate2().then((result2) => {
@@ -445154,38 +445285,6 @@ var init_kitty_protocol_detector = __esm(() => {
   DISABLED = process.env.LETTA_DISABLE_KITTY === "1";
 });
 
-// src/utils/version.ts
-function parseSemver(version2) {
-  const match3 = version2.match(/^(\d+)\.(\d+)\.(\d+)/);
-  if (!match3)
-    return null;
-  const [, major, minor, patch2] = match3;
-  return [
-    parseInt(major ?? "0", 10),
-    parseInt(minor ?? "0", 10),
-    parseInt(patch2 ?? "0", 10)
-  ];
-}
-function compareSemver(a2, b3) {
-  const aParts = parseSemver(a2);
-  const bParts = parseSemver(b3);
-  if (!aParts || !bParts)
-    return null;
-  for (let i4 = 0;i4 < 3; i4++) {
-    const a3 = aParts[i4] ?? 0;
-    const b4 = bParts[i4] ?? 0;
-    if (a3 < b4)
-      return -1;
-    if (a3 > b4)
-      return 1;
-  }
-  return 0;
-}
-function isVersionBelow(version2, minimum3) {
-  const result2 = compareSemver(version2, minimum3);
-  return result2 === -1;
-}
-
 // src/startup-docker-check.ts
 var exports_startup_docker_check = {};
 __export(exports_startup_docker_check, {
@@ -447156,7 +447255,7 @@ function getEnvironmentRoutedMessagingUnsupportedReason(environment2) {
   if (environment2.metadata?.environmentMessageProtocol === "v2-input") {
     return null;
   }
-  return `Environment ${environment2.connectionName} (${environment2.deviceId}) is running Letta Code ${environment2.metadata?.lettaCodeVersion ?? "unknown"} and does not advertise environment-routed headless messaging support. Update that runtime or omit --environment to use same-environment messaging.`;
+  return `Computer ${environment2.connectionName} (${environment2.deviceId}) is running Letta Code ${environment2.metadata?.lettaCodeVersion ?? "unknown"} and does not advertise computer-routed headless messaging support. Update that runtime or omit --computer to use same-computer messaging.`;
 }
 async function handleHeadlessCommand(parsedArgs, model, skillsDirectoryOverride, skillSourcesOverride, systemInfoReminderEnabledOverride, startupOptions = {}) {
   const { values: values3, positionals } = parsedArgs;
@@ -447229,7 +447328,7 @@ In headless mode, use:
   }
   let forceNewConversation = values3.new ?? false;
   const fromAgentId = values3["from-agent"];
-  const explicitEnvironmentSelector = values3.environment || values3.env;
+  const explicitEnvironmentSelector = values3.computer ?? values3.environment ?? values3.env;
   const usesRemoteEnvironment = typeof explicitEnvironmentSelector === "string" && explicitEnvironmentSelector.trim().length > 0;
   let agent = null;
   let ephemeralConversationId = null;
@@ -447597,9 +447696,6 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   markMilestone("HEADLESS_AGENT_RESOLVED");
   const publicAgentId = ephemeralFlag ? null : agent.id;
   telemetry.setCurrentAgent(publicAgentId, agent.tags);
-  if (!ephemeralFlag) {
-    await replaceClientMcpServers(agent.id, settingsManager.getMcpServers(agent.id), { stderr: "pipe" });
-  }
   const isResumingAgent = !ephemeralFlag && !!(specifiedAgentId || !forceNew && !fromAfFile);
   if (isResumingAgent) {
     if (model) {
@@ -447788,7 +447884,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
     process.exit(1);
   }
   if (usesRemoteEnvironment && isBidirectionalMode) {
-    console.error("Error: remote environment routing cannot be used with --input-format stream-json");
+    console.error("Error: remote computer routing cannot be used with --input-format stream-json");
     process.exit(1);
   }
   const sessionStats = new SessionStats;
@@ -448225,6 +448321,7 @@ ${loadedContents.join(`
   let emptyResponseRetries = 0;
   let conversationBusyRetries = 0;
   let chatgptPlanSwaps = 0;
+  const chatgptExhaustedProviders = new Set;
   markMilestone("HEADLESS_FIRST_STREAM_START");
   measureSinceMilestone("headless-setup-total", "HEADLESS_CLIENT_READY");
   const checkMaxTurns = async () => {
@@ -448492,6 +448589,7 @@ ${loadedContents.join(`
         emptyResponseRetries = 0;
         conversationBusyRetries = 0;
         chatgptPlanSwaps = 0;
+        chatgptExhaustedProviders.clear();
         const continueMessage = await emitHeadlessTurnEnd({
           agent,
           conversationId,
@@ -448595,8 +448693,10 @@ ${loadedContents.join(`
       if (chatgptPlanSwaps < CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN) {
         const rotation = await rotateChatGPTPlanOnQuotaLimit({
           agentId: agent.id,
+          conversationId,
           currentHandle: null,
-          error: runErrorInfo2 ?? detailFromRun ?? latestErrorText
+          error: runErrorInfo2 ?? detailFromRun ?? latestErrorText,
+          exhaustedProviders: chatgptExhaustedProviders
         });
         if (rotation) {
           chatgptPlanSwaps += 1;
@@ -450012,6 +450112,7 @@ var init_headless = __esm(async () => {
   init_headless_environment_response();
   init_headless_reflection_settings();
   init_diff_preview();
+  init_mcp_runtime();
   init_format_denial();
   init_startup();
   init_queue_runtime();
@@ -450030,7 +450131,6 @@ var init_headless = __esm(async () => {
     init_headless_ephemeral_startup(),
     init_headless_mod_adapter(),
     init_headless_tool_events(),
-    init_mcp_runtime(),
     init_manager4(),
     init_toolset()
   ]);
@@ -451352,7 +451452,7 @@ import { existsSync as existsSync67 } from "node:fs";
 import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir17, writeFile as writeFile20 } from "node:fs/promises";
 import { homedir as homedir46 } from "node:os";
 import { join as join84 } from "node:path";
-import { promisify as promisify15 } from "node:util";
+import { promisify as promisify16 } from "node:util";
 function buildGitEnv(token2, askpassPath) {
   return {
     ...process.env,
@@ -451375,7 +451475,7 @@ function formatTokenStatus(token2) {
 }
 async function runGit6(cwd2, args, env4) {
   try {
-    await execFile17("git", args, {
+    await execFile18("git", args, {
       cwd: cwd2,
       env: env4,
       encoding: "utf-8",
@@ -451460,11 +451560,11 @@ async function maybeUploadReflectionArenaChoiceToHf(row) {
     };
   }
 }
-var execFile17, HF_REPO_ID = "letta-ai/reflection-arena", HF_REPO_URL, GIT_TIMEOUT_MS2 = 60000, HF_CACHE_ROOT, HF_REPO_DIR, HF_DATASET_PATH = "data/choices.jsonl";
+var execFile18, HF_REPO_ID = "letta-ai/reflection-arena", HF_REPO_URL, GIT_TIMEOUT_MS2 = 60000, HF_CACHE_ROOT, HF_REPO_DIR, HF_DATASET_PATH = "data/choices.jsonl";
 var init_reflection_arena_hf_upload = __esm(() => {
   init_secrets_store();
   init_version();
-  execFile17 = promisify15(execFileCb5);
+  execFile18 = promisify16(execFileCb5);
   HF_REPO_URL = `https://huggingface.co/datasets/${HF_REPO_ID}`;
   HF_CACHE_ROOT = join84(homedir46(), ".letta", "reflection-arena", "hf-upload");
   HF_REPO_DIR = join84(HF_CACHE_ROOT, "repo");
@@ -451476,7 +451576,7 @@ import { randomInt as randomInt2, randomUUID as randomUUID37 } from "node:crypto
 import { appendFile as appendFile3, mkdir as mkdir18, readFile as readFile30, writeFile as writeFile21 } from "node:fs/promises";
 import { homedir as homedir47 } from "node:os";
 import { join as join85 } from "node:path";
-import { promisify as promisify16 } from "node:util";
+import { promisify as promisify17 } from "node:util";
 function sampleReflectionArenaComparisonModel(excludedModels = []) {
   const excluded = new Set(excludedModels);
   const candidates2 = REFLECTION_ARENA_COMPARISON_MODEL_POOL.filter((entry) => !excluded.has(entry.model));
@@ -451493,7 +451593,7 @@ function sampleReflectionArenaComparisonModel(excludedModels = []) {
 }
 async function getGitOutput(cwd2, args) {
   try {
-    const { stdout } = await execFile18("git", args, {
+    const { stdout } = await execFile19("git", args, {
       cwd: cwd2,
       encoding: "utf-8",
       timeout: 30000,
@@ -452068,7 +452168,7 @@ async function finalizeReflectionArenaChoice(options) {
     run: completedRun
   };
 }
-var execFile18, REFLECTION_ARENA_TELEMETRY_TRANSCRIPT_MAX_CHARS = 1e6, REFLECTION_ARENA_MODEL_A_DEFAULT = "letta/auto-memory", REFLECTION_ARENA_COMPARISON_MODEL_POOL, ANSI_BOLD = "\x1B[1m", ANSI_CYAN = "\x1B[36m", ANSI_MAGENTA = "\x1B[35m", ANSI_RESET_BOLD = "\x1B[22m", ANSI_RESET_FOREGROUND = "\x1B[39m", REFLECTION_ARENA_CANDIDATE_COUNT = 2, REFLECTION_ARENA_CHOICE_QUESTION = "Which reflection should be merged?", REFLECTION_ARENA_NOTES_QUESTION = "Optional feedback for this choice?", updateLocks;
+var execFile19, REFLECTION_ARENA_TELEMETRY_TRANSCRIPT_MAX_CHARS = 1e6, REFLECTION_ARENA_MODEL_A_DEFAULT = "letta/auto-memory", REFLECTION_ARENA_COMPARISON_MODEL_POOL, ANSI_BOLD = "\x1B[1m", ANSI_CYAN = "\x1B[36m", ANSI_MAGENTA = "\x1B[35m", ANSI_RESET_BOLD = "\x1B[22m", ANSI_RESET_FOREGROUND = "\x1B[39m", REFLECTION_ARENA_CANDIDATE_COUNT = 2, REFLECTION_ARENA_CHOICE_QUESTION = "Which reflection should be merged?", REFLECTION_ARENA_NOTES_QUESTION = "Optional feedback for this choice?", updateLocks;
 var init_reflection_arena = __esm(() => {
   init_memory_filesystem2();
   init_memory_worktree();
@@ -452080,7 +452180,7 @@ var init_reflection_arena = __esm(() => {
   init_reflection_transcript();
   init_telemetry();
   init_debug();
-  execFile18 = promisify16(execFileCb6);
+  execFile19 = promisify17(execFileCb6);
   REFLECTION_ARENA_COMPARISON_MODEL_POOL = [
     { model: "lc-anthropic/claude-sonnet-5", weight: 1 },
     { model: "lc-anthropic/claude-opus-4-8", weight: 3 },
@@ -453312,6 +453412,14 @@ var init_registry2 = __esm(() => {
         return "Clearing in-context messages...";
       }
     },
+    "/clear-messages": {
+      desc: "Reset all agent messages (destructive)",
+      hidden: true,
+      noArgs: true,
+      handler: () => {
+        return "Resetting agent messages...";
+      }
+    },
     "/chdir": {
       desc: "Change working directory for this TUI session (/chdir <path>)",
       args: "<path>",
@@ -464470,7 +464578,7 @@ import {
   mkdirSync as mkdirSync46,
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync44,
-  rmSync as rmSync17,
+  rmSync as rmSync18,
   writeFileSync as writeFileSync36
 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
@@ -464840,7 +464948,7 @@ async function installGithubApp(options) {
       agentUrl: resolvedAgentId ? buildAgentReference(resolvedAgentId) : null
     };
   } finally {
-    rmSync17(tempDir, { recursive: true, force: true });
+    rmSync18(tempDir, { recursive: true, force: true });
   }
 }
 var DEFAULT_WORKFLOW_PATH = ".github/workflows/letta.yml", ALTERNATE_WORKFLOW_PATH = ".github/workflows/letta-code.yml";
@@ -465913,11 +466021,11 @@ var init_McpSelector = __esm(async () => {
   init_truncate_text();
   init_use_terminal_width();
   init_mcp_oauth();
+  init_mcp_runtime();
   init_settings_manager();
   init_colors();
   await __promiseAll([
     init_build4(),
-    init_mcp_runtime(),
     init_Text2()
   ]);
   import_react87 = __toESM(require_react(), 1);
@@ -466219,7 +466327,7 @@ var init_McpSelector = __esm(async () => {
             flexDirection: "column",
             children: [
               /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Text2, {
-                children: tool.label ?? tool.name
+                children: tool.title ?? tool.name
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Text2, {
                 dimColor: true,
@@ -466229,7 +466337,7 @@ var init_McpSelector = __esm(async () => {
                 ]
               }, undefined, true, undefined, this)
             ]
-          }, tool.registrationKey ?? tool.name, true, undefined, this)),
+          }, tool.name, true, undefined, this)),
           /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Box_default, {
             marginTop: 1,
             children: /* @__PURE__ */ jsx_dev_runtime64.jsxDEV(Text2, {
@@ -468606,7 +468714,7 @@ import { execFile as execFileCb7 } from "node:child_process";
 import { chmodSync as chmodSync7, existsSync as existsSync70, mkdirSync as mkdirSync47, writeFileSync as writeFileSync37 } from "node:fs";
 import { homedir as homedir51 } from "node:os";
 import { join as join89 } from "node:path";
-import { promisify as promisify17 } from "node:util";
+import { promisify as promisify18 } from "node:util";
 function messagesFromOverview(overview) {
   return overview.messages?.map((message) => ({
     id: message.id,
@@ -468633,7 +468741,7 @@ function contextFromOverview(overview, model, contextWindow) {
 }
 async function runGitSafe(cwd2, args) {
   try {
-    const { stdout } = await execFile19("git", args, {
+    const { stdout } = await execFile20("git", args, {
       cwd: cwd2,
       maxBuffer: 10 * 1024 * 1024,
       timeout: 60000
@@ -468944,7 +469052,7 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   }
   return { filePath, opened: !skipOpen };
 }
-var execFile19, VIEWERS_DIR, MAX_COMMITS = 500, RECENT_DIFF_COUNT = 50, PER_DIFF_CAP = 1e5, TOTAL_PAYLOAD_CAP = 5000000, RECORD_SEP = "\x1E", REFLECTION_PATTERN;
+var execFile20, VIEWERS_DIR, MAX_COMMITS = 500, RECENT_DIFF_COUNT = 50, PER_DIFF_CAP = 1e5, TOTAL_PAYLOAD_CAP = 5000000, RECORD_SEP = "\x1E", REFLECTION_PATTERN;
 var init_generate_memory_viewer = __esm(() => {
   init_memory_filesystem2();
   init_memory_scanner();
@@ -468955,7 +469063,7 @@ var init_generate_memory_viewer = __esm(() => {
   init_context_usage();
   init_local_memory_context();
   init_memory_viewer_template();
-  execFile19 = promisify17(execFileCb7);
+  execFile20 = promisify18(execFileCb7);
   VIEWERS_DIR = join89(homedir51(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
@@ -492375,10 +492483,10 @@ import { execFile as execFileCb8 } from "node:child_process";
 import { chmodSync as chmodSync8, existsSync as existsSync72, mkdirSync as mkdirSync48, writeFileSync as writeFileSync38 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
 import { isAbsolute as isAbsolute30, join as join92, resolve as resolve42 } from "node:path";
-import { promisify as promisify18 } from "node:util";
+import { promisify as promisify19 } from "node:util";
 async function runGit8(cwd2, args) {
   try {
-    const { stdout } = await execFile20("git", args, {
+    const { stdout } = await execFile21("git", args, {
       cwd: cwd2,
       maxBuffer: GIT_MAX_BUFFER,
       timeout: GIT_TIMEOUT_MS3
@@ -492613,7 +492721,7 @@ async function generateAndOpenDiffViewer(targetPath) {
   }
   return { filePath, opened: !skipOpen, fileCount: rendered.files.length };
 }
-var execFile20, VIEWERS_DIR2, GIT_TIMEOUT_MS3 = 60000, GIT_MAX_BUFFER, MAX_RENDERED_FILES = 100, DIFF_UNSAFE_CSS = `
+var execFile21, VIEWERS_DIR2, GIT_TIMEOUT_MS3 = 60000, GIT_MAX_BUFFER, MAX_RENDERED_FILES = 100, DIFF_UNSAFE_CSS = `
 :host {
   --diffs-addition-color-override: #15803d;
   --diffs-deletion-color-override: #b91c1c;
@@ -492669,7 +492777,7 @@ var init_generate_diff_viewer = __esm(() => {
   init_dist15();
   init_ssr();
   init_diff_viewer_template();
-  execFile20 = promisify18(execFileCb8);
+  execFile21 = promisify19(execFileCb8);
   VIEWERS_DIR2 = join92(homedir53(), ".letta", "viewers");
   GIT_MAX_BUFFER = 50 * 1024 * 1024;
 });
@@ -493860,20 +493968,20 @@ var init_session3 = __esm(() => {
 });
 
 // src/cli/app/use-agent-mcp-servers.ts
-function useAgentMcpServers(agentId) {
+function useMcpCleanup(agentId) {
+  const previousAgentId = import_react110.useRef(agentId);
   import_react110.useEffect(() => {
-    const refresh = agentId ? replaceClientMcpServers(agentId, settingsManager.getMcpServers(agentId)) : closeClientMcpServers();
-    refresh.catch((error5) => debugWarn("mcp", `Failed to switch agent MCP servers: ${String(error5)}`));
+    if (previousAgentId.current === agentId)
+      return;
+    previousAgentId.current = agentId;
+    closeClientMcpServers().catch((error5) => debugWarn("mcp", `Failed to close client MCP servers: ${String(error5)}`));
   }, [agentId]);
 }
 var import_react110;
-var init_use_agent_mcp_servers = __esm(async () => {
-  init_settings_manager();
+var init_use_agent_mcp_servers = __esm(() => {
+  init_mcp_runtime();
+  init_mcp_runtime();
   init_debug();
-  await __promiseAll([
-    init_mcp_runtime(),
-    init_mcp_runtime()
-  ]);
   import_react110 = __toESM(require_react(), 1);
 });
 
@@ -495059,7 +495167,7 @@ function useConfigurationHandlers(ctx) {
         registryHandle,
         contextWindow: selectedContextWindow,
         reasoningCapabilities
-      }) : getReasoningTierOptionsForHandle2(modelHandle, selectedContextWindow, reasoningCapabilities);
+      }) : getReasoningTierOptionsForHandle2(registryHandle, selectedContextWindow, reasoningCapabilities);
       const reasoningTierOptions = baseReasoningTierOptions.map((option2) => {
         const optionModel = models3.find((entry) => entry.id === option2.modelId);
         const serviceTier = modelUpdateArgs?.service_tier;
@@ -495863,6 +495971,7 @@ function useConversationLoop(ctx) {
     clearApprovalToolContext,
     closeTrajectorySegment,
     chatgptPlanSwapsRef,
+    chatgptExhaustedProvidersRef,
     consumeQueuedMessages,
     queueModeRef,
     contextTrackerRef,
@@ -496095,6 +496204,7 @@ function useConversationLoop(ctx) {
       conversationBusyRetriesRef.current = 0;
       quotaAutoSwapAttemptedRef.current = false;
       chatgptPlanSwapsRef.current = 0;
+      chatgptExhaustedProvidersRef.current.clear();
     }
     let currentRunId;
     let preserveTranscriptStartForApproval = false;
@@ -497062,8 +497172,10 @@ ${feedback}
         if (chatgptPlanSwapsRef.current < CHATGPT_PLAN_ROTATION_MAX_SWAPS_PER_TURN) {
           const rotation = await rotateChatGPTPlanOnQuotaLimit({
             agentId: agentIdRef.current,
+            conversationId: conversationIdRef.current,
             currentHandle: currentModelId,
-            error: runErrorInfo2 ?? detailFromRun ?? fallbackError
+            error: runErrorInfo2 ?? detailFromRun ?? fallbackError,
+            exhaustedProviders: chatgptExhaustedProvidersRef.current
           });
           if (rotation) {
             chatgptPlanSwapsRef.current += 1;
@@ -501399,10 +501511,10 @@ function mcpHelpText() {
 `);
 }
 var activeCommandId2 = null;
-var init_mcp2 = __esm(async () => {
+var init_mcp2 = __esm(() => {
   init_error_formatter();
+  init_mcp_runtime();
   init_settings_manager();
-  await init_mcp_runtime();
 });
 
 // src/cli/commands/listen.ts
@@ -501465,24 +501577,24 @@ Listener disconnected from Letta Cloud.`, true);
     return;
   }
   if (msg.includes("--help") || msg.includes("-h")) {
-    addCommandResult3(ctx.buffersRef, ctx.refreshDerived, msg, `Usage: /server [--env-name <name>]
+    addCommandResult3(ctx.buffersRef, ctx.refreshDerived, msg, `Usage: /server [--computer-name <name>]
        /server off
 
-Register this letta-code instance to receive messages from Letta Cloud.
+Register this computer to receive messages from Letta Cloud.
 Alias: /remote
 
 Options:
-  --env-name <name>  Friendly name for this environment (uses hostname if not provided)
+  --computer-name <name>  Friendly name for this computer (uses hostname if not provided)
   off                Stop the active listener connection
   -h, --help         Show this help message
 
 Examples:
   /server                         # Start listener with hostname
-  /server --env-name "work-laptop" # Start with custom name
+  /server --computer-name "work-laptop" # Start with custom name
   /server off                     # Stop listening
 
 Once connected, this instance will listen for incoming messages from cloud agents.
-Messages will be executed locally using your letta-code environment.`, true);
+Messages will be executed locally on this computer.`, true);
     return;
   }
   let connectionName;
@@ -501532,7 +501644,7 @@ Retry ${attempt2} in ${Math.round(delayMs / 1000)}s: ${error5.message}`, true, "
     updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `✓ Registered successfully!
 
 ` + `Connection ID: ${connectionId}
-Environment: "${connectionName}"
+Computer: "${connectionName}"
 WebSocket: ${wsUrl}
 
 Starting WebSocket connection...`, true, "running");
@@ -501550,18 +501662,18 @@ Starting WebSocket connection...`, true, "running");
           const url2 = buildConnectionUrl(id2);
           const urlText = url2 ? `
 
-Connect to this environment:
+Connect to this computer:
 ${url2}` : "";
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment initialized: ${connectionName}
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer initialized: ${connectionName}
 ${statusText}${urlText}`, true, "finished");
         },
         onRetrying: (attempt2, _maxAttempts, nextRetryIn, id2) => {
           const url2 = buildConnectionUrl(id2);
           const urlText = url2 ? `
 
-Connect to this environment:
+Connect to this computer:
 ${url2}` : "";
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment initialized: ${connectionName}
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer initialized: ${connectionName}
 Reconnecting to Letta Cloud...
 Attempt ${attempt2}, retrying in ${Math.round(nextRetryIn / 1000)}s${urlText}`, true, "running");
         },
@@ -501569,14 +501681,14 @@ Attempt ${attempt2}, retrying in ${Math.round(nextRetryIn / 1000)}s${urlText}`,
           const url2 = buildConnectionUrl(id2);
           const urlText = url2 ? `
 
-Connect to this environment:
+Connect to this computer:
 ${url2}` : "";
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment initialized: ${connectionName}
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer initialized: ${connectionName}
 Awaiting instructions${urlText}`, true, "finished");
           ctx.setCommandRunning(false);
         },
         onNeedsReregister: async () => {
-          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Environment expired, re-registering "${connectionName}"...`, true, "running");
+          updateCommandResult3(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Computer connection expired, re-registering "${connectionName}"...`, true, "running");
           try {
             const nextRegisterOptions = await resolveRegisterOptions();
             const reregisterResult = await registerWithCloudRetry(nextRegisterOptions, {
@@ -501702,7 +501814,7 @@ async function handleConnectionCommand(msg, trimmed, ctx) {
     for (let i4 = 1;i4 < parts.length; i4++) {
       const part = parts[i4];
       const nextPart = parts[i4 + 1];
-      if (part === "--env-name" && nextPart) {
+      if ((part === "--computer-name" || part === "--env-name") && nextPart) {
         name = nextPart;
         i4++;
       }
@@ -501725,8 +501837,8 @@ async function handleConnectionCommand(msg, trimmed, ctx) {
   }
   return null;
 }
-var init_submit_connection_commands = __esm(async () => {
-  await init_mcp2();
+var init_submit_connection_commands = __esm(() => {
+  init_mcp2();
 });
 
 // src/cli/helpers/context-chart.ts
@@ -502652,10 +502764,10 @@ __export(exports_worktree_diff_list, {
 });
 import { execFile as execFileCb9 } from "node:child_process";
 import { basename as basename31 } from "node:path";
-import { promisify as promisify19 } from "node:util";
+import { promisify as promisify20 } from "node:util";
 async function runGit9(cwd2, args) {
   try {
-    const { stdout } = await execFile21("git", args, {
+    const { stdout } = await execFile22("git", args, {
       cwd: cwd2,
       maxBuffer: GIT_MAX_BUFFER2,
       timeout: GIT_TIMEOUT_MS4
@@ -502784,9 +502896,9 @@ async function listWorktreeDiffOptions(cwd2 = process.cwd()) {
   const worktrees = parseWorktreeList(output, currentPath);
   return Promise.all(worktrees.map((worktree) => summarizeWorktree(worktree)));
 }
-var execFile21, GIT_TIMEOUT_MS4 = 60000, GIT_MAX_BUFFER2;
+var execFile22, GIT_TIMEOUT_MS4 = 60000, GIT_MAX_BUFFER2;
 var init_worktree_diff_list = __esm(() => {
-  execFile21 = promisify19(execFileCb9);
+  execFile22 = promisify20(execFileCb9);
   GIT_MAX_BUFFER2 = 10 * 1024 * 1024;
 });
 
@@ -504064,15 +504176,19 @@ Tip: Use /clear instead to clear the current message buffer.`;
         });
         return { submitted: true };
       }
-      if (msg.trim() === "/clear") {
-        const cmd = commandRunner.start(msg.trim(), "Clearing in-context messages...");
+      const resetAllAgentMessages = trimmed === "/clear-messages";
+      if (trimmed === "/clear" || resetAllAgentMessages) {
+        const cmd = commandRunner.start(trimmed, resetAllAgentMessages ? "Resetting agent messages..." : "Clearing in-context messages...");
         resetPendingReasoningCycle();
         setCommandRunning(true);
         const clearPrevConversationId = conversationIdRef.current;
-        await runEndHooks("new");
         try {
           const backend3 = getBackend();
-          if (conversationIdRef.current === "default" && !backend3.capabilities.localModelCatalog) {
+          if (resetAllAgentMessages && backend3.capabilities.localModelCatalog) {
+            throw new Error("/clear-messages is unsupported by local backend.");
+          }
+          await runEndHooks("new");
+          if (!backend3.capabilities.localModelCatalog && (resetAllAgentMessages || conversationIdRef.current === "default")) {
             const client = await getClient();
             await client.agents.messages.reset(agentId, {
               add_default_initial_messages: false
@@ -504106,7 +504222,7 @@ Tip: Use /clear instead to clear the current message buffer.`;
             previousConversationId: clearPrevConversationId ?? null,
             reason: "new"
           }, modAdapter.context);
-          cmd.finish("Agent's in-context messages cleared & moved to conversation history", true);
+          cmd.finish(resetAllAgentMessages ? "All agent messages reset" : "Agent's in-context messages cleared & moved to conversation history", true);
         } catch (error5) {
           const errorDetails = formatErrorDetails2(error5, agentId);
           cmd.fail(`Failed: ${errorDetails}`);
@@ -505508,6 +505624,7 @@ var init_use_submit_handler = __esm(async () => {
   init_command_routing();
   init_ids();
   init_session3();
+  init_submit_connection_commands();
   init_submit_diagnostics_commands();
   init_submit_profile_commands();
   await __promiseAll([
@@ -505515,7 +505632,6 @@ var init_use_submit_handler = __esm(async () => {
     init_mods2(),
     init_PinDialog(),
     init_accumulator(),
-    init_submit_connection_commands(),
     init_submit_navigation_commands()
   ]);
   import_react120 = __toESM(require_react(), 1);
@@ -506211,6 +506327,7 @@ function App2({
   const quotaAutoSwapAttemptedRef = import_react121.useRef(false);
   const emptyResponseRetriesRef = import_react121.useRef(0);
   const chatgptPlanSwapsRef = import_react121.useRef(0);
+  const chatgptExhaustedProvidersRef = import_react121.useRef(new Set);
   const conversationBusyRetriesRef = import_react121.useRef(0);
   const [queueDisplay, setQueueDisplay] = import_react121.useState([]);
   const tuiQueueRef = import_react121.useRef(null);
@@ -506867,7 +506984,7 @@ function App2({
   import_react121.useEffect(() => {
     buffersRef.current.agentId = agentState?.id;
   }, [agentState?.id]);
-  useAgentMcpServers(agentState?.id);
+  useMcpCleanup(agentState?.id);
   const precomputedDiffsRef = import_react121.useRef(new Map);
   const eagerCommittedPreviewsRef = import_react121.useRef(new Set);
   const estimateApprovalPreviewLines = import_react121.useCallback((approval) => {
@@ -507700,6 +507817,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     buffersRef,
     clearApprovalToolContext,
     chatgptPlanSwapsRef,
+    chatgptExhaustedProvidersRef,
     closeTrajectorySegment,
     consumeQueuedMessages,
     queueModeRef,
@@ -508861,6 +508979,7 @@ var init_AppCoordinator = __esm(async () => {
   init_ids();
   init_model_config();
   init_session3();
+  init_use_agent_mcp_servers();
   init_use_feedback_handler();
   init_use_queued_approval_submit();
   init_use_reasoning_cycle();
@@ -508876,7 +508995,6 @@ var init_AppCoordinator = __esm(async () => {
     init_manager4(),
     init_toolset(),
     init_AppView(),
-    init_use_agent_mcp_servers(),
     init_use_approval_flow(),
     init_use_bash_handlers(),
     init_use_configuration_handlers(),
@@ -509093,13 +509211,13 @@ USAGE
   letta update          Check for updates and install (aliases: upgrade, --update, --upgrade)
   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 computers ...   List available remote computers (JSON-only)
+  letta teleport ...    Move the current conversation between computers
   letta messages ...    Messages subcommands (JSON-only)
   letta mcp ...         List, search, and call MCP servers available to an agent
   letta mods ...        List and manage local mods
   letta sandbox ...     Transfer files to or from the current Cloud sandbox
-  letta server ...      Run a remote environment, channels, or the App Server
+  letta server ...      Run a remote computer, channels, or the App Server
   letta connect ...     Connect providers from terminal
   letta backend ...     Show or set the default backend
   letta setup           Re-run first-run setup
@@ -509118,9 +509236,9 @@ SUBCOMMANDS
   letta memory pull --agent <id>
   letta memory tokens [--memory-dir <path>] [--agent <id>] [--format text|json]
   letta agents list [--query <text> | --name <name> | --tags <tags>]
-  letta environments list [--online-only]
-  letta environments current
-  letta teleport list|cloud|local|<environment>
+  letta computers list [--online-only]
+  letta computers current
+  letta teleport list|cloud|local|<computer>
   letta messages search --query <text> [--all-agents]
   letta messages list [--agent <id>]
   letta messages transcript --conversation <id> [--out <path>]
@@ -509130,7 +509248,7 @@ SUBCOMMANDS
   letta mods disable <package-spec>
   letta mods remove <package-spec>
   letta mcp list|get|tools|search|call ... [--agent <id>]
-  letta server [--env-name <name> | --listen [url]] [options]
+  letta server [--computer-name <name> | --listen [url]] [options]
   letta connect <provider> [options]
   letta install <thing> [--agent <id> | -n <name>]
   letta skills list [--agent <id> | -n <name>]
@@ -509891,7 +510009,7 @@ Error: ${message}`);
   markMilestone("REACT_IMPORT_DONE");
   await terminalPreflightPromise;
   markMilestone("TERMINAL_PREFLIGHT_DONE");
-  const { useState: useState56, useEffect: useEffect50, useRef: useRef20 } = React14;
+  const { useState: useState56, useEffect: useEffect50, useRef: useRef21 } = React14;
   const App3 = AppModule.App;
   function LoadingApp({
     forceNew: forceNew2,
@@ -509915,7 +510033,7 @@ Error: ${message}`);
     const [resumedExistingConversation, setResumedExistingConversation] = useState56(false);
     const [agentProvenance, setAgentProvenance] = useState56(null);
     const [selectedGlobalAgentId, setSelectedGlobalAgentId] = useState56(null);
-    const startupCreatedAgentRef = useRef20(null);
+    const startupCreatedAgentRef = useRef21(null);
     const [startupHasCloudCredentials, setStartupHasCloudCredentials] = useState56(Boolean(settings3.refreshToken || apiKey));
     const [fileAutocompleteFdPath, setFileAutocompleteFdPath] = useState56(() => resolveFdPath());
     const [startupHasAvailableLocalModels, setStartupHasAvailableLocalModels] = useState56(true);
@@ -510740,6 +510858,7 @@ var init_src5 = __esm(async () => {
   init_terminal_theme();
   init_startup_backend_mode();
   init_startup();
+  init_runtime_version();
   init_settings_manager();
   init_startup_auto_update();
   init_debug();
@@ -510753,6 +510872,7 @@ var init_src5 = __esm(async () => {
   ]);
   EMPTY_APPROVAL_ARRAY = [];
   EMPTY_MESSAGE_ARRAY = [];
+  assertSupportedBunRuntime();
   main2();
 });
 // node_modules/@earendil-works/pi-ai/dist/auth/oauth/oauth-page.js
@@ -512950,4 +513070,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=A04282B12C1CC94F64756E2164756E21
+//# debugId=67341FA9FF6344CE64756E2164756E21