@letta-ai/letta-code 0.15.2 → 0.15.4

package/letta.js

@@ -3122,7 +3122,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.15.2",
+    version: "0.15.4",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3184,6 +3184,8 @@ var init_package = __esm(() => {
       check: "bun run scripts/check.js",
       dev: "bun --loader:.md=text --loader:.mdx=text --loader:.txt=text run src/index.ts",
       build: "node scripts/postinstall-patches.js && bun run build.js",
+      "test:update-chain:manual": "bun run src/tests/update-chain-smoke.ts --mode manual",
+      "test:update-chain:startup": "bun run src/tests/update-chain-smoke.ts --mode startup",
       prepublishOnly: "bun run build",
       postinstall: "node scripts/postinstall-patches.js"
     },
@@ -4437,6 +4439,57 @@ var init_timing = __esm(() => {
   milestones = new Map;
 });
 
+// src/agent/skillSources.ts
+function isSkillSource(value) {
+  return ALL_SKILL_SOURCES.includes(value);
+}
+function normalizeSkillSources(sources) {
+  const sourceSet = new Set(sources);
+  return ALL_SKILL_SOURCES.filter((source) => sourceSet.has(source));
+}
+function parseSkillSourcesList(skillSourcesRaw) {
+  const tokens = skillSourcesRaw.split(",").map((source) => source.trim()).filter((source) => source.length > 0);
+  if (tokens.length === 0) {
+    throw new Error("--skill-sources must include at least one source (e.g. bundled,project)");
+  }
+  const sources = [];
+  for (const token of tokens) {
+    const source = token;
+    if (!VALID_SKILL_SOURCE_SPECIFIERS.includes(source)) {
+      throw new Error(`Invalid skill source "${token}". Valid values: ${VALID_SKILL_SOURCE_SPECIFIERS.join(", ")}`);
+    }
+    if (source === "all") {
+      sources.push(...ALL_SKILL_SOURCES);
+      continue;
+    }
+    if (isSkillSource(source)) {
+      sources.push(source);
+    }
+  }
+  return normalizeSkillSources(sources);
+}
+function resolveSkillSourcesSelection(input) {
+  if (input.noSkills) {
+    return [];
+  }
+  const configuredSources = input.skillSourcesRaw ? parseSkillSourcesList(input.skillSourcesRaw) : [...ALL_SKILL_SOURCES];
+  const filteredSources = input.noBundledSkills ? configuredSources.filter((source) => source !== "bundled") : configuredSources;
+  return normalizeSkillSources(filteredSources);
+}
+var ALL_SKILL_SOURCES, VALID_SKILL_SOURCE_SPECIFIERS;
+var init_skillSources = __esm(() => {
+  ALL_SKILL_SOURCES = [
+    "bundled",
+    "global",
+    "agent",
+    "project"
+  ];
+  VALID_SKILL_SOURCE_SPECIFIERS = [
+    "all",
+    ...ALL_SKILL_SOURCES
+  ];
+});
+
 // src/agent/memoryConstants.ts
 var READ_ONLY_BLOCK_LABELS;
 var init_memoryConstants = __esm(() => {
@@ -5635,13 +5688,15 @@ If the user asks for help or wants to give feedback inform them of the following
 
 When the user directly asks about Letta Code (eg 'can Letta Code do...', 'does Letta Code have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the WebFetch tool to gather information to answer the question from the Letta Code repository at https://github.com/letta-ai/letta-code.
 
+When running in Letta Code, shell tools provide \`AGENT_ID\`: your current agent ID.
+
 # Skills
  - /<skill-name> (e.g., /commit) is shorthand for users to invoke a skill. When executed, the skill gets expanded to a full prompt. Use the Skill tool to execute them. IMPORTANT: Only use Skill for skills listed in system-reminder messages in the conversation - do not guess or use built-in CLI commands.
 `;
 var init_system_prompt = () => {};
 
 // src/agent/prompts/system_prompt_memfs.txt
-var system_prompt_memfs_default = "\n# Memory\n\nYou have an advanced memory system that enables you to remember past interactions and continuously improve your own capabilities.\n\n## Memory Filesystem\nYour memory is stored in a git repository at `~/.letta/agents/<agent-id>/memory/`. This provides full version control, sync with the server, and create worktrees for parallel edits.\nEach file contains metadata frontmatter include a `description` (the description of the file's contents), `limit` (the character limit), and optional `metadata`.\nThe filesystem tree is always available in your system prompt, along with the contents of files in the `system/` folder.\nYou also have additional external memory (e.g. your message history) that is accessible and that you can bring into context with tools when needed.\n\n## How It Works\n1. Each `.md` file in `memory/system/` is pinned to your system prompt with tags <system/context/{name}.md></system/context/{name}.md>\n2. The `memory_filesystem` block renders the current tree view of all available memory files\n2. Changes pushed to git sync to the API server within seconds\n3. API server changes sync to git automatically\n4. The system prompt is only recompiled with the latest memory on the API on compactions or message resets: your local copy may diverge\n\n## Syncing\n```bash\ncd ~/.letta/agents/<agent-id>/memory\n\n# See what changed\ngit status\n\n# Commit and push your changes\ngit add system/\ngit commit -m \"<type>: <what changed>\"  # e.g. \"fix: update user prefs\", \"refactor: reorganize persona blocks\"\ngit push\n\n# Get latest from server\ngit pull\n```\nThe system will remind you when your memory has uncommitted changes. Sync when convenient.\n\n## History\n```bash\ngit -C ~/.letta/agents/<agent-id>/memory log --oneline\n```\n";
+var system_prompt_memfs_default = "\n# Memory\n\nYou have an advanced memory system that enables you to remember past interactions and continuously improve your own capabilities.\n\n## Memory Filesystem\nYour memory is stored in a git repository at `$MEMORY_DIR` (absolute path provided by Letta Code shell tools; usually `~/.letta/agents/$AGENT_ID/memory/`). This provides full version control, sync with the server, and create worktrees for parallel edits.\nEach file contains metadata frontmatter include a `description` (the description of the file's contents), `limit` (the character limit), and optional `metadata`.\nThe filesystem tree is always available in your system prompt, along with the contents of files in the `system/` folder.\nYou also have additional external memory (e.g. your message history) that is accessible and that you can bring into context with tools when needed.\n\n## How It Works\n1. Each `.md` file in `memory/system/` is pinned to your system prompt with tags <system/context/{name}.md></system/context/{name}.md>\n2. The `memory_filesystem` block renders the current tree view of all available memory files\n2. Changes pushed to git sync to the API server within seconds\n3. API server changes sync to git automatically\n4. The system prompt is only recompiled with the latest memory on the API on compactions or message resets: your local copy may diverge\n\n## Syncing\n```bash\ncd \"$MEMORY_DIR\"\n\n# See what changed\ngit status\n\n# Commit and push your changes\ngit add system/\ngit commit -m \"<type>: <what changed>\"  # e.g. \"fix: update user prefs\", \"refactor: reorganize persona blocks\"\ngit push\n\n# Get latest from server\ngit pull\n```\nThe system will remind you when your memory has uncommitted changes. Sync when convenient.\n\n## History\n```bash\ngit -C \"$MEMORY_DIR\" log --oneline\n```\n";
 var init_system_prompt_memfs = () => {};
 
 // src/agent/prompts/system_prompt_memory.txt
@@ -35031,6 +35086,7 @@ __export(exports_context, {
   setConversationId: () => setConversationId2,
   setAgentContext: () => setAgentContext2,
   getSkillsDirectory: () => getSkillsDirectory,
+  getSkillSources: () => getSkillSources,
   getNoSkills: () => getNoSkills,
   getCurrentAgentId: () => getCurrentAgentId,
   getConversationId: () => getConversationId
@@ -35041,16 +35097,16 @@ function getContext2() {
     global2[CONTEXT_KEY2] = {
       agentId: null,
       skillsDirectory: null,
-      noSkills: false,
+      skillSources: [...ALL_SKILL_SOURCES],
       conversationId: null
     };
   }
   return global2[CONTEXT_KEY2];
 }
-function setAgentContext2(agentId, skillsDirectory, noSkills) {
+function setAgentContext2(agentId, skillsDirectory, skillSources) {
   context2.agentId = agentId;
   context2.skillsDirectory = skillsDirectory || null;
-  context2.noSkills = noSkills ?? false;
+  context2.skillSources = skillSources !== undefined ? [...skillSources] : [...ALL_SKILL_SOURCES];
 }
 function setCurrentAgentId(agentId) {
   context2.agentId = agentId;
@@ -35064,8 +35120,11 @@ function getCurrentAgentId() {
 function getSkillsDirectory() {
   return context2.skillsDirectory;
 }
+function getSkillSources() {
+  return [...context2.skillSources];
+}
 function getNoSkills() {
-  return context2.noSkills;
+  return !context2.skillSources.includes("bundled");
 }
 function setConversationId2(conversationId) {
   context2.conversationId = conversationId;
@@ -35075,6 +35134,7 @@ function getConversationId() {
 }
 var CONTEXT_KEY2, context2;
 var init_context = __esm(() => {
+  init_skillSources();
   CONTEXT_KEY2 = Symbol.for("@letta/agentContext");
   context2 = getContext2();
 });
@@ -37549,6 +37609,926 @@ var init_process_manager = __esm(() => {
   backgroundTasks = new Map;
 });
 
+// src/providers/openai-codex-provider.ts
+var exports_openai_codex_provider = {};
+__export(exports_openai_codex_provider, {
+  updateOpenAICodexProvider: () => updateOpenAICodexProvider,
+  removeOpenAICodexProvider: () => removeOpenAICodexProvider,
+  listProviders: () => listProviders,
+  getOpenAICodexProvider: () => getOpenAICodexProvider,
+  deleteOpenAICodexProvider: () => deleteOpenAICodexProvider,
+  createOrUpdateOpenAICodexProvider: () => createOrUpdateOpenAICodexProvider,
+  createOpenAICodexProvider: () => createOpenAICodexProvider,
+  checkOpenAICodexEligibility: () => checkOpenAICodexEligibility,
+  OPENAI_CODEX_PROVIDER_NAME: () => OPENAI_CODEX_PROVIDER_NAME,
+  CHATGPT_OAUTH_PROVIDER_TYPE: () => CHATGPT_OAUTH_PROVIDER_TYPE
+});
+async function getLettaConfig() {
+  const settings = await settingsManager.getSettingsWithSecureTokens();
+  const baseUrl = process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
+  const apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY || "";
+  return { baseUrl, apiKey };
+}
+async function providersRequest(method, path3, body) {
+  const { baseUrl, apiKey } = await getLettaConfig();
+  const url = `${baseUrl}${path3}`;
+  const response = await fetch(url, {
+    method,
+    headers: getLettaCodeHeaders2(apiKey),
+    ...body && { body: JSON.stringify(body) }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    if (response.status === 403) {
+      try {
+        const errorData = JSON.parse(errorText);
+        if (errorData.error && typeof errorData.error === "string" && errorData.error.includes("only available for pro or enterprise")) {
+          throw new Error("PLAN_UPGRADE_REQUIRED");
+        }
+      } catch (parseError) {
+        if (parseError instanceof Error && parseError.message === "PLAN_UPGRADE_REQUIRED") {
+          throw parseError;
+        }
+      }
+    }
+    throw new Error(`Provider API error (${response.status}): ${errorText}`);
+  }
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  return JSON.parse(text);
+}
+async function listProviders() {
+  try {
+    const response = await providersRequest("GET", "/v1/providers");
+    return response;
+  } catch {
+    return [];
+  }
+}
+async function getOpenAICodexProvider() {
+  const providers = await listProviders();
+  return providers.find((p) => p.name === OPENAI_CODEX_PROVIDER_NAME) || null;
+}
+async function createOpenAICodexProvider(config) {
+  const apiKeyJson = JSON.stringify({
+    access_token: config.access_token,
+    id_token: config.id_token,
+    refresh_token: config.refresh_token,
+    account_id: config.account_id,
+    expires_at: config.expires_at
+  });
+  return providersRequest("POST", "/v1/providers", {
+    name: OPENAI_CODEX_PROVIDER_NAME,
+    provider_type: CHATGPT_OAUTH_PROVIDER_TYPE,
+    api_key: apiKeyJson
+  });
+}
+async function updateOpenAICodexProvider(providerId, config) {
+  const apiKeyJson = JSON.stringify({
+    access_token: config.access_token,
+    id_token: config.id_token,
+    refresh_token: config.refresh_token,
+    account_id: config.account_id,
+    expires_at: config.expires_at
+  });
+  return providersRequest("PATCH", `/v1/providers/${providerId}`, {
+    api_key: apiKeyJson
+  });
+}
+async function deleteOpenAICodexProvider(providerId) {
+  await providersRequest("DELETE", `/v1/providers/${providerId}`);
+}
+async function createOrUpdateOpenAICodexProvider(config) {
+  const existing = await getOpenAICodexProvider();
+  if (existing) {
+    return updateOpenAICodexProvider(existing.id, config);
+  } else {
+    return createOpenAICodexProvider(config);
+  }
+}
+async function removeOpenAICodexProvider() {
+  const existing = await getOpenAICodexProvider();
+  if (existing) {
+    await deleteOpenAICodexProvider(existing.id);
+  }
+}
+async function checkOpenAICodexEligibility() {
+  try {
+    const balance = await providersRequest("GET", "/v1/metadata/balance");
+    const billingTier = balance.billing_tier.toLowerCase();
+    if (billingTier === "pro" || billingTier === "enterprise") {
+      return {
+        eligible: true,
+        billing_tier: balance.billing_tier
+      };
+    }
+    return {
+      eligible: false,
+      billing_tier: balance.billing_tier,
+      reason: `ChatGPT OAuth requires a Pro or Enterprise plan. Current plan: ${balance.billing_tier}`
+    };
+  } catch (error) {
+    console.warn("Failed to check ChatGPT OAuth eligibility:", error);
+    return {
+      eligible: true,
+      billing_tier: "unknown"
+    };
+  }
+}
+var OPENAI_CODEX_PROVIDER_NAME = "chatgpt-plus-pro", CHATGPT_OAUTH_PROVIDER_TYPE = "chatgpt_oauth";
+var init_openai_codex_provider = __esm(async () => {
+  init_http_headers();
+  init_oauth();
+  await init_settings_manager();
+});
+
+// src/agent/available-models.ts
+var exports_available_models = {};
+__export(exports_available_models, {
+  prefetchAvailableModelHandles: () => prefetchAvailableModelHandles,
+  getModelContextWindow: () => getModelContextWindow,
+  getAvailableModelsCacheInfo: () => getAvailableModelsCacheInfo,
+  getAvailableModelHandles: () => getAvailableModelHandles,
+  clearAvailableModelsCache: () => clearAvailableModelsCache
+});
+function isFresh(now = Date.now()) {
+  return cache4 !== null && now - cache4.fetchedAt < CACHE_TTL_MS;
+}
+function clearAvailableModelsCache() {
+  cache4 = null;
+}
+function getAvailableModelsCacheInfo() {
+  const now = Date.now();
+  return {
+    hasCache: cache4 !== null,
+    isFresh: isFresh(now),
+    fetchedAt: cache4?.fetchedAt ?? null,
+    ageMs: cache4 ? now - cache4.fetchedAt : null,
+    ttlMs: CACHE_TTL_MS
+  };
+}
+async function refreshByokProviders() {
+  const client = await getClient2();
+  try {
+    const providers = await client.get("/v1/providers/");
+    const byokProviders = providers.filter((p) => p.provider_category === "byok");
+    await Promise.allSettled(byokProviders.map(async (provider) => {
+      try {
+        await client.patch(`/v1/providers/${provider.id}/refresh`);
+      } catch (error) {
+        debugWarn("available-models", `Failed to refresh provider ${provider.name} (${provider.id}):`, error);
+      }
+    }));
+  } catch (error) {
+    debugWarn("available-models", "Failed to list providers for refresh:", error);
+  }
+}
+async function fetchFromNetwork() {
+  const client = await getClient2();
+  const modelsList = await client.models.list();
+  const handles = new Set(modelsList.map((m) => m.handle).filter((h) => !!h));
+  const contextWindows = new Map;
+  for (const model of modelsList) {
+    if (model.handle && model.max_context_window) {
+      contextWindows.set(model.handle, model.max_context_window);
+    }
+  }
+  return { handles, contextWindows, fetchedAt: Date.now() };
+}
+async function getAvailableModelHandles(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const now = Date.now();
+  if (!forceRefresh && isFresh(now) && cache4) {
+    return {
+      handles: cache4.handles,
+      source: "cache",
+      fetchedAt: cache4.fetchedAt
+    };
+  }
+  if (!forceRefresh && inflight) {
+    const entry2 = await inflight;
+    return {
+      handles: entry2.handles,
+      source: "network",
+      fetchedAt: entry2.fetchedAt
+    };
+  }
+  if (forceRefresh) {
+    await refreshByokProviders();
+  }
+  inflight = fetchFromNetwork().then((entry2) => {
+    cache4 = entry2;
+    return entry2;
+  }).finally(() => {
+    inflight = null;
+  });
+  const entry = await inflight;
+  return {
+    handles: entry.handles,
+    source: "network",
+    fetchedAt: entry.fetchedAt
+  };
+}
+function prefetchAvailableModelHandles() {
+  getAvailableModelHandles().catch(() => {});
+}
+async function getModelContextWindow(handle) {
+  if (!cache4) {
+    await getAvailableModelHandles();
+  }
+  return cache4?.contextWindows.get(handle);
+}
+var CACHE_TTL_MS, cache4 = null, inflight = null;
+var init_available_models = __esm(async () => {
+  init_debug();
+  await init_client2();
+  CACHE_TTL_MS = 5 * 60 * 1000;
+});
+
+// src/agent/memoryPrompt.ts
+var exports_memoryPrompt = {};
+__export(exports_memoryPrompt, {
+  stripManagedMemorySections: () => stripManagedMemorySections,
+  reconcileMemoryPrompt: () => reconcileMemoryPrompt,
+  detectMemoryPromptDrift: () => detectMemoryPromptDrift
+});
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, `
+`);
+}
+function scanHeadingsOutsideFences(text) {
+  const lines = text.split(`
+`);
+  const headings = [];
+  let inFence = false;
+  let fenceToken = "";
+  let offset = 0;
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    const fenceMatch = trimmed.match(/^(```+|~~~+)/);
+    if (fenceMatch) {
+      const token = fenceMatch[1] ?? fenceMatch[0] ?? "";
+      const tokenChar = token.startsWith("`") ? "`" : "~";
+      if (!inFence) {
+        inFence = true;
+        fenceToken = tokenChar;
+      } else if (fenceToken === tokenChar) {
+        inFence = false;
+        fenceToken = "";
+      }
+    }
+    if (!inFence) {
+      const headingMatch = line.match(/^\s*(#{1,6})\s+(.+?)\s*$/);
+      if (headingMatch) {
+        const hashes = headingMatch[1] ?? "";
+        const rawTitle = headingMatch[2] ?? "";
+        if (hashes && rawTitle) {
+          const level = hashes.length;
+          const title = rawTitle.replace(/\s+#*$/, "").trim();
+          headings.push({
+            level,
+            title,
+            startOffset: offset
+          });
+        }
+      }
+    }
+    offset += line.length + 1;
+  }
+  return headings;
+}
+function stripHeadingSections(text, shouldStrip) {
+  let current = text;
+  while (true) {
+    const headings = scanHeadingsOutsideFences(current);
+    const target = headings.find(shouldStrip);
+    if (!target) {
+      return current;
+    }
+    const nextHeading = headings.find((heading) => heading.startOffset > target.startOffset && heading.level <= target.level);
+    const end = nextHeading ? nextHeading.startOffset : current.length;
+    current = `${current.slice(0, target.startOffset)}${current.slice(end)}`;
+  }
+}
+function getMemfsTailFragment() {
+  const tailAnchor = "# See what changed";
+  const start = SYSTEM_PROMPT_MEMFS_ADDON.indexOf(tailAnchor);
+  if (start === -1)
+    return "";
+  return SYSTEM_PROMPT_MEMFS_ADDON.slice(start).trim();
+}
+function stripExactAddon(text, addon) {
+  const trimmedAddon = addon.trim();
+  if (!trimmedAddon)
+    return text;
+  let current = text;
+  while (current.includes(trimmedAddon)) {
+    current = current.replace(trimmedAddon, "");
+  }
+  return current;
+}
+function stripOrphanMemfsTail(text) {
+  const tail = getMemfsTailFragment();
+  if (!tail)
+    return text;
+  let current = text;
+  while (current.includes(tail)) {
+    current = current.replace(tail, "");
+  }
+  return current;
+}
+function compactBlankLines(text) {
+  return text.replace(/\n{3,}/g, `
+
+`).trimEnd();
+}
+function stripManagedMemorySections(systemPrompt) {
+  let current = normalizeNewlines(systemPrompt);
+  current = stripExactAddon(current, SYSTEM_PROMPT_MEMORY_ADDON);
+  current = stripExactAddon(current, SYSTEM_PROMPT_MEMFS_ADDON);
+  current = stripOrphanMemfsTail(current);
+  current = stripHeadingSections(current, (heading) => heading.title === "Memory");
+  current = stripHeadingSections(current, (heading) => heading.title.startsWith("Memory Filesystem"));
+  return compactBlankLines(current);
+}
+function reconcileMemoryPrompt(systemPrompt, mode) {
+  const base2 = stripManagedMemorySections(systemPrompt).trimEnd();
+  const addon = mode === "memfs" ? SYSTEM_PROMPT_MEMFS_ADDON.trimStart() : SYSTEM_PROMPT_MEMORY_ADDON.trimStart();
+  return `${base2}
+
+${addon}`.trim();
+}
+function detectMemoryPromptDrift(systemPrompt, expectedMode) {
+  const prompt = normalizeNewlines(systemPrompt);
+  const drifts = [];
+  const hasLegacyMemoryLanguage = prompt.includes("Your memory consists of core memory (composed of memory blocks)");
+  const hasMemfsLanguage = prompt.includes("## Memory Filesystem") || prompt.includes("Your memory is stored in a git repository at");
+  const hasOrphanFragment = prompt.includes("# See what changed") && prompt.includes("git add system/") && prompt.includes('git commit -m "<type>: <what changed>"');
+  if (expectedMode === "memfs" && hasLegacyMemoryLanguage) {
+    drifts.push({
+      code: "legacy_memory_language_with_memfs",
+      message: "System prompt contains legacy memory-block language while memfs is enabled."
+    });
+  }
+  if (expectedMode === "standard" && hasMemfsLanguage) {
+    drifts.push({
+      code: "memfs_language_with_standard_mode",
+      message: "System prompt contains Memory Filesystem language while memfs is disabled."
+    });
+  }
+  if (hasOrphanFragment && !hasMemfsLanguage) {
+    drifts.push({
+      code: "orphan_memfs_fragment",
+      message: "System prompt contains orphaned memfs sync fragment without a full memfs section."
+    });
+  }
+  return drifts;
+}
+var init_memoryPrompt = __esm(() => {
+  init_promptAssets();
+});
+
+// src/agent/modify.ts
+var exports_modify = {};
+__export(exports_modify, {
+  updateAgentSystemPromptRaw: () => updateAgentSystemPromptRaw,
+  updateAgentSystemPromptMemfs: () => updateAgentSystemPromptMemfs,
+  updateAgentSystemPrompt: () => updateAgentSystemPrompt,
+  updateAgentLLMConfig: () => updateAgentLLMConfig
+});
+function buildModelSettings(modelHandle, updateArgs) {
+  const isOpenAI = modelHandle.startsWith("openai/") || modelHandle.startsWith(`${OPENAI_CODEX_PROVIDER_NAME}/`);
+  const isAnthropic = modelHandle.startsWith("anthropic/") || modelHandle.startsWith("claude-pro-max/");
+  const isZai = modelHandle.startsWith("zai/");
+  const isGoogleAI = modelHandle.startsWith("google_ai/");
+  const isGoogleVertex = modelHandle.startsWith("google_vertex/");
+  const isOpenRouter = modelHandle.startsWith("openrouter/");
+  const isBedrock = modelHandle.startsWith("bedrock/");
+  let settings;
+  if (isOpenAI || isOpenRouter) {
+    const openaiSettings = {
+      provider_type: "openai",
+      parallel_tool_calls: true
+    };
+    if (updateArgs?.reasoning_effort) {
+      openaiSettings.reasoning = {
+        reasoning_effort: updateArgs.reasoning_effort
+      };
+    }
+    settings = openaiSettings;
+  } else if (isAnthropic) {
+    const anthropicSettings = {
+      provider_type: "anthropic",
+      parallel_tool_calls: true
+    };
+    if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
+      anthropicSettings.thinking = {
+        type: updateArgs?.enable_reasoner === false ? "disabled" : "enabled",
+        ...typeof updateArgs?.max_reasoning_tokens === "number" && {
+          budget_tokens: updateArgs.max_reasoning_tokens
+        }
+      };
+    }
+    settings = anthropicSettings;
+  } else if (isZai) {
+    settings = {
+      provider_type: "zai",
+      parallel_tool_calls: true
+    };
+  } else if (isGoogleAI) {
+    const googleSettings = {
+      provider_type: "google_ai",
+      parallel_tool_calls: true
+    };
+    if (updateArgs?.thinking_budget !== undefined) {
+      googleSettings.thinking_config = {
+        thinking_budget: updateArgs.thinking_budget
+      };
+    }
+    if (typeof updateArgs?.temperature === "number") {
+      googleSettings.temperature = updateArgs.temperature;
+    }
+    settings = googleSettings;
+  } else if (isGoogleVertex) {
+    const googleVertexSettings = {
+      provider_type: "google_vertex",
+      parallel_tool_calls: true
+    };
+    if (updateArgs?.thinking_budget !== undefined) {
+      googleVertexSettings.thinking_config = {
+        thinking_budget: updateArgs.thinking_budget
+      };
+    }
+    if (typeof updateArgs?.temperature === "number") {
+      googleVertexSettings.temperature = updateArgs.temperature;
+    }
+    settings = googleVertexSettings;
+  } else if (isBedrock) {
+    const bedrockSettings = {
+      provider_type: "bedrock",
+      parallel_tool_calls: true
+    };
+    if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
+      bedrockSettings.thinking = {
+        type: updateArgs?.enable_reasoner === false ? "disabled" : "enabled",
+        ...typeof updateArgs?.max_reasoning_tokens === "number" && {
+          budget_tokens: updateArgs.max_reasoning_tokens
+        }
+      };
+    }
+    settings = bedrockSettings;
+  } else {
+    settings = {};
+  }
+  if (typeof updateArgs?.max_output_tokens === "number" && "provider_type" in settings) {
+    settings.max_output_tokens = updateArgs.max_output_tokens;
+  }
+  return settings;
+}
+async function updateAgentLLMConfig(agentId, modelHandle, updateArgs) {
+  const client = await getClient2();
+  const modelSettings = buildModelSettings(modelHandle, updateArgs);
+  const contextWindow = updateArgs?.context_window ?? await getModelContextWindow(modelHandle);
+  const hasModelSettings = Object.keys(modelSettings).length > 0;
+  await client.agents.update(agentId, {
+    model: modelHandle,
+    ...hasModelSettings && { model_settings: modelSettings },
+    ...contextWindow && { context_window_limit: contextWindow },
+    ...typeof updateArgs?.max_output_tokens === "number" && {
+      max_tokens: updateArgs.max_output_tokens
+    }
+  });
+  const finalAgent = await client.agents.retrieve(agentId);
+  return finalAgent.llm_config;
+}
+async function updateAgentSystemPromptRaw(agentId, systemPromptContent) {
+  try {
+    const client = await getClient2();
+    await client.agents.update(agentId, {
+      system: systemPromptContent
+    });
+    return {
+      success: true,
+      message: "System prompt updated successfully"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to update system prompt: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function updateAgentSystemPrompt(agentId, systemPromptId) {
+  try {
+    const { resolveSystemPrompt: resolveSystemPrompt2 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+    const { detectMemoryPromptDrift: detectMemoryPromptDrift2, reconcileMemoryPrompt: reconcileMemoryPrompt2 } = await Promise.resolve().then(() => (init_memoryPrompt(), exports_memoryPrompt));
+    const { settingsManager: settingsManager3 } = await init_settings_manager().then(() => exports_settings_manager);
+    const client = await getClient2();
+    const currentAgent = await client.agents.retrieve(agentId);
+    const baseContent = await resolveSystemPrompt2(systemPromptId);
+    const settingIndicatesMemfs = settingsManager3.isMemfsEnabled(agentId);
+    const promptIndicatesMemfs = detectMemoryPromptDrift2(currentAgent.system || "", "standard").some((drift) => drift.code === "memfs_language_with_standard_mode");
+    const memoryMode = settingIndicatesMemfs || promptIndicatesMemfs ? "memfs" : "standard";
+    const systemPromptContent = reconcileMemoryPrompt2(baseContent, memoryMode);
+    const updateResult = await updateAgentSystemPromptRaw(agentId, systemPromptContent);
+    if (!updateResult.success) {
+      return {
+        success: false,
+        message: updateResult.message,
+        agent: null
+      };
+    }
+    const agent = await client.agents.retrieve(agentId);
+    return {
+      success: true,
+      message: "System prompt applied successfully",
+      agent
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to apply system prompt: ${error instanceof Error ? error.message : String(error)}`,
+      agent: null
+    };
+  }
+}
+async function updateAgentSystemPromptMemfs(agentId, enableMemfs) {
+  try {
+    const client = await getClient2();
+    const agent = await client.agents.retrieve(agentId);
+    const { reconcileMemoryPrompt: reconcileMemoryPrompt2 } = await Promise.resolve().then(() => (init_memoryPrompt(), exports_memoryPrompt));
+    const nextSystemPrompt = reconcileMemoryPrompt2(agent.system || "", enableMemfs ? "memfs" : "standard");
+    await client.agents.update(agentId, {
+      system: nextSystemPrompt
+    });
+    return {
+      success: true,
+      message: enableMemfs ? "System prompt updated to include Memory Filesystem section" : "System prompt updated to include standard Memory section"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to update system prompt memfs: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+var init_modify = __esm(async () => {
+  await __promiseAll([
+    init_openai_codex_provider(),
+    init_available_models(),
+    init_client2()
+  ]);
+});
+
+// src/tools/filter.ts
+var exports_filter = {};
+__export(exports_filter, {
+  toolFilter: () => toolFilter
+});
+
+class ToolFilterManager {
+  enabledTools = null;
+  setEnabledTools(toolsString) {
+    if (toolsString === "") {
+      this.enabledTools = [];
+    } else {
+      this.enabledTools = toolsString.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+    }
+  }
+  isEnabled(toolName) {
+    if (this.enabledTools === null) {
+      return true;
+    }
+    return this.enabledTools.includes(toolName);
+  }
+  getEnabledTools() {
+    return this.enabledTools ? [...this.enabledTools] : null;
+  }
+  isActive() {
+    return this.enabledTools !== null;
+  }
+  reset() {
+    this.enabledTools = null;
+  }
+}
+function getFilter() {
+  const global2 = globalThis;
+  if (!global2[FILTER_KEY]) {
+    global2[FILTER_KEY] = new ToolFilterManager;
+  }
+  return global2[FILTER_KEY];
+}
+var FILTER_KEY, toolFilter;
+var init_filter = __esm(() => {
+  FILTER_KEY = Symbol.for("@letta/toolFilter");
+  toolFilter = getFilter();
+});
+
+// src/tools/toolset.ts
+var exports_toolset = {};
+__export(exports_toolset, {
+  switchToolsetForModel: () => switchToolsetForModel,
+  reattachMemoryTool: () => reattachMemoryTool,
+  forceToolsetSwitch: () => forceToolsetSwitch,
+  ensureCorrectMemoryTool: () => ensureCorrectMemoryTool,
+  detachMemoryTools: () => detachMemoryTools,
+  MEMORY_TOOL_NAMES: () => MEMORY_TOOL_NAMES
+});
+async function ensureCorrectMemoryTool(agentId, modelIdentifier, useMemoryPatch) {
+  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
+  const client = await getClient2();
+  const shouldUsePatch = useMemoryPatch !== undefined ? useMemoryPatch : isOpenAIModel(resolvedModel);
+  try {
+    const agentWithTools = await client.agents.retrieve(agentId, {
+      include: ["agent.tools"]
+    });
+    const currentTools = agentWithTools.tools || [];
+    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
+    const hasAnyMemoryTool = mapByName.has("memory") || mapByName.has("memory_apply_patch");
+    if (!hasAnyMemoryTool) {
+      return;
+    }
+    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
+    const otherMemoryTool = desiredMemoryTool === "memory" ? "memory_apply_patch" : "memory";
+    let desiredId = mapByName.get(desiredMemoryTool);
+    if (!desiredId) {
+      const resp = await client.tools.list({ name: desiredMemoryTool });
+      desiredId = resp.items[0]?.id;
+    }
+    if (!desiredId) {
+      return;
+    }
+    const otherId = mapByName.get(otherMemoryTool);
+    if (mapByName.has(desiredMemoryTool) && !otherId) {
+      return;
+    }
+    const currentIds = currentTools.map((t) => t.id).filter((id) => typeof id === "string");
+    const newIds = new Set(currentIds);
+    if (otherId)
+      newIds.delete(otherId);
+    newIds.add(desiredId);
+    const updatedRules = (agentWithTools.tool_rules || []).map((r) => r.tool_name === otherMemoryTool ? { ...r, tool_name: desiredMemoryTool } : r);
+    await client.agents.update(agentId, {
+      tool_ids: Array.from(newIds),
+      tool_rules: updatedRules
+    });
+  } catch (err) {
+    console.warn(`Warning: Failed to sync memory tool: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function detachMemoryTools(agentId) {
+  const client = await getClient2();
+  try {
+    const agentWithTools = await client.agents.retrieve(agentId, {
+      include: ["agent.tools"]
+    });
+    const currentTools = agentWithTools.tools || [];
+    let detachedAny = false;
+    for (const tool of currentTools) {
+      if (tool.name && MEMORY_TOOL_NAMES.has(tool.name)) {
+        if (tool.id) {
+          await client.agents.tools.detach(tool.id, { agent_id: agentId });
+          detachedAny = true;
+        }
+      }
+    }
+    return detachedAny;
+  } catch (err) {
+    console.warn(`Warning: Failed to detach memory tools: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+async function reattachMemoryTool(agentId, modelIdentifier) {
+  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
+  const client = await getClient2();
+  const shouldUsePatch = isOpenAIModel(resolvedModel);
+  try {
+    const agentWithTools = await client.agents.retrieve(agentId, {
+      include: ["agent.tools"]
+    });
+    const currentTools = agentWithTools.tools || [];
+    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
+    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
+    if (mapByName.has(desiredMemoryTool)) {
+      return;
+    }
+    const resp = await client.tools.list({ name: desiredMemoryTool });
+    const toolId = resp.items[0]?.id;
+    if (!toolId) {
+      console.warn(`Memory tool "${desiredMemoryTool}" not found on server`);
+      return;
+    }
+    await client.agents.tools.attach(toolId, { agent_id: agentId });
+  } catch (err) {
+    console.warn(`Warning: Failed to reattach memory tool: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function forceToolsetSwitch(toolsetName, agentId) {
+  let modelForLoading;
+  if (toolsetName === "none") {
+    clearToolsWithLock();
+    return;
+  } else if (toolsetName === "codex") {
+    await loadSpecificTools([...CODEX_TOOLS]);
+    modelForLoading = "openai/gpt-4";
+  } else if (toolsetName === "codex_snake") {
+    await loadTools("openai/gpt-4");
+    modelForLoading = "openai/gpt-4";
+  } else if (toolsetName === "gemini") {
+    await loadSpecificTools([...GEMINI_TOOLS]);
+    modelForLoading = "google_ai/gemini-3-pro-preview";
+  } else if (toolsetName === "gemini_snake") {
+    await loadTools("google_ai/gemini-3-pro-preview");
+    modelForLoading = "google_ai/gemini-3-pro-preview";
+  } else {
+    await loadTools("anthropic/claude-sonnet-4");
+    modelForLoading = "anthropic/claude-sonnet-4";
+  }
+  const useMemoryPatch = toolsetName === "codex" || toolsetName === "codex_snake";
+  await ensureCorrectMemoryTool(agentId, modelForLoading, useMemoryPatch);
+}
+async function switchToolsetForModel(modelIdentifier, agentId) {
+  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
+  await loadTools(resolvedModel);
+  const loadedAfterPrimary = getToolNames().length;
+  if (loadedAfterPrimary === 0 && !toolFilter.isActive()) {
+    await loadTools();
+    if (getToolNames().length === 0) {
+      throw new Error(`Failed to load any Letta tools for model "${resolvedModel}".`);
+    }
+  }
+  await ensureCorrectMemoryTool(agentId, resolvedModel);
+  const { isGeminiModel } = await init_manager3().then(() => exports_manager2);
+  const toolsetName = isOpenAIModel(resolvedModel) ? "codex" : isGeminiModel(resolvedModel) ? "gemini" : "default";
+  return toolsetName;
+}
+var CODEX_TOOLS, GEMINI_TOOLS, MEMORY_TOOL_NAMES;
+var init_toolset = __esm(async () => {
+  init_model();
+  init_filter();
+  await __promiseAll([
+    init_client2(),
+    init_manager3()
+  ]);
+  CODEX_TOOLS = OPENAI_PASCAL_TOOLS;
+  GEMINI_TOOLS = GEMINI_PASCAL_TOOLS;
+  MEMORY_TOOL_NAMES = new Set([
+    "memory",
+    "memory_apply_patch",
+    "memory_insert",
+    "memory_replace",
+    "memory_rethink"
+  ]);
+});
+
+// src/agent/memoryFilesystem.ts
+var exports_memoryFilesystem = {};
+__export(exports_memoryFilesystem, {
+  renderMemoryFilesystemTree: () => renderMemoryFilesystemTree,
+  labelFromRelativePath: () => labelFromRelativePath,
+  getMemorySystemDir: () => getMemorySystemDir,
+  getMemoryFilesystemRoot: () => getMemoryFilesystemRoot,
+  ensureMemoryFilesystemDirs: () => ensureMemoryFilesystemDirs,
+  enableMemfsIfCloud: () => enableMemfsIfCloud,
+  applyMemfsFlags: () => applyMemfsFlags,
+  MEMORY_SYSTEM_DIR: () => MEMORY_SYSTEM_DIR,
+  MEMORY_FS_ROOT: () => MEMORY_FS_ROOT,
+  MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR,
+  MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR
+});
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join7 } from "node:path";
+function getMemoryFilesystemRoot(agentId, homeDir = homedir8()) {
+  return join7(homeDir, MEMORY_FS_ROOT, MEMORY_FS_AGENTS_DIR, agentId, MEMORY_FS_MEMORY_DIR);
+}
+function getMemorySystemDir(agentId, homeDir = homedir8()) {
+  return join7(getMemoryFilesystemRoot(agentId, homeDir), MEMORY_SYSTEM_DIR);
+}
+function ensureMemoryFilesystemDirs(agentId, homeDir = homedir8()) {
+  const root = getMemoryFilesystemRoot(agentId, homeDir);
+  const systemDir = getMemorySystemDir(agentId, homeDir);
+  if (!existsSync6(root)) {
+    mkdirSync4(root, { recursive: true });
+  }
+  if (!existsSync6(systemDir)) {
+    mkdirSync4(systemDir, { recursive: true });
+  }
+}
+function labelFromRelativePath(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  return normalized.replace(/\.md$/, "");
+}
+function renderMemoryFilesystemTree(systemLabels, detachedLabels) {
+  const makeNode = () => ({ children: new Map, isFile: false });
+  const root = makeNode();
+  const insertPath = (base2, label) => {
+    const parts = base2 ? [base2, ...label.split("/")] : label.split("/");
+    let current = root;
+    for (const [i, partName] of parts.entries()) {
+      const part = i === parts.length - 1 ? `${partName}.md` : partName;
+      if (!current.children.has(part)) {
+        current.children.set(part, makeNode());
+      }
+      current = current.children.get(part);
+      if (i === parts.length - 1) {
+        current.isFile = true;
+      }
+    }
+  };
+  for (const label of systemLabels) {
+    insertPath(MEMORY_SYSTEM_DIR, label);
+  }
+  for (const label of detachedLabels) {
+    insertPath(null, label);
+  }
+  if (!root.children.has(MEMORY_SYSTEM_DIR)) {
+    root.children.set(MEMORY_SYSTEM_DIR, makeNode());
+  }
+  const sortedEntries = (node) => {
+    const entries = Array.from(node.children.entries());
+    return entries.sort(([nameA, nodeA], [nameB, nodeB]) => {
+      if (nodeA.isFile !== nodeB.isFile) {
+        return nodeA.isFile ? 1 : -1;
+      }
+      return nameA.localeCompare(nameB);
+    });
+  };
+  const lines = ["/memory/"];
+  const render2 = (node, prefix) => {
+    const entries = sortedEntries(node);
+    entries.forEach(([name, child], index) => {
+      const isLast = index === entries.length - 1;
+      const branch = isLast ? "└──" : "├──";
+      lines.push(`${prefix}${branch} ${name}${child.isFile ? "" : "/"}`);
+      if (child.children.size > 0) {
+        const nextPrefix = `${prefix}${isLast ? "    " : "│   "}`;
+        render2(child, nextPrefix);
+      }
+    });
+  };
+  render2(root, "");
+  return lines.join(`
+`);
+}
+async function applyMemfsFlags(agentId, memfsFlag, noMemfsFlag, options) {
+  const { getServerUrl: getServerUrl2 } = await init_client2().then(() => exports_client);
+  const { settingsManager: settingsManager3 } = await init_settings_manager().then(() => exports_settings_manager);
+  if (memfsFlag) {
+    const serverUrl = getServerUrl2();
+    if (!serverUrl.includes("api.letta.com")) {
+      throw new Error("--memfs is only available on Letta Cloud (api.letta.com).");
+    }
+  }
+  const hasExplicitToggle = Boolean(memfsFlag || noMemfsFlag);
+  const targetEnabled = memfsFlag ? true : noMemfsFlag ? false : settingsManager3.isMemfsEnabled(agentId);
+  if (hasExplicitToggle) {
+    const { updateAgentSystemPromptMemfs: updateAgentSystemPromptMemfs2 } = await init_modify().then(() => exports_modify);
+    const promptUpdate = await updateAgentSystemPromptMemfs2(agentId, targetEnabled);
+    if (!promptUpdate.success) {
+      throw new Error(promptUpdate.message);
+    }
+    settingsManager3.setMemfsEnabled(agentId, targetEnabled);
+  }
+  const isEnabled = hasExplicitToggle ? targetEnabled : settingsManager3.isMemfsEnabled(agentId);
+  if (isEnabled && memfsFlag) {
+    const { detachMemoryTools: detachMemoryTools2 } = await init_toolset().then(() => exports_toolset);
+    await detachMemoryTools2(agentId);
+  }
+  let pullSummary;
+  if (isEnabled) {
+    const { addGitMemoryTag: addGitMemoryTag2, isGitRepo: isGitRepo2, cloneMemoryRepo: cloneMemoryRepo2, pullMemory: pullMemory2 } = await init_memoryGit().then(() => exports_memoryGit);
+    await addGitMemoryTag2(agentId);
+    if (!isGitRepo2(agentId)) {
+      await cloneMemoryRepo2(agentId);
+    } else if (options?.pullOnExistingRepo) {
+      const result = await pullMemory2(agentId);
+      pullSummary = result.summary;
+    }
+  }
+  const action = memfsFlag ? "enabled" : noMemfsFlag ? "disabled" : "unchanged";
+  return {
+    action,
+    memoryDir: isEnabled ? getMemoryFilesystemRoot(agentId) : undefined,
+    pullSummary
+  };
+}
+async function enableMemfsIfCloud(agentId) {
+  const { getServerUrl: getServerUrl2 } = await init_client2().then(() => exports_client);
+  const serverUrl = getServerUrl2();
+  if (!serverUrl.includes("api.letta.com"))
+    return;
+  try {
+    await applyMemfsFlags(agentId, true, undefined);
+  } catch (error) {
+    console.warn(`Warning: Could not enable memfs for new agent: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+var MEMORY_FS_ROOT = ".letta", MEMORY_FS_AGENTS_DIR = "agents", MEMORY_FS_MEMORY_DIR = "memory", MEMORY_SYSTEM_DIR = "system";
+var init_memoryFilesystem = () => {};
+
 // src/tools/impl/shellEnv.ts
 var exports_shellEnv = {};
 __export(exports_shellEnv, {
@@ -37556,7 +38536,7 @@ __export(exports_shellEnv, {
   getShellEnv: () => getShellEnv,
   ensureLettaShimDir: () => ensureLettaShimDir
 });
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir } from "node:os";
 import * as path3 from "node:path";
@@ -37629,7 +38609,7 @@ function ensureLettaShimDir(invocation) {
   if (!invocation.command)
     return null;
   const shimDir = path3.join(tmpdir(), "letta-code-shell-shim");
-  mkdirSync4(shimDir, { recursive: true });
+  mkdirSync5(shimDir, { recursive: true });
   if (process.platform === "win32") {
     const cmdPath = path3.join(shimDir, "letta.cmd");
     const quotedCommand = `"${invocation.command.replaceAll('"', '""')}"`;
@@ -37669,9 +38649,33 @@ function getShellEnv() {
     const existingPath = env3[pathKey] || "";
     env3[pathKey] = existingPath ? `${pathPrefixes.join(path3.delimiter)}${path3.delimiter}${existingPath}` : pathPrefixes.join(path3.delimiter);
   }
+  let agentId;
   try {
-    env3.LETTA_AGENT_ID = getCurrentAgentId();
+    const resolvedAgentId = getCurrentAgentId();
+    if (typeof resolvedAgentId === "string" && resolvedAgentId.trim()) {
+      agentId = resolvedAgentId.trim();
+    }
   } catch {}
+  if (!agentId) {
+    const fallbackAgentId = env3.AGENT_ID || env3.LETTA_AGENT_ID;
+    if (typeof fallbackAgentId === "string" && fallbackAgentId.trim()) {
+      agentId = fallbackAgentId.trim();
+    }
+  }
+  if (agentId) {
+    env3.LETTA_AGENT_ID = agentId;
+    env3.AGENT_ID = agentId;
+    try {
+      if (settingsManager.isMemfsEnabled(agentId)) {
+        const memoryDir = getMemoryFilesystemRoot(agentId);
+        env3.LETTA_MEMORY_DIR = memoryDir;
+        env3.MEMORY_DIR = memoryDir;
+      } else {
+        delete env3.LETTA_MEMORY_DIR;
+        delete env3.MEMORY_DIR;
+      }
+    } catch {}
+  }
   if (!env3.LETTA_API_KEY || !env3.LETTA_BASE_URL) {
     try {
       const settings = settingsManager.getSettings();
@@ -37699,6 +38703,7 @@ function getShellEnv() {
 var LETTA_BIN_ARGS_ENV = "LETTA_CODE_BIN_ARGS_JSON";
 var init_shellEnv = __esm(async () => {
   init_context();
+  init_memoryFilesystem();
   await __promiseAll([
     init_client2(),
     init_settings_manager()
@@ -38472,8 +39477,8 @@ async function edit(args) {
 var init_Edit2 = () => {};
 
 // src/cli/helpers/planName.ts
-import { homedir as homedir9 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join10 } from "node:path";
 function randomElement(arr) {
   return arr[Math.floor(Math.random() * arr.length)];
 }
@@ -38485,7 +39490,7 @@ function generatePlanName() {
 }
 function generatePlanFilePath() {
   const name = generatePlanName();
-  return join9(homedir9(), ".letta", "plans", `${name}.md`);
+  return join10(homedir10(), ".letta", "plans", `${name}.md`);
 }
 var adjectives, nouns;
 var init_planName = __esm(() => {
@@ -38594,8 +39599,8 @@ var exports_mode = {};
 __export(exports_mode, {
   permissionMode: () => permissionMode2
 });
-import { homedir as homedir10 } from "node:os";
-import { join as join10 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join11 } from "node:path";
 function getGlobalMode2() {
   const global2 = globalThis;
   if (!global2[MODE_KEY2]) {
@@ -38716,7 +39721,7 @@ class PermissionModeManager2 {
           return "allow";
         }
         if (writeTools.includes(toolName)) {
-          const plansDir = join10(homedir10(), ".letta", "plans");
+          const plansDir = join11(homedir11(), ".letta", "plans");
           let targetPath = toolArgs?.file_path || toolArgs?.path;
           if ((toolName === "ApplyPatch" || toolName === "apply_patch") && toolArgs?.input) {
             const input = toolArgs.input;
@@ -40744,7 +41749,7 @@ var init_LS2 = __esm(() => {
 
 // src/tools/impl/LS.ts
 import { readdir as readdir3, stat } from "node:fs/promises";
-import { join as join12, resolve as resolve7 } from "node:path";
+import { join as join13, resolve as resolve7 } from "node:path";
 async function ls(args) {
   validateRequiredParams(args, ["path"], "LS");
   validateParamTypes(args, LS_default2, "LS");
@@ -40754,7 +41759,7 @@ async function ls(args) {
     const items = await readdir3(dirPath);
     const filteredItems = items.filter((item) => !ignore.some((pattern) => import_picomatch.default.isMatch(item, pattern)));
     const fileInfos = await Promise.all(filteredItems.map(async (item) => {
-      const fullPath = join12(dirPath, item);
+      const fullPath = join13(dirPath, item);
       try {
         const stats = await stat(fullPath);
         return {
@@ -40917,9 +41922,9 @@ __export(exports_imageResize_magick, {
 import { execSync } from "node:child_process";
 import { readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function getImageDimensions(buffer) {
-  const tempInput = join13(tmpdir2(), `image-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  const tempInput = join14(tmpdir2(), `image-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
   writeFileSync4(tempInput, buffer);
   try {
     const output = execSync(`magick identify -format "%w %h %m" "${tempInput}"`, {
@@ -40942,12 +41947,12 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
   if (buffer.length <= MAX_IMAGE_BYTES) {
     return null;
   }
-  const tempInput = join13(tmpdir2(), `compress-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  const tempInput = join14(tmpdir2(), `compress-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
   writeFileSync4(tempInput, buffer);
   try {
     const qualities = [85, 70, 55, 40];
     for (const quality of qualities) {
-      const tempOutput = join13(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
+      const tempOutput = join14(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
       try {
         execSync(`magick "${tempInput}" -quality ${quality} "${tempOutput}"`, {
           stdio: "ignore"
@@ -40973,7 +41978,7 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
     for (const scale of scales) {
       const scaledWidth = Math.floor(currentWidth * scale);
       const scaledHeight = Math.floor(currentHeight * scale);
-      const tempOutput = join13(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
+      const tempOutput = join14(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
       try {
         execSync(`magick "${tempInput}" -resize ${scaledWidth}x${scaledHeight} -quality 70 "${tempOutput}"`, {
           stdio: "ignore"
@@ -41017,11 +42022,11 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
       resized: false
     };
   }
-  const tempInput = join13(tmpdir2(), `resize-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  const tempInput = join14(tmpdir2(), `resize-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
   writeFileSync4(tempInput, buffer);
   try {
     if (needsResize) {
-      const tempOutput2 = join13(tmpdir2(), `resize-output-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      const tempOutput2 = join14(tmpdir2(), `resize-output-${Date.now()}-${Math.random().toString(36).slice(2)}`);
       let outputBuffer2;
       let outputMediaType;
       if (format2 === "jpeg" || format2 === "jpg") {
@@ -41052,7 +42057,7 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
         resized: true
       };
     }
-    const tempOutput = join13(tmpdir2(), `convert-output-${Date.now()}-${Math.random().toString(36).slice(2)}.png`);
+    const tempOutput = join14(tmpdir2(), `convert-output-${Date.now()}-${Math.random().toString(36).slice(2)}.png`);
     execSync(`magick "${tempInput}" "${tempOutput}"`, {
       stdio: "ignore"
     });
@@ -42272,7 +43277,7 @@ var require_range = __commonJS((exports, module) => {
     parseRange(range) {
       const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
       const memoKey = memoOpts + ":" + range;
-      const cached = cache4.get(memoKey);
+      const cached = cache5.get(memoKey);
       if (cached) {
         return cached;
       }
@@ -42306,7 +43311,7 @@ var require_range = __commonJS((exports, module) => {
         rangeMap.delete("");
       }
       const result = [...rangeMap.values()];
-      cache4.set(memoKey, result);
+      cache5.set(memoKey, result);
       return result;
     }
     intersects(range, options) {
@@ -42344,7 +43349,7 @@ var require_range = __commonJS((exports, module) => {
   }
   module.exports = Range;
   var LRU = require_lrucache();
-  var cache4 = new LRU;
+  var cache5 = new LRU;
   var parseOptions = require_parse_options();
   var Comparator = require_comparator();
   var debug = require_debug();
@@ -47387,7 +48392,7 @@ var require_utility = __commonJS((exports, module) => {
     format2.heif.input.fileSuffix = [".avif"];
     format2.heif.output.alias = ["avif"];
   }
-  function cache4(options) {
+  function cache5(options) {
     if (is.bool(options)) {
       if (options) {
         return sharp.cache(50, 20, 100);
@@ -47400,7 +48405,7 @@ var require_utility = __commonJS((exports, module) => {
       return sharp.cache();
     }
   }
-  cache4(true);
+  cache5(true);
   function concurrency(concurrency2) {
     return sharp.concurrency(is.integer(concurrency2) ? concurrency2 : null);
   }
@@ -47439,7 +48444,7 @@ var require_utility = __commonJS((exports, module) => {
     }
   }
   module.exports = (Sharp) => {
-    Sharp.cache = cache4;
+    Sharp.cache = cache5;
     Sharp.concurrency = concurrency;
     Sharp.counters = counters;
     Sharp.simd = simd;
@@ -54321,19 +55326,19 @@ __export(exports_skills, {
   SKILLS_DIR: () => SKILLS_DIR,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR
 });
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { readdir as readdir5, readFile as readFile3 } from "node:fs/promises";
-import { dirname as dirname4, join as join14 } from "node:path";
+import { dirname as dirname4, join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function getBundledSkillsPath() {
   const thisDir = dirname4(fileURLToPath6(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join14(thisDir, "../skills/builtin");
+    return join15(thisDir, "../skills/builtin");
   }
-  return join14(thisDir, "skills");
+  return join15(thisDir, "skills");
 }
 function getAgentSkillsDir(agentId) {
-  return join14(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
+  return join15(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills() {
   const bundledPath = getBundledSkillsPath();
@@ -54342,7 +55347,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors = [];
-  if (!existsSync7(skillsPath)) {
+  if (!existsSync8(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -54356,21 +55361,25 @@ async function discoverSkillsFromDir(skillsPath, source) {
   }
   return { skills, errors };
 }
-async function discoverSkills(projectSkillsPath = join14(process.cwd(), SKILLS_DIR), agentId, options) {
+async function discoverSkills(projectSkillsPath = join15(process.cwd(), SKILLS_DIR), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
-  if (!options?.skipBundled) {
+  const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
+  const includeSource = (source) => sourceSet.has(source);
+  if (includeSource("bundled") && !options?.skipBundled) {
     const bundledSkills = await getBundledSkills();
     for (const skill of bundledSkills) {
       skillsById.set(skill.id, skill);
     }
   }
-  const globalResult = await discoverSkillsFromDir(GLOBAL_SKILLS_DIR, "global");
-  allErrors.push(...globalResult.errors);
-  for (const skill of globalResult.skills) {
-    skillsById.set(skill.id, skill);
+  if (includeSource("global")) {
+    const globalResult = await discoverSkillsFromDir(GLOBAL_SKILLS_DIR, "global");
+    allErrors.push(...globalResult.errors);
+    for (const skill of globalResult.skills) {
+      skillsById.set(skill.id, skill);
+    }
   }
-  if (agentId) {
+  if (agentId && includeSource("agent")) {
     const agentSkillsDir = getAgentSkillsDir(agentId);
     const agentResult = await discoverSkillsFromDir(agentSkillsDir, "agent");
     allErrors.push(...agentResult.errors);
@@ -54378,10 +55387,12 @@ async function discoverSkills(projectSkillsPath = join14(process.cwd(), SKILLS_D
       skillsById.set(skill.id, skill);
     }
   }
-  const projectResult = await discoverSkillsFromDir(projectSkillsPath, "project");
-  allErrors.push(...projectResult.errors);
-  for (const skill of projectResult.skills) {
-    skillsById.set(skill.id, skill);
+  if (includeSource("project")) {
+    const projectResult = await discoverSkillsFromDir(projectSkillsPath, "project");
+    allErrors.push(...projectResult.errors);
+    for (const skill of projectResult.skills) {
+      skillsById.set(skill.id, skill);
+    }
   }
   return {
     skills: Array.from(skillsById.values()),
@@ -54392,7 +55403,7 @@ async function findSkillFiles(currentPath, rootPath, skills, errors, source) {
   try {
     const entries = await readdir5(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join14(currentPath, entry.name);
+      const fullPath = join15(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findSkillFiles(fullPath, rootPath, skills, errors, source);
       } else if (entry.isFile() && entry.name.toUpperCase() === "SKILL.MD") {
@@ -54466,7 +55477,8 @@ ${lines.join(`
 }
 var SKILLS_DIR = ".skills", GLOBAL_SKILLS_DIR;
 var init_skills = __esm(() => {
-  GLOBAL_SKILLS_DIR = join14(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  init_skillSources();
+  GLOBAL_SKILLS_DIR = join15(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/tools/impl/skillContentRegistry.ts
@@ -54491,7 +55503,7 @@ var init_skillContentRegistry = __esm(() => {
 // src/tools/impl/Skill.ts
 import { readdirSync as readdirSync3 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname5, join as join15 } from "node:path";
+import { dirname as dirname5, join as join16 } from "node:path";
 function hasAdditionalFiles(skillMdPath) {
   try {
     const skillDir = dirname5(skillMdPath);
@@ -54502,19 +55514,19 @@ function hasAdditionalFiles(skillMdPath) {
   }
 }
 async function readSkillContent(skillId, skillsDir, agentId) {
-  const projectSkillPath = join15(skillsDir, skillId, "SKILL.md");
+  const projectSkillPath = join16(skillsDir, skillId, "SKILL.md");
   try {
     const content = await readFile4(projectSkillPath, "utf-8");
     return { content, path: projectSkillPath };
   } catch {}
   if (agentId) {
-    const agentSkillPath = join15(getAgentSkillsDir(agentId), skillId, "SKILL.md");
+    const agentSkillPath = join16(getAgentSkillsDir(agentId), skillId, "SKILL.md");
     try {
       const content = await readFile4(agentSkillPath, "utf-8");
       return { content, path: agentSkillPath };
     } catch {}
   }
-  const globalSkillPath = join15(GLOBAL_SKILLS_DIR, skillId, "SKILL.md");
+  const globalSkillPath = join16(GLOBAL_SKILLS_DIR, skillId, "SKILL.md");
   try {
     const content = await readFile4(globalSkillPath, "utf-8");
     return { content, path: globalSkillPath };
@@ -54528,8 +55540,8 @@ async function readSkillContent(skillId, skillsDir, agentId) {
     } catch {}
   }
   try {
-    const bundledSkillsDir = join15(process.cwd(), "skills", "skills");
-    const bundledSkillPath = join15(bundledSkillsDir, skillId, "SKILL.md");
+    const bundledSkillsDir = join16(process.cwd(), "skills", "skills");
+    const bundledSkillPath = join16(bundledSkillsDir, skillId, "SKILL.md");
     const content = await readFile4(bundledSkillPath, "utf-8");
     return { content, path: bundledSkillPath };
   } catch {
@@ -54541,7 +55553,7 @@ async function getResolvedSkillsDir() {
   if (skillsDir) {
     return skillsDir;
   }
-  return join15(process.cwd(), SKILLS_DIR);
+  return join16(process.cwd(), SKILLS_DIR);
 }
 async function skill(args) {
   validateRequiredParams(args, ["skill"], "Skill");
@@ -54806,109 +55818,6 @@ var init_cli = __esm(() => {
   cliPermissions = new CliPermissions;
 });
 
-// src/agent/available-models.ts
-var exports_available_models = {};
-__export(exports_available_models, {
-  prefetchAvailableModelHandles: () => prefetchAvailableModelHandles,
-  getModelContextWindow: () => getModelContextWindow,
-  getAvailableModelsCacheInfo: () => getAvailableModelsCacheInfo,
-  getAvailableModelHandles: () => getAvailableModelHandles,
-  clearAvailableModelsCache: () => clearAvailableModelsCache
-});
-function isFresh(now = Date.now()) {
-  return cache4 !== null && now - cache4.fetchedAt < CACHE_TTL_MS;
-}
-function clearAvailableModelsCache() {
-  cache4 = null;
-}
-function getAvailableModelsCacheInfo() {
-  const now = Date.now();
-  return {
-    hasCache: cache4 !== null,
-    isFresh: isFresh(now),
-    fetchedAt: cache4?.fetchedAt ?? null,
-    ageMs: cache4 ? now - cache4.fetchedAt : null,
-    ttlMs: CACHE_TTL_MS
-  };
-}
-async function refreshByokProviders() {
-  const client = await getClient2();
-  try {
-    const providers = await client.get("/v1/providers/");
-    const byokProviders = providers.filter((p) => p.provider_category === "byok");
-    await Promise.allSettled(byokProviders.map(async (provider) => {
-      try {
-        await client.patch(`/v1/providers/${provider.id}/refresh`);
-      } catch (error) {
-        debugWarn("available-models", `Failed to refresh provider ${provider.name} (${provider.id}):`, error);
-      }
-    }));
-  } catch (error) {
-    debugWarn("available-models", "Failed to list providers for refresh:", error);
-  }
-}
-async function fetchFromNetwork() {
-  const client = await getClient2();
-  const modelsList = await client.models.list();
-  const handles = new Set(modelsList.map((m) => m.handle).filter((h) => !!h));
-  const contextWindows = new Map;
-  for (const model of modelsList) {
-    if (model.handle && model.max_context_window) {
-      contextWindows.set(model.handle, model.max_context_window);
-    }
-  }
-  return { handles, contextWindows, fetchedAt: Date.now() };
-}
-async function getAvailableModelHandles(options) {
-  const forceRefresh = options?.forceRefresh === true;
-  const now = Date.now();
-  if (!forceRefresh && isFresh(now) && cache4) {
-    return {
-      handles: cache4.handles,
-      source: "cache",
-      fetchedAt: cache4.fetchedAt
-    };
-  }
-  if (!forceRefresh && inflight) {
-    const entry2 = await inflight;
-    return {
-      handles: entry2.handles,
-      source: "network",
-      fetchedAt: entry2.fetchedAt
-    };
-  }
-  if (forceRefresh) {
-    await refreshByokProviders();
-  }
-  inflight = fetchFromNetwork().then((entry2) => {
-    cache4 = entry2;
-    return entry2;
-  }).finally(() => {
-    inflight = null;
-  });
-  const entry = await inflight;
-  return {
-    handles: entry.handles,
-    source: "network",
-    fetchedAt: entry.fetchedAt
-  };
-}
-function prefetchAvailableModelHandles() {
-  getAvailableModelHandles().catch(() => {});
-}
-async function getModelContextWindow(handle) {
-  if (!cache4) {
-    await getAvailableModelHandles();
-  }
-  return cache4?.contextWindows.get(handle);
-}
-var CACHE_TTL_MS, cache4 = null, inflight = null;
-var init_available_models = __esm(async () => {
-  init_debug();
-  await init_client2();
-  CACHE_TTL_MS = 5 * 60 * 1000;
-});
-
 // src/agent/subagents/manager.ts
 import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
@@ -56798,11 +57707,6 @@ var init_Task3 = __esm(() => {
       conversation_id: {
         type: "string",
         description: "Resume from an existing conversation. Does NOT require agent_id (conversation IDs are unique and encode the agent)."
-      },
-      max_turns: {
-        type: "integer",
-        exclusiveMinimum: 0,
-        description: "Maximum number of agentic turns (API round-trips) before stopping. Defaults to unlimited (recommended for most use cases)."
       }
     },
     required: ["description", "prompt", "subagent_type"],
@@ -58665,8 +59569,8 @@ function matchesFilePattern(query, pattern, workingDirectory) {
     globPattern = globPattern.slice(2);
   }
   if (globPattern.startsWith("~/")) {
-    const homedir11 = __require("node:os").homedir();
-    globPattern = globPattern.replace(/^~/, homedir11);
+    const homedir12 = __require("node:os").homedir();
+    globPattern = globPattern.replace(/^~/, homedir12);
   }
   globPattern = normalizeAbsolutePattern(globPattern, workingDirectory);
   const windowsContext = isWindowsContext(workingDirectory);
@@ -59088,8 +59992,8 @@ __export(exports_loader, {
   savePermissionRule: () => savePermissionRule,
   loadPermissions: () => loadPermissions
 });
-import { homedir as homedir11 } from "node:os";
-import { join as join16 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join17 } from "node:path";
 async function loadPermissions(workingDirectory = process.cwd()) {
   const merged = {
     allow: [],
@@ -59098,10 +60002,10 @@ async function loadPermissions(workingDirectory = process.cwd()) {
     additionalDirectories: []
   };
   const sources = [
-    join16(process.env.XDG_CONFIG_HOME || join16(homedir11(), ".config"), "letta", "settings.json"),
-    join16(homedir11(), ".letta", "settings.json"),
-    join16(workingDirectory, ".letta", "settings.json"),
-    join16(workingDirectory, ".letta", "settings.local.json")
+    join17(process.env.XDG_CONFIG_HOME || join17(homedir12(), ".config"), "letta", "settings.json"),
+    join17(homedir12(), ".letta", "settings.json"),
+    join17(workingDirectory, ".letta", "settings.json"),
+    join17(workingDirectory, ".letta", "settings.local.json")
   ];
   for (const settingsPath of sources) {
     try {
@@ -59137,13 +60041,13 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
   let settingsPath;
   switch (scope) {
     case "user":
-      settingsPath = join16(process.env.XDG_CONFIG_HOME || join16(homedir11(), ".config"), "letta", "settings.json");
+      settingsPath = join17(process.env.XDG_CONFIG_HOME || join17(homedir12(), ".config"), "letta", "settings.json");
       break;
     case "project":
-      settingsPath = join16(workingDirectory, ".letta", "settings.json");
+      settingsPath = join17(workingDirectory, ".letta", "settings.json");
       break;
     case "local":
-      settingsPath = join16(workingDirectory, ".letta", "settings.local.json");
+      settingsPath = join17(workingDirectory, ".letta", "settings.local.json");
       break;
   }
   let settings = {};
@@ -59168,7 +60072,7 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
   }
 }
 async function ensureLocalSettingsIgnored(workingDirectory) {
-  const gitignorePath = join16(workingDirectory, ".gitignore");
+  const gitignorePath = join17(workingDirectory, ".gitignore");
   const pattern = ".letta/settings.local.json";
   try {
     let content = "";
@@ -59193,7 +60097,7 @@ var exports_analyzer = {};
 __export(exports_analyzer, {
   analyzeApprovalContext: () => analyzeApprovalContext
 });
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 import { dirname as dirname7, relative, resolve as resolve16, win32 as win322 } from "node:path";
 function normalizeOsPath(path18) {
   return path18.replace(/\\/g, "/");
@@ -59230,7 +60134,7 @@ function formatAbsoluteRulePath(path18) {
   return `//${normalized.replace(/^\/+/, "")}`;
 }
 function formatDisplayPath(path18) {
-  return normalizeOsPath(path18).replace(normalizeOsPath(homedir12()), "~");
+  return normalizeOsPath(path18).replace(normalizeOsPath(homedir13()), "~");
 }
 function analyzeApprovalContext(toolName, toolArgs, workingDirectory) {
   const resolveFilePath = () => {
@@ -59373,7 +60277,7 @@ function detectSkillScript(command, workingDir) {
     return null;
   }
   const normalizedWorkingDir = normalizePathSeparators(workingDir).replace(/\/$/, "");
-  const normalizedHomeDir = normalizePathSeparators(homedir12()).replace(/\/$/, "");
+  const normalizedHomeDir = normalizePathSeparators(homedir13()).replace(/\/$/, "");
   const detect = (source, regex2) => {
     for (const candidate of pathCandidates) {
       const match3 = candidate.match(regex2);
@@ -59687,50 +60591,6 @@ var init_analyzer = __esm(() => {
   ];
 });
 
-// src/tools/filter.ts
-var exports_filter = {};
-__export(exports_filter, {
-  toolFilter: () => toolFilter
-});
-
-class ToolFilterManager {
-  enabledTools = null;
-  setEnabledTools(toolsString) {
-    if (toolsString === "") {
-      this.enabledTools = [];
-    } else {
-      this.enabledTools = toolsString.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
-    }
-  }
-  isEnabled(toolName) {
-    if (this.enabledTools === null) {
-      return true;
-    }
-    return this.enabledTools.includes(toolName);
-  }
-  getEnabledTools() {
-    return this.enabledTools ? [...this.enabledTools] : null;
-  }
-  isActive() {
-    return this.enabledTools !== null;
-  }
-  reset() {
-    this.enabledTools = null;
-  }
-}
-function getFilter() {
-  const global2 = globalThis;
-  if (!global2[FILTER_KEY]) {
-    global2[FILTER_KEY] = new ToolFilterManager;
-  }
-  return global2[FILTER_KEY];
-}
-var FILTER_KEY, toolFilter;
-var init_filter = __esm(() => {
-  FILTER_KEY = Symbol.for("@letta/toolFilter");
-  toolFilter = getFilter();
-});
-
 // src/tools/manager.ts
 var exports_manager2 = {};
 __export(exports_manager2, {
@@ -60778,19 +61638,19 @@ __export(exports_skills2, {
   SKILLS_DIR: () => SKILLS_DIR2,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { readdir as readdir6, readFile as readFile5 } from "node:fs/promises";
-import { dirname as dirname8, join as join17 } from "node:path";
+import { dirname as dirname8, join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function getBundledSkillsPath2() {
   const thisDir = dirname8(fileURLToPath7(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join17(thisDir, "../skills/builtin");
+    return join18(thisDir, "../skills/builtin");
   }
-  return join17(thisDir, "skills");
+  return join18(thisDir, "skills");
 }
 function getAgentSkillsDir2(agentId) {
-  return join17(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
+  return join18(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills2() {
   const bundledPath = getBundledSkillsPath2();
@@ -60799,7 +61659,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source) {
   const errors = [];
-  if (!existsSync8(skillsPath)) {
+  if (!existsSync9(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -60813,21 +61673,25 @@ async function discoverSkillsFromDir2(skillsPath, source) {
   }
   return { skills, errors };
 }
-async function discoverSkills2(projectSkillsPath = join17(process.cwd(), SKILLS_DIR2), agentId, options) {
+async function discoverSkills2(projectSkillsPath = join18(process.cwd(), SKILLS_DIR2), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
-  if (!options?.skipBundled) {
+  const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
+  const includeSource = (source) => sourceSet.has(source);
+  if (includeSource("bundled") && !options?.skipBundled) {
     const bundledSkills = await getBundledSkills2();
     for (const skill2 of bundledSkills) {
       skillsById.set(skill2.id, skill2);
     }
   }
-  const globalResult = await discoverSkillsFromDir2(GLOBAL_SKILLS_DIR2, "global");
-  allErrors.push(...globalResult.errors);
-  for (const skill2 of globalResult.skills) {
-    skillsById.set(skill2.id, skill2);
+  if (includeSource("global")) {
+    const globalResult = await discoverSkillsFromDir2(GLOBAL_SKILLS_DIR2, "global");
+    allErrors.push(...globalResult.errors);
+    for (const skill2 of globalResult.skills) {
+      skillsById.set(skill2.id, skill2);
+    }
   }
-  if (agentId) {
+  if (agentId && includeSource("agent")) {
     const agentSkillsDir = getAgentSkillsDir2(agentId);
     const agentResult = await discoverSkillsFromDir2(agentSkillsDir, "agent");
     allErrors.push(...agentResult.errors);
@@ -60835,10 +61699,12 @@ async function discoverSkills2(projectSkillsPath = join17(process.cwd(), SKILLS_
       skillsById.set(skill2.id, skill2);
     }
   }
-  const projectResult = await discoverSkillsFromDir2(projectSkillsPath, "project");
-  allErrors.push(...projectResult.errors);
-  for (const skill2 of projectResult.skills) {
-    skillsById.set(skill2.id, skill2);
+  if (includeSource("project")) {
+    const projectResult = await discoverSkillsFromDir2(projectSkillsPath, "project");
+    allErrors.push(...projectResult.errors);
+    for (const skill2 of projectResult.skills) {
+      skillsById.set(skill2.id, skill2);
+    }
   }
   return {
     skills: Array.from(skillsById.values()),
@@ -60849,7 +61715,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source) {
   try {
     const entries = await readdir6(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join17(currentPath, entry.name);
+      const fullPath = join18(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findSkillFiles2(fullPath, rootPath, skills, errors, source);
       } else if (entry.isFile() && entry.name.toUpperCase() === "SKILL.MD") {
@@ -60923,7 +61789,8 @@ ${lines.join(`
 }
 var SKILLS_DIR2 = ".skills", GLOBAL_SKILLS_DIR2;
 var init_skills2 = __esm(() => {
-  GLOBAL_SKILLS_DIR2 = join17(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  init_skillSources();
+  GLOBAL_SKILLS_DIR2 = join18(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/utils/fs.ts
@@ -60937,10 +61804,10 @@ __export(exports_fs, {
   exists: () => exists2
 });
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
-  mkdirSync as mkdirSync6
+  mkdirSync as mkdirSync7
 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 async function readFile6(path19) {
@@ -60948,16 +61815,16 @@ async function readFile6(path19) {
 }
 async function writeFile2(path19, content) {
   const dir = dirname9(path19);
-  if (!existsSync9(dir)) {
-    mkdirSync6(dir, { recursive: true });
+  if (!existsSync10(dir)) {
+    mkdirSync7(dir, { recursive: true });
   }
   fsWriteFileSync2(path19, content, { encoding: "utf-8", flush: true });
 }
 function exists2(path19) {
-  return existsSync9(path19);
+  return existsSync10(path19);
 }
 async function mkdir2(path19, options) {
-  mkdirSync6(path19, options);
+  mkdirSync7(path19, options);
 }
 async function readJsonFile(path19) {
   const text = await readFile6(path19);
@@ -61263,21 +62130,85 @@ var init_manager4 = __esm(() => {
 // src/updater/auto-update.ts
 var exports_auto_update = {};
 __export(exports_auto_update, {
+  resolveUpdateRegistryBaseUrl: () => resolveUpdateRegistryBaseUrl,
+  resolveUpdatePackageName: () => resolveUpdatePackageName,
+  resolveUpdateInstallRegistryUrl: () => resolveUpdateInstallRegistryUrl,
   manualUpdate: () => manualUpdate,
   detectPackageManager: () => detectPackageManager,
   checkForUpdate: () => checkForUpdate,
-  checkAndAutoUpdate: () => checkAndAutoUpdate
+  checkAndAutoUpdate: () => checkAndAutoUpdate,
+  buildLatestVersionUrl: () => buildLatestVersionUrl,
+  buildInstallCommand: () => buildInstallCommand,
+  buildInstallArgs: () => buildInstallArgs
 });
-import { exec as exec2 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readdir as readdir7, rm } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function debugLog2(...args) {
   if (DEBUG) {
     console.error("[auto-update]", ...args);
   }
 }
+function normalizeUpdatePackageName(raw) {
+  if (!raw)
+    return null;
+  const value = raw.trim();
+  if (!value)
+    return null;
+  if (/\s/.test(value) || /["'`;|&$]/.test(value))
+    return null;
+  return value;
+}
+function normalizeRegistryUrl(raw) {
+  if (!raw)
+    return null;
+  const value = raw.trim();
+  if (!value || /\s/.test(value) || /["'`;|&$]/.test(value))
+    return null;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return null;
+    }
+    return value.replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+function resolveUpdatePackageName(env3 = process.env) {
+  const custom = normalizeUpdatePackageName(env3[UPDATE_PACKAGE_NAME_ENV]);
+  if (custom) {
+    return custom;
+  }
+  return DEFAULT_UPDATE_PACKAGE_NAME;
+}
+function resolveUpdateRegistryBaseUrl(env3 = process.env) {
+  const custom = normalizeRegistryUrl(env3[UPDATE_REGISTRY_BASE_URL_ENV]);
+  if (custom) {
+    return custom;
+  }
+  return DEFAULT_UPDATE_REGISTRY_BASE_URL;
+}
+function resolveUpdateInstallRegistryUrl(env3 = process.env) {
+  return normalizeRegistryUrl(env3[UPDATE_INSTALL_REGISTRY_URL_ENV]);
+}
+function buildLatestVersionUrl(packageName, registryBaseUrl) {
+  return `${registryBaseUrl.replace(/\/+$/, "")}/${packageName}/latest`;
+}
+function buildInstallCommand(pm, env3 = process.env) {
+  return `${pm} ${buildInstallArgs(pm, env3).join(" ")}`;
+}
+function buildInstallArgs(pm, env3 = process.env) {
+  const packageName = resolveUpdatePackageName(env3);
+  const installRegistry = resolveUpdateInstallRegistryUrl(env3);
+  const args = [...INSTALL_ARG_PREFIX[pm], `${packageName}@latest`];
+  if (installRegistry) {
+    args.push("--registry", installRegistry);
+  }
+  return args;
+}
 function detectPackageManager() {
   const envOverride = process.env.LETTA_PACKAGE_MANAGER;
   if (envOverride) {
@@ -61323,9 +62254,14 @@ async function checkForUpdate() {
     debugLog2("Prerelease version detected, skipping auto-update check");
     return { updateAvailable: false, currentVersion };
   }
+  const packageName = resolveUpdatePackageName();
+  const registryBaseUrl = resolveUpdateRegistryBaseUrl();
+  const latestUrl = buildLatestVersionUrl(packageName, registryBaseUrl);
   try {
-    debugLog2("Checking registry for latest version...");
-    const res = await fetch("https://registry.npmjs.org/@letta-ai/letta-code/latest", { signal: AbortSignal.timeout(5000) });
+    debugLog2("Checking registry for latest version:", latestUrl);
+    const res = await fetch(latestUrl, {
+      signal: AbortSignal.timeout(5000)
+    });
     if (!res.ok) {
       throw new Error(`Registry returned ${res.status}`);
     }
@@ -61359,19 +62295,21 @@ async function checkForUpdate() {
 }
 async function getNpmGlobalPath() {
   try {
-    const { stdout } = await execAsync("npm prefix -g", { timeout: 5000 });
+    const { stdout } = await execFileAsync3("npm", ["prefix", "-g"], {
+      timeout: 5000
+    });
     return stdout.trim();
   } catch {
     return null;
   }
 }
 async function cleanupOrphanedDirs(globalPath) {
-  const lettaAiDir = join18(globalPath, "lib/node_modules/@letta-ai");
+  const lettaAiDir = join19(globalPath, "lib/node_modules/@letta-ai");
   try {
     const entries = await readdir7(lettaAiDir);
     for (const entry of entries) {
       if (entry.startsWith(".letta-code-")) {
-        const orphanPath = join18(lettaAiDir, entry);
+        const orphanPath = join19(lettaAiDir, entry);
         debugLog2("Cleaning orphaned temp directory:", orphanPath);
         await rm(orphanPath, { recursive: true, force: true });
       }
@@ -61380,7 +62318,8 @@ async function cleanupOrphanedDirs(globalPath) {
 }
 async function performUpdate() {
   const pm = detectPackageManager();
-  const installCmd = INSTALL_CMD[pm];
+  const installCmd = buildInstallCommand(pm);
+  const installArgs = buildInstallArgs(pm);
   debugLog2("Detected package manager:", pm);
   debugLog2("Install command:", installCmd);
   let globalPath = null;
@@ -61393,7 +62332,7 @@ async function performUpdate() {
   }
   try {
     debugLog2(`Running ${installCmd}...`);
-    await execAsync(installCmd, { timeout: 60000 });
+    await execFileAsync3(pm, installArgs, { timeout: 60000 });
     debugLog2("Update completed successfully");
     return { success: true };
   } catch (error) {
@@ -61402,7 +62341,7 @@ async function performUpdate() {
       debugLog2("ENOTEMPTY detected, attempting cleanup and retry...");
       await cleanupOrphanedDirs(globalPath);
       try {
-        await execAsync(installCmd, { timeout: 60000 });
+        await execFileAsync3(pm, installArgs, { timeout: 60000 });
         debugLog2("Update succeeded after cleanup retry");
         return { success: true };
       } catch (retryError) {
@@ -61476,17 +62415,17 @@ async function manualUpdate() {
     message: `Update failed: ${updateResult.error}`
   };
 }
-var execAsync, DEBUG, INSTALL_CMD, VALID_PACKAGE_MANAGERS;
+var execFileAsync3, DEBUG, DEFAULT_UPDATE_PACKAGE_NAME = "@letta-ai/letta-code", DEFAULT_UPDATE_REGISTRY_BASE_URL = "https://registry.npmjs.org", UPDATE_PACKAGE_NAME_ENV = "LETTA_UPDATE_PACKAGE_NAME", UPDATE_REGISTRY_BASE_URL_ENV = "LETTA_UPDATE_REGISTRY_BASE_URL", UPDATE_INSTALL_REGISTRY_URL_ENV = "LETTA_UPDATE_INSTALL_REGISTRY_URL", INSTALL_ARG_PREFIX, VALID_PACKAGE_MANAGERS;
 var init_auto_update = __esm(() => {
   init_version();
-  execAsync = promisify4(exec2);
+  execFileAsync3 = promisify4(execFile4);
   DEBUG = process.env.LETTA_DEBUG_AUTOUPDATE === "1";
-  INSTALL_CMD = {
-    npm: "npm install -g @letta-ai/letta-code@latest",
-    bun: "bun add -g @letta-ai/letta-code@latest",
-    pnpm: "pnpm add -g @letta-ai/letta-code@latest"
+  INSTALL_ARG_PREFIX = {
+    npm: ["install", "-g"],
+    bun: ["add", "-g"],
+    pnpm: ["add", "-g"]
   };
-  VALID_PACKAGE_MANAGERS = new Set(Object.keys(INSTALL_CMD));
+  VALID_PACKAGE_MANAGERS = new Set(Object.keys(INSTALL_ARG_PREFIX));
 });
 
 // src/tools/impl/overflow.ts
@@ -61726,9 +62665,9 @@ __export(exports_subagents2, {
   GLOBAL_AGENTS_DIR: () => GLOBAL_AGENTS_DIR2,
   AGENTS_DIR: () => AGENTS_DIR2
 });
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { readdir as readdir8, readFile as readFile7 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function isValidName2(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
@@ -61810,7 +62749,7 @@ function getBuiltinSubagentNames2() {
   return new Set(Object.keys(getBuiltinSubagents2()));
 }
 async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors) {
-  if (!existsSync11(agentsDir)) {
+  if (!existsSync12(agentsDir)) {
     return;
   }
   try {
@@ -61819,7 +62758,7 @@ async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors
       if (!entry.isFile() || !entry.name.endsWith(".md")) {
         continue;
       }
-      const filePath = join20(agentsDir, entry.name);
+      const filePath = join21(agentsDir, entry.name);
       try {
         const config = await parseSubagentFile2(filePath);
         if (config) {
@@ -61851,7 +62790,7 @@ async function discoverSubagents2(workingDirectory = process.cwd()) {
   const subagents = [];
   const seenNames = new Set;
   await discoverSubagentsFromDir2(GLOBAL_AGENTS_DIR2, seenNames, subagents, errors);
-  const projectAgentsDir = join20(workingDirectory, AGENTS_DIR2);
+  const projectAgentsDir = join21(workingDirectory, AGENTS_DIR2);
   await discoverSubagentsFromDir2(projectAgentsDir, seenNames, subagents, errors);
   return { subagents, errors };
 }
@@ -61894,7 +62833,7 @@ var init_subagents2 = __esm(() => {
     recall_default,
     reflection_default
   ];
-  GLOBAL_AGENTS_DIR2 = join20(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
+  GLOBAL_AGENTS_DIR2 = join21(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS2 = new Set(MEMORY_BLOCK_LABELS);
   cache5 = {
     builtins: null,
@@ -62038,24 +62977,24 @@ function defineLazyProperty(object, propertyName, valueGetter) {
 // node_modules/default-browser-id/index.js
 import { promisify as promisify5 } from "node:util";
 import process15 from "node:process";
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 async function defaultBrowserId() {
   if (process15.platform !== "darwin") {
     throw new Error("macOS only");
   }
-  const { stdout } = await execFileAsync3("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const { stdout } = await execFileAsync4("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
   const match3 = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
   return match3?.groups.id ?? "com.apple.Safari";
 }
-var execFileAsync3;
+var execFileAsync4;
 var init_default_browser_id = __esm(() => {
-  execFileAsync3 = promisify5(execFile4);
+  execFileAsync4 = promisify5(execFile5);
 });
 
 // node_modules/run-applescript/index.js
 import process16 from "node:process";
 import { promisify as promisify6 } from "node:util";
-import { execFile as execFile5, execFileSync } from "node:child_process";
+import { execFile as execFile6, execFileSync } from "node:child_process";
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
   if (process16.platform !== "darwin") {
     throw new Error("macOS only");
@@ -62065,12 +63004,12 @@ async function runAppleScript(script, { humanReadableOutput = true, signal } = {
   if (signal) {
     execOptions.signal = signal;
   }
-  const { stdout } = await execFileAsync4("osascript", ["-e", script, outputArguments], execOptions);
+  const { stdout } = await execFileAsync5("osascript", ["-e", script, outputArguments], execOptions);
   return stdout.trim();
 }
-var execFileAsync4;
+var execFileAsync5;
 var init_run_applescript = __esm(() => {
-  execFileAsync4 = promisify6(execFile5);
+  execFileAsync5 = promisify6(execFile6);
 });
 
 // node_modules/bundle-name/index.js
@@ -62084,8 +63023,8 @@ var init_bundle_name = __esm(() => {
 
 // node_modules/default-browser/windows.js
 import { promisify as promisify7 } from "node:util";
-import { execFile as execFile6 } from "node:child_process";
-async function defaultBrowser(_execFileAsync = execFileAsync5) {
+import { execFile as execFile7 } from "node:child_process";
+async function defaultBrowser(_execFileAsync = execFileAsync6) {
   const { stdout } = await _execFileAsync("reg", [
     "QUERY",
     " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
@@ -62103,9 +63042,9 @@ async function defaultBrowser(_execFileAsync = execFileAsync5) {
   }
   return browser;
 }
-var execFileAsync5, windowsBrowserProgIds, UnknownBrowserError;
+var execFileAsync6, windowsBrowserProgIds, UnknownBrowserError;
 var init_windows = __esm(() => {
-  execFileAsync5 = promisify7(execFile6);
+  execFileAsync6 = promisify7(execFile7);
   windowsBrowserProgIds = {
     AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
     MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
@@ -62124,7 +63063,7 @@ var init_windows = __esm(() => {
 // node_modules/default-browser/index.js
 import { promisify as promisify8 } from "node:util";
 import process17 from "node:process";
-import { execFile as execFile7 } from "node:child_process";
+import { execFile as execFile8 } from "node:child_process";
 async function defaultBrowser2() {
   if (process17.platform === "darwin") {
     const id = await defaultBrowserId();
@@ -62132,7 +63071,7 @@ async function defaultBrowser2() {
     return { name, id };
   }
   if (process17.platform === "linux") {
-    const { stdout } = await execFileAsync6("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const { stdout } = await execFileAsync7("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
     const id = stdout.trim();
     const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
     return { name, id };
@@ -62142,12 +63081,12 @@ async function defaultBrowser2() {
   }
   throw new Error("Only macOS, Linux, and Windows are supported");
 }
-var execFileAsync6, titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+var execFileAsync7, titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
 var init_default_browser = __esm(() => {
   init_default_browser_id();
   init_bundle_name();
   init_windows();
-  execFileAsync6 = promisify8(execFile7);
+  execFileAsync7 = promisify8(execFile8);
 });
 
 // node_modules/open/index.js
@@ -62168,7 +63107,7 @@ async function getWindowsDefaultBrowserFromWsl() {
   const powershellPath = await powerShellPath();
   const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
   const encodedCommand = Buffer3.from(rawCommand, "utf16le").toString("base64");
-  const { stdout } = await execFile8(powershellPath, [
+  const { stdout } = await execFile9(powershellPath, [
     "-NoProfile",
     "-NonInteractive",
     "-ExecutionPolicy",
@@ -62204,7 +63143,7 @@ function detectPlatformBinary({ [platform2]: platformBinary }, { wsl }) {
   }
   return detectArchBinary(platformBinary);
 }
-var execFile8, __dirname2, localXdgOpenPath, platform2, arch, pTryEach = async (array, mapper) => {
+var execFile9, __dirname2, localXdgOpenPath, platform2, arch, pTryEach = async (array, mapper) => {
   let latestError;
   for (const item of array) {
     try {
@@ -62383,7 +63322,7 @@ var init_open = __esm(() => {
   init_wsl_utils();
   init_default_browser();
   init_is_inside_container();
-  execFile8 = promisify9(childProcess.execFile);
+  execFile9 = promisify9(childProcess.execFile);
   __dirname2 = path21.dirname(fileURLToPath8(import.meta.url));
   localXdgOpenPath = path21.join(__dirname2, "xdg-open");
   ({ platform: platform2, arch } = process18);
@@ -62803,6 +63742,58 @@ function isConversationBusyError(detail) {
     return false;
   return detail.toLowerCase().includes(CONVERSATION_BUSY_DETAIL_FRAGMENT);
 }
+function isRetryableProviderErrorDetail(detail) {
+  if (typeof detail !== "string")
+    return false;
+  return RETRYABLE_PROVIDER_DETAIL_PATTERNS.some((pattern) => detail.includes(pattern));
+}
+function isNonRetryableProviderErrorDetail(detail) {
+  if (typeof detail !== "string")
+    return false;
+  const normalized = detail.toLowerCase();
+  if (NON_RETRYABLE_4XX_PATTERN.test(detail))
+    return true;
+  return NON_RETRYABLE_PROVIDER_DETAIL_PATTERNS.some((pattern) => normalized.includes(pattern));
+}
+function shouldRetryRunMetadataError(errorType, detail) {
+  const explicitLlmError = errorType === "llm_error";
+  const retryable429Detail = typeof detail === "string" && RETRYABLE_429_PATTERN.test(detail);
+  const retryableDetail = isRetryableProviderErrorDetail(detail);
+  const nonRetryableDetail = isNonRetryableProviderErrorDetail(detail);
+  if (nonRetryableDetail && !retryable429Detail)
+    return false;
+  if (explicitLlmError)
+    return true;
+  return retryable429Detail || retryableDetail;
+}
+function shouldRetryPreStreamTransientError(opts) {
+  const { status, detail } = opts;
+  if (status === 429)
+    return true;
+  if (status !== undefined && status >= 500)
+    return true;
+  if (status !== undefined && status >= 400)
+    return false;
+  const retryable429Detail = typeof detail === "string" && RETRYABLE_429_PATTERN.test(detail);
+  if (retryable429Detail)
+    return true;
+  if (isNonRetryableProviderErrorDetail(detail))
+    return false;
+  return isRetryableProviderErrorDetail(detail);
+}
+function parseRetryAfterHeaderMs(retryAfterValue) {
+  if (!retryAfterValue)
+    return null;
+  const seconds = Number(retryAfterValue);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.round(seconds * 1000);
+  }
+  const retryAtMs = Date.parse(retryAfterValue);
+  if (Number.isNaN(retryAtMs))
+    return null;
+  const delayMs = retryAtMs - Date.now();
+  return delayMs > 0 ? delayMs : 0;
+}
 function classifyPreStreamConflict(detail) {
   if (isApprovalPendingError(detail))
     return "approval_pending";
@@ -62810,7 +63801,7 @@ function classifyPreStreamConflict(detail) {
     return "conversation_busy";
   return null;
 }
-function getPreStreamErrorAction(detail, conversationBusyRetries, maxConversationBusyRetries) {
+function getPreStreamErrorAction(detail, conversationBusyRetries, maxConversationBusyRetries, opts) {
   const kind = classifyPreStreamConflict(detail);
   if (kind === "approval_pending") {
     return "resolve_approval_pending";
@@ -62818,6 +63809,9 @@ function getPreStreamErrorAction(detail, conversationBusyRetries, maxConversatio
   if (kind === "conversation_busy" && conversationBusyRetries < maxConversationBusyRetries) {
     return "retry_conversation_busy";
   }
+  if (opts && shouldRetryPreStreamTransientError({ status: opts.status, detail }) && (opts.transientRetries ?? 0) < (opts.maxTransientRetries ?? 0)) {
+    return "retry_transient";
+  }
   return "rethrow";
 }
 function extractConflictDetail(error) {
@@ -62861,7 +63855,42 @@ function rebuildInputWithFreshDenials(currentInput, serverApprovals, denialReaso
 function shouldAttemptApprovalRecovery(opts) {
   return opts.approvalPendingDetected && opts.retries < opts.maxRetries;
 }
-var INVALID_TOOL_CALL_IDS_FRAGMENT = "invalid tool call ids", APPROVAL_PENDING_DETAIL_FRAGMENT = "waiting for approval", CONVERSATION_BUSY_DETAIL_FRAGMENT = "another request is currently being processed";
+var INVALID_TOOL_CALL_IDS_FRAGMENT = "invalid tool call ids", APPROVAL_PENDING_DETAIL_FRAGMENT = "waiting for approval", CONVERSATION_BUSY_DETAIL_FRAGMENT = "another request is currently being processed", RETRYABLE_PROVIDER_DETAIL_PATTERNS, NON_RETRYABLE_PROVIDER_DETAIL_PATTERNS, NON_RETRYABLE_4XX_PATTERN, RETRYABLE_429_PATTERN;
+var init_turn_recovery_policy = __esm(() => {
+  RETRYABLE_PROVIDER_DETAIL_PATTERNS = [
+    "Anthropic API error",
+    "OpenAI API error",
+    "Google Vertex API error",
+    "ChatGPT API error",
+    "ChatGPT server error",
+    "Connection error during Anthropic streaming",
+    "Connection error during streaming",
+    "upstream connect error",
+    "connection termination",
+    "peer closed connection",
+    "incomplete chunked read",
+    "Network error",
+    "Connection error",
+    "Request timed out",
+    "overloaded",
+    "api_error"
+  ];
+  NON_RETRYABLE_PROVIDER_DETAIL_PATTERNS = [
+    "invalid api key",
+    "incorrect api key",
+    "authentication error",
+    "unauthorized",
+    "permission denied",
+    "forbidden",
+    "invalid_request_error",
+    "invalid model",
+    "model_not_found",
+    "context_length_exceeded",
+    "invalid_encrypted_content"
+  ];
+  NON_RETRYABLE_4XX_PATTERN = /Error code:\s*4(0[0-8]|1\d|2\d|3\d|4\d|51)/i;
+  RETRYABLE_429_PATTERN = /Error code:\s*429|rate limit|too many requests/i;
+});
 
 // src/agent/approval-recovery.ts
 async function fetchRunErrorDetail(runId) {
@@ -62877,336 +63906,10 @@ async function fetchRunErrorDetail(runId) {
   }
 }
 var init_approval_recovery = __esm(async () => {
+  init_turn_recovery_policy();
   await init_client2();
 });
 
-// src/providers/openai-codex-provider.ts
-var exports_openai_codex_provider = {};
-__export(exports_openai_codex_provider, {
-  updateOpenAICodexProvider: () => updateOpenAICodexProvider,
-  removeOpenAICodexProvider: () => removeOpenAICodexProvider,
-  listProviders: () => listProviders,
-  getOpenAICodexProvider: () => getOpenAICodexProvider,
-  deleteOpenAICodexProvider: () => deleteOpenAICodexProvider,
-  createOrUpdateOpenAICodexProvider: () => createOrUpdateOpenAICodexProvider,
-  createOpenAICodexProvider: () => createOpenAICodexProvider,
-  checkOpenAICodexEligibility: () => checkOpenAICodexEligibility,
-  OPENAI_CODEX_PROVIDER_NAME: () => OPENAI_CODEX_PROVIDER_NAME,
-  CHATGPT_OAUTH_PROVIDER_TYPE: () => CHATGPT_OAUTH_PROVIDER_TYPE
-});
-async function getLettaConfig() {
-  const settings = await settingsManager.getSettingsWithSecureTokens();
-  const baseUrl = process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
-  const apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY || "";
-  return { baseUrl, apiKey };
-}
-async function providersRequest(method, path22, body) {
-  const { baseUrl, apiKey } = await getLettaConfig();
-  const url = `${baseUrl}${path22}`;
-  const response = await fetch(url, {
-    method,
-    headers: getLettaCodeHeaders2(apiKey),
-    ...body && { body: JSON.stringify(body) }
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    if (response.status === 403) {
-      try {
-        const errorData = JSON.parse(errorText);
-        if (errorData.error && typeof errorData.error === "string" && errorData.error.includes("only available for pro or enterprise")) {
-          throw new Error("PLAN_UPGRADE_REQUIRED");
-        }
-      } catch (parseError) {
-        if (parseError instanceof Error && parseError.message === "PLAN_UPGRADE_REQUIRED") {
-          throw parseError;
-        }
-      }
-    }
-    throw new Error(`Provider API error (${response.status}): ${errorText}`);
-  }
-  const text = await response.text();
-  if (!text) {
-    return {};
-  }
-  return JSON.parse(text);
-}
-async function listProviders() {
-  try {
-    const response = await providersRequest("GET", "/v1/providers");
-    return response;
-  } catch {
-    return [];
-  }
-}
-async function getOpenAICodexProvider() {
-  const providers = await listProviders();
-  return providers.find((p) => p.name === OPENAI_CODEX_PROVIDER_NAME) || null;
-}
-async function createOpenAICodexProvider(config) {
-  const apiKeyJson = JSON.stringify({
-    access_token: config.access_token,
-    id_token: config.id_token,
-    refresh_token: config.refresh_token,
-    account_id: config.account_id,
-    expires_at: config.expires_at
-  });
-  return providersRequest("POST", "/v1/providers", {
-    name: OPENAI_CODEX_PROVIDER_NAME,
-    provider_type: CHATGPT_OAUTH_PROVIDER_TYPE,
-    api_key: apiKeyJson
-  });
-}
-async function updateOpenAICodexProvider(providerId, config) {
-  const apiKeyJson = JSON.stringify({
-    access_token: config.access_token,
-    id_token: config.id_token,
-    refresh_token: config.refresh_token,
-    account_id: config.account_id,
-    expires_at: config.expires_at
-  });
-  return providersRequest("PATCH", `/v1/providers/${providerId}`, {
-    api_key: apiKeyJson
-  });
-}
-async function deleteOpenAICodexProvider(providerId) {
-  await providersRequest("DELETE", `/v1/providers/${providerId}`);
-}
-async function createOrUpdateOpenAICodexProvider(config) {
-  const existing = await getOpenAICodexProvider();
-  if (existing) {
-    return updateOpenAICodexProvider(existing.id, config);
-  } else {
-    return createOpenAICodexProvider(config);
-  }
-}
-async function removeOpenAICodexProvider() {
-  const existing = await getOpenAICodexProvider();
-  if (existing) {
-    await deleteOpenAICodexProvider(existing.id);
-  }
-}
-async function checkOpenAICodexEligibility() {
-  try {
-    const balance = await providersRequest("GET", "/v1/metadata/balance");
-    const billingTier = balance.billing_tier.toLowerCase();
-    if (billingTier === "pro" || billingTier === "enterprise") {
-      return {
-        eligible: true,
-        billing_tier: balance.billing_tier
-      };
-    }
-    return {
-      eligible: false,
-      billing_tier: balance.billing_tier,
-      reason: `ChatGPT OAuth requires a Pro or Enterprise plan. Current plan: ${balance.billing_tier}`
-    };
-  } catch (error) {
-    console.warn("Failed to check ChatGPT OAuth eligibility:", error);
-    return {
-      eligible: true,
-      billing_tier: "unknown"
-    };
-  }
-}
-var OPENAI_CODEX_PROVIDER_NAME = "chatgpt-plus-pro", CHATGPT_OAUTH_PROVIDER_TYPE = "chatgpt_oauth";
-var init_openai_codex_provider = __esm(async () => {
-  init_http_headers();
-  init_oauth();
-  await init_settings_manager();
-});
-
-// src/agent/modify.ts
-var exports_modify = {};
-__export(exports_modify, {
-  updateAgentSystemPromptRaw: () => updateAgentSystemPromptRaw,
-  updateAgentSystemPromptMemfs: () => updateAgentSystemPromptMemfs,
-  updateAgentSystemPrompt: () => updateAgentSystemPrompt,
-  updateAgentLLMConfig: () => updateAgentLLMConfig
-});
-function buildModelSettings(modelHandle, updateArgs) {
-  const isOpenAI = modelHandle.startsWith("openai/") || modelHandle.startsWith(`${OPENAI_CODEX_PROVIDER_NAME}/`);
-  const isAnthropic = modelHandle.startsWith("anthropic/") || modelHandle.startsWith("claude-pro-max/");
-  const isZai = modelHandle.startsWith("zai/");
-  const isGoogleAI = modelHandle.startsWith("google_ai/");
-  const isGoogleVertex = modelHandle.startsWith("google_vertex/");
-  const isOpenRouter = modelHandle.startsWith("openrouter/");
-  const isBedrock = modelHandle.startsWith("bedrock/");
-  let settings;
-  if (isOpenAI || isOpenRouter) {
-    const openaiSettings = {
-      provider_type: "openai",
-      parallel_tool_calls: true
-    };
-    if (updateArgs?.reasoning_effort) {
-      openaiSettings.reasoning = {
-        reasoning_effort: updateArgs.reasoning_effort
-      };
-    }
-    settings = openaiSettings;
-  } else if (isAnthropic) {
-    const anthropicSettings = {
-      provider_type: "anthropic",
-      parallel_tool_calls: true
-    };
-    if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
-      anthropicSettings.thinking = {
-        type: updateArgs?.enable_reasoner === false ? "disabled" : "enabled",
-        ...typeof updateArgs?.max_reasoning_tokens === "number" && {
-          budget_tokens: updateArgs.max_reasoning_tokens
-        }
-      };
-    }
-    settings = anthropicSettings;
-  } else if (isZai) {
-    settings = {
-      provider_type: "zai",
-      parallel_tool_calls: true
-    };
-  } else if (isGoogleAI) {
-    const googleSettings = {
-      provider_type: "google_ai",
-      parallel_tool_calls: true
-    };
-    if (updateArgs?.thinking_budget !== undefined) {
-      googleSettings.thinking_config = {
-        thinking_budget: updateArgs.thinking_budget
-      };
-    }
-    if (typeof updateArgs?.temperature === "number") {
-      googleSettings.temperature = updateArgs.temperature;
-    }
-    settings = googleSettings;
-  } else if (isGoogleVertex) {
-    const googleVertexSettings = {
-      provider_type: "google_vertex",
-      parallel_tool_calls: true
-    };
-    if (updateArgs?.thinking_budget !== undefined) {
-      googleVertexSettings.thinking_config = {
-        thinking_budget: updateArgs.thinking_budget
-      };
-    }
-    if (typeof updateArgs?.temperature === "number") {
-      googleVertexSettings.temperature = updateArgs.temperature;
-    }
-    settings = googleVertexSettings;
-  } else if (isBedrock) {
-    const bedrockSettings = {
-      provider_type: "bedrock",
-      parallel_tool_calls: true
-    };
-    if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
-      bedrockSettings.thinking = {
-        type: updateArgs?.enable_reasoner === false ? "disabled" : "enabled",
-        ...typeof updateArgs?.max_reasoning_tokens === "number" && {
-          budget_tokens: updateArgs.max_reasoning_tokens
-        }
-      };
-    }
-    settings = bedrockSettings;
-  } else {
-    settings = {};
-  }
-  if (typeof updateArgs?.max_output_tokens === "number" && "provider_type" in settings) {
-    settings.max_output_tokens = updateArgs.max_output_tokens;
-  }
-  return settings;
-}
-async function updateAgentLLMConfig(agentId, modelHandle, updateArgs) {
-  const client = await getClient2();
-  const modelSettings = buildModelSettings(modelHandle, updateArgs);
-  const contextWindow = updateArgs?.context_window ?? await getModelContextWindow(modelHandle);
-  const hasModelSettings = Object.keys(modelSettings).length > 0;
-  await client.agents.update(agentId, {
-    model: modelHandle,
-    ...hasModelSettings && { model_settings: modelSettings },
-    ...contextWindow && { context_window_limit: contextWindow },
-    ...typeof updateArgs?.max_output_tokens === "number" && {
-      max_tokens: updateArgs.max_output_tokens
-    }
-  });
-  const finalAgent = await client.agents.retrieve(agentId);
-  return finalAgent.llm_config;
-}
-async function updateAgentSystemPromptRaw(agentId, systemPromptContent) {
-  try {
-    const client = await getClient2();
-    await client.agents.update(agentId, {
-      system: systemPromptContent
-    });
-    return {
-      success: true,
-      message: "System prompt updated successfully"
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to update system prompt: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-async function updateAgentSystemPrompt(agentId, systemPromptId) {
-  try {
-    const { resolveSystemPrompt: resolveSystemPrompt3, SYSTEM_PROMPT_MEMORY_ADDON: SYSTEM_PROMPT_MEMORY_ADDON3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
-    const baseContent = await resolveSystemPrompt3(systemPromptId);
-    const systemPromptContent = `${baseContent}
-${SYSTEM_PROMPT_MEMORY_ADDON3}`;
-    const updateResult = await updateAgentSystemPromptRaw(agentId, systemPromptContent);
-    if (!updateResult.success) {
-      return {
-        success: false,
-        message: updateResult.message,
-        agent: null
-      };
-    }
-    const client = await getClient2();
-    const agent = await client.agents.retrieve(agentId);
-    return {
-      success: true,
-      message: "System prompt applied successfully",
-      agent
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to apply system prompt: ${error instanceof Error ? error.message : String(error)}`,
-      agent: null
-    };
-  }
-}
-async function updateAgentSystemPromptMemfs(agentId, enableMemfs) {
-  try {
-    const client = await getClient2();
-    const agent = await client.agents.retrieve(agentId);
-    let currentSystemPrompt = agent.system || "";
-    const { SYSTEM_PROMPT_MEMFS_ADDON: SYSTEM_PROMPT_MEMFS_ADDON3, SYSTEM_PROMPT_MEMORY_ADDON: SYSTEM_PROMPT_MEMORY_ADDON3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
-    const memoryHeaderRegex = /\n#{1,2} Memory\b[\s\S]*?(?=\n#{1,2} (?!Memory|Filesystem|Structure|How It Works|Syncing|History)[^\n]|$)/;
-    currentSystemPrompt = currentSystemPrompt.replace(memoryHeaderRegex, "");
-    const addon = enableMemfs ? SYSTEM_PROMPT_MEMFS_ADDON3 : SYSTEM_PROMPT_MEMORY_ADDON3;
-    currentSystemPrompt = `${currentSystemPrompt}
-${addon}`;
-    await client.agents.update(agentId, {
-      system: currentSystemPrompt
-    });
-    return {
-      success: true,
-      message: enableMemfs ? "System prompt updated to include Memory Filesystem section" : "System prompt updated to include standard Memory section"
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to update system prompt memfs: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-var init_modify = __esm(async () => {
-  await __promiseAll([
-    init_openai_codex_provider(),
-    init_available_models(),
-    init_client2()
-  ]);
-});
-
 // src/agent/prompts/sleeptime.ts
 var SLEEPTIME_MEMORY_PERSONA = `I am a sleep-time memory management agent. I observe the conversation between the user and their primary agent, then actively maintain memory blocks to keep them accurate, concise, and useful.
 
@@ -63364,8 +64067,7 @@ async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingM
   } else {
     systemPromptContent = await resolveSystemPrompt(options.systemPromptPreset);
   }
-  systemPromptContent = `${systemPromptContent}
-${SYSTEM_PROMPT_MEMORY_ADDON}`;
+  systemPromptContent = reconcileMemoryPrompt(systemPromptContent, options.memoryPromptMode ?? "standard");
   if (options.systemPromptAppend) {
     systemPromptContent = `${systemPromptContent}
 
@@ -63435,6 +64137,7 @@ ${options.systemPromptAppend}`;
 var init_create = __esm(async () => {
   init_constants();
   init_memory();
+  init_memoryPrompt();
   init_model();
   init_promptAssets();
   await __promiseAll([
@@ -64025,163 +64728,6 @@ var init_interactivePolicy = __esm(() => {
   HEADLESS_AUTO_ALLOW_TOOLS = new Set(["EnterPlanMode"]);
 });
 
-// src/tools/toolset.ts
-var exports_toolset = {};
-__export(exports_toolset, {
-  switchToolsetForModel: () => switchToolsetForModel,
-  reattachMemoryTool: () => reattachMemoryTool,
-  forceToolsetSwitch: () => forceToolsetSwitch,
-  ensureCorrectMemoryTool: () => ensureCorrectMemoryTool,
-  detachMemoryTools: () => detachMemoryTools,
-  MEMORY_TOOL_NAMES: () => MEMORY_TOOL_NAMES
-});
-async function ensureCorrectMemoryTool(agentId, modelIdentifier, useMemoryPatch) {
-  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
-  const client = await getClient2();
-  const shouldUsePatch = useMemoryPatch !== undefined ? useMemoryPatch : isOpenAIModel(resolvedModel);
-  try {
-    const agentWithTools = await client.agents.retrieve(agentId, {
-      include: ["agent.tools"]
-    });
-    const currentTools = agentWithTools.tools || [];
-    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
-    const hasAnyMemoryTool = mapByName.has("memory") || mapByName.has("memory_apply_patch");
-    if (!hasAnyMemoryTool) {
-      return;
-    }
-    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
-    const otherMemoryTool = desiredMemoryTool === "memory" ? "memory_apply_patch" : "memory";
-    let desiredId = mapByName.get(desiredMemoryTool);
-    if (!desiredId) {
-      const resp = await client.tools.list({ name: desiredMemoryTool });
-      desiredId = resp.items[0]?.id;
-    }
-    if (!desiredId) {
-      return;
-    }
-    const otherId = mapByName.get(otherMemoryTool);
-    if (mapByName.has(desiredMemoryTool) && !otherId) {
-      return;
-    }
-    const currentIds = currentTools.map((t) => t.id).filter((id) => typeof id === "string");
-    const newIds = new Set(currentIds);
-    if (otherId)
-      newIds.delete(otherId);
-    newIds.add(desiredId);
-    const updatedRules = (agentWithTools.tool_rules || []).map((r) => r.tool_name === otherMemoryTool ? { ...r, tool_name: desiredMemoryTool } : r);
-    await client.agents.update(agentId, {
-      tool_ids: Array.from(newIds),
-      tool_rules: updatedRules
-    });
-  } catch (err) {
-    console.warn(`Warning: Failed to sync memory tool: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-async function detachMemoryTools(agentId) {
-  const client = await getClient2();
-  try {
-    const agentWithTools = await client.agents.retrieve(agentId, {
-      include: ["agent.tools"]
-    });
-    const currentTools = agentWithTools.tools || [];
-    let detachedAny = false;
-    for (const tool of currentTools) {
-      if (tool.name && MEMORY_TOOL_NAMES.has(tool.name)) {
-        if (tool.id) {
-          await client.agents.tools.detach(tool.id, { agent_id: agentId });
-          detachedAny = true;
-        }
-      }
-    }
-    return detachedAny;
-  } catch (err) {
-    console.warn(`Warning: Failed to detach memory tools: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  }
-}
-async function reattachMemoryTool(agentId, modelIdentifier) {
-  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
-  const client = await getClient2();
-  const shouldUsePatch = isOpenAIModel(resolvedModel);
-  try {
-    const agentWithTools = await client.agents.retrieve(agentId, {
-      include: ["agent.tools"]
-    });
-    const currentTools = agentWithTools.tools || [];
-    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
-    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
-    if (mapByName.has(desiredMemoryTool)) {
-      return;
-    }
-    const resp = await client.tools.list({ name: desiredMemoryTool });
-    const toolId = resp.items[0]?.id;
-    if (!toolId) {
-      console.warn(`Memory tool "${desiredMemoryTool}" not found on server`);
-      return;
-    }
-    await client.agents.tools.attach(toolId, { agent_id: agentId });
-  } catch (err) {
-    console.warn(`Warning: Failed to reattach memory tool: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-async function forceToolsetSwitch(toolsetName, agentId) {
-  let modelForLoading;
-  if (toolsetName === "none") {
-    clearToolsWithLock();
-    return;
-  } else if (toolsetName === "codex") {
-    await loadSpecificTools([...CODEX_TOOLS]);
-    modelForLoading = "openai/gpt-4";
-  } else if (toolsetName === "codex_snake") {
-    await loadTools("openai/gpt-4");
-    modelForLoading = "openai/gpt-4";
-  } else if (toolsetName === "gemini") {
-    await loadSpecificTools([...GEMINI_TOOLS]);
-    modelForLoading = "google_ai/gemini-3-pro-preview";
-  } else if (toolsetName === "gemini_snake") {
-    await loadTools("google_ai/gemini-3-pro-preview");
-    modelForLoading = "google_ai/gemini-3-pro-preview";
-  } else {
-    await loadTools("anthropic/claude-sonnet-4");
-    modelForLoading = "anthropic/claude-sonnet-4";
-  }
-  const useMemoryPatch = toolsetName === "codex" || toolsetName === "codex_snake";
-  await ensureCorrectMemoryTool(agentId, modelForLoading, useMemoryPatch);
-}
-async function switchToolsetForModel(modelIdentifier, agentId) {
-  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
-  await loadTools(resolvedModel);
-  const loadedAfterPrimary = getToolNames().length;
-  if (loadedAfterPrimary === 0 && !toolFilter.isActive()) {
-    await loadTools();
-    if (getToolNames().length === 0) {
-      throw new Error(`Failed to load any Letta tools for model "${resolvedModel}".`);
-    }
-  }
-  await ensureCorrectMemoryTool(agentId, resolvedModel);
-  const { isGeminiModel: isGeminiModel3 } = await init_manager3().then(() => exports_manager2);
-  const toolsetName = isOpenAIModel(resolvedModel) ? "codex" : isGeminiModel3(resolvedModel) ? "gemini" : "default";
-  return toolsetName;
-}
-var CODEX_TOOLS, GEMINI_TOOLS, MEMORY_TOOL_NAMES;
-var init_toolset = __esm(async () => {
-  init_model();
-  init_filter();
-  await __promiseAll([
-    init_client2(),
-    init_manager3()
-  ]);
-  CODEX_TOOLS = OPENAI_PASCAL_TOOLS;
-  GEMINI_TOOLS = GEMINI_PASCAL_TOOLS;
-  MEMORY_TOOL_NAMES = new Set([
-    "memory",
-    "memory_apply_patch",
-    "memory_insert",
-    "memory_replace",
-    "memory_rethink"
-  ]);
-});
-
 // src/cli/helpers/toolNameMapping.ts
 function getDisplayToolName(rawName) {
   if (rawName === "write")
@@ -65320,6 +65866,14 @@ function getRetryStatusMessage(errorDetail) {
     return DEFAULT_RETRY_MESSAGE;
   if (errorDetail.includes("Anthropic API is overloaded"))
     return "Anthropic API is overloaded, retrying...";
+  if (errorDetail.includes("ChatGPT API error") || errorDetail.includes("ChatGPT server error") || errorDetail.includes("upstream connect error")) {
+    return "OpenAI ChatGPT backend connection failed, retrying...";
+  }
+  if (errorDetail.includes("Connection error during streaming") || errorDetail.includes("incomplete chunked read") || errorDetail.includes("connection termination")) {
+    return "OpenAI ChatGPT streaming connection dropped, retrying...";
+  }
+  if (errorDetail.includes("OpenAI API error"))
+    return "OpenAI API error, retrying...";
   return DEFAULT_RETRY_MESSAGE;
 }
 function createAgentLink(runId, agentId, conversationId) {
@@ -65340,6 +65894,157 @@ var init_errorFormatter = __esm(() => {
 `);
 });
 
+// src/cli/helpers/memoryReminder.ts
+function isValidStepCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
+}
+function normalizeStepCount(value, fallback) {
+  return isValidStepCount(value) ? value : fallback;
+}
+function normalizeTrigger(value, fallback) {
+  if (value === "off" || value === "step-count" || value === "compaction-event") {
+    return value;
+  }
+  return fallback;
+}
+function normalizeBehavior(value, fallback) {
+  if (value === "reminder" || value === "auto-launch") {
+    return value;
+  }
+  return fallback;
+}
+function applyExplicitReflectionOverrides(base2, raw) {
+  return {
+    trigger: normalizeTrigger(raw.reflectionTrigger, base2.trigger),
+    behavior: normalizeBehavior(raw.reflectionBehavior, base2.behavior),
+    stepCount: normalizeStepCount(raw.reflectionStepCount, base2.stepCount)
+  };
+}
+function legacyModeToReflectionSettings(mode) {
+  if (typeof mode === "number") {
+    return {
+      trigger: "step-count",
+      behavior: "reminder",
+      stepCount: normalizeStepCount(mode, DEFAULT_STEP_COUNT)
+    };
+  }
+  if (mode === null) {
+    return {
+      trigger: "off",
+      behavior: DEFAULT_REFLECTION_SETTINGS.behavior,
+      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
+    };
+  }
+  if (mode === "compaction") {
+    return {
+      trigger: "compaction-event",
+      behavior: "reminder",
+      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
+    };
+  }
+  if (mode === "auto-compaction") {
+    return {
+      trigger: "compaction-event",
+      behavior: "auto-launch",
+      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
+    };
+  }
+  return { ...DEFAULT_REFLECTION_SETTINGS };
+}
+function reflectionSettingsToLegacyMode(settings) {
+  if (settings.trigger === "off") {
+    return null;
+  }
+  if (settings.trigger === "compaction-event") {
+    return settings.behavior === "auto-launch" ? "auto-compaction" : "compaction";
+  }
+  return normalizeStepCount(settings.stepCount, DEFAULT_STEP_COUNT);
+}
+function getReflectionSettings() {
+  const globalSettings = settingsManager.getSettings();
+  let resolved = legacyModeToReflectionSettings(globalSettings.memoryReminderInterval);
+  resolved = applyExplicitReflectionOverrides(resolved, globalSettings);
+  try {
+    const localSettings = settingsManager.getLocalProjectSettings();
+    if (localSettings.memoryReminderInterval !== undefined) {
+      resolved = legacyModeToReflectionSettings(localSettings.memoryReminderInterval);
+    }
+    resolved = applyExplicitReflectionOverrides(resolved, localSettings);
+  } catch {}
+  return resolved;
+}
+function shouldFireStepCountTrigger(turnCount, settings = getReflectionSettings()) {
+  if (settings.trigger !== "step-count") {
+    return false;
+  }
+  const stepCount = normalizeStepCount(settings.stepCount, DEFAULT_STEP_COUNT);
+  return turnCount > 0 && turnCount % stepCount === 0;
+}
+async function buildMemfsAwareMemoryReminder(agentId, trigger) {
+  if (settingsManager.isMemfsEnabled(agentId)) {
+    debugLog("memory", `Reflection reminder fired (${trigger}, agent ${agentId})`);
+    const { MEMORY_REFLECTION_REMINDER: MEMORY_REFLECTION_REMINDER3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+    return MEMORY_REFLECTION_REMINDER3;
+  }
+  debugLog("memory", `Memory check reminder fired (${trigger}, agent ${agentId})`);
+  const { MEMORY_CHECK_REMINDER: MEMORY_CHECK_REMINDER3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+  return MEMORY_CHECK_REMINDER3;
+}
+async function buildCompactionMemoryReminder(agentId) {
+  return buildMemfsAwareMemoryReminder(agentId, "compaction");
+}
+async function buildMemoryReminder(turnCount, agentId) {
+  const reflectionSettings = getReflectionSettings();
+  if (reflectionSettings.trigger !== "step-count") {
+    return "";
+  }
+  if (shouldFireStepCountTrigger(turnCount, reflectionSettings)) {
+    debugLog("memory", `Turn-based memory reminder fired (turn ${turnCount}, interval ${reflectionSettings.stepCount}, agent ${agentId})`);
+    return buildMemfsAwareMemoryReminder(agentId, "interval");
+  }
+  return "";
+}
+function parseMemoryPreference(questions, answers) {
+  for (const q of questions) {
+    if (!q.question)
+      continue;
+    const questionLower = q.question.toLowerCase();
+    const headerLower = q.header?.toLowerCase() || "";
+    if (questionLower.includes("memory") || questionLower.includes("remember") || headerLower.includes("memory")) {
+      const answer = answers[q.question]?.toLowerCase() || "";
+      if (answer.includes("frequent")) {
+        settingsManager.updateLocalProjectSettings({
+          memoryReminderInterval: MEMORY_INTERVAL_FREQUENT,
+          reflectionTrigger: "step-count",
+          reflectionBehavior: "reminder",
+          reflectionStepCount: MEMORY_INTERVAL_FREQUENT
+        });
+        return true;
+      } else if (answer.includes("occasional")) {
+        settingsManager.updateLocalProjectSettings({
+          memoryReminderInterval: MEMORY_INTERVAL_OCCASIONAL,
+          reflectionTrigger: "step-count",
+          reflectionBehavior: "reminder",
+          reflectionStepCount: MEMORY_INTERVAL_OCCASIONAL
+        });
+        return true;
+      }
+      break;
+    }
+  }
+  return false;
+}
+var MEMORY_INTERVAL_FREQUENT = 5, MEMORY_INTERVAL_OCCASIONAL = 10, DEFAULT_STEP_COUNT = 25, DEFAULT_REFLECTION_SETTINGS;
+var init_memoryReminder = __esm(async () => {
+  init_debug();
+  await init_settings_manager();
+  DEFAULT_REFLECTION_SETTINGS = {
+    trigger: "compaction-event",
+    behavior: "reminder",
+    stepCount: DEFAULT_STEP_COUNT
+  };
+});
+
 // src/cli/helpers/streamProcessor.ts
 class StreamProcessor {
   pendingApprovals = new Map;
@@ -65525,7 +66230,7 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
     if (!streamProcessor.lastRunId) {
       fallbackError = errorMessage;
     }
-    stopReason = "error";
+    stopReason = streamProcessor.stopReason || "error";
     markIncompleteToolsAsCancelled(buffers, true, "stream_error");
     queueMicrotask(refresh);
   } finally {
@@ -65763,7 +66468,7 @@ function parseRegistryHandle(handle) {
 }
 async function importAgentFromRegistry(options) {
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const { join: join21 } = await import("node:path");
+  const { join: join22 } = await import("node:path");
   const { writeFile: writeFile4, unlink } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
@@ -65775,7 +66480,7 @@ async function importAgentFromRegistry(options) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join21(tmpdir3(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join22(tmpdir3(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile4(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
@@ -65800,149 +66505,6 @@ var init_import = __esm(async () => {
   ]);
 });
 
-// src/agent/memoryFilesystem.ts
-var exports_memoryFilesystem = {};
-__export(exports_memoryFilesystem, {
-  renderMemoryFilesystemTree: () => renderMemoryFilesystemTree,
-  labelFromRelativePath: () => labelFromRelativePath,
-  getMemorySystemDir: () => getMemorySystemDir,
-  getMemoryFilesystemRoot: () => getMemoryFilesystemRoot,
-  ensureMemoryFilesystemDirs: () => ensureMemoryFilesystemDirs,
-  enableMemfsIfCloud: () => enableMemfsIfCloud,
-  applyMemfsFlags: () => applyMemfsFlags,
-  MEMORY_SYSTEM_DIR: () => MEMORY_SYSTEM_DIR,
-  MEMORY_FS_ROOT: () => MEMORY_FS_ROOT,
-  MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR,
-  MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR
-});
-import { existsSync as existsSync12, mkdirSync as mkdirSync8 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join21 } from "node:path";
-function getMemoryFilesystemRoot(agentId, homeDir = homedir14()) {
-  return join21(homeDir, MEMORY_FS_ROOT, MEMORY_FS_AGENTS_DIR, agentId, MEMORY_FS_MEMORY_DIR);
-}
-function getMemorySystemDir(agentId, homeDir = homedir14()) {
-  return join21(getMemoryFilesystemRoot(agentId, homeDir), MEMORY_SYSTEM_DIR);
-}
-function ensureMemoryFilesystemDirs(agentId, homeDir = homedir14()) {
-  const root = getMemoryFilesystemRoot(agentId, homeDir);
-  const systemDir = getMemorySystemDir(agentId, homeDir);
-  if (!existsSync12(root)) {
-    mkdirSync8(root, { recursive: true });
-  }
-  if (!existsSync12(systemDir)) {
-    mkdirSync8(systemDir, { recursive: true });
-  }
-}
-function labelFromRelativePath(relativePath) {
-  const normalized = relativePath.replace(/\\/g, "/");
-  return normalized.replace(/\.md$/, "");
-}
-function renderMemoryFilesystemTree(systemLabels, detachedLabels) {
-  const makeNode = () => ({ children: new Map, isFile: false });
-  const root = makeNode();
-  const insertPath = (base2, label) => {
-    const parts = base2 ? [base2, ...label.split("/")] : label.split("/");
-    let current = root;
-    for (const [i, partName] of parts.entries()) {
-      const part = i === parts.length - 1 ? `${partName}.md` : partName;
-      if (!current.children.has(part)) {
-        current.children.set(part, makeNode());
-      }
-      current = current.children.get(part);
-      if (i === parts.length - 1) {
-        current.isFile = true;
-      }
-    }
-  };
-  for (const label of systemLabels) {
-    insertPath(MEMORY_SYSTEM_DIR, label);
-  }
-  for (const label of detachedLabels) {
-    insertPath(null, label);
-  }
-  if (!root.children.has(MEMORY_SYSTEM_DIR)) {
-    root.children.set(MEMORY_SYSTEM_DIR, makeNode());
-  }
-  const sortedEntries = (node) => {
-    const entries = Array.from(node.children.entries());
-    return entries.sort(([nameA, nodeA], [nameB, nodeB]) => {
-      if (nodeA.isFile !== nodeB.isFile) {
-        return nodeA.isFile ? 1 : -1;
-      }
-      return nameA.localeCompare(nameB);
-    });
-  };
-  const lines = ["/memory/"];
-  const render2 = (node, prefix) => {
-    const entries = sortedEntries(node);
-    entries.forEach(([name, child], index) => {
-      const isLast = index === entries.length - 1;
-      const branch = isLast ? "└──" : "├──";
-      lines.push(`${prefix}${branch} ${name}${child.isFile ? "" : "/"}`);
-      if (child.children.size > 0) {
-        const nextPrefix = `${prefix}${isLast ? "    " : "│   "}`;
-        render2(child, nextPrefix);
-      }
-    });
-  };
-  render2(root, "");
-  return lines.join(`
-`);
-}
-async function applyMemfsFlags(agentId, memfsFlag, noMemfsFlag, options) {
-  const { getServerUrl: getServerUrl2 } = await init_client2().then(() => exports_client);
-  const { settingsManager: settingsManager3 } = await init_settings_manager().then(() => exports_settings_manager);
-  if (memfsFlag) {
-    const serverUrl = getServerUrl2();
-    if (!serverUrl.includes("api.letta.com")) {
-      throw new Error("--memfs is only available on Letta Cloud (api.letta.com).");
-    }
-    settingsManager3.setMemfsEnabled(agentId, true);
-  } else if (noMemfsFlag) {
-    settingsManager3.setMemfsEnabled(agentId, false);
-  }
-  const isEnabled = settingsManager3.isMemfsEnabled(agentId);
-  if (isEnabled && memfsFlag) {
-    const { detachMemoryTools: detachMemoryTools2 } = await init_toolset().then(() => exports_toolset);
-    await detachMemoryTools2(agentId);
-  }
-  if (memfsFlag || noMemfsFlag) {
-    const { updateAgentSystemPromptMemfs: updateAgentSystemPromptMemfs2 } = await init_modify().then(() => exports_modify);
-    await updateAgentSystemPromptMemfs2(agentId, isEnabled);
-  }
-  let pullSummary;
-  if (isEnabled) {
-    const { addGitMemoryTag: addGitMemoryTag2, isGitRepo: isGitRepo2, cloneMemoryRepo: cloneMemoryRepo2, pullMemory: pullMemory2 } = await init_memoryGit().then(() => exports_memoryGit);
-    await addGitMemoryTag2(agentId);
-    if (!isGitRepo2(agentId)) {
-      await cloneMemoryRepo2(agentId);
-    } else if (options?.pullOnExistingRepo) {
-      const result = await pullMemory2(agentId);
-      pullSummary = result.summary;
-    }
-  }
-  const action = memfsFlag ? "enabled" : noMemfsFlag ? "disabled" : "unchanged";
-  return {
-    action,
-    memoryDir: isEnabled ? getMemoryFilesystemRoot(agentId) : undefined,
-    pullSummary
-  };
-}
-async function enableMemfsIfCloud(agentId) {
-  const { getServerUrl: getServerUrl2 } = await init_client2().then(() => exports_client);
-  const serverUrl = getServerUrl2();
-  if (!serverUrl.includes("api.letta.com"))
-    return;
-  try {
-    await applyMemfsFlags(agentId, true, undefined);
-  } catch (error) {
-    console.warn(`Warning: Could not enable memfs for new agent: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-var MEMORY_FS_ROOT = ".letta", MEMORY_FS_AGENTS_DIR = "agents", MEMORY_FS_MEMORY_DIR = "memory", MEMORY_SYSTEM_DIR = "system";
-var init_memoryFilesystem = () => {};
-
 // src/agent/defaults.ts
 var exports_defaults = {};
 __export(exports_defaults, {
@@ -66180,10 +66742,106 @@ var init_check_approval = __esm(() => {
 // src/headless.ts
 var exports_headless = {};
 __export(exports_headless, {
+  shouldReinjectSkillsAfterCompaction: () => shouldReinjectSkillsAfterCompaction,
+  prependSkillsReminderToContent: () => prependSkillsReminderToContent,
   handleHeadlessCommand: () => handleHeadlessCommand
 });
 import { parseArgs as parseArgs5 } from "node:util";
-async function handleHeadlessCommand(argv, model, skillsDirectory, noSkills) {
+function prependSkillsReminderToContent(content, skillsReminder) {
+  if (!skillsReminder) {
+    return content;
+  }
+  if (typeof content === "string") {
+    return `${skillsReminder}
+
+${content}`;
+  }
+  if (Array.isArray(content)) {
+    return [
+      {
+        type: "text",
+        text: `${skillsReminder}
+
+`
+      },
+      ...content
+    ];
+  }
+  return content;
+}
+function shouldReinjectSkillsAfterCompaction(lines) {
+  return lines.some((line) => line.kind === "event" && line.eventType === "compaction" && line.phase === "finished" && (line.summary !== undefined || line.stats !== undefined));
+}
+function parseReflectionOverrides(values) {
+  const triggerRaw = values["reflection-trigger"];
+  const behaviorRaw = values["reflection-behavior"];
+  const stepCountRaw = values["reflection-step-count"];
+  if (!triggerRaw && !behaviorRaw && !stepCountRaw) {
+    return {};
+  }
+  const overrides = {};
+  if (triggerRaw !== undefined) {
+    if (triggerRaw !== "off" && triggerRaw !== "step-count" && triggerRaw !== "compaction-event") {
+      throw new Error(`Invalid --reflection-trigger "${triggerRaw}". Valid values: off, step-count, compaction-event`);
+    }
+    overrides.trigger = triggerRaw;
+  }
+  if (behaviorRaw !== undefined) {
+    if (behaviorRaw !== "reminder" && behaviorRaw !== "auto-launch") {
+      throw new Error(`Invalid --reflection-behavior "${behaviorRaw}". Valid values: reminder, auto-launch`);
+    }
+    overrides.behavior = behaviorRaw;
+  }
+  if (stepCountRaw !== undefined) {
+    const parsed = Number.parseInt(stepCountRaw, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+      throw new Error(`Invalid --reflection-step-count "${stepCountRaw}". Expected a positive integer.`);
+    }
+    overrides.stepCount = parsed;
+  }
+  return overrides;
+}
+function hasReflectionOverrides(overrides) {
+  return overrides.trigger !== undefined || overrides.behavior !== undefined || overrides.stepCount !== undefined;
+}
+async function applyReflectionOverrides(agentId, overrides) {
+  const current = getReflectionSettings();
+  const merged = {
+    trigger: overrides.trigger ?? current.trigger,
+    behavior: overrides.behavior ?? current.behavior,
+    stepCount: overrides.stepCount ?? current.stepCount
+  };
+  if (!hasReflectionOverrides(overrides)) {
+    return merged;
+  }
+  const memfsEnabled = settingsManager.isMemfsEnabled(agentId);
+  if (!memfsEnabled && merged.trigger === "compaction-event") {
+    throw new Error("--reflection-trigger compaction-event requires memfs enabled for this agent.");
+  }
+  if (!memfsEnabled && merged.trigger !== "off" && merged.behavior === "auto-launch") {
+    throw new Error("--reflection-behavior auto-launch requires memfs enabled for this agent.");
+  }
+  try {
+    settingsManager.getLocalProjectSettings();
+  } catch {
+    await settingsManager.loadLocalProjectSettings();
+  }
+  const legacyMode = reflectionSettingsToLegacyMode(merged);
+  settingsManager.updateLocalProjectSettings({
+    memoryReminderInterval: legacyMode,
+    reflectionTrigger: merged.trigger,
+    reflectionBehavior: merged.behavior,
+    reflectionStepCount: merged.stepCount
+  });
+  settingsManager.updateSettings({
+    memoryReminderInterval: legacyMode,
+    reflectionTrigger: merged.trigger,
+    reflectionBehavior: merged.behavior,
+    reflectionStepCount: merged.stepCount
+  });
+  return merged;
+}
+async function handleHeadlessCommand(argv, model, skillsDirectoryOverride, skillSourcesOverride, systemInfoReminderEnabledOverride) {
   const { values, positionals } = parseArgs5({
     args: argv,
     options: {
@@ -66216,6 +66874,7 @@ async function handleHeadlessCommand(argv, model, skillsDirectory, noSkills) {
       "permission-mode": { type: "string" },
       yolo: { type: "boolean" },
       skills: { type: "string" },
+      "skill-sources": { type: "string" },
       "pre-load-skills": { type: "string" },
       "init-blocks": { type: "string" },
       "base-tools": { type: "string" },
@@ -66224,6 +66883,11 @@ async function handleHeadlessCommand(argv, model, skillsDirectory, noSkills) {
       memfs: { type: "boolean" },
       "no-memfs": { type: "boolean" },
       "no-skills": { type: "boolean" },
+      "no-bundled-skills": { type: "boolean" },
+      "no-system-info-reminder": { type: "boolean" },
+      "reflection-trigger": { type: "string" },
+      "reflection-behavior": { type: "string" },
+      "reflection-step-count": { type: "string" },
       "max-turns": { type: "string" }
     },
     strict: false,
@@ -66315,12 +66979,42 @@ In headless mode, use:
   const blockValueArgs = values["block-value"];
   const initBlocksRaw = values["init-blocks"];
   const baseToolsRaw = values["base-tools"];
+  const skillsDirectory = values.skills ?? skillsDirectoryOverride;
+  const noSkillsFlag = values["no-skills"];
+  const noBundledSkillsFlag = values["no-bundled-skills"];
+  const skillSourcesRaw = values["skill-sources"];
   const memfsFlag = values.memfs;
   const noMemfsFlag = values["no-memfs"];
+  const requestedMemoryPromptMode = memfsFlag ? "memfs" : noMemfsFlag ? "standard" : undefined;
+  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !noMemfsFlag;
   const fromAfFile = values["from-af"];
   const preLoadSkillsRaw = values["pre-load-skills"];
+  const systemInfoReminderEnabled = systemInfoReminderEnabledOverride ?? !values["no-system-info-reminder"];
+  const reflectionOverrides = (() => {
+    try {
+      return parseReflectionOverrides(values);
+    } catch (error) {
+      console.error(error instanceof Error ? `Error: ${error.message}` : String(error));
+      process.exit(1);
+    }
+  })();
   const maxTurnsRaw = values["max-turns"];
-  const tagsRaw = values["tags"];
+  const tagsRaw = values.tags;
+  const resolvedSkillSources = (() => {
+    if (skillSourcesOverride) {
+      return skillSourcesOverride;
+    }
+    try {
+      return resolveSkillSourcesSelection({
+        skillSourcesRaw,
+        noSkills: noSkillsFlag,
+        noBundledSkills: noBundledSkillsFlag
+      });
+    } catch (error) {
+      console.error(error instanceof Error ? `Error: ${error.message}` : String(error));
+      process.exit(1);
+    }
+  })();
   let tags;
   if (tagsRaw !== undefined) {
     const trimmed = tagsRaw.trim();
@@ -66339,6 +67033,10 @@ In headless mode, use:
     }
     maxTurns = parsed;
   }
+  if (preLoadSkillsRaw && resolvedSkillSources.length === 0) {
+    console.error("Error: --pre-load-skills cannot be used when all skill sources are disabled.");
+    process.exit(1);
+  }
   if (specifiedConversationId?.startsWith("agent-")) {
     if (specifiedAgentId && specifiedAgentId !== specifiedConversationId) {
       console.error(`Error: Conflicting agent IDs: --agent ${specifiedAgentId} vs --conv ${specifiedConversationId}`);
@@ -66547,6 +67245,7 @@ In headless mode, use:
       systemPromptPreset,
       systemPromptCustom: systemCustom,
       systemPromptAppend: systemAppend,
+      memoryPromptMode: requestedMemoryPromptMode,
       initBlocks,
       baseTools,
       memoryBlocks,
@@ -66555,8 +67254,10 @@ In headless mode, use:
     };
     const result = await createAgent(createOptions);
     agent = result.agent;
-    const { enableMemfsIfCloud: enableMemfsIfCloud2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
-    await enableMemfsIfCloud2(agent.id);
+    if (shouldAutoEnableMemfsForNewAgent) {
+      const { enableMemfsIfCloud: enableMemfsIfCloud2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
+      await enableMemfsIfCloud2(agent.id);
+    }
   }
   let resolvedLocalConvId = null;
   if (!agent) {
@@ -66622,6 +67323,7 @@ In headless mode, use:
     }
   }
   let conversationId;
+  let effectiveReflectionSettings;
   const isSubagent = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
   try {
     const { applyMemfsFlags: applyMemfsFlags2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
@@ -66634,6 +67336,12 @@ In headless mode, use:
     console.error(`Memory git sync failed: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
+  try {
+    effectiveReflectionSettings = await applyReflectionOverrides(agent.id, reflectionOverrides);
+  } catch (error) {
+    console.error(`Failed to apply sleeptime settings: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
   const isolatedBlockLabels = initBlocks === undefined ? [...ISOLATED_BLOCK_LABELS] : ISOLATED_BLOCK_LABELS.filter((label) => initBlocks.includes(label));
   if (specifiedConversationId) {
     if (specifiedConversationId === "default") {
@@ -66711,7 +67419,7 @@ In headless mode, use:
       }
     } catch {}
   }
-  setAgentContext2(agent.id, skillsDirectory, noSkills);
+  setAgentContext2(agent.id, skillsDirectory, resolvedSkillSources);
   const outputFormat = values["output-format"] || "text";
   const includePartialMessages = Boolean(values["include-partial-messages"]);
   if (!["text", "json", "stream-json"].includes(outputFormat)) {
@@ -66726,7 +67434,7 @@ In headless mode, use:
   const loadedToolNames = getClientToolsFromRegistry2().map((t) => t.name);
   const availableTools = loadedToolNames.length > 0 ? loadedToolNames : agent.tools?.map((t) => t.name).filter((n) => !!n) || [];
   if (isBidirectionalMode) {
-    await runBidirectionalMode(agent, conversationId, client, outputFormat, includePartialMessages, availableTools);
+    await runBidirectionalMode(agent, conversationId, client, outputFormat, includePartialMessages, availableTools, resolvedSkillSources, systemInfoReminderEnabled, effectiveReflectionSettings);
     return;
   }
   const buffers = createBuffers(agent.id);
@@ -66746,6 +67454,11 @@ In headless mode, use:
       permission_mode: "",
       slash_commands: [],
       memfs_enabled: settingsManager.isMemfsEnabled(agent.id),
+      skill_sources: resolvedSkillSources,
+      system_info_reminder_enabled: systemInfoReminderEnabled,
+      reflection_trigger: effectiveReflectionSettings.trigger,
+      reflection_behavior: effectiveReflectionSettings.behavior,
+      reflection_step_count: effectiveReflectionSettings.stepCount,
       uuid: `init-${agent.id}`
     };
     console.log(JSON.stringify(initEvent));
@@ -66869,7 +67582,7 @@ ${SYSTEM_REMINDER_CLOSE}
     try {
       const skillsDir = getSkillsDirectory2() || join22(process.cwd(), defaultDir);
       const { skills } = await discoverSkills3(skillsDir, agent.id, {
-        skipBundled: noSkills
+        sources: resolvedSkillSources
       });
       const skillsReminder = formatSkillsAsSystemReminder3(skills);
       if (skillsReminder) {
@@ -66959,7 +67672,11 @@ ${loadedContents.join(`
         });
       } catch (preStreamError) {
         const errorDetail = extractConflictDetail(preStreamError);
-        const preStreamAction = getPreStreamErrorAction(errorDetail, conversationBusyRetries, CONVERSATION_BUSY_MAX_RETRIES);
+        const preStreamAction = getPreStreamErrorAction(errorDetail, conversationBusyRetries, CONVERSATION_BUSY_MAX_RETRIES, {
+          status: preStreamError instanceof APIError2 ? preStreamError.status : undefined,
+          transientRetries: llmApiErrorRetries,
+          maxTransientRetries: LLM_API_ERROR_MAX_RETRIES
+        });
         if (preStreamAction === "resolve_approval_pending") {
           if (outputFormat === "stream-json") {
             const recoveryMsg = {
@@ -66995,6 +67712,30 @@ ${loadedContents.join(`
           await new Promise((resolve20) => setTimeout(resolve20, CONVERSATION_BUSY_RETRY_DELAY_MS));
           continue;
         }
+        if (preStreamAction === "retry_transient") {
+          const attempt = llmApiErrorRetries + 1;
+          const retryAfterMs = preStreamError instanceof APIError2 ? parseRetryAfterHeaderMs(preStreamError.headers?.get("retry-after")) : null;
+          const delayMs = retryAfterMs ?? 1000 * 2 ** (attempt - 1);
+          llmApiErrorRetries = attempt;
+          if (outputFormat === "stream-json") {
+            const retryMsg = {
+              type: "retry",
+              reason: "llm_api_error",
+              attempt,
+              max_attempts: LLM_API_ERROR_MAX_RETRIES,
+              delay_ms: delayMs,
+              session_id: sessionId,
+              uuid: `retry-pre-stream-${crypto.randomUUID()}`
+            };
+            console.log(JSON.stringify(retryMsg));
+          } else {
+            const delaySeconds = Math.round(delayMs / 1000);
+            console.error(`Transient API error before streaming (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES}), retrying in ${delaySeconds}s...`);
+          }
+          await new Promise((resolve20) => setTimeout(resolve20, delayMs));
+          conversationBusyRetries = 0;
+          continue;
+        }
         conversationBusyRetries = 0;
         throw preStreamError;
       }
@@ -67257,18 +67998,7 @@ ${loadedContents.join(`
           const metaError = run.metadata?.error;
           const errorType = metaError?.error_type ?? metaError?.error?.error_type;
           const detail = metaError?.detail ?? metaError?.error?.detail ?? "";
-          const is4xxError = /Error code: 4\d{2}/.test(detail);
-          const llmProviderPatterns = [
-            "Anthropic API error",
-            "OpenAI API error",
-            "Google Vertex API error",
-            "overloaded",
-            "api_error",
-            "Network error",
-            "Connection error during Anthropic streaming"
-          ];
-          const isLlmErrorFromDetail = llmProviderPatterns.some((pattern) => detail.includes(pattern));
-          if ((errorType === "llm_error" || isLlmErrorFromDetail) && !is4xxError) {
+          if (shouldRetryRunMetadataError(errorType, detail)) {
             const attempt = llmApiErrorRetries + 1;
             const baseDelayMs = 1000;
             const delayMs = baseDelayMs * 2 ** (attempt - 1);
@@ -67416,7 +68146,7 @@ ${loadedContents.join(`
   markMilestone("HEADLESS_COMPLETE");
   reportAllMilestones();
 }
-async function runBidirectionalMode(agent, conversationId, client, _outputFormat, includePartialMessages, availableTools) {
+async function runBidirectionalMode(agent, conversationId, client, _outputFormat, includePartialMessages, availableTools, skillSources, systemInfoReminderEnabled, reflectionSettings) {
   const sessionId = agent.id;
   const readline = await import("node:readline");
   const initEvent = {
@@ -67429,10 +68159,18 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
     tools: availableTools,
     cwd: process.cwd(),
     memfs_enabled: settingsManager.isMemfsEnabled(agent.id),
+    skill_sources: skillSources,
+    system_info_reminder_enabled: systemInfoReminderEnabled,
+    reflection_trigger: reflectionSettings.trigger,
+    reflection_behavior: reflectionSettings.behavior,
+    reflection_step_count: reflectionSettings.stepCount,
     uuid: `init-${agent.id}`
   };
   console.log(JSON.stringify(initEvent));
   let currentAbortController = null;
+  let hasInjectedSkillsReminder = false;
+  let pendingSkillsReinject = false;
+  let cachedSkillsReminder = null;
   const resolveAllPendingApprovals = async () => {
     const { getResumeData: getResumeData3 } = await Promise.resolve().then(() => (init_check_approval(), exports_check_approval));
     while (true) {
@@ -67614,7 +68352,13 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
             response: {
               agent_id: agent.id,
               model: agent.llm_config?.model,
-              tools: availableTools
+              tools: availableTools,
+              memfs_enabled: settingsManager.isMemfsEnabled(agent.id),
+              skill_sources: skillSources,
+              system_info_reminder_enabled: systemInfoReminderEnabled,
+              reflection_trigger: reflectionSettings.trigger,
+              reflection_behavior: reflectionSettings.behavior,
+              reflection_step_count: reflectionSettings.stepCount
             }
           },
           session_id: sessionId,
@@ -67699,7 +68443,7 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
       }
       continue;
     }
-    if (message.type === "user" && message.message?.content) {
+    if (message.type === "user" && message.message?.content !== undefined) {
       const userContent = message.message.content;
       currentAbortController = new AbortController;
       try {
@@ -67708,26 +68452,34 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
         let numTurns = 0;
         let lastStopReason = null;
         let sawStreamError = false;
+        let preStreamTransientRetries = 0;
         let enrichedContent = userContent;
-        if (typeof enrichedContent === "string") {
-          try {
-            const {
-              discoverSkills: discover,
-              SKILLS_DIR: defaultDir,
-              formatSkillsAsSystemReminder: formatSkillsAsSystemReminder3
-            } = await Promise.resolve().then(() => (init_skills(), exports_skills));
-            const { getSkillsDirectory: getSkillsDirectory2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-            const { join: join22 } = await import("node:path");
-            const skillsDir = getSkillsDirectory2() || join22(process.cwd(), defaultDir);
-            const { skills } = await discover(skillsDir, agent.id);
-            const skillsReminder = formatSkillsAsSystemReminder3(skills);
-            if (skillsReminder) {
-              enrichedContent = `${skillsReminder}
-
-${enrichedContent}`;
-            }
-          } catch {}
-        }
+        try {
+          const {
+            discoverSkills: discover,
+            SKILLS_DIR: defaultDir,
+            formatSkillsAsSystemReminder: formatSkillsAsSystemReminder3
+          } = await Promise.resolve().then(() => (init_skills(), exports_skills));
+          const { getSkillsDirectory: getSkillsDirectory2 } = await Promise.resolve().then(() => (init_context(), exports_context));
+          const { join: join22 } = await import("node:path");
+          const skillsDir = getSkillsDirectory2() || join22(process.cwd(), defaultDir);
+          const { skills } = await discover(skillsDir, agent.id, {
+            sources: skillSources
+          });
+          const latestSkillsReminder = formatSkillsAsSystemReminder3(skills);
+          if (cachedSkillsReminder !== null && latestSkillsReminder !== cachedSkillsReminder) {
+            pendingSkillsReinject = true;
+          }
+          cachedSkillsReminder = latestSkillsReminder;
+          const shouldInjectSkillsReminder = !hasInjectedSkillsReminder || pendingSkillsReinject;
+          if (shouldInjectSkillsReminder && latestSkillsReminder) {
+            enrichedContent = prependSkillsReminderToContent(enrichedContent, latestSkillsReminder);
+          }
+          if (shouldInjectSkillsReminder) {
+            hasInjectedSkillsReminder = true;
+            pendingSkillsReinject = false;
+          }
+        } catch {}
         let currentInput = [
           { role: "user", content: enrichedContent }
         ];
@@ -67759,7 +68511,11 @@ ${enrichedContent}`;
             });
           } catch (preStreamError) {
             const errorDetail = extractConflictDetail(preStreamError);
-            const preStreamAction = getPreStreamErrorAction(errorDetail, 0, 0);
+            const preStreamAction = getPreStreamErrorAction(errorDetail, 0, 0, {
+              status: preStreamError instanceof APIError2 ? preStreamError.status : undefined,
+              transientRetries: preStreamTransientRetries,
+              maxTransientRetries: LLM_API_ERROR_MAX_RETRIES
+            });
             if (preStreamAction === "resolve_approval_pending") {
               const recoveryMsg = {
                 type: "recovery",
@@ -67772,8 +68528,27 @@ ${enrichedContent}`;
               await resolveAllPendingApprovals();
               continue;
             }
+            if (preStreamAction === "retry_transient") {
+              const attempt = preStreamTransientRetries + 1;
+              const retryAfterMs = preStreamError instanceof APIError2 ? parseRetryAfterHeaderMs(preStreamError.headers?.get("retry-after")) : null;
+              const delayMs = retryAfterMs ?? 1000 * 2 ** (attempt - 1);
+              preStreamTransientRetries = attempt;
+              const retryMsg = {
+                type: "retry",
+                reason: "llm_api_error",
+                attempt,
+                max_attempts: LLM_API_ERROR_MAX_RETRIES,
+                delay_ms: delayMs,
+                session_id: sessionId,
+                uuid: `retry-bidir-${crypto.randomUUID()}`
+              };
+              console.log(JSON.stringify(retryMsg));
+              await new Promise((resolve20) => setTimeout(resolve20, delayMs));
+              continue;
+            }
             throw preStreamError;
           }
+          preStreamTransientRetries = 0;
           const streamJsonHook = ({
             chunk,
             shouldOutput,
@@ -67923,6 +68698,9 @@ ${enrichedContent}`;
         }
         const durationMs = performance.now() - startTime;
         const lines = toLines(buffers);
+        if (shouldReinjectSkillsAfterCompaction(lines)) {
+          pendingSkillsReinject = true;
+        }
         const reversed = [...lines].reverse();
         const lastAssistant = reversed.find((line2) => line2.kind === "assistant" && ("text" in line2) && typeof line2.text === "string" && line2.text.trim().length > 0);
         const lastReasoning = reversed.find((line2) => line2.kind === "reasoning" && ("text" in line2) && typeof line2.text === "string" && line2.text.trim().length > 0);
@@ -67997,6 +68775,7 @@ var init_headless = __esm(async () => {
   init_context();
   init_memory();
   init_model();
+  init_skillSources();
   init_errorFormatter();
   init_constants();
   init_interactivePolicy();
@@ -68008,6 +68787,7 @@ var init_headless = __esm(async () => {
     init_message(),
     init_accumulator(),
     init_approvalClassification(),
+    init_memoryReminder(),
     init_stream(),
     init_settings_manager(),
     init_manager3()
@@ -88408,11 +89188,11 @@ function SkillsDialog({ onClose, agentId }) {
     (async () => {
       try {
         const { discoverSkills: discoverSkills3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
-        const { getSkillsDirectory: getSkillsDirectory2, getNoSkills: getNoSkills2 } = await Promise.resolve().then(() => (init_context(), exports_context));
+        const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
         const { join: join29 } = await import("node:path");
         const skillsDir = getSkillsDirectory2() || join29(process.cwd(), SKILLS_DIR3);
         const result = await discoverSkills3(skillsDir, agentId, {
-          skipBundled: getNoSkills2()
+          sources: getSkillSources2()
         });
         setSkills(result.skills);
       } catch {
@@ -88634,7 +89414,7 @@ function parseInitialState(initialSettings) {
   return {
     trigger: initialSettings.trigger === "off" || initialSettings.trigger === "step-count" || initialSettings.trigger === "compaction-event" ? initialSettings.trigger : "step-count",
     behavior: initialSettings.behavior === "auto-launch" ? "auto-launch" : "reminder",
-    stepCount: String(Number.isInteger(initialSettings.stepCount) && initialSettings.stepCount > 0 ? initialSettings.stepCount : Number(DEFAULT_STEP_COUNT))
+    stepCount: String(Number.isInteger(initialSettings.stepCount) && initialSettings.stepCount > 0 ? initialSettings.stepCount : Number(DEFAULT_STEP_COUNT2))
   };
 }
 function parseStepCount(raw) {
@@ -88696,7 +89476,7 @@ function SleeptimeSelector({
       });
       return;
     }
-    const fallbackStepCount = parseStepCount(stepCountInput) ?? Number(DEFAULT_STEP_COUNT);
+    const fallbackStepCount = parseStepCount(stepCountInput) ?? Number(DEFAULT_STEP_COUNT2);
     onSave({
       trigger,
       behavior: memfsEnabled ? behavior : "reminder",
@@ -88953,7 +89733,7 @@ function SleeptimeSelector({
     ]
   }, undefined, true, undefined, this);
 }
-var import_react81, jsx_dev_runtime58, SOLID_LINE23 = "─", DEFAULT_STEP_COUNT = "25", BEHAVIOR_OPTIONS;
+var import_react81, jsx_dev_runtime58, SOLID_LINE23 = "─", DEFAULT_STEP_COUNT2 = "25", BEHAVIOR_OPTIONS;
 var init_SleeptimeSelector = __esm(async () => {
   init_useTerminalWidth();
   init_colors();
@@ -92377,157 +93157,6 @@ var init_contextChart = __esm(() => {
   ].map(hexToFgAnsi);
 });
 
-// src/cli/helpers/memoryReminder.ts
-function isValidStepCount(value) {
-  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
-}
-function normalizeStepCount(value, fallback) {
-  return isValidStepCount(value) ? value : fallback;
-}
-function normalizeTrigger(value, fallback) {
-  if (value === "off" || value === "step-count" || value === "compaction-event") {
-    return value;
-  }
-  return fallback;
-}
-function normalizeBehavior(value, fallback) {
-  if (value === "reminder" || value === "auto-launch") {
-    return value;
-  }
-  return fallback;
-}
-function applyExplicitReflectionOverrides(base2, raw) {
-  return {
-    trigger: normalizeTrigger(raw.reflectionTrigger, base2.trigger),
-    behavior: normalizeBehavior(raw.reflectionBehavior, base2.behavior),
-    stepCount: normalizeStepCount(raw.reflectionStepCount, base2.stepCount)
-  };
-}
-function legacyModeToReflectionSettings(mode) {
-  if (typeof mode === "number") {
-    return {
-      trigger: "step-count",
-      behavior: "reminder",
-      stepCount: normalizeStepCount(mode, DEFAULT_STEP_COUNT2)
-    };
-  }
-  if (mode === null) {
-    return {
-      trigger: "off",
-      behavior: DEFAULT_REFLECTION_SETTINGS.behavior,
-      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
-    };
-  }
-  if (mode === "compaction") {
-    return {
-      trigger: "compaction-event",
-      behavior: "reminder",
-      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
-    };
-  }
-  if (mode === "auto-compaction") {
-    return {
-      trigger: "compaction-event",
-      behavior: "auto-launch",
-      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
-    };
-  }
-  return { ...DEFAULT_REFLECTION_SETTINGS };
-}
-function reflectionSettingsToLegacyMode(settings) {
-  if (settings.trigger === "off") {
-    return null;
-  }
-  if (settings.trigger === "compaction-event") {
-    return settings.behavior === "auto-launch" ? "auto-compaction" : "compaction";
-  }
-  return normalizeStepCount(settings.stepCount, DEFAULT_STEP_COUNT2);
-}
-function getReflectionSettings() {
-  const globalSettings = settingsManager.getSettings();
-  let resolved = legacyModeToReflectionSettings(globalSettings.memoryReminderInterval);
-  resolved = applyExplicitReflectionOverrides(resolved, globalSettings);
-  try {
-    const localSettings = settingsManager.getLocalProjectSettings();
-    if (localSettings.memoryReminderInterval !== undefined) {
-      resolved = legacyModeToReflectionSettings(localSettings.memoryReminderInterval);
-    }
-    resolved = applyExplicitReflectionOverrides(resolved, localSettings);
-  } catch {}
-  return resolved;
-}
-function shouldFireStepCountTrigger(turnCount, settings = getReflectionSettings()) {
-  if (settings.trigger !== "step-count") {
-    return false;
-  }
-  const stepCount = normalizeStepCount(settings.stepCount, DEFAULT_STEP_COUNT2);
-  return turnCount > 0 && turnCount % stepCount === 0;
-}
-async function buildMemfsAwareMemoryReminder(agentId, trigger) {
-  if (settingsManager.isMemfsEnabled(agentId)) {
-    debugLog("memory", `Reflection reminder fired (${trigger}, agent ${agentId})`);
-    const { MEMORY_REFLECTION_REMINDER: MEMORY_REFLECTION_REMINDER3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
-    return MEMORY_REFLECTION_REMINDER3;
-  }
-  debugLog("memory", `Memory check reminder fired (${trigger}, agent ${agentId})`);
-  const { MEMORY_CHECK_REMINDER: MEMORY_CHECK_REMINDER3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
-  return MEMORY_CHECK_REMINDER3;
-}
-async function buildCompactionMemoryReminder(agentId) {
-  return buildMemfsAwareMemoryReminder(agentId, "compaction");
-}
-async function buildMemoryReminder(turnCount, agentId) {
-  const reflectionSettings = getReflectionSettings();
-  if (reflectionSettings.trigger !== "step-count") {
-    return "";
-  }
-  if (shouldFireStepCountTrigger(turnCount, reflectionSettings)) {
-    debugLog("memory", `Turn-based memory reminder fired (turn ${turnCount}, interval ${reflectionSettings.stepCount}, agent ${agentId})`);
-    return buildMemfsAwareMemoryReminder(agentId, "interval");
-  }
-  return "";
-}
-function parseMemoryPreference(questions, answers) {
-  for (const q of questions) {
-    if (!q.question)
-      continue;
-    const questionLower = q.question.toLowerCase();
-    const headerLower = q.header?.toLowerCase() || "";
-    if (questionLower.includes("memory") || questionLower.includes("remember") || headerLower.includes("memory")) {
-      const answer = answers[q.question]?.toLowerCase() || "";
-      if (answer.includes("frequent")) {
-        settingsManager.updateLocalProjectSettings({
-          memoryReminderInterval: MEMORY_INTERVAL_FREQUENT,
-          reflectionTrigger: "step-count",
-          reflectionBehavior: "reminder",
-          reflectionStepCount: MEMORY_INTERVAL_FREQUENT
-        });
-        return true;
-      } else if (answer.includes("occasional")) {
-        settingsManager.updateLocalProjectSettings({
-          memoryReminderInterval: MEMORY_INTERVAL_OCCASIONAL,
-          reflectionTrigger: "step-count",
-          reflectionBehavior: "reminder",
-          reflectionStepCount: MEMORY_INTERVAL_OCCASIONAL
-        });
-        return true;
-      }
-      break;
-    }
-  }
-  return false;
-}
-var MEMORY_INTERVAL_FREQUENT = 5, MEMORY_INTERVAL_OCCASIONAL = 10, DEFAULT_STEP_COUNT2 = 25, DEFAULT_REFLECTION_SETTINGS;
-var init_memoryReminder = __esm(async () => {
-  init_debug();
-  await init_settings_manager();
-  DEFAULT_REFLECTION_SETTINGS = {
-    trigger: "compaction-event",
-    behavior: "reminder",
-    stepCount: DEFAULT_STEP_COUNT2
-  };
-});
-
 // src/cli/helpers/queuedMessageParts.ts
 function getQueuedNotificationSummaries(queued) {
   const summaries = [];
@@ -92683,6 +93312,15 @@ function buildSessionContext(options) {
         lastRunInfo = "(failed to parse last run time)";
       }
     }
+    const showMemoryDir = (() => {
+      try {
+        return settingsManager.isMemfsEnabled(agentInfo.id);
+      } catch {
+        return false;
+      }
+    })();
+    const memoryDirLine = showMemoryDir ? `
+- **Memory directory (also stored in \`MEMORY_DIR\` env var)**: \`${getMemoryFilesystemRoot(agentInfo.id)}\`` : "";
     let context3 = `${SYSTEM_REMINDER_OPEN}
 This is an automated message providing context about the user's environment.
 The user has just initiated a new connection via the [Letta Code CLI client](https://docs.letta.com/letta-code/index.md).
@@ -92720,7 +93358,7 @@ ${gitInfo.status}
     }
     context3 += `
 ## Agent Information (i.e. information about you)
-- **Agent ID**: ${agentInfo.id}
+- **Agent ID (also stored in \`AGENT_ID\` env var)**: ${agentInfo.id}${memoryDirLine}
 - **Agent name**: ${agentInfo.name || "(unnamed)"} (the user can change this with /rename)
 - **Agent description**: ${agentInfo.description || "(no description)"} (the user can change this with /description)
 - **Last message**: ${lastRunInfo}
@@ -92732,6 +93370,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
   }
 }
 var init_sessionContext = __esm(async () => {
+  init_memoryFilesystem();
   init_oauth();
   init_constants();
   init_version();
@@ -94835,19 +95474,7 @@ async function isRetriableError(stopReason, lastRunId) {
       const metaError = run.metadata?.error;
       const errorType = metaError?.error_type ?? metaError?.error?.error_type;
       const detail = metaError?.detail ?? metaError?.error?.detail ?? "";
-      const is4xxError = /Error code: 4\d{2}/.test(detail);
-      if (errorType === "llm_error" && !is4xxError)
-        return true;
-      const llmProviderPatterns = [
-        "Anthropic API error",
-        "OpenAI API error",
-        "Google Vertex API error",
-        "overloaded",
-        "api_error",
-        "Network error",
-        "Connection error during Anthropic streaming"
-      ];
-      if (llmProviderPatterns.some((pattern) => detail.includes(pattern)) && !is4xxError) {
+      if (shouldRetryRunMetadataError(errorType, detail)) {
         return true;
       }
       return false;
@@ -95029,7 +95656,8 @@ function App2({
   tokenStreaming = false,
   showCompactions = false,
   agentProvenance = null,
-  releaseNotes = null
+  releaseNotes = null,
+  sessionContextReminderEnabled = true
 }) {
   import_react94.useEffect(() => {
     prefetchAvailableModelHandles();
@@ -96407,7 +97035,11 @@ ${newState.originalPrompt}`
           stream2 = await sendMessageStream(conversationIdRef.current, currentInput, { agentId: agentIdRef.current });
         } catch (preStreamError) {
           const errorDetail = extractConflictDetail(preStreamError);
-          const preStreamAction = getPreStreamErrorAction(errorDetail, conversationBusyRetriesRef.current, CONVERSATION_BUSY_MAX_RETRIES2);
+          const preStreamAction = getPreStreamErrorAction(errorDetail, conversationBusyRetriesRef.current, CONVERSATION_BUSY_MAX_RETRIES2, {
+            status: preStreamError instanceof APIError2 ? preStreamError.status : undefined,
+            transientRetries: llmApiErrorRetriesRef.current,
+            maxTransientRetries: LLM_API_ERROR_MAX_RETRIES2
+          });
           if (shouldAttemptApprovalRecovery({
             approvalPendingDetected: preStreamAction === "resolve_approval_pending",
             retries: llmApiErrorRetriesRef.current,
@@ -96453,6 +97085,37 @@ ${newState.originalPrompt}`
               continue;
             }
           }
+          if (preStreamAction === "retry_transient") {
+            llmApiErrorRetriesRef.current += 1;
+            const attempt = llmApiErrorRetriesRef.current;
+            const retryAfterMs = preStreamError instanceof APIError2 ? parseRetryAfterHeaderMs(preStreamError.headers?.get("retry-after")) : null;
+            const delayMs = retryAfterMs ?? 1000 * 2 ** (attempt - 1);
+            const statusId = uid4("status");
+            buffersRef.current.byId.set(statusId, {
+              kind: "status",
+              id: statusId,
+              lines: [getRetryStatusMessage(errorDetail)]
+            });
+            buffersRef.current.order.push(statusId);
+            refreshDerived();
+            let cancelled = false;
+            const startTime = Date.now();
+            while (Date.now() - startTime < delayMs) {
+              if (abortControllerRef.current?.signal.aborted || userCancelledRef.current) {
+                cancelled = true;
+                break;
+              }
+              await new Promise((resolve23) => setTimeout(resolve23, 100));
+            }
+            buffersRef.current.byId.delete(statusId);
+            buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
+            refreshDerived();
+            if (!cancelled) {
+              buffersRef.current.interrupted = false;
+              conversationBusyRetriesRef.current = 0;
+              continue;
+            }
+          }
           conversationBusyRetriesRef.current = 0;
           const hasApprovalInPayload2 = currentInput.some((item) => item?.type === "approval");
           if (hasApprovalInPayload2) {
@@ -97317,6 +97980,7 @@ ${feedback}
       pendingInterruptRecoveryConversationIdRef.current = conversationIdRef.current;
       userCancelledRef.current = true;
       setStreaming(false);
+      resetTrajectoryBases();
       setIsExecutingTool(false);
       toolResultsInFlightRef.current = false;
       refreshDerived();
@@ -97351,6 +98015,7 @@ ${feedback}
       conversationGenerationRef.current += 1;
       processingConversationRef.current = 0;
       setStreaming(false);
+      resetTrajectoryBases();
       toolResultsInFlightRef.current = false;
       if (!toolsCancelled) {
         appendError(INTERRUPT_MESSAGE, true);
@@ -97430,7 +98095,8 @@ ${feedback}
     pendingApprovals,
     autoHandledResults,
     autoDeniedApprovals,
-    queueApprovalResults
+    queueApprovalResults,
+    resetTrajectoryBases
   ]);
   const processConversationRef = import_react94.useRef(processConversation);
   import_react94.useEffect(() => {
@@ -97867,6 +98533,14 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
       debugLog("queue", `Bumping dequeueEpoch: userCancelledRef was reset, ${messageQueue.length} message(s) queued, agent not busy`);
       setDequeueEpoch((e) => e + 1);
     }
+    const isSlashCommand = userTextForInput.startsWith("/");
+    if (isAgentBusy() && isSlashCommand) {
+      const attemptedCommand = userTextForInput.split(/\s+/)[0] || "/";
+      const disabledMessage = `'${attemptedCommand}' is disabled while the agent is running.`;
+      const cmd = commandRunner.start(userTextForInput, disabledMessage);
+      cmd.fail(disabledMessage);
+      return { submitted: true };
+    }
     const shouldBypassQueue = isInteractiveCommand(userTextForInput) || isNonStateCommand(userTextForInput);
     if (isAgentBusy() && !shouldBypassQueue) {
       setMessageQueue((prev) => {
@@ -99131,9 +99805,13 @@ ${recentCommits}
 ## Memory Filesystem Location
 
 Your memory blocks are synchronized with the filesystem at:
-\`~/.letta/agents/${agentId}/memory/\`
+\`${getMemoryFilesystemRoot(agentId)}\`
+
+Environment variables available in Letta Code:
+- \`AGENT_ID=${agentId}\`
+- \`MEMORY_DIR=${getMemoryFilesystemRoot(agentId)}\`
 
-Use this path when working with memory files during initialization.
+Use \`$MEMORY_DIR\` when working with memory files during initialization.
 ` : "";
           const initMessage = `${SYSTEM_REMINDER_OPEN}
 The user has requested memory initialization via /init.
@@ -99243,7 +99921,7 @@ ${SYSTEM_REMINDER_CLOSE}`)
     }
     let sessionContextReminder = "";
     const sessionContextEnabled = settingsManager.getSetting("sessionContextEnabled");
-    if (!hasSentSessionContextRef.current && sessionContextEnabled) {
+    if (!hasSentSessionContextRef.current && sessionContextEnabled && sessionContextReminderEnabled) {
       const { buildSessionContext: buildSessionContext2 } = await init_sessionContext().then(() => exports_sessionContext);
       sessionContextReminder = buildSessionContext2({
         agentInfo: {
@@ -99353,25 +100031,30 @@ ${SYSTEM_REMINDER_CLOSE}
     };
     pushReminder(sessionContextReminder);
     {
-      if (!discoveredSkillsRef.current) {
-        try {
-          const { discoverSkills: discover, SKILLS_DIR: defaultDir } = await Promise.resolve().then(() => (init_skills(), exports_skills));
-          const { getSkillsDirectory: getSkillsDirectory2, getNoSkills: getNoSkills2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-          const skillsDir = getSkillsDirectory2() || join30(process.cwd(), defaultDir);
-          const { skills } = await discover(skillsDir, agentId, {
-            skipBundled: getNoSkills2()
-          });
-          discoveredSkillsRef.current = skills;
-        } catch {
-          discoveredSkillsRef.current = [];
-        }
+      const {
+        discoverSkills: discover,
+        SKILLS_DIR: defaultDir,
+        formatSkillsAsSystemReminder: formatSkillsAsSystemReminder3
+      } = await Promise.resolve().then(() => (init_skills(), exports_skills));
+      const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
+      const previousSkillsReminder = discoveredSkillsRef.current ? formatSkillsAsSystemReminder3(discoveredSkillsRef.current) : null;
+      let latestSkills = discoveredSkillsRef.current ?? [];
+      try {
+        const skillsDir = getSkillsDirectory2() || join30(process.cwd(), defaultDir);
+        const { skills } = await discover(skillsDir, agentId, {
+          sources: getSkillSources2()
+        });
+        latestSkills = skills;
+      } catch {}
+      discoveredSkillsRef.current = latestSkills;
+      const latestSkillsReminder = formatSkillsAsSystemReminder3(discoveredSkillsRef.current);
+      if (previousSkillsReminder !== null && previousSkillsReminder !== latestSkillsReminder) {
+        contextTrackerRef.current.pendingSkillsReinject = true;
       }
       const needsSkillsReinject = contextTrackerRef.current.pendingSkillsReinject;
       if (!hasInjectedSkillsRef.current || needsSkillsReinject) {
-        const { formatSkillsAsSystemReminder: formatSkillsAsSystemReminder3 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
-        const skillsReminder = formatSkillsAsSystemReminder3(discoveredSkillsRef.current);
-        if (skillsReminder) {
-          pushReminder(skillsReminder);
+        if (latestSkillsReminder) {
+          pushReminder(latestSkillsReminder);
         }
         hasInjectedSkillsRef.current = true;
         contextTrackerRef.current.pendingSkillsReinject = false;
@@ -99833,6 +100516,7 @@ ${SYSTEM_REMINDER_CLOSE}
     pendingRalphConfig,
     openTrajectorySegment,
     resetTrajectoryBases,
+    sessionContextReminderEnabled,
     appendTaskNotificationEvents
   ]);
   const onSubmitRef = import_react94.useRef(onSubmit);
@@ -100349,8 +101033,8 @@ ${guidance}`);
           output: `Switching system prompt to ${prompt.label}...`,
           phase: "running"
         });
-        const { updateAgentSystemPromptRaw: updateAgentSystemPromptRaw2 } = await init_modify().then(() => exports_modify);
-        const result = await updateAgentSystemPromptRaw2(agentId, prompt.content);
+        const { updateAgentSystemPrompt: updateAgentSystemPrompt2 } = await init_modify().then(() => exports_modify);
+        const result = await updateAgentSystemPrompt2(agentId, promptId);
         if (result.success) {
           setCurrentSystemPromptId(promptId);
           cmd.finish(`Switched system prompt to ${prompt.label}`, true);
@@ -102747,8 +103431,7 @@ async function createAgent2(nameOrOptions = DEFAULT_AGENT_NAME, model, embedding
   } else {
     systemPromptContent = await resolveSystemPrompt(options.systemPromptPreset);
   }
-  systemPromptContent = `${systemPromptContent}
-${SYSTEM_PROMPT_MEMORY_ADDON}`;
+  systemPromptContent = reconcileMemoryPrompt(systemPromptContent, options.memoryPromptMode ?? "standard");
   if (options.systemPromptAppend) {
     systemPromptContent = `${systemPromptContent}
 
@@ -102818,6 +103501,7 @@ ${options.systemPromptAppend}`;
 var init_create3 = __esm(async () => {
   init_constants();
   init_memory();
+  init_memoryPrompt();
   init_model();
   init_promptAssets();
   await __promiseAll([
@@ -103117,10 +103801,16 @@ async function updateAgentSystemPromptRaw2(agentId, systemPromptContent) {
 }
 async function updateAgentSystemPrompt2(agentId, systemPromptId) {
   try {
-    const { resolveSystemPrompt: resolveSystemPrompt3, SYSTEM_PROMPT_MEMORY_ADDON: SYSTEM_PROMPT_MEMORY_ADDON3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+    const { resolveSystemPrompt: resolveSystemPrompt3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+    const { detectMemoryPromptDrift: detectMemoryPromptDrift2, reconcileMemoryPrompt: reconcileMemoryPrompt2 } = await Promise.resolve().then(() => (init_memoryPrompt(), exports_memoryPrompt));
+    const { settingsManager: settingsManager3 } = await init_settings_manager().then(() => exports_settings_manager);
+    const client = await getClient2();
+    const currentAgent = await client.agents.retrieve(agentId);
     const baseContent = await resolveSystemPrompt3(systemPromptId);
-    const systemPromptContent = `${baseContent}
-${SYSTEM_PROMPT_MEMORY_ADDON3}`;
+    const settingIndicatesMemfs = settingsManager3.isMemfsEnabled(agentId);
+    const promptIndicatesMemfs = detectMemoryPromptDrift2(currentAgent.system || "", "standard").some((drift) => drift.code === "memfs_language_with_standard_mode");
+    const memoryMode = settingIndicatesMemfs || promptIndicatesMemfs ? "memfs" : "standard";
+    const systemPromptContent = reconcileMemoryPrompt2(baseContent, memoryMode);
     const updateResult = await updateAgentSystemPromptRaw2(agentId, systemPromptContent);
     if (!updateResult.success) {
       return {
@@ -103129,7 +103819,6 @@ ${SYSTEM_PROMPT_MEMORY_ADDON3}`;
         agent: null
       };
     }
-    const client = await getClient2();
     const agent = await client.agents.retrieve(agentId);
     return {
       success: true,
@@ -103148,15 +103837,10 @@ async function updateAgentSystemPromptMemfs2(agentId, enableMemfs) {
   try {
     const client = await getClient2();
     const agent = await client.agents.retrieve(agentId);
-    let currentSystemPrompt = agent.system || "";
-    const { SYSTEM_PROMPT_MEMFS_ADDON: SYSTEM_PROMPT_MEMFS_ADDON3, SYSTEM_PROMPT_MEMORY_ADDON: SYSTEM_PROMPT_MEMORY_ADDON3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
-    const memoryHeaderRegex = /\n#{1,2} Memory\b[\s\S]*?(?=\n#{1,2} (?!Memory|Filesystem|Structure|How It Works|Syncing|History)[^\n]|$)/;
-    currentSystemPrompt = currentSystemPrompt.replace(memoryHeaderRegex, "");
-    const addon = enableMemfs ? SYSTEM_PROMPT_MEMFS_ADDON3 : SYSTEM_PROMPT_MEMORY_ADDON3;
-    currentSystemPrompt = `${currentSystemPrompt}
-${addon}`;
+    const { reconcileMemoryPrompt: reconcileMemoryPrompt2 } = await Promise.resolve().then(() => (init_memoryPrompt(), exports_memoryPrompt));
+    const nextSystemPrompt = reconcileMemoryPrompt2(agent.system || "", enableMemfs ? "memfs" : "standard");
     await client.agents.update(agentId, {
-      system: currentSystemPrompt
+      system: nextSystemPrompt
     });
     return {
       success: true,
@@ -103275,19 +103959,22 @@ async function applyMemfsFlags2(agentId, memfsFlag, noMemfsFlag, options) {
     if (!serverUrl.includes("api.letta.com")) {
       throw new Error("--memfs is only available on Letta Cloud (api.letta.com).");
     }
-    settingsManager3.setMemfsEnabled(agentId, true);
-  } else if (noMemfsFlag) {
-    settingsManager3.setMemfsEnabled(agentId, false);
   }
-  const isEnabled = settingsManager3.isMemfsEnabled(agentId);
+  const hasExplicitToggle = Boolean(memfsFlag || noMemfsFlag);
+  const targetEnabled = memfsFlag ? true : noMemfsFlag ? false : settingsManager3.isMemfsEnabled(agentId);
+  if (hasExplicitToggle) {
+    const { updateAgentSystemPromptMemfs: updateAgentSystemPromptMemfs3 } = await init_modify().then(() => exports_modify);
+    const promptUpdate = await updateAgentSystemPromptMemfs3(agentId, targetEnabled);
+    if (!promptUpdate.success) {
+      throw new Error(promptUpdate.message);
+    }
+    settingsManager3.setMemfsEnabled(agentId, targetEnabled);
+  }
+  const isEnabled = hasExplicitToggle ? targetEnabled : settingsManager3.isMemfsEnabled(agentId);
   if (isEnabled && memfsFlag) {
     const { detachMemoryTools: detachMemoryTools2 } = await init_toolset().then(() => exports_toolset);
     await detachMemoryTools2(agentId);
   }
-  if (memfsFlag || noMemfsFlag) {
-    const { updateAgentSystemPromptMemfs: updateAgentSystemPromptMemfs3 } = await init_modify().then(() => exports_modify);
-    await updateAgentSystemPromptMemfs3(agentId, isEnabled);
-  }
   let pullSummary;
   if (isEnabled) {
     const { addGitMemoryTag: addGitMemoryTag2, isGitRepo: isGitRepo2, cloneMemoryRepo: cloneMemoryRepo2, pullMemory: pullMemory2 } = await init_memoryGit().then(() => exports_memoryGit);
@@ -103624,6 +104311,7 @@ async function getClient() {
 }
 
 // src/agent/context.ts
+init_skillSources();
 var CONTEXT_KEY = Symbol.for("@letta/agentContext");
 function getContext() {
   const global2 = globalThis;
@@ -103631,17 +104319,17 @@ function getContext() {
     global2[CONTEXT_KEY] = {
       agentId: null,
       skillsDirectory: null,
-      noSkills: false,
+      skillSources: [...ALL_SKILL_SOURCES],
       conversationId: null
     };
   }
   return global2[CONTEXT_KEY];
 }
 var context = getContext();
-function setAgentContext(agentId, skillsDirectory, noSkills) {
+function setAgentContext(agentId, skillsDirectory, skillSources) {
   context.agentId = agentId;
   context.skillsDirectory = skillsDirectory || null;
-  context.noSkills = noSkills ?? false;
+  context.skillSources = skillSources !== undefined ? [...skillSources] : [...ALL_SKILL_SOURCES];
 }
 function setConversationId(conversationId) {
   context.conversationId = conversationId;
@@ -103669,6 +104357,54 @@ var MEMORY_BLOCK_LABELS2 = [
 ];
 var ISOLATED_BLOCK_LABELS2 = [];
 
+// src/agent/skillSources.ts
+var ALL_SKILL_SOURCES2 = [
+  "bundled",
+  "global",
+  "agent",
+  "project"
+];
+var VALID_SKILL_SOURCE_SPECIFIERS2 = [
+  "all",
+  ...ALL_SKILL_SOURCES2
+];
+function isSkillSource2(value) {
+  return ALL_SKILL_SOURCES2.includes(value);
+}
+function normalizeSkillSources2(sources) {
+  const sourceSet = new Set(sources);
+  return ALL_SKILL_SOURCES2.filter((source) => sourceSet.has(source));
+}
+function parseSkillSourcesList2(skillSourcesRaw) {
+  const tokens = skillSourcesRaw.split(",").map((source) => source.trim()).filter((source) => source.length > 0);
+  if (tokens.length === 0) {
+    throw new Error("--skill-sources must include at least one source (e.g. bundled,project)");
+  }
+  const sources = [];
+  for (const token of tokens) {
+    const source = token;
+    if (!VALID_SKILL_SOURCE_SPECIFIERS2.includes(source)) {
+      throw new Error(`Invalid skill source "${token}". Valid values: ${VALID_SKILL_SOURCE_SPECIFIERS2.join(", ")}`);
+    }
+    if (source === "all") {
+      sources.push(...ALL_SKILL_SOURCES2);
+      continue;
+    }
+    if (isSkillSource2(source)) {
+      sources.push(source);
+    }
+  }
+  return normalizeSkillSources2(sources);
+}
+function resolveSkillSourcesSelection2(input) {
+  if (input.noSkills) {
+    return [];
+  }
+  const configuredSources = input.skillSourcesRaw ? parseSkillSourcesList2(input.skillSourcesRaw) : [...ALL_SKILL_SOURCES2];
+  const filteredSources = input.noBundledSkills ? configuredSources.filter((source) => source !== "bundled") : configuredSources;
+  return normalizeSkillSources2(filteredSources);
+}
+
 // src/index.ts
 init_oauth2();
 
@@ -106382,6 +107118,18 @@ if (!globalThis.__lettaSettingsManager) {
 }
 var settingsManager2 = globalThis.__lettaSettingsManager;
 
+// src/startup-auto-update.ts
+function startStartupAutoUpdateCheck(checkAndAutoUpdate, logError = console.error) {
+  checkAndAutoUpdate().then((result) => {
+    if (result?.enotemptyFailed) {
+      logError(`
+Auto-update failed due to filesystem issue (ENOTEMPTY).`);
+      logError(`Fix: rm -rf $(npm prefix -g)/lib/node_modules/@letta-ai/letta-code && npm i -g @letta-ai/letta-code
+`);
+    }
+  }).catch(() => {});
+}
+
 // src/telemetry/index.ts
 init_http_headers();
 await init_settings_manager();
@@ -106893,10 +107641,21 @@ OPTIONS
                         Emit stream_event wrappers for each chunk (stream-json only)
   --from-agent <id>     Inject agent-to-agent system reminder (headless mode)
   --skills <path>       Custom path to skills directory (default: .skills in current directory)
+  --skill-sources <csv> Skill sources: all,bundled,global,agent,project (default: all)
+  --no-skills           Disable all skill sources
+  --no-bundled-skills   Disable bundled skills only
   --import <path>       Create agent from an AgentFile (.af) template
                         Use @author/name to import from the agent registry
   --memfs               Enable memory filesystem for this agent
   --no-memfs            Disable memory filesystem for this agent
+  --no-system-info-reminder
+                        Disable first-turn environment reminder (device/git/cwd context)
+  --reflection-trigger <mode>
+                        Sleeptime trigger: off, step-count, compaction-event
+  --reflection-behavior <mode>
+                        Sleeptime behavior: reminder, auto-launch
+  --reflection-step-count <n>
+                        Sleeptime step-count interval (positive integer)
 
 SUBCOMMANDS (JSON-only)
   letta memfs status --agent <id>
@@ -107095,14 +107854,7 @@ async function main() {
   }
   telemetry.init();
   const { checkAndAutoUpdate: checkAndAutoUpdate2 } = await Promise.resolve().then(() => (init_auto_update(), exports_auto_update));
-  checkAndAutoUpdate2().then((result) => {
-    if (result?.enotemptyFailed) {
-      console.error(`
-Auto-update failed due to filesystem issue (ENOTEMPTY).`);
-      console.error(`Fix: rm -rf $(npm prefix -g)/lib/node_modules/@letta-ai/letta-code && npm i -g @letta-ai/letta-code
-`);
-    }
-  }).catch(() => {});
+  startStartupAutoUpdateCheck(checkAndAutoUpdate2);
   const { cleanupOldOverflowFiles: cleanupOldOverflowFiles2 } = await Promise.resolve().then(() => (init_overflow2(), exports_overflow));
   Promise.resolve().then(() => {
     try {
@@ -107149,6 +107901,7 @@ Auto-update failed due to filesystem issue (ENOTEMPTY).`);
         "include-partial-messages": { type: "boolean" },
         "from-agent": { type: "string" },
         skills: { type: "string" },
+        "skill-sources": { type: "string" },
         "pre-load-skills": { type: "string" },
         "from-af": { type: "string" },
         import: { type: "string" },
@@ -107156,6 +107909,11 @@ Auto-update failed due to filesystem issue (ENOTEMPTY).`);
         memfs: { type: "boolean" },
         "no-memfs": { type: "boolean" },
         "no-skills": { type: "boolean" },
+        "no-bundled-skills": { type: "boolean" },
+        "no-system-info-reminder": { type: "boolean" },
+        "reflection-trigger": { type: "string" },
+        "reflection-behavior": { type: "string" },
+        "reflection-step-count": { type: "string" },
         "max-turns": { type: "string" }
       },
       strict: true,
@@ -107178,6 +107936,10 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
   const command = positionals[2];
   if (values.help) {
     printHelp();
+    const helpDelayMs = Number.parseInt(process.env.LETTA_TEST_HELP_EXIT_DELAY_MS ?? "", 10);
+    if (Number.isFinite(helpDelayMs) && helpDelayMs > 0) {
+      await new Promise((resolve24) => setTimeout(resolve24, helpDelayMs));
+    }
     process.exit(0);
   }
   if (values.version) {
@@ -107234,7 +107996,24 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
   const skillsDirectory = values.skills ?? undefined;
   const memfsFlag = values.memfs;
   const noMemfsFlag = values["no-memfs"];
+  const requestedMemoryPromptMode = memfsFlag ? "memfs" : noMemfsFlag ? "standard" : undefined;
+  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !noMemfsFlag;
   const noSkillsFlag = values["no-skills"];
+  const noBundledSkillsFlag = values["no-bundled-skills"];
+  const skillSourcesRaw = values["skill-sources"];
+  const noSystemInfoReminderFlag = values["no-system-info-reminder"];
+  const resolvedSkillSources = (() => {
+    try {
+      return resolveSkillSourcesSelection2({
+        skillSourcesRaw,
+        noSkills: noSkillsFlag,
+        noBundledSkills: noBundledSkillsFlag
+      });
+    } catch (error) {
+      console.error(error instanceof Error ? `Error: ${error.message}` : String(error));
+      process.exit(1);
+    }
+  })();
   const fromAfFile = values.import ?? values["from-af"];
   const isHeadless = values.prompt || values.run || !process.stdin.isTTY;
   if (command && !isHeadless) {
@@ -107500,7 +108279,7 @@ Error: ${message}`);
     await loadTools2(modelForTools);
     markMilestone2("TOOLS_LOADED");
     const { handleHeadlessCommand: handleHeadlessCommand2 } = await init_headless().then(() => exports_headless);
-    await handleHeadlessCommand2(process.argv, specifiedModel, skillsDirectory, noSkillsFlag);
+    await handleHeadlessCommand2(process.argv, specifiedModel, skillsDirectory, resolvedSkillSources, !noSystemInfoReminderFlag);
     return;
   }
   markMilestone2("TUI_MODE_START");
@@ -107927,13 +108706,16 @@ Error: ${message}`);
             skillsDirectory: skillsDirectory2,
             parallelToolCalls: true,
             systemPromptPreset: systemPromptPreset2,
+            memoryPromptMode: requestedMemoryPromptMode,
             initBlocks: initBlocks2,
             baseTools: baseTools2
           });
           agent = result.agent;
           setAgentProvenance(result.provenance);
-          const { enableMemfsIfCloud: enableMemfsIfCloud3 } = await Promise.resolve().then(() => (init_memoryFilesystem2(), exports_memoryFilesystem2));
-          await enableMemfsIfCloud3(agent.id);
+          if (shouldAutoEnableMemfsForNewAgent) {
+            const { enableMemfsIfCloud: enableMemfsIfCloud3 } = await Promise.resolve().then(() => (init_memoryFilesystem2(), exports_memoryFilesystem2));
+            await enableMemfsIfCloud3(agent.id);
+          }
         }
         if (!agent && resumingAgentId) {
           try {
@@ -107977,7 +108759,7 @@ Error: ${message}`);
             }
           } catch {}
         }
-        setAgentContext(agent.id, skillsDirectory2, noSkillsFlag);
+        setAgentContext(agent.id, skillsDirectory2, resolvedSkillSources);
         const isSubagent = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
         try {
           const { applyMemfsFlags: applyMemfsFlags3 } = await Promise.resolve().then(() => (init_memoryFilesystem2(), exports_memoryFilesystem2));
@@ -108199,7 +108981,8 @@ Error during initialization: ${message}`);
         tokenStreaming: settings.tokenStreaming,
         showCompactions: settings.showCompactions,
         agentProvenance,
-        releaseNotes: releaseNotes2
+        releaseNotes: releaseNotes2,
+        sessionContextReminderEnabled: !noSystemInfoReminderFlag
       });
     }
     return React14.createElement(App3, {
@@ -108215,7 +108998,8 @@ Error during initialization: ${message}`);
       tokenStreaming: settings.tokenStreaming,
       showCompactions: settings.showCompactions,
       agentProvenance,
-      releaseNotes: releaseNotes2
+      releaseNotes: releaseNotes2,
+      sessionContextReminderEnabled: !noSystemInfoReminderFlag
     });
   }
   markMilestone2("REACT_RENDER_START");
@@ -108237,4 +109021,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=2DEF3E9D56D2EFE964756E2164756E21
+//# debugId=097C38A722A3206664756E2164756E21