@letta-ai/letta-code 0.25.3 → 0.25.5

package/letta.js

@@ -3143,7 +3143,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.25.3",
+    version: "0.25.5",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -5756,13 +5756,16 @@ function isTruthyEnv(value) {
 function isLocalBackendEnvEnabled(env = process.env) {
   return isTruthyEnv(env[LOCAL_BACKEND_EXPERIMENTAL_ENV]);
 }
+function isLocalBackendNoMemfsEnvEnabled(env = process.env) {
+  return isTruthyEnv(env[LOCAL_BACKEND_NO_MEMFS_ENV]);
+}
 function getLocalBackendStorageDir(homeDir = homedir3()) {
   return process.env[LOCAL_BACKEND_DIR_ENV] ?? join3(homeDir, ".letta", "lc-local-backend");
 }
 function getLocalBackendMemoryFilesystemRoot(agentId, storageDir = getLocalBackendStorageDir()) {
   return join3(storageDir, "memfs", agentId, "memory");
 }
-var LOCAL_BACKEND_DIR_ENV = "LETTA_LOCAL_BACKEND_DIR", LOCAL_BACKEND_EXPERIMENTAL_ENV = "LETTA_LOCAL_BACKEND_EXPERIMENTAL";
+var LOCAL_BACKEND_DIR_ENV = "LETTA_LOCAL_BACKEND_DIR", LOCAL_BACKEND_EXPERIMENTAL_ENV = "LETTA_LOCAL_BACKEND_EXPERIMENTAL", LOCAL_BACKEND_NO_MEMFS_ENV = "LETTA_LOCAL_BACKEND_NO_MEMFS";
 var init_paths = () => {};
 
 // src/agent/memoryGit.ts
@@ -5918,6 +5921,11 @@ function getMemoryRemoteUrl(agentId) {
   return getGitRemoteUrl(agentId);
 }
 async function getAuthToken() {
+  const { getBackend } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+  const backend = getBackend();
+  if (backend.capabilities.localMemfs && !backend.capabilities.remoteMemfs) {
+    return "";
+  }
   const client = await getClient();
   return client._options?.apiKey ?? "";
 }
@@ -5969,7 +5977,7 @@ async function runGit(cwd, args, token) {
   const result = await execFile("git", allArgs, {
     cwd,
     env: buildNonInteractiveGitEnv(),
-    maxBuffer: 10 * 1024 * 1024,
+    maxBuffer: 10485760,
     timeout: 60000
   });
   return {
@@ -6101,9 +6109,9 @@ async function unsetLocalGitConfig(dir, key) {
 async function fetchAgentDisplayName(agentId) {
   let timeout;
   try {
-    const client = await getClient();
+    const { getBackend } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
     const agent = await Promise.race([
-      client.agents.retrieve(agentId),
+      getBackend().retrieveAgent(agentId),
       new Promise((resolve2) => {
         timeout = setTimeout(() => resolve2(null), AGENT_DISPLAY_NAME_TIMEOUT_MS);
       })
@@ -6714,12 +6722,13 @@ async function getMemoryGitStatus(agentId) {
   };
 }
 async function addGitMemoryTag(agentId, prefetchedAgent) {
-  const client = await getClient();
   try {
-    const agent = prefetchedAgent ?? await client.agents.retrieve(agentId);
+    const { getBackend } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+    const backend = getBackend();
+    const agent = prefetchedAgent ?? await backend.retrieveAgent(agentId);
     const tags = agent.tags || [];
     if (!tags.includes(GIT_MEMORY_ENABLED_TAG)) {
-      await client.agents.update(agentId, {
+      await backend.updateAgent(agentId, {
         tags: [...tags, GIT_MEMORY_ENABLED_TAG]
       });
       debugLog("memfs-git", `Added ${GIT_MEMORY_ENABLED_TAG} tag`);
@@ -6729,12 +6738,13 @@ async function addGitMemoryTag(agentId, prefetchedAgent) {
   }
 }
 async function removeGitMemoryTag(agentId) {
-  const client = await getClient();
   try {
-    const agent = await client.agents.retrieve(agentId);
+    const { getBackend } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+    const backend = getBackend();
+    const agent = await backend.retrieveAgent(agentId);
     const tags = agent.tags || [];
     if (tags.includes(GIT_MEMORY_ENABLED_TAG)) {
-      await client.agents.update(agentId, {
+      await backend.updateAgent(agentId, {
         tags: tags.filter((t) => t !== GIT_MEMORY_ENABLED_TAG)
       });
       debugLog("memfs-git", `Removed ${GIT_MEMORY_ENABLED_TAG} tag`);
@@ -64368,6 +64378,8 @@ function createChatGPTFetch(options) {
     const auth = await getFreshAuth(options.storageDir);
     next.headers.delete("authorization");
     next.headers.set("authorization", `Bearer ${auth.access}`);
+    next.headers.set("OpenAI-Beta", "responses=v1");
+    next.headers.set("OpenAI-Originator", "codex");
     if (auth.accountId) {
       next.headers.set("ChatGPT-Account-Id", auth.accountId);
     }
@@ -69891,6 +69903,9 @@ function anthropicThinking(value, modelHandle) {
 function aiSDKProviderKind(modelHandle, modelSettings) {
   return aiSDKProviderKindFromModel(modelHandle, modelSettings);
 }
+function isChatGPTOAuthModel(modelHandle, modelSettings) {
+  return modelHandle.startsWith("chatgpt-plus-pro/") || stringValue(modelSettings.provider_type) === "chatgpt_oauth";
+}
 function partProviderMetadata(part) {
   if (!isRecord2(part))
     return;
@@ -69916,22 +69931,153 @@ function shouldKeepReasoningPart(part, provider) {
     return hasAnthropicReasoningMetadata(part);
   return true;
 }
-function sanitizeUIMessagesForProvider(messages, provider) {
+function stringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : undefined;
+}
+function mimeToModality(mime) {
+  if (mime.startsWith("image/"))
+    return "image";
+  if (mime.startsWith("audio/"))
+    return "audio";
+  if (mime.startsWith("video/"))
+    return "video";
+  if (mime === "application/pdf")
+    return "pdf";
+  return;
+}
+function modalitiesFromModelSettings(modelSettings) {
+  const modalities = isRecord2(modelSettings.modalities) ? modelSettings.modalities : undefined;
+  const input = stringArray(modalities?.input);
+  if (!input)
+    return;
+  return new Set(input.filter((entry) => ["text", "image", "audio", "video", "pdf"].includes(entry)));
+}
+function capabilitiesFromModelSettings(modelSettings) {
+  const capabilities = isRecord2(modelSettings.capabilities) ? modelSettings.capabilities : undefined;
+  const input = isRecord2(capabilities?.input) ? capabilities.input : undefined;
+  if (!input)
+    return;
+  const supported = new Set(["text"]);
+  for (const modality of ["image", "audio", "video", "pdf"]) {
+    if (input[modality] === true)
+      supported.add(modality);
+  }
+  return supported;
+}
+function knownModelInputModalities(modelHandle, modelSettings) {
+  const explicitModalities = modalitiesFromModelSettings(modelSettings);
+  if (explicitModalities)
+    return explicitModalities;
+  const explicitCapabilities = capabilitiesFromModelSettings(modelSettings);
+  if (explicitCapabilities)
+    return explicitCapabilities;
+  const handle = modelHandle.toLowerCase();
+  const supported = new Set(["text"]);
+  if (handle.startsWith("anthropic/") || handle.startsWith("claude-pro-max/") || handle.startsWith("bedrock/") || handle.startsWith("google_ai/") || handle.startsWith("google_vertex/") || handle.includes("gemini") || handle.includes("claude") || handle.includes("gpt-4o") || handle.includes("gpt-4.1") || handle.includes("gpt-5") || handle.includes("o3") || handle.includes("o4") || handle.includes("vision") || handle.includes("qwen-vl") || handle.includes("qwen2-vl") || handle.includes("qwen2.5-vl") || handle.includes("qwen3-vl") || handle.includes("llava") || handle.includes("bakllava") || handle.includes("moondream")) {
+    supported.add("image");
+  }
+  return supported;
+}
+function modelSupportsInputModality(modelHandle, modelSettings, modality) {
+  if (modality === "text")
+    return true;
+  return knownModelInputModalities(modelHandle, modelSettings).has(modality);
+}
+function isEmptyBase64DataUrl(data) {
+  if (typeof data !== "string" || !data.startsWith("data:"))
+    return false;
+  const match = data.match(/^data:([^;]+);base64,(.*)$/);
+  return Boolean(match && (!match[2] || match[2].length === 0));
+}
+function filePartMediaType(part) {
+  if (typeof part.mediaType === "string")
+    return part.mediaType;
+  if (typeof part.mime === "string")
+    return part.mime;
+  return;
+}
+function imagePartMediaType(part) {
+  if (typeof part.image === "string" && part.image.startsWith("data:")) {
+    return part.image.split(";")[0]?.replace("data:", "");
+  }
+  if (isRecord2(part.source) && typeof part.source.media_type === "string") {
+    return part.source.media_type;
+  }
+  return;
+}
+function partFilename(part) {
+  return stringValue(part.filename) ?? stringValue(part.name);
+}
+function replaceUnsupportedInputPart(part, agent) {
+  if (!isRecord2(part))
+    return part;
+  const record2 = part;
+  const partType = typeof record2.type === "string" ? record2.type : undefined;
+  if (partType !== "file" && partType !== "image") {
+    return part;
+  }
+  if (partType === "image" && isEmptyBase64DataUrl(record2.image)) {
+    return {
+      type: "text",
+      text: "ERROR: Image file is empty or corrupted. Please provide a valid image."
+    };
+  }
+  const mime = partType === "image" ? imagePartMediaType(record2) : filePartMediaType(record2);
+  if (!mime)
+    return part;
+  const modality = mimeToModality(mime);
+  if (!modality)
+    return part;
+  if (modelSupportsInputModality(agent.model, agent.model_settings, modality)) {
+    return part;
+  }
+  const name25 = partFilename(record2);
+  return {
+    type: "text",
+    text: `ERROR: Cannot read ${name25 ? `"${name25}"` : modality} (this model does not support ${modality} input). Inform the user.`
+  };
+}
+function replaceUnsupportedInputParts(messages, agent) {
+  let didChange = false;
+  const transformed = messages.map((message) => {
+    if (message.role !== "user")
+      return message;
+    let messageDidChange = false;
+    const parts = message.parts.map((part) => {
+      const replacement = replaceUnsupportedInputPart(part, agent);
+      if (replacement !== part) {
+        didChange = true;
+        messageDidChange = true;
+      }
+      return replacement;
+    });
+    return messageDidChange ? { ...message, parts } : message;
+  });
+  return didChange ? transformed : messages;
+}
+function sanitizeUIMessagesForProvider(messages, provider, agent) {
+  const capabilitySanitizedMessages = replaceUnsupportedInputParts(messages, agent);
   if (provider === "unknown")
-    return messages;
-  return messages.map((message) => {
+    return capabilitySanitizedMessages;
+  return capabilitySanitizedMessages.map((message) => {
     const parts = message.parts.filter((part) => shouldKeepReasoningPart(part, provider));
     return parts.length === message.parts.length ? message : { ...message, parts };
   }).filter((message) => message.role !== "assistant" || message.parts.length > 0);
 }
-function buildAISDKProviderOptions(modelHandle, modelSettings) {
+function buildAISDKProviderOptions(modelHandle, modelSettings, options = {}) {
   const provider = aiSDKProviderKind(modelHandle, modelSettings);
   if (provider === "openai") {
+    const chatgptOAuth = isChatGPTOAuthModel(modelHandle, modelSettings);
     const reasoning = isRecord2(modelSettings.reasoning) ? modelSettings.reasoning : undefined;
     const reasoningEffort = openAIReasoningEffort(reasoning?.reasoning_effort ?? modelSettings.reasoning_effort);
     const textVerbosity = openAITextVerbosity(modelSettings.verbosity);
     const parallelToolCalls = boolValue(modelSettings.parallel_tool_calls);
     const openai2 = {
+      ...chatgptOAuth ? {
+        instructions: options.systemPrompt,
+        store: false,
+        systemMessageMode: "remove"
+      } : {},
       ...reasoningEffort !== undefined ? { reasoningEffort } : {},
       ...textVerbosity !== undefined ? { textVerbosity } : {},
       ...parallelToolCalls !== undefined ? { parallelToolCalls } : {}
@@ -70011,15 +70157,15 @@ class AISDKStreamAdapter {
     const tools = toToolSet(input.clientTools);
     const provider = aiSDKProviderKind(input.agent.model, input.agent.model_settings);
     const uiMessages = await validateUIMessages({
-      messages: sanitizeUIMessagesForProvider(input.uiMessages, provider),
+      messages: sanitizeUIMessagesForProvider(input.uiMessages, provider, input.agent),
       tools
     });
     const result = this.runStreamText({
       model: this.createModel?.() ?? createAISDKModelFactoryFromAgent(input.agent.model, input.agent.model_settings, { localProviderAuthStorageDir: this.localProviderAuthStorageDir })(),
-      system: input.systemPrompt ?? input.agent.system,
+      system: provider === "openai" && isChatGPTOAuthModel(input.agent.model, input.agent.model_settings) ? undefined : input.systemPrompt ?? input.agent.system,
       messages: await convertToModelMessages(uiMessages, { tools }),
       tools,
-      providerOptions: buildAISDKProviderOptions(input.agent.model, input.agent.model_settings),
+      providerOptions: buildAISDKProviderOptions(input.agent.model, input.agent.model_settings, { systemPrompt: input.systemPrompt ?? input.agent.system }),
       maxRetries: 0,
       abortSignal: this.abortSignal
     });
@@ -70421,6 +70567,7 @@ function normalizeAgentRecord(value, defaultAgentModel) {
   if (modelSettings.max_tokens === undefined && (typeof legacyLlmConfig.max_tokens === "number" || legacyLlmConfig.max_tokens === null)) {
     modelSettings.max_tokens = legacyLlmConfig.max_tokens;
   }
+  const compactionSettings = optionalRecordOrNull(value.compaction_settings);
   return {
     id: value.id,
     name: optionalString(value.name) ?? "Letta Code",
@@ -70428,7 +70575,8 @@ function normalizeAgentRecord(value, defaultAgentModel) {
     system: optionalString(value.system) ?? "",
     tags: isStringArray(value.tags) ? value.tags : [],
     model: optionalString(value.model) ?? optionalString(legacyLlmConfig.model) ?? defaultAgentModel,
-    model_settings: modelSettings
+    model_settings: modelSettings,
+    ...compactionSettings !== undefined ? { compaction_settings: compactionSettings } : {}
   };
 }
 function projectAgentState(record2, messageIds = [], inContextMessageIds = messageIds, lastRunCompletion) {
@@ -70444,6 +70592,7 @@ function projectAgentState(record2, messageIds = [], inContextMessageIds = messa
     tags: record2.tags,
     model: record2.model,
     model_settings: record2.model_settings,
+    ...record2.compaction_settings !== undefined ? { compaction_settings: record2.compaction_settings } : {},
     message_ids: messageIds,
     in_context_message_ids: inContextMessageIds,
     ...lastRunCompletion ? { last_run_completion: lastRunCompletion } : {},
@@ -70472,6 +70621,39 @@ function normalizeContent(content) {
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function localFilePartFromLegacyImage(part) {
+  if (part.type !== "image" || !isRecord3(part.source)) {
+    return null;
+  }
+  const source = part.source;
+  if (source.type !== "base64") {
+    return null;
+  }
+  const mediaType = source.media_type;
+  const data = source.data;
+  if (typeof mediaType !== "string" || typeof data !== "string") {
+    return null;
+  }
+  return {
+    type: "file",
+    mediaType,
+    url: `data:${mediaType};base64,${data}`
+  };
+}
+function normalizeLocalMessageForAISDK(message) {
+  let didChange = false;
+  const parts = message.parts.map((part) => {
+    if (isRecord3(part)) {
+      const filePart = localFilePartFromLegacyImage(part);
+      if (filePart) {
+        didChange = true;
+        return filePart;
+      }
+    }
+    return part;
+  });
+  return didChange ? { ...message, parts } : message;
+}
 function textFromContent(content) {
   if (typeof content === "string")
     return content;
@@ -70703,6 +70885,19 @@ class LocalStore {
     }
     return this.projectAgent(updated);
   }
+  setAgentCompactionSettings(agentId, settings) {
+    const existing = this.agents.get(agentId);
+    if (!existing) {
+      throw new LocalBackendNotFoundError("Agent", agentId);
+    }
+    const updated = {
+      ...existing,
+      compaction_settings: settings === null ? null : { ...settings }
+    };
+    this.agents.set(agentId, updated);
+    this.persistAgent(agentId);
+    return this.projectAgent(updated);
+  }
   createAgent(body) {
     const agent = this.createAgentRecord(body);
     const agentId = agent.id;
@@ -70940,8 +71135,12 @@ class LocalStore {
       },
       parts: [{ type: "text", text: input.packedSummary }]
     };
-    this.localMessagesByConversationKey.set(key, [summaryMessage]);
-    conversation.in_context_message_ids = [summaryMessage.id];
+    const compactedMessages = [
+      summaryMessage,
+      ...(input.remainingMessages ?? []).map(cloneLocalMessage)
+    ];
+    this.localMessagesByConversationKey.set(key, compactedMessages);
+    conversation.in_context_message_ids = compactedMessages.map((message) => message.id);
     conversation.last_message_at = date5;
     conversation.updated_at = date5;
     this.conversations.set(key, conversation);
@@ -70949,7 +71148,7 @@ class LocalStore {
     this.rebuildMessageIndex();
     return {
       numMessagesBefore: previousMessages.length,
-      numMessagesAfter: 1,
+      numMessagesAfter: compactedMessages.length,
       summaryMessage: cloneLocalMessage(summaryMessage)
     };
   }
@@ -71305,6 +71504,11 @@ class LocalStore {
         parts.push({ type: "text", text: part.text });
         continue;
       }
+      const filePart = localFilePartFromLegacyImage(part);
+      if (filePart) {
+        parts.push(filePart);
+        continue;
+      }
       parts.push(part);
     }
     return parts.length > 0 ? parts : textContent(textFromContent(content));
@@ -71341,7 +71545,7 @@ class LocalStore {
         if (!conversation?.id || !conversation.agent_id)
           continue;
         const key = this.conversationKey(conversation.id, conversation.agent_id);
-        const localMessages = readJsonlFile(join7(conversationDir, "messages.jsonl"));
+        const localMessages = readJsonlFile(join7(conversationDir, "messages.jsonl")).map(normalizeLocalMessageForAISDK);
         const compiledSystemPrompt = readJsonFile(join7(conversationDir, "system-prompt.json"));
         const messages = projectLocalMessagesToStoredMessages(localMessages, conversation.agent_id, conversation.id);
         this.conversations.set(key, conversation);
@@ -71892,6 +72096,9 @@ var init_HeadlessBackend = __esm(() => {
 });
 
 // src/backend/local/compaction.ts
+function isLocalSlidingWindowCompactionPlanningError(error51) {
+  return error51 instanceof LocalSlidingWindowCompactionPlanningError;
+}
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -71950,24 +72157,24 @@ ${body}
   }
   return transcript;
 }
-async function runGenerateText(input, transcript) {
+async function runGenerateText(input, transcript, defaultPrompt) {
   const run = input.generateText ?? generateText;
   return run({
     model: input.createModel?.() ?? createAISDKModelFactoryFromAgent(input.agent.model, input.agent.model_settings, { localProviderAuthStorageDir: input.localProviderAuthStorageDir })(),
-    system: input.prompt ?? LOCAL_ALL_COMPACTION_PROMPT,
+    system: input.prompt ?? defaultPrompt,
     prompt: transcript,
     providerOptions: buildAISDKProviderOptions(input.agent.model, input.agent.model_settings),
     maxRetries: 0,
     abortSignal: input.abortSignal
   });
 }
-async function summarizeLocalMessagesAll(input) {
+async function summarizeLocalMessagesWithPrompt(input, defaultPrompt) {
   if (input.messages.length === 0)
     return "No prior conversation messages.";
   const primaryTranscript = formatLocalMessagesForSummary(input.messages);
   let result;
   try {
-    result = await runGenerateText(input, primaryTranscript);
+    result = await runGenerateText(input, primaryTranscript, defaultPrompt);
   } catch (error51) {
     if (!isContextWindowOverflowError(error51))
       throw error51;
@@ -71975,7 +72182,7 @@ async function summarizeLocalMessagesAll(input) {
       truncationChars: TOOL_TRANSCRIPT_TRUNCATION_CHARS,
       maxChars: TRANSCRIPT_FALLBACK_MAX_CHARS
     });
-    result = await runGenerateText(input, fallbackTranscript);
+    result = await runGenerateText(input, fallbackTranscript, defaultPrompt);
   }
   let summary = result.text.trim();
   const clipChars = input.clipChars === undefined ? 50000 : input.clipChars;
@@ -71984,6 +72191,62 @@ async function summarizeLocalMessagesAll(input) {
   }
   return summary;
 }
+async function summarizeLocalMessagesAll(input) {
+  return summarizeLocalMessagesWithPrompt(input, LOCAL_ALL_COMPACTION_PROMPT);
+}
+function isSettledLocalToolState2(state) {
+  return state === "output-available" || state === "output-error" || state === "output-denied";
+}
+function hasPendingLocalToolPart(message) {
+  return message.parts.some((part) => {
+    if (!isRecord4(part))
+      return false;
+    const partRecord = part;
+    return typeof partRecord.type === "string" && partRecord.type.startsWith("tool-") && !isSettledLocalToolState2(partRecord.state);
+  });
+}
+function normalizedSlidingWindowPercentage(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return LOCAL_DEFAULT_SLIDING_WINDOW_PERCENTAGE;
+  }
+  if (value <= 0)
+    return 0.1;
+  if (value > 1)
+    return 1;
+  return value;
+}
+function isValidSlidingWindowCutoff(messages, index, maximumCutoffIndex) {
+  const message = messages[index];
+  return message?.role === "assistant" && index > 1 && index < maximumCutoffIndex;
+}
+function planLocalSlidingWindowCompaction(messages, options = {}) {
+  if (messages.length < 4) {
+    throw new LocalSlidingWindowCompactionPlanningError("Not enough messages for sliding window compaction.");
+  }
+  const percentage = normalizedSlidingWindowPercentage(options.slidingWindowPercentage);
+  const lastMessage = messages.at(-1);
+  const maximumCutoffIndex = lastMessage && hasPendingLocalToolPart(lastMessage) ? messages.length - 2 : messages.length - 1;
+  const goalTokens = typeof options.contextWindow === "number" && Number.isFinite(options.contextWindow) ? (1 - percentage) * options.contextWindow : undefined;
+  for (let evictionPercentage = percentage;evictionPercentage < 1; evictionPercentage += 0.1) {
+    const messageCutoffIndex = Math.min(Math.round(evictionPercentage * messages.length), messages.length - 1);
+    const cutoffIndex = [...Array(messageCutoffIndex + 1).keys()].reverse().find((index) => isValidSlidingWindowCutoff(messages, index, maximumCutoffIndex));
+    if (cutoffIndex === undefined)
+      continue;
+    const messagesToKeep = messages.slice(cutoffIndex);
+    if (goalTokens !== undefined && estimateLocalMessageTokens(messagesToKeep) >= goalTokens) {
+      continue;
+    }
+    return {
+      messagesToSummarize: messages.slice(0, cutoffIndex),
+      messagesToKeep,
+      cutoffIndex
+    };
+  }
+  throw new LocalSlidingWindowCompactionPlanningError("No assistant message found for sliding window compaction.");
+}
+async function summarizeLocalMessagesSlidingWindow(input) {
+  return summarizeLocalMessagesWithPrompt(input, LOCAL_SLIDING_WINDOW_COMPACTION_PROMPT);
+}
 function estimateLocalMessageTokens(messages) {
   const chars = messages.reduce((total, message) => total + JSON.stringify(message).length, 0);
   return Math.ceil(chars / 4);
@@ -71998,12 +72261,18 @@ The following is an in-context recursive summary of the prior messages: ${summar
     ...stats ? { compaction_stats: stats } : {}
   });
 }
-var ALL_WORD_LIMIT = 500, SUMMARY_TRUNCATION_SUFFIX = "... [summary truncated to fit]", TOOL_TRANSCRIPT_TRUNCATION_CHARS = 4000, TRANSCRIPT_FALLBACK_MAX_CHARS = 120000, LOCAL_ALL_COMPACTION_PROMPT;
+var ALL_WORD_LIMIT = 500, SLIDING_WORD_LIMIT = 300, SUMMARY_TRUNCATION_SUFFIX = "... [summary truncated to fit]", TOOL_TRANSCRIPT_TRUNCATION_CHARS = 4000, TRANSCRIPT_FALLBACK_MAX_CHARS = 120000, LOCAL_DEFAULT_COMPACTION_MODE = "sliding_window", LOCAL_DEFAULT_SLIDING_WINDOW_PERCENTAGE = 0.3, LocalSlidingWindowCompactionPlanningError, LOCAL_ALL_COMPACTION_PROMPT, LOCAL_SLIDING_WINDOW_COMPACTION_PROMPT;
 var init_compaction = __esm(() => {
   init_dist6();
   init_AISDKModelFactory();
   init_AISDKStreamAdapter();
   init_contextWindowOverflow();
+  LocalSlidingWindowCompactionPlanningError = class LocalSlidingWindowCompactionPlanningError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "LocalSlidingWindowCompactionPlanningError";
+    }
+  };
   LOCAL_ALL_COMPACTION_PROMPT = `Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions.
 This summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing development work without losing context. Your summary should include the following sections:
 
@@ -72027,6 +72296,24 @@ This summary should be thorough in capturing technical details, code patterns, a
 Write in first person as a factual record of what occurred. Be concise but thorough - the goal is to preserve enough context that the recent messages make sense and important information isn't lost to prevent duplicate work or repeated mistakes.
 
 Keep your summary under ${ALL_WORD_LIMIT} words. Only output the summary.`;
+  LOCAL_SLIDING_WINDOW_COMPACTION_PROMPT = `The following messages are being evicted from the BEGINNING of your context window. Write a detailed summary that captures what happened in these messages to appear BEFORE the remaining recent messages in context, providing background for what comes after. Include the following sections:
+
+1.**High level goals**: What is the high level goal and ongoing task? Capture the user's explicit requests and intent in detail. If there is an existing summary in the transcript, make sure to take it into consideration to continue tracking the higher level goals and long-term progress.
+
+2. **What happened**: The conversations, tasks, and exchanges that took place. What did the user ask for? What did you do? How did things progress? If there is a previous summary being evicted, please extract a concise version of the critical info from it.
+
+3. **Important details**: Enumerate specific files and code sections examined, modified, or created, as well as important plan files, GitHub issues/PR links, and Linear ticket IDs. For each item, include why it matters and any relevant names, data, configs, or facts discussed.
+   - **Preserve identifiers verbatim** (plan filename/path, exact URL, issue/PR number, ticket ID); do not paraphrase or truncate.
+   - **Preserve referenced identifiers unless explicitly resolved**: Keep exact URLs/IDs from the conversation unless there is clear evidence they are no longer relevant.
+   - Do not omit details likely to be referenced later.
+
+4. **Errors and fixes**: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received and record verbatim if useful.
+
+5. **Lookup hints**: For any detailed content (long lists, extensive data, specific conversations) that couldn't fit in the summary, note the topic and key terms that could be used to find it in message history later.
+
+Write in first person as a factual record of what occurred. Be thorough and detailed - the goal is to preserve enough context that the recent messages make sense and important information isn't lost to prevent duplicate work or repeated mistakes.
+
+Keep your summary under ${SLIDING_WORD_LIMIT} words. Only output the summary.`;
 });
 
 // src/backend/local/LocalModelConfig.ts
@@ -76274,6 +76561,9 @@ __export(exports_modify, {
 function supportsDistinctAnthropicXHighEffort(modelHandle) {
   return modelHandle.includes("claude-opus-4-7");
 }
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 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/") || modelHandle.startsWith("minimax/");
@@ -76396,6 +76686,12 @@ function buildModelSettings(modelHandle, updateArgs) {
   if (typeof updateArgs?.max_output_tokens === "number" && "provider_type" in settings) {
     settings.max_output_tokens = updateArgs.max_output_tokens;
   }
+  if (isRecord5(updateArgs?.modalities)) {
+    settings.modalities = updateArgs.modalities;
+  }
+  if (isRecord5(updateArgs?.capabilities)) {
+    settings.capabilities = updateArgs.capabilities;
+  }
   return settings;
 }
 async function updateAgentLLMConfig(agentId, modelHandle, updateArgs, options) {
@@ -78106,6 +78402,95 @@ function createTelegramAdapter(config2) {
   let botModule = null;
   let running = false;
   const bufferedMediaGroups = new Map;
+  const typingByChatId = new Map;
+  async function sendTypingAction(chatId) {
+    if (!running)
+      return;
+    try {
+      const telegramBot = await ensureBot();
+      await telegramBot.api.sendChatAction(chatId, "typing");
+    } catch (error51) {
+      console.warn(`[Telegram] Failed to send typing action for chat ${chatId}:`, error51 instanceof Error ? error51.message : error51);
+    }
+  }
+  function getTypingSourceKey(source) {
+    const chatId = getTypingChatId(source);
+    if (!chatId)
+      return null;
+    return [
+      source.accountId ?? "",
+      chatId,
+      source.threadId ?? "",
+      source.messageId ?? "",
+      source.agentId,
+      source.conversationId
+    ].join(":");
+  }
+  function startTypingForSource(source) {
+    const chatId = getTypingChatId(source);
+    const sourceKey = getTypingSourceKey(source);
+    if (!chatId || !sourceKey)
+      return;
+    const existing = typingByChatId.get(chatId);
+    if (existing) {
+      existing.sourceKeys.add(sourceKey);
+      return;
+    }
+    sendTypingAction(chatId);
+    const timer = setInterval(() => {
+      sendTypingAction(chatId);
+    }, TELEGRAM_TYPING_REFRESH_MS);
+    const timeout = setTimeout(() => {
+      clearTypingForChat(chatId);
+    }, TELEGRAM_TYPING_MAX_MS);
+    if (typeof timer.unref === "function") {
+      timer.unref?.();
+    }
+    if (typeof timeout.unref === "function") {
+      timeout.unref?.();
+    }
+    typingByChatId.set(chatId, {
+      sourceKeys: new Set([sourceKey]),
+      timer,
+      timeout
+    });
+  }
+  function stopTypingForSource(source) {
+    const chatId = getTypingChatId(source);
+    const sourceKey = getTypingSourceKey(source);
+    if (!chatId || !sourceKey)
+      return;
+    const entry = typingByChatId.get(chatId);
+    if (!entry)
+      return;
+    entry.sourceKeys.delete(sourceKey);
+    if (entry.sourceKeys.size === 0) {
+      clearTypingForChat(chatId);
+    }
+  }
+  function clearTypingForChat(chatId) {
+    const entry = typingByChatId.get(chatId);
+    if (!entry)
+      return;
+    clearInterval(entry.timer);
+    clearTimeout(entry.timeout);
+    typingByChatId.delete(chatId);
+  }
+  function clearAllTyping() {
+    for (const entry of typingByChatId.values()) {
+      clearInterval(entry.timer);
+      clearTimeout(entry.timeout);
+    }
+    typingByChatId.clear();
+  }
+  function getTypingChatId(source) {
+    if (source.channel !== "telegram")
+      return null;
+    const chatId = source.chatId;
+    if (typeof chatId !== "string" || chatId.length === 0)
+      return null;
+    return chatId;
+  }
   async function ensureModule() {
     if (!botModule) {
       botModule = await loadGrammyModule();
@@ -78299,6 +78684,7 @@ function createTelegramAdapter(config2) {
         clearTimeout(entry.timer);
       }
       bufferedMediaGroups.clear();
+      clearAllTyping();
       if (!running || !bot)
         return;
       await bot.stop();
@@ -78324,6 +78710,7 @@ function createTelegramAdapter(config2) {
         } else {
           await telegramBot.api.setMessageReaction(msg.chatId, Number(targetMessageId), []);
         }
+        clearTypingForChat(msg.chatId);
         return { messageId: targetMessageId };
       }
       if (msg.mediaPath) {
@@ -78350,6 +78737,7 @@ function createTelegramAdapter(config2) {
               return await telegramBot.api.sendDocument(msg.chatId, inputFile, options);
           }
         })();
+        clearTypingForChat(msg.chatId);
         return { messageId: String(result2.message_id) };
       }
       const opts = {};
@@ -78362,6 +78750,7 @@ function createTelegramAdapter(config2) {
         opts.parse_mode = msg.parseMode;
       }
       const result = await telegramBot.api.sendMessage(msg.chatId, msg.text, opts);
+      clearTypingForChat(msg.chatId);
       return { messageId: String(result.message_id) };
     },
     async sendDirectReply(chatId, text2, options) {
@@ -78371,12 +78760,29 @@ function createTelegramAdapter(config2) {
       } : undefined;
       await telegramBot.api.sendMessage(chatId, text2, reply_parameters ? { reply_parameters } : {});
     },
+    async handleTurnLifecycleEvent(event) {
+      if (!running)
+        return;
+      if (event.type === "queued") {
+        return;
+      }
+      if (event.type === "processing") {
+        for (const source of event.sources) {
+          startTypingForSource(source);
+        }
+        return;
+      }
+      for (const source of event.sources) {
+        stopTypingForSource(source);
+      }
+    },
     async handleControlRequestEvent(event) {
       const telegramBot = await ensureBot();
       const reply_parameters = event.source.messageId || event.source.threadId ? {
         message_id: Number(event.source.threadId ?? event.source.messageId)
       } : undefined;
       await telegramBot.api.sendMessage(event.source.chatId, formatChannelControlRequestPrompt(event), reply_parameters ? { reply_parameters } : {});
+      clearTypingForChat(event.source.chatId);
     },
     onMessage: undefined
   };
@@ -78393,9 +78799,11 @@ async function validateTelegramToken(token) {
     id: info.id
   };
 }
+var TELEGRAM_TYPING_REFRESH_MS = 4000, TELEGRAM_TYPING_MAX_MS;
 var init_adapter = __esm(() => {
   init_media();
   init_runtime();
+  TELEGRAM_TYPING_MAX_MS = 5 * 60 * 1000;
 });
 
 // src/channels/telegram/messageActions.ts
@@ -78488,13 +78896,13 @@ function cloneAccount(account) {
   }
   return cloned;
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeLoadedAccount(account) {
   const next = cloneAccount(account);
   if (!isFirstPartyChannelId(next.channel)) {
-    next.config = isRecord5(next.config) ? { ...next.config } : {};
+    next.config = isRecord6(next.config) ? { ...next.config } : {};
   }
   if (isTelegramChannelAccount(next) && (next.displayName === "Telegram bot" || next.displayName === "Migrated Telegram bot") || isSlackChannelAccount(next) && (next.displayName === "Slack app" || next.displayName === "Migrated Slack app") || isDiscordChannelAccount(next) && (next.displayName === "Discord bot" || next.displayName === "Migrated Discord bot")) {
     next.displayName = undefined;
@@ -80995,6 +81403,12 @@ function resolveDiscordReactionEmoji(value) {
   };
   return nameMap[normalized] ?? normalized;
 }
+function buildDiscordIngressMessageKey(accountId, messageId) {
+  if (!isNonEmptyString3(accountId) || !isNonEmptyString3(messageId)) {
+    return null;
+  }
+  return `${accountId}:${messageId}`;
+}
 function buildDiscordReplyOptions(replyToMessageId, channelId) {
   const trimmed = replyToMessageId?.trim();
   if (!trimmed || trimmed === channelId) {
@@ -81002,7 +81416,8 @@ function buildDiscordReplyOptions(replyToMessageId, channelId) {
   }
   return {
     reply: {
-      messageReference: trimmed
+      messageReference: trimmed,
+      failIfNotExists: false
     }
   };
 }
@@ -81044,12 +81459,6 @@ function createDiscordAdapter(config2) {
   const seenIngressMessageKeys = new Map;
   const lifecycleStateByMessageKey = new Map;
   const lifecycleOperationByMessageKey = new Map;
-  function buildIngressMessageKey(channelId, messageId) {
-    if (!isNonEmptyString3(channelId) || !isNonEmptyString3(messageId)) {
-      return null;
-    }
-    return `${channelId}:${messageId}`;
-  }
   function pruneSeenIngressMessageKeys(now2 = Date.now()) {
     for (const [key, expiresAt] of seenIngressMessageKeys) {
       if (expiresAt <= now2) {
@@ -81068,8 +81477,8 @@ function createDiscordAdapter(config2) {
       }
     }
   }
-  function markIngressMessageSeen(channelId, messageId) {
-    const key = buildIngressMessageKey(channelId, messageId);
+  function markIngressMessageSeen(messageId) {
+    const key = buildDiscordIngressMessageKey(config2.accountId, messageId);
     if (!key)
       return false;
     const now2 = Date.now();
@@ -81259,7 +81668,7 @@ function createDiscordAdapter(config2) {
         const isThread = isThreadMessage(message);
         const wasMentioned = chatType === "channel" && hasBotMention(message);
         if (chatType === "direct") {
-          if (markIngressMessageSeen(message.channelId, message.id))
+          if (markIngressMessageSeen(message.id))
             return;
           const attachments2 = await collectAttachments(message.attachments, message.channelId);
           if (!content && (!attachments2 || attachments2.length === 0))
@@ -81296,7 +81705,7 @@ function createDiscordAdapter(config2) {
           allowedChannels: config2.allowedChannels
         }))
           return;
-        if (markIngressMessageSeen(message.channelId, message.id))
+        if (markIngressMessageSeen(message.id))
           return;
         let effectiveChatId = message.channelId;
         let effectiveThreadId = isThread ? message.channelId : null;
@@ -81767,7 +82176,7 @@ __export(exports_pluginRegistry, {
 import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
 import { resolve as resolve6, sep } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-function isRecord6(value) {
+function isRecord7(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isValidChannelId(value) {
@@ -81783,7 +82192,7 @@ function readChannelManifest(channelDir) {
   }
   try {
     const parsed = JSON.parse(readFileSync9(manifestPath, "utf-8"));
-    if (!isRecord6(parsed)) {
+    if (!isRecord7(parsed)) {
       return null;
     }
     const id = typeof parsed.id === "string" ? parsed.id.trim() : "";
@@ -81827,8 +82236,8 @@ function createUserChannelRegistration(manifest) {
         throw new Error(`Channel plugin "${manifest.id}" entry escapes its directory.`);
       }
       const loadPromise = import(pathToFileURL2(entryPath).href).then((loaded) => {
-        const exported = (isRecord6(loaded) ? loaded.channelPlugin : undefined) ?? (isRecord6(loaded) ? loaded.default : undefined);
-        if (!isRecord6(exported)) {
+        const exported = (isRecord7(loaded) ? loaded.channelPlugin : undefined) ?? (isRecord7(loaded) ? loaded.default : undefined);
+        if (!isRecord7(exported)) {
           throw new Error(`Channel plugin "${manifest.id}" must export channelPlugin or default.`);
         }
         const plugin = exported;
@@ -82775,6 +83184,9 @@ function buildChannelNotificationXml(msg) {
     `chat_id="${escapeXmlAttribute(msg.chatId)}"`,
     `sender_id="${escapeXmlAttribute(msg.senderId)}"`
   ];
+  if (msg.accountId) {
+    attrs.push(`account_id="${escapeXmlAttribute(msg.accountId)}"`);
+  }
   if (msg.senderName) {
     attrs.push(`sender_name="${escapeXmlAttribute(msg.senderName)}"`);
   }
@@ -83135,8 +83547,9 @@ class ChannelRegistry {
     }
     return matches[0] ?? null;
   }
-  getRouteForScope(channel, chatId, agentId, conversationId) {
-    const matches = getRoutesForChannel(channel).filter((route) => route.chatId === chatId && route.agentId === agentId && route.conversationId === conversationId && route.enabled);
+  getRouteForScope(channel, chatId, agentId, conversationId, accountId) {
+    const normalizedAccountId = accountId?.trim();
+    const matches = getRoutesForChannel(channel).filter((route) => route.chatId === chatId && route.agentId === agentId && route.conversationId === conversationId && (!normalizedAccountId || (route.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID) === normalizedAccountId) && route.enabled);
     if (matches.length !== 1) {
       return null;
     }
@@ -83730,6 +84143,7 @@ async function executeSingleDecision(decision, onChunk, options) {
         toolCallId: decision.approval.toolCallId,
         toolContextId: options?.toolContextId,
         parentScope: options?.parentScope,
+        channelTurnSources: options?.channelTurnSources,
         onOutput: options?.onStreamingOutput ? (chunk, stream) => options.onStreamingOutput?.(decision.approval.toolCallId, chunk, stream === "stderr") : undefined,
         onFileWrite: options?.onFileWrite
       });
@@ -90339,8 +90753,7 @@ var init_readOnlyShell = __esm(() => {
     memory: new Set(["status", "help", "backups", "export", "tokens"]),
     memfs: new Set(["status", "help", "backups", "export", "tokens"]),
     agents: new Set(["list", "help"]),
-    messages: new Set(["search", "list", "help"]),
-    blocks: new Set(["list", "help"])
+    messages: new Set(["search", "list", "help"])
   };
   SAFE_GH_COMMANDS = {
     pr: new Set(["list", "status", "checks", "diff", "view"]),
@@ -90817,7 +91230,7 @@ async function initSecretsFromServer(agentId, cachedAgent) {
     setCache(agentId, {});
     return;
   }
-  const agent = cachedAgent ?? await (await getClient()).agents.retrieve(agentId, {
+  const agent = cachedAgent ?? await getBackend().retrieveAgent(agentId, {
     include: ["agent.secrets"]
   });
   const secrets2 = {};
@@ -90850,6 +91263,9 @@ async function refreshAndListSecrets(agentIdArg) {
   return Object.keys(cache3).sort().map((key) => ({ key, value: cache3[key] ?? "" }));
 }
 async function applySecretBatch(options, agentIdArg) {
+  if (!getBackend().capabilities.serverSecrets) {
+    throw new Error("Agent secrets are not supported by this backend yet");
+  }
   const agentId = resolveSecretsAgentId(agentIdArg);
   if (!agentId) {
     throw new Error("No agent context set. Agent ID is required.");
@@ -90861,8 +91277,7 @@ async function applySecretBatch(options, agentIdArg) {
   for (const rawKey of options.unset ?? []) {
     delete next[rawKey.toUpperCase()];
   }
-  const client = await getClient();
-  await client.agents.update(agentId, { secrets: next });
+  await getBackend().updateAgent(agentId, { secrets: next });
   setCache(agentId, next);
   return Object.keys(next).sort();
 }
@@ -90870,14 +91285,13 @@ async function setSecretOnServer(key, value, agentIdArg) {
   if (!getBackend().capabilities.serverSecrets) {
     throw new Error("Agent secrets are not supported by this backend yet");
   }
-  const client = await getClient();
   const agentId = resolveSecretsAgentId(agentIdArg);
   if (!agentId) {
     throw new Error("No agent context set. Agent ID is required.");
   }
   const secrets2 = { ...loadSecrets(agentId) };
   secrets2[key] = value;
-  await client.agents.update(agentId, { secrets: secrets2 });
+  await getBackend().updateAgent(agentId, { secrets: secrets2 });
   setCache(agentId, secrets2);
 }
 async function deleteSecretOnServer(key, agentIdArg) {
@@ -90893,8 +91307,7 @@ async function deleteSecretOnServer(key, agentIdArg) {
     return false;
   }
   delete secrets2[key];
-  const client = await getClient();
-  await client.agents.update(agentId, { secrets: secrets2 });
+  await getBackend().updateAgent(agentId, { secrets: secrets2 });
   setCache(agentId, secrets2);
   return true;
 }
@@ -90910,7 +91323,6 @@ var SECRETS_CACHE_KEY;
 var init_secretsStore = __esm(() => {
   init_context();
   init_backend2();
-  init_client2();
   SECRETS_CACHE_KEY = Symbol.for("@letta/secretsCache");
 });
 
@@ -93684,7 +94096,9 @@ function getShellEnv() {
     env.LETTA_AGENT_ID = agentId;
     env.AGENT_ID = agentId;
     try {
-      if (settingsManager.isMemfsEnabled(agentId) || process.env.LETTA_LOCAL_BACKEND_EXPERIMENTAL === "1" || process.env.LETTA_LOCAL_BACKEND_EXPERIMENTAL?.toLowerCase() === "true") {
+      const localBackendNoMemfs = isLocalBackendNoMemfsEnvEnabled();
+      const localBackendEnabled = process.env.LETTA_LOCAL_BACKEND_EXPERIMENTAL === "1" || process.env.LETTA_LOCAL_BACKEND_EXPERIMENTAL?.toLowerCase() === "true";
+      if (!localBackendNoMemfs && (settingsManager.isMemfsEnabled(agentId) || localBackendEnabled)) {
         const memoryDir = resolveScopedMemoryDir({ agentId });
         if (!memoryDir) {
           throw new Error("Unable to resolve memory directory");
@@ -93752,6 +94166,7 @@ var init_shellEnv = __esm(() => {
   init_context();
   init_memoryFilesystem();
   init_client2();
+  init_paths();
   init_runtime_context();
   init_settings_manager();
 });
@@ -96872,6 +97287,25 @@ function buildSyntheticChannelRoute(params) {
     updatedAt: now2
   };
 }
+function inferAccountIdFromChannelTurnSources(params) {
+  const chatId = params.input.chatId;
+  if (!chatId) {
+    return;
+  }
+  const accountIds = new Set;
+  for (const source of params.channelTurnSources ?? []) {
+    if (source.channel !== params.input.channel || source.chatId !== chatId || source.agentId !== params.scope.agentId || source.conversationId !== params.scope.conversationId) {
+      continue;
+    }
+    if (params.input.threadId !== undefined && (source.threadId ?? null) !== (params.input.threadId ?? null)) {
+      continue;
+    }
+    if (source.accountId?.trim()) {
+      accountIds.add(source.accountId.trim());
+    }
+  }
+  return accountIds.size === 1 ? [...accountIds][0] : undefined;
+}
 async function resolveExplicitMessageChannelContext(params) {
   if (params.input.channel !== "slack") {
     return `Error: Explicit MessageChannel targets are not supported on ${params.input.channel}.`;
@@ -96922,9 +97356,14 @@ async function message_channel(args) {
   try {
     let executionContext;
     if (input.chatId) {
-      const route2 = registry2.getRouteForScope(input.channel, input.chatId, scope.agentId, scope.conversationId);
+      const resolvedAccountId = input.accountId ?? inferAccountIdFromChannelTurnSources({
+        input,
+        scope,
+        channelTurnSources: args.channelTurnSources
+      });
+      const route2 = registry2.getRouteForScope(input.channel, input.chatId, scope.agentId, scope.conversationId, resolvedAccountId);
       if (!route2) {
-        return `Error: No route for chat_id "${input.chatId}" on "${input.channel}" for this agent/conversation.`;
+        return resolvedAccountId ? `Error: No route for chat_id "${input.chatId}" on "${input.channel}" account "${resolvedAccountId}" for this agent/conversation.` : `Error: No route for chat_id "${input.chatId}" on "${input.channel}" for this agent/conversation. If multiple channel accounts can receive this chat, pass accountId (from the channel notification's account_id) to disambiguate.`;
       }
       const adapter2 = registry2.getAdapter(input.channel, route2.accountId);
       if (!adapter2) {
@@ -110712,6 +111151,12 @@ var init_SearchFileContentGemini2 = __esm(() => {
 // src/agent/skills.ts
 var exports_skills = {};
 __export(exports_skills, {
+  isUserInvocableSkill: () => isUserInvocableSkill,
+  isModelInvocableSkill: () => isModelInvocableSkill,
+  getLegacyAgentSkillsDir: () => getLegacyAgentSkillsDir,
+  getFrontmatterStringList: () => getFrontmatterStringList,
+  getFrontmatterString: () => getFrontmatterString,
+  getFrontmatterBoolean: () => getFrontmatterBoolean,
   getBundledSkills: () => getBundledSkills,
   getAgentSkillsDir: () => getAgentSkillsDir,
   formatSkillsAsSystemReminder: () => formatSkillsAsSystemReminder,
@@ -110734,7 +111179,45 @@ function getBundledSkillsPath() {
 function compareSkills(a, b) {
   return a.id.localeCompare(b.id) || a.source.localeCompare(b.source) || a.path.localeCompare(b.path);
 }
+function stripSurroundingQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function getFrontmatterString(frontmatter, key) {
+  const value = frontmatter[key];
+  return typeof value === "string" ? stripSurroundingQuotes(value) : undefined;
+}
+function getFrontmatterStringList(frontmatter, key) {
+  const value = frontmatter[key];
+  if (Array.isArray(value)) {
+    return value.map(stripSurroundingQuotes).filter((item) => item.length > 0);
+  }
+  if (typeof value === "string") {
+    return stripSurroundingQuotes(value).split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  return;
+}
+function getFrontmatterBoolean(frontmatter, key) {
+  const value = getFrontmatterString(frontmatter, key)?.toLowerCase();
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  return;
+}
+function isModelInvocableSkill(skill) {
+  return skill.disableModelInvocation !== true;
+}
+function isUserInvocableSkill(skill) {
+  return skill.userInvocable !== false;
+}
 function getAgentSkillsDir(agentId) {
+  return join25(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
+}
+function getLegacyAgentSkillsDir(agentId) {
   return join25(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills() {
@@ -110777,6 +111260,12 @@ async function discoverSkills(projectSkillsPath = join25(process.cwd(), SKILLS_D
     }
   }
   if (agentId && includeSource("agent")) {
+    const legacyDir = getLegacyAgentSkillsDir(agentId);
+    const legacyResult = await discoverSkillsFromDir(legacyDir, "agent");
+    allErrors.push(...legacyResult.errors);
+    for (const skill of legacyResult.skills) {
+      skillsById.set(skill.id, skill);
+    }
     const agentSkillsDir = getAgentSkillsDir(agentId);
     const agentResult = await discoverSkillsFromDir(agentSkillsDir, "agent");
     allErrors.push(...agentResult.errors);
@@ -110860,7 +111349,7 @@ async function parseSkillFile(filePath, rootPath, source) {
   const defaultId = dirPath || "root";
   const id = (typeof frontmatter.id === "string" ? frontmatter.id : null) || defaultId;
   const name25 = (typeof frontmatter.name === "string" ? frontmatter.name : null) || (typeof frontmatter.title === "string" ? frontmatter.title : null) || (id.split("/").pop() ?? "").replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
-  let description = typeof frontmatter.description === "string" ? frontmatter.description : null;
+  let description = getFrontmatterString(frontmatter, "description") ?? null;
   if (!description) {
     const firstParagraph = body.trim().split(`
 
@@ -110868,30 +111357,31 @@ async function parseSkillFile(filePath, rootPath, source) {
     description = firstParagraph || "No description available";
   }
   description = description.trim();
-  if (description.startsWith('"') && description.endsWith('"') || description.startsWith("'") && description.endsWith("'")) {
-    description = description.slice(1, -1);
-  }
-  let tags;
-  if (Array.isArray(frontmatter.tags)) {
-    tags = frontmatter.tags;
-  } else if (typeof frontmatter.tags === "string") {
-    tags = [frontmatter.tags];
-  }
+  const whenToUse = getFrontmatterString(frontmatter, "when_to_use")?.trim();
+  const modelDescription = whenToUse ? `${description}
+
+When to use: ${whenToUse}` : description;
+  const tags = getFrontmatterStringList(frontmatter, "tags");
   return {
     id,
     name: name25,
-    description,
-    category: typeof frontmatter.category === "string" ? frontmatter.category : undefined,
+    description: modelDescription,
+    whenToUse,
+    argumentHint: getFrontmatterString(frontmatter, "argument-hint"),
+    arguments: getFrontmatterStringList(frontmatter, "arguments"),
+    disableModelInvocation: getFrontmatterBoolean(frontmatter, "disable-model-invocation") ?? false,
+    userInvocable: getFrontmatterBoolean(frontmatter, "user-invocable") ?? true,
+    category: getFrontmatterString(frontmatter, "category"),
     tags,
     path: filePath,
     source
   };
 }
 function formatSkillsAsSystemReminder(skills) {
-  if (skills.length === 0) {
+  const lines = skills.filter(isModelInvocableSkill).sort(compareSkills).map((s) => `- ${s.id} (${s.source}): ${s.description}`);
+  if (lines.length === 0) {
     return "";
   }
-  const lines = [...skills].sort(compareSkills).map((s) => `- ${s.id} (${s.source}): ${s.description}`);
   return `<system-reminder>
 The following skills are available for use with the Skill tool:
 
@@ -110925,6 +111415,15 @@ var init_skillContentRegistry = __esm(() => {
 });
 
 // src/tools/impl/Skill.ts
+var exports_Skill = {};
+__export(exports_Skill, {
+  wrapSkillContent: () => wrapSkillContent,
+  skill: () => skill,
+  renderSkillContent: () => renderSkillContent,
+  readSkillContent: () => readSkillContent,
+  loadRenderedSkillContent: () => loadRenderedSkillContent,
+  getResolvedSkillsDir: () => getResolvedSkillsDir
+});
 import { existsSync as existsSync23, readdirSync as readdirSync7 } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
 import { dirname as dirname12, join as join26 } from "node:path";
@@ -111009,6 +111508,83 @@ function getResolvedAgentId(args) {
     return;
   }
 }
+function splitSkillArguments(args) {
+  const parts = [];
+  const pattern = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|\S+/g;
+  for (const match2 of args.matchAll(pattern)) {
+    const raw = match2[1] ?? match2[2] ?? match2[0];
+    parts.push(raw.replace(/\\(["'\\])/g, "$1"));
+  }
+  return parts;
+}
+function substituteSkillArguments(content, args, argumentNames) {
+  const rawArgs = args?.trim() ?? "";
+  if (!rawArgs) {
+    return content;
+  }
+  const argParts = splitSkillArguments(rawArgs);
+  let result = content;
+  let substituted = false;
+  result = result.replace(/\$ARGUMENTS\[(\d+)\]/g, (_match, index) => {
+    substituted = true;
+    return argParts[Number(index)] ?? "";
+  });
+  result = result.replace(/\$ARGUMENTS/g, () => {
+    substituted = true;
+    return rawArgs;
+  });
+  result = result.replace(/\$(\d+)\b/g, (_match, index) => {
+    substituted = true;
+    return argParts[Number(index)] ?? "";
+  });
+  for (const [index, name25] of (argumentNames ?? []).entries()) {
+    const escapedName = name25.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const namePattern = new RegExp(`\\$${escapedName}\\b`, "g");
+    result = result.replace(namePattern, () => {
+      substituted = true;
+      return argParts[index] ?? "";
+    });
+  }
+  if (!substituted) {
+    result = `${result.trimEnd()}
+
+ARGUMENTS: ${rawArgs}`;
+  }
+  return result;
+}
+function renderSkillContent(skillName, skillContent, skillPath, options = {}) {
+  const { frontmatter } = parseFrontmatter(skillContent);
+  if (!options.allowDisabledModelInvocation && getFrontmatterBoolean(frontmatter, "disable-model-invocation") === true) {
+    throw new Error(`Skill "${skillName}" is marked disable-model-invocation and can only be invoked directly by the user.`);
+  }
+  const skillDir = dirname12(skillPath);
+  const hasExtras = hasAdditionalFiles(skillPath);
+  const argumentNames = getFrontmatterStringList(frontmatter, "arguments");
+  const withSkillDir = skillContent.replace(/<SKILL_DIR>/g, skillDir).replace(/\$\{CLAUDE_SKILL_DIR\}/g, skillDir);
+  const withArguments = substituteSkillArguments(withSkillDir, options.args, argumentNames);
+  const dirHeader = hasExtras ? `# Skill Directory: ${skillDir}
+
+` : "";
+  return `${dirHeader}${withArguments}`;
+}
+async function loadRenderedSkillContent(skillName, options = {}) {
+  const skillsDir = options.skillsDir ?? await getResolvedSkillsDir();
+  const { content: skillContent, path: skillPath } = await readSkillContent(skillName, skillsDir, options.agentId);
+  return renderSkillContent(skillName, skillContent, skillPath, options);
+}
+function escapeXmlAttribute2(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function wrapSkillContent(skillName, content) {
+  if (/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(skillName)) {
+    return `<${skillName}>
+${content}
+</${skillName}>`;
+  }
+  return `<skill name="${escapeXmlAttribute2(skillName)}">
+${content}
+</skill>`;
+}
 async function skill(args) {
   validateRequiredParams(args, ["skill"], "Skill");
   const { skill: skillName, toolCallId } = args;
@@ -111018,18 +111594,13 @@ async function skill(args) {
   try {
     const agentId = getResolvedAgentId(args);
     const skillsDir = await getResolvedSkillsDir();
-    const { content: skillContent, path: skillPath } = await readSkillContent(skillName, skillsDir, agentId);
-    const skillDir = dirname12(skillPath);
-    const hasExtras = hasAdditionalFiles(skillPath);
-    const processedContent = hasExtras ? skillContent.replace(/<SKILL_DIR>/g, skillDir) : skillContent;
-    const dirHeader = hasExtras ? `# Skill Directory: ${skillDir}
-
-` : "";
-    const fullContent = `${dirHeader}${processedContent}`;
+    const fullContent = await loadRenderedSkillContent(skillName, {
+      agentId,
+      skillsDir,
+      args: args.args
+    });
     if (toolCallId) {
-      queueSkillContent(toolCallId, `<${skillName}>
-${fullContent}
-</${skillName}>`);
+      queueSkillContent(toolCallId, wrapSkillContent(skillName, fullContent));
     }
     return { message: `Launching skill: ${skillName}` };
   } catch (error51) {
@@ -111415,18 +111986,21 @@ var init_contextBudget = __esm(() => {
 // src/agent/subagents/manager.ts
 import { spawn as spawn5 } from "node:child_process";
 function getModelHandleFromAgent(agent) {
+  const directModel = agent.model;
+  if (directModel?.includes("/")) {
+    return directModel;
+  }
   const endpoint = agent.llm_config?.model_endpoint_type;
   const model = agent.llm_config?.model;
   if (endpoint && model) {
     return `${endpoint}/${model}`;
   }
-  return model || null;
+  return directModel || model || null;
 }
 async function getPrimaryAgentModelHandle() {
   try {
     const agentId = getCurrentAgentId();
-    const client = await getClient();
-    const agent = await client.agents.retrieve(agentId);
+    const agent = await getBackend().retrieveAgent(agentId);
     return { handle: getModelHandleFromAgent(agent), agent };
   } catch {
     return { handle: null, agent: null };
@@ -111696,6 +112270,8 @@ function resolveSubagentLauncher(cliArgs, options = {}) {
 function composeSubagentChildEnv(options) {
   const {
     parentProcessEnv,
+    backendMode,
+    localBackendStorageDir,
     parentAgentId,
     permissionMode: permissionMode2,
     inheritedPrimaryRoot,
@@ -111709,6 +112285,14 @@ function composeSubagentChildEnv(options) {
     LETTA_CODE_AGENT_ROLE: "subagent",
     ...parentAgentId && { LETTA_PARENT_AGENT_ID: parentAgentId }
   };
+  if (backendMode === "local") {
+    childEnv.LETTA_LOCAL_BACKEND_EXPERIMENTAL = "1";
+    if (localBackendStorageDir) {
+      childEnv.LETTA_LOCAL_BACKEND_DIR = localBackendStorageDir;
+    }
+  } else if (backendMode === "api") {
+    childEnv.LETTA_LOCAL_BACKEND_EXPERIMENTAL = "0";
+  }
   const nextScope = new Set([
     ...parseScopeList(parentProcessEnv.LETTA_MEMORY_SCOPE),
     ...cliPermissions.getMemoryScope()
@@ -111732,6 +112316,12 @@ function composeSubagentChildEnv(options) {
   }
   return childEnv;
 }
+function resolveSubagentInheritedPrimaryRoot(options) {
+  if (options.backendMode === "local" && options.parentAgentId) {
+    return getLocalBackendMemoryFilesystemRoot(options.parentAgentId, options.localBackendStorageDir ?? getLocalBackendStorageDir2());
+  }
+  return options.inheritedPrimaryRoot;
+}
 function getReflectionStartupNotice() {
   return `[Reflection startup context truncated: system prompt + initial message are capped at ~${REFLECTION_STARTUP_CONTEXT_TOKEN_LIMIT.toLocaleString()} estimated tokens. Some parent memory preview content was omitted; read files directly from MEMORY_DIR if needed.]`;
 }
@@ -111794,9 +112384,12 @@ ${userPrompt}`);
   }
   return hardTruncateReflectionPrompt(userPrompt, allowedPromptChars);
 }
-function buildSubagentArgs(type, config2, model, userPrompt, existingAgentId, existingConversationId, maxTurns) {
+function buildSubagentArgs(type, config2, model, userPrompt, existingAgentId, existingConversationId, maxTurns, options = {}) {
   const args = [];
   const isDeployingExisting = Boolean(existingAgentId || existingConversationId);
+  if (options.backendMode) {
+    args.push("--backend", options.backendMode);
+  }
   if (isDeployingExisting) {
     if (existingConversationId) {
       args.push("--conv", existingConversationId);
@@ -111868,7 +112461,9 @@ async function executeSubagent(type, config2, model, userPrompt, baseURL, subage
     updateSubagent(subagentId, { model });
   }
   try {
-    const cliArgs = buildSubagentArgs(type, config2, model, userPrompt, existingAgentId, existingConversationId, maxTurns);
+    const activeBackend = getBackend();
+    const backendMode = activeBackend.capabilities.localMemfs ? "local" : "api";
+    const cliArgs = buildSubagentArgs(type, config2, model, userPrompt, existingAgentId, existingConversationId, maxTurns, { backendMode });
     const launcher = resolveSubagentLauncher(cliArgs);
     let parentAgentId = parentAgentIdOverride;
     if (!parentAgentId) {
@@ -111882,19 +112477,28 @@ async function executeSubagent(type, config2, model, userPrompt, baseURL, subage
     const inheritedMemoryRoots = resolveAllowedMemoryRoots({
       currentAgentId: parentAgentId ?? null
     });
+    const localBackendStorageDir = backendMode === "local" ? getLocalBackendStorageDir2() : null;
+    const inheritedPrimaryRoot = resolveSubagentInheritedPrimaryRoot({
+      backendMode,
+      parentAgentId,
+      inheritedPrimaryRoot: inheritedMemoryRoots.primaryRoot,
+      localBackendStorageDir
+    });
     const subagentWorkingDirectory = resolveSubagentWorkingDirectory(process.env, getCurrentWorkingDirectory(), {
       subagentType: type,
       permissionMode: config2.permissionMode,
-      inheritedPrimaryRoot: inheritedMemoryRoots.primaryRoot
+      inheritedPrimaryRoot
     });
     const childEnv = composeSubagentChildEnv({
       parentProcessEnv: {
         ...process.env,
         USER_CWD: subagentWorkingDirectory
       },
+      backendMode,
+      localBackendStorageDir,
       parentAgentId,
       permissionMode: config2.permissionMode,
-      inheritedPrimaryRoot: inheritedMemoryRoots.primaryRoot,
+      inheritedPrimaryRoot,
       inheritedApiKey,
       inheritedBaseUrl
     });
@@ -112080,7 +112684,7 @@ async function spawnSubagent(type, prompt, userModel, subagentId, signal, existi
   let finalPrompt = prompt;
   if (isDeployingExisting && resolvedParentAgentId) {
     try {
-      const cachedParent = parentAgent ?? await (await getClient()).agents.retrieve(resolvedParentAgentId);
+      const cachedParent = parentAgent ?? await getBackend().retrieveAgent(resolvedParentAgentId);
       if (forkedContext) {
         const systemReminder = buildForkSystemReminder(type);
         finalPrompt = systemReminder + prompt;
@@ -112095,8 +112699,9 @@ async function spawnSubagent(type, prompt, userModel, subagentId, signal, existi
 }
 var BYOK_PROVIDER_TO_BASE;
 var init_manager3 = __esm(() => {
-  init_client2();
+  init_backend2();
   init_metadata();
+  init_paths();
   init_subagentState();
   init_constants();
   init_cli();
@@ -112124,22 +112729,6 @@ var init_manager3 = __esm(() => {
   };
 });
 
-// src/backend/api/conversations.ts
-var exports_conversations = {};
-__export(exports_conversations, {
-  forkConversation: () => forkConversation
-});
-async function forkConversation(conversationId, options = {}) {
-  const query = {
-    ...options.agentId ? { agent_id: options.agentId } : {},
-    ...options.hidden !== undefined ? { hidden: options.hidden } : {}
-  };
-  return apiRequest("POST", `/v1/conversations/${encodeURIComponent(conversationId)}/fork`, undefined, { query });
-}
-var init_conversations2 = __esm(() => {
-  init_request();
-});
-
 // src/cli/helpers/messageQueueBridge.ts
 function setMessageQueueAdder(fn) {
   queueAdder = fn;
@@ -112557,7 +113146,7 @@ async function task(args) {
     try {
       const parentAgentId = getCurrentAgentId();
       const parentConvId = getConversationId() ?? "default";
-      const forkedConv = await forkConversation(parentConvId, {
+      const forkedConv = await getBackend().forkConversation(parentConvId, {
         ...parentConvId === "default" ? { agentId: parentAgentId } : {},
         hidden: true
       });
@@ -112655,7 +113244,7 @@ var init_Task2 = __esm(() => {
   init_context();
   init_subagents();
   init_manager3();
-  init_conversations2();
+  init_backend2();
   init_messageQueueBridge();
   init_subagentState();
   init_hooks();
@@ -116900,7 +117489,7 @@ function detectSkillScript(command, workingDir) {
   if (projectSkill) {
     return projectSkill;
   }
-  const agentRegex = new RegExp(`^${escapeRegex4(normalizedHomeDir)}/\\.letta/agents/[^/]+/skills/(.+?)/scripts/`);
+  const agentRegex = new RegExp(`^${escapeRegex4(normalizedHomeDir)}/\\.letta/agents/[^/]+/(?:memory/)?skills/(.+?)/scripts/`);
   const agentSkill = detect("agent-scoped", agentRegex);
   if (agentSkill) {
     return agentSkill;
@@ -117773,14 +118362,14 @@ function clipToolReturn(text2, maxLines = 3, maxChars = 300) {
   }
   return clipped;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function isStringArray2(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 function isMultimodalContent(arr) {
-  return arr.every((item) => isRecord7(item) && (item.type === "text" || item.type === "image"));
+  return arr.every((item) => isRecord8(item) && (item.type === "text" || item.type === "image"));
 }
 function flattenToolResponse(result) {
   if (result === null || result === undefined) {
@@ -117789,7 +118378,7 @@ function flattenToolResponse(result) {
   if (typeof result === "string") {
     return result;
   }
-  if (!isRecord7(result)) {
+  if (!isRecord8(result)) {
     return JSON.stringify(result);
   }
   if (typeof result.message === "string") {
@@ -117806,7 +118395,7 @@ function flattenToolResponse(result) {
     return result.content;
   }
   if (Array.isArray(result.content)) {
-    const textContent2 = result.content.filter((item) => isRecord7(item) && item.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
+    const textContent2 = result.content.filter((item) => isRecord8(item) && item.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
 `);
     if (textContent2) {
       return textContent2;
@@ -117921,8 +118510,16 @@ async function executeTool2(name25, args, options) {
       if (internalName === "Skill" && options?.parentScope) {
         enhancedArgs = { ...enhancedArgs, parentScope: options.parentScope };
       }
-      if (internalName === "MessageChannel" && options?.parentScope) {
-        enhancedArgs = { ...enhancedArgs, parentScope: options.parentScope };
+      if (internalName === "MessageChannel") {
+        if (options?.parentScope) {
+          enhancedArgs = { ...enhancedArgs, parentScope: options.parentScope };
+        }
+        if (options?.channelTurnSources?.length) {
+          enhancedArgs = {
+            ...enhancedArgs,
+            channelTurnSources: options.channelTurnSources
+          };
+        }
       }
       const PLAN_MODE_TOOL_NAMES = new Set([
         "EnterPlanMode",
@@ -117949,7 +118546,7 @@ async function executeTool2(name25, args, options) {
           } catch {}
         }
       }
-      const recordResult = isRecord7(result) ? result : undefined;
+      const recordResult = isRecord8(result) ? result : undefined;
       const stdoutValue = recordResult?.stdout;
       const stderrValue = recordResult?.stderr;
       const stdout = isStringArray2(stdoutValue) ? stdoutValue : undefined;
@@ -118683,9 +119280,8 @@ async function hydrateMemfsSettingFromAgent(agent) {
   return enabled;
 }
 async function isMemfsEnabledOnServer(agentId) {
-  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-  const client = await getClient2();
-  const agent = await client.agents.retrieve(agentId, {
+  const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+  const agent = await getBackend2().retrieveAgent(agentId, {
     include: ["agent.tags"]
   });
   const { GIT_MEMORY_ENABLED_TAG: GIT_MEMORY_ENABLED_TAG2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
@@ -118818,7 +119414,8 @@ async function applyMemfsFlags(agentId, memfsFlag, noMemfsFlag, options) {
   const backend = getBackend2();
   if (backend.capabilities.localMemfs) {
     if (noMemfsFlag) {
-      throw new Error("Disabling MemFS is not supported by the local backend.");
+      settingsManager2.setMemfsEnabled(agentId, false);
+      return { action: "disabled" };
     }
     const memoryDir = getScopedMemoryFilesystemRoot(agentId);
     const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
@@ -119274,7 +119871,7 @@ ${skillsBlock.trimStart()}`;
 function compileLocalSystemPrompt(options) {
   const compiledAt = options.now ?? new Date;
   const memoryDir = options.memoryDir ?? getMemoryFilesystemRoot(options.agent.id);
-  const memfs = renderMemfsProjection(memoryDir);
+  const memfs = options.includeMemfs === false ? { content: "", revision: undefined } : renderMemfsProjection(memoryDir);
   const metadata = compileMemoryMetadata({
     agentId: options.agent.id,
     conversationId: options.conversationId,
@@ -119346,6 +119943,37 @@ function initialMemoryFilesFromCreateBody(body) {
   }
   return [...files.values()].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compactionSettingsRecord(value) {
+  if (value === null)
+    return null;
+  return isRecord9(value) ? { ...value } : undefined;
+}
+function hasOwn2(record2, key) {
+  return Object.hasOwn(record2, key);
+}
+function localCompactionMode(value) {
+  if (value === "all" || value === "sliding_window")
+    return value;
+  return;
+}
+function validateLocalCompactionSettingsRecord(settings) {
+  if (settings.mode === undefined || settings.mode === null)
+    return;
+  if (!localCompactionMode(settings.mode)) {
+    throw new Error(`Local backend compaction currently supports only modes "all" and "sliding_window" (received "${String(settings.mode)}").`);
+  }
+}
+function localCompactionSettingsForStorage(settings) {
+  if (settings === undefined || settings === null)
+    return settings;
+  const hasLocalSetting = hasOwn2(settings, "mode") || hasOwn2(settings, "prompt") || hasOwn2(settings, "clip_chars") || hasOwn2(settings, "sliding_window_percentage");
+  if (!hasLocalSetting)
+    return;
+  return { ...settings };
+}
 function createLocalExecutor(options, onContextWindowOverflow, onContextUsage) {
   if (options.executor)
     return options.executor;
@@ -119385,6 +120013,7 @@ var init_LocalBackend = __esm(() => {
     storageDir;
     createModel;
     generateText;
+    memfsEnabledOverride;
     constructor(options) {
       const localBackendRef = {};
       const modelConfig = resolveLocalModelConfig(options.storageDir);
@@ -119410,19 +120039,46 @@ var init_LocalBackend = __esm(() => {
       this.memoryDir = options.memoryDir;
       this.createModel = options.createModel;
       this.generateText = options.generateText;
+      this.memfsEnabledOverride = options.memfsEnabled;
     }
     async listModels() {
       return listLocalModels(this.storageDir);
     }
     async createAgent(...args) {
       const [body] = args;
-      const agent = await super.createAgent(...args);
-      await this.ensureLocalMemoryRepo(agent.id, initialMemoryFilesFromCreateBody(body), agent.name ?? undefined);
+      const requestedCompactionSettings = compactionSettingsRecord(body.compaction_settings);
+      if (requestedCompactionSettings !== undefined && requestedCompactionSettings !== null) {
+        validateLocalCompactionSettingsRecord(requestedCompactionSettings);
+      }
+      const compactionSettingsForStorage = localCompactionSettingsForStorage(requestedCompactionSettings);
+      let agent = await super.createAgent(...args);
+      if (compactionSettingsForStorage !== undefined) {
+        agent = this.store.setAgentCompactionSettings(agent.id, compactionSettingsForStorage);
+      }
+      if (this.isLocalMemfsEnabled()) {
+        await this.ensureLocalMemoryRepo(agent.id, initialMemoryFilesFromCreateBody(body), agent.name ?? undefined);
+      }
       await this.compileAndMaybePersistSystemPrompt("default", agent.id, {
         dryRun: false
       });
       return agent;
     }
+    async updateAgent(...args) {
+      const [agentId, body] = args;
+      const bodyRecord = body;
+      const settings = hasOwn2(bodyRecord, "compaction_settings") ? compactionSettingsRecord(bodyRecord.compaction_settings) : undefined;
+      if (settings !== undefined && settings !== null) {
+        validateLocalCompactionSettingsRecord(settings);
+      }
+      const compactionSettingsForStorage = localCompactionSettingsForStorage(settings);
+      let agent = await super.updateAgent(...args);
+      if (hasOwn2(bodyRecord, "compaction_settings")) {
+        if (compactionSettingsForStorage !== undefined) {
+          agent = this.store.setAgentCompactionSettings(agentId, compactionSettingsForStorage);
+        }
+      }
+      return agent;
+    }
     async createConversation(body) {
       const conversation = await super.createConversation(body);
       await this.compileAndMaybePersistSystemPrompt(conversation.id, conversation.agent_id, { dryRun: false });
@@ -119437,7 +120093,7 @@ var init_LocalBackend = __esm(() => {
     async compactConversationMessages(conversationId, body) {
       const bodyRecord = body ?? {};
       const agentId = typeof bodyRecord.agent_id === "string" && bodyRecord.agent_id.length > 0 ? bodyRecord.agent_id : this.store.resolveAgentIdForConversation(conversationId);
-      const result = await this.compactLocalConversationAll(conversationId, agentId, "manual", body);
+      const result = await this.compactLocalConversation(conversationId, agentId, "manual", body);
       return {
         num_messages_before: result.numMessagesBefore,
         num_messages_after: result.numMessagesAfter,
@@ -119452,6 +120108,9 @@ var init_LocalBackend = __esm(() => {
     memoryDirForAgent(agentId) {
       return this.memoryDir ?? getLocalBackendMemoryFilesystemRoot(agentId, this.storageDir);
     }
+    isLocalMemfsEnabled() {
+      return this.memfsEnabledOverride ?? !isLocalBackendNoMemfsEnvEnabled();
+    }
     async ensureLocalMemoryRepo(agentId, files = [], authorName) {
       await initializeLocalMemoryRepo({
         memoryDir: this.memoryDirForAgent(agentId),
@@ -119461,9 +120120,7 @@ var init_LocalBackend = __esm(() => {
       });
     }
     async compactAfterContextOverflow(input, _error) {
-      const result = await this.compactLocalConversationAll(input.conversationId, input.agentId, "context_window_overflow", {
-        compaction_settings: { mode: "all" }
-      });
+      const result = await this.compactLocalConversation(input.conversationId, input.agentId, "context_window_overflow");
       return {
         uiMessages: this.store.listLocalMessages(input.conversationId, input.agentId),
         summary: result.summary,
@@ -119476,9 +120133,7 @@ var init_LocalBackend = __esm(() => {
       if (contextTokens === undefined || contextWindow === undefined || contextTokens <= contextWindow) {
         return null;
       }
-      const result = await this.compactLocalConversationAll(input.conversationId, input.agentId, "context_window_limit", {
-        compaction_settings: { mode: "all" }
-      });
+      const result = await this.compactLocalConversation(input.conversationId, input.agentId, "context_window_limit");
       return {
         uiMessages: this.store.listLocalMessages(input.conversationId, input.agentId),
         summary: result.summary,
@@ -119497,24 +120152,55 @@ var init_LocalBackend = __esm(() => {
       const agent = this.store.retrieveAgentRecord(agentId);
       return typeof agent.model_settings.context_window_limit === "number" ? agent.model_settings.context_window_limit : undefined;
     }
-    async compactLocalConversationAll(conversationId, agentId, trigger, body) {
-      const settings = (body ?? {}).compaction_settings;
-      const mode = typeof settings?.mode === "string" ? settings.mode : "all";
-      if (mode !== "all") {
-        throw new Error(`Local backend compaction currently supports only mode "all" (received "${mode}").`);
-      }
+    resolveCompactionSettings(agent, body) {
+      const bodyRecord = body ?? {};
+      const requestSettings = compactionSettingsRecord(bodyRecord.compaction_settings);
+      if (requestSettings !== undefined && requestSettings !== null) {
+        validateLocalCompactionSettingsRecord(requestSettings);
+      }
+      const agentSettings = compactionSettingsRecord(agent.compaction_settings);
+      const baseSettings = agentSettings && agentSettings !== null ? agentSettings : {};
+      const mergedSettings = requestSettings && requestSettings !== null ? { ...baseSettings, ...requestSettings } : baseSettings;
+      const requestChangedMode = requestSettings !== undefined && requestSettings !== null && hasOwn2(requestSettings, "mode");
+      const requestChangedPrompt = requestSettings !== undefined && requestSettings !== null && hasOwn2(requestSettings, "prompt");
+      if (requestChangedMode && !requestChangedPrompt && agentSettings && agentSettings !== null && agentSettings.mode !== requestSettings.mode) {
+        delete mergedSettings.prompt;
+      }
+      const mode = localCompactionMode(mergedSettings.mode) ?? LOCAL_DEFAULT_COMPACTION_MODE;
+      return {
+        mode,
+        prompt: typeof mergedSettings.prompt === "string" || mergedSettings.prompt === null ? mergedSettings.prompt : undefined,
+        clipChars: typeof mergedSettings.clip_chars === "number" || mergedSettings.clip_chars === null ? mergedSettings.clip_chars : undefined,
+        slidingWindowPercentage: typeof mergedSettings.sliding_window_percentage === "number" ? mergedSettings.sliding_window_percentage : LOCAL_DEFAULT_SLIDING_WINDOW_PERCENTAGE
+      };
+    }
+    async compactLocalConversation(conversationId, agentId, trigger, body) {
       const agent = this.store.retrieveAgentRecord(agentId);
+      const settings = this.resolveCompactionSettings(agent, body);
+      if (settings.mode === "sliding_window") {
+        try {
+          return await this.compactLocalConversationSlidingWindow(conversationId, agentId, agent, trigger, settings);
+        } catch (error51) {
+          if (!isLocalSlidingWindowCompactionPlanningError(error51))
+            throw error51;
+        }
+      }
+      return this.compactLocalConversationAll(conversationId, agentId, agent, trigger, {
+        ...settings,
+        mode: "all",
+        prompt: settings.mode === "all" ? settings.prompt : undefined
+      });
+    }
+    async compactLocalConversationAll(conversationId, agentId, agent, trigger, settings) {
       const messages = this.store.listLocalMessages(conversationId, agentId);
       const contextTokensBefore = estimateLocalMessageTokens(messages);
-      const prompt = typeof settings?.prompt === "string" ? settings.prompt : null;
-      const clipChars = typeof settings?.clip_chars === "number" || settings?.clip_chars === null ? settings.clip_chars : undefined;
       const summary = await summarizeLocalMessagesAll({
         agent,
         messages,
         createModel: this.createModel,
         generateText: this.generateText,
-        prompt,
-        clipChars,
+        prompt: settings.prompt,
+        clipChars: settings.clipChars,
         localProviderAuthStorageDir: this.storageDir
       });
       const stats = {
@@ -119539,10 +120225,51 @@ var init_LocalBackend = __esm(() => {
         stats
       };
     }
+    async compactLocalConversationSlidingWindow(conversationId, agentId, agent, trigger, settings) {
+      const messages = this.store.listLocalMessages(conversationId, agentId);
+      const contextWindow = this.effectiveContextWindow(conversationId, agentId);
+      const plan = planLocalSlidingWindowCompaction(messages, {
+        slidingWindowPercentage: settings.slidingWindowPercentage,
+        contextWindow
+      });
+      const summary = await summarizeLocalMessagesSlidingWindow({
+        agent,
+        messages: plan.messagesToSummarize,
+        createModel: this.createModel,
+        generateText: this.generateText,
+        prompt: settings.prompt,
+        clipChars: settings.clipChars,
+        localProviderAuthStorageDir: this.storageDir
+      });
+      const contextTokensAfter = Math.ceil(summary.length / 4) + estimateLocalMessageTokens(plan.messagesToKeep);
+      const stats = {
+        trigger,
+        context_tokens_before: estimateLocalMessageTokens(messages),
+        context_tokens_after: contextTokensAfter,
+        context_window: contextWindow,
+        messages_count_before: messages.length,
+        messages_count_after: 1 + plan.messagesToKeep.length
+      };
+      const storeResult = this.store.compactConversationAll({
+        conversationId,
+        agentId,
+        summary,
+        packedSummary: packageLocalSummaryMessage(summary, stats),
+        stats,
+        remainingMessages: plan.messagesToKeep
+      });
+      return {
+        numMessagesBefore: storeResult.numMessagesBefore,
+        numMessagesAfter: storeResult.numMessagesAfter,
+        summary,
+        stats
+      };
+    }
     async getOrCompileSystemPrompt(conversationId, agentId, agent = this.store.retrieveAgentRecord(agentId), previousMessageCount = 0) {
       const existing = this.store.getCompiledSystemPrompt(conversationId, agentId);
-      const memfsRevision = await getMemoryHeadRevision(this.memoryDirForAgent(agentId));
-      if (existing?.rawSystemHash === hashRawSystemPrompt(agent.system) && memfsRevision !== null && existing.memfsRevision === memfsRevision) {
+      const memfsEnabled = this.isLocalMemfsEnabled();
+      const memfsRevision = memfsEnabled ? await getMemoryHeadRevision(this.memoryDirForAgent(agentId)) : undefined;
+      if (existing?.rawSystemHash === hashRawSystemPrompt(agent.system) && (memfsEnabled ? memfsRevision !== null && existing.memfsRevision === memfsRevision : existing.memfsRevision === undefined)) {
         return existing;
       }
       return this.compileAndMaybePersistSystemPrompt(conversationId, agentId, {
@@ -119552,7 +120279,10 @@ var init_LocalBackend = __esm(() => {
     }
     async compileAndMaybePersistSystemPrompt(conversationId, agentId, options) {
       const agent = this.store.retrieveAgentRecord(agentId);
-      await this.ensureLocalMemoryRepo(agentId, [], agent.name);
+      const memfsEnabled = this.isLocalMemfsEnabled();
+      if (memfsEnabled) {
+        await this.ensureLocalMemoryRepo(agentId, [], agent.name);
+      }
       const previousMessageCount = options.previousMessageCount ?? this.store.listConversationMessages(conversationId, {
         agent_id: agentId,
         order: "asc"
@@ -119561,7 +120291,8 @@ var init_LocalBackend = __esm(() => {
         agent,
         conversationId,
         previousMessageCount,
-        memoryDir: this.memoryDirForAgent(agentId)
+        memoryDir: memfsEnabled ? this.memoryDirForAgent(agentId) : undefined,
+        includeMemfs: memfsEnabled
       });
       if (!options.dryRun) {
         this.store.setCompiledSystemPrompt(conversationId, agentId, compiled);
@@ -119571,6 +120302,22 @@ var init_LocalBackend = __esm(() => {
   };
 });
 
+// src/backend/api/conversations.ts
+var exports_conversations = {};
+__export(exports_conversations, {
+  forkConversation: () => forkConversation
+});
+async function forkConversation(conversationId, options = {}) {
+  const query = {
+    ...options.agentId ? { agent_id: options.agentId } : {},
+    ...options.hidden !== undefined ? { hidden: options.hidden } : {}
+  };
+  return apiRequest("POST", `/v1/conversations/${encodeURIComponent(conversationId)}/fork`, undefined, { query });
+}
+var init_conversations2 = __esm(() => {
+  init_request();
+});
+
 // src/backend/backend.ts
 import { homedir as homedir19 } from "node:os";
 
@@ -119717,6 +120464,7 @@ function getBackend() {
 }
 function configureBackendMode(mode) {
   configuredBackendMode = mode;
+  process.env[LOCAL_BACKEND_EXPERIMENTAL_ENV] = mode === "local" ? "1" : "0";
   backend = createBackendForMode(mode);
 }
 function isLocalBackendEnabled() {
@@ -143952,7 +144700,10 @@ function getTerminalTheme() {
   cachedTheme = detectTerminalThemeSync();
   return cachedTheme;
 }
-var cachedTheme = null;
+function getTerminalBackgroundColor() {
+  return cachedBackground;
+}
+var cachedTheme = null, cachedBackground = null;
 
 // src/cli/components/colors.ts
 function parseHex(hex3) {
@@ -143963,6 +144714,26 @@ function parseHex(hex3) {
     b: parseInt(h.slice(4, 6), 16)
   };
 }
+function rgbToHex({ r, g, b }) {
+  const toHex = (value) => value.toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function isLightRgb({ r, g, b }) {
+  return 0.299 * r + 0.587 * g + 0.114 * b > 128;
+}
+function blendRgb(fg, bg, alpha) {
+  return {
+    r: Math.floor(fg.r * alpha + bg.r * (1 - alpha)),
+    g: Math.floor(fg.g * alpha + bg.g * (1 - alpha)),
+    b: Math.floor(fg.b * alpha + bg.b * (1 - alpha))
+  };
+}
+function getCodexUserMessageBackground() {
+  const theme = getTerminalTheme();
+  const terminalBg = getTerminalBackgroundColor() ?? (theme === "light" ? { r: 255, g: 255, b: 255 } : { r: 0, g: 0, b: 0 });
+  const overlay = isLightRgb(terminalBg) ? { color: { r: 0, g: 0, b: 0 }, alpha: 0.04 } : { color: { r: 255, g: 255, b: 255 }, alpha: 0.12 };
+  return rgbToHex(blendRgb(overlay.color, terminalBg, overlay.alpha));
+}
 function hexToBgAnsi(hex3) {
   const { r, g, b } = parseHex(hex3);
   return `\x1B[48;2;${r};${g};${b}m`;
@@ -144135,9 +144906,8 @@ var init_colors = __esm(() => {
       return getTerminalTheme() === "light" ? _colors.shellSyntaxLight : _colors.shellSyntaxDark;
     },
     get userMessage() {
-      const theme = getTerminalTheme();
       return {
-        background: theme === "light" ? "#dcddf2" : "#2d2d2d",
+        background: getCodexUserMessageBackground(),
         text: undefined
       };
     }
@@ -145758,6 +146528,8 @@ function toTildePath(absolutePath) {
   return absolutePath;
 }
 function getInitialAuthMethod() {
+  if (isLocalBackendEnabled())
+    return "local";
   if (process.env.LETTA_BASE_URL)
     return "url";
   if (process.env.LETTA_API_KEY)
@@ -145765,6 +146537,8 @@ function getInitialAuthMethod() {
   return null;
 }
 async function getAuthMethod() {
+  if (isLocalBackendEnabled())
+    return "local";
   if (process.env.LETTA_BASE_URL) {
     return "url";
   }
@@ -145800,7 +146574,7 @@ function WelcomeScreen({
       getAuthMethod().then(setAuthMethod);
     }
   }, [initialAuth]);
-  const authDisplay = authMethod === "url" ? process.env.LETTA_BASE_URL || "Custom URL" : authMethod === "api-key" ? "API key auth" : "OAuth";
+  const authDisplay = authMethod === "local" ? "Local" : authMethod === "url" ? process.env.LETTA_BASE_URL || "Custom URL" : authMethod === "api-key" ? "API key auth" : "OAuth";
   const memfsEnabled = agentState?.id ? settingsManager.isMemfsEnabled(agentState.id) : true;
   return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
     flexDirection: "row",
@@ -145870,6 +146644,7 @@ function getLoadingMessage(loadingState, continueSession) {
 var import_react25, jsx_dev_runtime6;
 var init_WelcomeScreen = __esm(async () => {
   init_model();
+  init_backend2();
   init_settings_manager();
   init_version();
   init_useTerminalWidth();
@@ -146686,7 +147461,7 @@ var init_accountConfig3 = __esm(() => {
 });
 
 // src/channels/accountConfig.ts
-function isRecord8(value) {
+function isRecord11(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getChannelAccountConfigAdapter(channelId) {
@@ -146697,7 +147472,7 @@ function getChannelPluginConfig(input, key = "config") {
   if (value === undefined) {
     return {};
   }
-  return isRecord8(value) ? value : null;
+  return isRecord11(value) ? value : null;
 }
 function isValidChannelPluginConfigPayload(channelId, input, key = "config") {
   const config2 = getChannelPluginConfig(input, key);
@@ -152028,6 +152803,15 @@ function shouldRetryRunMetadataError(errorType, detail) {
     return true;
   return retryable429Detail || retryableDetail;
 }
+function normalizeStreamErrorTypeToStopReason(errorType) {
+  if (errorType === "llm_error" || errorType === "llm_api_error") {
+    return "llm_api_error";
+  }
+  if (errorType === "internal_error" || errorType === "stream_incomplete") {
+    return "error";
+  }
+  return "error";
+}
 function isEmptyResponseRetryable(errorType, detail, emptyResponseRetries, maxEmptyResponseRetries) {
   if (emptyResponseRetries >= maxEmptyResponseRetries)
     return false;
@@ -152894,6 +153678,13 @@ var init_approval_result_normalization = __esm(() => {
 });
 
 // src/agent/clientSkills.ts
+var exports_clientSkills = {};
+__export(exports_clientSkills, {
+  invalidateClientSkillsPayloadCacheForAgent: () => invalidateClientSkillsPayloadCacheForAgent,
+  invalidateClientSkillsPayloadCache: () => invalidateClientSkillsPayloadCache,
+  discoverClientSideSkills: () => discoverClientSideSkills,
+  buildClientSkillsPayload: () => buildClientSkillsPayload
+});
 import { existsSync as existsSync32, readdirSync as readdirSync11, realpathSync as realpathSync3, statSync as statSync8 } from "node:fs";
 import { join as join34 } from "node:path";
 function getCache2() {
@@ -152988,6 +153779,17 @@ function cloneResult(result) {
     errors: result.errors.map((e) => ({ ...e }))
   };
 }
+function invalidateClientSkillsPayloadCache() {
+  getCache2().clear();
+}
+function invalidateClientSkillsPayloadCacheForAgent(agentId) {
+  const cache5 = getCache2();
+  for (const [k, entry] of cache5) {
+    if (entry.key.startsWith(`${agentId}|`) || k.startsWith(`${agentId}|`)) {
+      cache5.delete(k);
+    }
+  }
+}
 function getMemorySkillsDirs2(agentId) {
   const dirs = new Set;
   const scopedMemoryDir = resolveScopedMemoryDir({ agentId });
@@ -153043,56 +153845,28 @@ function resolveSkillDiscoveryContext(options) {
 function getPrimaryProjectSkillsDirectory() {
   return join34(process.cwd(), ".agents", "skills");
 }
-async function buildClientSkillsPayload(options = {}) {
-  const { legacySkillsDirectory, skillSources } = resolveSkillDiscoveryContext(options);
+async function collectClientSideSkills(options) {
   const discoverSkillsFn = options.discoverSkillsFn ?? discoverSkills;
-  const useCache = !options.discoverSkillsFn;
-  const cwd2 = process.cwd();
-  const primaryProjectSkillsDirectory = getPrimaryProjectSkillsDirectory();
-  const memorySkillsDirs = getMemorySkillsDirs2(options.agentId);
-  const cacheComponents = {
-    agentId: options.agentId,
-    skillSources,
-    cwd: cwd2,
-    legacySkillsDirectory,
-    primaryProjectSkillsDirectory,
-    memorySkillsDirs,
-    skillRootRevisions: getSkillRootRevisions({
-      agentId: options.agentId,
-      skillSources,
-      legacySkillsDirectory,
-      primaryProjectSkillsDirectory,
-      memorySkillsDirs
-    })
-  };
-  const cacheKey = computeCacheKey(cacheComponents);
-  if (useCache) {
-    const cache5 = getCache2();
-    const cached2 = cache5.get(cacheKey);
-    if (cached2) {
-      return cloneResult(cached2.result);
-    }
-  }
   const skillsById = new Map;
   const errors4 = [];
-  const nonProjectSources = skillSources.filter((source) => source !== "project");
+  const nonProjectSources = options.skillSources?.filter((source) => source !== "project") ?? [];
   const discoveryRuns = [];
   if (nonProjectSources.length > 0) {
     discoveryRuns.push({
-      path: primaryProjectSkillsDirectory,
+      path: options.primaryProjectSkillsDirectory,
       sources: nonProjectSources
     });
   }
-  const includeProjectSource = skillSources.includes("project");
-  if (includeProjectSource && legacySkillsDirectory !== primaryProjectSkillsDirectory) {
+  const includeProjectSource = options.skillSources?.includes("project") ?? false;
+  if (includeProjectSource && options.legacySkillsDirectory !== options.primaryProjectSkillsDirectory) {
     discoveryRuns.push({
-      path: legacySkillsDirectory,
+      path: options.legacySkillsDirectory,
       sources: ["project"]
     });
   }
   if (includeProjectSource) {
     discoveryRuns.push({
-      path: primaryProjectSkillsDirectory,
+      path: options.primaryProjectSkillsDirectory,
       sources: ["project"]
     });
   }
@@ -153110,7 +153884,7 @@ async function buildClientSkillsPayload(options = {}) {
       errors4.push({ path: run.path, message });
     }
   }
-  if (skillSources.length > 0) {
+  if ((options.skillSources?.length ?? 0) > 0) {
     const memoryDiscovery = await discoverMemorySkills(options.agentId);
     errors4.push(...memoryDiscovery.errors);
     for (const skill2 of memoryDiscovery.skills) {
@@ -153121,7 +153895,59 @@ async function buildClientSkillsPayload(options = {}) {
       skillsById.set(skill2.id, skill2);
     }
   }
-  const sortedSkills = [...skillsById.values()].sort(compareSkills);
+  return {
+    skills: [...skillsById.values()].sort(compareSkills),
+    errors: errors4
+  };
+}
+async function discoverClientSideSkills(options = {}) {
+  const { legacySkillsDirectory, skillSources } = resolveSkillDiscoveryContext(options);
+  return collectClientSideSkills({
+    ...options,
+    legacySkillsDirectory,
+    skillSources,
+    primaryProjectSkillsDirectory: getPrimaryProjectSkillsDirectory()
+  });
+}
+async function buildClientSkillsPayload(options = {}) {
+  const { legacySkillsDirectory, skillSources } = resolveSkillDiscoveryContext(options);
+  const discoverSkillsFn = options.discoverSkillsFn ?? discoverSkills;
+  const useCache = !options.discoverSkillsFn;
+  const cwd2 = process.cwd();
+  const primaryProjectSkillsDirectory = getPrimaryProjectSkillsDirectory();
+  const memorySkillsDirs = getMemorySkillsDirs2(options.agentId);
+  const cacheComponents = {
+    agentId: options.agentId,
+    skillSources,
+    cwd: cwd2,
+    legacySkillsDirectory,
+    primaryProjectSkillsDirectory,
+    memorySkillsDirs,
+    skillRootRevisions: getSkillRootRevisions({
+      agentId: options.agentId,
+      skillSources,
+      legacySkillsDirectory,
+      primaryProjectSkillsDirectory,
+      memorySkillsDirs
+    })
+  };
+  const cacheKey = computeCacheKey(cacheComponents);
+  if (useCache) {
+    const cache5 = getCache2();
+    const cached2 = cache5.get(cacheKey);
+    if (cached2) {
+      return cloneResult(cached2.result);
+    }
+  }
+  const discovery = await collectClientSideSkills({
+    ...options,
+    legacySkillsDirectory,
+    skillSources,
+    primaryProjectSkillsDirectory,
+    discoverSkillsFn
+  });
+  const errors4 = discovery.errors;
+  const sortedSkills = discovery.skills.filter(isModelInvocableSkill);
   if (errors4.length > 0) {
     const summarizedErrors = errors4.map((error51) => `${error51.path}: ${error51.message}`);
     options.logger?.(`Failed to build some client_skills entries: ${summarizedErrors.join("; ")}`);
@@ -154008,7 +154834,7 @@ function markIncompleteToolsAsCancelled(b, setInterruptedFlag = true, reason = "
   }
   return anyToolsCancelled;
 }
-function isRecord9(v) {
+function isRecord12(v) {
   return v !== null && typeof v === "object";
 }
 function getStringProp(obj, key) {
@@ -154019,9 +154845,9 @@ function extractTextPart(v) {
   if (typeof v === "string")
     return v;
   if (Array.isArray(v)) {
-    return v.map((p) => isRecord9(p) ? getStringProp(p, "text") ?? "" : "").join("");
+    return v.map((p) => isRecord12(p) ? getStringProp(p, "text") ?? "" : "").join("");
   }
-  if (isRecord9(v)) {
+  if (isRecord12(v)) {
     return getStringProp(v, "text") ?? getStringProp(v, "delta") ?? "";
   }
   return "";
@@ -155941,13 +156767,13 @@ function buildAgentInfo(options) {
     }
     const showMemoryDir = (() => {
       try {
-        return settingsManager.isMemfsEnabled(agentInfo.id);
+        return isLocalBackendEnvEnabled() || settingsManager.isMemfsEnabled(agentInfo.id);
       } catch {
         return false;
       }
     })();
     const memoryDirLine = showMemoryDir ? `
-- **Memory directory (also stored in \`MEMORY_DIR\` env var)**: \`${getMemoryFilesystemRoot(agentInfo.id)}\`` : "";
+- **Memory directory (also stored in \`MEMORY_DIR\` env var)**: \`${getScopedMemoryFilesystemRoot(agentInfo.id)}\`` : "";
     const convLine = conversationId ? `
 - **Conversation ID (also stored in \`CONVERSATION_ID\` env var)**: ${conversationId}` : "";
     return `${SYSTEM_REMINDER_OPEN} This is an automated message providing information about you.
@@ -155962,6 +156788,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
 }
 var init_agentInfo = __esm(() => {
   init_memoryFilesystem();
+  init_paths();
   init_constants();
   init_settings_manager();
 });
@@ -158144,6 +158971,9 @@ function getApprovalToolCallDesyncErrorText(errorInfo) {
   }
   return null;
 }
+function isBackendNotFoundError(error51) {
+  return error51 instanceof APIError2 && (error51.status === 404 || error51.status === 422) || error51 instanceof Error && error51.name === "LocalBackendNotFoundError";
+}
 function shouldAttemptPostStopApprovalRecovery(params) {
   const approvalDesyncDetected = isApprovalToolCallDesyncError(params.runErrorDetail) || isApprovalToolCallDesyncError(params.latestErrorText) || isApprovalToolCallDesyncError(params.fallbackError);
   return shouldAttemptApprovalRecovery({
@@ -158201,7 +159031,7 @@ async function drainRecoveryStreamWithEmission(recoveryStream, socket, runtime,
     if (errorInfo) {
       emitLoopErrorNotice(socket, runtime, {
         message: errorInfo.message || "Stream error",
-        stopReason: errorInfo.error_type || "error",
+        stopReason: normalizeStreamErrorTypeToStopReason(errorInfo.error_type),
         isTerminal: false,
         runId: runtime.activeRunId || errorInfo.run_id,
         agentId: params.agentId ?? undefined,
@@ -158275,12 +159105,12 @@ async function debugLogApprovalResumeState(runtime, params) {
     return;
   }
   try {
-    const client = await getClient();
-    const agent = await client.agents.retrieve(params.agentId);
+    const backend4 = getBackend();
+    const agent = await backend4.retrieveAgent(params.agentId);
     const isExplicitConversation = params.conversationId.length > 0 && params.conversationId !== "default";
-    const lastInContextId = isExplicitConversation ? (await client.conversations.retrieve(params.conversationId)).in_context_message_ids?.at(-1) ?? null : agent.message_ids?.at(-1) ?? null;
-    const lastInContextMessages = lastInContextId ? await client.messages.retrieve(lastInContextId) : [];
-    const resumeData = await getResumeData(client, agent, params.conversationId, {
+    const lastInContextId = isExplicitConversation ? (await backend4.retrieveConversation(params.conversationId)).in_context_message_ids?.at(-1) ?? null : agent.message_ids?.at(-1) ?? null;
+    const lastInContextMessages = lastInContextId ? await backend4.retrieveMessage(lastInContextId) : [];
+    const resumeData = await getResumeDataFromBackend2(agent, params.conversationId, {
       includeMessageHistory: false
     });
     console.log("[Listen][DEBUG] Post-approval continuation resume snapshot", JSON.stringify({
@@ -158323,12 +159153,12 @@ async function recoverApprovalStateForSync(runtime, scope) {
     clearRecoveredApprovalState(runtime);
     return;
   }
-  const client = await getClient();
+  const backend4 = getBackend();
   let agent;
   try {
-    agent = await client.agents.retrieve(scope.agent_id);
+    agent = await backend4.retrieveAgent(scope.agent_id);
   } catch (error51) {
-    if (error51 instanceof APIError2 && (error51.status === 404 || error51.status === 422)) {
+    if (isBackendNotFoundError(error51)) {
       clearRecoveredApprovalState(runtime);
       return;
     }
@@ -158336,11 +159166,11 @@ async function recoverApprovalStateForSync(runtime, scope) {
   }
   let resumeData;
   try {
-    resumeData = await getResumeData(client, agent, scope.conversation_id, {
+    resumeData = await getResumeDataFromBackend2(agent, scope.conversation_id, {
       includeMessageHistory: false
     });
   } catch (error51) {
-    if (error51 instanceof APIError2 && (error51.status === 404 || error51.status === 422)) {
+    if (isBackendNotFoundError(error51)) {
       clearRecoveredApprovalState(runtime);
       return;
     }
@@ -158496,7 +159326,8 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
         parentScope: recovered.agentId && recovered.conversationId ? {
           agentId: recovered.agentId,
           conversationId: recovered.conversationId
-        } : undefined
+        } : undefined,
+        channelTurnSources: runtime.activeChannelTurnSources ?? undefined
       });
     } finally {
       emitToolExecutionOutput.flush();
@@ -158554,7 +159385,6 @@ var init_recovery = __esm(async () => {
   init_check_approval();
   init_turn_recovery_policy();
   init_backend2();
-  init_client2();
   init_formatDenial();
   init_interactivePolicy();
   init_constants2();
@@ -158606,16 +159436,19 @@ function markAwaitingAcceptedApprovalContinuationRunId(runtime, input) {
     runtime.activeRunId = null;
   }
 }
+function isBackendNotFoundError2(err) {
+  return err instanceof APIError2 && (err.status === 404 || err.status === 422) || err instanceof Error && err.name === "LocalBackendNotFoundError";
+}
 async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
   if (!runtime.agentId)
     return null;
-  const getResumeDataImpl = deps.getResumeData ?? getResumeData;
-  const client = await getClient();
+  const getResumeDataImpl = deps.getResumeData ?? getResumeDataFromBackend2;
+  const backend4 = getBackend();
   let agent;
   try {
-    agent = await client.agents.retrieve(runtime.agentId);
+    agent = await backend4.retrieveAgent(runtime.agentId);
   } catch (err) {
-    if (err instanceof APIError2 && (err.status === 404 || err.status === 422)) {
+    if (isBackendNotFoundError2(err)) {
       return null;
     }
     throw err;
@@ -158623,11 +159456,11 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
   const requestedConversationId = runtime.conversationId !== "default" ? runtime.conversationId : undefined;
   let resumeData;
   try {
-    resumeData = await getResumeDataImpl(client, agent, requestedConversationId, {
+    resumeData = await getResumeDataImpl(agent, requestedConversationId, {
       includeMessageHistory: false
     });
   } catch (err) {
-    if (err instanceof APIError2 && (err.status === 404 || err.status === 422)) {
+    if (isBackendNotFoundError2(err)) {
       return null;
     }
     throw err;
@@ -158993,7 +159826,6 @@ var init_send = __esm(async () => {
   init_check_approval();
   init_turn_recovery_policy();
   init_backend2();
-  init_client2();
   init_errorFormatter();
   init_streamAbortRelay();
   init_constants2();
@@ -160748,7 +161580,7 @@ function formatArgsDisplay(argsJson, toolName) {
   try {
     if (argsJson?.trim()) {
       const p = JSON.parse(argsJson);
-      if (isRecord10(p)) {
+      if (isRecord13(p)) {
         const clone2 = { ...p };
         if ("request_heartbeat" in clone2)
           delete clone2.request_heartbeat;
@@ -160869,7 +161701,7 @@ function formatArgsDisplay(argsJson, toolName) {
   }
   return { display, parsed, shellSemantic };
 }
-var isRecord10 = (v) => typeof v === "object" && v !== null;
+var isRecord13 = (v) => typeof v === "object" && v !== null;
 var init_formatArgsDisplay = __esm(async () => {
   init_shellSemanticDisplay();
   await init_toolNameMapping();
@@ -161366,6 +162198,7 @@ async function handleApprovalStop(params) {
       onStreamingOutput: emitToolExecutionOutput,
       workingDirectory: turnWorkingDirectory,
       parentScope: agentId && conversationId ? { agentId, conversationId } : undefined,
+      channelTurnSources: runtime.activeChannelTurnSources ?? undefined,
       onFileWrite
     });
   } finally {
@@ -161491,9 +162324,8 @@ var init_turn_approval = __esm(async () => {
 
 // src/websocket/listener/memfs-sync.ts
 async function syncMemfsForAgent(agentId) {
-  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-  const client = await getClient2();
-  const agent = await client.agents.retrieve(agentId);
+  const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+  const agent = await getBackend2().retrieveAgent(agentId);
   const { GIT_MEMORY_ENABLED_TAG: GIT_MEMORY_ENABLED_TAG2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
   if (!agent.tags?.includes(GIT_MEMORY_ENABLED_TAG2)) {
     debugLog("memfs-sync", `Agent ${agentId} does not have memfs tag, skipping`);
@@ -161530,8 +162362,7 @@ function getAgentMetadataPromise(listener, agentId) {
   return listener.agentMetadataByAgent.get(agentId) ?? null;
 }
 async function fetchListenerAgentMetadata(agentId) {
-  const client = await getClient();
-  const agent = await client.agents.retrieve(agentId);
+  const agent = await getBackend().retrieveAgent(agentId);
   return {
     name: agent.name ?? null,
     description: agent.description ?? null,
@@ -161584,7 +162415,7 @@ function clearListenerWarmState(listener) {
 }
 var defaultWarmupDeps, warmupDeps;
 var init_warmup = __esm(() => {
-  init_client2();
+  init_backend2();
   init_debug();
   init_memfs_sync();
   init_secrets_sync();
@@ -161641,8 +162472,7 @@ function buildMaybeLaunchReflectionSubagent(params) {
       let systemPrompt = cachedAgent?.system ?? undefined;
       if (!systemPrompt) {
         try {
-          const client = await getClient();
-          const agent = await client.agents.retrieve(agentId);
+          const agent = await getBackend().retrieveAgent(agentId);
           systemPrompt = agent.system ?? undefined;
         } catch {
           debugLog("memory", "Failed to fetch agent system prompt for reflection payload");
@@ -161819,8 +162649,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         syncReminderStateFromContextTracker(runtime.reminderState, runtime.contextTracker);
         if (agentId) {
           try {
-            const client = await getClient();
-            cachedAgent = await client.agents.retrieve(agentId);
+            cachedAgent = await getBackend().retrieveAgent(agentId);
           } catch {}
         }
         if (!runtime.reminderState.hasSentAgentInfo && cachedAgent) {
@@ -161943,7 +162772,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           if (!recoverableApprovalErrorText) {
             emitLoopErrorNotice(socket, runtime, {
               message: errorInfo.message || "Stream error",
-              stopReason: errorInfo.error_type || "error",
+              stopReason: normalizeStreamErrorTypeToStopReason(errorInfo.error_type),
               isTerminal: false,
               runId: runId || errorInfo.run_id,
               agentId,
@@ -162034,9 +162863,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             conversationId
           });
           try {
-            const client = await getClient();
-            const agent = await client.agents.retrieve(agentId || "");
-            const { pendingApprovals: existingApprovals } = await getResumeData(client, agent, requestedConversationId);
+            const agent = await getBackend().retrieveAgent(agentId || "");
+            const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend2(agent, requestedConversationId);
             currentInput = rebuildInputWithFreshDenials(currentInput, existingApprovals ?? [], "Auto-denied: stale approval from interrupted session");
           } catch {
             currentInput = rebuildInputWithFreshDenials(currentInput, [], "");
@@ -162320,7 +163148,7 @@ var init_turn = __esm(async () => {
   init_context();
   init_memoryFilesystem();
   init_turn_recovery_policy();
-  init_client2();
+  init_backend2();
   init_errorFormatter();
   init_memoryReminder();
   init_memorySubagentCompletion();
@@ -162427,17 +163255,19 @@ function emitSlashCommandEnd(socket, runtime, scope, fields) {
   emitCanonicalMessageDelta(socket, runtime, endDelta, scope);
 }
 async function handleClearCommand(_socket, conversationRuntime, opts) {
-  const client = await getClient();
+  const backend4 = getBackend();
   const agentId = conversationRuntime.agentId;
   if (!agentId) {
     throw new Error("No agent ID available for /clear command");
   }
-  if (conversationRuntime.conversationId === "default") {
+  if (conversationRuntime.conversationId === "default" && !backend4.capabilities.localModelCatalog) {
+    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+    const client = await getClient2();
     await client.agents.messages.reset(agentId, {
       add_default_initial_messages: false
     });
   }
-  const conversation = await client.conversations.create({
+  const conversation = await backend4.createConversation({
     agent_id: agentId,
     isolated_block_labels: [...ISOLATED_BLOCK_LABELS]
   });
@@ -162635,7 +163465,7 @@ var init_commands = __esm(async () => {
   init_memory();
   init_memoryFilesystem();
   init_promptAssets();
-  init_client2();
+  init_backend2();
   init_initCommand();
   init_constants();
   init_settings_manager();
@@ -164018,6 +164848,16 @@ function isExecuteCommandCommand(value) {
   const hasValidArgs = c.args === undefined || typeof c.args === "string";
   return c.type === "execute_command" && typeof c.command_id === "string" && typeof c.request_id === "string" && isRuntimeScope(c.runtime) && hasValidArgs;
 }
+function parseServerLifecycleMessage(data) {
+  try {
+    const raw = typeof data === "string" ? data : data.toString();
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.type === "pong") {
+      return { type: "pong" };
+    }
+  } catch {}
+  return null;
+}
 function parseServerMessage(data) {
   try {
     const raw = typeof data === "string" ? data : data.toString();
@@ -165513,11 +166353,12 @@ function handleMemoryProtocolCommand(parsed, context4) {
         const buffer = encoding === "base64" ? Buffer.from(parsed.content, "base64") : Buffer.from(parsed.content, "utf-8");
         await mkdir9(dirname20(absolutePath), { recursive: true });
         await writeFile11(absolutePath, buffer);
+        const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+        const backend4 = getBackend2();
+        const memorySyncMode = backend4.capabilities.localMemfs && !backend4.capabilities.remoteMemfs ? "local" : undefined;
         let agentName = parsed.agent_id;
         try {
-          const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-          const client = await getClient2();
-          const agent = await client.agents.retrieve(parsed.agent_id);
+          const agent = await backend4.retrieveAgent(parsed.agent_id);
           if (agent.name && agent.name.trim().length > 0) {
             agentName = agent.name.trim();
           }
@@ -165533,6 +166374,7 @@ function handleMemoryProtocolCommand(parsed, context4) {
             authorName: agentName,
             authorEmail: `${parsed.agent_id}@letta.com`
           },
+          ...memorySyncMode ? { syncMode: memorySyncMode } : {},
           replay: async () => {
             await mkdir9(dirname20(absolutePath), { recursive: true });
             await writeFile11(absolutePath, buffer);
@@ -165627,11 +166469,12 @@ function handleMemoryProtocolCommand(parsed, context4) {
           }, "listener_delete_memory_file_send_failed", "listener_delete_memory_file");
           return;
         }
+        const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+        const backend4 = getBackend2();
+        const memorySyncMode = backend4.capabilities.localMemfs && !backend4.capabilities.remoteMemfs ? "local" : undefined;
         let agentName = parsed.agent_id;
         try {
-          const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-          const client = await getClient2();
-          const agent = await client.agents.retrieve(parsed.agent_id);
+          const agent = await backend4.retrieveAgent(parsed.agent_id);
           if (agent.name && agent.name.trim().length > 0) {
             agentName = agent.name.trim();
           }
@@ -165646,6 +166489,7 @@ function handleMemoryProtocolCommand(parsed, context4) {
             authorName: agentName,
             authorEmail: `${parsed.agent_id}@letta.com`
           },
+          ...memorySyncMode ? { syncMode: memorySyncMode } : {},
           replay: async () => {
             await removeIfPresent();
             return [pathspec];
@@ -168175,6 +169019,11 @@ function createListenerMessageHandler(params) {
     const raw = data.toString();
     let parsedScope = null;
     try {
+      const lifecycleMessage = parseServerLifecycleMessage(data);
+      if (lifecycleMessage) {
+        safeEmitWsEvent("recv", "lifecycle", lifecycleMessage);
+        return;
+      }
       const parsed = parseServerMessage(data);
       parsedScope = getParsedRuntimeScope(parsed);
       if (parsed) {
@@ -169496,6 +170345,178 @@ var init_listen_client = __esm(async () => {
   await init_client4();
 });
 
+// src/backend/api/search.ts
+async function warmSearchCache(body) {
+  return apiRequest("POST", "/v1/_internal_search/cache-warm", body);
+}
+async function searchMessages(body) {
+  return apiRequest("POST", "/v1/messages/search", body);
+}
+var init_search = __esm(() => {
+  init_request();
+});
+
+// src/backend/messageSearch.ts
+function pageItems(page) {
+  if (Array.isArray(page))
+    return page;
+  if (page && typeof page === "object") {
+    const maybePage = page;
+    if (typeof maybePage.getPaginatedItems === "function") {
+      return maybePage.getPaginatedItems();
+    }
+    if (Array.isArray(maybePage.items)) {
+      return maybePage.items;
+    }
+  }
+  return [];
+}
+function textFromContent2(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => {
+    if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+      return part.text;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+function stringifySearchValue(value) {
+  if (typeof value === "string")
+    return value;
+  if (value === null || value === undefined)
+    return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function searchableText(message) {
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : message.tool_call ? [message.tool_call] : [];
+  return [
+    message.message_type,
+    textFromContent2(message.content),
+    message.reasoning,
+    message.summary,
+    ...toolCalls.flatMap((call) => [call.name, call.arguments]),
+    stringifySearchValue(message.tool_return),
+    stringifySearchValue(message.func_response)
+  ].filter((part) => typeof part === "string" && part.length > 0).join(`
+`);
+}
+function matchesQuery(message, query) {
+  const terms = query.toLowerCase().split(/\s+/).map((term) => term.trim()).filter(Boolean);
+  if (terms.length === 0)
+    return false;
+  const haystack = searchableText(message).toLowerCase();
+  return terms.every((term) => haystack.includes(term));
+}
+function withinDateRange(message, startDate, endDate) {
+  if (!startDate && !endDate)
+    return true;
+  if (!message.date)
+    return true;
+  const time3 = new Date(message.date).getTime();
+  if (Number.isNaN(time3))
+    return true;
+  const startTime = startDate ? new Date(startDate).getTime() : 0;
+  const endTime = endDate ? new Date(endDate).getTime() : Number.POSITIVE_INFINITY;
+  return time3 >= startTime && time3 <= endTime;
+}
+function toSearchResult(message) {
+  const createdAt = message.date ?? new Date(0).toISOString();
+  return {
+    ...message,
+    message_id: message.id ?? `${message.agent_id ?? "local"}:${createdAt}`,
+    created_at: createdAt,
+    agent_id: message.agent_id ?? null,
+    conversation_id: message.conversation_id ?? null
+  };
+}
+async function localConversationMessages(backend4, conversationId, agentId) {
+  try {
+    const page = await backend4.listConversationMessages(conversationId, {
+      limit: LOCAL_SEARCH_SCAN_LIMIT,
+      order: "desc",
+      ...agentId ? { agent_id: agentId } : {}
+    });
+    return pageItems(page);
+  } catch {
+    return [];
+  }
+}
+async function localAgentMessages(backend4, agentId) {
+  const messages = [
+    ...await localConversationMessages(backend4, "default", agentId)
+  ];
+  try {
+    const conversationsPage = await backend4.listConversations({
+      agent_id: agentId,
+      limit: LOCAL_SEARCH_SCAN_LIMIT
+    });
+    const conversations = pageItems(conversationsPage);
+    for (const conversation of conversations) {
+      if (!conversation.id || conversation.id === "default")
+        continue;
+      messages.push(...await localConversationMessages(backend4, conversation.id, agentId));
+    }
+  } catch {}
+  return messages;
+}
+async function localSearchMessages(backend4, body) {
+  const query = typeof body.query === "string" ? body.query.trim() : "";
+  if (!query)
+    return [];
+  const limit2 = typeof body.limit === "number" ? body.limit : 100;
+  const agentId = typeof body.agent_id === "string" ? body.agent_id : undefined;
+  const conversationId = typeof body.conversation_id === "string" ? body.conversation_id : undefined;
+  const startDate = typeof body.start_date === "string" ? body.start_date : undefined;
+  const endDate = typeof body.end_date === "string" ? body.end_date : undefined;
+  let messages = [];
+  if (conversationId) {
+    messages = await localConversationMessages(backend4, conversationId, agentId);
+  } else if (agentId) {
+    messages = await localAgentMessages(backend4, agentId);
+  } else {
+    const agentsPage = await backend4.listAgents({
+      limit: LOCAL_SEARCH_SCAN_LIMIT
+    });
+    const agents = pageItems(agentsPage);
+    for (const agent of agents) {
+      messages.push(...await localAgentMessages(backend4, agent.id));
+    }
+  }
+  return messages.filter((message) => matchesQuery(message, query)).filter((message) => withinDateRange(message, startDate, endDate)).sort((a, b) => (b.date ?? "").localeCompare(a.date ?? "")).slice(0, limit2).map(toSearchResult);
+}
+async function searchMessagesForBackend(body, backend4 = getBackend()) {
+  if (backend4.capabilities.localModelCatalog) {
+    return await localSearchMessages(backend4, body);
+  }
+  return searchMessages({
+    ...body,
+    search_mode: body.search_mode === "vector" || body.search_mode === "fts" || body.search_mode === "hybrid" ? body.search_mode : body.search_mode
+  });
+}
+async function warmMessageSearchCacheForBackend(body, backend4 = getBackend()) {
+  if (backend4.capabilities.localModelCatalog) {
+    return {
+      collection: body.collection ?? "messages",
+      status: "local-backend-noop",
+      warmed: false
+    };
+  }
+  return warmSearchCache(body);
+}
+var LOCAL_SEARCH_SCAN_LIMIT = 1000;
+var init_messageSearch = __esm(() => {
+  init_search();
+  init_backend();
+});
+
 // src/utils/debug.ts
 var exports_debug2 = {};
 __export(exports_debug2, {
@@ -169637,6 +170658,12 @@ var init_version2 = __esm(() => {
 // src/agent/skills.ts
 var exports_skills2 = {};
 __export(exports_skills2, {
+  isUserInvocableSkill: () => isUserInvocableSkill2,
+  isModelInvocableSkill: () => isModelInvocableSkill2,
+  getLegacyAgentSkillsDir: () => getLegacyAgentSkillsDir2,
+  getFrontmatterStringList: () => getFrontmatterStringList2,
+  getFrontmatterString: () => getFrontmatterString2,
+  getFrontmatterBoolean: () => getFrontmatterBoolean2,
   getBundledSkills: () => getBundledSkills2,
   getAgentSkillsDir: () => getAgentSkillsDir2,
   formatSkillsAsSystemReminder: () => formatSkillsAsSystemReminder2,
@@ -169659,7 +170686,45 @@ function getBundledSkillsPath2() {
 function compareSkills2(a, b) {
   return a.id.localeCompare(b.id) || a.source.localeCompare(b.source) || a.path.localeCompare(b.path);
 }
+function stripSurroundingQuotes2(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function getFrontmatterString2(frontmatter, key) {
+  const value = frontmatter[key];
+  return typeof value === "string" ? stripSurroundingQuotes2(value) : undefined;
+}
+function getFrontmatterStringList2(frontmatter, key) {
+  const value = frontmatter[key];
+  if (Array.isArray(value)) {
+    return value.map(stripSurroundingQuotes2).filter((item) => item.length > 0);
+  }
+  if (typeof value === "string") {
+    return stripSurroundingQuotes2(value).split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  return;
+}
+function getFrontmatterBoolean2(frontmatter, key) {
+  const value = getFrontmatterString2(frontmatter, key)?.toLowerCase();
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  return;
+}
+function isModelInvocableSkill2(skill2) {
+  return skill2.disableModelInvocation !== true;
+}
+function isUserInvocableSkill2(skill2) {
+  return skill2.userInvocable !== false;
+}
 function getAgentSkillsDir2(agentId) {
+  return join42(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
+}
+function getLegacyAgentSkillsDir2(agentId) {
   return join42(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills2() {
@@ -169702,6 +170767,12 @@ async function discoverSkills2(projectSkillsPath = join42(process.cwd(), SKILLS_
     }
   }
   if (agentId && includeSource("agent")) {
+    const legacyDir = getLegacyAgentSkillsDir2(agentId);
+    const legacyResult = await discoverSkillsFromDir2(legacyDir, "agent");
+    allErrors.push(...legacyResult.errors);
+    for (const skill2 of legacyResult.skills) {
+      skillsById.set(skill2.id, skill2);
+    }
     const agentSkillsDir = getAgentSkillsDir2(agentId);
     const agentResult = await discoverSkillsFromDir2(agentSkillsDir, "agent");
     allErrors.push(...agentResult.errors);
@@ -169785,7 +170856,7 @@ async function parseSkillFile2(filePath, rootPath, source) {
   const defaultId = dirPath || "root";
   const id = (typeof frontmatter.id === "string" ? frontmatter.id : null) || defaultId;
   const name25 = (typeof frontmatter.name === "string" ? frontmatter.name : null) || (typeof frontmatter.title === "string" ? frontmatter.title : null) || (id.split("/").pop() ?? "").replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
-  let description = typeof frontmatter.description === "string" ? frontmatter.description : null;
+  let description = getFrontmatterString2(frontmatter, "description") ?? null;
   if (!description) {
     const firstParagraph = body.trim().split(`
 
@@ -169793,30 +170864,31 @@ async function parseSkillFile2(filePath, rootPath, source) {
     description = firstParagraph || "No description available";
   }
   description = description.trim();
-  if (description.startsWith('"') && description.endsWith('"') || description.startsWith("'") && description.endsWith("'")) {
-    description = description.slice(1, -1);
-  }
-  let tags;
-  if (Array.isArray(frontmatter.tags)) {
-    tags = frontmatter.tags;
-  } else if (typeof frontmatter.tags === "string") {
-    tags = [frontmatter.tags];
-  }
+  const whenToUse = getFrontmatterString2(frontmatter, "when_to_use")?.trim();
+  const modelDescription = whenToUse ? `${description}
+
+When to use: ${whenToUse}` : description;
+  const tags = getFrontmatterStringList2(frontmatter, "tags");
   return {
     id,
     name: name25,
-    description,
-    category: typeof frontmatter.category === "string" ? frontmatter.category : undefined,
+    description: modelDescription,
+    whenToUse,
+    argumentHint: getFrontmatterString2(frontmatter, "argument-hint"),
+    arguments: getFrontmatterStringList2(frontmatter, "arguments"),
+    disableModelInvocation: getFrontmatterBoolean2(frontmatter, "disable-model-invocation") ?? false,
+    userInvocable: getFrontmatterBoolean2(frontmatter, "user-invocable") ?? true,
+    category: getFrontmatterString2(frontmatter, "category"),
     tags,
     path: filePath,
     source
   };
 }
 function formatSkillsAsSystemReminder2(skills) {
-  if (skills.length === 0) {
+  const lines = skills.filter(isModelInvocableSkill2).sort(compareSkills2).map((s) => `- ${s.id} (${s.source}): ${s.description}`);
+  if (lines.length === 0) {
     return "";
   }
-  const lines = [...skills].sort(compareSkills2).map((s) => `- ${s.id} (${s.source}): ${s.description}`);
   return `<system-reminder>
 The following skills are available for use with the Skill tool:
 
@@ -169881,6 +170953,7 @@ __export(exports_terminalTheme, {
   parseHexComponent: () => parseHexComponent,
   initTerminalTheme: () => initTerminalTheme,
   getTerminalTheme: () => getTerminalTheme2,
+  getTerminalBackgroundColor: () => getTerminalBackgroundColor2,
   detectTerminalThemeSync: () => detectTerminalThemeSync2,
   detectTerminalThemeAsync: () => detectTerminalThemeAsync,
   calculateLuminance: () => calculateLuminance
@@ -169955,6 +171028,7 @@ function calculateLuminance(r, g, b) {
 async function detectTerminalThemeAsync() {
   const bg = await queryTerminalBackground(100);
   if (bg) {
+    cachedBackground2 = bg;
     const luminance = calculateLuminance(bg.r, bg.g, bg.b);
     return luminance > 0.4 ? "light" : "dark";
   }
@@ -169983,11 +171057,14 @@ function getTerminalTheme2() {
   cachedTheme2 = detectTerminalThemeSync2();
   return cachedTheme2;
 }
+function getTerminalBackgroundColor2() {
+  return cachedBackground2;
+}
 async function initTerminalTheme() {
   cachedTheme2 = await detectTerminalThemeAsync();
   return cachedTheme2;
 }
-var cachedTheme2 = null;
+var cachedTheme2 = null, cachedBackground2 = null;
 
 // src/agent/bootstrap-tools.ts
 var exports_bootstrap_tools = {};
@@ -172182,15 +173259,19 @@ In headless mode, use:
   const skillSourcesRaw = values["skill-sources"];
   const memfsFlag = values.memfs;
   const noMemfsFlag = values["no-memfs"];
+  const localNoMemfsRequested = Boolean(backend4.capabilities.localMemfs && (noMemfsFlag || isLocalBackendNoMemfsEnvEnabled()));
+  if (localNoMemfsRequested) {
+    process.env[LOCAL_BACKEND_NO_MEMFS_ENV] = "1";
+  }
   const memfsStartupRaw = values["memfs-startup"];
   const memfsStartupPolicy = memfsStartupRaw === "background" || memfsStartupRaw === "skip" ? memfsStartupRaw : "blocking";
-  const requestedMemoryPromptMode = memfsFlag ? "memfs" : noMemfsFlag ? "standard" : undefined;
+  const requestedMemoryPromptMode = memfsFlag ? "memfs" : noMemfsFlag || localNoMemfsRequested ? "standard" : undefined;
   if (memfsFlag && !backend4.capabilities.remoteMemfs) {
     trackHeadlessBoundaryError("headless_memfs_unsupported_backend", "MemFS requires a backend with remote MemFS support", "headless_startup_memfs_flags");
     console.error("Error: --memfs is not supported by this backend yet");
     process.exit(1);
   }
-  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !noMemfsFlag;
+  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !noMemfsFlag && !localNoMemfsRequested;
   const fromAfFile = resolveImportFlagAlias2({
     importFlagValue: values.import,
     fromAfFlagValue: values["from-af"]
@@ -172470,7 +173551,7 @@ In headless mode, use:
   if (!agent && forceNew) {
     const { isLettaCloud: isLettaCloud2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
     const willAutoEnableMemfs = backend4.capabilities.remoteMemfs && shouldAutoEnableMemfsForNewAgent && await isLettaCloud2();
-    const effectiveMemoryMode = backend4.capabilities.localMemfs ? "local-memfs" : requestedMemoryPromptMode ?? (willAutoEnableMemfs ? "memfs" : undefined);
+    const effectiveMemoryMode = backend4.capabilities.localMemfs ? localNoMemfsRequested ? "standard" : "local-memfs" : requestedMemoryPromptMode ?? (willAutoEnableMemfs ? "memfs" : undefined);
     const personalityOptions = personality ? await buildCreateAgentOptionsForPersonality2({
       personalityId: personality,
       model,
@@ -172572,12 +173653,8 @@ In headless mode, use:
   const secretsInitPromise = secretsAgentId ? Promise.resolve().then(() => (init_secretsStore(), exports_secretsStore)).then(({ initSecretsFromServer: initSecretsFromServer2 }) => initSecretsFromServer2(secretsAgentId, agent ?? undefined)) : Promise.resolve();
   if (!backend4.capabilities.remoteMemfs) {
     if (backend4.capabilities.localMemfs) {
-      if (noMemfsFlag) {
-        console.error("Disabling MemFS is not supported by the local backend.");
-        process.exit(1);
-      }
-      settingsManager.setMemfsEnabled(agent.id, true);
-    } else if (noMemfsFlag) {
+      settingsManager.setMemfsEnabled(agent.id, !localNoMemfsRequested);
+    } else if (noMemfsFlag || localNoMemfsRequested) {
       settingsManager.setMemfsEnabled(agent.id, false);
     }
   } else if (memfsStartupPolicy === "skip") {
@@ -174553,6 +175630,7 @@ var init_headless = __esm(async () => {
   init_personality();
   init_skillSources();
   init_backend2();
+  init_paths();
   init_errorFormatter();
   init_memoryReminder();
   init_messageQueueBridge();
@@ -175395,8 +176473,7 @@ async function handleProfileSave(ctx, msg, profileName) {
   const cmdId = addCommandResult2(ctx.buffersRef, ctx.refreshDerived, msg, `Saving profile "${profileName}"...`, false, "running");
   ctx.setCommandRunning(true);
   try {
-    const client = await getClient();
-    await client.agents.update(ctx.agentId, { name: profileName });
+    await getBackend().updateAgent(ctx.agentId, { name: profileName });
     ctx.updateAgentName(profileName);
     settingsManager.saveProfile(profileName, ctx.agentId);
     updateCommandResult2(ctx.buffersRef, ctx.refreshDerived, cmdId, msg, `Pinned "${profileName}" locally and globally.`, true);
@@ -175478,9 +176555,7 @@ async function handlePin(ctx, msg, argsStr) {
   const globalPinned = settingsManager.getGlobalPinnedAgents();
   if (name25 && name25 !== ctx.agentName) {
     try {
-      const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-      const client = await getClient2();
-      await client.agents.update(ctx.agentId, { name: name25 });
+      await getBackend().updateAgent(ctx.agentId, { name: name25 });
       ctx.updateAgentName(name25);
     } catch (error51) {
       addCommandResult2(ctx.buffersRef, ctx.refreshDerived, msg, `Failed to rename agent: ${error51}`, false);
@@ -175527,7 +176602,7 @@ function handleUnpin(ctx, msg, argsStr) {
 }
 var activeCommandId2 = null;
 var init_profile = __esm(() => {
-  init_client2();
+  init_backend2();
   init_settings_manager();
   init_errorFormatter();
 });
@@ -190685,7 +191760,7 @@ function highlightCode(code, language) {
   }
   return lines;
 }
-var import_react34, jsx_dev_runtime12, lowlight, BASH_LANGUAGE = "bash", FIRST_LINE_PREFIX = "$ ", EXT_TO_LANG, HEREDOC_RE, REDIRECT_FILE_RE, SyntaxHighlightedCommand;
+var import_react34, jsx_dev_runtime12, lowlight, BASH_LANGUAGE = "bash", FIRST_LINE_PROMPT = "$", PROMPT_COLUMN_WIDTH = 2, EXT_TO_LANG, HEREDOC_RE, REDIRECT_FILE_RE, SyntaxHighlightedCommand;
 var init_SyntaxHighlightedCommand = __esm(async () => {
   init_lowlight();
   init_colors();
@@ -190786,9 +191861,13 @@ var init_SyntaxHighlightedCommand = __esm(async () => {
           const lineKey = spans.map((s) => s.text).join("");
           return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
             children: [
-              showPrompt ? /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text2, {
-                color: palette.prompt,
-                children: lineIdx === 0 ? FIRST_LINE_PREFIX : "  "
+              showPrompt ? /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+                width: PROMPT_COLUMN_WIDTH,
+                flexShrink: 0,
+                children: lineIdx === 0 ? /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text2, {
+                  color: palette.prompt,
+                  children: FIRST_LINE_PROMPT
+                }, undefined, false, undefined, this) : null
               }, undefined, false, undefined, this) : null,
               /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text2, {
                 color: palette.text,
@@ -199500,6 +200579,7 @@ function boxBottom(width) {
 }
 var import_react67, jsx_dev_runtime44, BOX_TOP_LEFT = "╭", BOX_TOP_RIGHT = "╮", BOX_BOTTOM_LEFT = "╰", BOX_BOTTOM_RIGHT = "╯", BOX_HORIZONTAL = "─", BOX_VERTICAL = "│", HOOK_EVENTS, FALLBACK_TOOL_NAMES, SAVE_LOCATIONS, HooksManager;
 var init_HooksManager = __esm(async () => {
+  init_backend2();
   init_types3();
   init_writer();
   init_settings_manager();
@@ -199572,6 +200652,9 @@ var init_HooksManager = __esm(async () => {
         return;
       const fetchAgentTools = async () => {
         try {
+          if (!getBackend().capabilities.serverSideToolManagement) {
+            return;
+          }
           const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
           const client = await getClient2();
           const toolsPage = await client.agents.tools.list(agentId, {
@@ -202359,6 +203442,7 @@ function SlashCommandAutocomplete({
 }) {
   const columns = useTerminalWidth();
   const [customCommands, setCustomCommands] = import_react72.useState([]);
+  const [skillCommands, setSkillCommands] = import_react72.useState([]);
   import_react72.useEffect(() => {
     Promise.resolve().then(() => (init_custom(), exports_custom)).then(({ getCustomCommands: getCustomCommands2 }) => {
       getCustomCommands2().then((customs) => {
@@ -202371,6 +203455,35 @@ function SlashCommandAutocomplete({
       });
     });
   }, []);
+  import_react72.useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const { discoverClientSideSkills: discoverClientSideSkills2 } = await Promise.resolve().then(() => (init_clientSkills(), exports_clientSkills));
+        const { getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
+        const { isUserInvocableSkill: isUserInvocableSkill3 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
+        const discovery = await discoverClientSideSkills2({
+          agentId,
+          skillSources: getSkillSources2()
+        });
+        if (cancelled)
+          return;
+        const matches2 = discovery.skills.filter(isUserInvocableSkill3).map((skill2) => ({
+          cmd: `/${skill2.id}`,
+          desc: `${skill2.description}${skill2.argumentHint ? ` ${skill2.argumentHint}` : ""} (${skill2.source} skill)`,
+          order: 300
+        }));
+        setSkillCommands(matches2);
+      } catch {
+        if (!cancelled) {
+          setSkillCommands([]);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [agentId]);
   const allCommands = import_react72.useMemo(() => {
     let builtins = _allCommands;
     if (agentId) {
@@ -202394,8 +203507,13 @@ function SlashCommandAutocomplete({
         builtins = _allCommands;
       }
     }
-    return [...builtins, ...customCommands].sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
-  }, [agentId, workingDirectory, customCommands]);
+    const reservedCommands = new Set([
+      ...builtins.map((cmd) => cmd.cmd),
+      ...customCommands.map((cmd) => cmd.cmd)
+    ]);
+    const visibleSkillCommands = skillCommands.filter((cmd) => !reservedCommands.has(cmd.cmd));
+    return [...builtins, ...customCommands, ...visibleSkillCommands].sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
+  }, [agentId, workingDirectory, customCommands, skillCommands]);
   const queryInfo = import_react72.useMemo(() => extractSearchQuery2(currentInput, cursorPosition), [currentInput, cursorPosition]);
   const { matches, showNoMatches, hideAutocomplete } = import_react72.useMemo(() => {
     if (!queryInfo) {
@@ -209408,8 +210526,7 @@ function MemoryTabViewer({
   import_react81.useEffect(() => {
     const fetchBlocks = async () => {
       try {
-        const client = await getClient();
-        const agent = await client.agents.retrieve(agentId, {
+        const agent = await getBackend().retrieveAgent(agentId, {
           include: ["agent.blocks"]
         });
         setFreshBlocks(agent.memory?.blocks || []);
@@ -209686,7 +210803,7 @@ function MemoryTabViewer({
 }
 var import_react81, jsx_dev_runtime58, SOLID_LINE21 = "─", VISIBLE_LINES = 12;
 var init_MemoryTabViewer = __esm(async () => {
-  init_client2();
+  init_backend2();
   init_debug();
   init_useTerminalWidth();
   init_colors();
@@ -209700,24 +210817,13 @@ var init_MemoryTabViewer = __esm(async () => {
   jsx_dev_runtime58 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
-// src/backend/api/search.ts
-async function warmSearchCache(body) {
-  return apiRequest("POST", "/v1/_internal_search/cache-warm", body);
-}
-async function searchMessages(body) {
-  return apiRequest("POST", "/v1/messages/search", body);
-}
-var init_search = __esm(() => {
-  init_request();
-});
-
 // src/cli/components/MessageSearch.tsx
 async function warmMessageSearchCache() {
   const body = {
     collection: "messages",
     scope: {}
   };
-  return warmSearchCache(body);
+  return warmMessageSearchCacheForBackend(body);
 }
 function isSearchRangeAvailable(range2, options) {
   if (range2 === "agent")
@@ -209856,7 +210962,7 @@ function MessageSearch({
     } else if (range2 === "conv" && conversationId) {
       body.conversation_id = conversationId;
     }
-    return searchMessages(body);
+    return searchMessagesForBackend(body);
   }, [agentId, conversationId]);
   const fetchAndCacheSearchResults = import_react82.useCallback(async (query, mode, range2) => {
     const cacheKey = getCacheKey(query, mode, range2);
@@ -210329,7 +211435,7 @@ function MessageSearch({
 }
 var import_react82, jsx_dev_runtime59, SOLID_LINE22 = "─", VISIBLE_ITEMS = 5, SEARCH_LIMIT = 100, SEARCH_MODES, SEARCH_RANGES;
 var init_MessageSearch = __esm(async () => {
-  init_search();
+  init_messageSearch();
   init_useTerminalWidth();
   init_colors();
   await __promiseAll([
@@ -212657,7 +213763,7 @@ function getTabDescription(tab2, agentId) {
     case "project":
       return ".skills/";
     case "agent":
-      return `~/.letta/agents/${shortId}/skills/`;
+      return `~/.letta/agents/${shortId}/memory/skills/`;
     case "global":
       return "~/.letta/skills/";
     case "bundled":
@@ -212697,7 +213803,7 @@ function SkillsDialog({ onClose, agentId }) {
     }
     return grouped;
   }, [skills]);
-  const availableTabs = import_react91.useMemo(() => TAB_ORDER.filter((tab2) => (skillsBySource.get(tab2)?.length ?? 0) > 0), [skillsBySource]);
+  const availableTabs = import_react91.useMemo(() => [...TAB_ORDER], []);
   const [activeTab, setActiveTab] = import_react91.useState(null);
   import_react91.useEffect(() => {
     if (!loading && availableTabs.length > 0 && activeTab === null) {
@@ -212851,13 +213957,20 @@ function SkillsDialog({ onClose, agentId }) {
           }, undefined, false, undefined, this) : null
         ]
       }, undefined, true, undefined, this),
+      !loading && activeTab && currentSkills.length === 0 && /* @__PURE__ */ jsx_dev_runtime68.jsxDEV(Box_default, {
+        paddingLeft: 2,
+        children: /* @__PURE__ */ jsx_dev_runtime68.jsxDEV(Text2, {
+          dimColor: true,
+          children: "No skills in this location"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime68.jsxDEV(Box_default, {
         marginTop: 1,
         children: /* @__PURE__ */ jsx_dev_runtime68.jsxDEV(Text2, {
           dimColor: true,
           children: [
             "  ",
-            availableTabs.length > 1 ? "↑↓ scroll · ←→/Tab switch · Esc to close" : "Esc to close"
+            "↑↓ scroll · ←→/Tab switch · Esc to close"
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this)
@@ -215162,7 +216275,7 @@ var init_ToolCallMessageRich = __esm(async () => {
       let shellCommand = null;
       let shellSemanticKind = null;
       if (!isQuestionTool(rawName)) {
-        const parseArgs10 = () => {
+        const parseArgs9 = () => {
           if (!argsText.trim()) {
             return { formatted: null, parseable: true };
           }
@@ -215173,7 +216286,7 @@ var init_ToolCallMessageRich = __esm(async () => {
             return { formatted: null, parseable: false };
           }
         };
-        const { formatted, parseable } = parseArgs10();
+        const { formatted, parseable } = parseArgs9();
         const argsComplete = parseable || line.phase === "running" || line.phase === "finished" || !isStreaming;
         if (!argsComplete) {
           args = "(…)";
@@ -215286,13 +216399,13 @@ var init_ToolCallMessageRich = __esm(async () => {
           }, undefined, true, undefined, this);
         }
         const displayResultText = clipToolReturn(extractedText).replace(/\n+$/, "");
-        const isRecord11 = (v) => typeof v === "object" && v !== null;
+        const isRecord14 = (v) => typeof v === "object" && v !== null;
         if (isTodoTool(rawName, displayName) && line.resultOk !== false && line.argsText) {
           try {
             const parsedArgs = JSON.parse(line.argsText);
             if (parsedArgs.todos && Array.isArray(parsedArgs.todos)) {
               const safeTodos = parsedArgs.todos.map((t, i) => {
-                const rec = isRecord11(t) ? t : {};
+                const rec = isRecord14(t) ? t : {};
                 const status = rec.status === "completed" ? "completed" : rec.status === "in_progress" ? "in_progress" : "pending";
                 const id = typeof rec.id === "string" ? rec.id : String(i);
                 const content = typeof rec.content === "string" ? rec.content : typeof rec.description === "string" ? rec.description : JSON.stringify(t);
@@ -215310,7 +216423,7 @@ var init_ToolCallMessageRich = __esm(async () => {
             const parsedArgs = JSON.parse(line.argsText);
             if (parsedArgs.plan && Array.isArray(parsedArgs.plan)) {
               const safePlan = parsedArgs.plan.map((item) => {
-                const rec = isRecord11(item) ? item : {};
+                const rec = isRecord14(item) ? item : {};
                 const status = rec.status === "completed" ? "completed" : rec.status === "in_progress" ? "in_progress" : "pending";
                 const step = typeof rec.step === "string" ? rec.step : JSON.stringify(item);
                 return { step, status };
@@ -216127,6 +217240,27 @@ var init_TrajectorySummary = __esm(async () => {
 });
 
 // src/cli/components/UserMessageRich.tsx
+function getCurrentStdoutColumns() {
+  if (typeof process === "undefined")
+    return null;
+  const columns = process.stdout?.columns;
+  return typeof columns === "number" && columns > 0 ? columns : null;
+}
+function isInkFullWidthCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || 11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || 12880 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65131 || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 262141);
+}
+function inkStringWidth(text2) {
+  let width = 0;
+  for (let index = 0;index < text2.length; ) {
+    const codePoint = text2.codePointAt(index);
+    if (codePoint === undefined)
+      break;
+    const character = String.fromCodePoint(codePoint);
+    width += isInkFullWidthCodePoint(codePoint) || character.length > 1 ? 2 : 1;
+    index += character.length;
+  }
+  return width;
+}
 function wordWrap(text2, width) {
   if (width <= 0)
     return [text2];
@@ -216138,7 +217272,7 @@ function wordWrap(text2, width) {
       current = word;
     } else {
       const candidate = `${current} ${word}`;
-      if (stringWidth(candidate) <= width) {
+      if (inkStringWidth(candidate) <= width) {
         current = candidate;
       } else {
         lines.push(current);
@@ -216186,7 +217320,11 @@ function splitSystemReminderBlocks(text2) {
   }
   return blocks;
 }
-function renderBlock(text2, contentWidth, columns, highlighted, colorAnsi, promptPrefix, continuationPrefix) {
+function padToColumns(text2, columns) {
+  const pad = Math.max(0, columns - inkStringWidth(text2));
+  return `${text2}${" ".repeat(pad)}`;
+}
+function renderBlock(text2, contentWidth, columns, highlighted, promptPrefix, continuationPrefix) {
   const inputLines = text2.split(`
 `);
   const outputLines = [];
@@ -216202,34 +217340,39 @@ function renderBlock(text2, contentWidth, columns, highlighted, colorAnsi, promp
   }
   if (outputLines.length === 0)
     return [];
-  const isSingleLine = outputLines.length === 1;
-  return outputLines.map((ol, i) => {
+  const renderedLines = outputLines.map((ol, i) => {
     const prefix = i === 0 ? promptPrefix : continuationPrefix;
+    const content = `${prefix}${ol}`;
     if (!highlighted) {
-      return prefix + ol;
-    }
-    const content = i === 0 ? `${promptPrefix.slice(0, -1)}${colorAnsi} ${ol}` : `${prefix}${ol}`;
-    const visWidth = stringWidth(content);
-    if (isSingleLine) {
-      return `${colorAnsi}${content}${" ".repeat(COMPACT_PAD)}\x1B[0m`;
+      return { text: content, highlighted: false };
     }
-    const pad = Math.max(0, columns - visWidth);
-    return `${colorAnsi}${content}${" ".repeat(pad)}\x1B[0m`;
+    return { text: padToColumns(content, columns), highlighted: true };
   });
+  if (!highlighted) {
+    return renderedLines;
+  }
+  const blankLine = {
+    text: " ".repeat(Math.max(0, columns)),
+    highlighted: true
+  };
+  return [blankLine, ...renderedLines, blankLine];
 }
-var import_react101, jsx_dev_runtime81, COMPACT_PAD = 1, UserMessage;
+var import_react101, jsx_dev_runtime81, UserMessage;
 var init_UserMessageRich = __esm(async () => {
-  init_string_width();
   init_constants();
   init_useTerminalWidth();
   init_colors();
-  await init_Text2();
+  await __promiseAll([
+    init_build2(),
+    init_Text2()
+  ]);
   import_react101 = __toESM(require_react(), 1);
   jsx_dev_runtime81 = __toESM(require_jsx_dev_runtime(), 1);
   UserMessage = import_react101.memo(({ line, prompt }) => {
-    const columns = useTerminalWidth();
+    const trackedColumns2 = useTerminalWidth();
+    const columns = getCurrentStdoutColumns() ?? trackedColumns2;
     const promptPrefix = `${prompt || ">"} `;
-    const prefixWidth = stringWidth(promptPrefix);
+    const prefixWidth = inkStringWidth(promptPrefix);
     const continuationPrefix = " ".repeat(prefixWidth);
     const contentWidth = Math.max(1, columns - prefixWidth);
     const cleanedText = extractTaskNotificationsForDisplay(line.text).cleanedText;
@@ -216238,23 +217381,25 @@ var init_UserMessageRich = __esm(async () => {
       return null;
     }
     const { background, text: textColor } = colors.userMessage;
-    const bgAnsi = hexToBgAnsi(background);
-    const fgAnsi = textColor ? hexToFgAnsi(textColor) : "";
-    const colorAnsi = bgAnsi + fgAnsi;
     const blocks = splitSystemReminderBlocks(displayText);
     const allLines = [];
     for (const block of blocks) {
       if (!block.text.trim())
         continue;
       if (allLines.length > 0) {
-        allLines.push("");
+        allLines.push({ text: "", highlighted: false });
       }
-      const blockLines = renderBlock(block.text, contentWidth, columns, !block.isSystemReminder, colorAnsi, promptPrefix, continuationPrefix);
+      const blockLines = renderBlock(block.text, contentWidth, columns, !block.isSystemReminder, promptPrefix, continuationPrefix);
       allLines.push(...blockLines);
     }
-    return /* @__PURE__ */ jsx_dev_runtime81.jsxDEV(Text2, {
-      children: allLines.join(`
-`)
+    return /* @__PURE__ */ jsx_dev_runtime81.jsxDEV(Box_default, {
+      flexDirection: "column",
+      children: allLines.map((line2, index) => /* @__PURE__ */ jsx_dev_runtime81.jsxDEV(Text2, {
+        backgroundColor: line2.highlighted ? background : undefined,
+        color: line2.highlighted ? textColor : undefined,
+        wrap: line2.highlighted ? "end" : "wrap",
+        children: line2.text
+      }, index, false, undefined, this))
     }, undefined, false, undefined, this);
   });
   UserMessage.displayName = "UserMessage";
@@ -217736,7 +218881,7 @@ function updateCommandResult3(buffersRef, refreshDerived, cmdId, input, output,
   buffersRef.current.byId.set(cmdId, line);
   refreshDerived();
 }
-function parseArgs10(msg) {
+function parseArgs9(msg) {
   return msg.trim().split(/\s+/).filter(Boolean);
 }
 function formatConnectUsage() {
@@ -217936,7 +219081,7 @@ ${formatBedrockUsage2()}`, false);
   }
 }
 async function handleConnect(ctx, msg) {
-  const parts = parseArgs10(msg);
+  const parts = parseArgs9(msg);
   const providerToken = parts[1];
   if (!providerToken) {
     addCommandResult3(ctx.buffersRef, ctx.refreshDerived, msg, formatConnectUsage(), false);
@@ -218052,7 +219197,7 @@ The '${CLAUDE_PROVIDER_NAME}' provider does not exist in your Letta account.`, f
   }
 }
 async function handleDisconnect(ctx, msg) {
-  const parts = parseArgs10(msg);
+  const parts = parseArgs9(msg);
   const providerToken = parts[1]?.toLowerCase();
   if (providerToken === "help") {
     addCommandResult3(ctx.buffersRef, ctx.refreshDerived, msg, formatDisconnectHelp(), true);
@@ -220354,9 +221499,8 @@ function App2({
         return;
       }
       try {
-        const client = await getClient();
         debugLog("conversations", `retrieve(${conversationId}) [syncConversationModel]`);
-        const conversation = await client.conversations.retrieve(conversationId);
+        const conversation = await getBackend().retrieveConversation(conversationId);
         if (cancelled)
           return;
         const conversationModel = conversation.model;
@@ -220788,9 +221932,8 @@ ${newState.originalPrompt}`,
           })) {
             llmApiErrorRetriesRef.current += 1;
             try {
-              const client = await getClient();
-              const agent = await client.agents.retrieve(agentIdRef.current);
-              const { pendingApprovals: existingApprovals } = await getResumeData(client, agent, conversationIdRef.current);
+              const agent = await getBackend().retrieveAgent(agentIdRef.current);
+              const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend2(agent, conversationIdRef.current);
               currentInput = rebuildInputWithFreshDenials(currentInput, existingApprovals ?? [], "Auto-denied: stale approval from interrupted session");
             } catch {
               currentInput = rebuildInputWithFreshDenials(currentInput, [], "");
@@ -220939,9 +222082,8 @@ ${newState.originalPrompt}`,
           if (hasApprovalInPayload2) {
             if (isInvalidToolCallIdsError(errorDetail)) {
               try {
-                const client = await getClient();
-                const agent = await client.agents.retrieve(agentIdRef.current);
-                const { pendingApprovals: serverApprovals } = await getResumeData(client, agent, conversationIdRef.current);
+                const agent = await getBackend().retrieveAgent(agentIdRef.current);
+                const { pendingApprovals: serverApprovals } = await getResumeDataFromBackend2(agent, conversationIdRef.current);
                 if (serverApprovals && serverApprovals.length > 0) {
                   const userMessage = currentInput.find((item) => item?.type === "message");
                   if (userMessage && "content" in userMessage) {
@@ -220988,7 +222130,7 @@ ${newState.originalPrompt}`,
         }
         const syncAgentState = async () => {
           try {
-            const agent = prefetchedAgent ?? await (await getClient()).agents.retrieve(agentIdRef.current);
+            const agent = prefetchedAgent ?? await getBackend().retrieveAgent(agentIdRef.current);
             const currentModel = llmConfigRef.current?.model;
             const currentEndpoint = llmConfigRef.current?.model_endpoint_type;
             const currentEffort = llmConfigRef.current?.reasoning_effort;
@@ -221149,8 +222291,7 @@ ${feedback}
             if (!conversationTitle) {
               isAutoConversationTitleInFlightRef.current = false;
             } else {
-              const client = await getClient();
-              client.conversations.update(conversationIdRef.current, {
+              getBackend().updateConversation(conversationIdRef.current, {
                 summary: conversationTitle
               }).then(() => {
                 shouldAutoGenerateConversationTitleRef.current = false;
@@ -221568,9 +222709,8 @@ ${feedback}
         const invalidIdsDetected = isInvalidToolCallIdsError(detailFromRun) || isInvalidToolCallIdsError(latestErrorText);
         if (hasApprovalInPayload && invalidIdsDetected) {
           try {
-            const client = await getClient();
-            const agent = await client.agents.retrieve(agentIdRef.current);
-            const { pendingApprovals: serverApprovals } = await getResumeData(client, agent, conversationIdRef.current);
+            const agent = await getBackend().retrieveAgent(agentIdRef.current);
+            const { pendingApprovals: serverApprovals } = await getResumeDataFromBackend2(agent, conversationIdRef.current);
             if (serverApprovals && serverApprovals.length > 0) {
               const userMessage = currentInput.find((item) => item?.type === "message");
               if (userMessage && "content" in userMessage) {
@@ -221613,9 +222753,8 @@ ${feedback}
         })) {
           llmApiErrorRetriesRef.current += 1;
           try {
-            const client = await getClient();
-            const agent = await client.agents.retrieve(agentIdRef.current);
-            const { pendingApprovals: existingApprovals } = await getResumeData(client, agent, conversationIdRef.current);
+            const agent = await getBackend().retrieveAgent(agentIdRef.current);
+            const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend2(agent, conversationIdRef.current);
             currentInput = rebuildInputWithFreshDenials(currentInput, existingApprovals ?? [], "Auto-denied: stale approval from interrupted session");
           } catch {
             currentInput = rebuildInputWithFreshDenials(currentInput, [], "");
@@ -222248,7 +223387,7 @@ ${feedback}
     setBtwState({ status: "forking", question });
     try {
       const isDefault = conversationIdRef.current === "default";
-      const forked = await forkConversation(conversationIdRef.current, {
+      const forked = await getBackend().forkConversation(conversationIdRef.current, {
         ...isDefault ? { agentId } : {}
       });
       debugLog("btw", "forked conversationId=%s", forked.id);
@@ -222289,14 +223428,13 @@ ${feedback}
           })) {
             approvalRecoveryRetries += 1;
             try {
-              const client = await getClient();
               const currentAgentId = agentIdRef.current ?? agentId;
               if (!currentAgentId) {
                 currentInput = rebuildInputWithFreshDenials(currentInput, [], "");
                 continue;
               }
-              const agent = await client.agents.retrieve(currentAgentId);
-              const { pendingApprovals: existingApprovals } = await getResumeData(client, agent, forked.id);
+              const agent = await getBackend().retrieveAgent(currentAgentId);
+              const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend2(agent, forked.id);
               currentInput = rebuildInputWithFreshDenials(currentInput, existingApprovals ?? [], STALE_APPROVAL_RECOVERY_DENIAL_REASON);
             } catch {
               currentInput = rebuildInputWithFreshDenials(currentInput, [], "");
@@ -222353,8 +223491,7 @@ ${feedback}
       if (!agentState) {
         throw new Error("Agent state not available");
       }
-      const client = await getClient();
-      const resumeData = await getResumeData(client, agentState, conversationId2);
+      const resumeData = await getResumeDataFromBackend2(agentState, conversationId2);
       await maybeCarryOverActiveConversationModel(conversationId2);
       setConversationIdAndRef(conversationId2);
       setConversationAutoTitleEligibility(false);
@@ -222457,8 +223594,7 @@ ${feedback}
     const cmd = overlayCommand ?? commandRunner.start("/agents", "Switching agent...");
     cmd.update({ output: "Switching agent...", phase: "running" });
     try {
-      const client = await getClient();
-      const agent = await client.agents.retrieve(targetAgentId);
+      const agent = await getBackend().retrieveAgent(targetAgentId);
       const targetConversationId = opts?.conversationId ?? "default";
       await updateProjectSettings({ lastAgent: targetAgentId });
       settingsManager.persistSession(targetAgentId, targetConversationId);
@@ -222547,8 +223683,7 @@ ${feedback}
       const isSelfHosted = !getServerUrl().includes("api.letta.com");
       if (isSelfHosted) {
         try {
-          const client = await getClient();
-          const availableHandles = (await client.models.list()).map((model) => model.handle).filter((handle) => typeof handle === "string");
+          const availableHandles = (await backend4.listModels()).map((model) => model.handle).filter((handle) => typeof handle === "string");
           effectiveModel = selectDefaultAgentModel({
             preferredModel: effectiveModel,
             isSelfHosted: true,
@@ -222744,9 +223879,8 @@ ${expanded.command}` : expanded.command;
       return { blocked: false };
     }
     try {
-      const client = await getClient();
-      const agent = await client.agents.retrieve(agentId);
-      const { pendingApprovals: existingApprovals } = await getResumeData(client, agent, conversationIdRef.current);
+      const agent = await getBackend().retrieveAgent(agentId);
+      const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend2(agent, conversationIdRef.current);
       if (!existingApprovals || existingApprovals.length === 0) {
         setNeedsEagerApprovalCheck(false);
         return { blocked: false };
@@ -222910,6 +224044,11 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
         return { submitted: true };
       }
       if (trimmed === "/install-github-app") {
+        if (getBackend().capabilities.localModelCatalog) {
+          const cmd = commandRunner.start(trimmed, "Checking GitHub App installer support...");
+          cmd.fail("GitHub App installation is not supported by the local backend.");
+          return { submitted: true };
+        }
         startOverlayCommand("install-github-app", "/install-github-app", "Opening GitHub App installer...", "GitHub App installer dismissed");
         setActiveOverlay("install-github-app");
         return { submitted: true };
@@ -223013,6 +224152,11 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
         };
         const afterMcp = msg.trim().slice(4).trim();
         const firstWord = afterMcp.split(/\s+/)[0]?.toLowerCase();
+        if (firstWord !== "help" && !getBackend().capabilities.serverSideToolManagement) {
+          const cmd = commandRunner.start(msg, "Checking MCP support...");
+          cmd.fail("MCP server management is not supported by the local backend yet.");
+          return { submitted: true };
+        }
         if (!firstWord) {
           startOverlayCommand("mcp", "/mcp", "Opening MCP server manager...", "MCP dialog dismissed");
           setActiveOverlay("mcp");
@@ -223527,8 +224671,8 @@ Type your task to begin the loop.`, true);
         setCommandRunning(true);
         await runEndHooks();
         try {
-          const client = await getClient();
-          const conversation = await client.conversations.create({
+          const backend4 = getBackend();
+          const conversation = await backend4.createConversation({
             agent_id: agentId,
             isolated_block_labels: [...ISOLATED_BLOCK_LABELS],
             ...conversationName && { summary: conversationName }
@@ -223568,13 +224712,13 @@ Type your task to begin the loop.`, true);
         setCommandRunning(true);
         await runEndHooks();
         try {
-          const client = await getClient();
           const isDefault = conversationIdRef.current === "default";
-          const forked = await forkConversation(conversationIdRef.current, {
+          const backend4 = getBackend();
+          const forked = await backend4.forkConversation(conversationIdRef.current, {
             ...isDefault ? { agentId } : {}
           });
           if (conversationSummary) {
-            await client.conversations.update(forked.id, {
+            await backend4.updateConversation(forked.id, {
               summary: conversationSummary
             });
           }
@@ -223623,13 +224767,14 @@ Type your task to begin the loop.`, true);
         setCommandRunning(true);
         await runEndHooks();
         try {
-          const client = await getClient();
-          if (conversationIdRef.current === "default") {
+          const backend4 = getBackend();
+          if (conversationIdRef.current === "default" && !backend4.capabilities.localModelCatalog) {
+            const client = await getClient();
             await client.agents.messages.reset(agentId, {
               add_default_initial_messages: false
             });
           }
-          const conversation = await client.conversations.create({
+          const conversation = await backend4.createConversation({
             agent_id: agentId,
             isolated_block_labels: [...ISOLATED_BLOCK_LABELS]
           });
@@ -223776,20 +224921,20 @@ Type your task to begin the loop.`, true);
           });
           setCommandRunning(true);
           try {
-            const client = await getClient();
+            const backend4 = getBackend();
             if (shouldAutoGenerate) {
               const conversationTitle = await generateConversationTitle();
               if (!conversationTitle) {
                 cmd.fail("No conversation content available to generate a title");
                 return { submitted: true };
               }
-              await client.conversations.update(conversationId, {
+              await backend4.updateConversation(conversationId, {
                 summary: conversationTitle
               });
               setConversationAutoTitleEligibility(false);
               cmd.finish(`Conversation title set to "${conversationTitle}"`, true);
             } else {
-              await client.conversations.update(conversationId, {
+              await backend4.updateConversation(conversationId, {
                 summary: newValue
               });
               setConversationAutoTitleEligibility(false);
@@ -223814,8 +224959,9 @@ Type your task to begin the loop.`, true);
         });
         setCommandRunning(true);
         try {
-          const client = await getClient();
-          await client.agents.update(agentId, { name: newValue });
+          await getBackend().updateAgent(agentId, {
+            name: newValue
+          });
           updateAgentName(newValue);
           cmd.agentHint = `Your name is now "${newValue}" — acknowledge this and save your new name to memory.`;
           cmd.finish(`Agent renamed to "${newValue}"`, true);
@@ -223852,10 +224998,11 @@ Type your task to begin the loop.`, true);
         cmd.update({ output: "Updating description...", phase: "running" });
         setCommandRunning(true);
         try {
-          const client = await getClient();
-          await client.agents.update(agentId, {
+          await getBackend().updateAgent(agentId, {
             description: newDescription
           });
+          setAgentState((prev) => prev ? { ...prev, description: newDescription } : prev);
+          setAgentDescription(newDescription);
           cmd.finish(`Description updated to "${newDescription}"`, true);
         } catch (error51) {
           const errorDetails = formatErrorDetails2(error51, agentId);
@@ -223898,8 +225045,7 @@ Type your task to begin the loop.`, true);
           setCommandRunning(true);
           try {
             if (agentState) {
-              const client = await getClient();
-              const resumeData = await getResumeData(client, agentState, targetConvId);
+              const resumeData = await getResumeDataFromBackend2(agentState, targetConvId);
               setConversationIdAndRef(targetConvId);
               setConversationAutoTitleEligibility(false);
               pendingConversationSwitchRef.current = {
@@ -224173,6 +225319,10 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
       }
       if (msg.trim() === "/export" || msg.trim() === "/download") {
         const cmd = commandRunner.start(msg.trim(), "Exporting agent file...");
+        if (!getBackend().capabilities.agentFileImportExport) {
+          cmd.fail("AgentFile export is not supported by the local backend yet.");
+          return { submitted: true };
+        }
         setCommandRunning(true);
         try {
           const client = await getClient();
@@ -224459,8 +225609,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
           const reflectionConversationId = conversationIdRef.current;
           let systemPrompt;
           try {
-            const client = await getClient();
-            const agent = await client.agents.retrieve(agentId);
+            const agent = await getBackend().retrieveAgent(agentId);
             systemPrompt = agent.system ?? undefined;
           } catch {}
           const autoPayload = await buildAutoReflectionPayload(agentId, reflectionConversationId, systemPrompt);
@@ -224727,6 +225876,48 @@ ${SYSTEM_REMINDER_CLOSE}`),
         if (registryCmd) {
           registryCmd.fail(`Unknown command: ${registryCommandName}`);
         }
+        const skillCommandName = registryCommandName.slice(1);
+        const { discoverClientSideSkills: discoverClientSideSkills2 } = await Promise.resolve().then(() => (init_clientSkills(), exports_clientSkills));
+        const { getSkillSources: getSkillSources3 } = await Promise.resolve().then(() => (init_context(), exports_context));
+        const { isUserInvocableSkill: isUserInvocableSkill3 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
+        const skillDiscovery = await discoverClientSideSkills2({
+          agentId,
+          skillSources: getSkillSources3()
+        });
+        const matchedSkill = skillDiscovery.skills.find((skill2) => skill2.id === skillCommandName && isUserInvocableSkill3(skill2));
+        if (matchedSkill) {
+          const cmd = commandRunner.start(trimmed, `Running /${matchedSkill.id}...`);
+          const approvalCheck = await checkPendingApprovalsForSlashCommand();
+          if (approvalCheck.blocked) {
+            cmd.fail(`Pending approval(s). Resolve approvals before running /${matchedSkill.id}.`);
+            return { submitted: false };
+          }
+          const args = trimmed.slice(`/${matchedSkill.id}`.length).trim();
+          setCommandRunning(true);
+          try {
+            const { loadRenderedSkillContent: loadRenderedSkillContent2, wrapSkillContent: wrapSkillContent2 } = await Promise.resolve().then(() => (init_Skill2(), exports_Skill));
+            const skillContent = await loadRenderedSkillContent2(matchedSkill.id, {
+              agentId,
+              args,
+              allowDisabledModelInvocation: true
+            });
+            cmd.finish("Running skill...", true);
+            await processConversationWithQueuedApprovals([
+              {
+                type: "message",
+                role: "user",
+                content: buildTextParts(wrapSkillContent2(matchedSkill.id, skillContent)),
+                otid: randomUUID18()
+              }
+            ]);
+          } catch (error51) {
+            const errorDetails = formatErrorDetails2(error51, agentId);
+            cmd.fail(`Failed to run skill: ${errorDetails}`);
+          } finally {
+            setCommandRunning(false);
+          }
+          return { submitted: true };
+        }
       } else {
         if (registryCmd) {
           registryCmd.finish(result.output, result.success);
@@ -224817,8 +226008,7 @@ ${SYSTEM_REMINDER_CLOSE}
         const reflectionConversationId = conversationIdRef.current;
         let systemPrompt;
         try {
-          const client = await getClient();
-          const agent = await client.agents.retrieve(agentId);
+          const agent = await getBackend().retrieveAgent(agentId);
           systemPrompt = agent.system ?? undefined;
         } catch {}
         const autoPayload = await buildAutoReflectionPayload(agentId, reflectionConversationId, systemPrompt);
@@ -224947,9 +226137,8 @@ ${SYSTEM_REMINDER_CLOSE}
       buffersRef.current.order.push(eagerStatusId);
       refreshDerived();
       try {
-        const client = await getClient();
-        const agent = await client.agents.retrieve(agentId);
-        const { pendingApprovals: existingApprovals } = await getResumeData(client, agent, conversationIdRef.current);
+        const agent = await getBackend().retrieveAgent(agentId);
+        const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend2(agent, conversationIdRef.current);
         buffersRef.current.byId.delete(eagerStatusId);
         buffersRef.current.order = buffersRef.current.order.filter((id) => id !== eagerStatusId);
         if (userCancelledRef.current || abortControllerRef.current?.signal.aborted) {
@@ -225908,16 +227097,17 @@ ${guidance}`);
         phase: "running"
       });
       try {
-        const client = await getClient();
         const existing = agentState?.compaction_settings;
         const existingModel = existing?.model?.trim();
-        await client.agents.update(agentId, {
-          compaction_settings: {
-            ...existing,
-            model: existingModel || DEFAULT_SUMMARIZATION_MODEL,
-            mode
-          }
+        const nextCompactionSettings = {
+          ...existing,
+          model: existingModel || DEFAULT_SUMMARIZATION_MODEL,
+          mode
+        };
+        await getBackend().updateAgent(agentId, {
+          compaction_settings: nextCompactionSettings
         });
+        setAgentState((prev) => prev ? { ...prev, compaction_settings: nextCompactionSettings } : prev);
         cmd.finish(`Updated compaction mode to: ${mode}`, true);
       } catch (error51) {
         const errorDetails = formatErrorDetails2(error51, agentId);
@@ -226069,9 +227259,8 @@ ${guidance}`);
             if (action.conversationId === conversationId) {
               cmd.finish("Already on this conversation", true);
             } else {
-              const client = await getClient();
               if (agentState) {
-                const resumeData = await getResumeData(client, agentState, action.conversationId);
+                const resumeData = await getResumeDataFromBackend2(agentState, action.conversationId);
                 setConversationIdAndRef(action.conversationId);
                 setConversationAutoTitleEligibility(false);
                 pendingConversationSwitchRef.current = {
@@ -227382,8 +228571,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                   });
                   try {
                     if (agentState) {
-                      const client = await getClient();
-                      const resumeData = await getResumeData(client, agentState, convId);
+                      const resumeData = await getResumeDataFromBackend2(agentState, convId);
                       setConversationIdAndRef(convId);
                       setConversationAutoTitleEligibility(false);
                       pendingConversationSwitchRef.current = {
@@ -227488,8 +228676,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                     phase: "running"
                   });
                   try {
-                    const client = await getClient();
-                    const conversation = await client.conversations.create({
+                    const conversation = await getBackend().createConversation({
                       agent_id: agentId,
                       isolated_block_labels: [...ISOLATED_BLOCK_LABELS]
                     });
@@ -227577,8 +228764,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                   });
                   try {
                     if (agentState) {
-                      const client = await getClient();
-                      const resumeData = await getResumeData(client, agentState, actualTargetConv);
+                      const resumeData = await getResumeDataFromBackend2(agentState, actualTargetConv);
                       setConversationIdAndRef(actualTargetConv);
                       setConversationAutoTitleEligibility(false);
                       pendingConversationSwitchRef.current = {
@@ -227734,9 +228920,10 @@ Open /mcp to attach or detach tools for this server.`, true);
                     phase: "running"
                   });
                   try {
-                    const client = await getClient();
                     if (newName && newName !== agentName) {
-                      await client.agents.update(agentId, { name: newName });
+                      await getBackend().updateAgent(agentId, {
+                        name: newName
+                      });
                       updateAgentName(newName);
                     }
                     if (pinDialogLocal) {
@@ -227784,7 +228971,6 @@ var init_App2 = __esm(async () => {
   init_backend2();
   init_agents5();
   init_client2();
-  init_conversations2();
   init_metadata();
   init_constants();
   init_manager();
@@ -229121,9 +230307,8 @@ async function hydrateMemfsSettingFromAgent2(agent) {
   return enabled;
 }
 async function isMemfsEnabledOnServer2(agentId) {
-  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-  const client = await getClient2();
-  const agent = await client.agents.retrieve(agentId, {
+  const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
+  const agent = await getBackend2().retrieveAgent(agentId, {
     include: ["agent.tags"]
   });
   const { GIT_MEMORY_ENABLED_TAG: GIT_MEMORY_ENABLED_TAG2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
@@ -229256,7 +230441,8 @@ async function applyMemfsFlags2(agentId, memfsFlag, noMemfsFlag, options) {
   const backend4 = getBackend2();
   if (backend4.capabilities.localMemfs) {
     if (noMemfsFlag) {
-      throw new Error("Disabling MemFS is not supported by the local backend.");
+      settingsManager3.setMemfsEnabled(agentId, false);
+      return { action: "disabled" };
     }
     const memoryDir = getScopedMemoryFilesystemRoot2(agentId);
     const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
@@ -229433,7 +230619,7 @@ async function initSecretsFromServer2(agentId, cachedAgent) {
     setCache2(agentId, {});
     return;
   }
-  const agent = cachedAgent ?? await (await getClient()).agents.retrieve(agentId, {
+  const agent = cachedAgent ?? await getBackend().retrieveAgent(agentId, {
     include: ["agent.secrets"]
   });
   const secrets2 = {};
@@ -229466,6 +230652,9 @@ async function refreshAndListSecrets2(agentIdArg) {
   return Object.keys(cache5).sort().map((key) => ({ key, value: cache5[key] ?? "" }));
 }
 async function applySecretBatch2(options, agentIdArg) {
+  if (!getBackend().capabilities.serverSecrets) {
+    throw new Error("Agent secrets are not supported by this backend yet");
+  }
   const agentId = resolveSecretsAgentId2(agentIdArg);
   if (!agentId) {
     throw new Error("No agent context set. Agent ID is required.");
@@ -229477,8 +230666,7 @@ async function applySecretBatch2(options, agentIdArg) {
   for (const rawKey of options.unset ?? []) {
     delete next[rawKey.toUpperCase()];
   }
-  const client = await getClient();
-  await client.agents.update(agentId, { secrets: next });
+  await getBackend().updateAgent(agentId, { secrets: next });
   setCache2(agentId, next);
   return Object.keys(next).sort();
 }
@@ -229486,14 +230674,13 @@ async function setSecretOnServer2(key, value, agentIdArg) {
   if (!getBackend().capabilities.serverSecrets) {
     throw new Error("Agent secrets are not supported by this backend yet");
   }
-  const client = await getClient();
   const agentId = resolveSecretsAgentId2(agentIdArg);
   if (!agentId) {
     throw new Error("No agent context set. Agent ID is required.");
   }
   const secrets2 = { ...loadSecrets2(agentId) };
   secrets2[key] = value;
-  await client.agents.update(agentId, { secrets: secrets2 });
+  await getBackend().updateAgent(agentId, { secrets: secrets2 });
   setCache2(agentId, secrets2);
 }
 async function deleteSecretOnServer2(key, agentIdArg) {
@@ -229509,8 +230696,7 @@ async function deleteSecretOnServer2(key, agentIdArg) {
     return false;
   }
   delete secrets2[key];
-  const client = await getClient();
-  await client.agents.update(agentId, { secrets: secrets2 });
+  await getBackend().updateAgent(agentId, { secrets: secrets2 });
   setCache2(agentId, secrets2);
   return true;
 }
@@ -229526,7 +230712,6 @@ var SECRETS_CACHE_KEY2;
 var init_secretsStore2 = __esm(() => {
   init_context();
   init_backend2();
-  init_client2();
   SECRETS_CACHE_KEY2 = Symbol.for("@letta/secretsCache");
 });
 
@@ -230059,6 +231244,9 @@ init_available_models();
 function supportsDistinctAnthropicXHighEffort2(modelHandle) {
   return modelHandle.includes("claude-opus-4-7");
 }
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function buildModelSettings2(modelHandle, updateArgs) {
   const isOpenAI = modelHandle.startsWith("openai/") || modelHandle.startsWith(`${OPENAI_CODEX_PROVIDER_NAME}/`);
   const isAnthropic = modelHandle.startsWith("anthropic/") || modelHandle.startsWith("claude-pro-max/") || modelHandle.startsWith("minimax/");
@@ -230181,6 +231369,12 @@ function buildModelSettings2(modelHandle, updateArgs) {
   if (typeof updateArgs?.max_output_tokens === "number" && "provider_type" in settings) {
     settings.max_output_tokens = updateArgs.max_output_tokens;
   }
+  if (isRecord10(updateArgs?.modalities)) {
+    settings.modalities = updateArgs.modalities;
+  }
+  if (isRecord10(updateArgs?.capabilities)) {
+    settings.capabilities = updateArgs.capabilities;
+  }
   return settings;
 }
 async function updateAgentLLMConfig2(agentId, modelHandle, updateArgs, options) {
@@ -230504,6 +231698,15 @@ async function getBillingTier2() {
   }
 }
 
+// src/backend/local/paths.ts
+var LOCAL_BACKEND_NO_MEMFS_ENV2 = "LETTA_LOCAL_BACKEND_NO_MEMFS";
+function isTruthyEnv3(value) {
+  return value === "1" || value?.toLowerCase() === "true";
+}
+function isLocalBackendNoMemfsEnvEnabled2(env = process.env) {
+  return isTruthyEnv3(env[LOCAL_BACKEND_NO_MEMFS_ENV2]);
+}
+
 // src/cli/args.ts
 import { parseArgs } from "node:util";
 var CLI_FLAG_CATALOG = {
@@ -232841,7 +234044,7 @@ function validateRegistryHandleOrThrow(handle) {
 // src/cli/subcommands/agents.ts
 init_create();
 init_personality();
-init_client2();
+init_backend2();
 init_settings_manager();
 import { parseArgs as parseArgs2 } from "node:util";
 function printUsage() {
@@ -232975,8 +234178,7 @@ async function runCreateAction(values) {
     if (values.pinned) {
       settingsManager.pinGlobal(agentId);
     }
-    const client = await getClient();
-    const updatedAgent = await client.agents.retrieve(agentId);
+    const updatedAgent = await getBackend().retrieveAgent(agentId);
     console.log(JSON.stringify(updatedAgent, null, 2));
     return 0;
   } catch (error51) {
@@ -233006,8 +234208,7 @@ async function runListAction(values) {
     params.include = ["agent.blocks"];
   }
   try {
-    const client = await getClient();
-    const result = await client.agents.list(params);
+    const result = await getBackend().listAgents(params);
     console.log(JSON.stringify(result, null, 2));
     return 0;
   } catch (error51) {
@@ -233016,234 +234217,6 @@ async function runListAction(values) {
   }
 }
 
-// src/cli/subcommands/blocks.ts
-init_client2();
-init_settings_manager();
-import { parseArgs as parseArgs3 } from "node:util";
-function printUsage2() {
-  console.log(`
-Usage:
-  letta blocks list --agent <id> [--limit <n>]
-  letta blocks copy --block-id <id> [--label <new-label>] [--agent <id>] [--override]
-  letta blocks attach --block-id <id> [--agent <id>] [--read-only] [--override]
-
-Notes:
-  - Output is JSON only.
-  - Uses CLI auth; override with LETTA_API_KEY/LETTA_BASE_URL if needed.
-  - Default target agent for copy/attach is LETTA_AGENT_ID.
-`.trim());
-}
-function parseLimit2(value, fallback) {
-  if (typeof value !== "string" || value.length === 0)
-    return fallback;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isNaN(parsed) ? fallback : parsed;
-}
-function getAgentId2(agentFromArgs, agentIdFromArgs) {
-  return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
-}
-var BLOCKS_OPTIONS = {
-  help: { type: "boolean", short: "h" },
-  agent: { type: "string" },
-  "agent-id": { type: "string" },
-  limit: { type: "string" },
-  "block-id": { type: "string" },
-  label: { type: "string" },
-  override: { type: "boolean" },
-  "read-only": { type: "boolean" }
-};
-function parseBlocksArgs(argv) {
-  return parseArgs3({
-    args: argv,
-    options: BLOCKS_OPTIONS,
-    strict: true,
-    allowPositionals: true
-  });
-}
-async function copyBlock(client, blockId, options) {
-  const currentAgentId = getAgentId2(options?.targetAgentId);
-  if (!currentAgentId) {
-    throw new Error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
-  }
-  let detachedBlock;
-  const sourceBlock = await client.blocks.retrieve(blockId);
-  const targetLabel = options?.labelOverride || sourceBlock.label || "migrated-block";
-  if (options?.override) {
-    const currentBlocksResponse = await client.agents.blocks.list(currentAgentId);
-    const currentBlocks = Array.isArray(currentBlocksResponse) ? currentBlocksResponse : currentBlocksResponse.items || [];
-    const conflictingBlock = currentBlocks.find((b) => b.label === targetLabel);
-    if (conflictingBlock) {
-      console.error(`Detaching existing block with label "${targetLabel}" (${conflictingBlock.id})...`);
-      detachedBlock = conflictingBlock;
-      try {
-        await client.agents.blocks.detach(conflictingBlock.id, {
-          agent_id: currentAgentId
-        });
-      } catch (detachError) {
-        throw new Error(`Failed to detach existing block "${targetLabel}": ${detachError instanceof Error ? detachError.message : String(detachError)}`);
-      }
-    }
-  }
-  let newBlock;
-  try {
-    newBlock = await client.blocks.create({
-      label: targetLabel,
-      value: sourceBlock.value,
-      description: sourceBlock.description || undefined,
-      limit: sourceBlock.limit
-    });
-  } catch (createError) {
-    if (detachedBlock) {
-      console.error(`Create failed, reattaching original block "${detachedBlock.label}"...`);
-      try {
-        await client.agents.blocks.attach(detachedBlock.id, {
-          agent_id: currentAgentId
-        });
-        console.error("Original block reattached successfully.");
-      } catch {
-        console.error(`WARNING: Failed to reattach original block! Block ID: ${detachedBlock.id}`);
-      }
-    }
-    throw createError;
-  }
-  let attachResult;
-  try {
-    attachResult = await client.agents.blocks.attach(newBlock.id, {
-      agent_id: currentAgentId
-    });
-  } catch (attachError) {
-    if (detachedBlock) {
-      console.error(`Attach failed, reattaching original block "${detachedBlock.label}"...`);
-      try {
-        await client.agents.blocks.attach(detachedBlock.id, {
-          agent_id: currentAgentId
-        });
-        console.error("Original block reattached successfully.");
-      } catch {
-        console.error(`WARNING: Failed to reattach original block! Block ID: ${detachedBlock.id}`);
-      }
-    }
-    throw attachError;
-  }
-  return { sourceBlock, newBlock, attachResult, detachedBlock };
-}
-async function attachBlock(client, blockId, options) {
-  const currentAgentId = getAgentId2(options?.targetAgentId);
-  if (!currentAgentId) {
-    throw new Error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
-  }
-  let detachedBlock;
-  if (options?.override) {
-    const sourceBlock = await client.blocks.retrieve(blockId);
-    const sourceLabel = sourceBlock.label;
-    const currentBlocksResponse = await client.agents.blocks.list(currentAgentId);
-    const currentBlocks = Array.isArray(currentBlocksResponse) ? currentBlocksResponse : currentBlocksResponse.items || [];
-    const conflictingBlock = currentBlocks.find((b) => b.label === sourceLabel);
-    if (conflictingBlock) {
-      console.error(`Detaching existing block with label "${sourceLabel}" (${conflictingBlock.id})...`);
-      detachedBlock = conflictingBlock;
-      try {
-        await client.agents.blocks.detach(conflictingBlock.id, {
-          agent_id: currentAgentId
-        });
-      } catch (detachError) {
-        throw new Error(`Failed to detach existing block "${sourceLabel}": ${detachError instanceof Error ? detachError.message : String(detachError)}`);
-      }
-    }
-  }
-  let attachResult;
-  try {
-    attachResult = await client.agents.blocks.attach(blockId, {
-      agent_id: currentAgentId
-    });
-  } catch (attachError) {
-    if (detachedBlock) {
-      console.error(`Attach failed, reattaching original block "${detachedBlock.label}"...`);
-      try {
-        await client.agents.blocks.attach(detachedBlock.id, {
-          agent_id: currentAgentId
-        });
-        console.error("Original block reattached successfully.");
-      } catch {
-        console.error(`WARNING: Failed to reattach original block! Block ID: ${detachedBlock.id}`);
-      }
-    }
-    throw attachError;
-  }
-  if (options?.readOnly) {
-    console.warn("Note: read_only flag is set on the block itself, not per-agent. " + "Use the block update API to set read_only if needed.");
-  }
-  return { attachResult, detachedBlock };
-}
-async function runBlocksSubcommand(argv) {
-  let parsed;
-  try {
-    parsed = parseBlocksArgs(argv);
-  } catch (error51) {
-    const message = error51 instanceof Error ? error51.message : String(error51);
-    console.error(`Error: ${message}`);
-    printUsage2();
-    return 1;
-  }
-  const [action] = parsed.positionals;
-  if (parsed.values.help || !action || action === "help") {
-    printUsage2();
-    return 0;
-  }
-  try {
-    await settingsManager.initialize();
-    const client = await getClient();
-    if (action === "list") {
-      const agentId = parsed.values.agent || parsed.values["agent-id"] || "";
-      if (!agentId || typeof agentId !== "string") {
-        console.error("Missing required --agent <id>.");
-        return 1;
-      }
-      const result = await client.agents.blocks.list(agentId, {
-        limit: parseLimit2(parsed.values.limit, 1000)
-      });
-      console.log(JSON.stringify(result, null, 2));
-      return 0;
-    }
-    if (action === "copy") {
-      const blockId = parsed.values["block-id"];
-      if (!blockId || typeof blockId !== "string") {
-        console.error("Missing required --block-id <id>.");
-        return 1;
-      }
-      const agentId = getAgentId2(parsed.values.agent, parsed.values["agent-id"]);
-      const result = await copyBlock(client, blockId, {
-        labelOverride: typeof parsed.values.label === "string" ? parsed.values.label : undefined,
-        targetAgentId: agentId,
-        override: parsed.values.override === true
-      });
-      console.log(JSON.stringify(result, null, 2));
-      return 0;
-    }
-    if (action === "attach") {
-      const blockId = parsed.values["block-id"];
-      if (!blockId || typeof blockId !== "string") {
-        console.error("Missing required --block-id <id>.");
-        return 1;
-      }
-      const agentId = getAgentId2(parsed.values.agent, parsed.values["agent-id"]);
-      const result = await attachBlock(client, blockId, {
-        readOnly: parsed.values["read-only"] === true,
-        override: parsed.values.override === true,
-        targetAgentId: agentId
-      });
-      console.log(JSON.stringify(result, null, 2));
-      return 0;
-    }
-  } catch (error51) {
-    console.error(error51 instanceof Error ? error51.message : String(error51));
-    return 1;
-  }
-  console.error(`Unknown action: ${action}`);
-  printUsage2();
-  return 1;
-}
-
 // src/cli/subcommands/channels.ts
 init_accounts();
 init_pairing();
@@ -233252,8 +234225,8 @@ init_registry();
 init_routing();
 init_runtimeDeps();
 await init_service();
-import { parseArgs as parseArgs4 } from "node:util";
-function printUsage3() {
+import { parseArgs as parseArgs3 } from "node:util";
+function printUsage2() {
   console.log(`
 Usage:
   letta channels install <channel>            Install channel runtime dependencies
@@ -233317,14 +234290,14 @@ var CHANNELS_OPTIONS = {
   code: { type: "string" }
 };
 function parseChannelsArgs(argv) {
-  return parseArgs4({
+  return parseArgs3({
     args: argv,
     options: CHANNELS_OPTIONS,
     strict: true,
     allowPositionals: true
   });
 }
-function getAgentId3(fromArgs) {
+function getAgentId2(fromArgs) {
   return fromArgs || process.env.LETTA_AGENT_ID || "";
 }
 function getConversationId2(fromArgs) {
@@ -233461,7 +234434,7 @@ function handleRouteAdd(values) {
   const channelId = values.channel;
   const accountId = values["account-id"];
   const chatId = values["chat-id"];
-  const agentId = getAgentId3(values.agent);
+  const agentId = getAgentId2(values.agent);
   const conversationId = getConversationId2(values.conversation);
   if (!channelId) {
     console.error("Error: --channel is required.");
@@ -233549,7 +234522,7 @@ async function handlePair(values) {
   const channelId = values.channel;
   const accountId = values["account-id"];
   const code = values.code;
-  const agentId = getAgentId3(values.agent);
+  const agentId = getAgentId2(values.agent);
   const conversationId = getConversationId2(values.conversation);
   if (!channelId) {
     console.error("Error: --channel is required.");
@@ -233580,7 +234553,7 @@ async function handlePair(values) {
 function handleBind(values) {
   const channelId = values.channel;
   const accountId = values["account-id"];
-  const agentId = getAgentId3(values.agent);
+  const agentId = getAgentId2(values.agent);
   if (!channelId) {
     console.error("Error: --channel is required.");
     return 1;
@@ -233620,7 +234593,7 @@ function handleBind(values) {
 async function runChannelsSubcommand(argv) {
   const { values, positionals } = parseChannelsArgs(argv);
   if (values.help) {
-    printUsage3();
+    printUsage2();
     return 0;
   }
   const [action, ...rest] = positionals;
@@ -233663,7 +234636,7 @@ async function runChannelsSubcommand(argv) {
       return await handlePair(values);
     default:
       if (!action) {
-        printUsage3();
+        printUsage2();
         return 0;
       }
       console.error(`Unknown channels action: "${action}". Use: install, configure, status, route, bind, pair`);
@@ -233678,7 +234651,7 @@ init_connect_normalize();
 init_connect_oauth_core();
 import { createInterface as createInterface4 } from "node:readline/promises";
 import { Writable } from "node:stream";
-import { parseArgs as parseArgs5 } from "node:util";
+import { parseArgs as parseArgs4 } from "node:util";
 var CONNECT_OPTIONS = {
   help: { type: "boolean", short: "h" },
   "api-key": { type: "string" },
@@ -233769,7 +234742,7 @@ async function runConnectSubcommand(argv, deps = {}) {
   const io = { ...DEFAULT_DEPS2, ...deps };
   let parsed;
   try {
-    parsed = parseArgs5({
+    parsed = parseArgs4({
       args: argv,
       options: CONNECT_OPTIONS,
       strict: true,
@@ -233878,8 +234851,8 @@ async function runConnectSubcommand(argv, deps = {}) {
 
 // src/cli/subcommands/cron.ts
 init_cron();
-import { parseArgs as parseArgs6 } from "node:util";
-function printUsage4() {
+import { parseArgs as parseArgs5 } from "node:util";
+function printUsage3() {
   console.log(`
 Usage:
   letta cron add --prompt <text> --every <interval> [options]
@@ -233923,14 +234896,14 @@ var CRON_OPTIONS = {
   all: { type: "boolean" }
 };
 function parseCronArgs(argv) {
-  return parseArgs6({
+  return parseArgs5({
     args: argv,
     options: CRON_OPTIONS,
     strict: true,
     allowPositionals: true
   });
 }
-function getAgentId4(fromArgs) {
+function getAgentId3(fromArgs) {
   return fromArgs || process.env.LETTA_AGENT_ID || "";
 }
 function getConversationId3(fromArgs) {
@@ -233952,7 +234925,7 @@ function handleAdd(values) {
     console.error("Error: --prompt is required.");
     return 1;
   }
-  const agentId = getAgentId4(values.agent);
+  const agentId = getAgentId3(values.agent);
   if (!agentId) {
     console.error("Error: --agent or LETTA_AGENT_ID required.");
     return 1;
@@ -234073,7 +235046,7 @@ function handleGet(positionals) {
 }
 function handleDelete(values, positionals) {
   if (values.all) {
-    const agentId = getAgentId4(values.agent);
+    const agentId = getAgentId3(values.agent);
     if (!agentId) {
       console.error("Error: --agent or LETTA_AGENT_ID required with --all.");
       return 1;
@@ -234101,12 +235074,12 @@ async function runCronSubcommand(argv) {
     parsed = parseCronArgs(argv);
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    printUsage4();
+    printUsage3();
     return 1;
   }
   const [action] = parsed.positionals;
   if (parsed.values.help || !action || action === "help") {
-    printUsage4();
+    printUsage3();
     return 0;
   }
   switch (action) {
@@ -234120,7 +235093,7 @@ async function runCronSubcommand(argv) {
       return handleDelete(parsed.values, parsed.positionals);
     default:
       console.error(`Unknown action: ${action}`);
-      printUsage4();
+      printUsage3();
       return 1;
   }
 }
@@ -234135,7 +235108,7 @@ await __promiseAll([
 ]);
 var import_react30 = __toESM(require_react(), 1);
 import { hostname as hostname4 } from "node:os";
-import { parseArgs as parseArgs7 } from "node:util";
+import { parseArgs as parseArgs6 } from "node:util";
 
 // src/websocket/listen-log.ts
 import {
@@ -234454,7 +235427,7 @@ async function resolveListenerRegistrationOptions(deviceId, connectionName) {
   };
 }
 async function runListenSubcommand(argv) {
-  const { values } = parseArgs7({
+  const { values } = parseArgs6({
     args: argv,
     options: {
       "env-name": { type: "string" },
@@ -234790,7 +235763,7 @@ import { cpSync, existsSync as existsSync35, mkdirSync as mkdirSync25, rmSync as
 import { readdir as readdir7 } from "node:fs/promises";
 import { homedir as homedir26 } from "node:os";
 import { join as join38 } from "node:path";
-import { parseArgs as parseArgs8 } from "node:util";
+import { parseArgs as parseArgs7 } from "node:util";
 
 // src/cli/subcommands/memoryTokens.ts
 init_systemPromptSize();
@@ -234871,7 +235844,7 @@ async function runMemoryTokensAction(options) {
 }
 
 // src/cli/subcommands/memory.ts
-function printUsage5() {
+function printUsage4() {
   console.log(`
 Usage:
   letta memory status [--agent <id>]
@@ -234900,7 +235873,7 @@ Examples:
   letta memory tokens --memory-dir ~/.letta/agents/agent-123/memory --format json
 `.trim());
 }
-function getAgentId5(agentFromArgs, agentIdFromArgs) {
+function getAgentId4(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
 var MEMORY_OPTIONS = {
@@ -234916,7 +235889,7 @@ var MEMORY_OPTIONS = {
   quiet: { type: "boolean" }
 };
 function parseMemoryArgs(argv) {
-  return parseArgs8({
+  return parseArgs7({
     args: argv,
     options: MEMORY_OPTIONS,
     strict: true,
@@ -234977,15 +235950,15 @@ async function runMemorySubcommand(argv) {
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : String(error51);
     console.error(`Error: ${message}`);
-    printUsage5();
+    printUsage4();
     return 1;
   }
   const [action] = parsed.positionals;
   if (parsed.values.help || !action || action === "help") {
-    printUsage5();
+    printUsage4();
     return 0;
   }
-  const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
+  const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
   if (action === "tokens") {
     return runMemoryTokensAction({
       memoryDir: parsed.values["memory-dir"],
@@ -235118,17 +236091,18 @@ async function runMemorySubcommand(argv) {
     return 1;
   }
   console.error(`Unknown action: ${action}`);
-  printUsage5();
+  printUsage4();
   return 1;
 }
 
 // src/cli/subcommands/messages.ts
-init_client2();
+init_backend2();
+init_messageSearch();
 init_settings_manager();
 import { writeFile as writeFile11 } from "node:fs/promises";
 import { resolve as resolve33 } from "node:path";
-import { parseArgs as parseArgs9 } from "node:util";
-function printUsage6() {
+import { parseArgs as parseArgs8 } from "node:util";
+function printUsage5() {
   console.log(`
 Usage:
   letta messages search --query <text> [options]
@@ -235171,7 +236145,7 @@ Notes:
   - For agent-to-agent messaging, use: letta -p --from-agent <sender-id> --agent <target-id> "message"
 `.trim());
 }
-function parseLimit3(value, fallback) {
+function parseLimit2(value, fallback) {
   if (typeof value !== "string" || value.length === 0)
     return fallback;
   const parsed = Number.parseInt(value, 10);
@@ -235191,9 +236165,23 @@ function parseOrder(value) {
   }
   return;
 }
-function getAgentId6(agentFromArgs, agentIdFromArgs) {
+function getAgentId5(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
+function pageItems2(page) {
+  if (Array.isArray(page))
+    return page;
+  if (page && typeof page === "object") {
+    const maybePage = page;
+    if (typeof maybePage.getPaginatedItems === "function") {
+      return maybePage.getPaginatedItems();
+    }
+    if (Array.isArray(maybePage.items)) {
+      return maybePage.items;
+    }
+  }
+  return [];
+}
 var MESSAGES_OPTIONS = {
   help: { type: "boolean", short: "h" },
   query: { type: "string" },
@@ -235214,7 +236202,7 @@ var MESSAGES_OPTIONS = {
   output: { type: "string" }
 };
 function parseMessagesArgs(argv) {
-  return parseArgs9({
+  return parseArgs8({
     args: argv,
     options: MESSAGES_OPTIONS,
     strict: true,
@@ -235228,17 +236216,17 @@ async function runMessagesSubcommand(argv) {
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : String(error51);
     console.error(`Error: ${message}`);
-    printUsage6();
+    printUsage5();
     return 1;
   }
   const [action] = parsed.positionals;
   if (parsed.values.help || !action || action === "help") {
-    printUsage6();
+    printUsage5();
     return 0;
   }
   try {
     await settingsManager.initialize();
-    const client = await getClient();
+    const backend4 = getBackend();
     const renderText = (value) => {
       if (typeof value === "string")
         return value;
@@ -235322,13 +236310,13 @@ async function runMessagesSubcommand(argv) {
       const seenIds = new Set;
       let cursorBefore;
       for (let pageIndex = 0;pageIndex < maxPages; pageIndex += 1) {
-        const page = await client.conversations.messages.list(conversationId, {
+        const page = await backend4.listConversationMessages(conversationId, {
           limit: pageLimit,
           order: "desc",
           ...conversationId === "default" && agentIdForDefault ? { agent_id: agentIdForDefault } : {},
           ...cursorBefore ? { before: cursorBefore } : {}
         });
-        const items = page.getPaginatedItems();
+        const items = pageItems2(page);
         if (items.length === 0) {
           break;
         }
@@ -235355,24 +236343,24 @@ async function runMessagesSubcommand(argv) {
         return 1;
       }
       const allAgents = parsed.values["all-agents"] ?? false;
-      const agentId = getAgentId6(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
       if (!allAgents && !agentId) {
         console.error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
         return 1;
       }
-      const result = await client.messages.search({
+      const result = await searchMessagesForBackend({
         query,
         agent_id: allAgents ? undefined : agentId,
         search_mode: parseMode(parsed.values.mode) ?? "hybrid",
         start_date: parsed.values["start-date"],
         end_date: parsed.values["end-date"],
-        limit: parseLimit3(parsed.values.limit, 10)
+        limit: parseLimit2(parsed.values.limit, 10)
       });
       console.log(JSON.stringify(result, null, 2));
       return 0;
     }
     if (action === "list") {
-      const agentId = getAgentId6(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
       if (!agentId) {
         console.error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
         return 1;
@@ -235383,14 +236371,14 @@ async function runMessagesSubcommand(argv) {
         console.error(`Invalid --order "${orderRaw}". Use "asc" or "desc".`);
         return 1;
       }
-      const response = await client.agents.messages.list(agentId, {
+      const response = await backend4.listAgentMessages(agentId, {
         conversation_id: "default",
-        limit: parseLimit3(parsed.values.limit, 20),
+        limit: parseLimit2(parsed.values.limit, 20),
         after: parsed.values.after,
         before: parsed.values.before,
         order
       });
-      const messages = response.getPaginatedItems() ?? [];
+      const messages = pageItems2(response);
       const startDate = parsed.values["start-date"];
       const endDate = parsed.values["end-date"];
       let filtered = messages;
@@ -235418,13 +236406,13 @@ async function runMessagesSubcommand(argv) {
         console.error("Missing conversation id. Pass --conversation <id> or --conversation-id <id>.");
         return 1;
       }
-      const agentId = getAgentId6(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
       if (conversationId === "default" && !agentId) {
         console.error('Conversation "default" requires an agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.');
         return 1;
       }
-      const pageLimit = Math.max(1, parseLimit3(parsed.values.limit, 100));
-      const maxPages = Math.max(1, parseLimit3(parsed.values["max-pages"], 200));
+      const pageLimit = Math.max(1, parseLimit2(parsed.values.limit, 100));
+      const maxPages = Math.max(1, parseLimit2(parsed.values["max-pages"], 200));
       const outputPathRaw = parsed.values.out || parsed.values.output;
       const messages = await fetchConversationMessages(conversationId, agentId || undefined, pageLimit, maxPages);
       const transcript = messages.flatMap((msg) => formatEntry(msg)).join(`
@@ -235455,7 +236443,7 @@ async function runMessagesSubcommand(argv) {
     return 1;
   }
   console.error(`Unknown action: ${action}`);
-  printUsage6();
+  printUsage5();
   return 1;
 }
 
@@ -235473,8 +236461,6 @@ async function runSubcommand(argv) {
       return runAgentsSubcommand(rest);
     case "messages":
       return runMessagesSubcommand(rest);
-    case "blocks":
-      return runBlocksSubcommand(rest);
     case "server":
     case "remote":
       return runListenSubcommand(rest);
@@ -237695,7 +238681,6 @@ USAGE
   letta memory ...      Memory filesystem subcommands
   letta agents ...      Agents subcommands (JSON-only)
   letta messages ...    Messages subcommands (JSON-only)
-  letta blocks ...      Blocks subcommands (JSON-only)
   letta connect ...     Connect providers from terminal
 
 OPTIONS
@@ -237715,9 +238700,6 @@ SUBCOMMANDS
   letta messages search --query <text> [--all-agents]
   letta messages list [--agent <id>]
   letta messages transcript --conversation <id> [--out <path>]
-  letta blocks list --agent <id>
-  letta blocks copy --block-id <id> [--label <label>] [--agent <id>] [--override]
-  letta blocks attach --block-id <id> [--agent <id>] [--read-only] [--override]
   letta connect <provider> [options]
 
 BEHAVIOR
@@ -238006,8 +238988,13 @@ 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 startupBackend = getBackend();
+  const localNoMemfsRequested = Boolean(startupBackend.capabilities.localMemfs && (noMemfsFlag || isLocalBackendNoMemfsEnvEnabled2()));
+  if (localNoMemfsRequested) {
+    process.env[LOCAL_BACKEND_NO_MEMFS_ENV2] = "1";
+  }
+  const requestedMemoryPromptMode = memfsFlag ? "memfs" : noMemfsFlag || localNoMemfsRequested ? "standard" : undefined;
+  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !noMemfsFlag && !localNoMemfsRequested;
   const noSkillsFlag = values["no-skills"];
   const noBundledSkillsFlag = values["no-bundled-skills"];
   const skillSourcesRaw = values["skill-sources"];
@@ -238758,7 +239745,7 @@ Error: ${message}`);
           }
           const { isLettaCloud: isLettaCloud3 } = await Promise.resolve().then(() => (init_memoryFilesystem2(), exports_memoryFilesystem2));
           const willAutoEnableMemfs = shouldAutoEnableMemfsForNewAgent && await isLettaCloud3();
-          const effectiveMemoryMode = backend4.capabilities.localMemfs ? "local-memfs" : requestedMemoryPromptMode ?? (willAutoEnableMemfs ? "memfs" : undefined);
+          const effectiveMemoryMode = backend4.capabilities.localMemfs ? localNoMemfsRequested ? "standard" : "local-memfs" : requestedMemoryPromptMode ?? (willAutoEnableMemfs ? "memfs" : undefined);
           const personalityOptions = personality ? await buildCreateAgentOptionsForPersonality({
             personalityId: personality,
             model: effectiveModel
@@ -238820,16 +239807,15 @@ Error: ${message}`);
           skipPromptUpdate: shouldCreateNew
         })) : Promise.resolve().then(() => {
           if (backend4.capabilities.localMemfs) {
-            if (noMemfsFlag) {
-              throw new Error("Disabling MemFS is not supported by the local backend.");
-            }
-            settingsManager2.setMemfsEnabled(agentId2, true);
-            return { action: "enabled" };
+            settingsManager2.setMemfsEnabled(agentId2, !localNoMemfsRequested);
+            return {
+              action: localNoMemfsRequested ? "disabled" : "enabled"
+            };
           }
           if (memfsFlag) {
             throw new Error("MemFS is not supported by the active backend.");
           }
-          if (noMemfsFlag) {
+          if (noMemfsFlag || localNoMemfsRequested) {
             settingsManager2.setMemfsEnabled(agentId2, false);
           }
           return null;
@@ -239121,4 +240107,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=6C6C45F6A1ED024464756E2164756E21
+//# debugId=3EDFF39471E7DC8264756E2164756E21