@letta-ai/letta-code 0.19.3 → 0.19.5

package/dist/types/protocol.d.ts

@@ -312,7 +312,7 @@ export interface QueueBatchDequeuedEvent extends MessageEnvelope {
 }
 /**
  * Why the queue cannot dequeue right now.
- * - streaming: Agent turn is actively streaming
+ * - streaming: Agent turn is actively running/streaming (request, response, or local tool execution)
  * - pending_approvals: Waiting for HITL approval decisions
  * - overlay_open: Plan mode, AskUserQuestion, or other overlay is active
  * - command_running: Slash command is executing

package/letta.js

@@ -3240,7 +3240,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.19.3",
+    version: "0.19.5",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3308,12 +3308,12 @@ var init_package = __esm(() => {
       fix: "bunx --bun @biomejs/biome@2.2.5 check --write src",
       typecheck: "tsc --noEmit",
       check: "bun run scripts/check.js",
-      dev: "LETTA_DEBUG=1 bun --loader:.md=text --loader:.mdx=text --loader:.txt=text run src/index.ts",
+      dev: "LETTA_DEBUG=${LETTA_DEBUG:-1} bun --loader:.md=text --loader:.mdx=text --loader:.txt=text run src/index.ts",
       build: "node scripts/postinstall-patches.js && bun run build.js",
       "test:update-chain:manual": "bun run src/tests/update-chain-smoke.ts --mode manual",
       "test:update-chain:startup": "bun run src/tests/update-chain-smoke.ts --mode startup",
       prepublishOnly: "bun run build",
-      postinstall: "node scripts/postinstall-patches.js || echo letta: vendor patches skipped"
+      postinstall: `node scripts/postinstall-patches.js || echo letta: vendor patches skipped && node -e "try{require('fs').chmodSync(require('path').join(require.resolve('node-pty/package.json'),'../prebuilds/darwin-arm64/spawn-helper'),0o755)}catch(e){}" || true`
     },
     "lint-staged": {
       "*.{ts,tsx,js,jsx,json}": [
@@ -4858,7 +4858,7 @@ var init_memory_check_reminder = () => {};
 var memory_filesystem_default = `---
 label: memory_filesystem
 description: Filesystem view of memory blocks (system + user)
-limit: 20000
+limit: 8000
 ---
 
 /memory/
@@ -44712,6 +44712,56 @@ var init_process_manager = __esm(() => {
   backgroundTasks = new Map;
 });
 
+// src/utils/directoryLimits.ts
+function parsePositiveIntEnv(value, fallback, min, max) {
+  if (!value || value.trim() === "") {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value.trim(), 10);
+  if (Number.isNaN(parsed)) {
+    return fallback;
+  }
+  if (parsed < min || parsed > max) {
+    return fallback;
+  }
+  return parsed;
+}
+function getDirectoryLimits(env3 = process.env) {
+  return {
+    memfsTreeMaxLines: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.memfsTreeMaxLines], DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxLines, 2, 50000),
+    memfsTreeMaxChars: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.memfsTreeMaxChars], DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChars, 128, 5000000),
+    memfsTreeMaxChildrenPerDir: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.memfsTreeMaxChildrenPerDir], DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChildrenPerDir, 1, 5000),
+    listDirMaxLimit: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.listDirMaxLimit], DIRECTORY_LIMIT_DEFAULTS.listDirMaxLimit, 1, 1e4),
+    listDirMaxDepth: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.listDirMaxDepth], DIRECTORY_LIMIT_DEFAULTS.listDirMaxDepth, 1, 100),
+    listDirMaxOffset: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.listDirMaxOffset], DIRECTORY_LIMIT_DEFAULTS.listDirMaxOffset, 1, 1e6),
+    listDirMaxCollectedEntries: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.listDirMaxCollectedEntries], DIRECTORY_LIMIT_DEFAULTS.listDirMaxCollectedEntries, 10, 2000000),
+    listDirMaxChildrenPerDir: parsePositiveIntEnv(env3[DIRECTORY_LIMIT_ENV.listDirMaxChildrenPerDir], DIRECTORY_LIMIT_DEFAULTS.listDirMaxChildrenPerDir, 1, 5000)
+  };
+}
+var DIRECTORY_LIMIT_ENV, DIRECTORY_LIMIT_DEFAULTS;
+var init_directoryLimits = __esm(() => {
+  DIRECTORY_LIMIT_ENV = {
+    memfsTreeMaxLines: "LETTA_MEMFS_TREE_MAX_LINES",
+    memfsTreeMaxChars: "LETTA_MEMFS_TREE_MAX_CHARS",
+    memfsTreeMaxChildrenPerDir: "LETTA_MEMFS_TREE_MAX_CHILDREN_PER_DIR",
+    listDirMaxLimit: "LETTA_LIST_DIR_MAX_LIMIT",
+    listDirMaxDepth: "LETTA_LIST_DIR_MAX_DEPTH",
+    listDirMaxOffset: "LETTA_LIST_DIR_MAX_OFFSET",
+    listDirMaxCollectedEntries: "LETTA_LIST_DIR_MAX_COLLECTED_ENTRIES",
+    listDirMaxChildrenPerDir: "LETTA_LIST_DIR_MAX_CHILDREN_PER_DIR"
+  };
+  DIRECTORY_LIMIT_DEFAULTS = {
+    memfsTreeMaxLines: 500,
+    memfsTreeMaxChars: 20000,
+    memfsTreeMaxChildrenPerDir: 50,
+    listDirMaxLimit: 200,
+    listDirMaxDepth: 5,
+    listDirMaxOffset: 1e4,
+    listDirMaxCollectedEntries: 12000,
+    listDirMaxChildrenPerDir: 50
+  };
+});
+
 // src/agent/memoryGit.ts
 var exports_memoryGit = {};
 __export(exports_memoryGit, {
@@ -45563,6 +45613,9 @@ __export(exports_memoryFilesystem, {
   ensureMemoryFilesystemDirs: () => ensureMemoryFilesystemDirs,
   enableMemfsIfCloud: () => enableMemfsIfCloud,
   applyMemfsFlags: () => applyMemfsFlags,
+  MEMORY_TREE_MAX_LINES: () => MEMORY_TREE_MAX_LINES,
+  MEMORY_TREE_MAX_CHILDREN_PER_DIR: () => MEMORY_TREE_MAX_CHILDREN_PER_DIR,
+  MEMORY_TREE_MAX_CHARS: () => MEMORY_TREE_MAX_CHARS,
   MEMORY_SYSTEM_DIR: () => MEMORY_SYSTEM_DIR,
   MEMORY_FS_ROOT: () => MEMORY_FS_ROOT,
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR,
@@ -45591,7 +45644,7 @@ function labelFromRelativePath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   return normalized.replace(/\.md$/, "");
 }
-function renderMemoryFilesystemTree(systemLabels, detachedLabels) {
+function renderMemoryFilesystemTree(systemLabels, detachedLabels, options = {}) {
   const makeNode = () => ({ children: new Map, isFile: false });
   const root = makeNode();
   const insertPath = (base2, label) => {
@@ -45626,20 +45679,75 @@ function renderMemoryFilesystemTree(systemLabels, detachedLabels) {
       return nameA.localeCompare(nameB);
     });
   };
-  const lines = ["/memory/"];
+  const limits = getDirectoryLimits();
+  const maxLines = Math.max(2, options.maxLines ?? limits.memfsTreeMaxLines);
+  const maxChars = Math.max(128, options.maxChars ?? limits.memfsTreeMaxChars);
+  const maxChildrenPerDir = Math.max(1, options.maxChildrenPerDir ?? limits.memfsTreeMaxChildrenPerDir);
+  const rootLine = "/memory/";
+  const lines = [rootLine];
+  let totalChars = rootLine.length;
+  const countTreeEntries = (node) => {
+    let total = 0;
+    for (const [, child] of node.children) {
+      total += 1;
+      if (child.children.size > 0) {
+        total += countTreeEntries(child);
+      }
+    }
+    return total;
+  };
+  const canAppendLine = (line) => {
+    const nextLineCount = lines.length + 1;
+    const nextCharCount = totalChars + 1 + line.length;
+    return nextLineCount <= maxLines && nextCharCount <= maxChars;
+  };
   const render2 = (node, prefix) => {
     const entries = sortedEntries(node);
-    entries.forEach(([name, child], index) => {
-      const isLast = index === entries.length - 1;
+    const visibleEntries = entries.slice(0, maxChildrenPerDir);
+    const omittedEntries = Math.max(0, entries.length - visibleEntries.length);
+    const renderItems = visibleEntries.map(([name, child]) => ({
+      kind: "entry",
+      name,
+      child
+    }));
+    if (omittedEntries > 0) {
+      renderItems.push({ kind: "omitted", omittedCount: omittedEntries });
+    }
+    for (const [index, item] of renderItems.entries()) {
+      const isLast = index === renderItems.length - 1;
       const branch = isLast ? "└──" : "├──";
-      lines.push(`${prefix}${branch} ${name}${child.isFile ? "" : "/"}`);
-      if (child.children.size > 0) {
+      const line = item.kind === "entry" ? `${prefix}${branch} ${item.name}${item.child.isFile ? "" : "/"}` : `${prefix}${branch} … (${item.omittedCount.toLocaleString()} more entries)`;
+      if (!canAppendLine(line)) {
+        return false;
+      }
+      lines.push(line);
+      totalChars += 1 + line.length;
+      if (item.kind === "entry" && item.child.children.size > 0) {
         const nextPrefix = `${prefix}${isLast ? "    " : "│   "}`;
-        render2(child, nextPrefix);
+        if (!render2(item.child, nextPrefix)) {
+          return false;
+        }
       }
-    });
+    }
+    return true;
   };
-  render2(root, "");
+  const totalEntries = countTreeEntries(root);
+  const fullyRendered = render2(root, "");
+  if (!fullyRendered) {
+    while (lines.length > 1) {
+      const shownEntries = Math.max(0, lines.length - 1);
+      const omittedEntries = Math.max(1, totalEntries - shownEntries);
+      const notice = `[Tree truncated: showing ${shownEntries.toLocaleString()} of ${totalEntries.toLocaleString()} entries. ${omittedEntries.toLocaleString()} omitted.]`;
+      if (canAppendLine(notice)) {
+        lines.push(notice);
+        break;
+      }
+      const removed = lines.pop();
+      if (removed) {
+        totalChars -= 1 + removed.length;
+      }
+    }
+  }
   return lines.join(`
 `);
 }
@@ -45721,8 +45829,13 @@ async function enableMemfsIfCloud(agentId) {
     console.warn(`Warning: Could not enable memfs for new agent: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-var MEMORY_FS_ROOT = ".letta", MEMORY_FS_AGENTS_DIR = "agents", MEMORY_FS_MEMORY_DIR = "memory", MEMORY_SYSTEM_DIR = "system";
-var init_memoryFilesystem = () => {};
+var MEMORY_FS_ROOT = ".letta", MEMORY_FS_AGENTS_DIR = "agents", MEMORY_FS_MEMORY_DIR = "memory", MEMORY_SYSTEM_DIR = "system", MEMORY_TREE_MAX_LINES, MEMORY_TREE_MAX_CHARS, MEMORY_TREE_MAX_CHILDREN_PER_DIR;
+var init_memoryFilesystem = __esm(() => {
+  init_directoryLimits();
+  MEMORY_TREE_MAX_LINES = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxLines;
+  MEMORY_TREE_MAX_CHARS = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChars;
+  MEMORY_TREE_MAX_CHILDREN_PER_DIR = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChildrenPerDir;
+});
 
 // src/tools/impl/shellEnv.ts
 var exports_shellEnv = {};
@@ -47153,32 +47266,47 @@ import { promises as fs10 } from "node:fs";
 import * as path10 from "node:path";
 async function list_dir(args) {
   validateRequiredParams(args, ["dir_path"], "list_dir");
-  const { dir_path, offset = 1, limit: limit2 = 25, depth = 2 } = args;
+  const limits = getDirectoryLimits();
+  const {
+    dir_path,
+    offset = DEFAULT_OFFSET,
+    limit: limit2 = DEFAULT_LIMIT2,
+    depth = DEFAULT_DEPTH
+  } = args;
   const userCwd = process.env.USER_CWD || process.cwd();
   const resolvedPath = path10.isAbsolute(dir_path) ? dir_path : path10.resolve(userCwd, dir_path);
-  if (offset < 1) {
-    throw new Error("offset must be a 1-indexed entry number");
+  if (!Number.isInteger(offset) || offset < 1) {
+    throw new Error("offset must be a positive integer (1-indexed)");
   }
-  if (limit2 < 1) {
-    throw new Error("limit must be greater than zero");
+  if (offset > limits.listDirMaxOffset) {
+    throw new Error(`offset must be less than or equal to ${limits.listDirMaxOffset.toLocaleString()}`);
+  }
+  if (!Number.isInteger(limit2) || limit2 < 1) {
+    throw new Error("limit must be a positive integer");
   }
-  if (depth < 1) {
-    throw new Error("depth must be greater than zero");
+  if (!Number.isInteger(depth) || depth < 1) {
+    throw new Error("depth must be a positive integer");
   }
-  const entries = await listDirSlice(resolvedPath, offset, limit2, depth);
+  const effectiveLimit = Math.min(limit2, limits.listDirMaxLimit);
+  const effectiveDepth = Math.min(depth, limits.listDirMaxDepth);
+  const entries = await listDirSlice(resolvedPath, offset, effectiveLimit, effectiveDepth, limits.listDirMaxCollectedEntries, limits.listDirMaxChildrenPerDir);
   const output = [`Absolute path: ${resolvedPath}`, ...entries];
+  if (effectiveLimit !== limit2 || effectiveDepth !== depth) {
+    output.push(`[Request capped: limit=${limit2}->${effectiveLimit}, depth=${depth}->${effectiveDepth}]`);
+  }
   return { content: output.join(`
 `) };
 }
-async function listDirSlice(dirPath, offset, limit2, maxDepth) {
+async function listDirSlice(dirPath, offset, limit2, maxDepth, maxCollectedEntries, maxChildrenPerDir) {
   const entries = [];
-  await collectEntries(dirPath, "", maxDepth, entries);
+  const maxEntriesToCollect = Math.min(offset + limit2, maxCollectedEntries);
+  const { hitCollectionCap, hitFolderTruncation } = await collectEntries(dirPath, "", maxDepth, entries, maxEntriesToCollect, maxChildrenPerDir);
   if (entries.length === 0) {
     return [];
   }
   const startIndex = offset - 1;
   if (startIndex >= entries.length) {
-    throw new Error("offset exceeds directory entry count");
+    throw new Error(`offset exceeds available entries in current view (max offset: ${entries.length.toLocaleString()})`);
   }
   const remainingEntries = entries.length - startIndex;
   const cappedLimit = Math.min(limit2, remainingEntries);
@@ -47190,15 +47318,21 @@ async function listDirSlice(dirPath, offset, limit2, maxDepth) {
     formatted.push(formatEntryLine(entry));
   }
   if (endIndex < entries.length) {
-    formatted.push(`More than ${cappedLimit} entries found`);
+    formatted.push(`More entries available. Use offset=${endIndex + 1} to continue.`);
+  } else if (hitCollectionCap || hitFolderTruncation) {
+    formatted.push("More entries may exist beyond the current truncated view.");
   }
   return formatted;
 }
-async function collectEntries(dirPath, relativePrefix, remainingDepth, entries) {
+async function collectEntries(dirPath, relativePrefix, remainingDepth, entries, maxEntriesToCollect, maxChildrenPerDir) {
   const queue = [
     { absPath: dirPath, prefix: relativePrefix, depth: remainingDepth }
   ];
+  let hitFolderTruncation = false;
   while (queue.length > 0) {
+    if (entries.length >= maxEntriesToCollect) {
+      return { hitCollectionCap: true, hitFolderTruncation };
+    }
     const current = queue.shift();
     if (!current)
       break;
@@ -47238,7 +47372,28 @@ async function collectEntries(dirPath, relativePrefix, remainingDepth, entries)
       throw new Error(`failed to read directory: ${err}`);
     }
     dirEntries.sort((a, b) => a.entry.name.localeCompare(b.entry.name));
-    for (const item of dirEntries) {
+    const visibleEntries = dirEntries.slice(0, maxChildrenPerDir);
+    const omittedEntries = Math.max(0, dirEntries.length - visibleEntries.length);
+    if (omittedEntries > 0) {
+      hitFolderTruncation = true;
+      const omittedSortKey = formatEntryName(`${prefix ? `${prefix}/` : ""}￿-omitted`);
+      const omittedDepth = prefix ? prefix.split(path10.sep).length : 0;
+      visibleEntries.push({
+        absPath,
+        relativePath: prefix,
+        kind: "omitted",
+        entry: {
+          name: omittedSortKey,
+          displayName: `… (${omittedEntries.toLocaleString()} more entries)`,
+          depth: omittedDepth,
+          kind: "omitted"
+        }
+      });
+    }
+    for (const item of visibleEntries) {
+      if (entries.length >= maxEntriesToCollect) {
+        return { hitCollectionCap: true, hitFolderTruncation };
+      }
       if (item.kind === "directory" && depth > 1) {
         queue.push({
           absPath: item.absPath,
@@ -47249,6 +47404,7 @@ async function collectEntries(dirPath, relativePrefix, remainingDepth, entries)
       entries.push(item.entry);
     }
   }
+  return { hitCollectionCap: false, hitFolderTruncation };
 }
 function formatEntryName(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -47276,13 +47432,17 @@ function formatEntryLine(entry) {
     case "other":
       name += "?";
       break;
+    case "omitted":
+      break;
     default:
       break;
   }
   return `${indent}${name}`;
 }
-var MAX_ENTRY_LENGTH = 500, INDENTATION_SPACES = 2;
-var init_ListDirCodex2 = () => {};
+var MAX_ENTRY_LENGTH = 500, INDENTATION_SPACES = 2, DEFAULT_OFFSET = 1, DEFAULT_LIMIT2 = 25, DEFAULT_DEPTH = 2;
+var init_ListDirCodex2 = __esm(() => {
+  init_directoryLimits();
+});
 
 // src/tools/schemas/LS.json
 var LS_default2;
@@ -47450,7 +47610,7 @@ async function memory(args) {
     if (existsSync13(filePath)) {
       throw new Error(`memory create: block already exists at ${pathArg}`);
     }
-    const limit2 = args.limit ?? DEFAULT_LIMIT2;
+    const limit2 = args.limit ?? DEFAULT_LIMIT3;
     if (!Number.isInteger(limit2) || limit2 <= 0) {
       throw new Error("memory create: 'limit' must be a positive integer");
     }
@@ -47779,7 +47939,7 @@ function requireString(value, field, command) {
   }
   return value;
 }
-var execFile9, DEFAULT_LIMIT2 = 2000;
+var execFile9, DEFAULT_LIMIT3 = 2000;
 var init_Memory2 = __esm(async () => {
   init_context();
   await init_client2();
@@ -68043,6 +68203,7 @@ var init_manager3 = __esm(async () => {
     "Glob",
     "Grep",
     "TaskStop",
+    "memory",
     "Read",
     "Skill",
     "Task",
@@ -68052,6 +68213,7 @@ var init_manager3 = __esm(async () => {
   OPENAI_DEFAULT_TOOLS = [
     "shell_command",
     "apply_patch",
+    "memory",
     "update_plan",
     "view_image"
   ];
@@ -68061,6 +68223,7 @@ var init_manager3 = __esm(async () => {
     "list_directory",
     "glob_gemini",
     "search_file_content",
+    "memory",
     "replace",
     "write_file_gemini",
     "write_todos",
@@ -68072,6 +68235,7 @@ var init_manager3 = __esm(async () => {
     "AskUserQuestion",
     "EnterPlanMode",
     "ExitPlanMode",
+    "memory",
     "Task",
     "TaskOutput",
     "TaskStop",
@@ -68085,6 +68249,7 @@ var init_manager3 = __esm(async () => {
     "AskUserQuestion",
     "EnterPlanMode",
     "ExitPlanMode",
+    "memory",
     "Skill",
     "Task",
     "RunShellCommand",
@@ -68175,82 +68340,157 @@ function sendTerminalMessage(socket, message) {
     socket.send(JSON.stringify(message));
   }
 }
+function makeOutputBatcher(onFlush) {
+  let buffer = "";
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (buffer.length > 0) {
+      onFlush(buffer);
+      buffer = "";
+    }
+  };
+  return (chunk) => {
+    buffer += chunk;
+    if (buffer.length >= MAX_BUFFER_BYTES) {
+      flush();
+    } else if (!timer) {
+      timer = setTimeout(flush, FLUSH_INTERVAL_MS);
+    }
+  };
+}
+function spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) {
+  const handleData = makeOutputBatcher((data) => sendTerminalMessage(socket, { type: "terminal_output", terminal_id, data }));
+  const proc2 = Bun.spawn([shell2], {
+    cwd: cwd2,
+    env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" },
+    terminal: {
+      cols: cols || 80,
+      rows: rows || 24,
+      data: (_t, chunk) => handleData(new TextDecoder().decode(chunk))
+    }
+  });
+  const terminal = proc2.terminal;
+  if (!terminal) {
+    throw new Error("Bun.spawn terminal object missing — API unavailable");
+  }
+  proc2.exited.then((exitCode) => {
+    const current = terminals.get(terminal_id);
+    if (current && current.pid === proc2.pid) {
+      terminals.delete(terminal_id);
+      sendTerminalMessage(socket, {
+        type: "terminal_exited",
+        terminal_id,
+        exitCode: exitCode ?? 0
+      });
+    }
+  });
+  return {
+    write: (d) => {
+      try {
+        terminal.write(d);
+      } catch {}
+    },
+    resize: (c, r) => {
+      try {
+        terminal.resize(c, r);
+      } catch {}
+    },
+    kill: () => {
+      try {
+        terminal.close();
+      } catch {}
+      try {
+        proc2.kill();
+      } catch {}
+    },
+    pid: proc2.pid,
+    terminalId: terminal_id,
+    spawnedAt: Date.now()
+  };
+}
+function spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket) {
+  const pty = __require("node-pty");
+  const handleData = makeOutputBatcher((data) => sendTerminalMessage(socket, { type: "terminal_output", terminal_id, data }));
+  const ptyProcess = pty.spawn(shell2, [], {
+    name: "xterm-256color",
+    cols: cols || 80,
+    rows: rows || 24,
+    cwd: cwd2,
+    env: {
+      ...process.env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor"
+    }
+  });
+  ptyProcess.onData(handleData);
+  ptyProcess.onExit(({ exitCode }) => {
+    const current = terminals.get(terminal_id);
+    if (current && current.pid === ptyProcess.pid) {
+      terminals.delete(terminal_id);
+      sendTerminalMessage(socket, {
+        type: "terminal_exited",
+        terminal_id,
+        exitCode: exitCode ?? 0
+      });
+    }
+  });
+  return {
+    write: (d) => {
+      try {
+        ptyProcess.write(d);
+      } catch {}
+    },
+    resize: (c, r) => {
+      try {
+        ptyProcess.resize(c, r);
+      } catch {}
+    },
+    kill: () => {
+      try {
+        ptyProcess.kill();
+      } catch {}
+    },
+    pid: ptyProcess.pid,
+    terminalId: terminal_id,
+    spawnedAt: Date.now()
+  };
+}
 function handleTerminalSpawn(msg, socket, cwd2) {
   const { terminal_id, cols, rows } = msg;
-  killTerminal(terminal_id);
-  const shell2 = getDefaultShell();
-  console.log(`[Terminal] Spawning PTY: shell=${shell2}, cwd=${cwd2}, cols=${cols}, rows=${rows}`);
-  try {
-    const proc2 = Bun.spawn([shell2], {
-      cwd: cwd2,
-      env: {
-        ...process.env,
-        TERM: "xterm-256color",
-        COLORTERM: "truecolor"
-      },
-      terminal: {
-        cols: cols || 80,
-        rows: rows || 24,
-        data: (() => {
-          let buffer = "";
-          let flushTimer = null;
-          return (_terminal, data) => {
-            buffer += new TextDecoder().decode(data);
-            if (!flushTimer) {
-              flushTimer = setTimeout(() => {
-                if (buffer.length > 0) {
-                  sendTerminalMessage(socket, {
-                    type: "terminal_output",
-                    terminal_id,
-                    data: buffer
-                  });
-                  buffer = "";
-                }
-                flushTimer = null;
-              }, 16);
-            }
-          };
-        })()
-      }
-    });
-    const terminal = proc2.terminal;
-    console.log(`[Terminal] proc.pid=${proc2.pid}, terminal=${typeof terminal}, keys=${Object.keys(proc2).join(",")}`);
-    if (!terminal) {
-      console.error("[Terminal] terminal object is undefined on proc — Bun.Terminal API may not be available");
+  const existing = terminals.get(terminal_id);
+  if (existing && Date.now() - existing.spawnedAt < 2000) {
+    let alive = true;
+    try {
+      existing.write("\r");
+    } catch {
+      alive = false;
+    }
+    if (alive) {
+      console.log(`[Terminal] Reusing session (age=${Date.now() - existing.spawnedAt}ms), pid=${existing.pid}`);
       sendTerminalMessage(socket, {
-        type: "terminal_exited",
+        type: "terminal_spawned",
         terminal_id,
-        exitCode: 1
+        pid: existing.pid
       });
       return;
     }
-    const session = {
-      process: proc2,
-      terminal,
-      terminalId: terminal_id,
-      spawnedAt: Date.now()
-    };
+    terminals.delete(terminal_id);
+  }
+  killTerminal(terminal_id);
+  const shell2 = getDefaultShell();
+  console.log(`[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, socket) : spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket);
     terminals.set(terminal_id, session);
-    console.log(`[Terminal] Session stored for terminal_id=${terminal_id}, map size=${terminals.size}`);
-    const myPid = proc2.pid;
-    proc2.exited.then((exitCode) => {
-      const current = terminals.get(terminal_id);
-      if (current && current.process.pid === myPid) {
-        console.log(`[Terminal] PTY process exited: terminal_id=${terminal_id}, pid=${myPid}, exitCode=${exitCode}`);
-        terminals.delete(terminal_id);
-        sendTerminalMessage(socket, {
-          type: "terminal_exited",
-          terminal_id,
-          exitCode: exitCode ?? 0
-        });
-      } else {
-        console.log(`[Terminal] Stale PTY exit ignored: terminal_id=${terminal_id}, pid=${myPid} (current pid=${current?.process.pid})`);
-      }
-    });
+    console.log(`[Terminal] Session stored for terminal_id=${terminal_id}, pid=${session.pid}`);
     sendTerminalMessage(socket, {
       type: "terminal_spawned",
       terminal_id,
-      pid: proc2.pid
+      pid: session.pid
     });
   } catch (error) {
     console.error("[Terminal] Failed to spawn PTY:", error);
@@ -68262,16 +68502,10 @@ function handleTerminalSpawn(msg, socket, cwd2) {
   }
 }
 function handleTerminalInput(msg) {
-  const session = terminals.get(msg.terminal_id);
-  if (session) {
-    session.terminal.write(msg.data);
-  }
+  terminals.get(msg.terminal_id)?.write(msg.data);
 }
 function handleTerminalResize(msg) {
-  const session = terminals.get(msg.terminal_id);
-  if (session) {
-    session.terminal.resize(msg.cols, msg.rows);
-  }
+  terminals.get(msg.terminal_id)?.resize(msg.cols, msg.rows);
 }
 function handleTerminalKill(msg) {
   const session = terminals.get(msg.terminal_id);
@@ -68284,11 +68518,8 @@ function handleTerminalKill(msg) {
 function killTerminal(terminalId) {
   const session = terminals.get(terminalId);
   if (session) {
-    console.log(`[Terminal] killTerminal: terminalId=${terminalId}, pid=${session.process.pid}`);
-    try {
-      session.terminal.close();
-    } catch {}
-    session.process.kill();
+    console.log(`[Terminal] killTerminal: terminalId=${terminalId}, pid=${session.pid}`);
+    session.kill();
     terminals.delete(terminalId);
   }
 }
@@ -68297,8 +68528,10 @@ function killAllTerminals() {
     killTerminal(id);
   }
 }
-var terminals;
+var IS_BUN, FLUSH_INTERVAL_MS = 16, MAX_BUFFER_BYTES, terminals;
 var init_terminalHandler = __esm(() => {
+  IS_BUN = typeof Bun !== "undefined";
+  MAX_BUFFER_BYTES = 64 * 1024;
   terminals = new Map;
 });
 
@@ -69172,7 +69405,7 @@ function resolvePendingApprovalResolver(runtime, response) {
   runtime.pendingApprovalResolvers.delete(requestId);
   runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
   if (runtime.pendingApprovalResolvers.size === 0) {
-    setLoopStatus(runtime, runtime.isProcessing ? "PROCESSING_API_RESPONSE" : "WAITING_ON_INPUT");
+    setLoopStatus(runtime, "WAITING_ON_INPUT");
   }
   pending.resolve(response);
   emitLoopStatusIfOpen(runtime.listener, {
@@ -69196,7 +69429,7 @@ function rejectPendingApprovalResolvers(runtime, reason) {
       runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
     }
   }
-  setLoopStatus(runtime, runtime.isProcessing ? "PROCESSING_API_RESPONSE" : "WAITING_ON_INPUT");
+  setLoopStatus(runtime, "WAITING_ON_INPUT");
   emitLoopStatusIfOpen(runtime.listener, {
     agent_id: runtime.agentId,
     conversation_id: runtime.conversationId
@@ -69857,12 +70090,19 @@ function mergeQueuedTurnInput(queued, options) {
 
 // src/websocket/helpers/listenerQueueAdapter.ts
 function getListenerBlockedReason(c) {
-  if (c.pendingApprovalsLen > 0)
-    return "pending_approvals";
   if (c.cancelRequested)
     return "interrupt_in_progress";
+  if (c.pendingApprovalsLen > 0)
+    return "pending_approvals";
   if (c.isRecoveringApprovals)
     return "runtime_busy";
+  if (c.loopStatus === "WAITING_ON_APPROVAL")
+    return "pending_approvals";
+  if (c.loopStatus === "EXECUTING_COMMAND")
+    return "command_running";
+  if (c.loopStatus === "SENDING_API_REQUEST" || c.loopStatus === "RETRYING_API_REQUEST" || c.loopStatus === "WAITING_FOR_API_RESPONSE" || c.loopStatus === "PROCESSING_API_RESPONSE" || c.loopStatus === "EXECUTING_CLIENT_SIDE_TOOL") {
+    return "streaming";
+  }
   if (c.isProcessing)
     return "runtime_busy";
   return null;
@@ -69876,7 +70116,8 @@ __export(exports_queue, {
   normalizeMessageContentImages: () => normalizeMessageContentImages,
   normalizeInboundMessages: () => normalizeInboundMessages,
   getQueueItemsScope: () => getQueueItemsScope,
-  getQueueItemScope: () => getQueueItemScope
+  getQueueItemScope: () => getQueueItemScope,
+  consumeQueuedTurn: () => consumeQueuedTurn
 });
 function getQueueItemScope(item) {
   if (!item) {
@@ -69895,6 +70136,9 @@ function getQueueItemsScope(items) {
   const sameScope = items.every((item) => (item.agentId ?? null) === (first.agentId ?? null) && (item.conversationId ?? null) === (first.conversationId ?? null));
   return sameScope ? getQueueItemScope(first) : {};
 }
+function hasSameQueueScope(a, b) {
+  return (a.agentId ?? null) === (b.agentId ?? null) && (a.conversationId ?? null) === (b.conversationId ?? null);
+}
 function mergeDequeuedBatchContent(items) {
   const queuedInputs = [];
   for (const item of items) {
@@ -70012,12 +70256,46 @@ function buildQueuedTurnMessage(runtime, batch) {
 function shouldQueueInboundMessage(parsed) {
   return parsed.messages.some((payload) => ("content" in payload));
 }
+function consumeQueuedTurn(runtime) {
+  const queuedItems = runtime.queueRuntime.peek();
+  const firstQueuedItem = queuedItems[0];
+  if (!firstQueuedItem || !isCoalescable(firstQueuedItem.kind)) {
+    return null;
+  }
+  let queueLen = 0;
+  let hasMessage = false;
+  for (const item of queuedItems) {
+    if (!isCoalescable(item.kind) || !hasSameQueueScope(firstQueuedItem, item)) {
+      break;
+    }
+    queueLen += 1;
+    if (item.kind === "message") {
+      hasMessage = true;
+    }
+  }
+  if (!hasMessage || queueLen === 0) {
+    return null;
+  }
+  const dequeuedBatch = runtime.queueRuntime.consumeItems(queueLen);
+  if (!dequeuedBatch) {
+    return null;
+  }
+  const queuedTurn = buildQueuedTurnMessage(runtime, dequeuedBatch);
+  if (!queuedTurn) {
+    return null;
+  }
+  return {
+    dequeuedBatch,
+    queuedTurn
+  };
+}
 function computeListenerQueueBlockedReason(runtime) {
   const activeScope = resolveRuntimeScope(runtime.listener, {
     agent_id: runtime.agentId,
     conversation_id: runtime.conversationId
   });
   return getListenerBlockedReason({
+    loopStatus: runtime.loopStatus,
     isProcessing: runtime.isProcessing,
     pendingApprovalsLen: activeScope ? getPendingControlRequestCount(runtime.listener, activeScope) : 0,
     cancelRequested: runtime.cancelRequested,
@@ -70039,18 +70317,11 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
         runtime.queueRuntime.tryDequeue(blockedReason);
         return;
       }
-      const queueLen = runtime.queueRuntime.length;
-      if (queueLen === 0) {
-        return;
-      }
-      const dequeuedBatch = runtime.queueRuntime.consumeItems(queueLen);
-      if (!dequeuedBatch) {
+      const consumedQueuedTurn = consumeQueuedTurn(runtime);
+      if (!consumedQueuedTurn) {
         return;
       }
-      const queuedTurn = buildQueuedTurnMessage(runtime, dequeuedBatch);
-      if (!queuedTurn) {
-        continue;
-      }
+      const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
       emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
       const preTurnStatus = getListenerStatus(runtime.listener) === "processing" ? "processing" : "receiving";
       if (opts.connectionId && runtime.listener.lastEmittedStatus !== preTurnStatus) {
@@ -70085,6 +70356,7 @@ function scheduleQueuePump(runtime, socket, opts, processQueuedTurn) {
   });
 }
 var init_queue = __esm(async () => {
+  init_queueRuntime();
   init_runtime();
   await __promiseAll([
     init_imageResize(),
@@ -74710,17 +74982,26 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
     runtime.activeAbortController = null;
     setLoopStatus(runtime, "SENDING_API_REQUEST", scope);
     emitRuntimeStateUpdates(runtime, scope);
+    const continuationMessages = [
+      {
+        type: "approval",
+        approvals: approvalResults
+      }
+    ];
+    let continuationBatchId = `batch-recovered-${crypto.randomUUID()}`;
+    const consumedQueuedTurn = consumeQueuedTurn(runtime);
+    if (consumedQueuedTurn) {
+      const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+      continuationBatchId = dequeuedBatch.batchId;
+      continuationMessages.push(...queuedTurn.messages);
+      emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
+    }
     await processTurn({
       type: "message",
       agentId: recovered.agentId,
       conversationId: recovered.conversationId,
-      messages: [
-        {
-          type: "approval",
-          approvals: approvalResults
-        }
-      ]
-    }, socket, runtime, opts?.onStatusChange, opts?.connectionId, `batch-recovered-${crypto.randomUUID()}`);
+      messages: continuationMessages
+    }, socket, runtime, opts?.onStatusChange, opts?.connectionId, continuationBatchId);
     clearRecoveredApprovalState(runtime);
     return true;
   } catch (error) {
@@ -74753,7 +75034,8 @@ var init_recovery = __esm(async () => {
     init_stream(),
     init_approval(),
     init_interrupts(),
-    init_protocol_outbound()
+    init_protocol_outbound(),
+    init_queue()
   ]);
 });
 
@@ -74877,9 +75159,10 @@ function markAwaitingAcceptedApprovalContinuationRunId(runtime, input) {
     runtime.activeRunId = null;
   }
 }
-async function resolveStaleApprovals(runtime, socket, abortSignal) {
+async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
   if (!runtime.agentId)
     return null;
+  const getResumeDataImpl = deps.getResumeData ?? getResumeData2;
   const client = await getClient2();
   let agent;
   try {
@@ -74893,7 +75176,7 @@ async function resolveStaleApprovals(runtime, socket, abortSignal) {
   const requestedConversationId = runtime.conversationId !== "default" ? runtime.conversationId : undefined;
   let resumeData;
   try {
-    resumeData = await getResumeData2(client, agent, requestedConversationId, {
+    resumeData = await getResumeDataImpl(client, agent, requestedConversationId, {
       includeMessageHistory: false
     });
   } catch (err) {
@@ -75014,7 +75297,19 @@ async function resolveStaleApprovals(runtime, socket, abortSignal) {
         conversationId: recoveryConversationId
       });
       emitInterruptToolReturnMessage(socket, runtime, approvalResults, runtime.activeRunId ?? undefined, "tool-return");
-      const recoveryStream = await sendApprovalContinuationWithRetry(recoveryConversationId, [{ type: "approval", approvals: approvalResults }], {
+      const continuationMessages = [
+        {
+          type: "approval",
+          approvals: approvalResults
+        }
+      ];
+      const consumedQueuedTurn = consumeQueuedTurn(runtime);
+      if (consumedQueuedTurn) {
+        const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+        continuationMessages.push(...queuedTurn.messages);
+        emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
+      }
+      const recoveryStream = await sendApprovalContinuationWithRetry(recoveryConversationId, continuationMessages, {
         agentId: runtime.agentId ?? undefined,
         streamTokens: true,
         background: true,
@@ -75023,6 +75318,7 @@ async function resolveStaleApprovals(runtime, socket, abortSignal) {
       if (!recoveryStream) {
         throw new Error("Approval recovery send resolved without a continuation stream");
       }
+      setLoopStatus(runtime, "PROCESSING_API_RESPONSE", scope);
       const drainResult = await drainRecoveryStreamWithEmission(recoveryStream, socket, runtime, {
         agentId: runtime.agentId ?? undefined,
         conversationId: recoveryConversationId,
@@ -75317,6 +75613,7 @@ var init_send = __esm(async () => {
     init_approval(),
     init_interrupts(),
     init_protocol_outbound(),
+    init_queue(),
     init_recovery()
   ]);
 });
@@ -76155,6 +76452,7 @@ async function handleApprovalStop(params) {
       terminated: true,
       stream: null,
       currentInput,
+      dequeuedBatchId,
       pendingNormalizationInterruptedToolCallIds: [],
       turnToolContextId,
       lastExecutionResults: null,
@@ -76231,11 +76529,10 @@ async function handleApprovalStop(params) {
           });
         }
       } else {
-        const denyReason = responseBody.error;
         decisions.push({
           type: "deny",
           approval: ac.approval,
-          reason: denyReason
+          reason: responseBody.error
         });
       }
     }
@@ -76250,7 +76547,7 @@ async function handleApprovalStop(params) {
     agent_id: agentId,
     conversation_id: conversationId
   });
-  const executionRunId = runId || runtime.activeRunId || params.msgRunIds[params.msgRunIds.length - 1];
+  const executionRunId = runId || runtime.activeRunId || msgRunIds[msgRunIds.length - 1];
   emitToolExecutionStartedEvents(socket, runtime, {
     toolCallIds: lastExecutingToolCallIds,
     runId: executionRunId,
@@ -76282,6 +76579,14 @@ async function handleApprovalStop(params) {
       approvals: persistedExecutionResults
     }
   ];
+  let continuationBatchId = dequeuedBatchId;
+  const consumedQueuedTurn = consumeQueuedTurn(runtime);
+  if (consumedQueuedTurn) {
+    const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+    continuationBatchId = dequeuedBatch.batchId;
+    nextInput.push(...queuedTurn.messages);
+    emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
+  }
   setLoopStatus(runtime, "SENDING_API_REQUEST", {
     agent_id: agentId,
     conversation_id: conversationId
@@ -76292,6 +76597,7 @@ async function handleApprovalStop(params) {
       terminated: true,
       stream: null,
       currentInput: nextInput,
+      dequeuedBatchId: continuationBatchId,
       pendingNormalizationInterruptedToolCallIds: [],
       turnToolContextId,
       lastExecutionResults,
@@ -76325,6 +76631,7 @@ async function handleApprovalStop(params) {
     terminated: false,
     stream: stream2,
     currentInput: nextInput,
+    dequeuedBatchId: continuationBatchId,
     pendingNormalizationInterruptedToolCallIds: [],
     turnToolContextId: null,
     lastExecutionResults,
@@ -76342,6 +76649,7 @@ var init_turn_approval = __esm(async () => {
     init_approval(),
     init_interrupts(),
     init_protocol_outbound(),
+    init_queue(),
     init_recovery(),
     init_send()
   ]);
@@ -76362,6 +76670,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
   let llmApiErrorRetries = 0;
   let emptyResponseRetries = 0;
   let lastApprovalContinuationAccepted = false;
+  let activeDequeuedBatchId = dequeuedBatchId;
   let lastExecutionResults = null;
   let lastExecutingToolCallIds = [];
   let lastNeedsUserInputToolCallIds = [];
@@ -76723,7 +77032,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         conversationId,
         turnWorkingDirectory,
         turnPermissionModeState,
-        dequeuedBatchId,
+        dequeuedBatchId: activeDequeuedBatchId,
         runId,
         msgRunIds,
         currentInput,
@@ -76736,6 +77045,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       }
       stream2 = approvalResult.stream;
       currentInput = approvalResult.currentInput;
+      activeDequeuedBatchId = approvalResult.dequeuedBatchId;
       pendingNormalizationInterruptedToolCallIds = approvalResult.pendingNormalizationInterruptedToolCallIds;
       turnToolContextId = approvalResult.turnToolContextId;
       lastExecutionResults = approvalResult.lastExecutionResults;
@@ -76957,6 +77267,51 @@ async function handleApprovalResponseInput(listener, params, deps = {
   }
   return false;
 }
+async function handleChangeDeviceStateInput(listener, params, deps = {}) {
+  const resolvedDeps = {
+    getActiveRuntime,
+    getOrCreateScopedRuntime,
+    getPendingControlRequestCount,
+    setLoopStatus,
+    handleModeChange,
+    handleCwdChange,
+    emitDeviceStatusUpdate,
+    scheduleQueuePump,
+    ...deps
+  };
+  if (listener !== resolvedDeps.getActiveRuntime() || listener.intentionallyClosed) {
+    return false;
+  }
+  const scope = {
+    agent_id: params.command.payload.agent_id ?? params.command.runtime.agent_id ?? undefined,
+    conversation_id: params.command.payload.conversation_id ?? params.command.runtime.conversation_id ?? undefined
+  };
+  const scopedRuntime = resolvedDeps.getOrCreateScopedRuntime(listener, scope.agent_id, scope.conversation_id);
+  const shouldTrackCommand = !scopedRuntime.isProcessing && resolvedDeps.getPendingControlRequestCount(listener, scope) === 0;
+  if (shouldTrackCommand) {
+    resolvedDeps.setLoopStatus(scopedRuntime, "EXECUTING_COMMAND", scope);
+  }
+  try {
+    if (params.command.payload.mode) {
+      resolvedDeps.handleModeChange({ mode: params.command.payload.mode }, params.socket, listener, scope);
+    }
+    if (params.command.payload.cwd) {
+      await resolvedDeps.handleCwdChange({
+        agentId: scope.agent_id ?? null,
+        conversationId: scope.conversation_id ?? null,
+        cwd: params.command.payload.cwd
+      }, params.socket, scopedRuntime);
+    } else if (!params.command.payload.mode) {
+      resolvedDeps.emitDeviceStatusUpdate(params.socket, listener, scope);
+    }
+  } finally {
+    if (shouldTrackCommand) {
+      resolvedDeps.setLoopStatus(scopedRuntime, "WAITING_ON_INPUT", scope);
+      resolvedDeps.scheduleQueuePump(scopedRuntime, params.socket, params.opts, params.processQueuedTurn);
+    }
+  }
+  return true;
+}
 async function handleCwdChange(msg, socket, runtime) {
   const conversationId = normalizeConversationId(msg.conversationId);
   const agentId = normalizeCwdAgentId(msg.agentId);
@@ -77241,36 +77596,15 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       return;
     }
     if (parsed.type === "change_device_state") {
-      if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
-        return;
-      }
-      const scope = {
-        agent_id: parsed.payload.agent_id ?? parsed.runtime.agent_id ?? undefined,
-        conversation_id: parsed.payload.conversation_id ?? parsed.runtime.conversation_id ?? undefined
-      };
-      const scopedRuntime = getOrCreateScopedRuntime(runtime, scope.agent_id, scope.conversation_id);
-      const shouldTrackCommand = !scopedRuntime.isProcessing && getPendingControlRequestCount(runtime, scope) === 0;
-      if (shouldTrackCommand) {
-        setLoopStatus(scopedRuntime, "EXECUTING_COMMAND", scope);
-      }
-      try {
-        if (parsed.payload.mode) {
-          handleModeChange({ mode: parsed.payload.mode }, socket, runtime, scope);
-        }
-        if (parsed.payload.cwd) {
-          await handleCwdChange({
-            agentId: scope.agent_id ?? null,
-            conversationId: scope.conversation_id ?? null,
-            cwd: parsed.payload.cwd
-          }, socket, scopedRuntime);
-        } else if (!parsed.payload.mode) {
-          emitDeviceStatusUpdate(socket, runtime, scope);
-        }
-      } finally {
-        if (shouldTrackCommand) {
-          setLoopStatus(scopedRuntime, "WAITING_ON_INPUT", scope);
-        }
-      }
+      await handleChangeDeviceStateInput(runtime, {
+        command: parsed,
+        socket,
+        opts: {
+          onStatusChange: opts.onStatusChange,
+          connectionId: opts.connectionId
+        },
+        processQueuedTurn
+      });
       return;
     }
     if (parsed.type === "abort_message") {
@@ -77626,10 +77960,13 @@ var init_client4 = __esm(async () => {
     shouldAttemptPostStopApprovalRecovery,
     getApprovalContinuationRecoveryDisposition,
     markAwaitingAcceptedApprovalContinuationRunId,
+    resolveStaleApprovals,
     normalizeMessageContentImages,
     normalizeInboundMessages,
+    consumeQueuedTurn,
     handleIncomingMessage,
     handleApprovalResponseInput,
+    handleChangeDeviceStateInput,
     scheduleQueuePump,
     recoverApprovalStateForSync,
     clearRecoveredApprovalStateForScope: (runtime, scope) => clearRecoveredApprovalStateForScope(asListenerRuntimeForTests(runtime), scope),
@@ -103339,7 +103676,9 @@ function ConversationSelector2({
       const result = await client.conversations.list({
         agent_id: agentId,
         limit: FETCH_PAGE_SIZE3,
-        ...afterCursor && { after: afterCursor }
+        ...afterCursor && { after: afterCursor },
+        order: "desc",
+        order_by: "last_run_completion"
       });
       const enrichedConversations = await Promise.all(result.map(async (conv) => {
         try {
@@ -135075,6 +135414,9 @@ __export(exports_memoryFilesystem2, {
   ensureMemoryFilesystemDirs: () => ensureMemoryFilesystemDirs2,
   enableMemfsIfCloud: () => enableMemfsIfCloud2,
   applyMemfsFlags: () => applyMemfsFlags2,
+  MEMORY_TREE_MAX_LINES: () => MEMORY_TREE_MAX_LINES2,
+  MEMORY_TREE_MAX_CHILDREN_PER_DIR: () => MEMORY_TREE_MAX_CHILDREN_PER_DIR2,
+  MEMORY_TREE_MAX_CHARS: () => MEMORY_TREE_MAX_CHARS2,
   MEMORY_SYSTEM_DIR: () => MEMORY_SYSTEM_DIR2,
   MEMORY_FS_ROOT: () => MEMORY_FS_ROOT2,
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR2,
@@ -135103,7 +135445,7 @@ function labelFromRelativePath2(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   return normalized.replace(/\.md$/, "");
 }
-function renderMemoryFilesystemTree2(systemLabels, detachedLabels) {
+function renderMemoryFilesystemTree2(systemLabels, detachedLabels, options = {}) {
   const makeNode = () => ({ children: new Map, isFile: false });
   const root = makeNode();
   const insertPath = (base2, label) => {
@@ -135138,20 +135480,75 @@ function renderMemoryFilesystemTree2(systemLabels, detachedLabels) {
       return nameA.localeCompare(nameB);
     });
   };
-  const lines = ["/memory/"];
+  const limits = getDirectoryLimits();
+  const maxLines = Math.max(2, options.maxLines ?? limits.memfsTreeMaxLines);
+  const maxChars = Math.max(128, options.maxChars ?? limits.memfsTreeMaxChars);
+  const maxChildrenPerDir = Math.max(1, options.maxChildrenPerDir ?? limits.memfsTreeMaxChildrenPerDir);
+  const rootLine = "/memory/";
+  const lines = [rootLine];
+  let totalChars = rootLine.length;
+  const countTreeEntries = (node) => {
+    let total = 0;
+    for (const [, child] of node.children) {
+      total += 1;
+      if (child.children.size > 0) {
+        total += countTreeEntries(child);
+      }
+    }
+    return total;
+  };
+  const canAppendLine = (line) => {
+    const nextLineCount = lines.length + 1;
+    const nextCharCount = totalChars + 1 + line.length;
+    return nextLineCount <= maxLines && nextCharCount <= maxChars;
+  };
   const render2 = (node, prefix) => {
     const entries = sortedEntries(node);
-    entries.forEach(([name, child], index) => {
-      const isLast = index === entries.length - 1;
+    const visibleEntries = entries.slice(0, maxChildrenPerDir);
+    const omittedEntries = Math.max(0, entries.length - visibleEntries.length);
+    const renderItems = visibleEntries.map(([name, child]) => ({
+      kind: "entry",
+      name,
+      child
+    }));
+    if (omittedEntries > 0) {
+      renderItems.push({ kind: "omitted", omittedCount: omittedEntries });
+    }
+    for (const [index, item] of renderItems.entries()) {
+      const isLast = index === renderItems.length - 1;
       const branch = isLast ? "└──" : "├──";
-      lines.push(`${prefix}${branch} ${name}${child.isFile ? "" : "/"}`);
-      if (child.children.size > 0) {
+      const line = item.kind === "entry" ? `${prefix}${branch} ${item.name}${item.child.isFile ? "" : "/"}` : `${prefix}${branch} … (${item.omittedCount.toLocaleString()} more entries)`;
+      if (!canAppendLine(line)) {
+        return false;
+      }
+      lines.push(line);
+      totalChars += 1 + line.length;
+      if (item.kind === "entry" && item.child.children.size > 0) {
         const nextPrefix = `${prefix}${isLast ? "    " : "│   "}`;
-        render2(child, nextPrefix);
+        if (!render2(item.child, nextPrefix)) {
+          return false;
+        }
       }
-    });
+    }
+    return true;
   };
-  render2(root, "");
+  const totalEntries = countTreeEntries(root);
+  const fullyRendered = render2(root, "");
+  if (!fullyRendered) {
+    while (lines.length > 1) {
+      const shownEntries = Math.max(0, lines.length - 1);
+      const omittedEntries = Math.max(1, totalEntries - shownEntries);
+      const notice = `[Tree truncated: showing ${shownEntries.toLocaleString()} of ${totalEntries.toLocaleString()} entries. ${omittedEntries.toLocaleString()} omitted.]`;
+      if (canAppendLine(notice)) {
+        lines.push(notice);
+        break;
+      }
+      const removed = lines.pop();
+      if (removed) {
+        totalChars -= 1 + removed.length;
+      }
+    }
+  }
   return lines.join(`
 `);
 }
@@ -135233,8 +135630,13 @@ async function enableMemfsIfCloud2(agentId) {
     console.warn(`Warning: Could not enable memfs for new agent: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-var MEMORY_FS_ROOT2 = ".letta", MEMORY_FS_AGENTS_DIR2 = "agents", MEMORY_FS_MEMORY_DIR2 = "memory", MEMORY_SYSTEM_DIR2 = "system";
-var init_memoryFilesystem2 = () => {};
+var MEMORY_FS_ROOT2 = ".letta", MEMORY_FS_AGENTS_DIR2 = "agents", MEMORY_FS_MEMORY_DIR2 = "memory", MEMORY_SYSTEM_DIR2 = "system", MEMORY_TREE_MAX_LINES2, MEMORY_TREE_MAX_CHARS2, MEMORY_TREE_MAX_CHILDREN_PER_DIR2;
+var init_memoryFilesystem2 = __esm(() => {
+  init_directoryLimits();
+  MEMORY_TREE_MAX_LINES2 = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxLines;
+  MEMORY_TREE_MAX_CHARS2 = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChars;
+  MEMORY_TREE_MAX_CHILDREN_PER_DIR2 = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChildrenPerDir;
+});
 
 // node_modules/@letta-ai/letta-client/core/error.mjs
 class LettaError extends Error {
@@ -136485,7 +136887,9 @@ function ConversationSelector({
       const result = await client.conversations.list({
         agent_id: agentId,
         limit: FETCH_PAGE_SIZE,
-        ...afterCursor && { after: afterCursor }
+        ...afterCursor && { after: afterCursor },
+        order: "desc",
+        order_by: "last_run_completion"
       });
       const enrichedConversations = await Promise.all(result.map(async (conv) => {
         try {
@@ -141191,6 +141595,7 @@ var ANTHROPIC_DEFAULT_TOOLS2 = [
   "Glob",
   "Grep",
   "TaskStop",
+  "memory",
   "Read",
   "Skill",
   "Task",
@@ -141201,6 +141606,7 @@ var OPENAI_PASCAL_TOOLS2 = [
   "AskUserQuestion",
   "EnterPlanMode",
   "ExitPlanMode",
+  "memory",
   "Task",
   "TaskOutput",
   "TaskStop",
@@ -141214,6 +141620,7 @@ var GEMINI_PASCAL_TOOLS2 = [
   "AskUserQuestion",
   "EnterPlanMode",
   "ExitPlanMode",
+  "memory",
   "Skill",
   "Task",
   "RunShellCommand",
@@ -142972,4 +143379,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=9B4D5740B8FA924E64756E2164756E21
+//# debugId=06EC6034A250F60F64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.19.3",
+  "version": "0.19.5",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {
@@ -68,12 +68,12 @@
     "fix": "bunx --bun @biomejs/biome@2.2.5 check --write src",
     "typecheck": "tsc --noEmit",
     "check": "bun run scripts/check.js",
-    "dev": "LETTA_DEBUG=1 bun --loader:.md=text --loader:.mdx=text --loader:.txt=text run src/index.ts",
+    "dev": "LETTA_DEBUG=${LETTA_DEBUG:-1} bun --loader:.md=text --loader:.mdx=text --loader:.txt=text run src/index.ts",
     "build": "node scripts/postinstall-patches.js && bun run build.js",
     "test:update-chain:manual": "bun run src/tests/update-chain-smoke.ts --mode manual",
     "test:update-chain:startup": "bun run src/tests/update-chain-smoke.ts --mode startup",
     "prepublishOnly": "bun run build",
-    "postinstall": "node scripts/postinstall-patches.js || echo letta: vendor patches skipped"
+    "postinstall": "node scripts/postinstall-patches.js || echo letta: vendor patches skipped && node -e \"try{require('fs').chmodSync(require('path').join(require.resolve('node-pty/package.json'),'../prebuilds/darwin-arm64/spawn-helper'),0o755)}catch(e){}\" || true"
   },
   "lint-staged": {
     "*.{ts,tsx,js,jsx,json}": [