@letta-ai/letta-code 0.19.4 → 0.19.6

package/letta.js

@@ -344,7 +344,7 @@ var init_values = __esm(() => {
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // node_modules/@letta-ai/letta-client/version.mjs
-var VERSION = "1.7.12";
+var VERSION = "1.8.0";
 
 // node_modules/@letta-ai/letta-client/internal/detect-platform.mjs
 function getDetectedPlatform() {
@@ -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.6",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3273,7 +3273,7 @@ var init_package = __esm(() => {
       access: "public"
     },
     dependencies: {
-      "@letta-ai/letta-client": "^1.7.12",
+      "@letta-ai/letta-client": "1.8.0",
       glob: "^13.0.0",
       "highlight.js": "^11.11.1",
       "ink-link": "^5.0.0",
@@ -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/
@@ -6970,7 +6970,12 @@ var init_models2 = __esm(() => {
         label: "Auto",
         description: "Automatically select the best model",
         isFeatured: true,
-        free: true
+        free: true,
+        updateArgs: {
+          context_window: 140000,
+          max_output_tokens: 28000,
+          parallel_tool_calls: true
+        }
       },
       {
         id: "auto-fast",
@@ -6978,7 +6983,12 @@ var init_models2 = __esm(() => {
         label: "Auto Fast",
         description: "Automatically select the best fast model",
         isFeatured: true,
-        free: true
+        free: true,
+        updateArgs: {
+          context_window: 140000,
+          max_output_tokens: 28000,
+          parallel_tool_calls: true
+        }
       },
       {
         id: "sonnet",
@@ -8431,12 +8441,24 @@ var init_models2 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "minimax-m2.7",
+        handle: "minimax/MiniMax-M2.7",
+        label: "MiniMax 2.7",
+        description: "MiniMax's latest coding model",
+        isFeatured: true,
+        free: true,
+        updateArgs: {
+          context_window: 160000,
+          max_output_tokens: 64000,
+          parallel_tool_calls: true
+        }
+      },
       {
         id: "minimax-m2.5",
         handle: "minimax/MiniMax-M2.5",
         label: "MiniMax 2.5",
-        description: "MiniMax's latest coding model",
-        isFeatured: true,
+        description: "MiniMax's latest coding model (legacy)",
         free: true,
         updateArgs: {
           context_window: 160000,
@@ -39806,9 +39828,483 @@ var init_build4 = __esm(async () => {
   build_default2 = Spinner;
 });
 
-// src/cli/helpers/planName.ts
+// src/cli/helpers/fileIndex.ts
+import { createHash as createHash2 } from "node:crypto";
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
+  statSync as statSync2,
+  writeFileSync as writeFileSync4
+} from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join8, normalize as normalize2, relative as relative2, sep as sep2 } from "node:path";
+function normalizeParent2(relativePath) {
+  if (relativePath.length === 0) {
+    return "";
+  }
+  const lastSepIndex = relativePath.lastIndexOf(sep2);
+  return lastSepIndex === -1 ? "" : relativePath.slice(0, lastSepIndex);
+}
+function hashValue2(input) {
+  return createHash2("sha256").update(input).digest("hex");
+}
+function lowerBound2(sorted, target) {
+  let low = 0;
+  let high = sorted.length;
+  while (low < high) {
+    const mid = low + high >> 1;
+    if ((sorted[mid] ?? "") < target) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low;
+}
+function findPrefixRange2(sorted, prefix) {
+  const start = lowerBound2(sorted, prefix);
+  let end = start;
+  while (end < sorted.length) {
+    const candidate = sorted[end];
+    if (!candidate?.startsWith(prefix)) {
+      break;
+    }
+    end++;
+  }
+  return [start, end];
+}
+function preparePreviousIndexData2(cache5) {
+  const entryPaths = cache5.entries.map((entry) => entry.path);
+  const merkleKeys = Object.keys(cache5.merkle).sort();
+  const stats = { ...cache5.stats };
+  const statsKeys = Object.keys(stats).sort();
+  return {
+    entries: cache5.entries,
+    entryPaths,
+    merkle: cache5.merkle,
+    merkleKeys,
+    stats,
+    statsKeys
+  };
+}
+function appendSubtreeEntries2(targetEntries, previous, path3) {
+  if (path3 === "") {
+    for (const e of previous.entries)
+      targetEntries.push(e);
+    return;
+  }
+  const { entryPaths, entries: previousEntries } = previous;
+  const prefix = `${path3}/`;
+  const [start, end] = findPrefixRange2(entryPaths, prefix);
+  for (let i = start;i < end; i++) {
+    const entry = previousEntries[i];
+    if (entry !== undefined)
+      targetEntries.push(entry);
+  }
+}
+function copyMerkleSubtree2(previous, path3, target) {
+  if (path3 !== "" && previous.merkle[path3]) {
+    target[path3] = previous.merkle[path3];
+  }
+  const prefix = path3 === "" ? "" : `${path3}/`;
+  const [start, end] = prefix === "" ? [0, previous.merkleKeys.length] : findPrefixRange2(previous.merkleKeys, prefix);
+  for (let i = start;i < end; i++) {
+    const key = previous.merkleKeys[i];
+    if (key === undefined)
+      continue;
+    target[key] = previous.merkle[key] ?? "";
+  }
+}
+function copyStatsSubtree2(previous, path3, target) {
+  if (path3 !== "" && previous.stats[path3]) {
+    target[path3] = previous.stats[path3];
+  }
+  const prefix = path3 === "" ? "" : `${path3}/`;
+  const [start, end] = prefix === "" ? [0, previous.statsKeys.length] : findPrefixRange2(previous.statsKeys, prefix);
+  for (let i = start;i < end; i++) {
+    const key = previous.statsKeys[i];
+    if (key === undefined)
+      continue;
+    const val = previous.stats[key];
+    if (val !== undefined)
+      target[key] = val;
+  }
+}
+function collectPreviousChildNames2(previous, path3) {
+  const names = new Set;
+  const prefix = path3 === "" ? "" : `${path3}/`;
+  const [start, end] = prefix === "" ? [0, previous.statsKeys.length] : findPrefixRange2(previous.statsKeys, prefix);
+  for (let i = start;i < end; i++) {
+    const key = previous.statsKeys[i];
+    if (!key) {
+      continue;
+    }
+    const remainder = key.slice(prefix.length);
+    const slashIndex = remainder.indexOf("/");
+    const childName = slashIndex === -1 ? remainder : remainder.slice(0, slashIndex);
+    if (childName.length > 0) {
+      names.add(childName);
+    }
+  }
+  return names;
+}
+function statsMatch2(prev, current) {
+  if (prev.type === "dir" && !current.isDirectory()) {
+    return false;
+  }
+  if (prev.type === "file" && !current.isFile()) {
+    return false;
+  }
+  if (prev.mtimeMs !== current.mtimeMs || prev.ino !== (current.ino ?? 0)) {
+    return false;
+  }
+  if (prev.type === "file") {
+    return typeof prev.size === "number" ? prev.size === current.size : true;
+  }
+  return true;
+}
+function shouldReuseDirectory2(previous, path3, stats, childNames, childStats) {
+  if (!previous) {
+    return false;
+  }
+  const previousStats = previous.stats[path3];
+  if (!previousStats || previousStats.type !== "dir") {
+    return false;
+  }
+  if (previousStats.mtimeMs !== stats.mtimeMs || previousStats.ino !== stats.ino) {
+    return false;
+  }
+  const previousChildNames = collectPreviousChildNames2(previous, path3);
+  const seen = new Set;
+  for (const childName of childNames) {
+    const childPath = path3 === "" ? childName : `${path3}/${childName}`;
+    const prevStats = previous.stats[childPath];
+    const currentStats = childStats.get(childName);
+    if (!prevStats || !currentStats) {
+      return false;
+    }
+    if (!statsMatch2(prevStats, currentStats)) {
+      return false;
+    }
+    seen.add(childName);
+  }
+  if (seen.size !== previousChildNames.size) {
+    return false;
+  }
+  for (const name of previousChildNames) {
+    if (!seen.has(name)) {
+      return false;
+    }
+  }
+  return true;
+}
+async function buildDirectory2(dir, relativePath, entries, merkle, statsMap, previous, depth, context2) {
+  let dirStats;
+  try {
+    dirStats = statSync2(dir);
+  } catch {
+    const unreadableHash = hashValue2("__unreadable__");
+    merkle[relativePath] = unreadableHash;
+    return unreadableHash;
+  }
+  const currentStats = {
+    type: "dir",
+    mtimeMs: dirStats.mtimeMs,
+    ino: dirStats.ino ?? 0
+  };
+  let dirEntries;
+  try {
+    dirEntries = readdirSync4(dir);
+  } catch {
+    const unreadableHash = hashValue2("__unreadable__");
+    merkle[relativePath] = unreadableHash;
+    return unreadableHash;
+  }
+  const childNames = [];
+  const childStatsMap = new Map;
+  for (const entry of dirEntries) {
+    const entryRelPath = relativePath === "" ? entry : `${relativePath}/${entry}`;
+    if (shouldExcludeEntry(entry, entryRelPath)) {
+      continue;
+    }
+    try {
+      const childStat = statSync2(join8(dir, entry));
+      childNames.push(entry);
+      childStatsMap.set(entry, childStat);
+    } catch {}
+  }
+  if (previous !== undefined && shouldReuseDirectory2(previous, relativePath, currentStats, childNames, childStatsMap)) {
+    copyStatsSubtree2(previous, relativePath, statsMap);
+    appendSubtreeEntries2(entries, previous, relativePath);
+    copyMerkleSubtree2(previous, relativePath, merkle);
+    return previous.merkle[relativePath] ?? hashValue2("__reused__");
+  }
+  statsMap[relativePath] = currentStats;
+  if (depth >= MAX_INDEX_DEPTH2 || context2.newEntryCount >= MAX_CACHE_ENTRIES2) {
+    context2.truncated = true;
+    const truncatedHash = hashValue2("__truncated__");
+    merkle[relativePath] = truncatedHash;
+    return truncatedHash;
+  }
+  const childHashes = [];
+  for (const entry of childNames) {
+    if (context2.newEntryCount >= MAX_CACHE_ENTRIES2) {
+      context2.truncated = true;
+      break;
+    }
+    if (context2.newEntryCount > 0 && context2.newEntryCount % 500 === 0) {
+      await new Promise((resolve2) => setImmediate(resolve2));
+    }
+    const entryStat = childStatsMap.get(entry);
+    if (!entryStat) {
+      continue;
+    }
+    const fullPath = join8(dir, entry);
+    const entryPath = relative2(process.cwd(), fullPath);
+    if (!entryPath) {
+      continue;
+    }
+    if (entryStat.isDirectory()) {
+      entries.push({
+        path: entryPath,
+        type: "dir",
+        lowerPath: entryPath.toLowerCase(),
+        parent: normalizeParent2(entryPath)
+      });
+      context2.newEntryCount++;
+      const childHash = await buildDirectory2(fullPath, entryPath, entries, merkle, statsMap, previous, depth + 1, context2);
+      childHashes.push(`dir:${entry}:${childHash}`);
+    } else {
+      const fileHash = hashValue2(`${entryPath}:${entryStat.size}:${entryStat.mtimeMs}:${entryStat.ino ?? 0}`);
+      statsMap[entryPath] = {
+        type: "file",
+        mtimeMs: entryStat.mtimeMs,
+        ino: entryStat.ino ?? 0,
+        size: entryStat.size
+      };
+      merkle[entryPath] = fileHash;
+      entries.push({
+        path: entryPath,
+        type: "file",
+        lowerPath: entryPath.toLowerCase(),
+        parent: normalizeParent2(entryPath)
+      });
+      context2.newEntryCount++;
+      childHashes.push(`file:${entry}:${fileHash}`);
+    }
+  }
+  const dirHash = hashValue2(childHashes.sort().join("|"));
+  merkle[relativePath] = dirHash;
+  return dirHash;
+}
+async function buildIndex2(previous) {
+  const entries = [];
+  const merkle = {};
+  const statsMap = {};
+  const context2 = { newEntryCount: 0, truncated: false };
+  const rootHash = await buildDirectory2(process.cwd(), "", entries, merkle, statsMap, previous, 0, context2);
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  const seen = new Set;
+  const deduped = entries.filter((e) => {
+    if (seen.has(e.path))
+      return false;
+    seen.add(e.path);
+    return true;
+  });
+  return {
+    entries: deduped,
+    merkle,
+    stats: statsMap,
+    rootHash,
+    truncated: context2.truncated
+  };
+}
+function sanitizeWorkspacePath2(workspacePath) {
+  const normalizedPath = normalize2(workspacePath);
+  const strippedPath = normalizedPath.replace(/^[/\\]+/, "");
+  const sanitized = strippedPath.replace(/[/\\:]/g, "_").replace(/\s+/g, "_");
+  return sanitized.length === 0 ? "workspace" : sanitized;
+}
+function getProjectStorageDir2() {
+  const homeDir = homedir7();
+  const sanitizedWorkspace = sanitizeWorkspacePath2(process.cwd());
+  return join8(homeDir, ".letta", "projects", sanitizedWorkspace);
+}
+function ensureProjectStorageDir2() {
+  const storageDir = getProjectStorageDir2();
+  if (!existsSync9(storageDir)) {
+    mkdirSync7(storageDir, { recursive: true });
+  }
+  return storageDir;
+}
+function getProjectIndexPath2() {
+  return join8(getProjectStorageDir2(), PROJECT_INDEX_FILENAME2);
+}
+function loadCachedIndex2() {
+  const indexPath = getProjectIndexPath2();
+  if (!existsSync9(indexPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync6(indexPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed?.metadata && typeof parsed.metadata.rootHash === "string" && Array.isArray(parsed.entries) && parsed.merkle && typeof parsed.merkle === "object") {
+      const merkle = {};
+      for (const [key, value] of Object.entries(parsed.merkle)) {
+        if (typeof value === "string") {
+          merkle[key] = value;
+        }
+      }
+      const stats = {};
+      if (parsed.stats && typeof parsed.stats === "object") {
+        for (const [path3, rawStats] of Object.entries(parsed.stats)) {
+          const sv = rawStats;
+          if (sv && typeof sv.mtimeMs === "number" && typeof sv.ino === "number" && (sv.type === "file" || sv.type === "dir")) {
+            stats[path3] = {
+              type: sv.type,
+              mtimeMs: sv.mtimeMs,
+              ino: sv.ino
+            };
+          }
+        }
+      }
+      return {
+        metadata: {
+          rootHash: parsed.metadata.rootHash
+        },
+        entries: parsed.entries,
+        merkle,
+        stats
+      };
+    }
+  } catch {}
+  return null;
+}
+function cacheProjectIndex2(result) {
+  try {
+    const storageDir = ensureProjectStorageDir2();
+    const indexPath = join8(storageDir, PROJECT_INDEX_FILENAME2);
+    const payload = {
+      metadata: {
+        rootHash: result.rootHash
+      },
+      entries: result.entries,
+      merkle: result.merkle,
+      stats: result.stats
+    };
+    writeFileSync4(indexPath, JSON.stringify(payload, null, 2), "utf-8");
+  } catch {}
+}
+function buildCachedEntries2(entries, stats) {
+  const sorted = [...entries].sort((a, b) => {
+    if (a.type === "dir" && b.type !== "dir")
+      return -1;
+    if (a.type !== "dir" && b.type === "dir")
+      return 1;
+    const aMtime = stats[a.path]?.mtimeMs ?? 0;
+    const bMtime = stats[b.path]?.mtimeMs ?? 0;
+    return bMtime - aMtime;
+  }).slice(0, MAX_CACHE_ENTRIES2);
+  return { entries: sorted, paths: new Set(sorted.map((e) => e.path)) };
+}
+function ensureFileIndex2() {
+  if (hasCompletedBuild2)
+    return Promise.resolve();
+  if (!buildPromise2) {
+    let currentPromise;
+    currentPromise = (async () => {
+      let succeeded = false;
+      try {
+        const diskIndex = loadCachedIndex2();
+        const previousData = diskIndex ? preparePreviousIndexData2(diskIndex) : undefined;
+        const buildResult = await buildIndex2(previousData);
+        if (diskIndex && diskIndex.metadata.rootHash === buildResult.rootHash) {
+          ({ entries: cachedEntries2, paths: cachedEntryPaths2 } = buildCachedEntries2(buildResult.entries, buildResult.stats));
+          succeeded = true;
+          return;
+        }
+        if (buildResult.truncated) {
+          debugLog("file-index", `Index truncated: workspace exceeds ${MAX_INDEX_DEPTH2} directory levels deep. ` + `Files beyond that depth will fall back to disk search.`);
+        }
+        cacheProjectIndex2(buildResult);
+        ({ entries: cachedEntries2, paths: cachedEntryPaths2 } = buildCachedEntries2(buildResult.entries, buildResult.stats));
+        succeeded = true;
+      } finally {
+        if (buildPromise2 === currentPromise)
+          buildPromise2 = null;
+        if (succeeded)
+          hasCompletedBuild2 = true;
+      }
+    })();
+    buildPromise2 = currentPromise;
+  }
+  return buildPromise2;
+}
+function refreshFileIndex() {
+  hasCompletedBuild2 = false;
+  buildPromise2 = null;
+  return ensureFileIndex2();
+}
+function addEntriesToCache(matches) {
+  const available = MAX_CACHE_ENTRIES2 - cachedEntries2.length;
+  if (available <= 0)
+    return;
+  let added = 0;
+  for (const match of matches) {
+    if (added >= available)
+      break;
+    if (!cachedEntryPaths2.has(match.path)) {
+      cachedEntries2.push({
+        path: match.path,
+        type: match.type,
+        lowerPath: match.path.toLowerCase(),
+        parent: normalizeParent2(match.path)
+      });
+      cachedEntryPaths2.add(match.path);
+      added++;
+    }
+  }
+}
+function searchFileIndex(options) {
+  const { searchDir, pattern, deep, maxResults } = options;
+  const normalizedDir = searchDir === "." ? "" : searchDir;
+  const dirWithSep = normalizedDir === "" ? "" : `${normalizedDir}${sep2}`;
+  const lowerPattern = pattern.toLowerCase();
+  const results = [];
+  for (const entry of cachedEntries2) {
+    if (normalizedDir) {
+      if (entry.path !== normalizedDir && !entry.path.startsWith(dirWithSep)) {
+        continue;
+      }
+    }
+    if (!deep && entry.parent !== normalizedDir) {
+      continue;
+    }
+    if (lowerPattern && !entry.lowerPath.includes(lowerPattern)) {
+      continue;
+    }
+    results.push({ path: entry.path, type: entry.type });
+    if (results.length >= maxResults) {
+      break;
+    }
+  }
+  return results;
+}
+var MAX_INDEX_DEPTH2 = 12, PROJECT_INDEX_FILENAME2 = "file-index.json", MAX_CACHE_ENTRIES2, cachedEntries2, cachedEntryPaths2, buildPromise2 = null, hasCompletedBuild2 = false;
+var init_fileIndex = __esm(() => {
+  init_debug();
+  init_lettaSettings();
+  init_fileSearchConfig();
+  MAX_CACHE_ENTRIES2 = readIntSetting("MAX_ENTRIES", 50000);
+  cachedEntries2 = [];
+  cachedEntryPaths2 = new Set;
+});
+
+// src/cli/helpers/planName.ts
+import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
 function randomElement(arr) {
   return arr[Math.floor(Math.random() * arr.length)];
 }
@@ -39820,7 +40316,7 @@ function generatePlanName() {
 }
 function generatePlanFilePath() {
   const name = generatePlanName();
-  return join8(homedir7(), ".letta", "plans", `${name}.md`);
+  return join9(homedir8(), ".letta", "plans", `${name}.md`);
 }
 var adjectives, nouns;
 var init_planName = __esm(() => {
@@ -40383,480 +40879,6 @@ var init_approval_execution = __esm(async () => {
   ]);
 });
 
-// src/cli/helpers/fileIndex.ts
-import { createHash as createHash2 } from "node:crypto";
-import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync7,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync6,
-  statSync as statSync2,
-  writeFileSync as writeFileSync4
-} from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join9, normalize as normalize3, relative as relative2, sep as sep2 } from "node:path";
-function normalizeParent2(relativePath) {
-  if (relativePath.length === 0) {
-    return "";
-  }
-  const lastSepIndex = relativePath.lastIndexOf(sep2);
-  return lastSepIndex === -1 ? "" : relativePath.slice(0, lastSepIndex);
-}
-function hashValue2(input) {
-  return createHash2("sha256").update(input).digest("hex");
-}
-function lowerBound2(sorted, target) {
-  let low = 0;
-  let high = sorted.length;
-  while (low < high) {
-    const mid = low + high >> 1;
-    if ((sorted[mid] ?? "") < target) {
-      low = mid + 1;
-    } else {
-      high = mid;
-    }
-  }
-  return low;
-}
-function findPrefixRange2(sorted, prefix) {
-  const start = lowerBound2(sorted, prefix);
-  let end = start;
-  while (end < sorted.length) {
-    const candidate = sorted[end];
-    if (!candidate?.startsWith(prefix)) {
-      break;
-    }
-    end++;
-  }
-  return [start, end];
-}
-function preparePreviousIndexData2(cache5) {
-  const entryPaths = cache5.entries.map((entry) => entry.path);
-  const merkleKeys = Object.keys(cache5.merkle).sort();
-  const stats = { ...cache5.stats };
-  const statsKeys = Object.keys(stats).sort();
-  return {
-    entries: cache5.entries,
-    entryPaths,
-    merkle: cache5.merkle,
-    merkleKeys,
-    stats,
-    statsKeys
-  };
-}
-function appendSubtreeEntries2(targetEntries, previous, path4) {
-  if (path4 === "") {
-    for (const e of previous.entries)
-      targetEntries.push(e);
-    return;
-  }
-  const { entryPaths, entries: previousEntries } = previous;
-  const prefix = `${path4}/`;
-  const [start, end] = findPrefixRange2(entryPaths, prefix);
-  for (let i = start;i < end; i++) {
-    const entry = previousEntries[i];
-    if (entry !== undefined)
-      targetEntries.push(entry);
-  }
-}
-function copyMerkleSubtree2(previous, path4, target) {
-  if (path4 !== "" && previous.merkle[path4]) {
-    target[path4] = previous.merkle[path4];
-  }
-  const prefix = path4 === "" ? "" : `${path4}/`;
-  const [start, end] = prefix === "" ? [0, previous.merkleKeys.length] : findPrefixRange2(previous.merkleKeys, prefix);
-  for (let i = start;i < end; i++) {
-    const key = previous.merkleKeys[i];
-    if (key === undefined)
-      continue;
-    target[key] = previous.merkle[key] ?? "";
-  }
-}
-function copyStatsSubtree2(previous, path4, target) {
-  if (path4 !== "" && previous.stats[path4]) {
-    target[path4] = previous.stats[path4];
-  }
-  const prefix = path4 === "" ? "" : `${path4}/`;
-  const [start, end] = prefix === "" ? [0, previous.statsKeys.length] : findPrefixRange2(previous.statsKeys, prefix);
-  for (let i = start;i < end; i++) {
-    const key = previous.statsKeys[i];
-    if (key === undefined)
-      continue;
-    const val = previous.stats[key];
-    if (val !== undefined)
-      target[key] = val;
-  }
-}
-function collectPreviousChildNames2(previous, path4) {
-  const names = new Set;
-  const prefix = path4 === "" ? "" : `${path4}/`;
-  const [start, end] = prefix === "" ? [0, previous.statsKeys.length] : findPrefixRange2(previous.statsKeys, prefix);
-  for (let i = start;i < end; i++) {
-    const key = previous.statsKeys[i];
-    if (!key) {
-      continue;
-    }
-    const remainder = key.slice(prefix.length);
-    const slashIndex = remainder.indexOf("/");
-    const childName = slashIndex === -1 ? remainder : remainder.slice(0, slashIndex);
-    if (childName.length > 0) {
-      names.add(childName);
-    }
-  }
-  return names;
-}
-function statsMatch2(prev, current) {
-  if (prev.type === "dir" && !current.isDirectory()) {
-    return false;
-  }
-  if (prev.type === "file" && !current.isFile()) {
-    return false;
-  }
-  if (prev.mtimeMs !== current.mtimeMs || prev.ino !== (current.ino ?? 0)) {
-    return false;
-  }
-  if (prev.type === "file") {
-    return typeof prev.size === "number" ? prev.size === current.size : true;
-  }
-  return true;
-}
-function shouldReuseDirectory2(previous, path4, stats, childNames, childStats) {
-  if (!previous) {
-    return false;
-  }
-  const previousStats = previous.stats[path4];
-  if (!previousStats || previousStats.type !== "dir") {
-    return false;
-  }
-  if (previousStats.mtimeMs !== stats.mtimeMs || previousStats.ino !== stats.ino) {
-    return false;
-  }
-  const previousChildNames = collectPreviousChildNames2(previous, path4);
-  const seen = new Set;
-  for (const childName of childNames) {
-    const childPath = path4 === "" ? childName : `${path4}/${childName}`;
-    const prevStats = previous.stats[childPath];
-    const currentStats = childStats.get(childName);
-    if (!prevStats || !currentStats) {
-      return false;
-    }
-    if (!statsMatch2(prevStats, currentStats)) {
-      return false;
-    }
-    seen.add(childName);
-  }
-  if (seen.size !== previousChildNames.size) {
-    return false;
-  }
-  for (const name of previousChildNames) {
-    if (!seen.has(name)) {
-      return false;
-    }
-  }
-  return true;
-}
-async function buildDirectory2(dir, relativePath, entries, merkle, statsMap, previous, depth, context2) {
-  let dirStats;
-  try {
-    dirStats = statSync2(dir);
-  } catch {
-    const unreadableHash = hashValue2("__unreadable__");
-    merkle[relativePath] = unreadableHash;
-    return unreadableHash;
-  }
-  const currentStats = {
-    type: "dir",
-    mtimeMs: dirStats.mtimeMs,
-    ino: dirStats.ino ?? 0
-  };
-  let dirEntries;
-  try {
-    dirEntries = readdirSync4(dir);
-  } catch {
-    const unreadableHash = hashValue2("__unreadable__");
-    merkle[relativePath] = unreadableHash;
-    return unreadableHash;
-  }
-  const childNames = [];
-  const childStatsMap = new Map;
-  for (const entry of dirEntries) {
-    const entryRelPath = relativePath === "" ? entry : `${relativePath}/${entry}`;
-    if (shouldExcludeEntry(entry, entryRelPath)) {
-      continue;
-    }
-    try {
-      const childStat = statSync2(join9(dir, entry));
-      childNames.push(entry);
-      childStatsMap.set(entry, childStat);
-    } catch {}
-  }
-  if (previous !== undefined && shouldReuseDirectory2(previous, relativePath, currentStats, childNames, childStatsMap)) {
-    copyStatsSubtree2(previous, relativePath, statsMap);
-    appendSubtreeEntries2(entries, previous, relativePath);
-    copyMerkleSubtree2(previous, relativePath, merkle);
-    return previous.merkle[relativePath] ?? hashValue2("__reused__");
-  }
-  statsMap[relativePath] = currentStats;
-  if (depth >= MAX_INDEX_DEPTH2 || context2.newEntryCount >= MAX_CACHE_ENTRIES2) {
-    context2.truncated = true;
-    const truncatedHash = hashValue2("__truncated__");
-    merkle[relativePath] = truncatedHash;
-    return truncatedHash;
-  }
-  const childHashes = [];
-  for (const entry of childNames) {
-    if (context2.newEntryCount >= MAX_CACHE_ENTRIES2) {
-      context2.truncated = true;
-      break;
-    }
-    if (context2.newEntryCount > 0 && context2.newEntryCount % 500 === 0) {
-      await new Promise((resolve3) => setImmediate(resolve3));
-    }
-    const entryStat = childStatsMap.get(entry);
-    if (!entryStat) {
-      continue;
-    }
-    const fullPath = join9(dir, entry);
-    const entryPath = relative2(process.cwd(), fullPath);
-    if (!entryPath) {
-      continue;
-    }
-    if (entryStat.isDirectory()) {
-      entries.push({
-        path: entryPath,
-        type: "dir",
-        lowerPath: entryPath.toLowerCase(),
-        parent: normalizeParent2(entryPath)
-      });
-      context2.newEntryCount++;
-      const childHash = await buildDirectory2(fullPath, entryPath, entries, merkle, statsMap, previous, depth + 1, context2);
-      childHashes.push(`dir:${entry}:${childHash}`);
-    } else {
-      const fileHash = hashValue2(`${entryPath}:${entryStat.size}:${entryStat.mtimeMs}:${entryStat.ino ?? 0}`);
-      statsMap[entryPath] = {
-        type: "file",
-        mtimeMs: entryStat.mtimeMs,
-        ino: entryStat.ino ?? 0,
-        size: entryStat.size
-      };
-      merkle[entryPath] = fileHash;
-      entries.push({
-        path: entryPath,
-        type: "file",
-        lowerPath: entryPath.toLowerCase(),
-        parent: normalizeParent2(entryPath)
-      });
-      context2.newEntryCount++;
-      childHashes.push(`file:${entry}:${fileHash}`);
-    }
-  }
-  const dirHash = hashValue2(childHashes.sort().join("|"));
-  merkle[relativePath] = dirHash;
-  return dirHash;
-}
-async function buildIndex2(previous) {
-  const entries = [];
-  const merkle = {};
-  const statsMap = {};
-  const context2 = { newEntryCount: 0, truncated: false };
-  const rootHash = await buildDirectory2(process.cwd(), "", entries, merkle, statsMap, previous, 0, context2);
-  entries.sort((a, b) => a.path.localeCompare(b.path));
-  const seen = new Set;
-  const deduped = entries.filter((e) => {
-    if (seen.has(e.path))
-      return false;
-    seen.add(e.path);
-    return true;
-  });
-  return {
-    entries: deduped,
-    merkle,
-    stats: statsMap,
-    rootHash,
-    truncated: context2.truncated
-  };
-}
-function sanitizeWorkspacePath2(workspacePath) {
-  const normalizedPath = normalize3(workspacePath);
-  const strippedPath = normalizedPath.replace(/^[/\\]+/, "");
-  const sanitized = strippedPath.replace(/[/\\:]/g, "_").replace(/\s+/g, "_");
-  return sanitized.length === 0 ? "workspace" : sanitized;
-}
-function getProjectStorageDir2() {
-  const homeDir = homedir8();
-  const sanitizedWorkspace = sanitizeWorkspacePath2(process.cwd());
-  return join9(homeDir, ".letta", "projects", sanitizedWorkspace);
-}
-function ensureProjectStorageDir2() {
-  const storageDir = getProjectStorageDir2();
-  if (!existsSync9(storageDir)) {
-    mkdirSync7(storageDir, { recursive: true });
-  }
-  return storageDir;
-}
-function getProjectIndexPath2() {
-  return join9(getProjectStorageDir2(), PROJECT_INDEX_FILENAME2);
-}
-function loadCachedIndex2() {
-  const indexPath = getProjectIndexPath2();
-  if (!existsSync9(indexPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync6(indexPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed?.metadata && typeof parsed.metadata.rootHash === "string" && Array.isArray(parsed.entries) && parsed.merkle && typeof parsed.merkle === "object") {
-      const merkle = {};
-      for (const [key, value] of Object.entries(parsed.merkle)) {
-        if (typeof value === "string") {
-          merkle[key] = value;
-        }
-      }
-      const stats = {};
-      if (parsed.stats && typeof parsed.stats === "object") {
-        for (const [path4, rawStats] of Object.entries(parsed.stats)) {
-          const sv = rawStats;
-          if (sv && typeof sv.mtimeMs === "number" && typeof sv.ino === "number" && (sv.type === "file" || sv.type === "dir")) {
-            stats[path4] = {
-              type: sv.type,
-              mtimeMs: sv.mtimeMs,
-              ino: sv.ino
-            };
-          }
-        }
-      }
-      return {
-        metadata: {
-          rootHash: parsed.metadata.rootHash
-        },
-        entries: parsed.entries,
-        merkle,
-        stats
-      };
-    }
-  } catch {}
-  return null;
-}
-function cacheProjectIndex2(result) {
-  try {
-    const storageDir = ensureProjectStorageDir2();
-    const indexPath = join9(storageDir, PROJECT_INDEX_FILENAME2);
-    const payload = {
-      metadata: {
-        rootHash: result.rootHash
-      },
-      entries: result.entries,
-      merkle: result.merkle,
-      stats: result.stats
-    };
-    writeFileSync4(indexPath, JSON.stringify(payload, null, 2), "utf-8");
-  } catch {}
-}
-function buildCachedEntries2(entries, stats) {
-  const sorted = [...entries].sort((a, b) => {
-    if (a.type === "dir" && b.type !== "dir")
-      return -1;
-    if (a.type !== "dir" && b.type === "dir")
-      return 1;
-    const aMtime = stats[a.path]?.mtimeMs ?? 0;
-    const bMtime = stats[b.path]?.mtimeMs ?? 0;
-    return bMtime - aMtime;
-  }).slice(0, MAX_CACHE_ENTRIES2);
-  return { entries: sorted, paths: new Set(sorted.map((e) => e.path)) };
-}
-function ensureFileIndex2() {
-  if (hasCompletedBuild2)
-    return Promise.resolve();
-  if (!buildPromise2) {
-    let currentPromise;
-    currentPromise = (async () => {
-      let succeeded = false;
-      try {
-        const diskIndex = loadCachedIndex2();
-        const previousData = diskIndex ? preparePreviousIndexData2(diskIndex) : undefined;
-        const buildResult = await buildIndex2(previousData);
-        if (diskIndex && diskIndex.metadata.rootHash === buildResult.rootHash) {
-          ({ entries: cachedEntries2, paths: cachedEntryPaths2 } = buildCachedEntries2(buildResult.entries, buildResult.stats));
-          succeeded = true;
-          return;
-        }
-        if (buildResult.truncated) {
-          debugLog("file-index", `Index truncated: workspace exceeds ${MAX_INDEX_DEPTH2} directory levels deep. ` + `Files beyond that depth will fall back to disk search.`);
-        }
-        cacheProjectIndex2(buildResult);
-        ({ entries: cachedEntries2, paths: cachedEntryPaths2 } = buildCachedEntries2(buildResult.entries, buildResult.stats));
-        succeeded = true;
-      } finally {
-        if (buildPromise2 === currentPromise)
-          buildPromise2 = null;
-        if (succeeded)
-          hasCompletedBuild2 = true;
-      }
-    })();
-    buildPromise2 = currentPromise;
-  }
-  return buildPromise2;
-}
-function refreshFileIndex() {
-  hasCompletedBuild2 = false;
-  buildPromise2 = null;
-  return ensureFileIndex2();
-}
-function addEntriesToCache(matches) {
-  const available = MAX_CACHE_ENTRIES2 - cachedEntries2.length;
-  if (available <= 0)
-    return;
-  let added = 0;
-  for (const match of matches) {
-    if (added >= available)
-      break;
-    if (!cachedEntryPaths2.has(match.path)) {
-      cachedEntries2.push({
-        path: match.path,
-        type: match.type,
-        lowerPath: match.path.toLowerCase(),
-        parent: normalizeParent2(match.path)
-      });
-      cachedEntryPaths2.add(match.path);
-      added++;
-    }
-  }
-}
-function searchFileIndex(options) {
-  const { searchDir, pattern, deep, maxResults } = options;
-  const normalizedDir = searchDir === "." ? "" : searchDir;
-  const dirWithSep = normalizedDir === "" ? "" : `${normalizedDir}${sep2}`;
-  const lowerPattern = pattern.toLowerCase();
-  const results = [];
-  for (const entry of cachedEntries2) {
-    if (normalizedDir) {
-      if (entry.path !== normalizedDir && !entry.path.startsWith(dirWithSep)) {
-        continue;
-      }
-    }
-    if (!deep && entry.parent !== normalizedDir) {
-      continue;
-    }
-    if (lowerPattern && !entry.lowerPath.includes(lowerPattern)) {
-      continue;
-    }
-    results.push({ path: entry.path, type: entry.type });
-    if (results.length >= maxResults) {
-      break;
-    }
-  }
-  return results;
-}
-var MAX_INDEX_DEPTH2 = 12, PROJECT_INDEX_FILENAME2 = "file-index.json", MAX_CACHE_ENTRIES2, cachedEntries2, cachedEntryPaths2, buildPromise2 = null, hasCompletedBuild2 = false;
-var init_fileIndex = __esm(() => {
-  init_debug();
-  init_lettaSettings();
-  init_fileSearchConfig();
-  MAX_CACHE_ENTRIES2 = readIntSetting("MAX_ENTRIES", 50000);
-  cachedEntries2 = [];
-  cachedEntryPaths2 = new Set;
-});
-
 // src/permissions/session.ts
 var exports_session = {};
 __export(exports_session, {
@@ -43551,7 +43573,7 @@ If a directory has more than 1,000 entries, only the first 1,000 will be shown.`
 var init_LS = () => {};
 
 // src/tools/descriptions/Memory.md
-var Memory_default = '# Memory\nA convinience tool for memories stored in the memory directory (`$MEMORY_DIR`) that automatically commits and pushes changes. \n\nFiles stored inside of `system/` eventually become part of the agent\'s system prompt, so are always in the context window and do not need to be re-read. Other files only have metadata in the system prompt, so may need to be explicitly read to be updated. \n\nSupported operations on memory files:  \n- `str_replace`\n- `insert`\n- `delete`\n- `rename` (path rename or description update mode)\n- `create`\nMore general operations can be performanced through directory modifying the files. \n\nPath formats accepted:\n- relative memory file paths (e.g. `system/contacts.md`, `reference/project/team.md`)\n\nNote: absolute paths and `/memories/...` paths are not supported by this client-side tool.\n\nExamples:\n\n```python\n# Replace text in a memory file \nmemory(command="str_replace", reason="Update theme preference", path="system/human/preferences.md", old_string="theme: dark", new_string="theme: light")\n\n# Insert text at line 5\nmemory(command="insert", reason="Add note about meeting", path="reference/history/meeting-notes.md", insert_line=5, insert_text="New note here")\n\n# Delete a memory file \nmemory(command="delete", reason="Remove stale notes", path="reference/history/old_notes.md")\n\n# Rename a memory file \nmemory(command="rename", reason="Promote temp notes", old_path="reference/history/temp.md", new_path="reference/history/permanent.md")\n\n# Create a block with starting text\nmemory(command="create", reason="Track coding preferences", path="system/human/prefs/coding.md", description="The user\'s coding preferences.", file_text="The user seems to add type hints to all of their Python code.")\n\n# Create an empty block\nmemory(command="create", reason="Create coding preferences block", path="reference/history/coding_preferences.md", description="The user\'s coding preferences.")\n```\n';
+var Memory_default = '# Memory\nA convinience tool for memories stored in the memory directory (`$MEMORY_DIR`) that automatically commits and pushes changes. \n\nFiles stored inside of `system/` eventually become part of the agent\'s system prompt, so are always in the context window and do not need to be re-read. Other files only have metadata in the system prompt, so may need to be explicitly read to be updated. \n\nSupported operations on memory files:  \n- `str_replace`\n- `insert`\n- `delete` (files, or directories recursively)\n- `rename` (path rename only)\n- `update_description`\n- `create`\nMore general operations can be performanced through directory modifying the files. \n\nPath formats accepted:\n- relative memory file paths (e.g. `system/contacts.md`, `reference/project/team.md`)\n- absolute paths only when they are inside `$MEMORY_DIR`\n\nNote: absolute paths outside `$MEMORY_DIR` are rejected.\n\nExamples:\n\n```python\n# Replace text in a memory file \nmemory(command="str_replace", reason="Update theme preference", path="system/human/preferences.md", old_string="theme: dark", new_string="theme: light")\n\n# Insert text at line 5\nmemory(command="insert", reason="Add note about meeting", path="reference/history/meeting-notes.md", insert_line=5, insert_text="New note here")\n\n# Delete a memory file \nmemory(command="delete", reason="Remove stale notes", path="reference/history/old_notes.md")\n\n# Rename a memory file \nmemory(command="rename", reason="Promote temp notes", old_path="reference/history/temp.md", new_path="reference/history/permanent.md")\n\n# Update a block description\nmemory(command="update_description", reason="Clarify coding prefs block", path="system/human/prefs/coding.md", description="Dr. Wooders\' coding preferences.")\n\n# Create a block with starting text\nmemory(command="create", reason="Track coding preferences", path="system/human/prefs/coding.md", description="The user\'s coding preferences.", file_text="The user seems to add type hints to all of their Python code.")\n\n# Create an empty block\nmemory(command="create", reason="Create coding preferences block", path="reference/history/coding_preferences.md", description="The user\'s coding preferences.")\n```\n';
 var init_Memory = () => {};
 
 // src/tools/descriptions/MultiEdit.md
@@ -44712,6 +44734,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 +45635,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 +45666,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 +45701,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 +45851,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 +47288,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 +47340,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 +47394,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 +47426,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 +47454,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;
@@ -47403,7 +47585,15 @@ var init_ListDirectoryGemini2 = __esm(() => {
 // src/tools/impl/Memory.ts
 import { execFile as execFileCb2 } from "node:child_process";
 import { existsSync as existsSync13 } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile3, rename, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import {
+  mkdir as mkdir2,
+  readFile as readFile3,
+  rename,
+  rm,
+  stat as stat2,
+  unlink,
+  writeFile as writeFile2
+} from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
 import { dirname as dirname5, isAbsolute as isAbsolute8, relative as relative5, resolve as resolve12 } from "node:path";
 import { promisify as promisify9 } from "node:util";
@@ -47444,20 +47634,16 @@ async function memory(args) {
   if (command === "create") {
     const pathArg = requireString(args.path, "path", "create");
     const description = requireString(args.description, "description", "create");
-    const label = normalizeMemoryLabel(pathArg, "path");
+    const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
     const filePath = resolveMemoryFilePath(memoryDir, label);
     const relPath = toRepoRelative(memoryDir, filePath);
     if (existsSync13(filePath)) {
       throw new Error(`memory create: block already exists at ${pathArg}`);
     }
-    const limit2 = args.limit ?? DEFAULT_LIMIT2;
-    if (!Number.isInteger(limit2) || limit2 <= 0) {
-      throw new Error("memory create: 'limit' must be a positive integer");
-    }
     const body = args.file_text ?? "";
     const rendered = renderMemoryFile({
       description,
-      limit: limit2
+      limit: DEFAULT_LIMIT3
     }, body);
     await mkdir2(dirname5(filePath), { recursive: true });
     await writeFile2(filePath, rendered, "utf8");
@@ -47466,7 +47652,7 @@ async function memory(args) {
     const pathArg = requireString(args.path, "path", "str_replace");
     const oldString = requireString(args.old_string, "old_string", "str_replace");
     const newString = requireString(args.new_string, "new_string", "str_replace");
-    const label = normalizeMemoryLabel(pathArg, "path");
+    const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
     const filePath = resolveMemoryFilePath(memoryDir, label);
     const relPath = toRepoRelative(memoryDir, filePath);
     const file = await loadEditableMemoryFile(filePath, pathArg);
@@ -47484,7 +47670,7 @@ async function memory(args) {
     if (typeof args.insert_line !== "number" || Number.isNaN(args.insert_line)) {
       throw new Error("memory insert: 'insert_line' must be a number");
     }
-    const label = normalizeMemoryLabel(pathArg, "path");
+    const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
     const filePath = resolveMemoryFilePath(memoryDir, label);
     const relPath = toRepoRelative(memoryDir, filePath);
     const file = await loadEditableMemoryFile(filePath, pathArg);
@@ -47502,44 +47688,48 @@ async function memory(args) {
     affectedPaths = [relPath];
   } else if (command === "delete") {
     const pathArg = requireString(args.path, "path", "delete");
-    const label = normalizeMemoryLabel(pathArg, "path");
-    const filePath = resolveMemoryFilePath(memoryDir, label);
-    const relPath = toRepoRelative(memoryDir, filePath);
-    await loadEditableMemoryFile(filePath, pathArg);
-    await unlink(filePath);
-    affectedPaths = [relPath];
-  } else if (command === "rename") {
-    const hasDescriptionUpdate = typeof args.path === "string" && args.path.trim().length > 0 && typeof args.description === "string" && args.description.trim().length > 0 && !args.old_path && !args.new_path;
-    if (hasDescriptionUpdate) {
-      const pathArg = requireString(args.path, "path", "rename");
-      const newDescription = requireString(args.description, "description", "rename description update");
-      const label = normalizeMemoryLabel(pathArg, "path");
+    const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
+    const targetPath = resolveMemoryPath(memoryDir, label);
+    if (existsSync13(targetPath) && (await stat2(targetPath)).isDirectory()) {
+      const relPath = toRepoRelative(memoryDir, targetPath);
+      await rm(targetPath, { recursive: true, force: false });
+      affectedPaths = [relPath];
+    } else {
       const filePath = resolveMemoryFilePath(memoryDir, label);
       const relPath = toRepoRelative(memoryDir, filePath);
-      const file = await loadEditableMemoryFile(filePath, pathArg);
-      const rendered = renderMemoryFile({
-        ...file.frontmatter,
-        description: newDescription
-      }, file.body);
-      await writeFile2(filePath, rendered, "utf8");
+      await loadEditableMemoryFile(filePath, pathArg);
+      await unlink(filePath);
       affectedPaths = [relPath];
-    } else {
-      const oldPathArg = requireString(args.old_path, "old_path", "rename");
-      const newPathArg = requireString(args.new_path, "new_path", "rename");
-      const oldLabel = normalizeMemoryLabel(oldPathArg, "old_path");
-      const newLabel = normalizeMemoryLabel(newPathArg, "new_path");
-      const oldFilePath = resolveMemoryFilePath(memoryDir, oldLabel);
-      const newFilePath = resolveMemoryFilePath(memoryDir, newLabel);
-      const oldRelPath = toRepoRelative(memoryDir, oldFilePath);
-      const newRelPath = toRepoRelative(memoryDir, newFilePath);
-      if (existsSync13(newFilePath)) {
-        throw new Error(`memory rename: destination already exists at ${newPathArg}`);
-      }
-      await loadEditableMemoryFile(oldFilePath, oldPathArg);
-      await mkdir2(dirname5(newFilePath), { recursive: true });
-      await rename(oldFilePath, newFilePath);
-      affectedPaths = [oldRelPath, newRelPath];
     }
+  } else if (command === "rename") {
+    const oldPathArg = requireString(args.old_path, "old_path", "rename");
+    const newPathArg = requireString(args.new_path, "new_path", "rename");
+    const oldLabel = normalizeMemoryLabel(memoryDir, oldPathArg, "old_path");
+    const newLabel = normalizeMemoryLabel(memoryDir, newPathArg, "new_path");
+    const oldFilePath = resolveMemoryFilePath(memoryDir, oldLabel);
+    const newFilePath = resolveMemoryFilePath(memoryDir, newLabel);
+    const oldRelPath = toRepoRelative(memoryDir, oldFilePath);
+    const newRelPath = toRepoRelative(memoryDir, newFilePath);
+    if (existsSync13(newFilePath)) {
+      throw new Error(`memory rename: destination already exists at ${newPathArg}`);
+    }
+    await loadEditableMemoryFile(oldFilePath, oldPathArg);
+    await mkdir2(dirname5(newFilePath), { recursive: true });
+    await rename(oldFilePath, newFilePath);
+    affectedPaths = [oldRelPath, newRelPath];
+  } else if (command === "update_description") {
+    const pathArg = requireString(args.path, "path", "update_description");
+    const newDescription = requireString(args.description, "description", "update_description");
+    const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
+    const filePath = resolveMemoryFilePath(memoryDir, label);
+    const relPath = toRepoRelative(memoryDir, filePath);
+    const file = await loadEditableMemoryFile(filePath, pathArg);
+    const rendered = renderMemoryFile({
+      ...file.frontmatter,
+      description: newDescription
+    }, file.body);
+    await writeFile2(filePath, rendered, "utf8");
+    affectedPaths = [relPath];
   } else {
     throw new Error(`Unsupported memory command: ${command}`);
   }
@@ -47583,18 +47773,31 @@ function ensureMemoryRepo(memoryDir) {
     throw new Error(`memory: ${memoryDir} is not a git repository. This tool requires a git-backed memory filesystem.`);
   }
 }
-function normalizeMemoryLabel(inputPath, fieldName) {
+function normalizeMemoryLabel(memoryDir, inputPath, fieldName) {
   const raw = inputPath.trim();
   if (!raw) {
     throw new Error(`memory: '${fieldName}' must be a non-empty string`);
   }
-  const normalized = raw.replace(/\\/g, "/");
-  if (/^[a-zA-Z]:\//.test(normalized)) {
-    throw new Error(`memory: '${fieldName}' must be a memory-relative file path, not an absolute host path`);
-  }
-  if (normalized.startsWith("~/") || normalized.startsWith("$HOME/")) {
+  if (raw.startsWith("~/") || raw.startsWith("$HOME/")) {
     throw new Error(`memory: '${fieldName}' must be a memory-relative file path, not a home-relative filesystem path`);
   }
+  const isWindowsAbsolute = /^[a-zA-Z]:[\\/]/.test(raw);
+  if (isAbsolute8(raw) || isWindowsAbsolute) {
+    const absolutePath = resolve12(raw);
+    const relToMemory = relative5(memoryDir, absolutePath);
+    if (relToMemory && !relToMemory.startsWith("..") && !isAbsolute8(relToMemory)) {
+      return normalizeRelativeMemoryLabel(relToMemory, fieldName);
+    }
+    throw new Error(memoryPrefixError(memoryDir));
+  }
+  return normalizeRelativeMemoryLabel(raw, fieldName);
+}
+function normalizeRelativeMemoryLabel(inputPath, fieldName) {
+  const raw = inputPath.trim();
+  if (!raw) {
+    throw new Error(`memory: '${fieldName}' must be a non-empty string`);
+  }
+  const normalized = raw.replace(/\\/g, "/");
   if (normalized.startsWith("/")) {
     throw new Error(`memory: '${fieldName}' must be a relative path like system/contacts.md`);
   }
@@ -47618,8 +47821,15 @@ function normalizeMemoryLabel(inputPath, fieldName) {
   }
   return segments.join("/");
 }
+function memoryPrefixError(memoryDir) {
+  return `The memory tool can only be used to modify files in {${memoryDir}} or provided as a relative path`;
+}
 function resolveMemoryFilePath(memoryDir, label) {
-  const absolute = resolve12(memoryDir, `${label}.md`);
+  const absolute = resolveMemoryPath(memoryDir, `${label}.md`);
+  return absolute;
+}
+function resolveMemoryPath(memoryDir, path11) {
+  const absolute = resolve12(memoryDir, path11);
   const rel = relative5(memoryDir, absolute);
   if (rel.startsWith("..") || isAbsolute8(rel)) {
     throw new Error("memory: resolved path escapes memory directory");
@@ -47779,7 +47989,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();
@@ -61313,7 +61523,7 @@ __export(exports_skills, {
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR
 });
 import { existsSync as existsSync15 } from "node:fs";
-import { readdir as readdir4, readFile as readFile4, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile4, realpath as realpath2, stat as stat3 } from "node:fs/promises";
 import { dirname as dirname6, join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function getBundledSkillsPath() {
@@ -61410,7 +61620,7 @@ async function findSkillFiles(currentPath, rootPath, skills, errors, source, vis
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
-          const entryStat = await stat2(fullPath);
+          const entryStat = await stat3(fullPath);
           isDirectory = entryStat.isDirectory();
           isFile = entryStat.isFile();
         }
@@ -63532,7 +63742,14 @@ var init_Memory3 = __esm(() => {
     properties: {
       command: {
         type: "string",
-        enum: ["str_replace", "insert", "delete", "rename", "create"],
+        enum: [
+          "str_replace",
+          "insert",
+          "delete",
+          "rename",
+          "update_description",
+          "create"
+        ],
         description: "Memory operation to perform"
       },
       reason: {
@@ -63541,15 +63758,15 @@ var init_Memory3 = __esm(() => {
       },
       path: {
         type: "string",
-        description: "Target memory file path relative to memory root (e.g. system/contacts.md)"
+        description: "Target memory path (file or directory). Accepts relative paths like system/contacts.md or absolute paths under MEMORY_DIR"
       },
       old_path: {
         type: "string",
-        description: "Source memory file path for rename operations (e.g. system/temp.md)"
+        description: "Source memory file path for rename operations (relative path or absolute path under MEMORY_DIR)"
       },
       new_path: {
         type: "string",
-        description: "Destination memory file path for rename operations (e.g. system/permanent.md)"
+        description: "Destination memory file path for rename operations (relative path or absolute path under MEMORY_DIR)"
       },
       old_string: {
         type: "string",
@@ -63569,15 +63786,11 @@ var init_Memory3 = __esm(() => {
       },
       description: {
         type: "string",
-        description: "Block description (required for create, or used with rename + path to update description)"
+        description: "Block description (required for create and update_description)"
       },
       file_text: {
         type: "string",
         description: "Initial block content for create"
-      },
-      limit: {
-        type: "number",
-        description: "Optional positive integer limit for create"
       }
     },
     required: ["command", "reason"],
@@ -69873,11 +70086,17 @@ function isTerminalKillCommand(value) {
   const c = value;
   return c.type === "terminal_kill" && typeof c.terminal_id === "string";
 }
+function isSearchFilesCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "search_files" && typeof c.query === "string" && typeof c.request_id === "string";
+}
 function parseServerMessage(data) {
   try {
     const raw = typeof data === "string" ? data : data.toString();
     const parsed = JSON.parse(raw);
-    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed)) {
+    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed)) {
       return parsed;
     }
     const invalidInput = getInvalidInputReason(parsed);
@@ -76545,6 +76764,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       });
       return;
     }
+    setCurrentAgentId(agentId);
+    setConversationId2(conversationId);
     if (isDebugEnabled()) {
       console.log(`[Listen] Handling message: agentId=${agentId}, requestedConversationId=${requestedConversationId}, conversationId=${conversationId}`);
     }
@@ -76974,6 +77195,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
 }
 var init_turn = __esm(async () => {
   init_check_approval();
+  init_context();
   init_turn_recovery_policy();
   init_errorFormatter();
   init_listenContext();
@@ -76999,7 +77221,7 @@ var init_turn = __esm(async () => {
 });
 
 // src/websocket/listener/client.ts
-import { realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { realpath as realpath3, stat as stat4 } from "node:fs/promises";
 import path22 from "node:path";
 import WebSocket4 from "ws";
 function handleModeChange(msg, socket, runtime, scope) {
@@ -77163,7 +77385,7 @@ async function handleCwdChange(msg, socket, runtime) {
     }
     const resolvedPath = path22.isAbsolute(requestedPath) ? requestedPath : path22.resolve(currentWorkingDirectory, requestedPath);
     const normalizedPath = await realpath3(resolvedPath);
-    const stats = await stat3(normalizedPath);
+    const stats = await stat4(normalizedPath);
     if (!stats.isDirectory()) {
       throw new Error(`Not a directory: ${normalizedPath}`);
     }
@@ -77508,6 +77730,24 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       scheduleQueuePump(scopedRuntime, socket, opts, processQueuedTurn);
       return;
     }
+    if (isSearchFilesCommand(parsed)) {
+      (async () => {
+        await ensureFileIndex2();
+        const files = searchFileIndex({
+          searchDir: ".",
+          pattern: parsed.query,
+          deep: true,
+          maxResults: parsed.max_results ?? 5
+        });
+        socket.send(JSON.stringify({
+          type: "search_files_response",
+          request_id: parsed.request_id,
+          files,
+          success: true
+        }));
+      })();
+      return;
+    }
     if (parsed.type === "terminal_spawn") {
       handleTerminalSpawn(parsed, socket, runtime.bootWorkingDirectory);
       return;
@@ -77741,6 +77981,7 @@ function createLegacyTestRuntime() {
 }
 var __listenClientTestUtils;
 var init_client4 = __esm(async () => {
+  init_fileIndex();
   init_planName();
   init_constants();
   init_queueRuntime();
@@ -77855,7 +78096,7 @@ __export(exports_skills2, {
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
 import { existsSync as existsSync20 } from "node:fs";
-import { readdir as readdir6, readFile as readFile6, realpath as realpath4, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile6, realpath as realpath4, stat as stat5 } from "node:fs/promises";
 import { dirname as dirname10, join as join27 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
@@ -77952,7 +78193,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
-          const entryStat = await stat4(fullPath);
+          const entryStat = await stat5(fullPath);
           isDirectory = entryStat.isDirectory();
           isFile = entryStat.isFile();
         }
@@ -78389,7 +78630,7 @@ __export(exports_auto_update, {
 });
 import { execFile as execFile10 } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
-import { readdir as readdir7, rm } from "node:fs/promises";
+import { readdir as readdir7, rm as rm2 } from "node:fs/promises";
 import { join as join28 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 function debugLog3(...args) {
@@ -78557,7 +78798,7 @@ async function cleanupOrphanedDirs(globalPath) {
       if (entry.startsWith(".letta-code-")) {
         const orphanPath = join28(lettaAiDir, entry);
         debugLog3("Cleaning orphaned temp directory:", orphanPath);
-        await rm(orphanPath, { recursive: true, force: true });
+        await rm2(orphanPath, { recursive: true, force: true });
       }
     }
   } catch {}
@@ -80477,7 +80718,6 @@ async function handleHeadlessCommand(parsedArgs, model, skillsDirectoryOverride,
   if (values.resume) {
     console.error(`Error: --resume is for interactive mode only (opens conversation selector).
 In headless mode, use:
-  --continue           Resume the last session (agent + conversation)
   --conversation <id>  Resume a specific conversation by ID`);
     process.exit(1);
   }
@@ -80487,7 +80727,6 @@ In headless mode, use:
   let specifiedAgentId = values.agent;
   const specifiedAgentName = values.name;
   let specifiedConversationId = values.conversation;
-  const shouldContinue = values.continue;
   const forceNew = values["new-agent"];
   const systemPromptPreset = values.system;
   const systemCustom = values["system-custom"];
@@ -80580,10 +80819,6 @@ In headless mode, use:
       console.error("Error: --from-agent requires --agent <id> or --conversation <id>.");
       process.exit(1);
     }
-    if (shouldContinue) {
-      console.error("Error: --from-agent cannot be used with --continue");
-      process.exit(1);
-    }
     if (forceNew) {
       console.error("Error: --from-agent cannot be used with --new-agent");
       process.exit(1);
@@ -80611,20 +80846,12 @@ In headless mode, use:
         {
           when: fromAfFile,
           message: "--conversation cannot be used with --import"
-        },
-        {
-          when: shouldContinue,
-          message: "--conversation cannot be used with --continue"
         }
       ]
     });
     validateFlagConflicts2({
       guard: forceNewConversation,
       checks: [
-        {
-          when: shouldContinue,
-          message: "--new cannot be used with --continue"
-        },
         {
           when: specifiedConversationId,
           message: "--new cannot be used with --conversation"
@@ -80649,10 +80876,6 @@ In headless mode, use:
             when: specifiedAgentName,
             message: "--import cannot be used with --name"
           },
-          {
-            when: shouldContinue,
-            message: "--import cannot be used with --continue"
-          },
           {
             when: forceNew,
             message: "--import cannot be used with --new-agent"
@@ -80827,11 +81050,6 @@ In headless mode, use:
       } catch (_error) {}
     }
   }
-  if (!agent && shouldContinue) {
-    console.error("No recent session found in .letta/ or ~/.letta.");
-    console.error("Run 'letta' to get started.");
-    process.exit(1);
-  }
   if (!agent) {
     const { ensureDefaultAgents: ensureDefaultAgents2 } = await init_defaults().then(() => exports_defaults);
     const defaultAgent = await ensureDefaultAgents2(client, {
@@ -80846,7 +81064,7 @@ In headless mode, use:
     process.exit(1);
   }
   markMilestone("HEADLESS_AGENT_RESOLVED");
-  const isResumingAgent = !!(specifiedAgentId || shouldContinue || !forceNew && !fromAfFile);
+  const isResumingAgent = !!(specifiedAgentId || !forceNew && !fromAfFile);
   if (isResumingAgent) {
     if (model) {
       const modelHandle = resolveModel2(model);
@@ -80972,28 +81190,6 @@ In headless mode, use:
         process.exit(1);
       }
     }
-  } else if (shouldContinue) {
-    await settingsManager.loadLocalProjectSettings();
-    const lastSession = settingsManager.getLocalLastSession(process.cwd()) ?? settingsManager.getGlobalLastSession();
-    if (lastSession && lastSession.agentId === agent.id) {
-      if (lastSession.conversationId === "default") {
-        conversationId = "default";
-      } else {
-        try {
-          debugLog("conversations", `retrieve(${lastSession.conversationId}) [headless lastSession resume]`);
-          await client.conversations.retrieve(lastSession.conversationId);
-          conversationId = lastSession.conversationId;
-        } catch {
-          console.error(`Attempting to resume conversation ${lastSession.conversationId}, but conversation was not found.`);
-          console.error("Resume the default conversation with 'letta -p ...', view recent conversations with 'letta --resume', or start a new conversation with 'letta -p ... --new'.");
-          process.exit(1);
-        }
-      }
-    } else {
-      console.error("No previous session found for this agent to resume.");
-      console.error("Resume the default conversation with 'letta -p ...', or start a new conversation with 'letta -p ... --new'.");
-      process.exit(1);
-    }
   } else if (forceNewConversation) {
     const conversation = await client.conversations.create({
       agent_id: agent.id,
@@ -103516,7 +103712,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 {
@@ -103632,20 +103830,6 @@ function ConversationSelector2({
         children: "⎿  "
       }, undefined, false, undefined, this);
       const indent = "   ";
-      if (conv.summary) {
-        return /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(Box_default, {
-          flexDirection: "row",
-          marginLeft: 2,
-          children: [
-            bracket,
-            /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(Text2, {
-              dimColor: true,
-              italic: true,
-              children: conv.summary.length > 57 ? `${conv.summary.slice(0, 54)}...` : conv.summary
-            }, undefined, false, undefined, this)
-          ]
-        }, undefined, true, undefined, this);
-      }
       if (previewLines.length > 0) {
         return /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(jsx_dev_runtime34.Fragment, {
           children: previewLines.map((line, idx) => /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(Box_default, {
@@ -103718,9 +103902,9 @@ function ConversationSelector2({
             /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(Text2, {
               bold: isSelected,
               color: isSelected ? colors.selector.itemHighlighted : undefined,
-              children: isDefault ? "default" : conv.id
+              children: conv.summary ? `${conv.summary.length > 40 ? `${conv.summary.slice(0, 37)}...` : conv.summary} (${conv.id})` : isDefault ? "default" : conv.id
             }, undefined, false, undefined, this),
-            isDefault && /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(Text2, {
+            !conv.summary && isDefault && /* @__PURE__ */ jsx_dev_runtime34.jsxDEV(Text2, {
               dimColor: true,
               children: " (agent's default conversation)"
             }, undefined, false, undefined, this),
@@ -116374,7 +116558,7 @@ function MessageSearch({
   const [searchInput, setSearchInput] = import_react79.useState(initialQuery ?? "");
   const [activeQuery, setActiveQuery] = import_react79.useState(initialQuery ?? "");
   const [searchMode, setSearchMode] = import_react79.useState("hybrid");
-  const [searchRange, setSearchRange] = import_react79.useState("all");
+  const [searchRange, setSearchRange] = import_react79.useState("agent");
   const [results, setResults] = import_react79.useState([]);
   const [loading, setLoading] = import_react79.useState(false);
   const [error, setError] = import_react79.useState(null);
@@ -129917,8 +130101,10 @@ Type your task to begin the loop.`, true);
         }
         return { submitted: true };
       }
-      if (msg.trim() === "/new") {
-        const cmd = commandRunner.start(msg.trim(), "Starting new conversation...");
+      const newMatch = msg.trim().match(/^\/new(?:\s+(.+))?$/);
+      if (newMatch) {
+        const conversationName = newMatch[1]?.trim();
+        const cmd = commandRunner.start(msg.trim(), conversationName ? `Starting new conversation: ${conversationName}...` : "Starting new conversation...");
         resetPendingReasoningCycle();
         setCommandRunning(true);
         await runEndHooks();
@@ -129926,8 +130112,12 @@ Type your task to begin the loop.`, true);
           const client = await getClient2();
           const conversation = await client.conversations.create({
             agent_id: agentId,
-            isolated_block_labels: [...ISOLATED_BLOCK_LABELS]
+            isolated_block_labels: [...ISOLATED_BLOCK_LABELS],
+            ...conversationName && { summary: conversationName }
           });
+          if (conversationName) {
+            hasSetConversationSummaryRef.current = true;
+          }
           await maybeCarryOverActiveConversationModel(conversation.id);
           setConversationId3(conversation.id);
           pendingConversationSwitchRef.current = {
@@ -133700,6 +133890,9 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                         summary: selectorContext?.summary,
                         messageHistory: resumeData.messageHistory
                       };
+                      if (selectorContext?.summary) {
+                        hasSetConversationSummaryRef.current = true;
+                      }
                       settingsManager.setLocalLastSession({ agentId, conversationId: convId }, process.cwd());
                       settingsManager.setGlobalLastSession({
                         agentId,
@@ -134702,7 +134895,7 @@ var init_release_notes = __esm(async () => {
 → Read more: https://docs.letta.com/letta-code/changelog#0134`,
     "0.13.0": `\uD83C\uDF81 **Letta Code 0.13.0: Introducing Conversations!**
 → Letta Code now starts a new conversation on each startup (memory is shared across all conversations)
-→ Use **/resume** to switch conversations, or run **letta --continue** to continue an existing conversation
+→ Use **/resume** to switch conversations, or run **letta --conv <id>** to continue a specific conversation
 → Read more: https://docs.letta.com/letta-code/changelog#0130`
   };
 });
@@ -135252,6 +135445,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 +135476,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 +135511,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 +135661,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 {
@@ -136224,13 +136480,6 @@ var CLI_FLAG_CATALOG = {
     mode: "both",
     help: { description: "Show current directory, skills, and pinned agents" }
   },
-  continue: {
-    parser: { type: "boolean", short: "c" },
-    mode: "both",
-    help: {
-      description: "Resume last session (agent + conversation) directly"
-    }
-  },
   resume: {
     parser: { type: "boolean", short: "r" },
     mode: "interactive",
@@ -136662,7 +136911,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 {
@@ -136778,20 +137029,6 @@ function ConversationSelector({
         children: "⎿  "
       }, undefined, false, undefined, this);
       const indent = "   ";
-      if (conv.summary) {
-        return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
-          flexDirection: "row",
-          marginLeft: 2,
-          children: [
-            bracket,
-            /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text2, {
-              dimColor: true,
-              italic: true,
-              children: conv.summary.length > 57 ? `${conv.summary.slice(0, 54)}...` : conv.summary
-            }, undefined, false, undefined, this)
-          ]
-        }, undefined, true, undefined, this);
-      }
       if (previewLines.length > 0) {
         return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(jsx_dev_runtime4.Fragment, {
           children: previewLines.map((line, idx) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
@@ -136864,9 +137101,9 @@ function ConversationSelector({
             /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text2, {
               bold: isSelected,
               color: isSelected ? colors.selector.itemHighlighted : undefined,
-              children: isDefault ? "default" : conv.id
+              children: conv.summary ? `${conv.summary.length > 40 ? `${conv.summary.slice(0, 37)}...` : conv.summary} (${conv.id})` : isDefault ? "default" : conv.id
             }, undefined, false, undefined, this),
-            isDefault && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text2, {
+            !conv.summary && isDefault && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text2, {
               dimColor: true,
               children: " (agent's default conversation)"
             }, undefined, false, undefined, this),
@@ -139426,8 +139663,8 @@ async function listBackups(agentId) {
     const path23 = join23(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat4 = statSync5(path23);
-      createdAt = stat4.mtime.toISOString();
+      const stat5 = statSync5(path23);
+      createdAt = stat5.mtime.toISOString();
     } catch {
       createdAt = null;
     }
@@ -139535,8 +139772,8 @@ async function runMemfsSubcommand(argv) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat4 = statSync5(backupPath);
-      if (!stat4.isDirectory()) {
+      const stat5 = statSync5(backupPath);
+      if (!stat5.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
       }
@@ -139558,8 +139795,8 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       if (existsSync18(out)) {
-        const stat4 = statSync5(out);
-        if (stat4.isDirectory()) {
+        const stat5 = statSync5(out);
+        if (stat5.isDirectory()) {
           const contents = await readdir5(out);
           if (contents.length > 0) {
             console.error(`Export directory not empty: ${out}`);
@@ -141763,9 +142000,8 @@ Letta Code is a general purpose CLI for interacting with Letta agents
 
 USAGE
   # interactive TUI
-  letta                 Resume default conversation (OG single-threaded experience)
+  letta                 Resume last conversation for this project
   letta --new           Create a new conversation (for concurrent sessions)
-  letta --continue      Resume last session (agent + conversation) directly
   letta --resume        Open agent selector UI to pick agent/conversation
   letta --new-agent     Create a new agent directly (skip profile selector)
   letta --agent <id>    Open a specific agent by ID
@@ -142034,7 +142270,6 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     console.log(result.message);
     process.exit(result.success ? 0 : 1);
   }
-  const shouldContinue = values.continue ?? false;
   const shouldResume = values.resume ?? false;
   let specifiedConversationId = values.conversation ?? null;
   const forceNew = values["new-agent"] ?? false;
@@ -142169,20 +142404,12 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
         {
           when: shouldResume,
           message: "--conversation cannot be used with --resume"
-        },
-        {
-          when: shouldContinue,
-          message: "--conversation cannot be used with --continue"
         }
       ]
     });
     validateFlagConflicts({
       guard: forceNewConversation,
       checks: [
-        {
-          when: shouldContinue,
-          message: "--new cannot be used with --continue"
-        },
         {
           when: specifiedConversationId,
           message: "--new cannot be used with --conversation"
@@ -142373,7 +142600,6 @@ Error: ${message}`);
   const AppModule = await init_App2().then(() => exports_App);
   const App3 = AppModule.default;
   function LoadingApp({
-    continueSession,
     forceNew: forceNew2,
     initBlocks: initBlocks2,
     baseTools: baseTools2,
@@ -142527,8 +142753,8 @@ Error: ${message}`);
           }
         }
         if (shouldResume) {
-          const localSession = settingsManager2.getLocalLastSession(process.cwd());
-          const localAgentId2 = localSession?.agentId ?? localSettings.lastAgent;
+          const localSession2 = settingsManager2.getLocalLastSession(process.cwd());
+          const localAgentId2 = localSession2?.agentId ?? localSettings.lastAgent;
           if (localAgentId2) {
             try {
               const agent = await client.agents.retrieve(localAgentId2);
@@ -142555,41 +142781,6 @@ Error: ${message}`);
           console.error("Run 'letta' to get started.");
           process.exit(1);
         }
-        if (continueSession) {
-          const localSession = settingsManager2.getLocalLastSession(process.cwd());
-          const localAgentId2 = localSession?.agentId ?? localSettings.lastAgent;
-          if (localAgentId2) {
-            try {
-              await client.agents.retrieve(localAgentId2);
-              setSelectedGlobalAgentId(localAgentId2);
-              if (localSession?.conversationId) {
-                setSelectedConversationId(localSession.conversationId);
-              }
-              setLoadingState("assembling");
-              return;
-            } catch {
-              setFailedAgentMessage(`Unable to locate agent ${localAgentId2} in .letta/, checking global (~/.letta)`);
-            }
-          } else {
-            console.log("No recent agent in .letta/, using global (~/.letta)");
-          }
-          const globalSession = settingsManager2.getGlobalLastSession();
-          const globalAgentId2 = globalSession?.agentId;
-          if (globalAgentId2) {
-            try {
-              await client.agents.retrieve(globalAgentId2);
-              setSelectedGlobalAgentId(globalAgentId2);
-              if (globalSession?.conversationId) {
-                setSelectedConversationId(globalSession.conversationId);
-              }
-              setLoadingState("assembling");
-              return;
-            } catch {}
-          }
-          console.error("No recent session found in .letta/ or ~/.letta.");
-          console.error("Run 'letta' to get started.");
-          process.exit(1);
-        }
         if (forceNew2 || agentIdArg || fromAfFile2) {
           setLoadingState("assembling");
           return;
@@ -142617,9 +142808,10 @@ Error: ${message}`);
         }
         const mergedPinned = settingsManager2.getMergedPinnedAgents(process.cwd());
         const { resolveStartupTarget: resolveStartupTarget2 } = await Promise.resolve().then(() => exports_resolve_startup_agent);
+        const localSession = settingsManager2.getLocalLastSession(process.cwd());
         const target = resolveStartupTarget2({
           localAgentId,
-          localConversationId: null,
+          localConversationId: localSession?.conversationId ?? null,
           localAgentExists,
           globalAgentId,
           globalAgentExists,
@@ -142633,6 +142825,9 @@ Error: ${message}`);
             if (cachedAgent && cachedAgent.id === target.agentId) {
               setValidatedAgent(cachedAgent);
             }
+            if (target.conversationId && !forceNewConversation) {
+              setSelectedConversationId(target.conversationId);
+            }
             setLoadingState("assembling");
             return;
           case "select":
@@ -142663,7 +142858,6 @@ Error: ${message}`);
       forceNew2,
       agentIdArg,
       fromAfFile2,
-      continueSession,
       shouldResume,
       specifiedConversationId
     ]);
@@ -142703,15 +142897,6 @@ Error: ${message}`);
               return;
             }
           }
-          if (!resumingAgentId && continueSession && settings.lastAgent) {
-            try {
-              await client.agents.retrieve(settings.lastAgent);
-              resumingAgentId = settings.lastAgent;
-            } catch {
-              setLoadingState("selecting_global");
-              return;
-            }
-          }
         }
         setIsResumingSession(!!resumingAgentId);
         const modelForTools = getModelForToolLoading(model, toolset);
@@ -142817,15 +143002,6 @@ Error: ${message}`);
             return;
           }
         }
-        if (!agent && continueSession && settings.lastAgent) {
-          try {
-            agent = await client.agents.retrieve(settings.lastAgent);
-          } catch (error) {
-            console.error(`Previous agent ${settings.lastAgent} not found (error: ${JSON.stringify(error)})`);
-            setLoadingState("selecting_global");
-            return;
-          }
-        }
         if (!agent) {
           console.error("No agent found. Use --new-agent to create a new agent.");
           process.exit(1);
@@ -142846,7 +143022,7 @@ Error: ${message}`);
         }));
         const isResumingProject = !shouldCreateNew && !!resumingAgentId;
         const isReusingExistingAgent = !shouldCreateNew && !fromAfFile2 && agent && agent.id;
-        const resuming = !!(continueSession || agentIdArg || isResumingProject || isReusingExistingAgent);
+        const resuming = !!(agentIdArg || isResumingProject || isReusingExistingAgent);
         setIsResumingSession(resuming);
         if (resuming) {
           if (model) {
@@ -142895,7 +143071,6 @@ Error: ${message}`);
         });
         let conversationIdToUse;
         if (isDebugEnabled2()) {
-          debugLog2("startup", "shouldContinue=%o", shouldContinue);
           debugLog2("startup", "shouldResume=%o", shouldResume);
           debugLog2("startup", "specifiedConversationId=%s", specifiedConversationId);
         }
@@ -142913,34 +143088,6 @@ Error: ${message}`);
             }
             throw error;
           }
-        } else if (shouldContinue) {
-          const lastSession = settingsManager2.getLocalLastSession(process.cwd()) ?? settingsManager2.getGlobalLastSession();
-          if (isDebugEnabled2()) {
-            debugLog2("startup", "lastSession=%s", JSON.stringify(lastSession));
-            debugLog2("startup", "agent.id=%s", agent.id);
-          }
-          let resumedSuccessfully = false;
-          if (lastSession && lastSession.agentId === agent.id) {
-            try {
-              setLoadingState("checking");
-              const data = await getResumeData(client, agent, lastSession.conversationId);
-              conversationIdToUse = lastSession.conversationId;
-              setResumedExistingConversation(true);
-              setResumeData(data);
-              resumedSuccessfully = true;
-            } catch (error) {
-              if (error instanceof APIError && (error.status === 404 || error.status === 422)) {
-                console.warn(`Previous conversation ${lastSession.conversationId} not found, creating new`);
-              } else {
-                throw error;
-              }
-            }
-          }
-          if (!resumedSuccessfully) {
-            console.error(`Attempting to resume conversation ${lastSession?.conversationId ?? "(unknown)"}, but conversation was not found.`);
-            console.error("Resume the default conversation with 'letta', view recent conversations with 'letta --resume', or start a new conversation with 'letta --new'.");
-            process.exit(1);
-          }
         } else if (selectedConversationId) {
           try {
             setLoadingState("checking");
@@ -142950,10 +143097,15 @@ Error: ${message}`);
             setResumeData(data);
           } catch (error) {
             if (error instanceof APIError && (error.status === 404 || error.status === 422)) {
-              console.error(`Conversation ${selectedConversationId} not found`);
-              process.exit(1);
+              console.warn(`Previous conversation ${selectedConversationId} not found, falling back to default`);
+              conversationIdToUse = "default";
+              setLoadingState("checking");
+              const data = await getResumeData(client, agent, "default");
+              setResumeData(data);
+              setResumedExistingConversation(data.messageHistory.length > 0);
+            } else {
+              throw error;
             }
-            throw error;
           }
         } else if (forceNewConversation) {
           const conversation = await client.conversations.create({
@@ -143024,7 +143176,6 @@ Error during initialization: ${message}`);
         process.exit(1);
       });
     }, [
-      continueSession,
       forceNew2,
       userRequestedNewAgent,
       agentIdArg,
@@ -143034,7 +143185,6 @@ Error during initialization: ${message}`);
       loadingState,
       selectedGlobalAgentId,
       validatedAgent,
-      shouldContinue,
       resumeAgentId,
       selectedConversationId
     ]);
@@ -143135,7 +143285,6 @@ Error during initialization: ${message}`);
   }
   markMilestone2("REACT_RENDER_START");
   render2(React14.createElement(LoadingApp, {
-    continueSession: shouldContinue,
     forceNew,
     initBlocks,
     baseTools,
@@ -143152,4 +143301,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=D1C8E311510A3C4964756E2164756E21
+//# debugId=370E7E3EE35E2CB664756E2164756E21