@letta-ai/letta-code 0.23.4 → 0.23.6

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.6",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -8391,10 +8391,10 @@ var init_models2 = __esm(() => {
         }
       },
       {
-        id: "opus",
+        id: "opus-4.6-high",
         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,74 @@ var init_models2 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "opus",
+        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-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",
@@ -10179,6 +10247,11 @@ function getModelInfoForLlmConfig(modelHandle, llmConfig) {
     const match = candidates.find((m) => m.updateArgs?.reasoning_effort === effort);
     if (match)
       return match;
+    if (effort === "max") {
+      const legacyXHighMatch = candidates.find((m) => m.updateArgs?.reasoning_effort === "xhigh");
+      if (legacyXHighMatch)
+        return legacyXHighMatch;
+    }
   }
   if (llmConfig?.enable_reasoner === false) {
     const match = candidates.find((m) => m.updateArgs?.enable_reasoner === false);
@@ -10295,7 +10368,8 @@ var init_model = __esm(() => {
     "low",
     "medium",
     "high",
-    "xhigh"
+    "xhigh",
+    "max"
   ];
   RESUME_REFRESH_FIELDS = [
     "max_output_tokens",
@@ -37776,6 +37850,11 @@ function getModelInfoForLlmConfig2(modelHandle, llmConfig) {
     const match = candidates.find((m) => m.updateArgs?.reasoning_effort === effort);
     if (match)
       return match;
+    if (effort === "max") {
+      const legacyXHighMatch = candidates.find((m) => m.updateArgs?.reasoning_effort === "xhigh");
+      if (legacyXHighMatch)
+        return legacyXHighMatch;
+    }
   }
   if (llmConfig?.enable_reasoner === false) {
     const match = candidates.find((m) => m.updateArgs?.enable_reasoner === false);
@@ -37892,7 +37971,8 @@ var init_model2 = __esm(() => {
     "low",
     "medium",
     "high",
-    "xhigh"
+    "xhigh",
+    "max"
   ];
   RESUME_REFRESH_FIELDS2 = [
     "max_output_tokens",
@@ -38170,6 +38250,9 @@ __export(exports_modify, {
   updateAgentLLMConfig: () => updateAgentLLMConfig2,
   recompileAgentSystemPrompt: () => recompileAgentSystemPrompt
 });
+function supportsDistinctAnthropicXHighEffort2(modelHandle) {
+  return modelHandle.includes("claude-opus-4-7");
+}
 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/");
@@ -38203,10 +38286,13 @@ function buildModelSettings2(modelHandle, updateArgs) {
       parallel_tool_calls: true
     };
     const effort = updateArgs?.reasoning_effort;
+    const hasDistinctXHigh = supportsDistinctAnthropicXHighEffort2(modelHandle);
     if (effort === "low" || effort === "medium" || effort === "high") {
       anthropicSettings.effort = effort;
     } else if (effort === "xhigh") {
-      anthropicSettings.effort = "max";
+      anthropicSettings.effort = hasDistinctXHigh ? "xhigh" : "max";
+    } else if (effort === "max") {
+      anthropicSettings.effort = effort;
     }
     if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
       anthropicSettings.thinking = {
@@ -38259,10 +38345,13 @@ function buildModelSettings2(modelHandle, updateArgs) {
       parallel_tool_calls: true
     };
     const effort = updateArgs?.reasoning_effort;
+    const hasDistinctXHigh = supportsDistinctAnthropicXHighEffort2(modelHandle);
     if (effort === "low" || effort === "medium" || effort === "high") {
       bedrockSettings.effort = effort;
     } else if (effort === "xhigh") {
-      bedrockSettings.effort = "max";
+      bedrockSettings.effort = hasDistinctXHigh ? "xhigh" : "max";
+    } else if (effort === "max") {
+      bedrockSettings.effort = effort;
     }
     if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
       bedrockSettings.thinking = {
@@ -39720,6 +39809,9 @@ function normalizeLoadedAccount(account) {
   if (next.channel === "telegram" && (next.displayName === "Telegram bot" || next.displayName === "Migrated Telegram bot") || next.channel === "slack" && (next.displayName === "Slack app" || next.displayName === "Migrated Slack app")) {
     next.displayName = undefined;
   }
+  if (next.channel === "slack") {
+    next.defaultPermissionMode = next.defaultPermissionMode ?? "default";
+  }
   return next;
 }
 function makeDefaultLegacyAccount(channelId) {
@@ -39754,6 +39846,7 @@ function makeDefaultLegacyAccount(channelId) {
     dmPolicy: config.dmPolicy,
     allowedUsers: [...config.allowedUsers],
     agentId: null,
+    defaultPermissionMode: "default",
     createdAt: now,
     updatedAt: now
   };
@@ -40574,14 +40667,27 @@ function getPackageManagerExecutable(packageManager) {
   }
   return packageManager;
 }
+function resolveInstallPlatform() {
+  return platformOverride ?? process.platform;
+}
 function getInstallArgs(packageManager, installPackages) {
+  const noBinLinks = resolveInstallPlatform() === "win32" && packageManager !== "bun";
   switch (packageManager) {
     case "bun":
       return ["add", "--no-save", ...installPackages];
     case "pnpm":
-      return ["add", ...installPackages];
+      return [
+        "add",
+        ...noBinLinks ? ["--no-bin-links"] : [],
+        ...installPackages
+      ];
     case "npm":
-      return ["install", "--no-save", ...installPackages];
+      return [
+        "install",
+        "--no-save",
+        ...noBinLinks ? ["--no-bin-links"] : [],
+        ...installPackages
+      ];
   }
 }
 async function installChannelRuntime(channelId) {
@@ -41214,6 +41320,14 @@ var init_plugin = __esm(() => {
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
 import { basename as basename3, extname as extname2, join as join12 } from "node:path";
+function mapSlackThreadMessage(message) {
+  return {
+    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
+  };
+}
 function asRecord(value) {
   return value && typeof value === "object" ? value : null;
 }
@@ -41245,6 +41359,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 +41539,97 @@ 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(mapSlackThreadMessage);
+  } catch {
+    return [];
+  }
+}
+async function resolveSlackChannelHistory(params) {
+  const maxMessages = params.limit ?? 20;
+  if (!Number.isFinite(maxMessages) || maxMessages <= 0) {
+    return [];
+  }
+  const fetchLimit = Math.min(Math.max(maxMessages * 3, maxMessages), 100);
+  try {
+    const response = await params.client.conversations.history({
+      channel: params.channelId,
+      latest: params.beforeTs,
+      inclusive: false,
+      limit: fetchLimit
+    });
+    const retained = (response.messages ?? []).filter((message) => {
+      if (message.ts === params.beforeTs) {
+        return false;
+      }
+      return Boolean(resolveSlackThreadMessageText(message));
+    }).slice(0, fetchLimit).reverse();
+    return retained.slice(-maxMessages).map(mapSlackThreadMessage);
+  } catch {
+    return [];
+  }
+}
 var MAX_SLACK_ATTACHMENTS = 8, MAX_SLACK_ATTACHMENT_BYTES, ALLOWED_SLACK_HOST_SUFFIXES;
 var init_media2 = __esm(() => {
   init_config();
@@ -41428,6 +41645,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 +41677,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 +41735,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 +41743,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 +41758,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 +41774,34 @@ 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}`;
+}
+function buildSlackChannelContextLabel(msg) {
+  if (msg.chatType !== "channel") {
+    return;
+  }
+  const roomLabel = isNonEmptyString2(msg.chatLabel) && msg.chatLabel !== msg.chatId ? ` in ${msg.chatLabel}` : "";
+  return roomLabel ? `Slack channel context${roomLabel} before thread start` : `Slack channel context before thread start`;
+}
 async function resolveSlackAccountDisplayName(botToken, appToken) {
   const bolt = await loadSlackBoltModule();
   const App2 = resolveSlackAppConstructor(bolt);
@@ -41563,11 +41827,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 +41859,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 +42172,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 +42208,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 +42245,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 +42260,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 +42271,98 @@ 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)) {
+        return msg;
+      }
+      const shouldHydrateExistingThreadContext = msg.threadId !== msg.messageId;
+      const shouldHydrateChannelBootstrapContext = msg.isMention === true && msg.threadId === msg.messageId;
+      if (!shouldHydrateExistingThreadContext && !shouldHydrateChannelBootstrapContext) {
+        return msg;
+      }
+      const slackApp = await ensureApp();
+      const starter = shouldHydrateExistingThreadContext ? await resolveSlackThreadStarter({
+        channelId: msg.chatId,
+        threadTs: msg.threadId,
+        client: slackApp.client
+      }) : null;
+      const history = shouldHydrateExistingThreadContext ? await resolveSlackThreadHistory({
+        channelId: msg.chatId,
+        threadTs: msg.threadId,
+        client: slackApp.client,
+        currentMessageTs: msg.messageId,
+        limit: INITIAL_SLACK_THREAD_HISTORY_LIMIT
+      }) : await resolveSlackChannelHistory({
+        channelId: msg.chatId,
+        beforeTs: msg.messageId,
+        client: slackApp.client,
+        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: shouldHydrateExistingThreadContext ? buildSlackThreadLabel(msg, starter?.text) : buildSlackChannelContextLabel(msg),
+          ...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
@@ -42040,6 +42504,7 @@ DM Policy — who can message this app directly?
       botToken,
       appToken,
       agentId: null,
+      defaultPermissionMode: "default",
       dmPolicy: policy,
       allowedUsers,
       createdAt: now,
@@ -42081,8 +42546,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 +42603,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 +43189,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 +43248,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 +43335,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 +43386,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 +43549,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 +43594,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();
@@ -43050,6 +43627,16 @@ class ChannelRegistry {
       updatedAt: now
     };
     addRoute(msg.channel, route);
+    if (config.defaultPermissionMode !== "default") {
+      this.eventHandler?.({
+        type: "slack_conversation_created",
+        channelId: "slack",
+        accountId: config.accountId,
+        agentId: config.agentId,
+        conversationId,
+        defaultPermissionMode: config.defaultPermissionMode
+      });
+    }
     return route;
   }
   async ensureSlackRoute(adapter, msg, config) {
@@ -43071,7 +43658,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 +43682,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 +43700,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 +46210,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 +46245,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 +50507,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;
@@ -74195,7 +74820,12 @@ async function executeTool(name, args, options) {
         enhancedArgs = { ...enhancedArgs, signal: options.signal };
       }
       if (options?.onOutput) {
-        enhancedArgs = { ...enhancedArgs, onOutput: options.onOutput };
+        enhancedArgs = {
+          ...enhancedArgs,
+          onOutput: (chunk, stream2) => {
+            options.onOutput?.(scrubSecretsFromString(chunk), stream2);
+          }
+        };
       }
       enhancedArgs = substituteSecretsInArgs(enhancedArgs);
     }
@@ -74695,6 +75325,7 @@ function toAccountSnapshot(account) {
     hasBotToken: account.botToken.trim().length > 0,
     hasAppToken: account.appToken.trim().length > 0,
     agentId: account.agentId,
+    defaultPermissionMode: account.defaultPermissionMode ?? "default",
     createdAt: account.createdAt,
     updatedAt: account.updatedAt
   };
@@ -74727,6 +75358,7 @@ function createAccountFromPatch(channelId, accountId, patch) {
     botToken: patch.botToken ?? "",
     appToken: patch.appToken ?? "",
     agentId: patch.agentId ?? null,
+    defaultPermissionMode: patch.defaultPermissionMode ?? "default",
     dmPolicy: patch.dmPolicy ?? "open",
     allowedUsers: patch.allowedUsers ?? [],
     createdAt: now,
@@ -74754,6 +75386,7 @@ function mergeAccountPatch(existing, patch) {
     botToken: patch.botToken ?? existing.botToken,
     appToken: patch.appToken ?? existing.appToken,
     agentId: patch.agentId ?? existing.agentId,
+    defaultPermissionMode: patch.defaultPermissionMode ?? existing.defaultPermissionMode ?? "default",
     dmPolicy: patch.dmPolicy ?? existing.dmPolicy,
     allowedUsers: patch.allowedUsers ?? existing.allowedUsers,
     updatedAt: nextUpdatedAt
@@ -76790,7 +77423,7 @@ function addTask(input) {
       prompt: input.prompt,
       status: "active",
       created_at: now.toISOString(),
-      expires_at: input.recurring ? new Date(now.getTime() + DEFAULT_TTL_MS).toISOString() : null,
+      expires_at: null,
       last_fired_at: null,
       fire_count: 0,
       cancel_reason: null,
@@ -76918,10 +77551,9 @@ function getCronFileMtime() {
     return 0;
   }
 }
-var CRON_FILE_NAME = "crons.json", LOCK_DIR_NAME = "crons.lock", LOCK_TOKEN_FILE = "owner.json", LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 50, LOCK_STALE_AGE_MS = 30000, MAX_ACTIVE_TASKS_PER_AGENT = 50, TASK_ID_BYTES = 4, DEFAULT_TTL_MS, GC_AGE_MS;
+var CRON_FILE_NAME = "crons.json", LOCK_DIR_NAME = "crons.lock", LOCK_TOKEN_FILE = "owner.json", LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 50, LOCK_STALE_AGE_MS = 30000, MAX_ACTIVE_TASKS_PER_AGENT = 50, TASK_ID_BYTES = 4, GC_AGE_MS;
 var init_cronFile = __esm(() => {
   init_parseInterval();
-  DEFAULT_TTL_MS = 3 * 24 * 60 * 60 * 1000;
   GC_AGE_MS = 24 * 60 * 60 * 1000;
 });
 
@@ -83968,6 +84600,25 @@ function normalizeInterruptOutputLines(value) {
   const combinedLength = filtered.reduce((sum, entry) => sum + entry.length, 0);
   return combinedLength <= INTERRUPT_TOOL_RETURN_MAX_CHARS ? filtered : undefined;
 }
+function appendStreamingOutputWithCap(current, chunk) {
+  if (chunk.length === 0) {
+    return current;
+  }
+  const next = `${current}${chunk}`;
+  if (next.length <= STREAMING_TOOL_OUTPUT_MAX_CHARS) {
+    return next;
+  }
+  return next.slice(next.length - STREAMING_TOOL_OUTPUT_MAX_CHARS);
+}
+function normalizeStreamingOutputLines(text) {
+  if (text.length === 0) {
+    return;
+  }
+  const lines = text.replace(/\r\n/g, `
+`).split(`
+`).filter((line) => line.length > 0);
+  return lines.length > 0 ? lines : undefined;
+}
 function asToolReturnStatus(value) {
   if (value === "success" || value === "error") {
     return value;
@@ -84181,6 +84832,54 @@ function emitToolExecutionFinishedEvents(socket, runtime, params) {
     });
   }
 }
+function createToolExecutionOutputEmitter(socket, runtime, params) {
+  const outputByToolCallId = new Map;
+  return (toolCallId, chunk, isStderr = false) => {
+    if (!toolCallId || chunk.length === 0) {
+      return;
+    }
+    const existing = outputByToolCallId.get(toolCallId);
+    const outputState = existing ?? {
+      messageId: `message-tool-return-stream-${toolCallId}`,
+      stdout: "",
+      stderr: ""
+    };
+    if (isStderr) {
+      outputState.stderr = appendStreamingOutputWithCap(outputState.stderr, chunk);
+    } else {
+      outputState.stdout = appendStreamingOutputWithCap(outputState.stdout, chunk);
+    }
+    outputByToolCallId.set(toolCallId, outputState);
+    const stdout = normalizeStreamingOutputLines(outputState.stdout);
+    const stderr = normalizeStreamingOutputLines(outputState.stderr);
+    const toolReturn = [stdout?.join(`
+`), stderr?.join(`
+`)].filter((part) => typeof part === "string" && part.length > 0).join(`
+`);
+    emitCanonicalMessageDelta(socket, runtime, {
+      type: "message",
+      message_type: "tool_return_message",
+      id: outputState.messageId,
+      date: new Date().toISOString(),
+      run_id: params.runId ?? runtime.activeRunId ?? undefined,
+      status: "success",
+      tool_call_id: toolCallId,
+      tool_return: toolReturn,
+      tool_returns: [
+        {
+          tool_call_id: toolCallId,
+          status: "success",
+          tool_return: toolReturn,
+          ...stdout ? { stdout } : {},
+          ...stderr ? { stderr } : {}
+        }
+      ]
+    }, {
+      agent_id: params.agentId,
+      conversation_id: params.conversationId
+    });
+  };
+}
 function getInterruptApprovalsForEmission(runtime, params) {
   if (params.lastExecutionResults && params.lastExecutionResults.length > 0) {
     return params.lastExecutionResults;
@@ -84297,7 +84996,7 @@ function stashRecoveredApprovalInterrupts(runtime, recovered) {
   clearRecoveredApprovalState(runtime);
   return true;
 }
-var INTERRUPT_TOOL_RETURN_MAX_CHARS;
+var INTERRUPT_TOOL_RETURN_MAX_CHARS, STREAMING_TOOL_OUTPUT_MAX_CHARS;
 var init_interrupts = __esm(async () => {
   init_approval_result_normalization();
   init_constants();
@@ -84309,6 +85008,7 @@ var init_interrupts = __esm(async () => {
     init_protocol_outbound()
   ]);
   INTERRUPT_TOOL_RETURN_MAX_CHARS = LIMITS.BASH_OUTPUT_CHARS;
+  STREAMING_TOOL_OUTPUT_MAX_CHARS = LIMITS.BASH_OUTPUT_CHARS;
 });
 
 // src/websocket/listener/permissionMode.ts
@@ -85382,7 +86082,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 +86106,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 +86172,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 +86453,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 +87163,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 +87269,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 +87281,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 +87290,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 +87299,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 +87309,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)));
           }
         }
       }
@@ -87149,6 +87849,11 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
     agentId: recovered.agentId,
     conversationId: recovered.conversationId
   });
+  const emitToolExecutionOutput = createToolExecutionOutputEmitter(socket, runtime, {
+    runId: runtime.activeRunId ?? undefined,
+    agentId: recovered.agentId,
+    conversationId: recovered.conversationId
+  });
   const recoveryAbortController = new AbortController;
   runtime.activeAbortController = recoveryAbortController;
   const preparedToolContext = await prepareToolExecutionContextForScope({
@@ -87163,6 +87868,7 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
   try {
     const approvalResults = await executeApprovalBatch(decisions, undefined, {
       abortSignal: recoveryAbortController.signal,
+      onStreamingOutput: emitToolExecutionOutput,
       toolContextId: preparedToolContext.preparedToolContext.contextId,
       workingDirectory,
       parentScope: recovered.agentId && recovered.conversationId ? {
@@ -87433,9 +88139,15 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
       agentId: runtime.agentId ?? undefined,
       conversationId: recoveryConversationId
     });
+    const emitToolExecutionOutput = createToolExecutionOutputEmitter(socket, runtime, {
+      runId: runtime.activeRunId ?? undefined,
+      agentId: runtime.agentId ?? undefined,
+      conversationId: recoveryConversationId
+    });
     try {
       const approvalResults = await executeApprovalBatch(decisions, undefined, {
         abortSignal,
+        onStreamingOutput: emitToolExecutionOutput,
         toolContextId: preparedToolContext.preparedToolContext.contextId,
         workingDirectory: recoveryWorkingDirectory,
         parentScope: runtime.agentId && runtime.conversationId ? {
@@ -88004,6 +88716,11 @@ async function handleApprovalStop(params) {
     agentId,
     conversationId
   });
+  const emitToolExecutionOutput = createToolExecutionOutputEmitter(socket, runtime, {
+    runId: executionRunId,
+    agentId,
+    conversationId
+  });
   if (shouldInterrupt()) {
     return interruptTermination();
   }
@@ -88022,6 +88739,7 @@ async function handleApprovalStop(params) {
   const executionResults = await executeApprovalBatch(decisions, undefined, {
     toolContextId: turnToolContextId ?? undefined,
     abortSignal: abortController.signal,
+    onStreamingOutput: emitToolExecutionOutput,
     workingDirectory: turnWorkingDirectory,
     parentScope: agentId && conversationId ? { agentId, conversationId } : undefined,
     onFileWrite
@@ -89703,6 +90421,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 +90539,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 +90554,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 +90587,7 @@ function buildQueuedTurnMessage(runtime, batch) {
   messages[firstMessageIndex] = mergedFirstMessage;
   return {
     ...template,
+    ...channelTurnSources ? { channelTurnSources } : {},
     messages
   };
 }
@@ -89888,13 +90668,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 +90733,7 @@ function scheduleQueuePump(runtime, socket, opts, processQueuedTurn) {
   });
 }
 var init_queue = __esm(async () => {
+  init_registry();
   init_queueRuntime();
   init_errorReporting();
   init_runtime3();
@@ -89961,11 +90768,6 @@ function refreshTaskCache(state) {
   }
 }
 function shouldFireTask(task2, now) {
-  if (task2.recurring && task2.expires_at) {
-    if (new Date(task2.expires_at).getTime() <= now.getTime()) {
-      return false;
-    }
-  }
   if (!task2.recurring && task2.scheduled_for) {
     const scheduledMs = new Date(task2.scheduled_for).getTime() + task2.jitter_offset_ms;
     return scheduledMs <= now.getTime();
@@ -90005,16 +90807,6 @@ function fireCronTask(task2, now, socket, opts, processQueuedTurn) {
     });
   }
 }
-function handleExpiredRecurring(task2, now) {
-  if (!task2.recurring || !task2.expires_at)
-    return;
-  if (new Date(task2.expires_at).getTime() <= now.getTime()) {
-    updateTask(task2.id, (t) => {
-      t.status = "cancelled";
-      t.cancel_reason = "expired";
-    });
-  }
-}
 function handleMissedOneShot(task2, now) {
   if (task2.recurring || !task2.scheduled_for)
     return false;
@@ -90043,9 +90835,6 @@ function tick2(state, socket, opts, processQueuedTurn) {
   }
   refreshTaskCache(state);
   for (const task2 of state.cachedTasks) {
-    if (task2.status !== "active")
-      continue;
-    handleExpiredRecurring(task2, now);
     if (task2.status !== "active")
       continue;
     if (handleMissedOneShot(task2, now))
@@ -90509,6 +91298,12 @@ function isListInDirectoryCommand(value) {
   const c = value;
   return c.type === "list_in_directory" && typeof c.path === "string";
 }
+function isGetTreeCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "get_tree" && typeof c.path === "string" && typeof c.depth === "number" && typeof c.request_id === "string";
+}
 function isReadFileCommand(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -90835,7 +91630,7 @@ function parseServerMessage(data) {
   try {
     const raw = typeof data === "string" ? data : data.toString();
     const parsed = JSON.parse(raw);
-    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isFileOpsCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isChannelsListCommand(parsed) || isChannelAccountsListCommand(parsed) || isChannelAccountCreateCommand(parsed) || isChannelAccountUpdateCommand(parsed) || isChannelAccountBindCommand(parsed) || isChannelAccountUnbindCommand(parsed) || isChannelAccountDeleteCommand(parsed) || isChannelAccountStartCommand(parsed) || isChannelAccountStopCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelTargetsListCommand(parsed) || isChannelTargetBindCommand(parsed) || isChannelRouteUpdateCommand(parsed) || isChannelRouteRemoveCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
+    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isGetTreeCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isFileOpsCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isChannelsListCommand(parsed) || isChannelAccountsListCommand(parsed) || isChannelAccountCreateCommand(parsed) || isChannelAccountUpdateCommand(parsed) || isChannelAccountBindCommand(parsed) || isChannelAccountUnbindCommand(parsed) || isChannelAccountDeleteCommand(parsed) || isChannelAccountStartCommand(parsed) || isChannelAccountStopCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelTargetsListCommand(parsed) || isChannelTargetBindCommand(parsed) || isChannelRouteUpdateCommand(parsed) || isChannelRouteRemoveCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
       return parsed;
     }
     const invalidInput = getInvalidInputReason(parsed);
@@ -91033,7 +91828,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,
@@ -91208,18 +92003,20 @@ function formatToolsetStatusMessageForModelUpdate(params) {
   }
   return "Manual toolset override remains active: " + formatToolsetName(toolsetPreference) + ".";
 }
-function formatEffortSuffix(updateArgs) {
+function formatEffortSuffix(modelLabel, updateArgs) {
   if (!updateArgs)
     return "";
   const effort = updateArgs.reasoning_effort;
   if (typeof effort !== "string" || effort.length === 0)
     return "";
+  const xhighLabel = modelLabel.includes("Opus 4.7") ? "Extra-High" : "Max";
   const labels = {
     none: "No Reasoning",
     low: "Low",
     medium: "Medium",
     high: "High",
-    xhigh: "Max"
+    xhigh: xhighLabel,
+    max: "Max"
   };
   return ` (${labels[effort] ?? effort})`;
 }
@@ -91232,7 +92029,7 @@ function buildModelUpdateStatusMessage(params) {
     toolsetPreference,
     updateArgs
   } = params;
-  let message = `Model updated to ${modelLabel}${formatEffortSuffix(updateArgs)}.`;
+  let message = `Model updated to ${modelLabel}${formatEffortSuffix(modelLabel, updateArgs)}.`;
   if (toolsetError) {
     message += ` Warning: toolset switch failed (${toolsetError}).`;
     return { message, level: "warning" };
@@ -91406,6 +92203,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 {
@@ -91638,6 +92594,7 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
       has_bot_token: snapshot.hasBotToken,
       has_app_token: snapshot.hasAppToken,
       agent_id: snapshot.agentId,
+      default_permission_mode: snapshot.defaultPermissionMode,
       created_at: snapshot.createdAt,
       updated_at: snapshot.updatedAt
     };
@@ -91731,6 +92688,7 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
         appToken: "app_token" in parsed.account ? parsed.account.app_token : undefined,
         mode: "mode" in parsed.account ? parsed.account.mode : undefined,
         agentId: "agent_id" in parsed.account ? parsed.account.agent_id : undefined,
+        defaultPermissionMode: "default_permission_mode" in parsed.account ? parsed.account.default_permission_mode : undefined,
         dmPolicy: parsed.account.dm_policy,
         allowedUsers: parsed.account.allowed_users
       }, {
@@ -91771,6 +92729,7 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
         appToken: "app_token" in parsed.patch ? parsed.patch.app_token : undefined,
         mode: "mode" in parsed.patch ? parsed.patch.mode : undefined,
         agentId: "agent_id" in parsed.patch ? parsed.patch.agent_id : undefined,
+        defaultPermissionMode: "default_permission_mode" in parsed.patch ? parsed.patch.default_permission_mode : undefined,
         dmPolicy: parsed.patch.dm_policy,
         allowedUsers: parsed.patch.allowed_users
       });
@@ -92259,7 +93218,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 +93242,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,25 +93454,45 @@ 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) => {
-    if (event.type === "pairings_updated") {
-      emitChannelPairingsUpdated(socket, event.channelId);
-      emitChannelsUpdated(socket, event.channelId);
-      return;
-    }
-    emitChannelTargetsUpdated(socket, event.channelId);
-    emitChannelsUpdated(socket, event.channelId);
+    handleChannelRegistryEvent(event, socket, listener);
   });
   registry.setReady();
 }
+function handleChannelRegistryEvent(event, socket, runtime) {
+  if (event.type === "pairings_updated") {
+    emitChannelPairingsUpdated(socket, event.channelId);
+    emitChannelsUpdated(socket, event.channelId);
+    return;
+  }
+  if (event.type === "targets_updated") {
+    emitChannelTargetsUpdated(socket, event.channelId);
+    emitChannelsUpdated(socket, event.channelId);
+    return;
+  }
+  const permissionModeState = getOrCreateConversationPermissionModeStateRef(runtime, event.agentId, event.conversationId);
+  permissionModeState.mode = event.defaultPermissionMode;
+  permissionModeState.planFilePath = null;
+  permissionModeState.modeBeforePlan = null;
+  persistPermissionModeMapForRuntime(runtime);
+}
 function stampInboundUserMessageOtids(incoming) {
   let didChange = false;
   const messages = incoming.messages.map((payload) => {
@@ -92534,7 +93513,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 +93530,7 @@ function enqueueChannelTurn(runtime, route, messageContent) {
     type: "message",
     agentId: route.agentId,
     conversationId: route.conversationId,
+    ...turnSources?.length ? { channelTurnSources: turnSources } : {},
     messages: [
       {
         role: "user",
@@ -92921,6 +93901,51 @@ async function startListenerClient(opts) {
   telemetry.init();
   await connectWithRetry(runtime, opts);
 }
+async function listDirectoryHybrid(absDir, indexRoot3, includeFiles) {
+  let indexedNames;
+  const indexedFolders = [];
+  const indexedFiles = [];
+  if (indexRoot3 !== undefined) {
+    const relPath = path23.relative(indexRoot3, absDir);
+    if (!relPath.startsWith("..")) {
+      const indexed = searchFileIndex({
+        searchDir: relPath || ".",
+        pattern: "",
+        deep: false,
+        maxResults: 1e4
+      });
+      indexedNames = new Set;
+      for (const entry of indexed) {
+        const name = entry.path.split(path23.sep).pop() ?? entry.path;
+        indexedNames.add(name);
+        if (entry.type === "dir") {
+          indexedFolders.push(name);
+        } else {
+          indexedFiles.push(name);
+        }
+      }
+    }
+  }
+  const { readdir: readdir7 } = await import("node:fs/promises");
+  const entries = await readdir7(absDir, { withFileTypes: true });
+  const extraFolders = [];
+  const extraFiles = [];
+  for (const e of entries) {
+    if (DIR_LISTING_IGNORED_NAMES.has(e.name))
+      continue;
+    if (indexedNames?.has(e.name))
+      continue;
+    if (e.isDirectory()) {
+      extraFolders.push(e.name);
+    } else if (includeFiles) {
+      extraFiles.push(e.name);
+    }
+  }
+  return {
+    folders: [...indexedFolders, ...extraFolders].sort((a, b) => a.localeCompare(b)),
+    files: includeFiles ? [...indexedFiles, ...extraFiles].sort((a, b) => a.localeCompare(b)) : []
+  };
+}
 async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now()) {
   if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
     return;
@@ -93241,33 +94266,21 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         console.log(`[Listen] Received list_in_directory command: path=${parsed.path}`);
         runDetachedListenerTask("list_in_directory", async () => {
           try {
-            const { readdir: readdir7 } = await import("node:fs/promises");
+            let indexRoot3;
+            try {
+              await ensureFileIndex2();
+              indexRoot3 = getIndexRoot();
+            } catch {}
             console.log(`[Listen] Reading directory: ${parsed.path}`);
-            const entries = await readdir7(parsed.path, { withFileTypes: true });
-            console.log(`[Listen] Directory read success, ${entries.length} entries`);
-            const IGNORED_NAMES = new Set([
-              ".DS_Store",
-              ".git",
-              ".gitignore",
-              "Thumbs.db"
-            ]);
-            const sortedEntries = entries.filter((e) => !IGNORED_NAMES.has(e.name)).sort((a, b) => a.name.localeCompare(b.name));
-            const allFolders = [];
-            const allFiles = [];
-            for (const e of sortedEntries) {
-              if (e.isDirectory()) {
-                allFolders.push(e.name);
-              } else if (parsed.include_files) {
-                allFiles.push(e.name);
-              }
-            }
+            const { folders: allFolders, files: allFiles } = await listDirectoryHybrid(parsed.path, indexRoot3, !!parsed.include_files);
             const total = allFolders.length + allFiles.length;
             const offset = parsed.offset ?? 0;
             const limit2 = parsed.limit ?? total;
             const combined = [...allFolders, ...allFiles];
             const page = combined.slice(offset, offset + limit2);
-            const folders = page.filter((name) => allFolders.includes(name));
-            const files = page.filter((name) => allFiles.includes(name));
+            const folderSet = new Set(allFolders);
+            const folders = page.filter((name) => folderSet.has(name));
+            const files = page.filter((name) => !folderSet.has(name));
             const response = {
               type: "list_in_directory_response",
               path: parsed.path,
@@ -93298,6 +94311,71 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         });
         return;
       }
+      if (isGetTreeCommand(parsed)) {
+        console.log(`[Listen] Received get_tree command: path=${parsed.path}, depth=${parsed.depth}`);
+        runDetachedListenerTask("get_tree", async () => {
+          try {
+            const results = [];
+            let hasMoreDepth = false;
+            let indexRoot3;
+            try {
+              await ensureFileIndex2();
+              indexRoot3 = getIndexRoot();
+            } catch {}
+            const queue = [[parsed.path, "", 0]];
+            let qi = 0;
+            while (qi < queue.length) {
+              const item = queue[qi++];
+              if (!item)
+                break;
+              const [absDir, relDir, depth] = item;
+              if (depth >= parsed.depth) {
+                if (depth === parsed.depth && relDir !== "") {
+                  hasMoreDepth = true;
+                }
+                continue;
+              }
+              let listing;
+              try {
+                listing = await listDirectoryHybrid(absDir, indexRoot3, true);
+              } catch {
+                continue;
+              }
+              for (const name of listing.folders) {
+                const entryRel = relDir === "" ? name : `${relDir}/${name}`;
+                results.push({ path: entryRel, type: "dir" });
+                queue.push([path23.join(absDir, name), entryRel, depth + 1]);
+              }
+              for (const name of listing.files) {
+                const entryRel = relDir === "" ? name : `${relDir}/${name}`;
+                results.push({ path: entryRel, type: "file" });
+              }
+            }
+            console.log(`[Listen] Sending get_tree_response: ${results.length} entries, has_more_depth=${hasMoreDepth}`);
+            safeSocketSend(socket, {
+              type: "get_tree_response",
+              path: parsed.path,
+              request_id: parsed.request_id,
+              entries: results,
+              has_more_depth: hasMoreDepth,
+              success: true
+            }, "listener_get_tree_send_failed", "listener_get_tree");
+          } catch (err) {
+            trackListenerError("listener_get_tree_failed", err, "listener_file_browser");
+            console.error(`[Listen] get_tree error: ${err instanceof Error ? err.message : "Unknown error"}`);
+            safeSocketSend(socket, {
+              type: "get_tree_response",
+              path: parsed.path,
+              request_id: parsed.request_id,
+              entries: [],
+              has_more_depth: false,
+              success: false,
+              error: err instanceof Error ? err.message : "Failed to get tree"
+            }, "listener_get_tree_send_failed", "listener_get_tree");
+          }
+        });
+        return;
+      }
       if (isReadFileCommand(parsed)) {
         console.log(`[Listen] Received read_file command: path=${parsed.path}, request_id=${parsed.request_id}`);
         runDetachedListenerTask("read_file", async () => {
@@ -93358,6 +94436,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
               }
             }
             console.log(`[Listen] write_file success: ${parsed.path} (${parsed.content.length} bytes)`);
+            refreshFileIndex();
             safeSocketSend(socket, {
               type: "write_file_response",
               request_id: parsed.request_id,
@@ -93454,6 +94533,9 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
               expected_replacements: parsed.expected_replacements
             });
             console.log(`[Listen] edit_file success: ${result.replacements} replacement(s) at line ${result.startLine}`);
+            if (result.replacements > 0) {
+              refreshFileIndex();
+            }
             if (result.replacements > 0) {
               try {
                 const contentAfter = await readFile11(parsed.file_path, "utf-8");
@@ -93509,144 +94591,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;
       }
@@ -94225,7 +95170,7 @@ function createLegacyTestRuntime() {
   }
   return bridge;
 }
-var channelsServiceLoaderOverride = null, WIKI_LINK_REGEX, __listenClientTestUtils;
+var channelsServiceLoaderOverride = null, WIKI_LINK_REGEX, DIR_LISTING_IGNORED_NAMES, __listenClientTestUtils;
 var init_client4 = __esm(async () => {
   init_available_models();
   init_client2();
@@ -94272,6 +95217,7 @@ var init_client4 = __esm(async () => {
     init_protocol_outbound()
   ]);
   WIKI_LINK_REGEX = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+  DIR_LISTING_IGNORED_NAMES = new Set([".DS_Store", ".git", "Thumbs.db"]);
   __listenClientTestUtils = {
     setChannelsServiceLoaderForTests: (loader) => {
       channelsServiceLoaderOverride = loader;
@@ -94324,8 +95270,10 @@ var init_client4 = __esm(async () => {
     handleAbortMessageInput,
     handleChangeDeviceStateInput,
     handleCronCommand,
+    handleListMemoryCommand,
     isDetachedChannelsCommand,
     handleChannelsProtocolCommand,
+    handleChannelRegistryEvent,
     handleSkillCommand,
     handleCreateAgentCommand,
     handleReflectionSettingsCommand,
@@ -99479,10 +100427,10 @@ var init_headless = __esm(async () => {
     init_toolset()
   ]);
   PROVIDER_FALLBACK_MAP = {
-    opus: "bedrock-opus-4.6",
     "opus-4.6-no-reasoning": "bedrock-opus-4.6",
     "opus-4.6-low": "bedrock-opus-4.6",
     "opus-4.6-medium": "bedrock-opus-4.6",
+    "opus-4.6-high": "bedrock-opus-4.6",
     "opus-4.6-xhigh": "bedrock-opus-4.6",
     sonnet: "bedrock-sonnet-4.6",
     "sonnet-1m": "bedrock-sonnet-4.6",
@@ -115408,16 +116356,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 +122777,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 +122834,7 @@ function translatePasteForImages(paste) {
         const id = allocateImage({
           data: b64,
           mediaType: mt,
-          filename: basename9(filePath)
+          filename: basename10(filePath)
         });
         s = `[Image #${id}]`;
       }
@@ -123493,7 +124441,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 +124501,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");
@@ -126340,6 +127288,8 @@ function formatReasoningLabel(effort) {
   if (effort === "none")
     return null;
   if (effort === "xhigh")
+    return "xhigh";
+  if (effort === "max")
     return "max";
   if (effort === "minimal")
     return "minimal";
@@ -127378,6 +128328,8 @@ function getReasoningEffortTag(effort) {
   if (effort === "none")
     return null;
   if (effort === "xhigh")
+    return "xhigh";
+  if (effort === "max")
     return "max";
   if (effort === "minimal")
     return "minimal";
@@ -135005,10 +135957,12 @@ var init_MessageSearch = __esm(async () => {
 });
 
 // src/cli/components/ModelReasoningSelector.tsx
-function formatEffortLabel(effort) {
+function formatEffortLabel(effort, hasDistinctMaxTier) {
   if (effort === "none")
     return "Off";
   if (effort === "xhigh")
+    return hasDistinctMaxTier ? "Extra-High" : "Max";
+  if (effort === "max")
     return "Max";
   if (effort === "minimal")
     return "Minimal";
@@ -135035,6 +135989,7 @@ function ModelReasoningSelector({
   }, [options, initialModelId]);
   const selectedOption = options[selectedIndex] ?? options[0];
   const effortOptions = import_react82.useMemo(() => options.filter((option) => option.effort !== "none"), [options]);
+  const hasDistinctMaxTier = import_react82.useMemo(() => options.some((option) => option.effort === "max"), [options]);
   const totalBars = Math.max(effortOptions.length, 1);
   const selectedBars = import_react82.useMemo(() => {
     if (!selectedOption)
@@ -135073,7 +136028,7 @@ function ModelReasoningSelector({
       setSelectedIndex((prev) => (prev + 1) % options.length);
     }
   });
-  const effortLabel = selectedOption ? formatEffortLabel(selectedOption.effort) : "Medium";
+  const effortLabel = selectedOption ? formatEffortLabel(selectedOption.effort, hasDistinctMaxTier) : "Medium";
   const selectedText = selectedBars > 0 ? EFFORT_BLOCK.repeat(selectedBars) : "";
   const remainingBars = totalBars > selectedBars ? EFFORT_BLOCK.repeat(totalBars - selectedBars) : "";
   return /* @__PURE__ */ jsx_dev_runtime59.jsxDEV(Box_default, {
@@ -143160,12 +144115,12 @@ function deriveReasoningEffort(modelSettings, llmConfig) {
       const effort = modelSettings.effort;
       if (effort === "low" || effort === "medium" || effort === "high")
         return effort;
-      if (effort === "max")
-        return "xhigh";
+      if (effort === "xhigh" || effort === "max")
+        return effort;
     }
   }
   const re = llmConfig?.reasoning_effort;
-  if (re === "none" || re === "minimal" || re === "low" || re === "medium" || re === "high" || re === "xhigh")
+  if (re === "none" || re === "minimal" || re === "low" || re === "medium" || re === "high" || re === "xhigh" || re === "max")
     return re;
   if (llmConfig?.enable_reasoner === false)
     return "none";
@@ -143174,7 +144129,7 @@ function deriveReasoningEffort(modelSettings, llmConfig) {
 function inferReasoningEffortFromModelPreset(modelId, modelHandle) {
   const modelInfo = (modelId ? getModelInfo2(modelId) : null) ?? (modelHandle ? getModelInfo2(modelHandle) : null);
   const presetEffort = modelInfo?.updateArgs?.reasoning_effort;
-  if (presetEffort === "none" || presetEffort === "minimal" || presetEffort === "low" || presetEffort === "medium" || presetEffort === "high" || presetEffort === "xhigh") {
+  if (presetEffort === "none" || presetEffort === "minimal" || presetEffort === "low" || presetEffort === "medium" || presetEffort === "high" || presetEffort === "xhigh" || presetEffort === "max") {
     return presetEffort;
   }
   return null;
@@ -143215,7 +144170,8 @@ function getErrorHintForStopReason(stopReason, currentModelId, modelEndpointType
   }
   const isAutoModel = currentModelId?.startsWith("auto") ?? false;
   const statusInfo = modelEndpointType && !isAutoModel ? PROVIDER_STATUS_PAGES[modelEndpointType] : undefined;
-  const hasBedrockOpus = currentModelId === "opus" && modelEndpointType === "anthropic" && getModelInfo2("bedrock-opus-4.6");
+  const isOpus46 = currentModelId?.startsWith("opus-4.6") ?? false;
+  const hasBedrockOpus = isOpus46 && modelEndpointType === "anthropic" && getModelInfo2("bedrock-opus-4.6");
   const modelSwapSuffix = hasBedrockOpus ? " (e.g. Opus 4.6 via Amazon Bedrock)" : "";
   if (statusInfo) {
     return [
@@ -143554,6 +144510,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 +144537,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 +148030,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 +148095,7 @@ ${feedback}
     runEndHooks,
     maybeCarryOverActiveConversationModel,
     resetBootstrapReminderState,
+    setConversationIdAndRef,
     setCommandRunning,
     setStreaming,
     recoverRestoredPendingApprovals,
@@ -147188,7 +148148,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 +148201,8 @@ ${feedback}
     resetDeferredToolCallCommits,
     resetTrajectoryBases,
     resetBootstrapReminderState,
-    resetPendingReasoningCycle
+    resetPendingReasoningCycle,
+    setConversationIdAndRef
   ]);
   const handleCreateNewAgent = import_react104.useCallback(async (name) => {
     setActiveOverlay(null);
@@ -147309,7 +148270,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 +148304,8 @@ ${feedback}
     setCommandRunning,
     resetDeferredToolCallCommits,
     resetTrajectoryBases,
-    resetBootstrapReminderState
+    resetBootstrapReminderState,
+    setConversationIdAndRef
   ]);
   const handleBashSubmit = import_react104.useCallback(async (command) => {
     if (bashRunning)
@@ -148284,7 +149246,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 +149291,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 +149345,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 +149596,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 +150531,7 @@ ${SYSTEM_REMINDER_CLOSE}
         name: agentName,
         description: agentDescription,
         lastRunAt: agentLastRunAt,
-        conversationId
+        conversationId: conversationIdRef.current
       },
       state: sharedReminderStateRef.current,
       sessionContextReminderEnabled,
@@ -150022,6 +150984,7 @@ ${SYSTEM_REMINDER_CLOSE}
     agentName,
     agentDescription,
     agentLastRunAt,
+    conversationId,
     commandRunner,
     handleExit,
     isExecutingTool,
@@ -150040,7 +151003,8 @@ ${SYSTEM_REMINDER_CLOSE}
     resetTrajectoryBases,
     sessionContextReminderEnabled,
     appendTaskNotificationEvents,
-    maybeCarryOverActiveConversationModel
+    maybeCarryOverActiveConversationModel,
+    setConversationIdAndRef
   ]);
   const onSubmitRef = import_react104.useRef(onSubmit);
   import_react104.useEffect(() => {
@@ -150555,7 +151519,7 @@ ${SYSTEM_REMINDER_CLOSE}
       const modelHandle = model.handle ?? model.id;
       const modelUpdateArgs = model.updateArgs;
       const rawReasoningEffort = modelUpdateArgs?.reasoning_effort;
-      const reasoningLevel = typeof rawReasoningEffort === "string" ? rawReasoningEffort === "none" ? "no" : rawReasoningEffort === "xhigh" ? "max" : rawReasoningEffort : modelUpdateArgs?.enable_reasoner === false ? "no" : null;
+      const reasoningLevel = typeof rawReasoningEffort === "string" ? rawReasoningEffort === "none" ? "no" : rawReasoningEffort === "xhigh" ? model.label.includes("Opus 4.7") ? "extra-high" : "max" : rawReasoningEffort : modelUpdateArgs?.enable_reasoner === false ? "no" : null;
       const selectedContextWindow = model.updateArgs?.context_window;
       const reasoningTierOptions = getReasoningTierOptionsForHandle3(modelHandle, selectedContextWindow);
       if (!opts?.skipReasoningPrompt && activeOverlay === "model" && reasoningTierOptions.length > 1) {
@@ -151040,7 +152004,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 +152057,8 @@ ${guidance}`);
     commandRunner.getHandle,
     commandRunner.start,
     recoverRestoredPendingApprovals,
-    resetBootstrapReminderState
+    resetBootstrapReminderState,
+    setConversationIdAndRef
   ]);
   const handleFeedbackSubmit = import_react104.useCallback(async (message) => {
     const overlayCommand = consumeOverlayCommand("feedback");
@@ -151330,7 +152295,16 @@ ${guidance}`);
       }).filter((m) => Boolean(m.effort));
       if (tiers.length < 2)
         return;
-      const order = ["none", "minimal", "low", "medium", "high", "xhigh"];
+      const anthropicXHighEffort = modelHandle.includes("claude-opus-4-7") ? "xhigh" : "max";
+      const order = [
+        "none",
+        "minimal",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+        "max"
+      ];
       const rank = (effort) => {
         const idx = order.indexOf(effort);
         return idx >= 0 ? idx : 999;
@@ -151367,12 +152341,11 @@ ${guidance}`);
             };
           }
           if (ms.provider_type === "anthropic" || ms.provider_type === "bedrock") {
-            const anthropicEffort = next.effort === "xhigh" ? "max" : next.effort;
             return {
               ...prev,
               model_settings: {
                 ...ms,
-                effort: anthropicEffort
+                effort: next.effort === "xhigh" ? anthropicXHighEffort : next.effort
               }
             };
           }
@@ -152351,7 +153324,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 +153436,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 +153520,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 +154892,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 +154927,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$/, "");
@@ -154794,6 +155786,9 @@ init_openai_codex_provider();
 init_debug();
 init_available_models();
 init_client2();
+function supportsDistinctAnthropicXHighEffort(modelHandle) {
+  return modelHandle.includes("claude-opus-4-7");
+}
 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/");
@@ -154827,10 +155822,13 @@ function buildModelSettings(modelHandle, updateArgs) {
       parallel_tool_calls: true
     };
     const effort = updateArgs?.reasoning_effort;
+    const hasDistinctXHigh = supportsDistinctAnthropicXHighEffort(modelHandle);
     if (effort === "low" || effort === "medium" || effort === "high") {
       anthropicSettings.effort = effort;
     } else if (effort === "xhigh") {
-      anthropicSettings.effort = "max";
+      anthropicSettings.effort = hasDistinctXHigh ? "xhigh" : "max";
+    } else if (effort === "max") {
+      anthropicSettings.effort = effort;
     }
     if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
       anthropicSettings.thinking = {
@@ -154883,10 +155881,13 @@ function buildModelSettings(modelHandle, updateArgs) {
       parallel_tool_calls: true
     };
     const effort = updateArgs?.reasoning_effort;
+    const hasDistinctXHigh = supportsDistinctAnthropicXHighEffort(modelHandle);
     if (effort === "low" || effort === "medium" || effort === "high") {
       bedrockSettings.effort = effort;
     } else if (effort === "xhigh") {
-      bedrockSettings.effort = "max";
+      bedrockSettings.effort = hasDistinctXHigh ? "xhigh" : "max";
+    } else if (effort === "max") {
+      bedrockSettings.effort = effort;
     }
     if (updateArgs?.enable_reasoner !== undefined || typeof updateArgs?.max_reasoning_tokens === "number") {
       bedrockSettings.thinking = {
@@ -157714,8 +158715,14 @@ Usage:
   letta channels route list [--channel <ch>]  Show routing table
   letta channels route add [options]          Add a route
   letta channels route remove [options]       Remove a route
+  letta channels bind [options]               Bind a Slack app to an agent
   letta channels pair [options]               Approve pairing + bind to agent
 
+Bind options (Slack only):
+  --channel slack        Required
+  --account-id <id>      Channel account ID (optional; inferred when only one account exists)
+  --agent <id>           Agent ID (defaults to LETTA_AGENT_ID)
+
 Route add options:
   --channel <name>       Channel name (e.g. "telegram")
   --account-id <id>      Channel account ID (required when multiple accounts exist)
@@ -158009,6 +159016,46 @@ async function handlePair(values) {
   }
   return result.success ? 0 : 1;
 }
+function handleBind(values) {
+  const channelId = values.channel;
+  const accountId = values["account-id"];
+  const agentId = getAgentId3(values.agent);
+  if (!channelId) {
+    console.error("Error: --channel is required.");
+    return 1;
+  }
+  if (channelId !== "slack") {
+    console.error(`"bind" is only supported for Slack. Telegram binding is route-scoped — use "pair" or "route add" instead.`);
+    return 1;
+  }
+  if (!agentId) {
+    console.error("Error: --agent is required (or set LETTA_AGENT_ID env var).");
+    return 1;
+  }
+  let resolvedAccountId;
+  try {
+    resolvedAccountId = resolveSelectedAccountId(channelId, accountId);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  const account = getChannelAccount(channelId, resolvedAccountId);
+  if (!account) {
+    console.error(`Account "${resolvedAccountId}" not found for channel "${channelId}".`);
+    return 1;
+  }
+  account.agentId = agentId;
+  account.updatedAt = new Date().toISOString();
+  upsertChannelAccount(channelId, account);
+  console.log(JSON.stringify({
+    success: true,
+    channel: channelId,
+    accountId: resolvedAccountId,
+    agentId
+  }, null, 2));
+  console.warn("Note: If a listener is running, restart it for the binding to take effect.");
+  return 0;
+}
 async function runChannelsSubcommand(argv) {
   const { values, positionals } = parseChannelsArgs(argv);
   if (values.help) {
@@ -158049,6 +159096,8 @@ async function runChannelsSubcommand(argv) {
           return 1;
       }
     }
+    case "bind":
+      return handleBind(values);
     case "pair":
       return await handlePair(values);
     default:
@@ -158056,7 +159105,7 @@ async function runChannelsSubcommand(argv) {
         printUsage3();
         return 0;
       }
-      console.error(`Unknown channels action: "${action}". Use: install, configure, status, route, pair`);
+      console.error(`Unknown channels action: "${action}". Use: install, configure, status, route, bind, pair`);
       return 1;
   }
 }
@@ -163181,4 +164230,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=29DBF7A2819CB6C064756E2164756E21
+//# debugId=B587994115421B1064756E2164756E21