@letta-ai/letta-code 0.24.5 → 0.24.7

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.24.5",
+    version: "0.24.7",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -4721,13 +4721,14 @@ var init_timing = __esm(() => {
 // src/agent/client.ts
 var exports_client = {};
 __export(exports_client, {
-  isDesktopLocalProxyUrl: () => isDesktopLocalProxyUrl,
   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) {
@@ -4785,8 +4786,29 @@ function isLocalhostUrl(value) {
     return false;
   }
 }
-function isDesktopLocalProxyUrl(value) {
-  return process.env.LETTA_DESKTOP_DEBUG_PANEL === "1" && isLocalhostUrl(value);
+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;
@@ -4797,10 +4819,6 @@ function getMemfsServerUrl() {
   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() {
@@ -4876,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();
@@ -38537,6 +38555,7 @@ var init_create = __esm(() => {
 var exports_memoryGit = {};
 __export(exports_memoryGit, {
   unsetMemoryRepositoryUrl: () => unsetMemoryRepositoryUrl,
+  shouldConfigurePersistentMemfsCredentialHelper: () => shouldConfigurePersistentMemfsCredentialHelper,
   setMemoryRepositoryUrl: () => setMemoryRepositoryUrl,
   removeGitMemoryTag: () => removeGitMemoryTag,
   readMemoryRepositoryPushLog: () => readMemoryRepositoryPushLog,
@@ -38548,6 +38567,7 @@ __export(exports_memoryGit, {
   isRetryableGitTransientError: () => isRetryableGitTransientError,
   isMissingCwdGitError: () => isMissingCwdGitError,
   isMemfsRemoteUrlForAgent: () => isMemfsRemoteUrlForAgent,
+  isMemfsGitNetworkCommand: () => isMemfsGitNetworkCommand,
   isGitRepo: () => isGitRepo,
   getMemoryRepositoryUrl: () => getMemoryRepositoryUrl,
   getMemoryRepoDir: () => getMemoryRepoDir,
@@ -38559,6 +38579,7 @@ __export(exports_memoryGit, {
   commitAndSyncMemoryWrite: () => commitAndSyncMemoryWrite,
   cloneMemoryRepo: () => cloneMemoryRepo,
   buildNonInteractiveGitEnv: () => buildNonInteractiveGitEnv,
+  buildMemfsGitProxyArgs: () => buildMemfsGitProxyArgs,
   buildGitAuthArgs: () => buildGitAuthArgs,
   assertMemoryRepoReadyForWrite: () => assertMemoryRepoReadyForWrite,
   addGitMemoryTag: () => addGitMemoryTag,
@@ -38679,6 +38700,22 @@ function buildGitAuthArgs(token) {
     `http.extraHeader=Authorization: Basic ${Buffer.from(`letta:${token}`).toString("base64")}`
   ];
 }
+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,
@@ -38690,7 +38727,7 @@ function buildNonInteractiveGitEnv(env3 = process.env) {
 }
 async function runGit(cwd2, args, token) {
   const authArgs = token ? buildGitAuthArgs(token) : [];
-  const allArgs = [...authArgs, ...args];
+  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>"];
@@ -38754,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");
@@ -38777,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");
@@ -39027,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);
 }
@@ -39092,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) {
@@ -49253,9 +49331,9 @@ function getServerHostLabel(serverUrl) {
   }
 }
 async function isLettaMemfsServer() {
-  const { getMemfsServerUrl: getMemfsServerUrl2, isDesktopLocalProxyUrl: isDesktopLocalProxyUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const { getMemfsServerUrl: getMemfsServerUrl2 } = 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";
+  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));
@@ -54655,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";
@@ -54742,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";
@@ -56563,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,
@@ -56948,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,
@@ -72351,6 +72448,15 @@ Results include:
 `;
 var init_recall_subagent = () => {};
 
+// src/agent/subagents/contextBudget.ts
+function estimateStartupContextTokens(text) {
+  return Math.ceil(text.length / STARTUP_CONTEXT_ESTIMATED_CHARS_PER_TOKEN);
+}
+var STARTUP_CONTEXT_ESTIMATED_CHARS_PER_TOKEN = 4, REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT = 16000, REFLECTION_STARTUP_CONTEXT_CHAR_LIMIT, REFLECTION_PARENT_MEMORY_SNAPSHOT_CHAR_LIMIT = 40000;
+var init_contextBudget = __esm(() => {
+  REFLECTION_STARTUP_CONTEXT_CHAR_LIMIT = REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT * STARTUP_CONTEXT_ESTIMATED_CHARS_PER_TOKEN;
+});
+
 // src/agent/subagents/manager.ts
 import { spawn as spawn5 } from "node:child_process";
 function getModelHandleFromAgent(agent) {
@@ -72668,6 +72774,68 @@ function composeSubagentChildEnv(options) {
   }
   return childEnv;
 }
+function getReflectionStartupNotice() {
+  return `[Reflection startup context truncated: system prompt + initial message are capped at ~${REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT.toLocaleString()} estimated tokens. Some parent memory preview content was omitted; read files directly from MEMORY_DIR if needed.]`;
+}
+function buildMinimalParentMemorySection(maxChars) {
+  const notice = getReflectionStartupNotice();
+  const section = `<parent_memory>
+${notice}
+</parent_memory>`;
+  if (section.length <= maxChars) {
+    return section;
+  }
+  return section.slice(0, Math.max(0, maxChars));
+}
+function shrinkParentMemorySection(section, maxChars) {
+  const notice = getReflectionStartupNotice();
+  const treeMatch = section.match(/<memory_filesystem>[\s\S]*?<\/memory_filesystem>/);
+  const prefix = `<parent_memory>
+`;
+  const suffix = `
+</parent_memory>`;
+  const tree = treeMatch?.[0];
+  if (tree) {
+    const candidate = `${prefix}${tree}
+${notice}${suffix}`;
+    if (candidate.length <= maxChars) {
+      return candidate;
+    }
+  }
+  return buildMinimalParentMemorySection(maxChars);
+}
+function hardTruncateReflectionPrompt(prompt, maxChars) {
+  const notice = `
+${getReflectionStartupNotice()}`;
+  if (maxChars <= notice.length) {
+    return notice.slice(0, Math.max(0, maxChars));
+  }
+  return `${prompt.slice(0, maxChars - notice.length).trimEnd()}${notice}`;
+}
+function capReflectionStartupPrompt(type, systemPrompt, userPrompt) {
+  if (type !== "reflection") {
+    return userPrompt;
+  }
+  const estimatedTokens = estimateStartupContextTokens(`${systemPrompt}
+${userPrompt}`);
+  if (estimatedTokens <= REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT) {
+    return userPrompt;
+  }
+  const allowedPromptChars = Math.max(0, REFLECTION_STARTUP_CONTEXT_CHAR_LIMIT - systemPrompt.length - 1);
+  const parentMemoryMatch = userPrompt.match(/<parent_memory>[\s\S]*?<\/parent_memory>/);
+  if (parentMemoryMatch?.index !== undefined) {
+    const start = parentMemoryMatch.index;
+    const end = start + parentMemoryMatch[0].length;
+    const outsideChars = userPrompt.length - parentMemoryMatch[0].length;
+    const parentMemoryBudget = Math.max(0, allowedPromptChars - outsideChars);
+    const replacement = shrinkParentMemorySection(parentMemoryMatch[0], parentMemoryBudget);
+    const candidate = `${userPrompt.slice(0, start)}${replacement}${userPrompt.slice(end)}`;
+    if (candidate.length <= allowedPromptChars) {
+      return candidate;
+    }
+  }
+  return hardTruncateReflectionPrompt(userPrompt, allowedPromptChars);
+}
 function buildSubagentArgs(type, config, model, userPrompt, existingAgentId, existingConversationId, maxTurns) {
   const args = [];
   const isDeployingExisting = Boolean(existingAgentId || existingConversationId);
@@ -72685,7 +72853,8 @@ function buildSubagentArgs(type, config, model, userPrompt, existingAgentId, exi
       args.push("--model", model);
     }
   }
-  args.push("-p", userPrompt);
+  const boundedUserPrompt = capReflectionStartupPrompt(type, config.systemPrompt, userPrompt);
+  args.push("-p", boundedUserPrompt);
   args.push("--output-format", "stream-json");
   const subagentMode = config.permissionMode;
   const parentMode = permissionMode.getMode();
@@ -72976,6 +73145,7 @@ var init_manager2 = __esm(() => {
   init_model2();
   init_recall_subagent();
   init_subagents();
+  init_contextBudget();
   BYOK_PROVIDER_TO_BASE = {
     "lc-anthropic": "anthropic",
     "lc-openai": "openai",
@@ -77253,11 +77423,14 @@ var init_checker = __esm(() => {
 var exports_loader = {};
 __export(exports_loader, {
   savePermissionRule: () => savePermissionRule,
+  resetPermissionLoaderCacheForTests: () => resetPermissionLoaderCacheForTests,
   loadPermissions: () => loadPermissions,
   getUserSettingsPaths: () => getUserSettingsPaths
 });
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync18, statSync as statSync6, watch } from "node:fs";
 import { homedir as homedir17 } from "node:os";
-import { join as join26 } from "node:path";
+import { dirname as dirname13, join as join26, resolve as resolve25 } from "node:path";
 function getUserSettingsPaths(options = {}) {
   const homeDir = options.homeDir || homedir17();
   const xdgConfigHome = options.xdgConfigHome || process.env.XDG_CONFIG_HOME || join26(homeDir, ".config");
@@ -77266,20 +77439,127 @@ function getUserSettingsPaths(options = {}) {
     legacy: join26(xdgConfigHome, "letta", "settings.json")
   };
 }
+function getPermissionSourcePaths(workingDirectory) {
+  const { canonical: userSettingsPath, legacy: legacyUserSettingsPath } = getUserSettingsPaths();
+  return [
+    legacyUserSettingsPath,
+    userSettingsPath,
+    join26(workingDirectory, ".letta", "settings.json"),
+    join26(workingDirectory, ".letta", "settings.local.json")
+  ];
+}
+function getFileSignature(path20) {
+  try {
+    const stat5 = statSync6(path20);
+    if (!stat5.isFile()) {
+      return { exists: false };
+    }
+    return {
+      exists: true,
+      mtimeMs: stat5.mtimeMs,
+      size: stat5.size,
+      hash: createHash3("sha256").update(readFileSync18(path20)).digest("hex")
+    };
+  } catch {
+    return { exists: false };
+  }
+}
+function getFileSignatures(paths) {
+  const signatures = new Map;
+  for (const path20 of paths) {
+    signatures.set(path20, getFileSignature(path20));
+  }
+  return signatures;
+}
+function signaturesEqual(a, b) {
+  if (!a || !b)
+    return false;
+  if (!a.exists || !b.exists)
+    return a.exists === b.exists;
+  return a.mtimeMs === b.mtimeMs && a.size === b.size && a.hash === b.hash;
+}
+function cachedEntryMatchesSources(entry, sources, signatures) {
+  if (entry.sources.length !== sources.length) {
+    return false;
+  }
+  for (let i = 0;i < sources.length; i += 1) {
+    if (entry.sources[i] !== sources[i]) {
+      return false;
+    }
+  }
+  for (const source of sources) {
+    if (!signaturesEqual(entry.signatures.get(source), signatures.get(source))) {
+      return false;
+    }
+  }
+  return true;
+}
+function clonePermissions(permissions) {
+  return {
+    allow: [...permissions.allow || []],
+    deny: [...permissions.deny || []],
+    ask: [...permissions.ask || []],
+    additionalDirectories: [...permissions.additionalDirectories || []]
+  };
+}
+function invalidatePermissionSource(sourcePath) {
+  for (const [cacheKey, entry] of permissionCache) {
+    if (entry.sources.includes(sourcePath)) {
+      permissionCache.delete(cacheKey);
+    }
+  }
+}
+function invalidatePermissionSourcesInDirectory(directoryPath) {
+  for (const [cacheKey, entry] of permissionCache) {
+    if (entry.sources.some((source) => dirname13(source) === directoryPath)) {
+      permissionCache.delete(cacheKey);
+    }
+  }
+}
+function watchPath(path20, onChange) {
+  if (watchers.has(path20) || !exists(path20)) {
+    return;
+  }
+  try {
+    const watcher = watch(path20, { persistent: false }, onChange);
+    watcher.on("error", () => {
+      watcher.close();
+      watchers.delete(path20);
+      onChange();
+    });
+    watchers.set(path20, watcher);
+  } catch {}
+}
+function ensurePermissionWatchers(sources) {
+  for (const source of sources) {
+    watchPath(source, () => invalidatePermissionSource(source));
+    const directoryPath = dirname13(source);
+    watchPath(directoryPath, () => invalidatePermissionSourcesInDirectory(directoryPath));
+  }
+}
+function resetPermissionLoaderCacheForTests() {
+  permissionCache.clear();
+  for (const watcher of watchers.values()) {
+    watcher.close();
+  }
+  watchers.clear();
+}
 async function loadPermissions(workingDirectory = process.cwd()) {
+  const normalizedWorkingDirectory = resolve25(workingDirectory);
+  const sources = getPermissionSourcePaths(normalizedWorkingDirectory);
+  const signatures = getFileSignatures(sources);
+  const cacheKey = normalizedWorkingDirectory;
+  const cached = permissionCache.get(cacheKey);
+  if (cached && cachedEntryMatchesSources(cached, sources, signatures)) {
+    ensurePermissionWatchers(sources);
+    return clonePermissions(cached.permissions);
+  }
   const merged = {
     allow: [],
     deny: [],
     ask: [],
     additionalDirectories: []
   };
-  const { canonical: userSettingsPath, legacy: legacyUserSettingsPath } = getUserSettingsPaths();
-  const sources = [
-    legacyUserSettingsPath,
-    userSettingsPath,
-    join26(workingDirectory, ".letta", "settings.json"),
-    join26(workingDirectory, ".letta", "settings.local.json")
-  ];
   for (const settingsPath of sources) {
     try {
       if (exists(settingsPath)) {
@@ -77291,7 +77571,13 @@ async function loadPermissions(workingDirectory = process.cwd()) {
       }
     } catch (_error) {}
   }
-  return merged;
+  permissionCache.set(cacheKey, {
+    permissions: clonePermissions(merged),
+    sources,
+    signatures
+  });
+  ensurePermissionWatchers(sources);
+  return clonePermissions(merged);
 }
 function mergePermissions(target, source) {
   if (source.allow) {
@@ -77320,16 +77606,17 @@ function mergeRuleList(existing, incoming) {
   return merged;
 }
 async function savePermissionRule(rule, ruleType, scope, workingDirectory = process.cwd()) {
+  const normalizedWorkingDirectory = resolve25(workingDirectory);
   let settingsPath;
   switch (scope) {
     case "user":
       settingsPath = getUserSettingsPaths().canonical;
       break;
     case "project":
-      settingsPath = join26(workingDirectory, ".letta", "settings.json");
+      settingsPath = join26(normalizedWorkingDirectory, ".letta", "settings.json");
       break;
     case "local":
-      settingsPath = join26(workingDirectory, ".letta", "settings.local.json");
+      settingsPath = join26(normalizedWorkingDirectory, ".letta", "settings.local.json");
       break;
   }
   let settings = {};
@@ -77350,8 +77637,9 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
     settings.permissions[ruleType].push(normalizedRule);
   }
   await writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  invalidatePermissionSource(settingsPath);
   if (scope === "local") {
-    await ensureLocalSettingsIgnored(workingDirectory);
+    await ensureLocalSettingsIgnored(normalizedWorkingDirectory);
   }
 }
 async function ensureLocalSettingsIgnored(workingDirectory) {
@@ -77371,9 +77659,12 @@ async function ensureLocalSettingsIgnored(workingDirectory) {
     }
   } catch (_error) {}
 }
+var permissionCache, watchers;
 var init_loader2 = __esm(() => {
   init_fs();
   init_rule_normalization();
+  permissionCache = new Map;
+  watchers = new Map;
 });
 
 // src/permissions/analyzer.ts
@@ -77382,7 +77673,7 @@ __export(exports_analyzer, {
   analyzeApprovalContext: () => analyzeApprovalContext
 });
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname13, relative as relative8, resolve as resolve25, win32 as win323 } from "node:path";
+import { dirname as dirname14, relative as relative8, resolve as resolve26, win32 as win323 } from "node:path";
 function normalizeOsPath(path20) {
   return path20.replace(/\\/g, "/");
 }
@@ -77391,7 +77682,7 @@ function isWindowsPath(path20) {
 }
 function resolvePathForContext(basePath, targetPath) {
   const windows = isWindowsPath(basePath) || isWindowsPath(targetPath);
-  return windows ? win323.resolve(basePath, targetPath) : resolve25(basePath, targetPath);
+  return windows ? win323.resolve(basePath, targetPath) : resolve26(basePath, targetPath);
 }
 function relativePathForContext(basePath, targetPath) {
   const windows = isWindowsPath(basePath) || isWindowsPath(targetPath);
@@ -77408,7 +77699,7 @@ function isPathWithinDirectory(path20, directory) {
   return !relativePath.startsWith("../") && relativePath !== ".." && !relativePath.startsWith("/") && !/^[a-zA-Z]:\//.test(relativePath);
 }
 function dirnameForContext(path20) {
-  return isWindowsPath(path20) ? win323.dirname(path20) : dirname13(path20);
+  return isWindowsPath(path20) ? win323.dirname(path20) : dirname14(path20);
 }
 function formatAbsoluteRulePath(path20) {
   const normalized = normalizeOsPath(path20).replace(/\/+$/, "");
@@ -77469,7 +77760,7 @@ function analyzeReadApproval(filePath, workingDir) {
     };
   }
   const relativePath = normalizeOsPath(relativePathForContext(workingDir, absolutePath));
-  const relativeDir = dirname13(relativePath);
+  const relativeDir = dirname14(relativePath);
   const pattern = relativeDir === "." || relativeDir === "" ? "**" : `${relativeDir}/**`;
   return {
     recommendedRule: `Read(${pattern})`,
@@ -78095,8 +78386,8 @@ function acquireSwitchLock() {
   const lock = getSwitchLock();
   lock.refCount++;
   if (lock.refCount === 1) {
-    lock.promise = new Promise((resolve27) => {
-      lock.resolve = resolve27;
+    lock.promise = new Promise((resolve28) => {
+      lock.resolve = resolve28;
     });
   }
 }
@@ -80151,7 +80442,7 @@ async function generatePKCE() {
   return { codeVerifier, codeChallenge };
 }
 function startLocalOAuthServer(expectedState, port = OPENAI_OAUTH_CONFIG.defaultPort) {
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "", `http://localhost:${port}`);
       if (url.pathname === OPENAI_OAUTH_CONFIG.callbackPath) {
@@ -80197,7 +80488,7 @@ function startLocalOAuthServer(expectedState, port = OPENAI_OAUTH_CONFIG.default
           message: "You can close this window and return to Letta Code.",
           autoClose: true
         }));
-        resolve27({ result: { code, state }, server });
+        resolve28({ result: { code, state }, server });
       } else {
         res.writeHead(404, { "Content-Type": "text/plain" });
         res.end("Not found");
@@ -80712,14 +81003,14 @@ var execFile11, __dirname2, localXdgOpenPath, platform4, arch, pTryEach = async
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve27(subprocess);
+        resolve28(subprocess);
       });
     });
   }
@@ -81105,10 +81396,10 @@ import { randomBytes } from "node:crypto";
 import {
   existsSync as existsSync24,
   mkdirSync as mkdirSync18,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   renameSync as renameSync2,
   rmSync as rmSync2,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync15
 } from "node:fs";
 import { join as join27 } from "node:path";
@@ -81131,7 +81422,7 @@ function readCronFile() {
   if (!existsSync24(path21))
     return emptyFile();
   try {
-    const raw = readFileSync18(path21, "utf-8");
+    const raw = readFileSync19(path21, "utf-8");
     const data = JSON.parse(raw);
     if (data.version !== 1)
       return emptyFile();
@@ -81152,7 +81443,7 @@ function writeCronFile(data) {
 }
 function readLinuxProcessIdentity(pid) {
   try {
-    const stat5 = readFileSync18(`/proc/${pid}/stat`, "utf8");
+    const stat5 = readFileSync19(`/proc/${pid}/stat`, "utf8");
     const endCommand = stat5.lastIndexOf(")");
     if (endCommand === -1) {
       return null;
@@ -81164,7 +81455,7 @@ function readLinuxProcessIdentity(pid) {
     }
     let bootId = null;
     try {
-      bootId = readFileSync18("/proc/sys/kernel/random/boot_id", "utf8").trim() || null;
+      bootId = readFileSync19("/proc/sys/kernel/random/boot_id", "utf8").trim() || null;
     } catch {}
     return { startTicks, bootId };
   } catch {
@@ -81205,7 +81496,7 @@ function isProcessAlive(pid, owner) {
 }
 function readLockOwner(lockDir) {
   try {
-    const raw = readFileSync18(join27(lockDir, LOCK_TOKEN_FILE), "utf-8");
+    const raw = readFileSync19(join27(lockDir, LOCK_TOKEN_FILE), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -81218,7 +81509,7 @@ function isLockStale(lockDir) {
   const owner = readLockOwner(lockDir);
   if (!owner) {
     try {
-      const stat5 = statSync6(lockDir);
+      const stat5 = statSync7(lockDir);
       return Date.now() - stat5.mtimeMs > LOCK_STALE_AGE_MS;
     } catch {
       return true;
@@ -81462,7 +81753,7 @@ function getActiveTasks() {
 function getCronFileMtime() {
   const path21 = getCronFilePath();
   try {
-    return statSync6(path21).mtimeMs;
+    return statSync7(path21).mtimeMs;
   } catch {
     return 0;
   }
@@ -81705,7 +81996,7 @@ async function registerWithCloudRetry(opts, callbacks) {
       if (error instanceof Error) {
         callbacks?.onRetry?.(attempt, delay, error);
       }
-      await new Promise((resolve27) => setTimeout(resolve27, delay));
+      await new Promise((resolve28) => setTimeout(resolve28, delay));
     }
   }
 }
@@ -83610,7 +83901,7 @@ var init_memoryReminder = __esm(() => {
 });
 
 // src/utils/systemPromptSize.ts
-import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync19 } from "node:fs";
+import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync20 } from "node:fs";
 import { join as join29 } from "node:path";
 function estimateSystemTokens(text) {
   return Math.ceil(Buffer.byteLength(text, "utf8") / SYSTEM_PROMPT_BYTES_PER_TOKEN);
@@ -83647,7 +83938,7 @@ function estimateSystemPromptSize(memoryDir) {
   const files = walkMarkdownFiles(systemDir).sort();
   const rows = [];
   for (const filePath of files) {
-    const text = readFileSync19(filePath, "utf8");
+    const text = readFileSync20(filePath, "utf8");
     const rel = normalizePath2(filePath.slice(memoryDir.length + 1));
     rows.push({ path: rel, tokens: estimateSystemTokens(text) });
   }
@@ -87043,10 +87334,36 @@ function buildParentMemoryTree(files) {
   return lines.join(`
 `);
 }
-async function buildParentMemorySnapshot(memoryDir) {
+function joinedLength(lines) {
+  return lines.join(`
+`).length;
+}
+function canAppendWithinBudget(lines, additions, maxChars) {
+  return joinedLength([...lines, ...additions, "</parent_memory>"]) <= maxChars;
+}
+function truncateMemoryContentToFit(lines, prefix, content, suffix, maxChars) {
+  const fixedLength = joinedLength([
+    ...lines,
+    ...prefix,
+    "",
+    ...suffix,
+    "</parent_memory>"
+  ]);
+  const budget = maxChars - fixedLength;
+  if (budget <= 0) {
+    return null;
+  }
+  return content.slice(0, budget).trimEnd();
+}
+function buildMemoryPreviewNotice(relativePath, absolutePath, kind) {
+  const action = kind === "truncated" ? "truncated" : "omitted";
+  return `[Memory preview ${action}: startup context is capped at ~16k estimated tokens. Full file available at ${absolutePath}; read it directly if needed. Relative path: ${relativePath}]`;
+}
+async function buildParentMemorySnapshot(memoryDir, options = {}) {
   const files = await collectParentMemoryFiles(memoryDir);
   const tree = buildParentMemoryTree(files);
   const systemFiles = files.filter((file) => isSystemMemoryFile(file.relativePath));
+  const maxChars = Math.max(1000, options.maxChars ?? REFLECTION_PARENT_MEMORY_SNAPSHOT_CHAR_LIMIT);
   const lines = [
     "<parent_memory>",
     "<memory_filesystem>",
@@ -87056,13 +87373,47 @@ async function buildParentMemorySnapshot(memoryDir) {
   if (files.length === 0) {
     lines.push("(no memory markdown files found)");
   } else {
+    let omittedSystemFiles = 0;
     for (const file of systemFiles) {
       const normalizedPath = file.relativePath.replace(/\\/g, "/");
       const absolutePath = `${memoryDir.replace(/\\/g, "/")}/${normalizedPath}`;
-      lines.push("<memory>");
-      lines.push(`<path>${absolutePath}</path>`);
-      lines.push(file.content);
-      lines.push("</memory>");
+      const prefix = ["<memory>", `<path>${absolutePath}</path>`];
+      const suffix = ["</memory>"];
+      const fullEntry = [...prefix, file.content, ...suffix];
+      if (canAppendWithinBudget(lines, fullEntry, maxChars)) {
+        lines.push(...fullEntry);
+        continue;
+      }
+      const truncatedNotice = buildMemoryPreviewNotice(normalizedPath, absolutePath, "truncated");
+      const truncatedContent = truncateMemoryContentToFit(lines, prefix, file.content, [truncatedNotice, ...suffix], maxChars);
+      if (truncatedContent) {
+        const truncatedEntry = [
+          ...prefix,
+          truncatedContent,
+          truncatedNotice,
+          ...suffix
+        ];
+        if (canAppendWithinBudget(lines, truncatedEntry, maxChars)) {
+          lines.push(...truncatedEntry);
+          continue;
+        }
+      }
+      const omittedEntry = [
+        ...prefix,
+        buildMemoryPreviewNotice(normalizedPath, absolutePath, "omitted"),
+        ...suffix
+      ];
+      if (canAppendWithinBudget(lines, omittedEntry, maxChars)) {
+        lines.push(...omittedEntry);
+      } else {
+        omittedSystemFiles += 1;
+      }
+    }
+    if (omittedSystemFiles > 0) {
+      const notice = `[Memory preview omitted ${omittedSystemFiles.toLocaleString()} additional system file(s) because the reflection startup context budget was exhausted. Read files directly from ${memoryDir} if needed.]`;
+      if (canAppendWithinBudget(lines, [notice], maxChars)) {
+        lines.push(notice);
+      }
     }
   }
   lines.push("</parent_memory>");
@@ -87310,12 +87661,13 @@ async function finalizeAutoReflectionPayload(agentId, conversationId, _payloadPa
 var TRANSCRIPT_ROOT_ENV = "LETTA_TRANSCRIPT_ROOT", DEFAULT_TRANSCRIPT_DIR = "transcripts", TOOL_ARGS_TRUNCATE_LIMIT = 300;
 var init_reflectionTranscript = __esm(() => {
   init_memoryFilesystem();
+  init_contextBudget();
   init_directoryLimits();
 });
 
 // src/utils/tuiPerf.ts
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync20 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 function ensureExitHook() {
   if (tuiPerfExitHookRegistered) {
     return;
@@ -87404,7 +87756,7 @@ function flushTuiPerfTelemetry() {
     };
   }
   try {
-    const dir = dirname14(filePath);
+    const dir = dirname15(filePath);
     if (tuiPerfFileDirEnsured !== dir) {
       mkdirSync20(dir, { recursive: true });
       tuiPerfFileDirEnsured = dir;
@@ -87746,11 +88098,11 @@ async function discoverFallbackRunIdWithTimeout(client, ctx) {
   return withTimeout(discoverFallbackRunIdForResume(client, ctx), FALLBACK_RUN_DISCOVERY_TIMEOUT_MS, `Fallback run discovery timed out after ${FALLBACK_RUN_DISCOVERY_TIMEOUT_MS}ms`);
 }
 function withTimeout(promise, timeoutMs, timeoutMessage) {
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
     promise.then((value) => {
       clearTimeout(timer);
-      resolve27(value);
+      resolve28(value);
     }, (error) => {
       clearTimeout(timer);
       reject(error);
@@ -88645,7 +88997,7 @@ var init_constants2 = __esm(() => {
 });
 
 // src/websocket/listener/remote-settings.ts
-import { existsSync as existsSync29, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync21 } from "node:fs";
 import { mkdir as mkdir8, writeFile as writeFile10 } from "node:fs/promises";
 import { homedir as homedir22 } from "node:os";
 import path21 from "node:path";
@@ -88660,7 +89012,7 @@ function loadRemoteSettings() {
   try {
     const settingsPath = getRemoteSettingsPath();
     if (existsSync29(settingsPath)) {
-      const raw = readFileSync20(settingsPath, "utf-8");
+      const raw = readFileSync21(settingsPath, "utf-8");
       const parsed = JSON.parse(raw);
       loaded = parsed;
     }
@@ -88697,7 +89049,7 @@ function loadLegacyCwdCache() {
     const legacyPath = path21.join(homedir22(), ".letta", "cwd-cache.json");
     if (!existsSync29(legacyPath))
       return {};
-    const raw = readFileSync20(legacyPath, "utf-8");
+    const raw = readFileSync21(legacyPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = {};
     for (const [key, value] of Object.entries(parsed)) {
@@ -88899,7 +89251,7 @@ function requestApprovalOverWS(runtime, socket, requestId, controlRequest) {
   if (isInterrupted()) {
     return Promise.reject(new Error("Cancelled by user"));
   }
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     let settled = false;
     const cleanupAbortListener = () => {
       abortSignal?.removeEventListener("abort", handleAbort);
@@ -88910,7 +89262,7 @@ function requestApprovalOverWS(runtime, socket, requestId, controlRequest) {
       }
       settled = true;
       cleanupAbortListener();
-      resolve27(response);
+      resolve28(response);
     };
     const wrappedReject = (error) => {
       if (settled) {
@@ -90535,7 +90887,7 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
             conversationId
           });
         }
-        await new Promise((resolve27) => setTimeout(resolve27, delayMs));
+        await new Promise((resolve28) => setTimeout(resolve28, delayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -90590,7 +90942,7 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
           agentId: runtime.agentId ?? undefined,
           conversationId
         });
-        await new Promise((resolve27) => setTimeout(resolve27, delayMs));
+        await new Promise((resolve28) => setTimeout(resolve28, delayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -90677,7 +91029,7 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
             conversationId
           });
         }
-        await new Promise((resolve27) => setTimeout(resolve27, delayMs));
+        await new Promise((resolve28) => setTimeout(resolve28, delayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -90731,7 +91083,7 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
           agentId: runtime.agentId ?? undefined,
           conversationId
         });
-        await new Promise((resolve27) => setTimeout(resolve27, retryDelayMs));
+        await new Promise((resolve28) => setTimeout(resolve28, retryDelayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -93732,7 +94084,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             agentId,
             conversationId
           });
-          await new Promise((resolve27) => setTimeout(resolve27, delayMs));
+          await new Promise((resolve28) => setTimeout(resolve28, delayMs));
           if (turnAbortSignal.aborted) {
             throw new Error("Cancelled by user");
           }
@@ -93777,7 +94129,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             agentId,
             conversationId
           });
-          await new Promise((resolve27) => setTimeout(resolve27, delayMs));
+          await new Promise((resolve28) => setTimeout(resolve28, delayMs));
           if (turnAbortSignal.aborted) {
             throw new Error("Cancelled by user");
           }
@@ -94282,7 +94634,7 @@ var init_commands = __esm(async () => {
 
 // src/websocket/listener/protocol-outbound.ts
 import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync22 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname16 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 import WebSocket3 from "ws";
 function getProtocolPerfKey(message) {
@@ -94331,7 +94683,7 @@ function writeProtocolPerfFile(record, fallbackLine) {
     return;
   }
   try {
-    const dir = dirname15(filePath);
+    const dir = dirname16(filePath);
     if (protocolPerfFileDirEnsured !== dir) {
       mkdirSync22(dir, { recursive: true });
       protocolPerfFileDirEnsured = dir;
@@ -95697,7 +96049,7 @@ async function runGrepInFiles(args) {
   });
 }
 function runRipgrep(rgArgs) {
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     const child = execFile12(rgPath3, rgArgs, {
       maxBuffer: 50 * 1024 * 1024
     }, (error, stdout, _stderr) => {
@@ -95705,7 +96057,7 @@ function runRipgrep(rgArgs) {
         reject(error);
         return;
       }
-      resolve27(stdout);
+      resolve28(stdout);
     });
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -96353,7 +96705,7 @@ var init_protocol_inbound = __esm(async () => {
 });
 
 // src/websocket/listener/worktree-watcher.ts
-import { readdir as readdir6, stat as stat5, watch } from "node:fs/promises";
+import { readdir as readdir6, stat as stat5, watch as watch2 } from "node:fs/promises";
 import path24 from "node:path";
 function startWorktreeWatcher(params) {
   const { runtime, agentId, conversationId } = params;
@@ -96409,7 +96761,7 @@ async function runWatchLoop(params) {
   }
   const existingEntries = new Set(await safeReaddir(worktreesDir));
   let debounceTimer = null;
-  const watcher = watch(worktreesDir, { signal: abort.signal });
+  const watcher = watch2(worktreesDir, { signal: abort.signal });
   for await (const event of watcher) {
     if (event.eventType !== "rename" || !event.filename)
       continue;
@@ -96460,7 +96812,7 @@ async function handleNewWorktree(params) {
   }
 }
 async function waitForDirectoryCreation(parentDir, targetName, signal) {
-  const watcher = watch(parentDir, { signal });
+  const watcher = watch2(parentDir, { signal });
   for await (const event of watcher) {
     if (event.eventType === "rename" && event.filename === targetName && await directoryExists(path24.join(parentDir, targetName))) {
       return;
@@ -96497,7 +96849,7 @@ __export(exports_memoryScanner, {
   readFileContent: () => readFileContent,
   getFileNodes: () => getFileNodes
 });
-import { readdirSync as readdirSync10, readFileSync as readFileSync21, statSync as statSync7 } from "node:fs";
+import { readdirSync as readdirSync10, readFileSync as readFileSync22, statSync as statSync8 } from "node:fs";
 import { join as join33, relative as relative13 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
@@ -96515,10 +96867,10 @@ function scanMemoryFilesystem(memoryRoot) {
       let aIsDir = false;
       let bIsDir = false;
       try {
-        aIsDir = statSync7(aPath).isDirectory();
+        aIsDir = statSync8(aPath).isDirectory();
       } catch {}
       try {
-        bIsDir = statSync7(bPath).isDirectory();
+        bIsDir = statSync8(bPath).isDirectory();
       } catch {}
       if (aIsDir !== bIsDir)
         return aIsDir ? -1 : 1;
@@ -96534,7 +96886,7 @@ function scanMemoryFilesystem(memoryRoot) {
       const fullPath = join33(dir, name);
       let isDir = false;
       try {
-        isDir = statSync7(fullPath).isDirectory();
+        isDir = statSync8(fullPath).isDirectory();
       } catch {
         return;
       }
@@ -96562,7 +96914,7 @@ function getFileNodes(nodes) {
 }
 function readFileContent(fullPath) {
   try {
-    return readFileSync21(fullPath, "utf-8");
+    return readFileSync22(fullPath, "utf-8");
   } catch {
     return "(unable to read file)";
   }
@@ -98826,8 +99178,8 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     const delay = Math.min(INITIAL_RETRY_DELAY_MS * 2 ** (attempt - 1), MAX_RETRY_DELAY_MS);
     const maxAttempts = Math.ceil(Math.log2(MAX_RETRY_DURATION_MS / INITIAL_RETRY_DELAY_MS));
     opts.onRetrying?.(attempt, maxAttempts, delay, opts.connectionId);
-    await new Promise((resolve27) => {
-      runtime.reconnectTimeout = setTimeout(resolve27, delay);
+    await new Promise((resolve28) => {
+      runtime.reconnectTimeout = setTimeout(resolve28, delay);
     });
     runtime.reconnectTimeout = null;
     if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
@@ -99374,11 +99726,11 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
             return;
           }
           try {
-            const { watch: watch2 } = await import("node:fs");
+            const { watch: watch3 } = await import("node:fs");
             const { stat: stat7 } = await import("node:fs/promises");
             if (cancelledWatches.delete(parsed.path))
               return;
-            const watcher = watch2(parsed.path, { persistent: false }, (eventType) => {
+            const watcher = watch3(parsed.path, { persistent: false }, (eventType) => {
               if (eventType !== "change" && eventType !== "rename")
                 return;
               const existing2 = watchDebounceTimers.get(parsed.path);
@@ -100305,7 +100657,7 @@ import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync24,
   readdirSync as readdirSync11,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   unlinkSync as unlinkSync8
 } from "node:fs";
 import { homedir as homedir26 } from "node:os";
@@ -100359,7 +100711,7 @@ class DebugLogFile2 {
     try {
       if (!existsSync31(this.logPath))
         return;
-      const content = readFileSync22(this.logPath, "utf8");
+      const content = readFileSync23(this.logPath, "utf8");
       const lines = content.trimEnd().split(`
 `);
       return lines.slice(-maxLines).join(`
@@ -100443,10 +100795,10 @@ __export(exports_skills2, {
 });
 import { existsSync as existsSync32 } from "node:fs";
 import { readdir as readdir8, readFile as readFile13, realpath as realpath4, stat as stat7 } from "node:fs/promises";
-import { dirname as dirname16, join as join38 } from "node:path";
+import { dirname as dirname17, join as join38 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function getBundledSkillsPath2() {
-  const thisDir = dirname16(fileURLToPath9(import.meta.url));
+  const thisDir = dirname17(fileURLToPath9(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
     return join38(thisDir, "../skills/builtin");
   }
@@ -100642,12 +100994,12 @@ import {
   writeFileSync as fsWriteFileSync2,
   mkdirSync as mkdirSync25
 } from "node:fs";
-import { dirname as dirname17 } from "node:path";
+import { dirname as dirname18 } from "node:path";
 async function readFile14(path26) {
   return fsReadFileSync2(path26, { encoding: "utf-8" });
 }
 async function writeFile12(path26, content) {
-  const dir = dirname17(path26);
+  const dir = dirname18(path26);
   if (!existsSync33(dir)) {
     mkdirSync25(dir, { recursive: true });
   }
@@ -100692,7 +101044,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
   }
   const wasRaw = process.stdin.isRaw;
   const wasFlowing = process.stdin.readableFlowing;
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     let response = "";
     let resolved = false;
     const cleanup = () => {
@@ -100709,7 +101061,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
     };
     const timeout = setTimeout(() => {
       cleanup();
-      resolve29(null);
+      resolve30(null);
     }, timeoutMs);
     const onData = (data) => {
       response += data.toString();
@@ -100719,7 +101071,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
       if (match3) {
         clearTimeout(timeout);
         cleanup();
-        resolve29({
+        resolve30({
           r: parseHexComponent(match3[1] ?? "0"),
           g: parseHexComponent(match3[2] ?? "0"),
           b: parseHexComponent(match3[3] ?? "0")
@@ -100734,7 +101086,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
     } catch {
       clearTimeout(timeout);
       cleanup();
-      resolve29(null);
+      resolve30(null);
     }
   });
 }
@@ -101967,10 +102319,10 @@ __export(exports_setup, {
   runSetup: () => runSetup
 });
 async function runSetup() {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const { waitUntilExit } = render_default(import_react32.default.createElement(SetupUI, {
       onComplete: () => {
-        resolve30();
+        resolve31();
       }
     }));
     waitUntilExit().catch((error) => {
@@ -102458,9 +102810,28 @@ function validateRegistryHandleOrThrow2(handle) {
 }
 
 // src/streamJsonWriter.ts
+function stampWireMessage(msg) {
+  return msg.timestamp === undefined ? { ...msg, timestamp: new Date().toISOString() } : msg;
+}
 function writeWireMessage(msg) {
-  const stamped = msg.timestamp === undefined ? { ...msg, timestamp: new Date().toISOString() } : msg;
-  console.log(JSON.stringify(stamped));
+  console.log(JSON.stringify(stampWireMessage(msg)));
+}
+async function writeWireMessageAsync(msg) {
+  const line = `${JSON.stringify(stampWireMessage(msg))}
+`;
+  await new Promise((resolve31, reject) => {
+    if (process.stdout.destroyed || process.stdout.writableEnded) {
+      resolve31();
+      return;
+    }
+    process.stdout.write(line, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve31();
+    });
+  });
 }
 
 // src/agent/github-utils.ts
@@ -102504,10 +102875,10 @@ __export(exports_import, {
 });
 import { createReadStream } from "node:fs";
 import { chmod, mkdir as mkdir10, readFile as readFile15, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname18, resolve as resolve30 } from "node:path";
+import { dirname as dirname19, resolve as resolve31 } from "node:path";
 async function importAgentFromFile(options) {
   const client = await getClient();
-  const resolvedPath = resolve30(options.filePath);
+  const resolvedPath = resolve31(options.filePath);
   const file = createReadStream(resolvedPath);
   const importResponse = await client.agents.importFile({
     file,
@@ -102542,7 +102913,7 @@ async function extractSkillsFromAf(afPath, destDir) {
     return [];
   }
   for (const skill2 of afData.skills) {
-    const skillDir = resolve30(destDir, skill2.name);
+    const skillDir = resolve31(destDir, skill2.name);
     await mkdir10(skillDir, { recursive: true });
     if (skill2.files) {
       await writeSkillFiles(skillDir, skill2.files);
@@ -102562,8 +102933,8 @@ async function writeSkillFiles(skillDir, files) {
   }
 }
 async function writeSkillFile(skillDir, filePath, content) {
-  const fullPath = resolve30(skillDir, filePath);
-  await mkdir10(dirname18(fullPath), { recursive: true });
+  const fullPath = resolve31(skillDir, filePath);
+  await mkdir10(dirname19(fullPath), { recursive: true });
   await writeFile13(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
@@ -102904,12 +103275,12 @@ async function sendScopedApprovalMessages(params) {
   });
 }
 async function flushAndExit(code) {
-  const flushWritable = (stream2) => new Promise((resolve31) => {
+  const flushWritable = (stream2) => new Promise((resolve32) => {
     if (stream2.destroyed || stream2.writableEnded) {
-      resolve31();
+      resolve32();
       return;
     }
-    stream2.write("", () => resolve31());
+    stream2.write("", () => resolve32());
   });
   await Promise.allSettled([
     flushWritable(process.stdout),
@@ -102918,12 +103289,12 @@ async function flushAndExit(code) {
   process.exit(code);
 }
 async function writeFinalHeadlessStdout(text) {
-  await new Promise((resolve31) => {
+  await new Promise((resolve32) => {
     if (process.stdout.destroyed || process.stdout.writableEnded) {
-      resolve31();
+      resolve32();
       return;
     }
-    process.stdout.write(text, () => resolve31());
+    process.stdout.write(text, () => resolve32());
   });
 }
 async function handleHeadlessCommand(parsedArgs, model, skillsDirectoryOverride, skillSourcesOverride, systemInfoReminderEnabledOverride) {
@@ -103756,7 +104127,7 @@ ${loadedContents.join(`
           session_id: sessionId,
           uuid: `error-max-turns-${randomUUID15()}`
         };
-        writeWireMessage(errorMsg);
+        await writeWireMessageAsync(errorMsg);
       } else {
         console.error(`Maximum turns limit reached (${buffers.usage.stepCount}/${maxTurns} steps)`);
       }
@@ -103855,7 +104226,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
             }
-            await new Promise((resolve31) => setTimeout(resolve31, retryDelayMs));
+            await new Promise((resolve32) => setTimeout(resolve32, retryDelayMs));
             continue;
           }
         }
@@ -103904,7 +104275,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`Transient API error before streaming (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve31) => setTimeout(resolve31, delayMs));
+          await new Promise((resolve32) => setTimeout(resolve32, delayMs));
           conversationBusyRetries = 0;
           continue;
         }
@@ -104140,7 +104511,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve31) => setTimeout(resolve31, delayMs));
+          await new Promise((resolve32) => setTimeout(resolve32, delayMs));
           refreshCurrentInputOtids();
           continue;
         }
@@ -104173,7 +104544,7 @@ ${loadedContents.join(`
               session_id: sessionId,
               uuid: `error-${lastRunId || randomUUID15()}`
             };
-            writeWireMessage(errorMsg);
+            await writeWireMessageAsync(errorMsg);
           } else {
             console.error("Failed to fetch pending approvals for resync");
           }
@@ -104230,7 +104601,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Empty LLM response, retrying (attempt ${attempt} of ${EMPTY_RESPONSE_MAX_RETRIES2})...`);
             }
-            await new Promise((resolve31) => setTimeout(resolve31, delayMs));
+            await new Promise((resolve32) => setTimeout(resolve32, delayMs));
             refreshCurrentInputOtids();
             continue;
           }
@@ -104258,7 +104629,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve31) => setTimeout(resolve31, delayMs));
+            await new Promise((resolve32) => setTimeout(resolve32, delayMs));
             refreshCurrentInputOtids();
             continue;
           }
@@ -104288,7 +104659,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve31) => setTimeout(resolve31, delayMs));
+            await new Promise((resolve32) => setTimeout(resolve32, delayMs));
             refreshCurrentInputOtids();
             continue;
           }
@@ -104326,7 +104697,7 @@ ${loadedContents.join(`
           session_id: sessionId,
           uuid: `error-${lastRunId || randomUUID15()}`
         };
-        writeWireMessage(errorMsg);
+        await writeWireMessageAsync(errorMsg);
       } else {
         console.error(`Error: ${errorMessage}`);
       }
@@ -104345,7 +104716,7 @@ ${loadedContents.join(`
         session_id: sessionId,
         uuid: `error-${lastKnownRunId || randomUUID15()}`
       };
-      writeWireMessage(errorMsg);
+      await writeWireMessageAsync(errorMsg);
     } else {
       console.error(`Error: ${errorDetails}`);
     }
@@ -104408,7 +104779,7 @@ ${loadedContents.join(`
       usage,
       uuid: resultUuid
     };
-    writeWireMessage(resultEvent);
+    await writeWireMessageAsync(resultEvent);
   } else {
     if (!resultText || resultText === "No assistant response found") {
       console.error("No assistant response found");
@@ -104607,9 +104978,9 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
     const syntheticUserLine = serializeQueuedMessageAsUserLine(queuedMessage);
     maybeNotifyBlocked(syntheticUserLine);
     if (lineResolver) {
-      const resolve31 = lineResolver;
+      const resolve32 = lineResolver;
       lineResolver = null;
-      resolve31(syntheticUserLine);
+      resolve32(syntheticUserLine);
       return;
     }
     lineQueue.push(syntheticUserLine);
@@ -104617,9 +104988,9 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
   rl.on("line", (line) => {
     maybeNotifyBlocked(line);
     if (lineResolver) {
-      const resolve31 = lineResolver;
+      const resolve32 = lineResolver;
       lineResolver = null;
-      resolve31(line);
+      resolve32(line);
     } else {
       lineQueue.push(line);
     }
@@ -104628,17 +104999,17 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
     setMessageQueueAdder(null);
     msgQueueRuntime.clear("shutdown");
     if (lineResolver) {
-      const resolve31 = lineResolver;
+      const resolve32 = lineResolver;
       lineResolver = null;
-      resolve31(null);
+      resolve32(null);
     }
   });
   async function getNextLine() {
     if (lineQueue.length > 0) {
       return lineQueue.shift() ?? null;
     }
-    return new Promise((resolve31) => {
-      lineResolver = resolve31;
+    return new Promise((resolve32) => {
+      lineResolver = resolve32;
     });
   }
   async function requestPermission(toolCallId, toolName, toolInput) {
@@ -105099,7 +105470,7 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
                 uuid: `retry-bidir-${randomUUID15()}`
               };
               writeWireMessage(retryMsg);
-              await new Promise((resolve31) => setTimeout(resolve31, delayMs));
+              await new Promise((resolve32) => setTimeout(resolve32, delayMs));
               continue;
             }
             throw preStreamError;
@@ -105399,10 +105770,10 @@ async function detectAndEnableKittyProtocol() {
     detectionComplete = true;
     return;
   }
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
       detectionComplete = true;
-      resolve31();
+      resolve32();
       return;
     }
     const originalRawMode = process.stdin.isRaw;
@@ -105435,7 +105806,7 @@ async function detectAndEnableKittyProtocol() {
         console.error("[kitty] protocol query unsupported; enabled anyway (best-effort)");
       }
       detectionComplete = true;
-      resolve31();
+      resolve32();
     };
     const handleData = (data) => {
       if (timeoutId === undefined) {
@@ -127540,9 +127911,9 @@ var init_pasteRegistry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync38, readFileSync as readFileSync24, statSync as statSync10, unlinkSync as unlinkSync10 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync25, statSync as statSync11, unlinkSync as unlinkSync10 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename13, extname as extname8, isAbsolute as isAbsolute20, join as join45, resolve as resolve31 } from "node:path";
+import { basename as basename13, extname as extname8, isAbsolute as isAbsolute20, join as join45, resolve as resolve32 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
 }
@@ -127592,21 +127963,21 @@ function translatePasteForImages(paste) {
         } catch {}
       }
       if (!isAbsolute20(filePath))
-        filePath = resolve31(process.cwd(), filePath);
+        filePath = resolve32(process.cwd(), filePath);
       const ext3 = extname8(filePath || "").toLowerCase();
       if (IMAGE_EXTS.has(ext3)) {
         let buf = null;
         try {
-          const stat8 = statSync10(filePath);
+          const stat8 = statSync11(filePath);
           if (stat8.isFile())
-            buf = readFileSync24(filePath);
+            buf = readFileSync25(filePath);
         } catch {}
         let clipboardMediaType = null;
         if (!buf && process.platform === "darwin" && /TemporaryItems\/.*screencaptureui/i.test(filePath)) {
           const clipResult = getClipboardImageToTempFile();
           if (clipResult) {
             try {
-              buf = readFileSync24(clipResult.tempPath);
+              buf = readFileSync25(clipResult.tempPath);
               clipboardMediaType = UTI_TO_MEDIA_TYPE[clipResult.uti] || null;
               try {
                 unlinkSync10(clipResult.tempPath);
@@ -127675,7 +128046,7 @@ async function tryImportClipboardImageMac() {
     return null;
   const { tempPath, uti } = clipboardResult;
   try {
-    const buffer = readFileSync24(tempPath);
+    const buffer = readFileSync25(tempPath);
     try {
       unlinkSync10(tempPath);
     } catch {}
@@ -128290,8 +128661,8 @@ async function pushToMemoryRepositoryWithTimeout(agentId) {
   try {
     return await Promise.race([
       pushToMemoryRepository(agentId),
-      new Promise((resolve32) => {
-        timeout = setTimeout(() => resolve32("timeout"), INITIAL_PUSH_TIMEOUT_MS);
+      new Promise((resolve33) => {
+        timeout = setTimeout(() => resolve33("timeout"), INITIAL_PUSH_TIMEOUT_MS);
       })
     ]);
   } finally {
@@ -128542,11 +128913,11 @@ import {
   copyFileSync,
   existsSync as existsSync39,
   mkdirSync as mkdirSync30,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync26,
   writeFileSync as writeFileSync21
 } from "node:fs";
 import { homedir as homedir32, platform as platform6 } from "node:os";
-import { dirname as dirname19, join as join46 } from "node:path";
+import { dirname as dirname20, join as join46 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -128612,7 +128983,7 @@ function keybindingExists(keybindingsPath) {
   if (!existsSync39(keybindingsPath))
     return false;
   try {
-    const content = readFileSync25(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync26(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings)
       return false;
@@ -128637,7 +129008,7 @@ function installKeybinding(keybindingsPath) {
     if (keybindingExists(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname19(keybindingsPath);
+    const parentDir = dirname20(keybindingsPath);
     if (!existsSync39(parentDir)) {
       mkdirSync30(parentDir, { recursive: true });
     }
@@ -128645,7 +129016,7 @@ function installKeybinding(keybindingsPath) {
     let backupPath = null;
     if (existsSync39(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
-      const content = readFileSync25(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync26(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
       if (parsed === null) {
         return {
@@ -128676,7 +129047,7 @@ function removeKeybinding(keybindingsPath) {
     if (!existsSync39(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync25(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync26(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings) {
       return {
@@ -128753,7 +129124,7 @@ function wezTermDeleteFixExists(configPath) {
   if (!existsSync39(configPath))
     return false;
   try {
-    const content = readFileSync25(configPath, { encoding: "utf-8" });
+    const content = readFileSync26(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -128770,7 +129141,7 @@ function installWezTermDeleteFix() {
     if (existsSync39(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync(configPath, backupPath);
-      content = readFileSync25(configPath, { encoding: "utf-8" });
+      content = readFileSync26(configPath, { encoding: "utf-8" });
     }
     if (content.includes("return {") && !content.includes("local config")) {
       content = content.replace(/return\s*\{/, "local config = {");
@@ -128796,7 +129167,7 @@ return config`);
 ${WEZTERM_DELETE_FIX}
 `;
     }
-    const parentDir = dirname19(configPath);
+    const parentDir = dirname20(configPath);
     if (!existsSync39(parentDir)) {
       mkdirSync30(parentDir, { recursive: true });
     }
@@ -129396,7 +129767,7 @@ __export(exports_custom, {
 });
 import { existsSync as existsSync40 } from "node:fs";
 import { readdir as readdir10, readFile as readFile16 } from "node:fs/promises";
-import { basename as basename14, dirname as dirname20, join as join47 } from "node:path";
+import { basename as basename14, dirname as dirname21, join as join47 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -129457,7 +129828,7 @@ async function parseCommandFile(filePath, rootPath, source2) {
   const content = await readFile16(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const id = basename14(filePath, ".md");
-  const relativePath = dirname20(filePath).slice(rootPath.length);
+  const relativePath = dirname21(filePath).slice(rootPath.length);
   const namespace = relativePath.replace(/^[/\\]/, "") || undefined;
   let description = getStringField(frontmatter, "description");
   if (!description) {
@@ -129806,11 +130177,11 @@ var init_HelpDialog = __esm(async () => {
 
 // src/hooks/writer.ts
 import { homedir as homedir33 } from "node:os";
-import { resolve as resolve32 } from "node:path";
+import { resolve as resolve33 } from "node:path";
 function isProjectSettingsPathCollidingWithGlobal2(workingDirectory) {
   const home = process.env.HOME || homedir33();
-  const globalSettingsPath = resolve32(home, ".letta", "settings.json");
-  const projectSettingsPath = resolve32(workingDirectory, ".letta", "settings.json");
+  const globalSettingsPath = resolve33(home, ".letta", "settings.json");
+  const projectSettingsPath = resolve33(workingDirectory, ".letta", "settings.json");
   return globalSettingsPath === projectSettingsPath;
 }
 function loadHooksFromLocation(location, workingDirectory = process.cwd()) {
@@ -132449,8 +132820,8 @@ var init_AgentInfoBar = __esm(async () => {
 });
 
 // src/cli/helpers/fileSearch.ts
-import { readdirSync as readdirSync13, statSync as statSync11 } from "node:fs";
-import { join as join48, relative as relative17, resolve as resolve33 } from "node:path";
+import { readdirSync as readdirSync13, statSync as statSync12 } from "node:fs";
+import { join as join48, relative as relative17, resolve as resolve34 } from "node:path";
 function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [], depth = 0, maxDepth = 10, lowerPattern = pattern.toLowerCase()) {
   if (results.length >= maxResults || depth >= maxDepth) {
     return results;
@@ -132464,7 +132835,7 @@ function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [],
         if (shouldHardExcludeEntry(entry, getIndexRoot())) {
           continue;
         }
-        const stats = statSync11(fullPath);
+        const stats = statSync12(fullPath);
         const matches = pattern.length === 0 || relativePath.toLowerCase().includes(lowerPattern);
         if (matches) {
           results.push({
@@ -132493,9 +132864,9 @@ async function searchFiles(query, deep = false) {
       const dirPart = query.slice(0, lastSlashIndex);
       const pattern = query.slice(lastSlashIndex + 1);
       try {
-        const resolvedDir = resolve33(getIndexRoot(), dirPart);
+        const resolvedDir = resolve34(getIndexRoot(), dirPart);
         try {
-          statSync11(resolvedDir);
+          statSync12(resolvedDir);
           searchDir = resolvedDir;
           searchPattern = pattern;
         } catch {}
@@ -132538,7 +132909,7 @@ async function searchFiles(query, deep = false) {
         for (const entry of matchingEntries.slice(0, 50)) {
           try {
             const fullPath = join48(searchDir, entry);
-            const stats = statSync11(fullPath);
+            const stats = statSync12(fullPath);
             const relativePath = relative17(getIndexRoot(), fullPath);
             results.push({
               path: relativePath,
@@ -134619,12 +134990,12 @@ import {
   existsSync as existsSync41,
   mkdirSync as mkdirSync31,
   mkdtempSync,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync27,
   rmSync as rmSync4,
   writeFileSync as writeFileSync22
 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { dirname as dirname21, join as join49 } from "node:path";
+import { dirname as dirname22, join as join49 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync4(command, args, {
@@ -134871,13 +135242,13 @@ function runGit3(args, cwd2) {
 }
 function writeWorkflow(repoDir, workflowPath, content) {
   const absolutePath = join49(repoDir, workflowPath);
-  if (!existsSync41(dirname21(absolutePath))) {
-    mkdirSync31(dirname21(absolutePath), { recursive: true });
+  if (!existsSync41(dirname22(absolutePath))) {
+    mkdirSync31(dirname22(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
   if (existsSync41(absolutePath)) {
-    const previous = readFileSync26(absolutePath, "utf8");
+    const previous = readFileSync27(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
@@ -147638,7 +148009,7 @@ async function executeStatusLineCommand(command, payload, options) {
   };
 }
 function runWithLauncher(launcher, inputJson, timeout, signal, workingDirectory, startTime) {
-  return new Promise((resolve34, reject) => {
+  return new Promise((resolve35, reject) => {
     const [executable, ...args] = launcher;
     if (!executable) {
       reject(new Error("Empty launcher"));
@@ -147651,7 +148022,7 @@ function runWithLauncher(launcher, inputJson, timeout, signal, workingDirectory,
     const safeResolve = (result) => {
       if (!resolved) {
         resolved = true;
-        resolve34(result);
+        resolve35(result);
       }
     };
     let child;
@@ -148098,7 +148469,7 @@ __export(exports_shellAliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync44, readFileSync as readFileSync27 } from "node:fs";
+import { existsSync as existsSync44, readFileSync as readFileSync28 } from "node:fs";
 import { homedir as homedir36 } from "node:os";
 import { join as join52 } from "node:path";
 function parseAliasesFromFile(filePath) {
@@ -148107,7 +148478,7 @@ function parseAliasesFromFile(filePath) {
     return aliases;
   }
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync28(filePath, "utf-8");
     const lines = content.split(`
 `);
     let inFunction = false;
@@ -148826,14 +149197,14 @@ __export(exports_export, {
   packageSkills: () => packageSkills
 });
 import { readdir as readdir11, readFile as readFile18 } from "node:fs/promises";
-import { relative as relative18, resolve as resolve34 } from "node:path";
+import { relative as relative18, resolve as resolve35 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
   const skillNames = new Set;
   const dirsToCheck = skillsDir ? [skillsDir] : [
     agentId && getAgentSkillsDir(agentId),
-    resolve34(process.cwd(), ".skills"),
-    resolve34(process.env.HOME || "~", ".letta", "skills")
+    resolve35(process.cwd(), ".skills"),
+    resolve35(process.env.HOME || "~", ".letta", "skills")
   ].filter((dir) => Boolean(dir));
   for (const baseDir of dirsToCheck) {
     try {
@@ -148843,8 +149214,8 @@ async function packageSkills(agentId, skillsDir) {
           continue;
         if (skillNames.has(entry.name))
           continue;
-        const skillDir = resolve34(baseDir, entry.name);
-        const skillMdPath = resolve34(skillDir, "SKILL.md");
+        const skillDir = resolve35(baseDir, entry.name);
+        const skillMdPath = resolve35(skillDir, "SKILL.md");
         try {
           await readFile18(skillMdPath, "utf-8");
         } catch {
@@ -148874,7 +149245,7 @@ async function readSkillFiles(skillDir) {
   async function walk(dir) {
     const entries = await readdir11(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = resolve34(dir, entry.name);
+      const fullPath = resolve35(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -149018,7 +149389,7 @@ __export(exports_App, {
   default: () => App2
 });
 import { randomUUID as randomUUID16 } from "node:crypto";
-import { existsSync as existsSync45, readFileSync as readFileSync28, renameSync as renameSync3, writeFileSync as writeFileSync24 } from "node:fs";
+import { existsSync as existsSync45, readFileSync as readFileSync29, renameSync as renameSync3, writeFileSync as writeFileSync24 } from "node:fs";
 import { homedir as homedir37, tmpdir as tmpdir7 } from "node:os";
 import { join as join53, relative as relative19 } from "node:path";
 function deriveReasoningEffort(modelSettings, llmConfig) {
@@ -149245,7 +149616,7 @@ function _readPlanFile(fallbackPlanFilePath) {
     return `Plan file not found at ${planFilePath}`;
   }
   try {
-    return readFileSync28(planFilePath, "utf-8");
+    return readFileSync29(planFilePath, "utf-8");
   } catch {
     return `Failed to read plan file at ${planFilePath}`;
   }
@@ -150596,10 +150967,10 @@ function App2({
     if (!planFilePath)
       return;
     try {
-      const { readFileSync: readFileSync29, existsSync: existsSync46 } = __require("node:fs");
+      const { readFileSync: readFileSync30, existsSync: existsSync46 } = __require("node:fs");
       if (!existsSync46(planFilePath))
         return;
-      const planContent = readFileSync29(planFilePath, "utf-8");
+      const planContent = readFileSync30(planFilePath, "utf-8");
       const previewItem = {
         kind: "approval_preview",
         id: `approval-preview-${toolCallId}`,
@@ -151009,12 +151380,12 @@ Memory may be stale. Try running: git -C ~/.letta/agents/${agentId}/memory pull`
     let watcher = null;
     (async () => {
       try {
-        const { watch: watch2 } = await import("node:fs");
+        const { watch: watch3 } = await import("node:fs");
         const { existsSync: existsSync46 } = await import("node:fs");
         const memRoot = getMemoryFilesystemRoot(agentId);
         if (!existsSync46(memRoot))
           return;
-        watcher = watch2(memRoot, { recursive: true }, () => {});
+        watcher = watch3(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher;
         debugLog("memfs", `Watching memory directory: ${memRoot}`);
         watcher.on("error", (err) => {
@@ -151341,7 +151712,7 @@ ${newState.originalPrompt}`,
                   cancelled = true;
                   break;
                 }
-                await new Promise((resolve35) => setTimeout(resolve35, 100));
+                await new Promise((resolve36) => setTimeout(resolve36, 100));
               }
               buffersRef.current.byId.delete(statusId);
               buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
@@ -151405,7 +151776,7 @@ ${newState.originalPrompt}`,
                 cancelled = true;
                 break;
               }
-              await new Promise((resolve35) => setTimeout(resolve35, 100));
+              await new Promise((resolve36) => setTimeout(resolve36, 100));
             }
             if (retryStatusId) {
               buffersRef.current.byId.delete(retryStatusId);
@@ -152155,7 +152526,7 @@ ${feedback}
           });
           buffersRef.current.order.push(statusId);
           refreshDerived();
-          await new Promise((resolve35) => setTimeout(resolve35, delayMs));
+          await new Promise((resolve36) => setTimeout(resolve36, delayMs));
           buffersRef.current.byId.delete(statusId);
           buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
           refreshDerived();
@@ -152215,7 +152586,7 @@ ${feedback}
               cancelled = true;
               break;
             }
-            await new Promise((resolve35) => setTimeout(resolve35, 100));
+            await new Promise((resolve36) => setTimeout(resolve36, 100));
           }
           if (retryStatusId) {
             buffersRef.current.byId.delete(retryStatusId);
@@ -153377,7 +153748,7 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
             ];
             const personaPath = personaCandidates.find((candidate) => existsSync45(candidate));
             if (personaPath) {
-              const personaContent = readFileSync28(personaPath, "utf-8");
+              const personaContent = readFileSync29(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
             } else {
               setCurrentPersonalityId(null);
@@ -158272,11 +158643,11 @@ import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync46,
   mkdirSync as mkdirSync33,
-  readFileSync as readFileSync29,
+  readFileSync as readFileSync30,
   writeFileSync as writeFileSync25
 } from "node:fs";
 import { homedir as homedir38, platform as platform7 } from "node:os";
-import { dirname as dirname22, join as join54 } from "node:path";
+import { dirname as dirname23, join as join54 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -158342,7 +158713,7 @@ function keybindingExists2(keybindingsPath) {
   if (!existsSync46(keybindingsPath))
     return false;
   try {
-    const content = readFileSync29(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync30(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings2(content);
     if (!keybindings)
       return false;
@@ -158367,7 +158738,7 @@ function installKeybinding2(keybindingsPath) {
     if (keybindingExists2(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname22(keybindingsPath);
+    const parentDir = dirname23(keybindingsPath);
     if (!existsSync46(parentDir)) {
       mkdirSync33(parentDir, { recursive: true });
     }
@@ -158375,7 +158746,7 @@ function installKeybinding2(keybindingsPath) {
     let backupPath = null;
     if (existsSync46(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
-      const content = readFileSync29(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync30(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
       if (parsed === null) {
         return {
@@ -158406,7 +158777,7 @@ function removeKeybinding2(keybindingsPath) {
     if (!existsSync46(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync29(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync30(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings2(content);
     if (!keybindings) {
       return {
@@ -158483,7 +158854,7 @@ function wezTermDeleteFixExists2(configPath) {
   if (!existsSync46(configPath))
     return false;
   try {
-    const content = readFileSync29(configPath, { encoding: "utf-8" });
+    const content = readFileSync30(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -158500,7 +158871,7 @@ function installWezTermDeleteFix2() {
     if (existsSync46(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync2(configPath, backupPath);
-      content = readFileSync29(configPath, { encoding: "utf-8" });
+      content = readFileSync30(configPath, { encoding: "utf-8" });
     }
     if (content.includes("return {") && !content.includes("local config")) {
       content = content.replace(/return\s*\{/, "local config = {");
@@ -158526,7 +158897,7 @@ return config`);
 ${WEZTERM_DELETE_FIX2}
 `;
     }
-    const parentDir = dirname22(configPath);
+    const parentDir = dirname23(configPath);
     if (!existsSync46(parentDir)) {
       mkdirSync33(parentDir, { recursive: true });
     }
@@ -159096,10 +159467,10 @@ __export(exports_import2, {
 });
 import { createReadStream as createReadStream2 } from "node:fs";
 import { chmod as chmod2, mkdir as mkdir11, readFile as readFile19, writeFile as writeFile14 } from "node:fs/promises";
-import { dirname as dirname23, resolve as resolve35 } from "node:path";
+import { dirname as dirname24, resolve as resolve36 } from "node:path";
 async function importAgentFromFile2(options) {
   const client = await getClient();
-  const resolvedPath = resolve35(options.filePath);
+  const resolvedPath = resolve36(options.filePath);
   const file = createReadStream2(resolvedPath);
   const importResponse = await client.agents.importFile({
     file,
@@ -159134,7 +159505,7 @@ async function extractSkillsFromAf2(afPath, destDir) {
     return [];
   }
   for (const skill2 of afData.skills) {
-    const skillDir = resolve35(destDir, skill2.name);
+    const skillDir = resolve36(destDir, skill2.name);
     await mkdir11(skillDir, { recursive: true });
     if (skill2.files) {
       await writeSkillFiles2(skillDir, skill2.files);
@@ -159154,8 +159525,8 @@ async function writeSkillFiles2(skillDir, files) {
   }
 }
 async function writeSkillFile2(skillDir, filePath, content) {
-  const fullPath = resolve35(skillDir, filePath);
-  await mkdir11(dirname23(fullPath), { recursive: true });
+  const fullPath = resolve36(skillDir, filePath);
+  await mkdir11(dirname24(fullPath), { recursive: true });
   await writeFile14(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
@@ -159268,7 +159639,7 @@ __export(exports_memoryFilesystem2, {
 });
 import { existsSync as existsSync47, mkdirSync as mkdirSync34 } from "node:fs";
 import { homedir as homedir40 } from "node:os";
-import { join as join56, resolve as resolve36 } from "node:path";
+import { join as join56, resolve as resolve37 } from "node:path";
 function getMemoryFilesystemRoot2(agentId, homeDir = homedir40()) {
   return join56(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
 }
@@ -159290,7 +159661,7 @@ function resolveScopedMemoryDir2(options = {}) {
   } catch {}
   const directMemoryDir = (env4.LETTA_MEMORY_DIR || env4.MEMORY_DIR || "").trim();
   if (directMemoryDir) {
-    return resolve36(directMemoryDir);
+    return resolve37(directMemoryDir);
   }
   const envAgentId = (env4.LETTA_AGENT_ID || env4.AGENT_ID || "").trim();
   if (envAgentId) {
@@ -159519,9 +159890,9 @@ function getServerHostLabel2(serverUrl) {
   }
 }
 async function isLettaMemfsServer2() {
-  const { getMemfsServerUrl: getMemfsServerUrl2, isDesktopLocalProxyUrl: isDesktopLocalProxyUrl2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const { getMemfsServerUrl: getMemfsServerUrl2 } = 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";
+  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));
@@ -164440,11 +164811,11 @@ async function runListenSubcommand(argv) {
       connectionName = hostname3();
       settingsManager.setListenerEnvName(connectionName);
     } else {
-      connectionName = await new Promise((resolve27) => {
+      connectionName = await new Promise((resolve28) => {
         const { unmount } = render_default(/* @__PURE__ */ jsx_dev_runtime9.jsxDEV(PromptEnvName, {
           onSubmit: (name) => {
             unmount();
-            resolve27(name);
+            resolve28(name);
           }
         }, undefined, false, undefined, this));
       });
@@ -164646,7 +165017,7 @@ async function runListenSubcommand(argv) {
 
 // src/cli/subcommands/memory.ts
 init_memoryGit();
-import { cpSync, existsSync as existsSync30, mkdirSync as mkdirSync23, rmSync as rmSync3, statSync as statSync8 } from "node:fs";
+import { cpSync, existsSync as existsSync30, mkdirSync as mkdirSync23, rmSync as rmSync3, statSync as statSync9 } from "node:fs";
 import { readdir as readdir7 } from "node:fs/promises";
 import { homedir as homedir23 } from "node:os";
 import { join as join34 } from "node:path";
@@ -164814,7 +165185,7 @@ async function listBackups(agentId) {
     const path26 = join34(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat7 = statSync8(path26);
+      const stat7 = statSync9(path26);
       createdAt = stat7.mtime.toISOString();
     } catch {
       createdAt = null;
@@ -164932,7 +165303,7 @@ async function runMemorySubcommand(argv) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat7 = statSync8(backupPath);
+      const stat7 = statSync9(backupPath);
       if (!stat7.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
@@ -164955,7 +165326,7 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       if (existsSync30(out)) {
-        const stat7 = statSync8(out);
+        const stat7 = statSync9(out);
         if (stat7.isDirectory()) {
           const contents = await readdir7(out);
           if (contents.length > 0) {
@@ -164986,7 +165357,7 @@ async function runMemorySubcommand(argv) {
 init_client2();
 init_settings_manager();
 import { writeFile as writeFile11 } from "node:fs/promises";
-import { resolve as resolve27 } from "node:path";
+import { resolve as resolve28 } from "node:path";
 import { parseArgs as parseArgs9 } from "node:util";
 function printUsage6() {
   console.log(`
@@ -165291,7 +165662,7 @@ async function runMessagesSubcommand(argv) {
 
 `).trim();
       if (outputPathRaw && typeof outputPathRaw === "string") {
-        const outputPath = resolve27(process.cwd(), outputPathRaw);
+        const outputPath = resolve28(process.cwd(), outputPathRaw);
         await writeFile11(outputPath, `${transcript}
 `, "utf-8");
         console.log(JSON.stringify({
@@ -165740,7 +166111,7 @@ init_fs();
 init_secrets();
 import { randomUUID as randomUUID11 } from "node:crypto";
 import { homedir as homedir25 } from "node:os";
-import { join as join36, resolve as resolve28 } from "node:path";
+import { join as join36, resolve as resolve29 } from "node:path";
 var DEFAULT_SETTINGS3 = {
   lastAgent: null,
   tokenStreaming: false,
@@ -166219,7 +166590,7 @@ class SettingsManager2 {
     return join36(workingDirectory, ".letta", "settings.json");
   }
   isProjectSettingsPathCollidingWithGlobal(workingDirectory) {
-    return resolve28(this.getProjectSettingsPath(workingDirectory)) === resolve28(this.getSettingsPath());
+    return resolve29(this.getProjectSettingsPath(workingDirectory)) === resolve29(this.getSettingsPath());
   }
   getLocalProjectSettingsPath(workingDirectory) {
     return join36(workingDirectory, ".letta", "settings.local.json");
@@ -167251,8 +167622,8 @@ function acquireSwitchLock2() {
   const lock = getSwitchLock2();
   lock.refCount++;
   if (lock.refCount === 1) {
-    lock.promise = new Promise((resolve29) => {
-      lock.resolve = resolve29;
+    lock.promise = new Promise((resolve30) => {
+      lock.resolve = resolve30;
     });
   }
 }
@@ -167737,7 +168108,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     printHelp();
     const helpDelayMs = Number.parseInt(process.env.LETTA_TEST_HELP_EXIT_DELAY_MS ?? "", 10);
     if (Number.isFinite(helpDelayMs) && helpDelayMs > 0) {
-      await new Promise((resolve37) => setTimeout(resolve37, helpDelayMs));
+      await new Promise((resolve38) => setTimeout(resolve38, helpDelayMs));
     }
     process.exit(0);
   }
@@ -167959,9 +168330,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
         process.exit(1);
       }
     } else {
-      const { resolve: resolve37 } = await import("path");
+      const { resolve: resolve38 } = await import("path");
       const { existsSync: existsSync48 } = await import("fs");
-      const resolvedPath = resolve37(fromAfFile);
+      const resolvedPath = resolve38(fromAfFile);
       if (!existsSync48(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
@@ -167981,6 +168352,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();
@@ -167996,11 +168373,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);
@@ -168849,4 +169221,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=CB5FADB2FE73B65E64756E2164756E21
+//# debugId=25A0545792FBAA5C64756E2164756E21