@letta-ai/letta-code 0.24.4 → 0.24.6

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.24.4",
+    version: "0.24.6",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -4723,10 +4723,12 @@ var exports_client = {};
 __export(exports_client, {
   getServerUrl: () => getServerUrl,
   getMemfsServerUrl: () => getMemfsServerUrl,
+  getMemfsGitProxyRewriteConfig: () => getMemfsGitProxyRewriteConfig,
   getClient: () => getClient,
   consumeLastSDKDiagnostic: () => consumeLastSDKDiagnostic,
   clearLastSDKDiagnostic: () => clearLastSDKDiagnostic,
-  __testOverrideGetClient: () => __testOverrideGetClient
+  __testOverrideGetClient: () => __testOverrideGetClient,
+  LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV: () => LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV
 });
 import { hostname } from "node:os";
 function __testOverrideGetClient(factory) {
@@ -4774,12 +4776,50 @@ 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 trimBaseUrl(value) {
+  return value.trim().replace(/\/+$/, "");
+}
+function getMemfsGitProxyRewriteConfig(env = process.env) {
+  const rawProxyBaseUrl = env[LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV]?.trim();
+  if (!rawProxyBaseUrl || !isLocalhostUrl(rawProxyBaseUrl)) {
+    return null;
+  }
+  const memfsBaseUrl = trimBaseUrl(getMemfsServerUrl());
+  if (!memfsBaseUrl.includes("api.letta.com")) {
+    return null;
+  }
+  const proxyBaseUrl = trimBaseUrl(rawProxyBaseUrl);
+  const proxyPrefix = `${proxyBaseUrl}/v1/git/`;
+  const memfsPrefix = `${memfsBaseUrl}/v1/git/`;
+  return {
+    proxyBaseUrl,
+    memfsBaseUrl,
+    proxyPrefix,
+    memfsPrefix,
+    configKey: `url.${proxyPrefix}.insteadOf`,
+    configValue: memfsPrefix
+  };
+}
 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;
+  }
+  return LETTA_CLOUD_API_URL;
 }
 async function getClient() {
   if (_testClientOverride) {
@@ -4854,7 +4894,7 @@ If you experience this issue multiple times, move ~/.letta to ~/.letta_backup, a
     ...isTimingsEnabled() && { fetch: createTimingFetch(fetch) }
   });
 }
