@letta-ai/letta-code 0.24.3 → 0.24.5

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.24.3",
+    version: "0.24.5",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -4721,6 +4721,7 @@ var init_timing = __esm(() => {
 // src/agent/client.ts
 var exports_client = {};
 __export(exports_client, {
+  isDesktopLocalProxyUrl: () => isDesktopLocalProxyUrl,
   getServerUrl: () => getServerUrl,
   getMemfsServerUrl: () => getMemfsServerUrl,
   getClient: () => getClient,
@@ -4774,12 +4775,33 @@ function getServerUrl() {
   const settings = settingsManager.getSettings();
   return process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
 }
+function isLocalhostUrl(value) {
+  if (!value)
+    return false;
+  try {
+    const parsed = new URL(value);
+    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+function isDesktopLocalProxyUrl(value) {
+  return process.env.LETTA_DESKTOP_DEBUG_PANEL === "1" && isLocalhostUrl(value);
+}
 function getMemfsServerUrl() {
   let settings = null;
   try {
     settings = settingsManager.getSettings();
   } catch {}
-  return process.env.LETTA_MEMFS_BASE_URL || settings?.env?.LETTA_MEMFS_BASE_URL || LETTA_CLOUD_API_URL;
+  const configuredMemfsUrl = process.env.LETTA_MEMFS_BASE_URL || settings?.env?.LETTA_MEMFS_BASE_URL;
+  if (configuredMemfsUrl) {
+    return configuredMemfsUrl;
+  }
+  const apiUrl = process.env.LETTA_BASE_URL || settings?.env?.LETTA_BASE_URL;
+  if (apiUrl && isDesktopLocalProxyUrl(apiUrl)) {
+    return apiUrl;
+  }
+  return LETTA_CLOUD_API_URL;
 }
 async function getClient() {
   if (_testClientOverride) {
@@ -7128,6 +7150,13 @@ If worktree creation fails (locked index), retry up to 3 times with backoff (sle
 ### 2. Read existing memory
 Read the memory files in your worktree, to understand what already exists in the memory filesystem.
 
+Before adding or expanding \`system/\` memory, measure its current token footprint:
+\`\`\`bash
+letta memory tokens --format json --quiet --memory-dir "$WORKTREE_DIR/$BRANCH_NAME"
+\`\`\`
+
+This command is memory-mode safe. Treat it as measurement only: use the reported \`total_tokens\` and per-file breakdown to decide whether new findings belong in \`system/\` or external memory. Do not use custom token-counting scripts, \`npx\`, \`awk\`, or \`find -exec wc\` for this.
+
 ### 3. Read and analyze history
 
 Your prompt will specify a pre-split JSONL chunk file and its source format. Use these patterns to read it:
@@ -7765,6 +7794,11 @@ You can create, delete, or modify files — including their contents, names, and
 - Why did the agent make the mistakes it did? What was missing from context?
 - Why did the user have to make corrections?
 - Does anything in memory contradict the observed conversation history, or need updating?
+- Check the current size of \`system/\` before adding or expanding in-context memory:
+  \`\`\`bash
+  letta memory tokens --format json --quiet
+  \`\`\`
+  This command is memory-mode safe. Treat it as measurement only: decide whether a size is concerning based on the actual context and the value of the proposed change. Prefer adding durable detail to external memory unless the information is important enough to stay in-context.
 
 ### Step 4: Update memory files (if needed)
 
@@ -9669,6 +9703,17 @@ var init_models2 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "deepseek-v4-pro",
+        handle: "openrouter/deepseek/deepseek-v4-pro",
+        label: "DeepSeek V4 Pro",
+        description: "DeepSeek's V4 Pro model",
+        updateArgs: {
+          context_window: 1048576,
+          max_output_tokens: 384000,
+          parallel_tool_calls: true
+        }
+      },
       {
         id: "glm-5.1",
         handle: "zai/glm-5.1",
@@ -38513,6 +38558,8 @@ __export(exports_memoryGit, {
   ensureLocalMemfsGitConfig: () => ensureLocalMemfsGitConfig,
   commitAndSyncMemoryWrite: () => commitAndSyncMemoryWrite,
   cloneMemoryRepo: () => cloneMemoryRepo,
+  buildNonInteractiveGitEnv: () => buildNonInteractiveGitEnv,
+  buildGitAuthArgs: () => buildGitAuthArgs,
   assertMemoryRepoReadyForWrite: () => assertMemoryRepoReadyForWrite,
   addGitMemoryTag: () => addGitMemoryTag,
   PRE_COMMIT_HOOK_SCRIPT: () => PRE_COMMIT_HOOK_SCRIPT,
@@ -38622,11 +38669,27 @@ async function getAuthToken() {
   const client = await getClient();
   return client._options?.apiKey ?? "";
 }
-async function runGit(cwd2, args, token) {
-  const authArgs = token ? [
+function buildGitAuthArgs(token) {
+  return [
+    "-c",
+    "credential.helper=",
+    "-c",
+    "core.askPass=",
     "-c",
     `http.extraHeader=Authorization: Basic ${Buffer.from(`letta:${token}`).toString("base64")}`
-  ] : [];
+  ];
+}
+function buildNonInteractiveGitEnv(env3 = process.env) {
+  return {
+    ...env3,
+    GIT_TERMINAL_PROMPT: "0",
+    GCM_INTERACTIVE: "never",
+    GIT_ASKPASS: "",
+    SSH_ASKPASS: ""
+  };
+}
+async function runGit(cwd2, args, token) {
+  const authArgs = token ? buildGitAuthArgs(token) : [];
   const allArgs = [...authArgs, ...args];
   let loggableArgs = args;
   if (args[0] === "config" && typeof args[1] === "string" && args[1].includes("credential") && args[1].includes(".helper")) {
@@ -38637,6 +38700,7 @@ async function runGit(cwd2, args, token) {
   debugLog("memfs-git", `git ${loggableArgs.join(" ")} (in ${cwd2})`);
   const result = await execFile("git", allArgs, {
     cwd: cwd2,
+    env: buildNonInteractiveGitEnv(),
     maxBuffer: 10 * 1024 * 1024,
     timeout: 60000
   });
@@ -47319,13 +47383,25 @@ function pushUnique(list, seen, entry) {
   seen.add(key);
   list.push(entry);
 }
+function normalizePowerShellCommand(command) {
+  const trimmed = command.trim();
+  if (trimmed.startsWith("&") || trimmed.startsWith('"') || trimmed.startsWith("'")) {
+    return trimmed.startsWith("&") ? trimmed : `& ${trimmed}`;
+  }
+  return trimmed;
+}
+function buildPowerShellCommand(command) {
+  const powerShellCommand = normalizePowerShellCommand(command);
+  const aliasPrelude = POWERSHELL_ENV_ALIASES.map((name) => `$${name} = $env:${name}`).join("; ");
+  return `${aliasPrelude}; ${powerShellCommand}`;
+}
 function windowsLaunchers(command) {
   const trimmed = command.trim();
   if (!trimmed)
     return [];
   const launchers = [];
   const seen = new Set;
-  const powerShellCommand = trimmed.startsWith("&") || trimmed.startsWith('"') || trimmed.startsWith("'") ? trimmed.startsWith("&") ? trimmed : `& ${trimmed}` : trimmed;
+  const powerShellCommand = buildPowerShellCommand(trimmed);
   pushUnique(launchers, seen, [
     "powershell.exe",
     "-NoProfile",
@@ -47407,7 +47483,19 @@ function buildShellLaunchers(command, options) {
   const login = options?.login ?? false;
   return process.platform === "win32" ? windowsLaunchers(command) : unixLaunchers(command, login);
 }
-var SEP2 = "\x00";
+var SEP2 = "\x00", POWERSHELL_ENV_ALIASES;
+var init_shellLaunchers = __esm(() => {
+  POWERSHELL_ENV_ALIASES = [
+    "MEMORY_DIR",
+    "LETTA_MEMORY_DIR",
+    "AGENT_ID",
+    "LETTA_AGENT_ID",
+    "LETTA_PARENT_AGENT_ID",
+    "CONVERSATION_ID",
+    "LETTA_CONVERSATION_ID",
+    "USER_CWD"
+  ];
+});
 
 // src/hooks/types.ts
 function supportsPromptHooks(event) {
@@ -47863,6 +47951,7 @@ async function executeHooksParallel(hooks, input, workingDirectory = process.cwd
 }
 var DEFAULT_TIMEOUT_MS = 60000;
 var init_executor = __esm(() => {
+  init_shellLaunchers();
   init_prompt_executor();
   init_types2();
 });
@@ -48895,6 +48984,7 @@ __export(exports_memoryFilesystem, {
   renderMemoryFilesystemTree: () => renderMemoryFilesystemTree,
   labelFromRelativePath: () => labelFromRelativePath,
   isMemfsEnabledOnServer: () => isMemfsEnabledOnServer,
+  isLettaMemfsServer: () => isLettaMemfsServer,
   isLettaCloud: () => isLettaCloud,
   getMemorySystemDir: () => getMemorySystemDir,
   getMemoryFilesystemRoot: () => getMemoryFilesystemRoot,
@@ -49082,8 +49172,8 @@ function renderMemoryFilesystemTree(systemLabels, detachedLabels, options = {})
 }
 async function applyMemfsFlags(agentId, memfsFlag, noMemfsFlag, options) {
   const { settingsManager: settingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), exports_settings_manager));
-  if (memfsFlag && !await isLettaCloud()) {
-    throw new Error("--memfs is only available on Letta Cloud (api.letta.com).");
+  if (memfsFlag && !await isLettaMemfsServer()) {
+    throw new Error(await getMemfsSyncUnavailableMessage());
   }
   const hasExplicitToggle = Boolean(memfsFlag || noMemfsFlag);
   const localMemfsEnabled = settingsManager2.isMemfsEnabled(agentId);
@@ -49154,6 +49244,24 @@ async function isLettaCloud() {
   const serverUrl = getServerUrl2();
   return serverUrl.includes("api.letta.com") || process.env.LETTA_MEMFS_LOCAL === "1" || process.env.LETTA_API_KEY === "local-desktop";
 }
+function getServerHostLabel(serverUrl) {
+  const trimmed = serverUrl.trim();
+  try {
+    return new URL(trimmed).host || trimmed;
+  } catch {
+    return trimmed.replace(/^https?:\/\//, "").replace(/\/+$/, "") || trimmed;
+  }
+}
+async function isLettaMemfsServer() {
+  const { getMemfsServerUrl: getMemfsServerUrl2, isDesktopLocalProxyUrl: isDesktopLocalProxyUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const memfsServerUrl = getMemfsServerUrl2();
+  return memfsServerUrl.includes("api.letta.com") || isDesktopLocalProxyUrl2(memfsServerUrl) || process.env.LETTA_MEMFS_LOCAL === "1" || process.env.LETTA_API_KEY === "local-desktop";
+}
+async function getMemfsSyncUnavailableMessage() {
+  const { getMemfsServerUrl: getMemfsServerUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const memfsServerUrl = getMemfsServerUrl2();
+  return `MemFS sync failed (expected api.letta.com, got ${getServerHostLabel(memfsServerUrl)})`;
+}
 async function enableMemfsIfCloud(agentId) {
   if (!await isLettaCloud())
     return;
@@ -54922,13 +55030,19 @@ function validateWorktreePath(command, cwd2) {
   }
   return null;
 }
+function rebuildCachedLauncher(command) {
+  if (!cachedWorkingLauncher)
+    return null;
+  const cachedExecutable = cachedWorkingLauncher[0]?.toLowerCase();
+  if (!cachedExecutable)
+    return null;
+  const launchers = buildShellLaunchers(command);
+  return launchers.find((launcher) => launcher[0]?.toLowerCase() === cachedExecutable) ?? null;
+}
 function getBackgroundLauncher(command) {
-  if (cachedWorkingLauncher) {
-    const [executable, ...launcherArgs] = cachedWorkingLauncher;
-    if (executable) {
-      return [executable, ...launcherArgs.slice(0, -1), command];
-    }
-  }
+  const cachedLauncher = rebuildCachedLauncher(command);
+  if (cachedLauncher)
+    return cachedLauncher;
   const launchers = buildShellLaunchers(command);
   return launchers[0] || [];
 }
@@ -54944,9 +55058,8 @@ async function spawnCommand(command, options) {
     });
   }
   if (cachedWorkingLauncher) {
-    const [executable, ...launcherArgs] = cachedWorkingLauncher;
-    if (executable) {
-      const newLauncher = [executable, ...launcherArgs.slice(0, -1), command];
+    const newLauncher = rebuildCachedLauncher(command);
+    if (newLauncher) {
       try {
         const result = await spawnWithLauncher(newLauncher, {
           cwd: options.cwd,
@@ -55195,6 +55308,7 @@ var init_Bash2 = __esm(() => {
   init_worktree_ownership();
   init_process_manager();
   init_shellEnv();
+  init_shellLaunchers();
   init_shellRunner();
   init_truncation();
 });
@@ -71382,6 +71496,7 @@ var DEFAULT_TIMEOUT = 120000;
 var init_Shell2 = __esm(() => {
   init_runtime_context();
   init_shellEnv();
+  init_shellLaunchers();
   init_shellRunner();
 });
 
@@ -71527,6 +71642,7 @@ var init_ShellCommand2 = __esm(() => {
   init_context();
   init_readOnlyShell();
   init_Shell2();
+  init_shellLaunchers();
   init_shellRunner();
   init_truncation();
 });
@@ -87563,6 +87679,60 @@ class StreamProcessor {
 }
 
 // src/cli/helpers/stream.ts
+function summarizeStreamForDebug(stream2) {
+  if (!stream2 || typeof stream2 !== "object") {
+    return `type=${typeof stream2}`;
+  }
+  const record = stream2;
+  const ctor = stream2.constructor?.name;
+  const controller = record.controller && typeof record.controller === "object" ? record.controller : null;
+  const keys = Object.keys(record).slice(0, 8);
+  return [
+    `ctor=${ctor ?? "unknown"}`,
+    `asyncIterator=${typeof record[Symbol.asyncIterator]}`,
+    `controller=${typeof record.controller}`,
+    `controllerAbort=${typeof controller?.abort}`,
+    `controllerSignal=${typeof controller?.signal}`,
+    keys.length > 0 ? `keys=${keys.join(",")}` : "keys=(none)"
+  ].join(" ");
+}
+function summarizeChunkForDebug(chunk) {
+  if (!chunk) {
+    return "none";
+  }
+  const record = chunk;
+  const parts = [`message_type=${chunk.message_type ?? "unknown"}`];
+  for (const key of ["run_id", "seq_id", "id", "otid", "tool_call_id"]) {
+    const value = record[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      parts.push(`${key}=${value}`);
+    }
+  }
+  if (chunk.message_type === "stop_reason") {
+    parts.push(`stop_reason=${String(record.stop_reason ?? "unknown")}`);
+  }
+  const toolCalls = record.tool_calls;
+  if (Array.isArray(toolCalls)) {
+    parts.push(`tool_calls=${toolCalls.length}`);
+  }
+  return parts.join(" ");
+}
+function abortStreamController(stream2, reason) {
+  const controller = stream2.controller;
+  if (!controller || typeof controller !== "object") {
+    debugWarn("drainStream", "stream.controller is unavailable during %s - cannot abort HTTP request (%s)", reason, summarizeStreamForDebug(stream2));
+    return;
+  }
+  const controllerRecord = controller;
+  if (controllerRecord.signal?.aborted) {
+    return;
+  }
+  if (typeof controllerRecord.abort !== "function") {
+    debugWarn("drainStream", "stream.controller.abort is unavailable during %s - cannot abort HTTP request (%s)", reason, summarizeStreamForDebug(stream2));
+    return;
+  }
+  controllerRecord.abort();
+}
 function hasPaginatedItems(response) {
   return !Array.isArray(response) && typeof response.getPaginatedItems === "function";
 }
@@ -87640,28 +87810,26 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
   let stopReason = null;
   let hasCalledFirstMessage = false;
   let fallbackError = null;
+  let lastChunkDebugSummary = "none";
   let abortedViaListener = false;
   const startAbortGen = buffers.abortGeneration || 0;
   const abortHandler = () => {
     abortedViaListener = true;
-    if (!stream2.controller) {
-      debugWarn("drainStream", "stream.controller is undefined - cannot abort HTTP request");
-      return;
-    }
-    if (!stream2.controller.signal.aborted) {
-      stream2.controller.abort();
-    }
+    abortStreamController(stream2, "abort_signal");
   };
   if (abortSignal && !abortSignal.aborted) {
     abortSignal.addEventListener("abort", abortHandler, { once: true });
   } else if (abortSignal?.aborted) {
     abortedViaListener = true;
-    if (stream2.controller && !stream2.controller.signal.aborted) {
-      stream2.controller.abort();
-    }
+    abortStreamController(stream2, "pre_aborted_signal");
   }
   try {
+    const asyncIterator = stream2[Symbol.asyncIterator];
+    if (typeof asyncIterator !== "function") {
+      throw new TypeError(`Stream is not async iterable (${summarizeStreamForDebug(stream2)})`);
+    }
     for await (const chunk of stream2) {
+      lastChunkDebugSummary = summarizeChunkForDebug(chunk);
       recordTuiJsonPayload(`stream_chunk:${chunk.message_type ?? "unknown"}`, chunk);
       if ((buffers.abortGeneration || 0) !== startAbortGen) {
         stopReason = "cancelled";
@@ -87730,7 +87898,10 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
     const errorMessage = e instanceof Error ? e.message : String(e);
     const sdkDiagnostic = consumeLastSDKDiagnostic();
     const errorMessageWithDiagnostic = sdkDiagnostic ? `${errorMessage} [${sdkDiagnostic}]` : errorMessage;
-    debugWarn("drainStream", "Stream error caught:", errorMessage);
+    debugWarn("drainStream", "Stream error caught: %s last_chunk=%s stream=%s", errorMessageWithDiagnostic, lastChunkDebugSummary, summarizeStreamForDebug(stream2));
+    if (e instanceof Error && e.stack) {
+      debugWarn("drainStream", "Stream error stack: %s", e.stack);
+    }
     if (!streamProcessor.lastRunId && e instanceof APIError2 && e.error) {
       const errorObj = e.error;
       if ("run_id" in errorObj && typeof errorObj.run_id === "string") {
@@ -95763,7 +95934,7 @@ function isSyncCommand(value) {
     return false;
   }
   const candidate = value;
-  return candidate.type === "sync" && isRuntimeScope(candidate.runtime);
+  return candidate.type === "sync" && isRuntimeScope(candidate.runtime) && (candidate.recover_approvals === undefined || typeof candidate.recover_approvals === "boolean");
 }
 function isTerminalSpawnCommand(value) {
   if (!value || typeof value !== "object")
@@ -96444,12 +96615,14 @@ function runDetachedListenerTask(commandName, task2) {
 async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
   const syncScopedRuntime = getOrCreateScopedRuntime(listenerRuntime, scope.agent_id, scope.conversation_id);
   const recoverFn = opts?.recoverApprovalStateForSync ?? recoverApprovalStateForSync;
-  try {
-    await recoverFn(syncScopedRuntime, scope);
-  } catch (error) {
-    trackListenerError("listener_sync_recovery_failed", error, "listener_sync_recovery");
-    if (isDebugEnabled()) {
-      console.warn("[Listen] Sync approval recovery failed:", error);
+  if (opts?.recoverApprovals ?? true) {
+    try {
+      await recoverFn(syncScopedRuntime, scope);
+    } catch (error) {
+      trackListenerError("listener_sync_recovery_failed", error, "listener_sync_recovery");
+      if (isDebugEnabled()) {
+        console.warn("[Listen] Sync approval recovery failed:", error);
+      }
     }
   }
   emitStateSync(socket, listenerRuntime, scope);
@@ -98796,7 +98969,9 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           console.log(`[Listen V2] Dropping sync: runtime mismatch or closed`);
           return;
         }
-        await replaySyncStateForRuntime(runtime, socket, parsed.runtime);
+        await replaySyncStateForRuntime(runtime, socket, parsed.runtime, {
+          recoverApprovals: parsed.recover_approvals !== false
+        });
         return;
       }
       if (parsed.type === "input") {
@@ -147564,7 +147739,9 @@ function runWithLauncher(launcher, inputJson, timeout, signal, workingDirectory,
   });
 }
 var MAX_STDOUT_BYTES = 4096;
-var init_statusLineRuntime = () => {};
+var init_statusLineRuntime = __esm(() => {
+  init_shellLaunchers();
+});
 
 // src/cli/helpers/subagentAggregation.ts
 function hasInProgressTaskToolCalls(order, byId, _emittedIds) {
@@ -159073,6 +159250,7 @@ __export(exports_memoryFilesystem2, {
   renderMemoryFilesystemTree: () => renderMemoryFilesystemTree2,
   labelFromRelativePath: () => labelFromRelativePath2,
   isMemfsEnabledOnServer: () => isMemfsEnabledOnServer2,
+  isLettaMemfsServer: () => isLettaMemfsServer2,
   isLettaCloud: () => isLettaCloud2,
   getMemorySystemDir: () => getMemorySystemDir2,
   getMemoryFilesystemRoot: () => getMemoryFilesystemRoot2,
@@ -159260,8 +159438,8 @@ function renderMemoryFilesystemTree2(systemLabels, detachedLabels, options = {})
 }
 async function applyMemfsFlags2(agentId, memfsFlag, noMemfsFlag, options) {
   const { settingsManager: settingsManager3 } = await Promise.resolve().then(() => (init_settings_manager(), exports_settings_manager));
-  if (memfsFlag && !await isLettaCloud2()) {
-    throw new Error("--memfs is only available on Letta Cloud (api.letta.com).");
+  if (memfsFlag && !await isLettaMemfsServer2()) {
+    throw new Error(await getMemfsSyncUnavailableMessage2());
   }
   const hasExplicitToggle = Boolean(memfsFlag || noMemfsFlag);
   const localMemfsEnabled = settingsManager3.isMemfsEnabled(agentId);
@@ -159332,6 +159510,24 @@ async function isLettaCloud2() {
   const serverUrl = getServerUrl2();
   return serverUrl.includes("api.letta.com") || process.env.LETTA_MEMFS_LOCAL === "1" || process.env.LETTA_API_KEY === "local-desktop";
 }
+function getServerHostLabel2(serverUrl) {
+  const trimmed = serverUrl.trim();
+  try {
+    return new URL(trimmed).host || trimmed;
+  } catch {
+    return trimmed.replace(/^https?:\/\//, "").replace(/\/+$/, "") || trimmed;
+  }
+}
+async function isLettaMemfsServer2() {
+  const { getMemfsServerUrl: getMemfsServerUrl2, isDesktopLocalProxyUrl: isDesktopLocalProxyUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const memfsServerUrl = getMemfsServerUrl2();
+  return memfsServerUrl.includes("api.letta.com") || isDesktopLocalProxyUrl2(memfsServerUrl) || process.env.LETTA_MEMFS_LOCAL === "1" || process.env.LETTA_API_KEY === "local-desktop";
+}
+async function getMemfsSyncUnavailableMessage2() {
+  const { getMemfsServerUrl: getMemfsServerUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const memfsServerUrl = getMemfsServerUrl2();
+  return `MemFS sync failed (expected api.letta.com, got ${getServerHostLabel2(memfsServerUrl)})`;
+}
 async function enableMemfsIfCloud2(agentId) {
   if (!await isLettaCloud2())
     return;
@@ -168653,4 +168849,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=22CE2EBE31776A7764756E2164756E21
+//# debugId=CB5FADB2FE73B65E64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.24.3",
+  "version": "0.24.5",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {

package/skills/context_doctor/SKILL.md

@@ -24,11 +24,12 @@ Below are additional common issues with context and how they can be resolved:
 #### System prompt bloat
 Memories compiled into the system prompt (contained in `system/`) should take up about 10% of the total context size (usually ~15-20K tokens). This is a soft target, not a hard requirement.
 
-Use the following script to evaluate the token usage of the system prompt:
+Use the built-in CLI to evaluate token usage of the system prompt:
 ```bash
-npx tsx <SKILL_DIR>/scripts/estimate_system_tokens.ts --memory-dir "$MEMORY_DIR"
+letta memory tokens --format json --quiet
 ```
-Where `<SKILL_DIR>` is the Skill Directory shown when the skill was loaded (visible in the injection header).
+
+The command reports `total_tokens` and per-file estimates for `system/`. It is only a measurement tool; decide whether to intervene based on the actual context and the guidance below.
 
 **Why detail is load-bearing (read this before cutting anything)**: In-context detail does more than carry information. It does at least four things, and byte-counting sweeps only see the first:
 1. **Information** — the literal facts stated

package/skills/context_doctor/scripts/estimate_system_tokens.ts

@@ -1,128 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Estimate token usage of system prompt memory files.
- *
- * Self-contained — no imports from the letta-code source tree.
- *
- * Usage:
- *   npx tsx estimate_system_tokens.ts --memory-dir "$MEMORY_DIR"
- *   npx tsx estimate_system_tokens.ts --memory-dir ~/.letta/agents/<id>/memory
- */
-
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// Codex heuristic: ~4 bytes per token (codex-rs/core/src/truncate.rs APPROX_BYTES_PER_TOKEN = 4)
-const BYTES_PER_TOKEN = 4;
-
-function estimateTokens(text: string): number {
-  return Math.ceil(Buffer.byteLength(text, "utf8") / BYTES_PER_TOKEN);
-}
-
-type FileEstimate = {
-  path: string;
-  tokens: number;
-};
-
-type ParsedArgs = {
-  memoryDir?: string;
-  top: number;
-};
-
-function parseArgs(argv: string[]): ParsedArgs {
-  const parsed: ParsedArgs = { top: 20 };
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--memory-dir") {
-      parsed.memoryDir = argv[i + 1];
-      i++;
-      continue;
-    }
-    if (arg === "--top") {
-      const raw = argv[i + 1];
-      const value = Number.parseInt(raw ?? "", 10);
-      if (!Number.isNaN(value) && value >= 0) {
-        parsed.top = value;
-      }
-      i++;
-    }
-  }
-
-  return parsed;
-}
-
-function normalizePath(value: string): string {
-  return value.replaceAll("\\", "/");
-}
-
-function walkMarkdownFiles(dir: string): string[] {
-  if (!existsSync(dir)) {
-    return [];
-  }
-
-  const out: string[] = [];
-  const entries = readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (entry.name.startsWith(".")) {
-      continue;
-    }
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      out.push(...walkMarkdownFiles(full));
-      continue;
-    }
-    if (entry.isFile() && entry.name.endsWith(".md")) {
-      out.push(full);
-    }
-  }
-
-  return out;
-}
-
-function formatNumber(value: number): string {
-  return value.toLocaleString("en-US");
-}
-
-function main(): number {
-  const args = parseArgs(process.argv.slice(2));
-  const memoryDir = args.memoryDir || process.env.MEMORY_DIR;
-
-  if (!memoryDir) {
-    console.error("Missing memory dir. Pass --memory-dir or set MEMORY_DIR.");
-    return 1;
-  }
-
-  const systemDir = join(memoryDir, "system");
-  if (!existsSync(systemDir)) {
-    console.error(`Missing system directory: ${systemDir}`);
-    return 1;
-  }
-
-  const files = walkMarkdownFiles(systemDir).sort();
-  const rows: FileEstimate[] = [];
-
-  for (const filePath of files) {
-    const text = readFileSync(filePath, "utf8");
-    const rel = normalizePath(filePath.slice(memoryDir.length + 1));
-    rows.push({ path: rel, tokens: estimateTokens(text) });
-  }
-
-  const estimatedTotalTokens = rows.reduce((sum, row) => sum + row.tokens, 0);
-
-  console.log("Estimated total tokens");
-  console.log(`  ${formatNumber(estimatedTotalTokens)}`);
-
-  console.log("\nPer-file token estimates");
-  console.log(`  ${"tokens".padStart(8)}  path`);
-
-  const sortedRows = [...rows].sort((a, b) => b.tokens - a.tokens);
-  for (const row of sortedRows.slice(0, Math.max(0, args.top))) {
-    console.log(`  ${formatNumber(row.tokens).padStart(8)}  ${row.path}`);
-  }
-
-  return 0;
-}
-
-process.exit(main());