@letta-ai/letta-code 0.23.4 → 0.23.5

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.23.4",
+    version: "0.23.5",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -8394,7 +8394,7 @@ var init_models2 = __esm(() => {
         id: "opus",
         handle: "anthropic/claude-opus-4-6",
         label: "Opus 4.6",
-        description: "Anthropic's best model (high reasoning)",
+        description: "Anthropic's (legacy) best model (high reasoning)",
         isFeatured: true,
         updateArgs: {
           context_window: 200000,
@@ -8458,6 +8458,88 @@ var init_models2 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "opus-4.7",
+        handle: "anthropic/claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Anthropic's best model (med reasoning)",
+        isFeatured: true,
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          reasoning_effort: "medium",
+          enable_reasoner: true,
+          max_reasoning_tokens: 12000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-4.7-low",
+        handle: "anthropic/claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 (low reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          reasoning_effort: "low",
+          enable_reasoner: true,
+          max_reasoning_tokens: 4000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-4.7-medium",
+        handle: "anthropic/claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 (med reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          reasoning_effort: "medium",
+          enable_reasoner: true,
+          max_reasoning_tokens: 12000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-4.7-high",
+        handle: "anthropic/claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 (high reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          reasoning_effort: "high",
+          enable_reasoner: true,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-4.7-xhigh",
+        handle: "anthropic/claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 (extra-high reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          reasoning_effort: "xhigh",
+          enable_reasoner: true,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-4.7-max",
+        handle: "anthropic/claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 (max reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          reasoning_effort: "max",
+          enable_reasoner: true,
+          parallel_tool_calls: true
+        }
+      },
       {
         id: "opus-1m",
         handle: "anthropic/claude-opus-4-6",
@@ -41245,6 +41327,18 @@ function normalizeSlackAttachmentLike(value) {
     files
   };
 }
+function resolveSlackThreadMessageText(message) {
+  const text = typeof message.text === "string" ? message.text.trim() : "";
+  if (text) {
+    return text;
+  }
+  const files = Array.isArray(message.files) ? message.files.map((entry) => normalizeSlackFileLike(entry)).filter((entry) => Boolean(entry)) : [];
+  if (files.length === 0) {
+    return "";
+  }
+  const fileNames = files.map((file) => file.name ?? "file").join(", ");
+  return `[attached: ${fileNames}]`;
+}
 function isAllowedSlackHostname(hostname3) {
   const normalized = hostname3.trim().toLowerCase();
   return ALLOWED_SLACK_HOST_SUFFIXES.some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
@@ -41413,6 +41507,78 @@ async function resolveSlackInboundAttachments(params) {
   }).catch(() => null)));
   return resolved.filter((attachment) => Boolean(attachment));
 }
