@letta-ai/letta-code 0.19.4 → 0.19.5

package/letta.js

@@ -3240,7 +3240,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.19.4",
+    version: "0.19.5",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3308,7 +3308,7 @@ 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",
@@ -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();
@@ -103516,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 {
@@ -135252,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,
@@ -135280,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) => {
@@ -135315,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(`
 `);
 }
@@ -135410,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 {
@@ -136662,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 {
@@ -143152,4 +143379,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=D1C8E311510A3C4964756E2164756E21
+//# debugId=06EC6034A250F60F64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.19.4",
+  "version": "0.19.5",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {
@@ -68,7 +68,7 @@
     "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",