-var SDK_DIAGNOSTIC_MAX_LEN = 400, SDK_DIAGNOSTIC_MAX_LINES = 4, lastSDKDiagnostic = null, _cachedApiKey, _testClientOverride = null, sdkLogger;
+var SDK_DIAGNOSTIC_MAX_LEN = 400, SDK_DIAGNOSTIC_MAX_LINES = 4, lastSDKDiagnostic = null, _cachedApiKey, _testClientOverride = null, sdkLogger, LETTA_MEMFS_GIT_PROXY_BASE_URL_ENV = "LETTA_MEMFS_GIT_PROXY_BASE_URL";
 var init_client2 = __esm(() => {
   init_letta_client();
   init_package();
@@ -7128,6 +7168,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 +7812,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 +9721,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",
@@ -38492,6 +38555,7 @@ var init_create = __esm(() => {
 var exports_memoryGit = {};
 __export(exports_memoryGit, {
   unsetMemoryRepositoryUrl: () => unsetMemoryRepositoryUrl,
+  shouldConfigurePersistentMemfsCredentialHelper: () => shouldConfigurePersistentMemfsCredentialHelper,
   setMemoryRepositoryUrl: () => setMemoryRepositoryUrl,
   removeGitMemoryTag: () => removeGitMemoryTag,
   readMemoryRepositoryPushLog: () => readMemoryRepositoryPushLog,
@@ -38503,6 +38567,7 @@ __export(exports_memoryGit, {
   isRetryableGitTransientError: () => isRetryableGitTransientError,
   isMissingCwdGitError: () => isMissingCwdGitError,
   isMemfsRemoteUrlForAgent: () => isMemfsRemoteUrlForAgent,
+  isMemfsGitNetworkCommand: () => isMemfsGitNetworkCommand,
   isGitRepo: () => isGitRepo,
   getMemoryRepositoryUrl: () => getMemoryRepositoryUrl,
   getMemoryRepoDir: () => getMemoryRepoDir,
@@ -38513,6 +38578,9 @@ __export(exports_memoryGit, {
   ensureLocalMemfsGitConfig: () => ensureLocalMemfsGitConfig,
   commitAndSyncMemoryWrite: () => commitAndSyncMemoryWrite,
   cloneMemoryRepo: () => cloneMemoryRepo,
+  buildNonInteractiveGitEnv: () => buildNonInteractiveGitEnv,
+  buildMemfsGitProxyArgs: () => buildMemfsGitProxyArgs,
+  buildGitAuthArgs: () => buildGitAuthArgs,
   assertMemoryRepoReadyForWrite: () => assertMemoryRepoReadyForWrite,
   addGitMemoryTag: () => addGitMemoryTag,
   PRE_COMMIT_HOOK_SCRIPT: () => PRE_COMMIT_HOOK_SCRIPT,
@@ -38622,12 +38690,44 @@ 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")}`
-  ] : [];
-  const allArgs = [...authArgs, ...args];
+  ];
+}
+function isMemfsGitNetworkCommand(args) {
+  return ["clone", "fetch", "pull", "push"].includes(args[0] ?? "");
+}
+function buildMemfsGitProxyArgs(args, env3 = process.env) {
+  if (!isMemfsGitNetworkCommand(args)) {
+    return [];
+  }
+  const rewrite = getMemfsGitProxyRewriteConfig(env3);
+  if (!rewrite) {
+    return [];
+  }
+  return ["-c", `${rewrite.configKey}=${rewrite.configValue}`];
+}
+function shouldConfigurePersistentMemfsCredentialHelper(env3 = process.env) {
+  return getMemfsGitProxyRewriteConfig(env3) === null;
+}
+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 = [...buildMemfsGitProxyArgs(args), ...authArgs, ...args];
   let loggableArgs = args;
   if (args[0] === "config" && typeof args[1] === "string" && args[1].includes("credential") && args[1].includes(".helper")) {
     loggableArgs = [args[0], args[1], "<redacted>"];
@@ -38637,6 +38737,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
   });
@@ -38690,6 +38791,11 @@ async function runGitWithRetry(cwd2, args, token, options) {
 async function configureLocalCredentialHelper(dir, token) {
   const rawBaseUrl = getMemfsServerUrl();
   const normalizedBaseUrl = normalizeCredentialBaseUrl(rawBaseUrl);
+  if (!shouldConfigurePersistentMemfsCredentialHelper()) {
+    await clearLocalCredentialHelper(dir, rawBaseUrl, normalizedBaseUrl);
+    debugLog("memfs-git", `Skipped persistent credential helper for ${normalizedBaseUrl}; using transient MemFS git proxy transport`);
+    return;
+  }
   let helper;
   if (platform2() === "win32") {
     const helperScriptPath = join7(dir, ".git", "letta-credential-helper.cmd");
@@ -38713,6 +38819,17 @@ echo password=${token}
   }
   debugLog("memfs-git", `Configured local credential helper for ${normalizedBaseUrl}${rawBaseUrl !== normalizedBaseUrl ? ` (and raw ${rawBaseUrl})` : ""}`);
 }
+async function clearLocalCredentialHelper(dir, rawBaseUrl, normalizedBaseUrl) {
+  const keys = new Set([
+    `credential.${normalizedBaseUrl}.helper`,
+    `credential.${rawBaseUrl}.helper`
+  ]);
+  for (const key of keys) {
+    try {
+      await runGit(dir, ["config", "--local", "--unset-all", key]);
+    } catch {}
+  }
+}
 function installPreCommitHook(dir) {
   const hooksDir = join7(dir, ".git", "hooks");
   const hookPath = join7(hooksDir, "pre-commit");
@@ -38963,6 +39080,32 @@ async function fetchMemoryRemote(memoryDir, token) {
     operation: "fetch origin"
   });
 }
+async function getMemoryAheadBehind(memoryDir) {
+  try {
+    const { stdout } = await runGit(memoryDir, [
+      "rev-list",
+      "--left-right",
+      "--count",
+      "HEAD...@{u}"
+    ]);
+    const [aheadRaw, behindRaw] = stdout.trim().split(/\s+/);
+    return {
+      ahead: Number.parseInt(aheadRaw ?? "0", 10) || 0,
+      behind: Number.parseInt(behindRaw ?? "0", 10) || 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function pushCleanPendingMemoryCommitsForWrite(memoryDir, agentId, token) {
+  await prepareMemoryRepoForGitOps(memoryDir, agentId, token);
+  const divergence = await getMemoryAheadBehind(memoryDir);
+  if (divergence && divergence.ahead > 0) {
+    await runGitWithRetry(memoryDir, ["push"], token, {
+      operation: "push pending memory commits"
+    });
+  }
+}
 async function resetMemoryToUpstream(memoryDir, token) {
   await runGit(memoryDir, ["reset", "--hard", "@{u}"], token);
 }
@@ -39028,19 +39171,18 @@ async function recoverMemoryPushConflict(params, token, initialSha) {
     rescueRef
   };
 }
-async function assertMemoryRepoReadyForWrite(memoryDir) {
+async function assertMemoryRepoReadyForWrite(memoryDir, agentId) {
   const status = await runGit(memoryDir, ["status", "--porcelain"]);
   if (status.stdout.trim().length > 0) {
     throw new Error("Memory repo has uncommitted changes. Commit, discard, or sync them before using memory tools.");
   }
+  if (agentId) {
+    const token = await getAuthToken();
+    await pushCleanPendingMemoryCommitsForWrite(memoryDir, agentId, token);
+  }
   try {
-    const { stdout } = await runGit(memoryDir, [
-      "rev-list",
-      "--count",
-      "@{u}..HEAD"
-    ]);
-    const aheadCount = parseInt(stdout.trim(), 10);
-    if (aheadCount > 0) {
+    const divergence = await getMemoryAheadBehind(memoryDir);
+    if (divergence && divergence.ahead > 0) {
       throw new Error("Memory repo has local commits that are not pushed to remote. Sync the repo before using memory tools.");
     }
   } catch (error) {
@@ -47319,13 +47461,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 +47561,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 +48029,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 +49062,7 @@ __export(exports_memoryFilesystem, {
   renderMemoryFilesystemTree: () => renderMemoryFilesystemTree,
   labelFromRelativePath: () => labelFromRelativePath,
   isMemfsEnabledOnServer: () => isMemfsEnabledOnServer,
+  isLettaMemfsServer: () => isLettaMemfsServer,
   isLettaCloud: () => isLettaCloud,
   getMemorySystemDir: () => getMemorySystemDir,
   getMemoryFilesystemRoot: () => getMemoryFilesystemRoot,
@@ -49082,8 +49250,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 +49322,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 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const memfsServerUrl = getMemfsServerUrl2();
+  return memfsServerUrl.includes("api.letta.com") || 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;
@@ -54547,6 +54733,24 @@ exec ${commandWithArgs} "$@"
   });
   return shimDir;
 }
+function appendGitConfigEnv(env3, key, value) {
+  const rawCount = env3.GIT_CONFIG_COUNT;
+  const count = rawCount && /^\d+$/.test(rawCount) ? Number(rawCount) : 0;
+  env3[`GIT_CONFIG_KEY_${count}`] = key;
+  env3[`GIT_CONFIG_VALUE_${count}`] = value;
+  env3.GIT_CONFIG_COUNT = String(count + 1);
+}
+function applyMemfsGitProxyEnv(env3) {
+  const rewrite = getMemfsGitProxyRewriteConfig(env3);
+  if (!rewrite) {
+    return;
+  }
+  appendGitConfigEnv(env3, rewrite.configKey, rewrite.configValue);
+  env3.GIT_TERMINAL_PROMPT = "0";
+  env3.GCM_INTERACTIVE = "never";
+  env3.GIT_ASKPASS = "";
+  env3.SSH_ASKPASS = "";
+}
 function getShellEnv() {
   const env3 = { ...process.env };
   const pathKey = Object.keys(env3).find((k) => k.toUpperCase() === "PATH") || "PATH";
@@ -54634,6 +54838,7 @@ function getShellEnv() {
   if (!env3.TERM) {
     env3.TERM = "xterm-256color";
   }
+  applyMemfsGitProxyEnv(env3);
   return env3;
 }
 var LETTA_BIN_ARGS_ENV = "LETTA_CODE_BIN_ARGS_JSON";
@@ -54922,13 +55127,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 +55155,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 +55405,7 @@ var init_Bash2 = __esm(() => {
   init_worktree_ownership();
   init_process_manager();
   init_shellEnv();
+  init_shellLaunchers();
   init_shellRunner();
   init_truncation();
 });
@@ -56449,14 +56660,14 @@ async function memory(args) {
   }
   const memoryDir = resolveMemoryDir();
   ensureMemoryRepo(memoryDir);
-  await assertMemoryRepoReadyForWrite(memoryDir);
+  const { agentId, agentName } = await getAgentIdentity();
+  await assertMemoryRepoReadyForWrite(memoryDir, agentId);
   const affectedPaths = await applyMemoryCommand(memoryDir, args);
   if (affectedPaths.length === 0) {
     return {
       message: `Memory ${args.command} completed with no changed paths.`
     };
   }
-  const { agentId, agentName } = await getAgentIdentity();
   const commitResult = await commitAndSyncMemoryWrite({
     memoryDir,
     pathspecs: affectedPaths,
@@ -56834,12 +57045,12 @@ async function memory_apply_patch(args) {
   }
   const memoryDir = resolveMemoryDir2();
   ensureMemoryRepo2(memoryDir);
-  await assertMemoryRepoReadyForWrite(memoryDir);
+  const { agentId, agentName } = await getAgentIdentity2();
+  await assertMemoryRepoReadyForWrite(memoryDir, agentId);
   const pathspecs = await applyMemoryPatch(memoryDir, input);
   if (pathspecs.length === 0) {
     return { message: "memory_apply_patch completed with no changed paths." };
   }
-  const { agentId, agentName } = await getAgentIdentity2();
   const commitResult = await commitAndSyncMemoryWrite({
     memoryDir,
     pathspecs,
@@ -71382,6 +71593,7 @@ var DEFAULT_TIMEOUT = 120000;
 var init_Shell2 = __esm(() => {
   init_runtime_context();
   init_shellEnv();
+  init_shellLaunchers();
   init_shellRunner();
 });
 
@@ -71527,6 +71739,7 @@ var init_ShellCommand2 = __esm(() => {
   init_context();
   init_readOnlyShell();
   init_Shell2();
+  init_shellLaunchers();
   init_shellRunner();
   init_truncation();
 });
@@ -147623,7 +147836,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) {
@@ -159132,6 +159347,7 @@ __export(exports_memoryFilesystem2, {
   renderMemoryFilesystemTree: () => renderMemoryFilesystemTree2,
   labelFromRelativePath: () => labelFromRelativePath2,
   isMemfsEnabledOnServer: () => isMemfsEnabledOnServer2,
+  isLettaMemfsServer: () => isLettaMemfsServer2,
   isLettaCloud: () => isLettaCloud2,
   getMemorySystemDir: () => getMemorySystemDir2,
   getMemoryFilesystemRoot: () => getMemoryFilesystemRoot2,
@@ -159319,8 +159535,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);
@@ -159391,6 +159607,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 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const memfsServerUrl = getMemfsServerUrl2();
+  return memfsServerUrl.includes("api.letta.com") || 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;
@@ -167844,6 +168078,12 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
   }
   const apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY;
   const baseURL = process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL2;
+  if (isHeadless && baseURL === LETTA_CLOUD_API_URL2 && !process.env.LETTA_API_KEY) {
+    console.error("Missing LETTA_API_KEY");
+    console.error("Headless mode requires an API key set via the LETTA_API_KEY environment variable.");
+    console.error("Get an API key at https://app.letta.com/api-keys");
+    process.exit(1);
+  }
   if (!isHeadless && baseURL === LETTA_CLOUD_API_URL2 && !settings.refreshToken && !apiKey) {
     const { runSetup: runSetup2 } = await init_setup4().then(() => exports_setup);
     await runSetup2();
@@ -167859,11 +168099,6 @@ Error: ${message}`);
     });
   }
   if (!apiKey && baseURL === LETTA_CLOUD_API_URL2) {
-    if (isHeadless) {
-      console.error("Missing LETTA_API_KEY");
-      console.error("Run 'letta' in interactive mode to authenticate or export the missing environment variable");
-      process.exit(1);
-    }
     console.log(`No credentials found. Let's get you set up!
 `);
     const { runSetup: runSetup2 } = await init_setup4().then(() => exports_setup);
@@ -168712,4 +168947,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=A2D8C37B0089C68564756E2164756E21
+//# debugId=00A382B05A86170664756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.24.4",
+  "version": "0.24.6",
   "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());