+async function resolveSlackThreadStarter(params) {
+  try {
+    const response = await params.client.conversations.replies({
+      channel: params.channelId,
+      ts: params.threadTs,
+      limit: 1,
+      inclusive: true
+    });
+    const message = response.messages?.[0];
+    if (!message) {
+      return null;
+    }
+    const text = resolveSlackThreadMessageText(message);
+    if (!text) {
+      return null;
+    }
+    return {
+      text,
+      userId: isNonEmptyString(message.user) ? message.user : undefined,
+      botId: isNonEmptyString(message.bot_id) ? message.bot_id : undefined,
+      ts: isNonEmptyString(message.ts) ? message.ts : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveSlackThreadHistory(params) {
+  const maxMessages = params.limit ?? 20;
+  if (!Number.isFinite(maxMessages) || maxMessages <= 0) {
+    return [];
+  }
+  const fetchLimit = 200;
+  const retained = [];
+  let cursor;
+  try {
+    do {
+      const response = await params.client.conversations.replies({
+        channel: params.channelId,
+        ts: params.threadTs,
+        limit: fetchLimit,
+        inclusive: true,
+        ...cursor ? { cursor } : {}
+      });
+      for (const message of response.messages ?? []) {
+        const text = resolveSlackThreadMessageText(message);
+        if (!text) {
+          continue;
+        }
+        if (params.currentMessageTs && message.ts === params.currentMessageTs) {
+          continue;
+        }
+        if (message.ts === params.threadTs) {
+          continue;
+        }
+        retained.push(message);
+        if (retained.length > maxMessages) {
+          retained.shift();
+        }
+      }
+      const nextCursor = response.response_metadata?.next_cursor;
+      cursor = typeof nextCursor === "string" && nextCursor.trim().length > 0 ? nextCursor.trim() : undefined;
+    } while (cursor);
+    return retained.map((message) => ({
+      text: resolveSlackThreadMessageText(message),
+      userId: isNonEmptyString(message.user) ? message.user : undefined,
+      botId: isNonEmptyString(message.bot_id) ? message.bot_id : undefined,
+      ts: isNonEmptyString(message.ts) ? message.ts : undefined
+    }));
+  } catch {
+    return [];
+  }
+}
 var MAX_SLACK_ATTACHMENTS = 8, MAX_SLACK_ATTACHMENT_BYTES, ALLOWED_SLACK_HOST_SUFFIXES;
 var init_media2 = __esm(() => {
   init_config();
@@ -41428,6 +41594,9 @@ var init_media2 = __esm(() => {
 async function loadSlackBoltModule() {
   return loadChannelRuntimeModule("slack", "@slack/bolt");
 }
+async function loadSlackWebApiModule() {
+  return loadChannelRuntimeModule("slack", "@slack/web-api");
+}
 async function ensureSlackRuntimeInstalled() {
   return ensureChannelRuntimeInstalled("slack");
 }
@@ -41457,6 +41626,22 @@ function resolveSlackAppConstructor(mod) {
   }
   return App2;
 }
+function resolveSlackWebClientModule(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const webClient = Reflect.get(value, "WebClient");
+  return isConstructorFunction(webClient) ? webClient : null;
+}
+function resolveSlackWebClientConstructor(mod) {
+  const defaultExport = mod && typeof mod === "object" ? Reflect.get(mod, "default") : undefined;
+  const nestedDefault = defaultExport && typeof defaultExport === "object" ? Reflect.get(defaultExport, "default") : undefined;
+  const WebClient = resolveSlackWebClientModule(mod) ?? resolveSlackWebClientModule(defaultExport) ?? resolveSlackWebClientModule(nestedDefault) ?? (isConstructorFunction(defaultExport) ? defaultExport : null);
+  if (!WebClient) {
+    throw new Error('Installed Slack runtime did not export constructor "WebClient".');
+  }
+  return WebClient;
+}
 function isNonEmptyString2(value) {
   return typeof value === "string" && value.length > 0;
 }
@@ -41499,7 +41684,7 @@ function resolveUploadMimeType(filePath) {
       return;
   }
 }
-async function uploadSlackFile(slackApp, msg) {
+async function uploadSlackFile(slackClient, msg) {
   if (!msg.mediaPath) {
     throw new Error("mediaPath is required for Slack file uploads.");
   }
@@ -41507,7 +41692,7 @@ async function uploadSlackFile(slackApp, msg) {
   const uploadFileName = msg.fileName ?? basename4(msg.mediaPath);
   const uploadTitle = msg.title ?? uploadFileName;
   const uploadMimeType = resolveUploadMimeType(uploadFileName);
-  const uploadUrlResp = await slackApp.client.files.getUploadURLExternal({
+  const uploadUrlResp = await slackClient.files.getUploadURLExternal({
     filename: uploadFileName,
     length: buffer.length
   });
@@ -41522,7 +41707,7 @@ async function uploadSlackFile(slackApp, msg) {
   if (!uploadResp.ok) {
     throw new Error(`Failed to upload Slack file: HTTP ${uploadResp.status}`);
   }
-  const completeResp = await slackApp.client.files.completeUploadExternal({
+  const completeResp = await slackClient.files.completeUploadExternal({
     files: [{ id: uploadUrlResp.file_id, title: uploadTitle }],
     channel_id: msg.chatId,
     ...msg.text.trim() ? { initial_comment: msg.text } : {},
@@ -41538,6 +41723,27 @@ function resolveSlackUserDisplayName(userInfo) {
   const profile = asRecord2(user?.profile);
   return firstNonEmptyString(profile?.display_name, profile?.real_name, user?.name);
 }
+function truncateSlackThreadLabel(text, maxLength = 80) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 1).trimEnd()}…`;
+}
+function buildSlackThreadLabel(msg, starterText) {
+  if (msg.chatType !== "channel") {
+    return;
+  }
+  const roomLabel = isNonEmptyString2(msg.chatLabel) && msg.chatLabel !== msg.chatId ? ` in ${msg.chatLabel}` : "";
+  const preview = truncateSlackThreadLabel(starterText ?? msg.text);
+  if (preview) {
+    return `Slack thread${roomLabel}: ${preview}`;
+  }
+  return roomLabel ? `Slack thread${roomLabel}` : `Slack thread ${msg.chatId}`;
+}
 async function resolveSlackAccountDisplayName(botToken, appToken) {
   const bolt = await loadSlackBoltModule();
   const App2 = resolveSlackAppConstructor(bolt);
@@ -41563,11 +41769,14 @@ async function resolveSlackAccountDisplayName(botToken, appToken) {
 }
 function createSlackAdapter(config) {
   let app = null;
+  let writeClient = null;
   let running = false;
   let botUserId = null;
   const knownThreadIdsByMessageId = new Map;
   const knownUserDisplayNames = new Map;
   const seenIngressMessageKeys = new Map;
+  const lifecycleStateByMessageKey = new Map;
+  const lifecycleOperationByMessageKey = new Map;
   function buildIngressMessageKey(channelId, messageId) {
     if (!isNonEmptyString2(channelId) || !isNonEmptyString2(messageId)) {
       return null;
@@ -41592,6 +41801,96 @@ function createSlackAdapter(config) {
       }
     }
   }
+  function getLifecycleMessageKey(source) {
+    if (source.channel !== "slack" || !isNonEmptyString2(source.chatId) || !isNonEmptyString2(source.messageId)) {
+      return null;
+    }
+    return `${source.chatId}:${source.messageId}`;
+  }
+  function pruneLifecycleState(now = Date.now()) {
+    for (const [key, entry] of lifecycleStateByMessageKey) {
+      if (entry.updatedAt + SLACK_LIFECYCLE_STATE_TTL_MS <= now) {
+        lifecycleStateByMessageKey.delete(key);
+      }
+    }
+    if (lifecycleStateByMessageKey.size <= SLACK_LIFECYCLE_STATE_MAX) {
+      return;
+    }
+    const oldestEntries = Array.from(lifecycleStateByMessageKey.entries()).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+    const overflowCount = lifecycleStateByMessageKey.size - SLACK_LIFECYCLE_STATE_MAX;
+    for (let index = 0;index < overflowCount; index += 1) {
+      const entry = oldestEntries[index];
+      if (entry) {
+        lifecycleStateByMessageKey.delete(entry[0]);
+      }
+    }
+  }
+  async function sendLifecycleReaction(source, emoji, removeReaction = false) {
+    if (!isNonEmptyString2(source.messageId)) {
+      return;
+    }
+    await ensureApp();
+    const slackClient = await ensureWriteClient();
+    if (removeReaction) {
+      await slackClient.reactions.remove({
+        channel: source.chatId,
+        timestamp: source.messageId,
+        name: emoji
+      });
+      return;
+    }
+    await slackClient.reactions.add({
+      channel: source.chatId,
+      timestamp: source.messageId,
+      name: emoji
+    });
+  }
+  function scheduleLifecycleTransition(source, nextState) {
+    const key = getLifecycleMessageKey(source);
+    if (!key) {
+      return null;
+    }
+    const previous = lifecycleOperationByMessageKey.get(key) ?? Promise.resolve();
+    const operation = previous.catch(() => {}).then(async () => {
+      pruneLifecycleState();
+      const currentState = lifecycleStateByMessageKey.get(key)?.state;
+      if (currentState === nextState) {
+        lifecycleStateByMessageKey.set(key, {
+          state: nextState,
+          updatedAt: Date.now()
+        });
+        return;
+      }
+      if (nextState === "queued") {
+        if (!currentState) {
+          await sendLifecycleReaction(source, "eyes");
+          lifecycleStateByMessageKey.set(key, {
+            state: nextState,
+            updatedAt: Date.now()
+          });
+        }
+        return;
+      }
+      if (currentState === "queued") {
+        try {
+          await sendLifecycleReaction(source, "eyes", true);
+        } catch {}
+      }
+      await sendLifecycleReaction(source, nextState === "completed" ? "white_check_mark" : "x");
+      lifecycleStateByMessageKey.set(key, {
+        state: nextState,
+        updatedAt: Date.now()
+      });
+    }).catch((error) => {
+      console.warn(`[Slack] Failed to update lifecycle reaction for ${key}:`, error instanceof Error ? error.message : error);
+    }).finally(() => {
+      if (lifecycleOperationByMessageKey.get(key) === operation) {
+        lifecycleOperationByMessageKey.delete(key);
+      }
+    });
+    lifecycleOperationByMessageKey.set(key, operation);
+    return operation;
+  }
   function markIngressMessageSeen(channelId, messageId) {
     const key = buildIngressMessageKey(channelId, messageId);
     if (!key) {
@@ -41815,6 +42114,19 @@ function createSlackAdapter(config) {
     app = instance;
     return instance;
   }
+  async function ensureWriteClient() {
+    if (writeClient) {
+      return writeClient;
+    }
+    const webApi = await loadSlackWebApiModule();
+    const WebClient = resolveSlackWebClientConstructor(webApi);
+    writeClient = new WebClient(config.botToken, {
+      retryConfig: {
+        retries: 0
+      }
+    });
+    return writeClient;
+  }
   const adapter = {
     id: `slack:${config.accountId}`,
     channelId: "slack",
@@ -41838,15 +42150,33 @@ function createSlackAdapter(config) {
       await app.stop();
       running = false;
       app = null;
+      writeClient = null;
       botUserId = null;
       seenIngressMessageKeys.clear();
+      lifecycleStateByMessageKey.clear();
+      lifecycleOperationByMessageKey.clear();
       console.log("[Slack] App stopped");
     },
     isRunning() {
       return running;
     },
+    async handleTurnLifecycleEvent(event) {
+      if (!running) {
+        return;
+      }
+      if (event.type === "queued") {
+        await scheduleLifecycleTransition(event.source, "queued");
+        return;
+      }
+      if (event.type === "processing") {
+        return;
+      }
+      const nextState = event.outcome === "completed" ? "completed" : event.outcome === "cancelled" ? "cancelled" : "error";
+      await Promise.all(event.sources.map((source) => scheduleLifecycleTransition(source, nextState)));
+    },
     async sendMessage(msg) {
-      const slackApp = await ensureApp();
+      await ensureApp();
+      const slackClient = await ensureWriteClient();
       if (msg.reaction) {
         const targetMessageId = msg.targetMessageId ?? msg.replyToMessageId;
         if (!targetMessageId) {
@@ -41857,13 +42187,13 @@ function createSlackAdapter(config) {
           throw new Error("Slack reaction emoji cannot be empty.");
         }
         if (msg.removeReaction) {
-          await slackApp.client.reactions.remove({
+          await slackClient.reactions.remove({
             channel: msg.chatId,
             timestamp: targetMessageId,
             name: emoji
           });
         } else {
-          await slackApp.client.reactions.add({
+          await slackClient.reactions.add({
             channel: msg.chatId,
             timestamp: targetMessageId,
             name: emoji
@@ -41872,9 +42202,9 @@ function createSlackAdapter(config) {
         return { messageId: targetMessageId };
       }
       if (msg.mediaPath) {
-        return uploadSlackFile(slackApp, msg);
+        return uploadSlackFile(slackClient, msg);
       }
-      const response = await slackApp.client.chat.postMessage({
+      const response = await slackClient.chat.postMessage({
         channel: msg.chatId,
         text: msg.text,
         ...msg.threadId ?? msg.replyToMessageId ? { thread_ts: msg.threadId ?? msg.replyToMessageId } : {}
@@ -41883,22 +42213,88 @@ function createSlackAdapter(config) {
       return { messageId: response.ts ?? "" };
     },
     async sendDirectReply(chatId, text, options) {
-      const slackApp = await ensureApp();
-      const response = await slackApp.client.chat.postMessage({
+      await ensureApp();
+      const slackClient = await ensureWriteClient();
+      const response = await slackClient.chat.postMessage({
         channel: chatId,
         text,
         ...options?.replyToMessageId ? { thread_ts: options.replyToMessageId } : {}
       });
       rememberMessageThread(response.ts, options?.replyToMessageId ?? response.ts ?? null);
     },
+    async prepareInboundMessage(msg, options) {
+      if (!options?.isFirstRouteTurn || msg.channel !== "slack" || msg.chatType !== "channel" || !isNonEmptyString2(msg.threadId) || !isNonEmptyString2(msg.messageId) || msg.threadId === msg.messageId) {
+        return msg;
+      }
+      const slackApp = await ensureApp();
+      const starter = await resolveSlackThreadStarter({
+        channelId: msg.chatId,
+        threadTs: msg.threadId,
+        client: slackApp.client
+      });
+      const history = await resolveSlackThreadHistory({
+        channelId: msg.chatId,
+        threadTs: msg.threadId,
+        client: slackApp.client,
+        currentMessageTs: msg.messageId,
+        limit: INITIAL_SLACK_THREAD_HISTORY_LIMIT
+      });
+      if (!starter && history.length === 0) {
+        return msg;
+      }
+      const uniqueUserIds = new Set;
+      if (isNonEmptyString2(starter?.userId)) {
+        uniqueUserIds.add(starter.userId);
+      }
+      for (const entry of history) {
+        if (isNonEmptyString2(entry.userId)) {
+          uniqueUserIds.add(entry.userId);
+        }
+      }
+      await Promise.all(Array.from(uniqueUserIds).map(async (userId) => {
+        await resolveUserName(slackApp, userId);
+      }));
+      const resolveThreadSenderName = (userId, botId) => {
+        if (isNonEmptyString2(userId)) {
+          return knownUserDisplayNames.get(userId) ?? userId;
+        }
+        if (isNonEmptyString2(botId)) {
+          return `Bot (${botId})`;
+        }
+        return;
+      };
+      return {
+        ...msg,
+        threadContext: {
+          label: buildSlackThreadLabel(msg, starter?.text),
+          ...starter ? {
+            starter: {
+              messageId: starter.ts,
+              senderId: starter.userId ?? starter.botId,
+              senderName: resolveThreadSenderName(starter.userId, starter.botId),
+              text: starter.text
+            }
+          } : {},
+          ...history.length > 0 ? {
+            history: history.map((entry) => ({
+              messageId: entry.ts,
+              senderId: entry.userId ?? entry.botId,
+              senderName: resolveThreadSenderName(entry.userId, entry.botId),
+              text: entry.text
+            }))
+          } : {}
+        }
+      };
+    },
     onMessage: undefined
   };
   return adapter;
 }
-var SLACK_INGRESS_DEDUPE_TTL_MS = 60000, SLACK_INGRESS_DEDUPE_MAX = 2000;
+var INITIAL_SLACK_THREAD_HISTORY_LIMIT = 20, SLACK_INGRESS_DEDUPE_TTL_MS = 60000, SLACK_INGRESS_DEDUPE_MAX = 2000, SLACK_LIFECYCLE_STATE_TTL_MS, SLACK_LIFECYCLE_STATE_MAX = 2000;
 var init_adapter2 = __esm(() => {
   init_media2();
   init_runtime2();
+  SLACK_LIFECYCLE_STATE_TTL_MS = 6 * 60 * 60 * 1000;
 });
 
 // src/channels/slack/messageActions.ts
@@ -42081,8 +42477,8 @@ var init_plugin2 = __esm(() => {
     metadata: {
       id: "slack",
       displayName: "Slack",
-      runtimePackages: ["@slack/bolt@4.7.0"],
-      runtimeModules: ["@slack/bolt"]
+      runtimePackages: ["@slack/bolt@4.7.0", "@slack/web-api@7.15.0"],
+      runtimeModules: ["@slack/bolt", "@slack/web-api"]
     },
     createAdapter(account) {
       return createSlackAdapter(account);
@@ -42138,8 +42534,8 @@ var init_pluginRegistry = __esm(() => {
       metadata: {
         id: "slack",
         displayName: "Slack",
-        runtimePackages: ["@slack/bolt@4.7.0"],
-        runtimeModules: ["@slack/bolt"]
+        runtimePackages: ["@slack/bolt@4.7.0", "@slack/web-api@7.15.0"],
+        runtimeModules: ["@slack/bolt", "@slack/web-api"]
       },
       load: async () => {
         const { slackChannelPlugin: slackChannelPlugin2 } = await Promise.resolve().then(() => (init_plugin2(), exports_plugin2));
@@ -42724,6 +43120,47 @@ function buildReactionXml(msg) {
   }
   return `<reaction ${attrs.join(" ")} />`;
 }
+function buildThreadContextEntryXml(tagName, entry) {
+  const attrs = [];
+  if (entry.senderId) {
+    attrs.push(`sender_id="${escapeXmlAttribute(entry.senderId)}"`);
+  }
+  if (entry.senderName) {
+    attrs.push(`sender_name="${escapeXmlAttribute(entry.senderName)}"`);
+  }
+  if (entry.messageId) {
+    attrs.push(`message_id="${escapeXmlAttribute(entry.messageId)}"`);
+  }
+  const attrString = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  return `<${tagName}${attrString}>
+${escapeXmlText(entry.text)}
+</${tagName}>`;
+}
+function buildThreadContextXml(msg) {
+  const threadContext = msg.threadContext;
+  if (!threadContext) {
+    return null;
+  }
+  const parts = [];
+  if (threadContext.starter) {
+    parts.push(buildThreadContextEntryXml("thread-starter", threadContext.starter));
+  }
+  const historyEntries = threadContext.history ?? [];
+  if (historyEntries.length > 0) {
+    parts.push([
+      "<thread-history>",
+      ...historyEntries.map((entry) => buildThreadContextEntryXml("thread-message", entry)),
+      "</thread-history>"
+    ].join(`
+`));
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  const attrs = threadContext.label ? ` label="${escapeXmlAttribute(threadContext.label)}"` : "";
+  return [`<thread-context${attrs}>`, ...parts, "</thread-context>"].join(`
+`);
+}
 function buildChannelNotificationXml(msg) {
   const attrs = [
     `source="${escapeXmlAttribute(msg.channel)}"`,
@@ -42742,8 +43179,9 @@ function buildChannelNotificationXml(msg) {
   const attrString = attrs.join(" ");
   const escapedText = msg.text ? escapeXmlText(msg.text) : "";
   const reactionXml = buildReactionXml(msg);
+  const threadContextXml = buildThreadContextXml(msg);
   const attachmentXml = (msg.attachments ?? []).map(buildAttachmentXml);
-  const body = [reactionXml, ...attachmentXml, escapedText].filter(Boolean).join(`
+  const body = [threadContextXml, reactionXml, ...attachmentXml, escapedText].filter(Boolean).join(`
 `);
   return `<channel-notification ${attrString}>
 ${body}
@@ -42828,6 +43266,18 @@ function buildSlackConversationSummary(msg) {
   }
   return `[Slack] Thread${channelLabel || ` ${msg.chatId}`}`;
 }
+function buildChannelTurnSource(route, msg) {
+  return {
+    channel: msg.channel,
+    accountId: msg.accountId,
+    chatId: msg.chatId,
+    chatType: msg.chatType,
+    messageId: msg.messageId,
+    threadId: msg.threadId,
+    agentId: route.agentId,
+    conversationId: route.conversationId
+  };
+}
 function getChannelRegistry() {
   return instance;
 }
@@ -42867,6 +43317,51 @@ class ChannelRegistry {
   getActiveChannelIds() {
     return Array.from(this.adapters.values()).filter((adapter) => adapter.isRunning()).map((adapter) => adapter.channelId ?? adapter.id);
   }
+  async dispatchTurnLifecycleEvent(event) {
+    const groups = new Map;
+    const sources = event.type === "queued" ? [event.source] : event.sources;
+    for (const source of sources) {
+      const adapter = this.getAdapter(source.channel, source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
+      if (!adapter?.handleTurnLifecycleEvent) {
+        continue;
+      }
+      const groupKey = this.getAdapterKey(source.channel, source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
+      const existing = groups.get(groupKey);
+      if (existing) {
+        existing.sources.push(source);
+        continue;
+      }
+      groups.set(groupKey, {
+        adapter,
+        sources: [source]
+      });
+    }
+    for (const { adapter, sources: groupedSources } of groups.values()) {
+      const handleTurnLifecycleEvent = adapter.handleTurnLifecycleEvent;
+      if (!handleTurnLifecycleEvent) {
+        continue;
+      }
+      try {
+        if (event.type === "queued") {
+          const [firstSource] = groupedSources;
+          if (!firstSource) {
+            continue;
+          }
+          await handleTurnLifecycleEvent({
+            type: "queued",
+            source: firstSource
+          });
+          continue;
+        }
+        await handleTurnLifecycleEvent({
+          ...event,
+          sources: groupedSources
+        });
+      } catch (error) {
+        console.error(`[Channels] Failed to handle ${event.type} lifecycle event for ${adapter.channelId ?? adapter.id}/${adapter.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID}:`, error instanceof Error ? error.message : error);
+      }
+    }
+  }
   setMessageHandler(handler) {
     this.messageHandler = handler;
   }
@@ -42985,11 +43480,20 @@ class ChannelRegistry {
     if (!config)
       return;
     if (msg.channel === "slack" && config.channel === "slack") {
-      const slackRoute = await this.ensureSlackRoute(adapter, msg, config);
-      if (!slackRoute) {
+      const slackResult = await this.ensureSlackRoute(adapter, msg, config);
+      if (!slackResult) {
         return;
       }
-      this.deliverOrBuffer(slackRoute, formatChannelNotification(msg));
+      const preparedMessage = adapter.prepareInboundMessage ? await adapter.prepareInboundMessage(msg, {
+        isFirstRouteTurn: slackResult.isFirstRouteTurn
+      }) : msg;
+      this.deliverOrBuffer({
+        route: slackResult.route,
+        content: formatChannelNotification(preparedMessage),
+        turnSources: [
+          buildChannelTurnSource(slackResult.route, preparedMessage)
+        ]
+      });
       return;
     }
     if (config.dmPolicy === "allowlist") {
@@ -43021,7 +43525,11 @@ class ChannelRegistry {
       return;
     }
     const content = formatChannelNotification(msg);
-    this.deliverOrBuffer(route, content);
+    this.deliverOrBuffer({
+      route,
+      content,
+      turnSources: [buildChannelTurnSource(route, msg)]
+    });
   }
   async createConversationForAgent(agentId, summary) {
     const client = await getClient();
@@ -43071,7 +43579,10 @@ class ChannelRegistry {
       route = getRoute(msg.channel, msg.chatId, accountId, routeThreadId);
     }
     if (route) {
-      return route;
+      return {
+        route,
+        isFirstRouteTurn: false
+      };
     }
     if (msg.chatType === "channel" && !msg.isMention) {
       return null;
@@ -43092,14 +43603,17 @@ class ChannelRegistry {
       type: "targets_updated",
       channelId: msg.channel
     });
-    return this.createSlackRoute(config, msg);
+    return {
+      route: await this.createSlackRoute(config, msg),
+      isFirstRouteTurn: true
+    };
   }
-  deliverOrBuffer(route, content) {
+  deliverOrBuffer(delivery) {
     if (this.isReady()) {
-      this.messageHandler?.(route, content);
+      this.messageHandler?.(delivery);
       return;
     }
-    this.buffer.push({ route, content });
+    this.buffer.push(delivery);
   }
   flushBuffer() {
     if (!this.messageHandler)
@@ -43107,7 +43621,7 @@ class ChannelRegistry {
     while (this.buffer.length > 0) {
       const item = this.buffer.shift();
       if (item) {
-        this.messageHandler(item.route, item.content);
+        this.messageHandler(item);
       }
     }
   }
@@ -45617,10 +46131,12 @@ var exports_memoryFilesystem = {};
 __export(exports_memoryFilesystem, {
   renderMemoryFilesystemTree: () => renderMemoryFilesystemTree,
   labelFromRelativePath: () => labelFromRelativePath,
+  isMemfsEnabledOnServer: () => isMemfsEnabledOnServer,
   isLettaCloud: () => isLettaCloud,
   getMemorySystemDir: () => getMemorySystemDir,
   getMemoryFilesystemRoot: () => getMemoryFilesystemRoot,
   ensureMemoryFilesystemDirs: () => ensureMemoryFilesystemDirs,
+  ensureLocalMemfsCheckout: () => ensureLocalMemfsCheckout,
   enableMemfsIfCloud: () => enableMemfsIfCloud,
   applyMemfsFlags: () => applyMemfsFlags,
   MEMORY_TREE_MAX_LINES: () => MEMORY_TREE_MAX_LINES,
@@ -45650,6 +46166,23 @@ function ensureMemoryFilesystemDirs(agentId, homeDir = homedir10()) {
     mkdirSync13(systemDir, { recursive: true });
   }
 }
+async function isMemfsEnabledOnServer(agentId) {
+  const { getClient: getClient3 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const client = await getClient3();
+  const agent = await client.agents.retrieve(agentId);
+  const { GIT_MEMORY_ENABLED_TAG: GIT_MEMORY_ENABLED_TAG2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
+  const enabled = agent.tags?.includes(GIT_MEMORY_ENABLED_TAG2) ?? false;
+  const { settingsManager: settingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), exports_settings_manager));
+  settingsManager2.setMemfsEnabled(agentId, enabled);
+  return enabled;
+}
+async function ensureLocalMemfsCheckout(agentId) {
+  const { isGitRepo: isGitRepo2, cloneMemoryRepo: cloneMemoryRepo2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
+  if (isGitRepo2(agentId)) {
+    return;
+  }
+  await cloneMemoryRepo2(agentId);
+}
 function labelFromRelativePath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   return normalized.replace(/\.md$/, "");
@@ -49895,6 +50428,19 @@ function resolveLettaInvocation(env3 = process.env, argv = process.argv, execPat
   }
   const scriptPath = argv[1] || "";
   if (scriptPath && isDevLettaEntryScript(scriptPath)) {
+    const runtimeName = path4.basename(execPath).toLowerCase();
+    if (runtimeName.includes("bun")) {
+      return {
+        command: execPath,
+        args: [
+          "--loader:.md=text",
+          "--loader:.mdx=text",
+          "--loader:.txt=text",
+          "run",
+          scriptPath
+        ]
+      };
+    }
     return { command: execPath, args: [scriptPath] };
   }
   return null;
@@ -85382,7 +85928,7 @@ __export(exports_diff, {
   ADV_DIFF_IGNORE_WHITESPACE: () => ADV_DIFF_IGNORE_WHITESPACE,
   ADV_DIFF_CONTEXT_LINES: () => ADV_DIFF_CONTEXT_LINES
 });
-import { basename as basename7 } from "node:path";
+import { basename as basename8 } from "node:path";
 function readFileOrNull(p) {
   try {
     return __require("node:fs").readFileSync(p, "utf-8");
@@ -85406,7 +85952,7 @@ function applyAllOccurrences(content, oldStr, newStr) {
   return { ok: true, out: content.split(oldStr).join(newStr) };
 }
 function computeAdvancedDiff(input, opts) {
-  const fileName = basename7(input.filePath || "");
+  const fileName = basename8(input.filePath || "");
   const fileContent = opts?.oldStrOverride !== undefined ? opts.oldStrOverride : readFileOrNull(input.filePath);
   if (fileContent === null && input.kind !== "write") {
     return { mode: "fallback", reason: "File not readable" };
@@ -85472,7 +86018,7 @@ function computeAdvancedDiff(input, opts) {
   return { mode: "advanced", fileName, oldStr, newStr, hunks };
 }
 function parsePatchToAdvancedDiff(patchLines, filePath) {
-  const fileName = basename7(filePath);
+  const fileName = basename8(filePath);
   const hunks = [];
   let currentHunk = null;
   let oldLine = 1;
@@ -85753,8 +86299,8 @@ function isFormatterSegment(tokens) {
   }
 }
 function isShellExecutor2(token) {
-  const basename8 = token.split("/").pop() ?? token;
-  return ["bash", "sh", "zsh", "dash", "ksh"].includes(basename8.toLowerCase());
+  const basename9 = token.split("/").pop() ?? token;
+  return ["bash", "sh", "zsh", "dash", "ksh"].includes(basename9.toLowerCase());
 }
 function normalizeRawCommand(command) {
   if (Array.isArray(command)) {
@@ -86463,7 +87009,7 @@ var init_formatArgsDisplay = __esm(async () => {
 });
 
 // src/helpers/diffPreview.ts
-import path21, { basename as basename8 } from "node:path";
+import path21, { basename as basename9 } from "node:path";
 function parseHunkLinePrefix(raw) {
   if (raw.length === 0) {
     return { type: "context", content: "" };
@@ -86569,7 +87115,7 @@ async function computeDiffPreviews(toolName, toolArgs, workingDirectory = proces
           filePath: resolvedFilePath,
           content: toolArgs.content || ""
         });
-        previews.push(toDiffPreview(result, basename8(filePath)));
+        previews.push(toDiffPreview(result, basename9(filePath)));
       }
     } else if (isFileEditTool2(toolName)) {
       const filePath = toolArgs.file_path;
@@ -86581,7 +87127,7 @@ async function computeDiffPreviews(toolName, toolArgs, workingDirectory = proces
             filePath: resolvedFilePath,
             edits: toolArgs.edits
           });
-          previews.push(toDiffPreview(result, basename8(filePath)));
+          previews.push(toDiffPreview(result, basename9(filePath)));
         } else {
           const result = computeAdvancedDiff2({
             kind: "edit",
@@ -86590,7 +87136,7 @@ async function computeDiffPreviews(toolName, toolArgs, workingDirectory = proces
             newString: toolArgs.new_string || "",
             replaceAll: toolArgs.replace_all
           });
-          previews.push(toDiffPreview(result, basename8(filePath)));
+          previews.push(toDiffPreview(result, basename9(filePath)));
         }
       }
     } else if (isPatchTool2(toolName) && toolArgs.input) {
@@ -86599,7 +87145,7 @@ async function computeDiffPreviews(toolName, toolArgs, workingDirectory = proces
         if (op.kind === "add" || op.kind === "update") {
           const result = parsePatchToAdvancedDiff2(op.patchLines, op.path);
           if (result) {
-            previews.push(toDiffPreview(result, basename8(op.path)));
+            previews.push(toDiffPreview(result, basename9(op.path)));
           }
         }
       }
@@ -86609,7 +87155,7 @@ async function computeDiffPreviews(toolName, toolArgs, workingDirectory = proces
         if (op.kind === "add" || op.kind === "update") {
           const result = parsePatchToAdvancedDiff2(op.patchLines, op.path);
           if (result) {
-            previews.push(toDiffPreview(result, basename8(op.path)));
+            previews.push(toDiffPreview(result, basename9(op.path)));
           }
         }
       }
@@ -89703,6 +90249,65 @@ function mergeDequeuedBatchContent(items) {
     normalizeUserContent: (content) => content
   });
 }
+function getChannelTurnSourceKey(source) {
+  return [
+    source.channel,
+    source.accountId ?? "",
+    source.chatId,
+    source.messageId ?? "",
+    source.threadId ?? "",
+    source.agentId,
+    source.conversationId
+  ].join(":");
+}
+function collectBatchChannelTurnSources(runtime, batch) {
+  const seen = new Set;
+  const sources = [];
+  for (const item of batch.items) {
+    const template = runtime.queuedMessagesByItemId.get(item.id);
+    for (const source of template?.channelTurnSources ?? []) {
+      const key = getChannelTurnSourceKey(source);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      sources.push(source);
+    }
+  }
+  return sources.length > 0 ? sources : undefined;
+}
+async function dispatchChannelTurnLifecycleEvent(event) {
+  if (event.sources.length === 0) {
+    return;
+  }
+  const registry = getChannelRegistry();
+  if (!registry) {
+    return;
+  }
+  if (event.type === "processing") {
+    await registry.dispatchTurnLifecycleEvent(event);
+    return;
+  }
+  await registry.dispatchTurnLifecycleEvent({
+    type: "finished",
+    batchId: event.batchId,
+    sources: event.sources,
+    outcome: event.outcome,
+    ...event.error ? { error: event.error } : {}
+  });
+}
+function mapTurnLifecycleOutcome(lastStopReason, didThrow) {
+  if (didThrow) {
+    return "error";
+  }
+  if (lastStopReason === "cancelled") {
+    return "cancelled";
+  }
+  if (lastStopReason && lastStopReason !== "end_turn") {
+    return "error";
+  }
+  return "completed";
+}
 function isBase64ImageContentPart(part) {
   if (!part || typeof part !== "object") {
     return false;
@@ -89762,6 +90367,7 @@ function getPrimaryQueueMessageItem(items) {
   return null;
 }
 function buildQueuedTurnMessage(runtime, batch) {
+  const channelTurnSources = collectBatchChannelTurnSources(runtime, batch);
   const primaryItem = getPrimaryQueueMessageItem(batch.items);
   if (!primaryItem) {
     for (const item of batch.items) {
@@ -89776,6 +90382,7 @@ function buildQueuedTurnMessage(runtime, batch) {
       type: "message",
       agentId: scopeItem?.agentId ?? runtime.agentId ?? undefined,
       conversationId: scopeItem?.conversationId ?? runtime.conversationId,
+      ...channelTurnSources ? { channelTurnSources } : {},
       messages: [
         {
           role: "user",
@@ -89808,6 +90415,7 @@ function buildQueuedTurnMessage(runtime, batch) {
   messages[firstMessageIndex] = mergedFirstMessage;
   return {
     ...template,
+    ...channelTurnSources ? { channelTurnSources } : {},
     messages
   };
 }
@@ -89888,13 +90496,39 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
         return;
       }
       const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+      const channelTurnSources = queuedTurn.channelTurnSources ?? [];
       emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
       const preTurnStatus = getListenerStatus(runtime.listener) === "processing" ? "processing" : "receiving";
       if (opts.connectionId && runtime.listener.lastEmittedStatus !== preTurnStatus) {
         runtime.listener.lastEmittedStatus = preTurnStatus;
         opts.onStatusChange?.(preTurnStatus, opts.connectionId);
       }
-      await processQueuedTurn(queuedTurn, dequeuedBatch);
+      if (channelTurnSources.length > 0) {
+        await dispatchChannelTurnLifecycleEvent({
+          type: "processing",
+          batchId: dequeuedBatch.batchId,
+          sources: channelTurnSources
+        });
+      }
+      let turnError;
+      let didThrow = false;
+      try {
+        await processQueuedTurn(queuedTurn, dequeuedBatch);
+      } catch (error) {
+        didThrow = true;
+        turnError = error instanceof Error ? error.message : String(error);
+        throw error;
+      } finally {
+        if (channelTurnSources.length > 0) {
+          await dispatchChannelTurnLifecycleEvent({
+            type: "finished",
+            batchId: dequeuedBatch.batchId,
+            sources: channelTurnSources,
+            outcome: mapTurnLifecycleOutcome(runtime.lastStopReason, didThrow),
+            ...turnError ? { error: turnError } : {}
+          });
+        }
+      }
       emitListenerStatus(runtime.listener, opts.onStatusChange, opts.connectionId);
       evictConversationRuntimeIfIdle(runtime);
     }
@@ -89927,6 +90561,7 @@ function scheduleQueuePump(runtime, socket, opts, processQueuedTurn) {
   });
 }
 var init_queue = __esm(async () => {
+  init_registry();
   init_queueRuntime();
   init_errorReporting();
   init_runtime3();
@@ -91033,7 +91668,7 @@ function scanMemoryFilesystem(memoryRoot) {
       } catch {
         return;
       }
-      const relativePath = relative12(memoryRoot, fullPath);
+      const relativePath = relative12(memoryRoot, fullPath).replace(/\\/g, "/");
       const isLast = index === sorted.length - 1;
       nodes.push({
         name: isDir ? `${name}/` : name,
@@ -91406,6 +92041,165 @@ function emitChannelTargetsUpdated(socket, channelId) {
     channel_id: channelId
   }, "listener_channels_send_failed", "listener_channels_command");
 }
+async function handleListMemoryCommand(parsed, socket, overrides = {}) {
+  try {
+    const {
+      ensureLocalMemfsCheckout: actualEnsureLocalMemfsCheckout,
+      getMemoryFilesystemRoot: actualGetMemoryFilesystemRoot,
+      isMemfsEnabledOnServer: actualIsMemfsEnabledOnServer
+    } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
+    const ensureLocalMemfsCheckout2 = overrides.ensureLocalMemfsCheckout ?? actualEnsureLocalMemfsCheckout;
+    const getMemoryFilesystemRoot2 = overrides.getMemoryFilesystemRoot ?? actualGetMemoryFilesystemRoot;
+    const isMemfsEnabledOnServer2 = overrides.isMemfsEnabledOnServer ?? actualIsMemfsEnabledOnServer;
+    const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memoryScanner(), exports_memoryScanner));
+    const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
+    const { existsSync: existsSync26 } = await import("node:fs");
+    const { join: join31, posix: posix2 } = await import("node:path");
+    const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
+    let memfsInitialized = existsSync26(join31(memoryRoot, ".git"));
+    const memfsEnabled = memfsInitialized ? true : await isMemfsEnabledOnServer2(parsed.agent_id);
+    if (!memfsEnabled) {
+      safeSocketSend(socket, {
+        type: "list_memory_response",
+        request_id: parsed.request_id,
+        entries: [],
+        done: true,
+        total: 0,
+        success: true,
+        memfs_enabled: false,
+        memfs_initialized: false
+      }, "listener_list_memory_send_failed", "listener_list_memory");
+      return true;
+    }
+    if (!memfsInitialized) {
+      await ensureLocalMemfsCheckout2(parsed.agent_id);
+      memfsInitialized = existsSync26(join31(memoryRoot, ".git"));
+    }
+    if (!memfsInitialized) {
+      throw new Error("MemFS is enabled, but the local memory checkout could not be initialized.");
+    }
+    const treeNodes = scanMemoryFilesystem2(memoryRoot);
+    const fileNodes = getFileNodes2(treeNodes).filter((n) => n.name.endsWith(".md"));
+    const includeReferences = parsed.include_references === true;
+    const allPaths = new Set(fileNodes.map((node) => node.relativePath));
+    const normalizeMemoryReference = (rawReference, sourcePath) => {
+      let target = rawReference.trim();
+      if (!target) {
+        return null;
+      }
+      if (target.startsWith("http://") || target.startsWith("https://") || target.startsWith("mailto:")) {
+        return null;
+      }
+      target = target.replace(/^<|>$/g, "");
+      target = target.split("#")[0] ?? "";
+      target = target.split("?")[0] ?? "";
+      target = target.trim().replace(/\\/g, "/");
+      if (!target || target.startsWith("#")) {
+        return null;
+      }
+      if (target.includes("|")) {
+        target = target.split("|")[0] ?? "";
+      }
+      if (!target) {
+        return null;
+      }
+      const sourceDir = posix2.dirname(sourcePath.replace(/\\/g, "/"));
+      const candidate = target.startsWith("./") || target.startsWith("../") ? posix2.normalize(posix2.join(sourceDir, target)) : posix2.normalize(target.startsWith("/") ? target.slice(1) : target);
+      if (!candidate || candidate.startsWith("../") || candidate === "." || candidate === "..") {
+        return null;
+      }
+      const withExtension = candidate.endsWith(".md") ? candidate : `${candidate}.md`;
+      const candidates = new Set([withExtension]);
+      const isExplicitRelative = target.startsWith("./") || target.startsWith("../");
+      if (!isExplicitRelative && !target.startsWith("/") && sourceDir && sourceDir !== ".") {
+        candidates.add(posix2.normalize(posix2.join(sourceDir, withExtension)));
+      }
+      if (!withExtension.startsWith("system/")) {
+        candidates.add(posix2.normalize(`system/${withExtension}`));
+      }
+      for (const resolved of candidates) {
+        if (allPaths.has(resolved)) {
+          return resolved;
+        }
+      }
+      return null;
+    };
+    const extractMemoryReferences = (body, sourcePath) => {
+      if (!body.includes("[[")) {
+        return [];
+      }
+      const refs = new Set;
+      for (const wikiMatch of body.matchAll(WIKI_LINK_REGEX)) {
+        const rawTarget = wikiMatch[1];
+        if (!rawTarget)
+          continue;
+        const normalized = normalizeMemoryReference(rawTarget, sourcePath);
+        if (normalized && normalized !== sourcePath) {
+          refs.add(normalized);
+        }
+      }
+      return [...refs];
+    };
+    const CHUNK_SIZE = 5;
+    const total = fileNodes.length;
+    for (let i = 0;i < total; i += CHUNK_SIZE) {
+      const chunk = fileNodes.slice(i, i + CHUNK_SIZE);
+      const entries = chunk.map((node) => {
+        const raw = readFileContent2(node.fullPath);
+        const { frontmatter, body } = parseFrontmatter2(raw);
+        const desc = frontmatter.description;
+        return {
+          relative_path: node.relativePath,
+          is_system: node.relativePath.startsWith("system/") || node.relativePath.startsWith("system\\"),
+          description: typeof desc === "string" ? desc : null,
+          content: body,
+          size: body.length,
+          ...includeReferences ? {
+            references: extractMemoryReferences(body, node.relativePath)
+          } : {}
+        };
+      });
+      const done = i + CHUNK_SIZE >= total;
+      const sent = safeSocketSend(socket, {
+        type: "list_memory_response",
+        request_id: parsed.request_id,
+        entries,
+        done,
+        total,
+        success: true,
+        memfs_enabled: true,
+        memfs_initialized: true
+      }, "listener_list_memory_send_failed", "listener_list_memory");
+      if (!sent) {
+        return true;
+      }
+    }
+    if (total === 0) {
+      safeSocketSend(socket, {
+        type: "list_memory_response",
+        request_id: parsed.request_id,
+        entries: [],
+        done: true,
+        total: 0,
+        success: true,
+        memfs_enabled: true,
+        memfs_initialized: true
+      }, "listener_list_memory_send_failed", "listener_list_memory");
+    }
+  } catch (err) {
+    trackListenerError("listener_list_memory_failed", err, "listener_memory_browser");
+    safeSocketSend(socket, {
+      type: "list_memory_response",
+      request_id: parsed.request_id,
+      entries: [],
+      done: true,
+      total: 0,
+      success: false,
+      error: err instanceof Error ? err.message : "Failed to list memory"
+    }, "listener_list_memory_send_failed", "listener_list_memory");
+  }
+  return true;
+}
 async function handleCronCommand(parsed, socket) {
   if (parsed.type === "cron_list") {
     try {
@@ -92259,7 +93053,7 @@ async function handleSkillCommand(parsed, socket) {
     symlinkSync,
     unlinkSync: unlinkSync8
   } = await import("node:fs");
-  const { basename: basename9, join: join31 } = await import("node:path");
+  const { basename: basename10, join: join31 } = await import("node:path");
   const lettaHome = process.env.LETTA_HOME || join31(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
   const globalSkillsDir = join31(lettaHome, "skills");
   if (parsed.type === "skill_enable") {
@@ -92283,7 +93077,7 @@ async function handleSkillCommand(parsed, socket) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const linkName = basename9(parsed.skill_path);
+      const linkName = basename10(parsed.skill_path);
       const linkPath = join31(globalSkillsDir, linkName);
       mkdirSync19(globalSkillsDir, { recursive: true });
       if (existsSync26(linkPath)) {
@@ -92495,12 +93289,21 @@ function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
   const registry = getChannelRegistry();
   if (!registry)
     return;
-  registry.setMessageHandler((route, messageContent) => {
-    const rawRuntime = getOrCreateConversationRuntime(listener, route.agentId, route.conversationId);
+  registry.setMessageHandler((delivery) => {
+    const rawRuntime = getOrCreateConversationRuntime(listener, delivery.route.agentId, delivery.route.conversationId);
     if (!rawRuntime)
       return;
     const conversationRuntime = ensureConversationQueueRuntime(listener, rawRuntime);
-    enqueueChannelTurn(conversationRuntime, route, messageContent);
+    const enqueuedItem = enqueueChannelTurn(conversationRuntime, delivery.route, delivery.content, delivery.turnSources);
+    if (!enqueuedItem) {
+      return;
+    }
+    for (const turnSource of delivery.turnSources ?? []) {
+      registry.dispatchTurnLifecycleEvent({
+        type: "queued",
+        source: turnSource
+      });
+    }
     scheduleQueuePump(conversationRuntime, socket, opts, processQueuedTurn);
   });
   registry.setEventHandler((event) => {
@@ -92534,7 +93337,7 @@ function stampInboundUserMessageOtids(incoming) {
     messages
   };
 }
-function enqueueChannelTurn(runtime, route, messageContent) {
+function enqueueChannelTurn(runtime, route, messageContent, turnSources) {
   const clientMessageId = `cm-channel-${crypto.randomUUID()}`;
   const enqueuedItem = runtime.queueRuntime.enqueue({
     kind: "message",
@@ -92551,6 +93354,7 @@ function enqueueChannelTurn(runtime, route, messageContent) {
     type: "message",
     agentId: route.agentId,
     conversationId: route.conversationId,
+    ...turnSources?.length ? { channelTurnSources: turnSources } : {},
     messages: [
       {
         role: "user",
@@ -93509,144 +94313,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       }
       if (isListMemoryCommand(parsed)) {
         runDetachedListenerTask("list_memory", async () => {
-          try {
-            const { getMemoryFilesystemRoot: getMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
-            const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memoryScanner(), exports_memoryScanner));
-            const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-            const { existsSync: existsSync26 } = await import("node:fs");
-            const { join: join31, posix: posix2 } = await import("node:path");
-            const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
-            const memfsInitialized = existsSync26(join31(memoryRoot, ".git"));
-            if (!memfsInitialized) {
-              safeSocketSend(socket, {
-                type: "list_memory_response",
-                request_id: parsed.request_id,
-                entries: [],
-                done: true,
-                total: 0,
-                success: true,
-                memfs_initialized: false
-              }, "listener_list_memory_send_failed", "listener_list_memory");
-              return;
-            }
-            const treeNodes = scanMemoryFilesystem2(memoryRoot);
-            const fileNodes = getFileNodes2(treeNodes).filter((n) => n.name.endsWith(".md"));
-            const includeReferences = parsed.include_references === true;
-            const allPaths = new Set(fileNodes.map((node) => node.relativePath));
-            const normalizeMemoryReference = (rawReference, sourcePath) => {
-              let target = rawReference.trim();
-              if (!target) {
-                return null;
-              }
-              if (target.startsWith("http://") || target.startsWith("https://") || target.startsWith("mailto:")) {
-                return null;
-              }
-              target = target.replace(/^<|>$/g, "");
-              target = target.split("#")[0] ?? "";
-              target = target.split("?")[0] ?? "";
-              target = target.trim().replace(/\\/g, "/");
-              if (!target || target.startsWith("#")) {
-                return null;
-              }
-              if (target.includes("|")) {
-                target = target.split("|")[0] ?? "";
-              }
-              if (!target) {
-                return null;
-              }
-              const sourceDir = posix2.dirname(sourcePath.replace(/\\/g, "/"));
-              const candidate = target.startsWith("./") || target.startsWith("../") ? posix2.normalize(posix2.join(sourceDir, target)) : posix2.normalize(target.startsWith("/") ? target.slice(1) : target);
-              if (!candidate || candidate.startsWith("../") || candidate === "." || candidate === "..") {
-                return null;
-              }
-              const withExtension = candidate.endsWith(".md") ? candidate : `${candidate}.md`;
-              const candidates = new Set([withExtension]);
-              const isExplicitRelative = target.startsWith("./") || target.startsWith("../");
-              if (!isExplicitRelative && !target.startsWith("/") && sourceDir && sourceDir !== ".") {
-                candidates.add(posix2.normalize(posix2.join(sourceDir, withExtension)));
-              }
-              if (!withExtension.startsWith("system/")) {
-                candidates.add(posix2.normalize(`system/${withExtension}`));
-              }
-              for (const resolved of candidates) {
-                if (allPaths.has(resolved)) {
-                  return resolved;
-                }
-              }
-              return null;
-            };
-            const extractMemoryReferences = (body, sourcePath) => {
-              if (!body.includes("[[")) {
-                return [];
-              }
-              const refs = new Set;
-              for (const wikiMatch of body.matchAll(WIKI_LINK_REGEX)) {
-                const rawTarget = wikiMatch[1];
-                if (!rawTarget)
-                  continue;
-                const normalized = normalizeMemoryReference(rawTarget, sourcePath);
-                if (normalized && normalized !== sourcePath) {
-                  refs.add(normalized);
-                }
-              }
-              return [...refs];
-            };
-            const CHUNK_SIZE = 5;
-            const total = fileNodes.length;
-            for (let i = 0;i < total; i += CHUNK_SIZE) {
-              const chunk = fileNodes.slice(i, i + CHUNK_SIZE);
-              const entries = chunk.map((node) => {
-                const raw2 = readFileContent2(node.fullPath);
-                const { frontmatter, body } = parseFrontmatter2(raw2);
-                const desc = frontmatter.description;
-                return {
-                  relative_path: node.relativePath,
-                  is_system: node.relativePath.startsWith("system/") || node.relativePath.startsWith("system\\"),
-                  description: typeof desc === "string" ? desc : null,
-                  content: body,
-                  size: body.length,
-                  ...includeReferences ? {
-                    references: extractMemoryReferences(body, node.relativePath)
-                  } : {}
-                };
-              });
-              const done = i + CHUNK_SIZE >= total;
-              const sent = safeSocketSend(socket, {
-                type: "list_memory_response",
-                request_id: parsed.request_id,
-                entries,
-                done,
-                total,
-                success: true,
-                memfs_initialized: true
-              }, "listener_list_memory_send_failed", "listener_list_memory");
-              if (!sent) {
-                return;
-              }
-            }
-            if (total === 0) {
-              safeSocketSend(socket, {
-                type: "list_memory_response",
-                request_id: parsed.request_id,
-                entries: [],
-                done: true,
-                total: 0,
-                success: true,
-                memfs_initialized: true
-              }, "listener_list_memory_send_failed", "listener_list_memory");
-            }
-          } catch (err) {
-            trackListenerError("listener_list_memory_failed", err, "listener_memory_browser");
-            safeSocketSend(socket, {
-              type: "list_memory_response",
-              request_id: parsed.request_id,
-              entries: [],
-              done: true,
-              total: 0,
-              success: false,
-              error: err instanceof Error ? err.message : "Failed to list memory"
-            }, "listener_list_memory_send_failed", "listener_list_memory");
-          }
+          await handleListMemoryCommand(parsed, socket);
         });
         return;
       }
@@ -94324,6 +94991,7 @@ var init_client4 = __esm(async () => {
     handleAbortMessageInput,
     handleChangeDeviceStateInput,
     handleCronCommand,
+    handleListMemoryCommand,
     isDetachedChannelsCommand,
     handleChannelsProtocolCommand,
     handleSkillCommand,
@@ -115408,16 +116076,16 @@ function clipStyledSpans(spans, maxColumns) {
   return { spans: clipped, clipped: false };
 }
 function languageFromPath(filePath) {
-  const basename9 = filePath.split("/").pop() ?? filePath;
-  const lower = basename9.toLowerCase();
+  const basename10 = filePath.split("/").pop() ?? filePath;
+  const lower = basename10.toLowerCase();
   if (lower === "makefile")
     return "makefile";
   if (lower === "dockerfile")
     return "dockerfile";
-  const dotIdx = basename9.lastIndexOf(".");
+  const dotIdx = basename10.lastIndexOf(".");
   if (dotIdx < 0)
     return;
-  const ext3 = basename9.slice(dotIdx + 1).toLowerCase();
+  const ext3 = basename10.slice(dotIdx + 1).toLowerCase();
   return EXT_TO_LANG[ext3];
 }
 function colorForClassName(className, palette) {
@@ -121829,7 +122497,7 @@ var init_pasteRegistry = __esm(() => {
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync34, readFileSync as readFileSync20, statSync as statSync10, unlinkSync as unlinkSync10 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename9, extname as extname8, isAbsolute as isAbsolute20, join as join42, resolve as resolve29 } from "node:path";
+import { basename as basename10, extname as extname8, isAbsolute as isAbsolute20, join as join42, resolve as resolve29 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
 }
@@ -121886,7 +122554,7 @@ function translatePasteForImages(paste) {
         const id = allocateImage({
           data: b64,
           mediaType: mt,
-          filename: basename9(filePath)
+          filename: basename10(filePath)
         });
         s = `[Image #${id}]`;
       }
@@ -123493,7 +124161,7 @@ __export(exports_custom, {
 });
 import { existsSync as existsSync36 } from "node:fs";
 import { readdir as readdir10, readFile as readFile14 } from "node:fs/promises";
-import { basename as basename10, dirname as dirname17, join as join44 } from "node:path";
+import { basename as basename11, dirname as dirname17, join as join44 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -123553,7 +124221,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source2) {
 async function parseCommandFile(filePath, rootPath, source2) {
   const content = await readFile14(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
-  const id = basename10(filePath, ".md");
+  const id = basename11(filePath, ".md");
   const relativePath = dirname17(filePath).slice(rootPath.length);
   const namespace = relativePath.replace(/^[/\\]/, "") || undefined;
   let description = getStringField(frontmatter, "description");
@@ -143554,6 +144222,10 @@ function App2({
   import_react104.useEffect(() => {
     conversationIdRef.current = conversationId;
   }, [conversationId]);
+  const setConversationIdAndRef = import_react104.useCallback((nextConversationId) => {
+    conversationIdRef.current = nextConversationId;
+    setConversationId3(nextConversationId);
+  }, []);
   const pendingTranscriptStartLineIndexRef = import_react104.useRef(null);
   const lastRunIdRef = import_react104.useRef(null);
   const resumeKey = useSuspend();
@@ -143577,10 +144249,9 @@ function App2({
   import_react104.useEffect(() => {
     if (initialConversationId !== prevInitialConversationIdRef.current) {
       prevInitialConversationIdRef.current = initialConversationId;
-      conversationIdRef.current = initialConversationId;
-      setConversationId3(initialConversationId);
+      setConversationIdAndRef(initialConversationId);
     }
-  }, [initialConversationId]);
+  }, [initialConversationId, setConversationIdAndRef]);
   import_react104.useEffect(() => {
     if (agentId) {
       setCurrentAgentId(agentId);
@@ -147071,7 +147742,7 @@ ${feedback}
       const client = await getClient();
       const resumeData = await getResumeData2(client, agentState, conversationId2);
       await maybeCarryOverActiveConversationModel(conversationId2);
-      setConversationId3(conversationId2);
+      setConversationIdAndRef(conversationId2);
       pendingConversationSwitchRef.current = {
         origin: "fork",
         conversationId: conversationId2,
@@ -147136,6 +147807,7 @@ ${feedback}
     runEndHooks,
     maybeCarryOverActiveConversationModel,
     resetBootstrapReminderState,
+    setConversationIdAndRef,
     setCommandRunning,
     setStreaming,
     recoverRestoredPendingApprovals,
@@ -147188,7 +147860,7 @@ ${feedback}
       setLlmConfig(agent.llm_config);
       const agentModelHandle = getPreferredAgentModelHandle2(agent);
       setCurrentModelHandle(agentModelHandle);
-      setConversationId3(targetConversationId);
+      setConversationIdAndRef(targetConversationId);
       resetBootstrapReminderState();
       {
         const { getModelDisplayName: getModelDisplayName3 } = await Promise.resolve().then(() => (init_model2(), exports_model2));
@@ -147241,7 +147913,8 @@ ${feedback}
     resetDeferredToolCallCommits,
     resetTrajectoryBases,
     resetBootstrapReminderState,
-    resetPendingReasoningCycle
+    resetPendingReasoningCycle,
+    setConversationIdAndRef
   ]);
   const handleCreateNewAgent = import_react104.useCallback(async (name) => {
     setActiveOverlay(null);
@@ -147309,7 +147982,7 @@ ${feedback}
       setLlmConfig(agent.llm_config);
       const agentModelHandle = getPreferredAgentModelHandle2(agent);
       setCurrentModelHandle(agentModelHandle);
-      setConversationId3(targetConversationId);
+      setConversationIdAndRef(targetConversationId);
       pendingConversationSwitchRef.current = {
         origin: "agent-switch",
         conversationId: targetConversationId,
@@ -147343,7 +148016,8 @@ ${feedback}
     setCommandRunning,
     resetDeferredToolCallCommits,
     resetTrajectoryBases,
-    resetBootstrapReminderState
+    resetBootstrapReminderState,
+    setConversationIdAndRef
   ]);
   const handleBashSubmit = import_react104.useCallback(async (command) => {
     if (bashRunning)
@@ -148284,7 +148958,7 @@ Type your task to begin the loop.`, true);
             hasSetConversationSummaryRef.current = true;
           }
           await maybeCarryOverActiveConversationModel(conversation.id);
-          setConversationId3(conversation.id);
+          setConversationIdAndRef(conversation.id);
           pendingConversationSwitchRef.current = {
             origin: "new",
             conversationId: conversation.id,
@@ -148329,7 +149003,7 @@ Type your task to begin the loop.`, true);
             hasSetConversationSummaryRef.current = true;
           }
           await maybeCarryOverActiveConversationModel(forked.id);
-          setConversationId3(forked.id);
+          setConversationIdAndRef(forked.id);
           pendingConversationSwitchRef.current = {
             origin: "fork",
             conversationId: forked.id,
@@ -148383,7 +149057,7 @@ Type your task to begin the loop.`, true);
             isolated_block_labels: [...ISOLATED_BLOCK_LABELS]
           });
           await maybeCarryOverActiveConversationModel(conversation.id);
-          setConversationId3(conversation.id);
+          setConversationIdAndRef(conversation.id);
           pendingConversationSwitchRef.current = {
             origin: "clear",
             conversationId: conversation.id,
@@ -148634,7 +149308,7 @@ Type your task to begin the loop.`, true);
             if (agentState) {
               const client = await getClient();
               const resumeData = await getResumeData2(client, agentState, targetConvId);
-              setConversationId3(targetConvId);
+              setConversationIdAndRef(targetConvId);
               pendingConversationSwitchRef.current = {
                 origin: "resume-direct",
                 conversationId: targetConvId,
@@ -149569,7 +150243,7 @@ ${SYSTEM_REMINDER_CLOSE}
         name: agentName,
         description: agentDescription,
         lastRunAt: agentLastRunAt,
-        conversationId
+        conversationId: conversationIdRef.current
       },
       state: sharedReminderStateRef.current,
       sessionContextReminderEnabled,
@@ -150022,6 +150696,7 @@ ${SYSTEM_REMINDER_CLOSE}
     agentName,
     agentDescription,
     agentLastRunAt,
+    conversationId,
     commandRunner,
     handleExit,
     isExecutingTool,
@@ -150040,7 +150715,8 @@ ${SYSTEM_REMINDER_CLOSE}
     resetTrajectoryBases,
     sessionContextReminderEnabled,
     appendTaskNotificationEvents,
-    maybeCarryOverActiveConversationModel
+    maybeCarryOverActiveConversationModel,
+    setConversationIdAndRef
   ]);
   const onSubmitRef = import_react104.useRef(onSubmit);
   import_react104.useEffect(() => {
@@ -151040,7 +151716,7 @@ ${guidance}`);
               const client = await getClient();
               if (agentState) {
                 const resumeData = await getResumeData2(client, agentState, action.conversationId);
-                setConversationId3(action.conversationId);
+                setConversationIdAndRef(action.conversationId);
                 pendingConversationSwitchRef.current = {
                   origin: "resume-selector",
                   conversationId: action.conversationId,
@@ -151093,7 +151769,8 @@ ${guidance}`);
     commandRunner.getHandle,
     commandRunner.start,
     recoverRestoredPendingApprovals,
-    resetBootstrapReminderState
+    resetBootstrapReminderState,
+    setConversationIdAndRef
   ]);
   const handleFeedbackSubmit = import_react104.useCallback(async (message) => {
     const overlayCommand = consumeOverlayCommand("feedback");
@@ -152351,7 +153028,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                     if (agentState) {
                       const client = await getClient();
                       const resumeData = await getResumeData2(client, agentState, convId);
-                      setConversationId3(convId);
+                      setConversationIdAndRef(convId);
                       pendingConversationSwitchRef.current = {
                         origin: "resume-selector",
                         conversationId: convId,
@@ -152463,7 +153140,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                       isolated_block_labels: [...ISOLATED_BLOCK_LABELS]
                     });
                     await maybeCarryOverActiveConversationModel(conversation.id);
-                    setConversationId3(conversation.id);
+                    setConversationIdAndRef(conversation.id);
                     settingsManager.persistSession(agentId, conversation.id);
                     const currentAgentName = agentState?.name || "Unnamed Agent";
                     const shortConvId = conversation.id.slice(0, 20);
@@ -152547,7 +153224,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                     if (agentState) {
                       const client = await getClient();
                       const resumeData = await getResumeData2(client, agentState, actualTargetConv);
-                      setConversationId3(actualTargetConv);
+                      setConversationIdAndRef(actualTargetConv);
                       pendingConversationSwitchRef.current = {
                         origin: "search",
                         conversationId: actualTargetConv,
@@ -153919,10 +154596,12 @@ var exports_memoryFilesystem2 = {};
 __export(exports_memoryFilesystem2, {
   renderMemoryFilesystemTree: () => renderMemoryFilesystemTree2,
   labelFromRelativePath: () => labelFromRelativePath2,
+  isMemfsEnabledOnServer: () => isMemfsEnabledOnServer2,
   isLettaCloud: () => isLettaCloud2,
   getMemorySystemDir: () => getMemorySystemDir2,
   getMemoryFilesystemRoot: () => getMemoryFilesystemRoot2,
   ensureMemoryFilesystemDirs: () => ensureMemoryFilesystemDirs2,
+  ensureLocalMemfsCheckout: () => ensureLocalMemfsCheckout2,
   enableMemfsIfCloud: () => enableMemfsIfCloud2,
   applyMemfsFlags: () => applyMemfsFlags2,
   MEMORY_TREE_MAX_LINES: () => MEMORY_TREE_MAX_LINES2,
@@ -153952,6 +154631,23 @@ function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir41()) {
     mkdirSync30(systemDir, { recursive: true });
   }
 }
+async function isMemfsEnabledOnServer2(agentId) {
+  const { getClient: getClient3 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const client = await getClient3();
+  const agent = await client.agents.retrieve(agentId);
+  const { GIT_MEMORY_ENABLED_TAG: GIT_MEMORY_ENABLED_TAG2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
+  const enabled = agent.tags?.includes(GIT_MEMORY_ENABLED_TAG2) ?? false;
+  const { settingsManager: settingsManager3 } = await Promise.resolve().then(() => (init_settings_manager(), exports_settings_manager));
+  settingsManager3.setMemfsEnabled(agentId, enabled);
+  return enabled;
+}
+async function ensureLocalMemfsCheckout2(agentId) {
+  const { isGitRepo: isGitRepo2, cloneMemoryRepo: cloneMemoryRepo2 } = await Promise.resolve().then(() => (init_memoryGit(), exports_memoryGit));
+  if (isGitRepo2(agentId)) {
+    return;
+  }
+  await cloneMemoryRepo2(agentId);
+}
 function labelFromRelativePath2(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   return normalized.replace(/\.md$/, "");
@@ -163181,4 +163877,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=29DBF7A2819CB6C064756E2164756E21
+//# debugId=E826850D234138B664756E2164756E21