@letta-ai/letta-code 0.16.15 → 0.17.1

package/letta.js

@@ -342,7 +342,7 @@ var init_values = __esm(() => {
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // node_modules/@letta-ai/letta-client/version.mjs
-var VERSION = "1.7.9";
+var VERSION = "1.7.11";
 
 // node_modules/@letta-ai/letta-client/internal/detect-platform.mjs
 function getDetectedPlatform() {
@@ -868,9 +868,11 @@ var init_stringify = __esm(() => {
   sentinel = {};
 });
 
-// node_modules/@letta-ai/letta-client/internal/qs/index.mjs
-var init_qs = __esm(() => {
-  init_formats();
+// node_modules/@letta-ai/letta-client/internal/utils/query.mjs
+function stringifyQuery(query) {
+  return stringify(query, { allowDots: true, arrayFormat: "repeat" });
+}
+var init_query = __esm(() => {
   init_stringify();
 });
 
@@ -2273,8 +2275,12 @@ var init_conversations = __esm(() => {
     delete(conversationID, options) {
       return this._client.delete(path`/v1/conversations/${conversationID}`, options);
     }
-    cancel(conversationID, options) {
-      return this._client.post(path`/v1/conversations/${conversationID}/cancel`, options);
+    cancel(conversationID, params = {}, options) {
+      const { agent_id } = params ?? {};
+      return this._client.post(path`/v1/conversations/${conversationID}/cancel`, {
+        query: { agent_id },
+        ...options
+      });
     }
   };
   Conversations.Messages = Messages2;
@@ -2841,7 +2847,7 @@ class Letta {
     return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
   }
   stringifyQuery(query) {
-    return stringify(query, { allowDots: true, arrayFormat: "repeat" });
+    return stringifyQuery(query);
   }
   getUserAgent() {
     return `${this.constructor.name}/JS ${VERSION}`;
@@ -3137,7 +3143,7 @@ var init_client = __esm(() => {
   init_tslib();
   init_values();
   init_detect_platform();
-  init_qs();
+  init_query();
   init_error();
   init_pagination();
   init_uploads2();
@@ -3216,7 +3222,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.16.15",
+    version: "0.17.1",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3249,7 +3255,7 @@ var init_package = __esm(() => {
       access: "public"
     },
     dependencies: {
-      "@letta-ai/letta-client": "^1.7.9",
+      "@letta-ai/letta-client": "^1.7.11",
       glob: "^13.0.0",
       "ink-link": "^5.0.0",
       open: "^10.2.0",
@@ -4695,6 +4701,12 @@ var approval_recovery_alert_default = `<system-reminder>Automated keep-alive pin
 `;
 var init_approval_recovery_alert = () => {};
 
+// src/agent/prompts/auto_init_reminder.txt
+var auto_init_reminder_default = `<system-reminder>
+A background agent is initializing this agent's memory system. Briefly let the user know that memory is being set up in the background, then respond to their message normally.
+</system-reminder>`;
+var init_auto_init_reminder = () => {};
+
 // src/agent/prompts/claude.md
 var claude_default = `You are Letta Code, a state-of-the-art coding agent running within the Letta Code CLI on a user's computer.
 You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
@@ -7182,6 +7194,7 @@ __export(exports_promptAssets, {
   MEMORY_PROMPTS: () => MEMORY_PROMPTS,
   MEMORY_CHECK_REMINDER: () => MEMORY_CHECK_REMINDER,
   INTERRUPT_RECOVERY_ALERT: () => INTERRUPT_RECOVERY_ALERT,
+  AUTO_INIT_REMINDER: () => AUTO_INIT_REMINDER,
   APPROVAL_RECOVERY_PROMPT: () => APPROVAL_RECOVERY_PROMPT
 });
 async function resolveSystemPrompt(systemPromptPreset) {
@@ -7200,9 +7213,10 @@ async function resolveSystemPrompt(systemPromptPreset) {
   }
   return SYSTEM_PROMPT;
 }
-var SYSTEM_PROMPT, SYSTEM_PROMPT_MEMORY_ADDON, SYSTEM_PROMPT_MEMFS_ADDON, PLAN_MODE_REMINDER, SKILL_CREATOR_PROMPT, REMEMBER_PROMPT, MEMORY_CHECK_REMINDER, MEMORY_REFLECTION_REMINDER, APPROVAL_RECOVERY_PROMPT, INTERRUPT_RECOVERY_ALERT, MEMORY_PROMPTS, SYSTEM_PROMPTS;
+var SYSTEM_PROMPT, SYSTEM_PROMPT_MEMORY_ADDON, SYSTEM_PROMPT_MEMFS_ADDON, PLAN_MODE_REMINDER, SKILL_CREATOR_PROMPT, REMEMBER_PROMPT, MEMORY_CHECK_REMINDER, MEMORY_REFLECTION_REMINDER, APPROVAL_RECOVERY_PROMPT, AUTO_INIT_REMINDER, INTERRUPT_RECOVERY_ALERT, MEMORY_PROMPTS, SYSTEM_PROMPTS;
 var init_promptAssets = __esm(() => {
   init_approval_recovery_alert();
+  init_auto_init_reminder();
   init_claude();
   init_codex();
   init_gemini();
@@ -7235,6 +7249,7 @@ var init_promptAssets = __esm(() => {
   MEMORY_CHECK_REMINDER = memory_check_reminder_default;
   MEMORY_REFLECTION_REMINDER = memory_reflection_reminder_default;
   APPROVAL_RECOVERY_PROMPT = approval_recovery_alert_default;
+  AUTO_INIT_REMINDER = auto_init_reminder_default;
   INTERRUPT_RECOVERY_ALERT = interrupt_recovery_alert_default;
   MEMORY_PROMPTS = {
     "persona.mdx": persona_default,
@@ -7301,6 +7316,20 @@ var init_promptAssets = __esm(() => {
 var models_default;
 var init_models2 = __esm(() => {
   models_default = [
+    {
+      id: "auto",
+      handle: "letta/auto",
+      label: "Auto (Beta)",
+      description: "Automatically select the best model",
+      isFeatured: true
+    },
+    {
+      id: "auto-fast",
+      handle: "letta/auto-fast",
+      label: "Auto Fast (Beta)",
+      description: "Automatically select the best fast model",
+      isFeatured: true
+    },
     {
       id: "sonnet",
       handle: "anthropic/claude-sonnet-4-6",
@@ -7370,6 +7399,19 @@ var init_models2 = __esm(() => {
         parallel_tool_calls: true
       }
     },
+    {
+      id: "sonnet-4.6-xhigh",
+      handle: "anthropic/claude-sonnet-4-6",
+      label: "Sonnet 4.6",
+      description: "Sonnet 4.6 (max reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        reasoning_effort: "xhigh",
+        enable_reasoner: true,
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "sonnet-4.5",
       handle: "anthropic/claude-sonnet-4-5-20250929",
@@ -7449,18 +7491,74 @@ var init_models2 = __esm(() => {
         parallel_tool_calls: true
       }
     },
+    {
+      id: "opus-4.6-xhigh",
+      handle: "anthropic/claude-opus-4-6",
+      label: "Opus 4.6",
+      description: "Opus 4.6 (max reasoning)",
+      updateArgs: {
+        context_window: 200000,
+        max_output_tokens: 128000,
+        reasoning_effort: "xhigh",
+        enable_reasoner: true,
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "opus-4.5",
       handle: "anthropic/claude-opus-4-5-20251101",
       label: "Opus 4.5",
-      description: "Anthropic's (legacy) best model",
+      description: "Anthropic's (legacy) best model (high reasoning)",
       updateArgs: {
         context_window: 180000,
         max_output_tokens: 64000,
+        reasoning_effort: "high",
+        enable_reasoner: true,
         max_reasoning_tokens: 31999,
         parallel_tool_calls: true
       }
     },
+    {
+      id: "opus-4.5-no-reasoning",
+      handle: "anthropic/claude-opus-4-5-20251101",
+      label: "Opus 4.5",
+      description: "Opus 4.5 with no reasoning (faster)",
+      updateArgs: {
+        context_window: 180000,
+        max_output_tokens: 64000,
+        reasoning_effort: "none",
+        enable_reasoner: false,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "opus-4.5-low",
+      handle: "anthropic/claude-opus-4-5-20251101",
+      label: "Opus 4.5",
+      description: "Opus 4.5 (low reasoning)",
+      updateArgs: {
+        context_window: 180000,
+        max_output_tokens: 64000,
+        reasoning_effort: "low",
+        enable_reasoner: true,
+        max_reasoning_tokens: 4000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "opus-4.5-medium",
+      handle: "anthropic/claude-opus-4-5-20251101",
+      label: "Opus 4.5",
+      description: "Opus 4.5 (med reasoning)",
+      updateArgs: {
+        context_window: 180000,
+        max_output_tokens: 64000,
+        reasoning_effort: "medium",
+        enable_reasoner: true,
+        max_reasoning_tokens: 12000,
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "bedrock-opus",
       handle: "bedrock/us.anthropic.claude-opus-4-5-20251101-v1:0",
@@ -7810,6 +7908,72 @@ var init_models2 = __esm(() => {
         parallel_tool_calls: true
       }
     },
+    {
+      id: "gpt-5.4-none",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (no reasoning)",
+      updateArgs: {
+        reasoning_effort: "none",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-low",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (low reasoning)",
+      updateArgs: {
+        reasoning_effort: "low",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-medium",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (med reasoning)",
+      updateArgs: {
+        reasoning_effort: "medium",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-high",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (high reasoning)",
+      isFeatured: true,
+      updateArgs: {
+        reasoning_effort: "high",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-xhigh",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (max reasoning)",
+      updateArgs: {
+        reasoning_effort: "xhigh",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "gpt-5.3-codex-none",
       handle: "openai/gpt-5.3-codex",
@@ -8458,7 +8622,7 @@ function getDefaultModel() {
 }
 function getDefaultModelForTier(billingTier) {
   if (billingTier?.toLowerCase() === "free") {
-    const freeDefault = models.find((m) => m.id === "minimax-m2.5");
+    const freeDefault = models.find((m) => m.id === "glm-5");
     if (freeDefault)
       return freeDefault.handle;
   }
@@ -34613,6 +34777,27 @@ var init_MarkdownDisplay = __esm(async () => {
   defaultHeaderStyle = { italic: true };
 });
 
+// src/cli/helpers/appUrls.ts
+function buildChatUrl(agentId, options) {
+  const base2 = `${APP_BASE}/chat/${agentId}`;
+  const params = new URLSearchParams;
+  if (options?.view) {
+    params.set("view", options.view);
+  }
+  if (options?.deviceId) {
+    params.set("deviceId", options.deviceId);
+  }
+  if (options?.conversationId && options.conversationId !== "default") {
+    params.set("conversation", options.conversationId);
+  }
+  const qs = params.toString();
+  return qs ? `${base2}?${qs}` : base2;
+}
+function buildAppUrl(path2) {
+  return `${APP_BASE}${path2}`;
+}
+var APP_BASE = "https://app.letta.com";
+
 // src/cli/helpers/errorContext.ts
 function setErrorContext(context2) {
   currentContext = { ...currentContext, ...context2 };
@@ -34740,7 +34925,7 @@ function getDefaultModel2() {
 }
 function getDefaultModelForTier2(billingTier) {
   if (billingTier?.toLowerCase() === "free") {
-    const freeDefault = models2.find((m) => m.id === "minimax-m2.5");
+    const freeDefault = models2.find((m) => m.id === "glm-5");
     if (freeDefault)
       return freeDefault.handle;
   }
@@ -60259,6 +60444,15 @@ async function getPrimaryAgentModelHandle() {
     return null;
   }
 }
+async function getCurrentBillingTier() {
+  try {
+    const client = await getClient2();
+    const balance = await client.get("/v1/metadata/balance");
+    return balance.billing_tier ?? null;
+  } catch {
+    return null;
+  }
+}
 function isProviderNotSupportedError(errorOutput) {
   return errorOutput.includes("Provider") && errorOutput.includes("is not supported") && errorOutput.includes("supported providers:");
 }
@@ -60282,13 +60476,16 @@ function swapProviderPrefix(parentHandle, recommendedHandle) {
   return `${parentProvider}/${modelPortion}`;
 }
 async function resolveSubagentModel(options) {
-  const { userModel, recommendedModel, parentModelHandle } = options;
+  const { userModel, recommendedModel, parentModelHandle, billingTier } = options;
   if (userModel)
     return userModel;
   let recommendedHandle = null;
   if (recommendedModel && recommendedModel !== "inherit") {
     recommendedHandle = resolveModel2(recommendedModel);
   }
+  if (recommendedModel !== "inherit" && billingTier?.toLowerCase() === "free") {
+    recommendedHandle = getDefaultModelForTier2(billingTier);
+  }
   let availableHandles = options.availableHandles ?? null;
   const isAvailable = async (handle) => {
     try {
@@ -60492,6 +60689,7 @@ function buildSubagentArgs(type, config, model, userPrompt, existingAgentId, exi
     }
   } else {
     args.push("--new-agent", "--system", type);
+    args.push("--tags", `type:${type}`);
     if (model) {
       args.push("--model", model);
     }
@@ -60690,10 +60888,12 @@ async function spawnSubagent(type, prompt, userModel, subagentId, signal, existi
   }
   const isDeployingExisting = Boolean(existingAgentId || existingConversationId);
   const parentModelHandle = await getPrimaryAgentModelHandle();
+  const billingTier = await getCurrentBillingTier();
   const model = isDeployingExisting ? null : await resolveSubagentModel({
     userModel,
     recommendedModel: config.recommendedModel,
-    parentModelHandle
+    parentModelHandle,
+    billingTier
   });
   const baseURL = getBaseURL();
   let finalPrompt = prompt;
@@ -65671,7 +65871,7 @@ async function loadSpecificTools(toolNames) {
     releaseSwitchLock();
   }
 }
-async function loadTools(modelIdentifier) {
+async function loadTools(modelIdentifier, options) {
   acquireSwitchLock();
   try {
     const { toolFilter: toolFilter2 } = await Promise.resolve().then(() => (init_filter(), exports_filter));
@@ -65692,6 +65892,10 @@ async function loadTools(modelIdentifier) {
     } else {
       baseToolNames = TOOL_NAMES;
     }
+    if (options?.exclude && options.exclude.length > 0) {
+      const excludeSet = new Set(options.exclude);
+      baseToolNames = baseToolNames.filter((name) => !excludeSet.has(name));
+    }
     const newRegistry = new Map;
     for (const name of baseToolNames) {
       if (!toolFilter2.isEnabled(name)) {
@@ -66473,340 +66677,6 @@ var init_approval_execution = __esm(async () => {
   ]);
 });
 
-// src/agent/check-approval.ts
-var exports_check_approval = {};
-__export(exports_check_approval, {
-  prepareMessageHistory: () => prepareMessageHistory2,
-  getResumeData: () => getResumeData2,
-  extractApprovals: () => extractApprovals2
-});
-function isPrimaryMessageType2(messageType) {
-  return messageType === "user_message" || messageType === "assistant_message" || messageType === "event_message" || messageType === "summary_message";
-}
-function isAnchorMessageType2(messageType) {
-  return messageType === "user_message" || messageType === "assistant_message";
-}
-function isBackfillEnabled2() {
-  const val = process.env.LETTA_BACKFILL;
-  return val !== "0" && val !== "false";
-}
-function extractApprovals2(messageToCheck) {
-  const approvalMsg = messageToCheck;
-  const toolCalls = Array.isArray(approvalMsg.tool_calls) ? approvalMsg.tool_calls : approvalMsg.tool_call ? [approvalMsg.tool_call] : [];
-  const pendingApprovals = toolCalls.filter((tc) => !!tc && !!tc.tool_call_id).map((tc) => ({
-    toolCallId: tc.tool_call_id,
-    toolName: tc.name || "",
-    toolArgs: tc.arguments || ""
-  }));
-  const pendingApproval = pendingApprovals[0] || null;
-  if (pendingApprovals.length > 0) {
-    debugWarn("check-approval", `Found ${pendingApprovals.length} pending approval(s): ${pendingApprovals.map((a) => a.toolName).join(", ")}`);
-  }
-  return { pendingApproval, pendingApprovals };
-}
-function prepareMessageHistory2(messages, opts) {
-  const isRenderable = (msg) => {
-    const t = msg.message_type;
-    if (t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "tool_call_message" || t === "tool_return_message" || t === "approval_request_message" || t === "approval_response_message") {
-      return true;
-    }
-    const ts = t;
-    return ts === "event_message" || ts === "summary_message";
-  };
-  const renderable = messages.filter(isRenderable);
-  if (opts?.primaryOnly) {
-    const convo = renderable.filter((m) => isPrimaryMessageType2(m.message_type));
-    let trimmed = convo.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
-    const hasAssistant = trimmed.some((m) => m.message_type === "assistant_message");
-    if (!hasAssistant) {
-      const lastAssistantIndex = convo.map((m) => m.message_type).lastIndexOf("assistant_message");
-      if (lastAssistantIndex >= 0) {
-        const lastAssistant = convo[lastAssistantIndex];
-        if (lastAssistant) {
-          const tailLimit = Math.max(BACKFILL_PRIMARY_MESSAGE_LIMIT2 - 1, 0);
-          const newestTail = tailLimit > 0 ? convo.slice(-tailLimit) : [];
-          trimmed = [lastAssistant, ...newestTail];
-        }
-      }
-    }
-    if (trimmed.length > 0)
-      return trimmed;
-    const reasoning = renderable.filter((m) => m.message_type === "reasoning_message");
-    if (reasoning.length > 0) {
-      return reasoning.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
-    }
-    return [];
-  }
-  const isPrimary = (msg) => {
-    const t = msg.message_type;
-    return t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "event_message" || t === "summary_message";
-  };
-  let primaryCount = 0;
-  let startIndex = Math.max(0, renderable.length - 1);
-  for (let i = renderable.length - 1;i >= 0; i -= 1) {
-    const msg = renderable[i];
-    if (!msg)
-      continue;
-    if (isPrimary(msg)) {
-      primaryCount += 1;
-      if (primaryCount >= BACKFILL_PRIMARY_MESSAGE_LIMIT2) {
-        startIndex = i;
-        break;
-      }
-    }
-    startIndex = i;
-  }
-  let messageHistory = renderable.slice(startIndex);
-  if (messageHistory.length > BACKFILL_MAX_RENDERABLE_MESSAGES2) {
-    messageHistory = messageHistory.slice(-BACKFILL_MAX_RENDERABLE_MESSAGES2);
-  }
-  if (messageHistory[0]?.message_type === "tool_return_message") {
-    messageHistory = messageHistory.slice(1);
-  }
-  return messageHistory;
-}
-function sortChronological2(messages) {
-  return [...messages].sort((a, b) => {
-    const ta = a.date ? new Date(a.date).getTime() : 0;
-    const tb = b.date ? new Date(b.date).getTime() : 0;
-    if (!Number.isFinite(ta) && !Number.isFinite(tb))
-      return 0;
-    if (!Number.isFinite(ta))
-      return -1;
-    if (!Number.isFinite(tb))
-      return 1;
-    return ta - tb;
-  });
-}
-async function fetchConversationBackfillMessages2(client, conversationId) {
-  const collected = [];
-  const seen = new Set;
-  let cursorBefore = null;
-  let assistantCount = 0;
-  let anchorCount = 0;
-  for (let pageIndex = 0;pageIndex < BACKFILL_MAX_PAGES2; pageIndex += 1) {
-    const page = await client.conversations.messages.list(conversationId, {
-      limit: BACKFILL_PAGE_LIMIT2,
-      order: "desc",
-      ...cursorBefore ? { before: cursorBefore } : {}
-    });
-    const items = page.getPaginatedItems();
-    if (items.length === 0)
-      break;
-    cursorBefore = items[items.length - 1]?.id ?? null;
-    for (const m of items) {
-      if (!m?.id)
-        continue;
-      const key = "otid" in m && m.otid ? `otid:${String(m.otid)}` : `id:${m.id}:${m.message_type ?? ""}`;
-      if (seen.has(key))
-        continue;
-      seen.add(key);
-      collected.push(m);
-      if (m.message_type === "assistant_message")
-        assistantCount += 1;
-      if (isAnchorMessageType2(m.message_type))
-        anchorCount += 1;
-    }
-    if (assistantCount >= BACKFILL_MIN_ASSISTANT2 && anchorCount >= BACKFILL_ANCHOR_MESSAGE_LIMIT2) {
-      break;
-    }
-    if (items.length < BACKFILL_PAGE_LIMIT2)
-      break;
-  }
-  if (assistantCount < BACKFILL_MIN_ASSISTANT2) {
-    debugWarn("check-approval", `Backfill scan found 0 assistant messages in last ${collected.length} messages (tool-heavy conversation?)`);
-  }
-  return sortChronological2(collected);
-}
-async function getResumeData2(client, agent, conversationId, options = {}) {
-  try {
-    const includeMessageHistory = options.includeMessageHistory ?? true;
-    let inContextMessageIds;
-    let messages = [];
-    const useConversationsApi = conversationId && conversationId !== "default";
-    if (process.env.DEBUG) {
-      console.log(`[DEBUG] getResumeData: conversationId=${conversationId}, useConversationsApi=${useConversationsApi}, agentId=${agent.id}`);
-    }
-    if (useConversationsApi) {
-      const conversation = await client.conversations.retrieve(conversationId);
-      inContextMessageIds = conversation.in_context_message_ids;
-      if (!inContextMessageIds || inContextMessageIds.length === 0) {
-        debugWarn("check-approval", "No in-context messages - no pending approvals");
-        if (includeMessageHistory && isBackfillEnabled2()) {
-          try {
-            const backfill = await fetchConversationBackfillMessages2(client, conversationId);
-            return {
-              pendingApproval: null,
-              pendingApprovals: [],
-              messageHistory: prepareMessageHistory2(backfill, {
-                primaryOnly: true
-              })
-            };
-          } catch (backfillError) {
-            debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
-          }
-        }
-        return {
-          pendingApproval: null,
-          pendingApprovals: [],
-          messageHistory: []
-        };
-      }
-      const lastInContextId = inContextMessageIds.at(-1);
-      if (!lastInContextId) {
-        throw new Error("Expected at least one in-context message");
-      }
-      const retrievedMessages = await client.messages.retrieve(lastInContextId);
-      if (includeMessageHistory && isBackfillEnabled2()) {
-        try {
-          messages = await fetchConversationBackfillMessages2(client, conversationId);
-        } catch (backfillError) {
-          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
-        }
-      }
-      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
-      if (messageToCheck) {
-        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
-        if (messageToCheck.message_type === "approval_request_message") {
-          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
-          return {
-            pendingApproval,
-            pendingApprovals,
-            messageHistory: prepareMessageHistory2(messages, {
-              primaryOnly: true
-            })
-          };
-        }
-      } else {
-        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve`);
-      }
-      return {
-        pendingApproval: null,
-        pendingApprovals: [],
-        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
-      };
-    } else {
-      inContextMessageIds = agent.message_ids;
-      if (!inContextMessageIds || inContextMessageIds.length === 0) {
-        debugWarn("check-approval", "No in-context messages (default/agent API) - no pending approvals");
-        return {
-          pendingApproval: null,
-          pendingApprovals: [],
-          messageHistory: []
-        };
-      }
-      const lastInContextId = inContextMessageIds.at(-1);
-      if (!lastInContextId) {
-        throw new Error("Expected at least one in-context message");
-      }
-      const retrievedMessages = await client.messages.retrieve(lastInContextId);
-      if (includeMessageHistory && isBackfillEnabled2()) {
-        try {
-          const messagesPage = await client.conversations.messages.list(agent.id, {
-            limit: BACKFILL_PAGE_LIMIT2,
-            order: "desc"
-          });
-          messages = sortChronological2(messagesPage.getPaginatedItems());
-          if (process.env.DEBUG) {
-            console.log(`[DEBUG] conversations.messages.list(${agent.id}) returned ${messages.length} messages`);
-          }
-        } catch (backfillError) {
-          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
-        }
-      }
-      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
-      if (messageToCheck) {
-        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
-        if (messageToCheck.message_type === "approval_request_message") {
-          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
-          return {
-            pendingApproval,
-            pendingApprovals,
-            messageHistory: prepareMessageHistory2(messages, {
-              primaryOnly: true
-            })
-          };
-        }
-      } else {
-        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve (default/agent API)`);
-      }
-      return {
-        pendingApproval: null,
-        pendingApprovals: [],
-        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
-      };
-    }
-  } catch (error) {
-    if (error instanceof APIError2 && (error.status === 404 || error.status === 422)) {
-      throw error;
-    }
-    console.error("Error getting resume data:", error);
-    return { pendingApproval: null, pendingApprovals: [], messageHistory: [] };
-  }
-}
-var BACKFILL_PRIMARY_MESSAGE_LIMIT2 = 12, BACKFILL_MAX_RENDERABLE_MESSAGES2 = 80, BACKFILL_ANCHOR_MESSAGE_LIMIT2 = 6, BACKFILL_PAGE_LIMIT2 = 200, BACKFILL_MAX_PAGES2 = 25, BACKFILL_MIN_ASSISTANT2 = 1;
-var init_check_approval = __esm(() => {
-  init_error();
-  init_debug();
-});
-
-// src/agent/message.ts
-function getStreamRequestStartTime(stream2) {
-  return streamRequestStartTimes.get(stream2);
-}
-function getStreamToolContextId(stream2) {
-  return streamToolContextIds.get(stream2) ?? null;
-}
-function getStreamRequestContext(stream2) {
-  return streamRequestContexts.get(stream2);
-}
-async function sendMessageStream(conversationId, messages, opts = { streamTokens: true, background: true }, requestOptions = {
-  maxRetries: 0
-}) {
-  const requestStartTime = isTimingsEnabled() ? performance.now() : undefined;
-  const requestStartedAtMs = Date.now();
-  const client = await getClient2();
-  await waitForToolsetReady();
-  const { clientTools, contextId } = captureToolExecutionContext();
-  const resolvedConversationId = conversationId === "default" ? opts.agentId : conversationId;
-  if (!resolvedConversationId) {
-    throw new Error("agentId is required in opts when using default conversation");
-  }
-  if (process.env.DEBUG) {
-    console.log(`[DEBUG] sendMessageStream: conversationId=${conversationId}, resolved=${resolvedConversationId}`);
-  }
-  const stream2 = await client.conversations.messages.create(resolvedConversationId, {
-    messages,
-    streaming: true,
-    stream_tokens: opts.streamTokens ?? true,
-    background: opts.background ?? true,
-    client_tools: clientTools,
-    include_compaction_messages: true
-  }, requestOptions);
-  if (requestStartTime !== undefined) {
-    streamRequestStartTimes.set(stream2, requestStartTime);
-  }
-  streamToolContextIds.set(stream2, contextId);
-  streamRequestContexts.set(stream2, {
-    conversationId,
-    resolvedConversationId,
-    agentId: opts.agentId ?? null,
-    requestStartedAtMs
-  });
-  return stream2;
-}
-var streamRequestStartTimes, streamToolContextIds, streamRequestContexts;
-var init_message = __esm(async () => {
-  init_timing();
-  await __promiseAll([
-    init_manager3(),
-    init_client2()
-  ]);
-  streamRequestStartTimes = new WeakMap;
-  streamToolContextIds = new WeakMap;
-  streamRequestContexts = new WeakMap;
-});
-
 // src/cli/helpers/errorFormatter.ts
 function extractReasonList2(value) {
   if (!Array.isArray(value))
@@ -67262,14 +67132,16 @@ function getProviderDisplayName() {
   return ENDPOINT_TYPE_DISPLAY_NAMES[modelEndpointType] ?? modelEndpointType;
 }
 function createAgentLink2(runId, agentId, conversationId) {
-  const url = `https://app.letta.com/agents/${agentId}${conversationId && conversationId !== "default" ? `?conversation=${conversationId}` : ""}`;
+  const url = buildChatUrl(agentId, { conversationId });
   return `View agent: \x1B]8;;${url}\x1B\\${agentId}\x1B]8;;\x1B\\ (run: ${runId})`;
 }
-var LETTA_USAGE_URL2 = "https://app.letta.com/settings/organization/usage", LETTA_AGENTS_URL2 = "https://app.letta.com/projects/default-project/agents", CLOUDFLARE_EDGE_5XX_MARKER_PATTERN2, CLOUDFLARE_EDGE_5XX_TITLE_PATTERN2, CHATGPT_USAGE_LIMIT_HINT2 = "Switch models with /model, or connect your own provider keys with /connect.", ENCRYPTED_CONTENT_HINT2, DEFAULT_RETRY_MESSAGE = "Unexpected downstream LLM API error, retrying...", ENDPOINT_TYPE_DISPLAY_NAMES;
+var LETTA_USAGE_URL2, LETTA_AGENTS_URL2, CLOUDFLARE_EDGE_5XX_MARKER_PATTERN2, CLOUDFLARE_EDGE_5XX_TITLE_PATTERN2, CHATGPT_USAGE_LIMIT_HINT2 = "Switch models with /model, or connect your own provider keys with /connect.", ENCRYPTED_CONTENT_HINT2, DEFAULT_RETRY_MESSAGE = "Unexpected downstream LLM API error, retrying...", ENDPOINT_TYPE_DISPLAY_NAMES;
 var init_errorFormatter = __esm(() => {
   init_error();
   init_errorContext();
   init_zaiErrors();
+  LETTA_USAGE_URL2 = buildAppUrl("/settings/organization/usage");
+  LETTA_AGENTS_URL2 = buildAppUrl("/projects/default-project/agents");
   CLOUDFLARE_EDGE_5XX_MARKER_PATTERN2 = /(^|\s)(502|52[0-6])\s*<!doctype html|error code\s*(502|52[0-6])/i;
   CLOUDFLARE_EDGE_5XX_TITLE_PATTERN2 = /\|\s*(502|52[0-6])\s*:/i;
   ENCRYPTED_CONTENT_HINT2 = [
@@ -67508,6 +67380,359 @@ var init_turn_recovery_policy = __esm(() => {
   RETRYABLE_429_PATTERN = /Error code:\s*429|rate limit|too many requests/i;
 });
 
+// src/agent/approval-recovery.ts
+async function fetchRunErrorDetail(runId) {
+  if (!runId)
+    return null;
+  try {
+    const client = await getClient2();
+    const run = await client.runs.retrieve(runId);
+    const metaError = run.metadata?.error;
+    return metaError?.detail ?? metaError?.message ?? metaError?.error?.detail ?? metaError?.error?.message ?? null;
+  } catch {
+    return null;
+  }
+}
+var init_approval_recovery = __esm(async () => {
+  init_turn_recovery_policy();
+  await init_client2();
+});
+
+// src/agent/check-approval.ts
+var exports_check_approval = {};
+__export(exports_check_approval, {
+  prepareMessageHistory: () => prepareMessageHistory2,
+  getResumeData: () => getResumeData2,
+  extractApprovals: () => extractApprovals2
+});
+function isPrimaryMessageType2(messageType) {
+  return messageType === "user_message" || messageType === "assistant_message" || messageType === "event_message" || messageType === "summary_message";
+}
+function isAnchorMessageType2(messageType) {
+  return messageType === "user_message" || messageType === "assistant_message";
+}
+function isBackfillEnabled2() {
+  const val = process.env.LETTA_BACKFILL;
+  return val !== "0" && val !== "false";
+}
+function extractApprovals2(messageToCheck) {
+  const approvalMsg = messageToCheck;
+  const toolCalls = Array.isArray(approvalMsg.tool_calls) ? approvalMsg.tool_calls : approvalMsg.tool_call ? [approvalMsg.tool_call] : [];
+  const pendingApprovals = toolCalls.filter((tc) => !!tc && !!tc.tool_call_id).map((tc) => ({
+    toolCallId: tc.tool_call_id,
+    toolName: tc.name || "",
+    toolArgs: tc.arguments || ""
+  }));
+  const pendingApproval = pendingApprovals[0] || null;
+  if (pendingApprovals.length > 0) {
+    debugWarn("check-approval", `Found ${pendingApprovals.length} pending approval(s): ${pendingApprovals.map((a) => a.toolName).join(", ")}`);
+  }
+  return { pendingApproval, pendingApprovals };
+}
+function prepareMessageHistory2(messages, opts) {
+  const isRenderable = (msg) => {
+    const t = msg.message_type;
+    if (t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "tool_call_message" || t === "tool_return_message" || t === "approval_request_message" || t === "approval_response_message") {
+      return true;
+    }
+    const ts = t;
+    return ts === "event_message" || ts === "summary_message";
+  };
+  const renderable = messages.filter(isRenderable);
+  if (opts?.primaryOnly) {
+    const convo = renderable.filter((m) => isPrimaryMessageType2(m.message_type));
+    let trimmed = convo.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
+    const hasAssistant = trimmed.some((m) => m.message_type === "assistant_message");
+    if (!hasAssistant) {
+      const lastAssistantIndex = convo.map((m) => m.message_type).lastIndexOf("assistant_message");
+      if (lastAssistantIndex >= 0) {
+        const lastAssistant = convo[lastAssistantIndex];
+        if (lastAssistant) {
+          const tailLimit = Math.max(BACKFILL_PRIMARY_MESSAGE_LIMIT2 - 1, 0);
+          const newestTail = tailLimit > 0 ? convo.slice(-tailLimit) : [];
+          trimmed = [lastAssistant, ...newestTail];
+        }
+      }
+    }
+    if (trimmed.length > 0)
+      return trimmed;
+    const reasoning = renderable.filter((m) => m.message_type === "reasoning_message");
+    if (reasoning.length > 0) {
+      return reasoning.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
+    }
+    return [];
+  }
+  const isPrimary = (msg) => {
+    const t = msg.message_type;
+    return t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "event_message" || t === "summary_message";
+  };
+  let primaryCount = 0;
+  let startIndex = Math.max(0, renderable.length - 1);
+  for (let i = renderable.length - 1;i >= 0; i -= 1) {
+    const msg = renderable[i];
+    if (!msg)
+      continue;
+    if (isPrimary(msg)) {
+      primaryCount += 1;
+      if (primaryCount >= BACKFILL_PRIMARY_MESSAGE_LIMIT2) {
+        startIndex = i;
+        break;
+      }
+    }
+    startIndex = i;
+  }
+  let messageHistory = renderable.slice(startIndex);
+  if (messageHistory.length > BACKFILL_MAX_RENDERABLE_MESSAGES2) {
+    messageHistory = messageHistory.slice(-BACKFILL_MAX_RENDERABLE_MESSAGES2);
+  }
+  if (messageHistory[0]?.message_type === "tool_return_message") {
+    messageHistory = messageHistory.slice(1);
+  }
+  return messageHistory;
+}
+function sortChronological2(messages) {
+  return [...messages].sort((a, b) => {
+    const ta = a.date ? new Date(a.date).getTime() : 0;
+    const tb = b.date ? new Date(b.date).getTime() : 0;
+    if (!Number.isFinite(ta) && !Number.isFinite(tb))
+      return 0;
+    if (!Number.isFinite(ta))
+      return -1;
+    if (!Number.isFinite(tb))
+      return 1;
+    return ta - tb;
+  });
+}
+async function fetchConversationBackfillMessages2(client, conversationId) {
+  const collected = [];
+  const seen = new Set;
+  let cursorBefore = null;
+  let assistantCount = 0;
+  let anchorCount = 0;
+  for (let pageIndex = 0;pageIndex < BACKFILL_MAX_PAGES2; pageIndex += 1) {
+    const page = await client.conversations.messages.list(conversationId, {
+      limit: BACKFILL_PAGE_LIMIT2,
+      order: "desc",
+      ...cursorBefore ? { before: cursorBefore } : {}
+    });
+    const items = page.getPaginatedItems();
+    if (items.length === 0)
+      break;
+    cursorBefore = items[items.length - 1]?.id ?? null;
+    for (const m of items) {
+      if (!m?.id)
+        continue;
+      const key = "otid" in m && m.otid ? `otid:${String(m.otid)}` : `id:${m.id}:${m.message_type ?? ""}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      collected.push(m);
+      if (m.message_type === "assistant_message")
+        assistantCount += 1;
+      if (isAnchorMessageType2(m.message_type))
+        anchorCount += 1;
+    }
+    if (assistantCount >= BACKFILL_MIN_ASSISTANT2 && anchorCount >= BACKFILL_ANCHOR_MESSAGE_LIMIT2) {
+      break;
+    }
+    if (items.length < BACKFILL_PAGE_LIMIT2)
+      break;
+  }
+  if (assistantCount < BACKFILL_MIN_ASSISTANT2) {
+    debugWarn("check-approval", `Backfill scan found 0 assistant messages in last ${collected.length} messages (tool-heavy conversation?)`);
+  }
+  return sortChronological2(collected);
+}
+async function getResumeData2(client, agent, conversationId, options = {}) {
+  try {
+    const includeMessageHistory = options.includeMessageHistory ?? true;
+    let inContextMessageIds;
+    let messages = [];
+    const useConversationsApi = conversationId && conversationId !== "default";
+    if (useConversationsApi) {
+      const conversation = await client.conversations.retrieve(conversationId);
+      inContextMessageIds = conversation.in_context_message_ids;
+      if (!inContextMessageIds || inContextMessageIds.length === 0) {
+        debugWarn("check-approval", "No in-context messages - no pending approvals");
+        if (includeMessageHistory && isBackfillEnabled2()) {
+          try {
+            const backfill = await fetchConversationBackfillMessages2(client, conversationId);
+            return {
+              pendingApproval: null,
+              pendingApprovals: [],
+              messageHistory: prepareMessageHistory2(backfill, {
+                primaryOnly: true
+              })
+            };
+          } catch (backfillError) {
+            debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
+          }
+        }
+        return {
+          pendingApproval: null,
+          pendingApprovals: [],
+          messageHistory: []
+        };
+      }
+      const lastInContextId = inContextMessageIds.at(-1);
+      if (!lastInContextId) {
+        throw new Error("Expected at least one in-context message");
+      }
+      const retrievedMessages = await client.messages.retrieve(lastInContextId);
+      if (includeMessageHistory && isBackfillEnabled2()) {
+        try {
+          messages = await fetchConversationBackfillMessages2(client, conversationId);
+        } catch (backfillError) {
+          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
+        }
+      }
+      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
+      if (messageToCheck) {
+        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
+        if (messageToCheck.message_type === "approval_request_message") {
+          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
+          return {
+            pendingApproval,
+            pendingApprovals,
+            messageHistory: prepareMessageHistory2(messages, {
+              primaryOnly: true
+            })
+          };
+        }
+      } else {
+        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve`);
+      }
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
+      };
+    } else {
+      inContextMessageIds = agent.message_ids;
+      if (!inContextMessageIds || inContextMessageIds.length === 0) {
+        debugWarn("check-approval", "No in-context messages (default/agent API) - no pending approvals");
+        return {
+          pendingApproval: null,
+          pendingApprovals: [],
+          messageHistory: []
+        };
+      }
+      const lastInContextId = inContextMessageIds.at(-1);
+      if (!lastInContextId) {
+        throw new Error("Expected at least one in-context message");
+      }
+      const retrievedMessages = await client.messages.retrieve(lastInContextId);
+      if (includeMessageHistory && isBackfillEnabled2()) {
+        try {
+          const messagesPage = await client.conversations.messages.list("default", {
+            agent_id: agent.id,
+            limit: BACKFILL_PAGE_LIMIT2,
+            order: "desc"
+          });
+          messages = sortChronological2(messagesPage.getPaginatedItems());
+          if (process.env.DEBUG) {
+            console.log(`[DEBUG] conversations.messages.list(default, agent_id=${agent.id}) returned ${messages.length} messages`);
+          }
+        } catch (backfillError) {
+          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
+        }
+      }
+      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
+      if (messageToCheck) {
+        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
+        if (messageToCheck.message_type === "approval_request_message") {
+          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
+          return {
+            pendingApproval,
+            pendingApprovals,
+            messageHistory: prepareMessageHistory2(messages, {
+              primaryOnly: true
+            })
+          };
+        }
+      } else {
+        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve (default/agent API)`);
+      }
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
+      };
+    }
+  } catch (error) {
+    if (error instanceof APIError2 && (error.status === 404 || error.status === 422)) {
+      throw error;
+    }
+    console.error("Error getting resume data:", error);
+    return { pendingApproval: null, pendingApprovals: [], messageHistory: [] };
+  }
+}
+var BACKFILL_PRIMARY_MESSAGE_LIMIT2 = 12, BACKFILL_MAX_RENDERABLE_MESSAGES2 = 80, BACKFILL_ANCHOR_MESSAGE_LIMIT2 = 6, BACKFILL_PAGE_LIMIT2 = 200, BACKFILL_MAX_PAGES2 = 25, BACKFILL_MIN_ASSISTANT2 = 1;
+var init_check_approval = __esm(() => {
+  init_error();
+  init_debug();
+});
+
+// src/agent/message.ts
+function getStreamRequestStartTime(stream2) {
+  return streamRequestStartTimes.get(stream2);
+}
+function getStreamToolContextId(stream2) {
+  return streamToolContextIds.get(stream2) ?? null;
+}
+function getStreamRequestContext(stream2) {
+  return streamRequestContexts.get(stream2);
+}
+async function sendMessageStream(conversationId, messages, opts = { streamTokens: true, background: true }, requestOptions = {
+  maxRetries: 0
+}) {
+  const requestStartTime = isTimingsEnabled() ? performance.now() : undefined;
+  const requestStartedAtMs = Date.now();
+  const client = await getClient2();
+  await waitForToolsetReady();
+  const { clientTools, contextId } = captureToolExecutionContext();
+  const isDefaultConversation = conversationId === "default";
+  if (isDefaultConversation && !opts.agentId) {
+    throw new Error("agentId is required in opts when using default conversation");
+  }
+  const resolvedConversationId = conversationId;
+  const requestBody = {
+    messages,
+    streaming: true,
+    stream_tokens: opts.streamTokens ?? true,
+    background: opts.background ?? true,
+    client_tools: clientTools,
+    include_compaction_messages: true,
+    ...isDefaultConversation ? { agent_id: opts.agentId } : {}
+  };
+  if (process.env.DEBUG) {
+    console.log(`[DEBUG] sendMessageStream: conversationId=${conversationId}, agentId=${opts.agentId ?? "(none)"}`);
+  }
+  const stream2 = await client.conversations.messages.create(resolvedConversationId, requestBody, requestOptions);
+  if (requestStartTime !== undefined) {
+    streamRequestStartTimes.set(stream2, requestStartTime);
+  }
+  streamToolContextIds.set(stream2, contextId);
+  streamRequestContexts.set(stream2, {
+    conversationId,
+    resolvedConversationId,
+    agentId: opts.agentId ?? null,
+    requestStartedAtMs
+  });
+  return stream2;
+}
+var streamRequestStartTimes, streamToolContextIds, streamRequestContexts;
+var init_message = __esm(async () => {
+  init_timing();
+  await __promiseAll([
+    init_manager3(),
+    init_client2()
+  ]);
+  streamRequestStartTimes = new WeakMap;
+  streamToolContextIds = new WeakMap;
+  streamRequestContexts = new WeakMap;
+});
+
 // src/cli/helpers/backfill.ts
 function getDisplayableToolReturn2(content) {
   if (!content)
@@ -70931,6 +71156,9 @@ function createRuntime() {
     cancelRequested: false,
     isRecoveringApprovals: false,
     pendingApprovalBatchByToolCallId: new Map,
+    pendingInterruptedResults: null,
+    pendingInterruptedContext: null,
+    continuationEpoch: 0,
     coalescedSkipQueueItemIds: new Set,
     pendingTurns: 0,
     queueRuntime: null
@@ -71045,6 +71273,12 @@ function resolvePendingApprovalBatchId(runtime, pendingApprovals) {
   }
   return batchIds.values().next().value ?? null;
 }
+function resolveRecoveryBatchId(runtime, pendingApprovals) {
+  if (runtime.pendingApprovalBatchByToolCallId.size === 0) {
+    return `recovery-${crypto.randomUUID()}`;
+  }
+  return resolvePendingApprovalBatchId(runtime, pendingApprovals);
+}
 function clearPendingApprovalBatchIds(runtime, approvals) {
   for (const approval of approvals) {
     runtime.pendingApprovalBatchByToolCallId.delete(approval.toolCallId);
@@ -71059,6 +71293,9 @@ function stopRuntime(runtime, suppressCallbacks) {
   clearRuntimeTimers(runtime);
   rejectPendingApprovalResolvers(runtime, "Listener runtime stopped");
   runtime.pendingApprovalBatchByToolCallId.clear();
+  runtime.pendingInterruptedResults = null;
+  runtime.pendingInterruptedContext = null;
+  runtime.continuationEpoch++;
   if (!runtime.socket) {
     return;
   }
@@ -71243,9 +71480,201 @@ function emitToWS(socket, event) {
     socket.send(JSON.stringify(outbound));
   }
 }
+function normalizeToolReturnValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === undefined) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractInterruptToolReturns(approvals) {
+  if (!approvals || approvals.length === 0) {
+    return [];
+  }
+  return approvals.flatMap((approval) => {
+    if (!approval || typeof approval !== "object") {
+      return [];
+    }
+    if ("type" in approval && approval.type === "tool") {
+      const toolCallId = "tool_call_id" in approval && typeof approval.tool_call_id === "string" ? approval.tool_call_id : null;
+      if (!toolCallId) {
+        return [];
+      }
+      const status = "status" in approval && approval.status === "success" ? "success" : "error";
+      const stdout = "stdout" in approval && Array.isArray(approval.stdout) ? approval.stdout.filter((entry) => typeof entry === "string") : undefined;
+      const stderr = "stderr" in approval && Array.isArray(approval.stderr) ? approval.stderr.filter((entry) => typeof entry === "string") : undefined;
+      return [
+        {
+          tool_call_id: toolCallId,
+          status,
+          tool_return: "tool_return" in approval ? normalizeToolReturnValue(approval.tool_return) : "",
+          ...stdout ? { stdout } : {},
+          ...stderr ? { stderr } : {}
+        }
+      ];
+    }
+    if ("type" in approval && approval.type === "approval") {
+      const toolCallId = "tool_call_id" in approval && typeof approval.tool_call_id === "string" ? approval.tool_call_id : null;
+      if (!toolCallId) {
+        return [];
+      }
+      const reason = "reason" in approval && typeof approval.reason === "string" ? approval.reason : "User interrupted the stream";
+      return [
+        {
+          tool_call_id: toolCallId,
+          status: "error",
+          tool_return: reason
+        }
+      ];
+    }
+    return [];
+  });
+}
+function emitInterruptToolReturnMessage(socket, runtime, approvals, runId, uuidPrefix = "interrupt-tool-return") {
+  const toolReturns = extractInterruptToolReturns(approvals);
+  if (toolReturns.length === 0) {
+    return;
+  }
+  const resolvedRunId = runId ?? runtime.activeRunId ?? undefined;
+  for (const toolReturn of toolReturns) {
+    emitToWS(socket, {
+      type: "message",
+      message_type: "tool_return_message",
+      id: `message-${crypto.randomUUID()}`,
+      date: new Date().toISOString(),
+      run_id: resolvedRunId,
+      tool_call_id: toolReturn.tool_call_id,
+      tool_return: toolReturn.tool_return,
+      status: toolReturn.status,
+      ...toolReturn.stdout ? { stdout: toolReturn.stdout } : {},
+      ...toolReturn.stderr ? { stderr: toolReturn.stderr } : {},
+      tool_returns: [toolReturn],
+      session_id: runtime.sessionId,
+      uuid: `${uuidPrefix}-${crypto.randomUUID()}`
+    });
+  }
+}
+function getInterruptApprovalsForEmission(runtime, params) {
+  if (params.lastExecutionResults && params.lastExecutionResults.length > 0) {
+    return params.lastExecutionResults;
+  }
+  const context3 = runtime.pendingInterruptedContext;
+  if (!context3 || context3.agentId !== params.agentId || context3.conversationId !== params.conversationId || context3.continuationEpoch !== runtime.continuationEpoch) {
+    return null;
+  }
+  if (!runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0) {
+    return null;
+  }
+  return runtime.pendingInterruptedResults;
+}
+function populateInterruptQueue(runtime, input) {
+  const shouldPopulate = !runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0 || !runtime.pendingInterruptedContext;
+  if (!shouldPopulate)
+    return false;
+  if (input.lastExecutionResults && input.lastExecutionResults.length > 0) {
+    runtime.pendingInterruptedResults = input.lastExecutionResults;
+    runtime.pendingInterruptedContext = {
+      agentId: input.agentId,
+      conversationId: input.conversationId,
+      continuationEpoch: runtime.continuationEpoch
+    };
+    return true;
+  }
+  const batchToolCallIds = [...runtime.pendingApprovalBatchByToolCallId.keys()];
+  const pendingIds = batchToolCallIds.length > 0 ? batchToolCallIds : input.lastNeedsUserInputToolCallIds;
+  if (pendingIds.length > 0) {
+    runtime.pendingInterruptedResults = pendingIds.map((toolCallId) => ({
+      type: "approval",
+      tool_call_id: toolCallId,
+      approve: false,
+      reason: "User interrupted the stream"
+    }));
+    runtime.pendingInterruptedContext = {
+      agentId: input.agentId,
+      conversationId: input.conversationId,
+      continuationEpoch: runtime.continuationEpoch
+    };
+    return true;
+  }
+  if (process.env.DEBUG) {
+    console.warn("[Listen] Cancel during approval loop but no tool_call_ids available " + "for interrupted queue — next turn may hit pre-stream conflict. " + `batchMap=${runtime.pendingApprovalBatchByToolCallId.size}, ` + `lastNeedsUserInput=${input.lastNeedsUserInputToolCallIds.length}`);
+  }
+  return false;
+}
+function consumeInterruptQueue(runtime, agentId, conversationId) {
+  if (!runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0) {
+    return null;
+  }
+  const ctx = runtime.pendingInterruptedContext;
+  let result = null;
+  if (ctx && ctx.agentId === agentId && ctx.conversationId === conversationId && ctx.continuationEpoch === runtime.continuationEpoch) {
+    result = {
+      type: "approval",
+      approvals: runtime.pendingInterruptedResults
+    };
+  }
+  runtime.pendingInterruptedResults = null;
+  runtime.pendingInterruptedContext = null;
+  runtime.pendingApprovalBatchByToolCallId.clear();
+  return result;
+}
+async function resolveStaleApprovals(runtime, abortSignal) {
+  if (!runtime.activeAgentId)
+    return;
+  const client = await getClient2();
+  let agent;
+  try {
+    agent = await client.agents.retrieve(runtime.activeAgentId);
+  } catch (err) {
+    if (err instanceof APIError2 && (err.status === 404 || err.status === 422)) {
+      return;
+    }
+    throw err;
+  }
+  const requestedConversationId = runtime.activeConversationId && runtime.activeConversationId !== "default" ? runtime.activeConversationId : undefined;
+  let resumeData;
+  try {
+    resumeData = await getResumeData2(client, agent, requestedConversationId, {
+      includeMessageHistory: false
+    });
+  } catch (err) {
+    if (err instanceof APIError2 && (err.status === 404 || err.status === 422)) {
+      return;
+    }
+    throw err;
+  }
+  const pendingApprovals = resumeData.pendingApprovals || [];
+  if (pendingApprovals.length === 0)
+    return;
+  if (abortSignal.aborted)
+    throw new Error("Cancelled");
+  const denialResults = pendingApprovals.map((approval) => ({
+    type: "approval",
+    tool_call_id: approval.toolCallId,
+    approve: false,
+    reason: "Auto-denied during pre-stream approval recovery"
+  }));
+  const recoveryConversationId = runtime.activeConversationId || "default";
+  const recoveryStream = await sendMessageStream(recoveryConversationId, [{ type: "approval", approvals: denialResults }], {
+    agentId: runtime.activeAgentId,
+    streamTokens: true,
+    background: true
+  }, { maxRetries: 0, signal: abortSignal });
+  const drainResult = await drainStreamWithResume(recoveryStream, createBuffers(runtime.activeAgentId), () => {}, abortSignal);
+  if (drainResult.stopReason === "error") {
+    throw new Error("Pre-stream approval recovery drain ended with error");
+  }
+}
 async function sendMessageStreamWithRetry(conversationId, messages, opts, socket, runtime, abortSignal) {
   let transientRetries = 0;
   let conversationBusyRetries = 0;
+  let preStreamRecoveryAttempts = 0;
   const MAX_CONVERSATION_BUSY_RETRIES = 1;
   while (true) {
     if (abortSignal?.aborted) {
@@ -71264,7 +71693,20 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
         maxTransientRetries: LLM_API_ERROR_MAX_RETRIES
       });
       if (action === "resolve_approval_pending") {
-        throw preStreamError;
+        if (abortSignal?.aborted)
+          throw new Error("Cancelled by user");
+        if (abortSignal && preStreamRecoveryAttempts < MAX_PRE_STREAM_RECOVERY) {
+          preStreamRecoveryAttempts++;
+          try {
+            await resolveStaleApprovals(runtime, abortSignal);
+            continue;
+          } catch (_recoveryError) {
+            if (abortSignal.aborted)
+              throw new Error("Cancelled by user");
+          }
+        }
+        const detail = await fetchRunErrorDetail(runtime.activeRunId);
+        throw new Error(detail || `Pre-stream approval conflict (resolve_approval_pending) after ${preStreamRecoveryAttempts} recovery attempts`);
       }
       if (action === "retry_transient") {
         const attempt = transientRetries + 1;
@@ -71406,6 +71848,13 @@ function buildApprovalExecutionPlan(approvalMessage, pendingApprovals) {
   return { slots, decisions };
 }
 async function recoverPendingApprovals(runtime, socket, msg) {
+  console.debug("[listener] recover_pending_approvals received", JSON.stringify({
+    agentId: msg.agentId,
+    conversationId: msg.conversationId ?? null,
+    isProcessing: runtime.isProcessing,
+    isRecovering: runtime.isRecoveringApprovals,
+    batchMapSize: runtime.pendingApprovalBatchByToolCallId.size
+  }));
   if (runtime.isProcessing || runtime.isRecoveringApprovals) {
     return;
   }
@@ -71434,11 +71883,11 @@ async function recoverPendingApprovals(runtime, socket, msg) {
     if (pendingApprovals.length === 0) {
       return;
     }
-    const recoveryBatchId = resolvePendingApprovalBatchId(runtime, pendingApprovals);
+    const recoveryBatchId = resolveRecoveryBatchId(runtime, pendingApprovals);
     if (!recoveryBatchId) {
       emitToWS(socket, {
         type: "error",
-        message: "Unable to recover pending approvals without originating batch correlation",
+        message: "Unable to recover pending approvals: ambiguous batch correlation",
         stop_reason: "error",
         session_id: runtime.sessionId,
         uuid: `error-${crypto.randomUUID()}`
@@ -71481,6 +71930,7 @@ async function recoverPendingApprovals(runtime, socket, msg) {
         runtime.lastStopReason = "requires_approval";
         return;
       }
+      runtime.lastStopReason = "requires_approval";
       for (const ac of needsUserInput) {
         const requestId = `perm-${ac.approval.toolCallId}`;
         const diffs = await computeDiffPreviews(ac.approval.toolName, ac.parsedArgs);
@@ -71693,6 +72143,14 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       if (hasPendingApprovals) {
         rejectPendingApprovalResolvers(runtime, "Cancelled by user");
       }
+      const cancelConversationId = runtime.activeConversationId;
+      const cancelAgentId = runtime.activeAgentId;
+      if (cancelAgentId) {
+        getClient2().then((client) => {
+          const cancelId = cancelConversationId === "default" || !cancelConversationId ? cancelAgentId : cancelConversationId;
+          return client.conversations.cancel(cancelId);
+        }).catch(() => {});
+      }
       emitCancelAck(socket, runtime, {
         requestId,
         accepted: true,
@@ -71891,6 +72349,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
   const msgStartTime = performance.now();
   let msgTurnCount = 0;
   const msgRunIds = [];
+  let lastExecutionResults = null;
+  let lastNeedsUserInputToolCallIds = [];
   runtime.isProcessing = true;
   runtime.cancelRequested = false;
   runtime.activeAbortController = new AbortController;
@@ -71913,8 +72373,13 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     if (connectionId) {
       onStatusChange?.("processing", connectionId);
     }
-    let messagesToSend = msg.messages;
+    let messagesToSend = [];
     let turnToolContextId = null;
+    const consumed = consumeInterruptQueue(runtime, agentId || "", conversationId);
+    if (consumed) {
+      messagesToSend.push(consumed);
+    }
+    messagesToSend.push(...msg.messages);
     const firstMessage = msg.messages[0];
     const isApprovalMessage = firstMessage && "type" in firstMessage && firstMessage.type === "approval" && "approvals" in firstMessage;
     if (isApprovalMessage) {
@@ -71955,6 +72420,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           approvals: rebuiltApprovals
         }
       ];
+      emitInterruptToolReturnMessage(socket, runtime, rebuiltApprovals, runtime.activeRunId ?? undefined, "tool-return");
     }
     let stream2 = await sendMessageStreamWithRetry(conversationId, messagesToSend, { agentId, streamTokens: true, background: true }, socket, runtime, runtime.activeAbortController.signal);
     turnToolContextId = getStreamToolContextId(stream2);
@@ -72062,13 +72528,45 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         break;
       }
       if (stopReason !== "requires_approval") {
-        runtime.lastStopReason = stopReason;
+        const effectiveStopReason = runtime.cancelRequested ? "cancelled" : stopReason || "error";
+        if (effectiveStopReason === "cancelled") {
+          runtime.lastStopReason = "cancelled";
+          runtime.isProcessing = false;
+          clearActiveRunState(runtime);
+          if (runtime.controlResponseCapable) {
+            emitToWS(socket, {
+              type: "result",
+              subtype: "interrupted",
+              agent_id: agentId,
+              conversation_id: conversationId,
+              duration_ms: performance.now() - msgStartTime,
+              duration_api_ms: 0,
+              num_turns: msgTurnCount,
+              result: null,
+              run_ids: msgRunIds,
+              usage: null,
+              stop_reason: "cancelled",
+              session_id: runtime.sessionId,
+              uuid: `result-${crypto.randomUUID()}`
+            });
+          } else {
+            sendClientMessage(socket, {
+              type: "result",
+              success: false,
+              stopReason: "cancelled"
+            });
+          }
+          break;
+        }
+        runtime.lastStopReason = effectiveStopReason;
         runtime.isProcessing = false;
         clearActiveRunState(runtime);
+        const errorDetail = await fetchRunErrorDetail(runId).catch(() => null);
+        const errorMessage = errorDetail || `Unexpected stop reason: ${stopReason}`;
         emitToWS(socket, {
           type: "error",
-          message: `Unexpected stop reason: ${stopReason}`,
-          stop_reason: stopReason || "error",
+          message: errorMessage,
+          stop_reason: effectiveStopReason,
           run_id: runId,
           session_id: runtime.sessionId,
           uuid: `error-${crypto.randomUUID()}`
@@ -72085,7 +72583,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             result: null,
             run_ids: msgRunIds,
             usage: null,
-            stop_reason: stopReason || "error",
+            stop_reason: effectiveStopReason,
             session_id: runtime.sessionId,
             uuid: `result-${crypto.randomUUID()}`
           });
@@ -72093,7 +72591,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           sendClientMessage(socket, {
             type: "result",
             success: false,
-            stopReason
+            stopReason: effectiveStopReason
           });
         }
         break;
@@ -72115,6 +72613,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         treatAskAsDeny: false,
         requireArgsForAutoApprove: true
       });
+      lastNeedsUserInputToolCallIds = needsUserInput.map((ac) => ac.approval.toolCallId);
+      lastExecutionResults = null;
       for (const ac of autoAllowed) {
         emitToWS(socket, {
           type: "auto_approval",
@@ -72209,6 +72709,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         toolContextId: turnToolContextId ?? undefined,
         abortSignal: runtime.activeAbortController.signal
       });
+      lastExecutionResults = executionResults;
+      emitInterruptToolReturnMessage(socket, runtime, executionResults, runtime.activeRunId || runId || msgRunIds[msgRunIds.length - 1] || undefined, "tool-return");
       clearPendingApprovalBatchIds(runtime, decisions.map((decision) => decision.approval));
       stream2 = await sendMessageStreamWithRetry(conversationId, [
         {
@@ -72216,10 +72718,26 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           approvals: executionResults
         }
       ], { agentId, streamTokens: true, background: true }, socket, runtime, runtime.activeAbortController.signal);
+      lastExecutionResults = null;
+      lastNeedsUserInputToolCallIds = [];
       turnToolContextId = getStreamToolContextId(stream2);
     }
   } catch (error) {
     if (runtime.cancelRequested) {
+      populateInterruptQueue(runtime, {
+        lastExecutionResults,
+        lastNeedsUserInputToolCallIds,
+        agentId: agentId || "",
+        conversationId
+      });
+      const approvalsForEmission = getInterruptApprovalsForEmission(runtime, {
+        lastExecutionResults,
+        agentId: agentId || "",
+        conversationId
+      });
+      if (approvalsForEmission) {
+        emitInterruptToolReturnMessage(socket, runtime, approvalsForEmission, runtime.activeRunId || msgRunIds[msgRunIds.length - 1] || undefined);
+      }
       runtime.lastStopReason = "cancelled";
       runtime.isProcessing = false;
       clearActiveRunState(runtime);
@@ -72251,6 +72769,22 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     runtime.lastStopReason = "error";
     runtime.isProcessing = false;
     clearActiveRunState(runtime);
+    if (msgRunIds.length === 0) {
+      const errorPayload = {
+        message: error instanceof Error ? error.message : String(error)
+      };
+      if (error instanceof APIError2) {
+        errorPayload.status = error.status;
+        if (error.error && typeof error.error === "object") {
+          errorPayload.body = error.error;
+        }
+      }
+      sendClientMessage(socket, {
+        type: "run_request_error",
+        error: errorPayload,
+        batch_id: dequeuedBatchId
+      });
+    }
     const errorMessage = error instanceof Error ? error.message : String(error);
     emitToWS(socket, {
       type: "error",
@@ -72301,7 +72835,7 @@ function stopListenerClient() {
   activeRuntime = null;
   stopRuntime(runtime, true);
 }
-var activeRuntime = null, MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS = 1000, MAX_RETRY_DELAY_MS = 30000, LLM_API_ERROR_MAX_RETRIES = 3, __listenClientTestUtils;
+var activeRuntime = null, MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS = 1000, MAX_RETRY_DELAY_MS = 30000, LLM_API_ERROR_MAX_RETRIES = 3, MAX_PRE_STREAM_RECOVERY = 2, __listenClientTestUtils;
 var init_listen_client = __esm(async () => {
   init_error();
   init_check_approval();
@@ -72312,6 +72846,7 @@ var init_listen_client = __esm(async () => {
   init_interactivePolicy();
   await __promiseAll([
     init_approval_execution(),
+    init_approval_recovery(),
     init_client2(),
     init_message(),
     init_accumulator(),
@@ -72327,7 +72862,13 @@ var init_listen_client = __esm(async () => {
     emitToWS,
     rememberPendingApprovalBatchIds,
     resolvePendingApprovalBatchId,
-    clearPendingApprovalBatchIds
+    resolveRecoveryBatchId,
+    clearPendingApprovalBatchIds,
+    populateInterruptQueue,
+    consumeInterruptQueue,
+    extractInterruptToolReturns,
+    emitInterruptToolReturnMessage,
+    getInterruptApprovalsForEmission
   };
 });
 
@@ -72353,19 +72894,19 @@ __export(exports_skills2, {
   SKILLS_DIR: () => SKILLS_DIR2,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { readdir as readdir6, readFile as readFile5, realpath as realpath3, stat as stat3 } from "node:fs/promises";
-import { dirname as dirname8, join as join21 } from "node:path";
+import { dirname as dirname8, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
   const thisDir = dirname8(fileURLToPath8(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join21(thisDir, "../skills/builtin");
+    return join22(thisDir, "../skills/builtin");
   }
-  return join21(thisDir, "skills");
+  return join22(thisDir, "skills");
 }
 function getAgentSkillsDir2(agentId) {
-  return join21(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
+  return join22(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills2() {
   const bundledPath = getBundledSkillsPath2();
@@ -72374,7 +72915,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source) {
   const errors = [];
-  if (!existsSync12(skillsPath)) {
+  if (!existsSync13(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -72388,7 +72929,7 @@ async function discoverSkillsFromDir2(skillsPath, source) {
   }
   return { skills, errors };
 }
-async function discoverSkills2(projectSkillsPath = join21(process.cwd(), SKILLS_DIR2), agentId, options) {
+async function discoverSkills2(projectSkillsPath = join22(process.cwd(), SKILLS_DIR2), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
@@ -72443,7 +72984,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
   try {
     const entries = await readdir6(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join21(currentPath, entry.name);
+      const fullPath = join22(currentPath, entry.name);
       try {
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
@@ -72532,7 +73073,7 @@ ${lines.join(`
 var SKILLS_DIR2 = ".skills", GLOBAL_SKILLS_DIR2;
 var init_skills2 = __esm(() => {
   init_skillSources();
-  GLOBAL_SKILLS_DIR2 = join21(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  GLOBAL_SKILLS_DIR2 = join22(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/utils/fs.ts
@@ -72546,10 +73087,10 @@ __export(exports_fs, {
   exists: () => exists2
 });
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
-  mkdirSync as mkdirSync10
+  mkdirSync as mkdirSync11
 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 async function readFile6(path20) {
@@ -72557,16 +73098,16 @@ async function readFile6(path20) {
 }
 async function writeFile2(path20, content) {
   const dir = dirname9(path20);
-  if (!existsSync13(dir)) {
-    mkdirSync10(dir, { recursive: true });
+  if (!existsSync14(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
   fsWriteFileSync2(path20, content, { encoding: "utf-8", flush: true });
 }
 function exists2(path20) {
-  return existsSync13(path20);
+  return existsSync14(path20);
 }
 async function mkdir2(path20, options) {
-  mkdirSync10(path20, options);
+  mkdirSync11(path20, options);
 }
 async function readJsonFile(path20) {
   const text = await readFile6(path20);
@@ -72886,9 +73427,9 @@ __export(exports_auto_update, {
 import { execFile as execFile9 } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readdir as readdir7, rm } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { promisify as promisify9 } from "node:util";
-function debugLog2(...args) {
+function debugLog3(...args) {
   if (DEBUG) {
     console.error("[auto-update]", ...args);
   }
@@ -72955,10 +73496,10 @@ function detectPackageManager() {
   const envOverride = process.env.LETTA_PACKAGE_MANAGER;
   if (envOverride) {
     if (VALID_PACKAGE_MANAGERS.has(envOverride)) {
-      debugLog2("Package manager from LETTA_PACKAGE_MANAGER:", envOverride);
+      debugLog3("Package manager from LETTA_PACKAGE_MANAGER:", envOverride);
       return envOverride;
     }
-    debugLog2(`Invalid LETTA_PACKAGE_MANAGER="${envOverride}", falling back to path detection`);
+    debugLog3(`Invalid LETTA_PACKAGE_MANAGER="${envOverride}", falling back to path detection`);
   }
   const argv = process.argv[1] || "";
   let resolvedPath = argv;
@@ -72966,14 +73507,14 @@ function detectPackageManager() {
     resolvedPath = realpathSync2(argv);
   } catch {}
   if (/[/\\]\.bun[/\\]/.test(resolvedPath)) {
-    debugLog2("Detected package manager from path: bun");
+    debugLog3("Detected package manager from path: bun");
     return "bun";
   }
   if (/[/\\]\.?pnpm[/\\]/.test(resolvedPath)) {
-    debugLog2("Detected package manager from path: pnpm");
+    debugLog3("Detected package manager from path: pnpm");
     return "pnpm";
   }
-  debugLog2("Detected package manager from path: npm (default)");
+  debugLog3("Detected package manager from path: npm (default)");
   return "npm";
 }
 function isAutoUpdateEnabled() {
@@ -72985,22 +73526,22 @@ function isRunningLocally() {
   try {
     resolvedPath = realpathSync2(argv);
   } catch {}
-  debugLog2("argv[1]:", argv);
-  debugLog2("resolved path:", resolvedPath);
+  debugLog3("argv[1]:", argv);
+  debugLog3("resolved path:", resolvedPath);
   return !resolvedPath.includes("node_modules");
 }
 async function checkForUpdate() {
   const currentVersion = getVersion();
-  debugLog2("Current version:", currentVersion);
+  debugLog3("Current version:", currentVersion);
   if (currentVersion.includes("-")) {
-    debugLog2("Prerelease version detected, skipping auto-update check");
+    debugLog3("Prerelease version detected, skipping auto-update check");
     return { updateAvailable: false, currentVersion };
   }
   const packageName = resolveUpdatePackageName();
   const registryBaseUrl = resolveUpdateRegistryBaseUrl();
   const latestUrl = buildLatestVersionUrl(packageName, registryBaseUrl);
   try {
-    debugLog2("Checking registry for latest version:", latestUrl);
+    debugLog3("Checking registry for latest version:", latestUrl);
     const res = await fetch(latestUrl, {
       signal: AbortSignal.timeout(5000)
     });
@@ -73012,18 +73553,18 @@ async function checkForUpdate() {
       throw new Error("Unexpected registry response shape");
     }
     const latestVersion = data.version;
-    debugLog2("Latest version from registry:", latestVersion);
+    debugLog3("Latest version from registry:", latestVersion);
     if (latestVersion !== currentVersion) {
-      debugLog2("Update available!");
+      debugLog3("Update available!");
       return {
         updateAvailable: true,
         latestVersion,
         currentVersion
       };
     }
-    debugLog2("Already on latest version");
+    debugLog3("Already on latest version");
   } catch (error) {
-    debugLog2("Failed to check for updates:", error);
+    debugLog3("Failed to check for updates:", error);
     return {
       updateAvailable: false,
       currentVersion,
@@ -73046,13 +73587,13 @@ async function getNpmGlobalPath() {
   }
 }
 async function cleanupOrphanedDirs(globalPath) {
-  const lettaAiDir = join22(globalPath, "lib/node_modules/@letta-ai");
+  const lettaAiDir = join23(globalPath, "lib/node_modules/@letta-ai");
   try {
     const entries = await readdir7(lettaAiDir);
     for (const entry of entries) {
       if (entry.startsWith(".letta-code-")) {
-        const orphanPath = join22(lettaAiDir, entry);
-        debugLog2("Cleaning orphaned temp directory:", orphanPath);
+        const orphanPath = join23(lettaAiDir, entry);
+        debugLog3("Cleaning orphaned temp directory:", orphanPath);
         await rm(orphanPath, { recursive: true, force: true });
       }
     }
@@ -73062,33 +73603,33 @@ async function performUpdate() {
   const pm = detectPackageManager();
   const installCmd = buildInstallCommand(pm);
   const installArgs = buildInstallArgs(pm);
-  debugLog2("Detected package manager:", pm);
-  debugLog2("Install command:", installCmd);
+  debugLog3("Detected package manager:", pm);
+  debugLog3("Install command:", installCmd);
   let globalPath = null;
   if (pm === "npm") {
     globalPath = await getNpmGlobalPath();
     if (globalPath) {
-      debugLog2("Pre-cleaning orphaned directories in:", globalPath);
+      debugLog3("Pre-cleaning orphaned directories in:", globalPath);
       await cleanupOrphanedDirs(globalPath);
     }
   }
   try {
-    debugLog2(`Running ${installCmd}...`);
+    debugLog3(`Running ${installCmd}...`);
     await execFileAsync7(pm, installArgs, { timeout: 60000 });
-    debugLog2("Update completed successfully");
+    debugLog3("Update completed successfully");
     return { success: true };
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     if (pm === "npm" && errorMsg.includes("ENOTEMPTY") && globalPath) {
-      debugLog2("ENOTEMPTY detected, attempting cleanup and retry...");
+      debugLog3("ENOTEMPTY detected, attempting cleanup and retry...");
       await cleanupOrphanedDirs(globalPath);
       try {
         await execFileAsync7(pm, installArgs, { timeout: 60000 });
-        debugLog2("Update succeeded after cleanup retry");
+        debugLog3("Update succeeded after cleanup retry");
         return { success: true };
       } catch (retryError) {
         const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
-        debugLog2("Update failed after retry:", retryMsg);
+        debugLog3("Update failed after retry:", retryMsg);
         if (retryMsg.includes("ENOTEMPTY")) {
           return {
             success: false,
@@ -73101,21 +73642,21 @@ async function performUpdate() {
     }
     const isNpmRaceCondition = pm === "npm" && (errorMsg.includes("TAR_ENTRY_ERROR") || errorMsg.includes("uv_cwd") || errorMsg.includes("spawn sh") && errorMsg.includes("ENOENT"));
     if (isNpmRaceCondition) {
-      debugLog2("npm race condition detected, cleaning up and retrying...");
+      debugLog3("npm race condition detected, cleaning up and retrying...");
       if (globalPath) {
         await cleanupOrphanedDirs(globalPath);
       }
       try {
         await execFileAsync7(pm, installArgs, { timeout: 60000 });
-        debugLog2("Update succeeded after race condition retry");
+        debugLog3("Update succeeded after race condition retry");
         return { success: true };
       } catch (retryError) {
         const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
-        debugLog2("Update failed after race condition retry:", retryMsg);
+        debugLog3("Update failed after race condition retry:", retryMsg);
         return { success: false, error: retryMsg };
       }
     }
-    debugLog2("Update failed:", error);
+    debugLog3("Update failed:", error);
     return { success: false, error: errorMsg };
   }
 }
@@ -73129,16 +73670,16 @@ function isSignificantUpdate(current, latest) {
   return false;
 }
 async function checkAndAutoUpdate() {
-  debugLog2("Auto-update check starting...");
-  debugLog2("isAutoUpdateEnabled:", isAutoUpdateEnabled());
+  debugLog3("Auto-update check starting...");
+  debugLog3("isAutoUpdateEnabled:", isAutoUpdateEnabled());
   const runningLocally = isRunningLocally();
-  debugLog2("isRunningLocally:", runningLocally);
+  debugLog3("isRunningLocally:", runningLocally);
   if (!isAutoUpdateEnabled()) {
-    debugLog2("Auto-update disabled via DISABLE_AUTOUPDATER=1");
+    debugLog3("Auto-update disabled via DISABLE_AUTOUPDATER=1");
     return;
   }
   if (runningLocally) {
-    debugLog2("Running locally, skipping auto-update");
+    debugLog3("Running locally, skipping auto-update");
     return;
   }
   const result = await checkForUpdate();
@@ -73313,6 +73854,7 @@ __export(exports_promptAssets2, {
   MEMORY_PROMPTS: () => MEMORY_PROMPTS2,
   MEMORY_CHECK_REMINDER: () => MEMORY_CHECK_REMINDER2,
   INTERRUPT_RECOVERY_ALERT: () => INTERRUPT_RECOVERY_ALERT2,
+  AUTO_INIT_REMINDER: () => AUTO_INIT_REMINDER2,
   APPROVAL_RECOVERY_PROMPT: () => APPROVAL_RECOVERY_PROMPT2
 });
 async function resolveSystemPrompt2(systemPromptPreset) {
@@ -73331,9 +73873,10 @@ async function resolveSystemPrompt2(systemPromptPreset) {
   }
   return SYSTEM_PROMPT2;
 }
-var SYSTEM_PROMPT2, SYSTEM_PROMPT_MEMORY_ADDON2, SYSTEM_PROMPT_MEMFS_ADDON2, PLAN_MODE_REMINDER2, SKILL_CREATOR_PROMPT2, REMEMBER_PROMPT2, MEMORY_CHECK_REMINDER2, MEMORY_REFLECTION_REMINDER2, APPROVAL_RECOVERY_PROMPT2, INTERRUPT_RECOVERY_ALERT2, MEMORY_PROMPTS2, SYSTEM_PROMPTS2;
+var SYSTEM_PROMPT2, SYSTEM_PROMPT_MEMORY_ADDON2, SYSTEM_PROMPT_MEMFS_ADDON2, PLAN_MODE_REMINDER2, SKILL_CREATOR_PROMPT2, REMEMBER_PROMPT2, MEMORY_CHECK_REMINDER2, MEMORY_REFLECTION_REMINDER2, APPROVAL_RECOVERY_PROMPT2, AUTO_INIT_REMINDER2, INTERRUPT_RECOVERY_ALERT2, MEMORY_PROMPTS2, SYSTEM_PROMPTS2;
 var init_promptAssets2 = __esm(() => {
   init_approval_recovery_alert();
+  init_auto_init_reminder();
   init_claude();
   init_codex();
   init_gemini();
@@ -73366,6 +73909,7 @@ var init_promptAssets2 = __esm(() => {
   MEMORY_CHECK_REMINDER2 = memory_check_reminder_default;
   MEMORY_REFLECTION_REMINDER2 = memory_reflection_reminder_default;
   APPROVAL_RECOVERY_PROMPT2 = approval_recovery_alert_default;
+  AUTO_INIT_REMINDER2 = auto_init_reminder_default;
   INTERRUPT_RECOVERY_ALERT2 = interrupt_recovery_alert_default;
   MEMORY_PROMPTS2 = {
     "persona.mdx": persona_default,
@@ -73438,9 +73982,9 @@ __export(exports_subagents2, {
   GLOBAL_AGENTS_DIR: () => GLOBAL_AGENTS_DIR2,
   AGENTS_DIR: () => AGENTS_DIR2
 });
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 import { readdir as readdir8, readFile as readFile7 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function isValidName2(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
@@ -73522,7 +74066,7 @@ function getBuiltinSubagentNames2() {
   return new Set(Object.keys(getBuiltinSubagents2()));
 }
 async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors) {
-  if (!existsSync15(agentsDir)) {
+  if (!existsSync16(agentsDir)) {
     return;
   }
   try {
@@ -73531,7 +74075,7 @@ async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors
       if (!entry.isFile() || !entry.name.endsWith(".md")) {
         continue;
       }
-      const filePath = join24(agentsDir, entry.name);
+      const filePath = join25(agentsDir, entry.name);
       try {
         const config = await parseSubagentFile2(filePath);
         if (config) {
@@ -73563,7 +74107,7 @@ async function discoverSubagents2(workingDirectory = process.cwd()) {
   const subagents = [];
   const seenNames = new Set;
   await discoverSubagentsFromDir2(GLOBAL_AGENTS_DIR2, seenNames, subagents, errors);
-  const projectAgentsDir = join24(workingDirectory, AGENTS_DIR2);
+  const projectAgentsDir = join25(workingDirectory, AGENTS_DIR2);
   await discoverSubagentsFromDir2(projectAgentsDir, seenNames, subagents, errors);
   return { subagents, errors };
 }
@@ -73606,7 +74150,7 @@ var init_subagents2 = __esm(() => {
     recall_default,
     reflection_default
   ];
-  GLOBAL_AGENTS_DIR2 = join24(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
+  GLOBAL_AGENTS_DIR2 = join25(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS2 = new Set(MEMORY_BLOCK_LABELS);
   cache5 = {
     builtins: null,
@@ -73978,24 +74522,6 @@ var init_cli2 = __esm(() => {
   cliPermissions2 = new CliPermissions2;
 });
 
-// src/agent/approval-recovery.ts
-async function fetchRunErrorDetail(runId) {
-  if (!runId)
-    return null;
-  try {
-    const client = await getClient2();
-    const run = await client.runs.retrieve(runId);
-    const metaError = run.metadata?.error;
-    return metaError?.detail ?? metaError?.message ?? metaError?.error?.detail ?? metaError?.error?.message ?? null;
-  } catch {
-    return null;
-  }
-}
-var init_approval_recovery = __esm(async () => {
-  init_turn_recovery_policy();
-  await init_client2();
-});
-
 // src/agent/listMessagesRouting.ts
 function resolveListMessagesRoute(listReq, sessionConvId, sessionAgentId) {
   const targetConvId = listReq.conversation_id ?? sessionConvId;
@@ -74003,7 +74529,7 @@ function resolveListMessagesRoute(listReq, sessionConvId, sessionAgentId) {
     return { kind: "conversations", conversationId: targetConvId };
   }
   const agentId = listReq.agent_id ?? sessionAgentId;
-  return { kind: "conversations", conversationId: agentId };
+  return { kind: "conversations", conversationId: "default", agentId };
 }
 
 // src/agent/bootstrapHandler.ts
@@ -74022,7 +74548,7 @@ async function handleBootstrapSessionState(params) {
   try {
     const route = resolveListMessagesRoute({ conversation_id: undefined, agent_id: sessionContext.agentId }, sessionContext.conversationId, sessionContext.agentId);
     const listStart = Date.now();
-    const page = await client.conversations.messages.list(route.conversationId, { limit: limit2, order });
+    const page = await client.conversations.messages.list(route.conversationId, { limit: limit2, order, ...route.agentId ? { agent_id: route.agentId } : {} });
     const items = page.getPaginatedItems();
     const listEnd = Date.now();
     const hasMore = items.length >= limit2;
@@ -74377,7 +74903,12 @@ async function handleListMessages(params) {
   };
   try {
     const route = resolveListMessagesRoute(listReq, sessionConversationId, sessionAgentId);
-    const page = await client.conversations.messages.list(route.conversationId, { limit: limit2, order, ...cursorOpts });
+    const page = await client.conversations.messages.list(route.conversationId, {
+      limit: limit2,
+      order,
+      ...route.agentId ? { agent_id: route.agentId } : {},
+      ...cursorOpts
+    });
     const items = page.getPaginatedItems();
     const hasMore = items.length >= limit2;
     const oldestId = items.length > 0 ? items[items.length - 1]?.id : undefined;
@@ -74998,6 +75529,11 @@ var init_catalog = __esm(() => {
       description: "Compaction-triggered reflection reminder/auto-launch behavior",
       modes: ["interactive", "headless-one-shot", "headless-bidirectional"]
     },
+    {
+      id: "deep-init",
+      description: "Auto-launch deep memory init after shallow init + turn gate",
+      modes: ["interactive"]
+    },
     {
       id: "command-io",
       description: "Recent slash command input/output context",
@@ -75007,6 +75543,11 @@ var init_catalog = __esm(() => {
       id: "toolset-change",
       description: "Client-side toolset change context",
       modes: ["interactive"]
+    },
+    {
+      id: "auto-init",
+      description: "Auto-init background onboarding notification",
+      modes: ["interactive"]
     }
   ];
   SHARED_REMINDER_IDS = SHARED_REMINDER_CATALOG.map((entry) => entry.id);
@@ -75014,7 +75555,7 @@ var init_catalog = __esm(() => {
 });
 
 // src/reminders/engine.ts
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 async function buildAgentInfoReminder(context3) {
   if (context3.state.hasSentAgentInfo) {
     return null;
@@ -75046,7 +75587,7 @@ async function buildSkillsReminder(context3) {
   const previousSkillsReminder = context3.state.cachedSkillsReminder;
   let latestSkillsReminder = previousSkillsReminder ?? "";
   try {
-    const skillsDir = getSkillsDirectory() || join25(process.cwd(), SKILLS_DIR);
+    const skillsDir = getSkillsDirectory() || join26(process.cwd(), SKILLS_DIR);
     const { skills } = await discoverSkills(skillsDir, context3.agent.id, {
       sources: context3.skillSources
     });
@@ -75129,6 +75670,30 @@ async function buildReflectionCompactionReminder(context3) {
   }
   return buildCompactionMemoryReminder(context3.agent.id);
 }
+async function buildAutoInitReminder(context3) {
+  if (!context3.state.pendingAutoInitReminder)
+    return null;
+  context3.state.pendingAutoInitReminder = false;
+  const { AUTO_INIT_REMINDER: AUTO_INIT_REMINDER3 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+  return AUTO_INIT_REMINDER3;
+}
+async function maybeLaunchDeepInit(context3) {
+  if (!DEEP_INIT_AUTO_LAUNCH_ENABLED)
+    return null;
+  if (!context3.state.shallowInitCompleted)
+    return null;
+  if (context3.state.deepInitFired)
+    return null;
+  if (context3.state.turnCount < 8)
+    return null;
+  const memfsEnabled = settingsManager.isMemfsEnabled(context3.agent.id);
+  if (!memfsEnabled)
+    return null;
+  if (context3.maybeLaunchDeepInitSubagent) {
+    await context3.maybeLaunchDeepInitSubagent();
+  }
+  return null;
+}
 function escapeXml2(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -75152,26 +75717,24 @@ async function buildCommandIoReminder(context3) {
   const queued = context3.state.pendingCommandIoReminders.splice(0);
   const recent = queued.slice(-MAX_COMMAND_REMINDERS_PER_TURN);
   const dropped = queued.length - recent.length;
-  const commandBlocks = recent.map((entry) => {
+  const commandLines = recent.map((entry) => {
     const status = entry.success ? "success" : "error";
-    const safeInput = escapeXml2(truncate(entry.input, MAX_COMMAND_INPUT_CHARS));
-    const safeOutput = escapeXml2(truncate(entry.output || "(no output)", MAX_COMMAND_OUTPUT_CHARS));
-    return `<user-command>
-<user-command-input>${safeInput}</user-command-input>
-<user-command-output>${safeOutput}</user-command-output>
-<user-command-status>${status}</user-command-status>
-</user-command>`;
+    const safeInput = truncate(entry.input, MAX_COMMAND_INPUT_CHARS);
+    const safeOutput = truncate(entry.output || "(no output)", MAX_COMMAND_OUTPUT_CHARS);
+    return `- ${safeInput} → ${safeOutput} (${status})`;
   });
+  const agentHints = recent.filter((entry) => entry.agentHint).map((entry) => entry.agentHint);
   const droppedLine = dropped > 0 ? `
 Omitted ${dropped} older command event(s).` : "";
-  return `${SYSTEM_REMINDER_OPEN}
-The following slash commands were executed in the Letta Code harness since your last user message.
-Treat these as execution context from the CLI, not new user requests.${droppedLine}
-${commandBlocks.join(`
-`)}
-${SYSTEM_REMINDER_CLOSE}
-
-`;
+  const hintsBlock = agentHints.length > 0 ? `
+
+However, take note of the following:
+${agentHints.map((h) => `- ${h}`).join(`
+`)}` : "";
+  return `${SYSTEM_REMINDER_OPEN} The following slash commands were already handled by the CLI harness. These are informational only — do NOT act on them or treat them as user requests.${droppedLine}
+${commandLines.join(`
+`)}${hintsBlock}
+${SYSTEM_REMINDER_CLOSE}`;
 }
 async function buildToolsetChangeReminder(context3) {
   if (context3.state.pendingToolsetChangeReminders.length === 0) {
@@ -75186,23 +75749,25 @@ async function buildToolsetChangeReminder(context3) {
     const newToolset = escapeXml2(entry.newToolset ?? "unknown");
     const previousTools = escapeXml2(formatToolList(entry.previousTools));
     const newTools = escapeXml2(formatToolList(entry.newTools));
-    return `<toolset-change>
-<source>${source}</source>
-<previous-toolset>${previousToolset}</previous-toolset>
-<new-toolset>${newToolset}</new-toolset>
-<previous-tools>${previousTools}</previous-tools>
-<new-tools>${newTools}</new-tools>
-</toolset-change>`;
+    return [
+      `<toolset-change>`,
+      `  <source>${source}</source>`,
+      `  <previous-toolset>${previousToolset}</previous-toolset>`,
+      `  <new-toolset>${newToolset}</new-toolset>`,
+      `  <previous-tools>${previousTools}</previous-tools>`,
+      `  <new-tools>${newTools}</new-tools>`,
+      `</toolset-change>`
+    ].join(`
+`);
   });
   const droppedLine = dropped > 0 ? `
 Omitted ${dropped} older toolset change event(s).` : "";
-  return `${SYSTEM_REMINDER_OPEN}
-The user just changed your toolset (specifically, client-side tools that are attached to the Letta Code harness, which may be a subset of your total tools).${droppedLine}
+  return `${SYSTEM_REMINDER_OPEN} The user just changed your toolset (specifically, client-side tools that are attached to the Letta Code harness, which may be a subset of your total tools).${droppedLine}
+
 ${changeBlocks.join(`
-`)}
-${SYSTEM_REMINDER_CLOSE}
 
-`;
+`)}
+${SYSTEM_REMINDER_CLOSE}`;
 }
 function assertSharedReminderCoverage() {
   const catalogIds = new Set(SHARED_REMINDER_CATALOG.map((entry) => entry.id));
@@ -75250,7 +75815,7 @@ function prependReminderPartsToContent(content, reminderParts) {
   }
   return content;
 }
-var PERMISSION_MODE_DESCRIPTIONS, MAX_COMMAND_REMINDERS_PER_TURN = 10, MAX_TOOLSET_REMINDERS_PER_TURN = 5, MAX_COMMAND_INPUT_CHARS = 2000, MAX_COMMAND_OUTPUT_CHARS = 4000, MAX_TOOL_LIST_CHARS = 3000, sharedReminderProviders;
+var PERMISSION_MODE_DESCRIPTIONS, DEEP_INIT_AUTO_LAUNCH_ENABLED = false, MAX_COMMAND_REMINDERS_PER_TURN = 10, MAX_TOOLSET_REMINDERS_PER_TURN = 5, MAX_COMMAND_INPUT_CHARS = 2000, MAX_COMMAND_OUTPUT_CHARS = 4000, MAX_TOOL_LIST_CHARS = 3000, sharedReminderProviders;
 var init_engine = __esm(async () => {
   init_context();
   init_skills();
@@ -75277,8 +75842,10 @@ var init_engine = __esm(async () => {
     "plan-mode": buildPlanModeReminder,
     "reflection-step-count": buildReflectionStepReminder,
     "reflection-compaction": buildReflectionCompactionReminder,
+    "deep-init": maybeLaunchDeepInit,
     "command-io": buildCommandIoReminder,
-    "toolset-change": buildToolsetChangeReminder
+    "toolset-change": buildToolsetChangeReminder,
+    "auto-init": buildAutoInitReminder
   };
   assertSharedReminderCoverage();
 });
@@ -75295,8 +75862,11 @@ function createSharedReminderState() {
     turnCount: 0,
     pendingSkillsReinject: false,
     pendingReflectionTrigger: false,
+    pendingAutoInitReminder: false,
     pendingCommandIoReminders: [],
-    pendingToolsetChangeReminders: []
+    pendingToolsetChangeReminders: [],
+    shallowInitCompleted: false,
+    deepInitFired: false
   };
 }
 function resetSharedReminderState(state) {
@@ -75480,7 +76050,7 @@ function parseRegistryHandle(handle) {
 }
 async function importAgentFromRegistry(options) {
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const { join: join26 } = await import("node:path");
+  const { join: join27 } = await import("node:path");
   const { writeFile: writeFile4, unlink } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
@@ -75492,7 +76062,7 @@ async function importAgentFromRegistry(options) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join26(tmpdir3(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join27(tmpdir3(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile4(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
@@ -75985,6 +76555,7 @@ In headless mode, use:
   }
   if (specifiedConversationId && specifiedConversationId !== "default") {
     try {
+      debugLog("conversations", `retrieve(${specifiedConversationId}) [headless conv→agent lookup]`);
       const conversation = await client.conversations.retrieve(specifiedConversationId);
       agent = await client.agents.retrieve(conversation.agent_id);
     } catch (_error) {
@@ -76162,6 +76733,7 @@ In headless mode, use:
       conversationId = "default";
     } else {
       try {
+        debugLog("conversations", `retrieve(${specifiedConversationId}) [headless --conv validate]`);
         await client.conversations.retrieve(specifiedConversationId);
         conversationId = specifiedConversationId;
       } catch {
@@ -76177,6 +76749,7 @@ In headless mode, use:
         conversationId = "default";
       } else {
         try {
+          debugLog("conversations", `retrieve(${lastSession.conversationId}) [headless lastSession resume]`);
           await client.conversations.retrieve(lastSession.conversationId);
           conversationId = lastSession.conversationId;
         } catch {
@@ -76493,21 +77066,22 @@ ${loadedContents.join(`
         }
         if (preStreamAction === "retry_conversation_busy") {
           conversationBusyRetries += 1;
+          const retryDelayMs = CONVERSATION_BUSY_RETRY_BASE_DELAY_MS * 2 ** (conversationBusyRetries - 1);
           if (outputFormat === "stream-json") {
             const retryMsg = {
               type: "retry",
               reason: "error",
               attempt: conversationBusyRetries,
               max_attempts: CONVERSATION_BUSY_MAX_RETRIES,
-              delay_ms: CONVERSATION_BUSY_RETRY_DELAY_MS,
+              delay_ms: retryDelayMs,
               session_id: sessionId,
               uuid: `retry-conversation-busy-${randomUUID7()}`
             };
             console.log(JSON.stringify(retryMsg));
           } else {
-            console.error(`Conversation is busy, waiting ${CONVERSATION_BUSY_RETRY_DELAY_MS / 1000}s and retrying...`);
+            console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
           }
-          await new Promise((resolve25) => setTimeout(resolve25, CONVERSATION_BUSY_RETRY_DELAY_MS));
+          await new Promise((resolve25) => setTimeout(resolve25, retryDelayMs));
           continue;
         }
         if (preStreamAction === "retry_transient") {
@@ -77789,7 +78363,7 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
   setMessageQueueAdder(null);
   process.exit(0);
 }
-var LLM_API_ERROR_MAX_RETRIES2 = 3, EMPTY_RESPONSE_MAX_RETRIES = 2, CONVERSATION_BUSY_MAX_RETRIES = 1, CONVERSATION_BUSY_RETRY_DELAY_MS = 2500;
+var LLM_API_ERROR_MAX_RETRIES2 = 3, EMPTY_RESPONSE_MAX_RETRIES = 2, CONVERSATION_BUSY_MAX_RETRIES = 3, CONVERSATION_BUSY_RETRY_BASE_DELAY_MS = 1e4;
 var init_headless = __esm(async () => {
   init_error();
   init_bootstrapHandler();
@@ -77802,6 +78376,7 @@ var init_headless = __esm(async () => {
   init_constants();
   init_diffPreview();
   init_interactivePolicy();
+  init_debug();
   init_timing();
   await __promiseAll([
     init_approval_recovery(),
@@ -78111,10 +78686,10 @@ __export(exports_settings, {
   loadProjectSettings: () => loadProjectSettings,
   getSetting: () => getSetting
 });
-import { homedir as homedir20 } from "node:os";
-import { join as join27 } from "node:path";
+import { homedir as homedir21 } from "node:os";
+import { join as join28 } from "node:path";
 function getSettingsPath() {
-  return join27(homedir20(), ".letta", "settings.json");
+  return join28(homedir21(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -78151,7 +78726,7 @@ async function getSetting(key) {
   return settings[key];
 }
 function getProjectSettingsPath() {
-  return join27(process.cwd(), ".letta", "settings.local.json");
+  return join28(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -78169,7 +78744,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join27(process.cwd(), ".letta");
+  const dirPath = join28(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -78671,6 +79246,13 @@ function createCommandRunner({
   onCommandFinished
 }) {
   function getHandle(id, input) {
+    const handle = {
+      id,
+      input,
+      update: null,
+      finish: null,
+      fail: null
+    };
     const update = (updateData) => {
       const previous = buffersRef.current.byId.get(id);
       const wasFinished = previous?.kind === "command" && previous.phase === "finished";
@@ -78687,24 +79269,26 @@ function createCommandRunner({
           output: next.output,
           success: next.success !== false,
           dimOutput: next.dimOutput,
-          preformatted: next.preformatted
+          preformatted: next.preformatted,
+          agentHint: handle.agentHint
         });
       }
       refreshDerived();
     };
-    const finish = (finalOutput, success = true, dimOutput, preformatted) => update({
+    handle.update = update;
+    handle.finish = (finalOutput, success = true, dimOutput, preformatted) => update({
       output: finalOutput,
       phase: "finished",
       success,
       dimOutput,
       preformatted
     });
-    const fail = (finalOutput) => update({
+    handle.fail = (finalOutput) => update({
       output: finalOutput,
       phase: "finished",
       success: false
     });
-    return { id, input, update, finish, fail };
+    return handle;
   }
   function start(input, output) {
     const id = createId("cmd");
@@ -80477,9 +81061,9 @@ function getFileEditHeader(toolName, toolArgs) {
     const relPath = relative9(cwd2, filePath);
     const displayPath = relPath.startsWith("..") ? filePath : relPath;
     if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-      const { existsSync: existsSync17 } = __require("node:fs");
+      const { existsSync: existsSync18 } = __require("node:fs");
       try {
-        if (existsSync17(filePath)) {
+        if (existsSync18(filePath)) {
           return `Overwrite ${displayPath}?`;
         }
       } catch {}
@@ -81181,9 +81765,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative9(cwd2, fileEdit.filePath);
   const displayPath = relPath.startsWith("..") ? fileEdit.filePath : relPath;
   if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-    const { existsSync: existsSync17 } = __require("node:fs");
+    const { existsSync: existsSync18 } = __require("node:fs");
     try {
-      if (existsSync17(fileEdit.filePath)) {
+      if (existsSync18(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -82821,9 +83405,9 @@ html.dark .agent-name { color: var(--text-dim); }
 var init_plan_viewer_template = () => {};
 
 // src/web/generate-plan-viewer.ts
-import { chmodSync as chmodSync2, existsSync as existsSync17, mkdirSync as mkdirSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir21 } from "node:os";
-import { join as join28 } from "node:path";
+import { chmodSync as chmodSync2, existsSync as existsSync18, mkdirSync as mkdirSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { join as join29 } from "node:path";
 async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
   const data = {
     agent: { name: options?.agentName ?? "" },
@@ -82833,13 +83417,13 @@ async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
   };
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html = plan_viewer_template_default.replace("<!--LETTA_PLAN_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync17(VIEWERS_DIR)) {
-    mkdirSync13(VIEWERS_DIR, { recursive: true, mode: 448 });
+  if (!existsSync18(VIEWERS_DIR)) {
+    mkdirSync14(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync2(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join28(VIEWERS_DIR, "plan.html");
+  const filePath = join29(VIEWERS_DIR, "plan.html");
   writeFileSync8(filePath, html);
   chmodSync2(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -82856,7 +83440,7 @@ async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
 var VIEWERS_DIR;
 var init_generate_plan_viewer = __esm(() => {
   init_plan_viewer_template();
-  VIEWERS_DIR = join28(homedir21(), ".letta", "viewers");
+  VIEWERS_DIR = join29(homedir22(), ".letta", "viewers");
 });
 
 // src/cli/components/StaticPlanApproval.tsx
@@ -84054,7 +84638,8 @@ function ConversationSelector2({
       let defaultConversation = null;
       if (!afterCursor) {
         try {
-          const defaultMessages = await client.conversations.messages.list(agentId, {
+          const defaultMessages = await client.conversations.messages.list("default", {
+            agent_id: agentId,
             limit: 20,
             order: "desc"
           });
@@ -84829,9 +85414,9 @@ var init_pasteRegistry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync18, readFileSync as readFileSync5, statSync as statSync4, unlinkSync as unlinkSync7 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync6, statSync as statSync4, unlinkSync as unlinkSync8 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename4, extname as extname5, isAbsolute as isAbsolute16, join as join29, resolve as resolve25 } from "node:path";
+import { basename as basename4, extname as extname5, isAbsolute as isAbsolute16, join as join30, resolve as resolve25 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
 }
@@ -84881,8 +85466,8 @@ function translatePasteForImages(paste) {
       if (!isAbsolute16(filePath))
         filePath = resolve25(process.cwd(), filePath);
       const ext3 = extname5(filePath || "").toLowerCase();
-      if (IMAGE_EXTS.has(ext3) && existsSync18(filePath) && statSync4(filePath).isFile()) {
-        const buf = readFileSync5(filePath);
+      if (IMAGE_EXTS.has(ext3) && existsSync19(filePath) && statSync4(filePath).isFile()) {
+        const buf = readFileSync6(filePath);
         const b64 = buf.toString("base64");
         const mt = ext3 === ".png" ? "image/png" : ext3 === ".jpg" || ext3 === ".jpeg" ? "image/jpeg" : ext3 === ".gif" ? "image/gif" : ext3 === ".webp" ? "image/webp" : ext3 === ".bmp" ? "image/bmp" : ext3 === ".svg" ? "image/svg+xml" : ext3 === ".tif" || ext3 === ".tiff" ? "image/tiff" : ext3 === ".heic" ? "image/heic" : ext3 === ".heif" ? "image/heif" : ext3 === ".avif" ? "image/avif" : "application/octet-stream";
         const id = allocateImage({
@@ -84899,7 +85484,7 @@ function translatePasteForImages(paste) {
 function getClipboardImageToTempFile() {
   if (process.platform !== "darwin")
     return null;
-  const tempPath = join29(tmpdir3(), `letta-clipboard-${Date.now()}.bin`);
+  const tempPath = join30(tmpdir3(), `letta-clipboard-${Date.now()}.bin`);
   try {
     const jxa = `
       ObjC.import('AppKit');
@@ -84922,13 +85507,13 @@ function getClipboardImageToTempFile() {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    if (!uti || !existsSync18(tempPath))
+    if (!uti || !existsSync19(tempPath))
       return null;
     return { tempPath, uti };
   } catch {
-    if (existsSync18(tempPath)) {
+    if (existsSync19(tempPath)) {
       try {
-        unlinkSync7(tempPath);
+        unlinkSync8(tempPath);
       } catch {}
     }
     return null;
@@ -84942,9 +85527,9 @@ async function tryImportClipboardImageMac() {
     return null;
   const { tempPath, uti } = clipboardResult;
   try {
-    const buffer = readFileSync5(tempPath);
+    const buffer = readFileSync6(tempPath);
     try {
-      unlinkSync7(tempPath);
+      unlinkSync8(tempPath);
     } catch {}
     const mediaType = UTI_TO_MEDIA_TYPE[uti] || "image/png";
     const resized = await resizeImageIfNeeded3(buffer, mediaType);
@@ -84959,9 +85544,9 @@ async function tryImportClipboardImageMac() {
       height: resized.height
     };
   } catch (err) {
-    if (existsSync18(tempPath)) {
+    if (existsSync19(tempPath)) {
       try {
-        unlinkSync7(tempPath);
+        unlinkSync8(tempPath);
       } catch {}
     }
     const message = err instanceof Error ? err.message : String(err);
@@ -85536,13 +86121,13 @@ __export(exports_terminalKeybindingInstaller, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync6,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync15,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { homedir as homedir22, platform as platform4 } from "node:os";
-import { dirname as dirname11, join as join30 } from "node:path";
+import { homedir as homedir23, platform as platform4 } from "node:os";
+import { dirname as dirname11, join as join31 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -85574,16 +86159,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os6 = platform4();
   if (os6 === "darwin") {
-    return join30(homedir22(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join31(homedir23(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os6 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join30(appData, appName, "User", "keybindings.json");
+    return join31(appData, appName, "User", "keybindings.json");
   }
   if (os6 === "linux") {
-    return join30(homedir22(), ".config", appName, "User", "keybindings.json");
+    return join31(homedir23(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -85605,10 +86190,10 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync19(keybindingsPath))
+  if (!existsSync20(keybindingsPath))
     return false;
   try {
-    const content = readFileSync6(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync7(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings)
       return false;
@@ -85618,7 +86203,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync19(keybindingsPath))
+  if (!existsSync20(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -85634,14 +86219,14 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname11(keybindingsPath);
-    if (!existsSync19(parentDir)) {
-      mkdirSync14(parentDir, { recursive: true });
+    if (!existsSync20(parentDir)) {
+      mkdirSync15(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync19(keybindingsPath)) {
+    if (existsSync20(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
-      const content = readFileSync6(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync7(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
       if (parsed === null) {
         return {
@@ -85669,10 +86254,10 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync19(keybindingsPath)) {
+    if (!existsSync20(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync6(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync7(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings) {
       return {
@@ -85736,20 +86321,20 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join30(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync19(xdgPath))
+    const xdgPath = join31(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync20(xdgPath))
       return xdgPath;
   }
-  const configPath = join30(homedir22(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync19(configPath))
+  const configPath = join31(homedir23(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync20(configPath))
     return configPath;
-  return join30(homedir22(), ".wezterm.lua");
+  return join31(homedir23(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync19(configPath))
+  if (!existsSync20(configPath))
     return false;
   try {
-    const content = readFileSync6(configPath, { encoding: "utf-8" });
+    const content = readFileSync7(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -85763,10 +86348,10 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync19(configPath)) {
+    if (existsSync20(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync(configPath, backupPath);
-      content = readFileSync6(configPath, { encoding: "utf-8" });
+      content = readFileSync7(configPath, { encoding: "utf-8" });
     }
     if (content.includes("return {") && !content.includes("local config")) {
       content = content.replace(/return\s*\{/, "local config = {");
@@ -85793,8 +86378,8 @@ ${WEZTERM_DELETE_FIX}
 `;
     }
     const parentDir = dirname11(configPath);
-    if (!existsSync19(parentDir)) {
-      mkdirSync14(parentDir, { recursive: true });
+    if (!existsSync20(parentDir)) {
+      mkdirSync15(parentDir, { recursive: true });
     }
     writeFileSync9(configPath, content, { encoding: "utf-8" });
     return {
@@ -86316,9 +86901,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { readdir as readdir9, readFile as readFile9 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname12, join as join31 } from "node:path";
+import { basename as basename5, dirname as dirname12, join as join32 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -86329,7 +86914,7 @@ async function getCustomCommands() {
 function refreshCustomCommands() {
   cachedCommands = null;
 }
-async function discoverCustomCommands(projectPath = join31(process.cwd(), COMMANDS_DIR)) {
+async function discoverCustomCommands(projectPath = join32(process.cwd(), COMMANDS_DIR)) {
   const commandsById = new Map;
   const userCommands = await discoverFromDirectory(GLOBAL_COMMANDS_DIR, "user");
   for (const cmd of userCommands) {
@@ -86350,7 +86935,7 @@ async function discoverCustomCommands(projectPath = join31(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source) {
-  if (!existsSync20(dirPath)) {
+  if (!existsSync21(dirPath)) {
     return [];
   }
   const commands2 = [];
@@ -86361,7 +86946,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source) {
   try {
     const entries = await readdir9(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join31(currentPath, entry.name);
+      const fullPath = join32(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findCommandFiles(fullPath, rootPath, commands2, source);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -86446,7 +87031,7 @@ async function findCustomCommand(commandName) {
 }
 var COMMANDS_DIR = ".commands", GLOBAL_COMMANDS_DIR, cachedCommands = null;
 var init_custom = __esm(() => {
-  GLOBAL_COMMANDS_DIR = join31(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
+  GLOBAL_COMMANDS_DIR = join32(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
 });
 
 // src/cli/components/HelpDialog.tsx
@@ -86727,10 +87312,10 @@ var init_HelpDialog = __esm(async () => {
 });
 
 // src/hooks/writer.ts
-import { homedir as homedir23 } from "node:os";
+import { homedir as homedir24 } from "node:os";
 import { resolve as resolve26 } from "node:path";
 function isProjectSettingsPathCollidingWithGlobal2(workingDirectory) {
-  const home = process.env.HOME || homedir23();
+  const home = process.env.HOME || homedir24();
   const globalSettingsPath = resolve26(home, ".letta", "settings.json");
   const projectSettingsPath = resolve26(workingDirectory, ".letta", "settings.json");
   return globalSettingsPath === projectSettingsPath;
@@ -87782,28 +88367,28 @@ var require_react_jsx_runtime_development = __commonJS((exports) => {
         return null;
       }
       var ReactSharedInternals = React14.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-      function error(format2) {
+      function error(format3) {
         {
           {
             for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1;_key2 < _len2; _key2++) {
               args[_key2 - 1] = arguments[_key2];
             }
-            printWarning("error", format2, args);
+            printWarning("error", format3, args);
           }
         }
       }
-      function printWarning(level, format2, args) {
+      function printWarning(level, format3, args) {
         {
           var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
           var stack = ReactDebugCurrentFrame2.getStackAddendum();
           if (stack !== "") {
-            format2 += "%s";
+            format3 += "%s";
             args = args.concat([stack]);
           }
           var argsWithFormat = args.map(function(item) {
             return String(item);
           });
-          argsWithFormat.unshift("Warning: " + format2);
+          argsWithFormat.unshift("Warning: " + format3);
           Function.prototype.apply.call(console[level], console, argsWithFormat);
         }
       }
@@ -89019,7 +89604,7 @@ var init_AgentInfoBar = __esm(async () => {
       return localPinned.includes(agentId) || globalPinned.includes(agentId);
     }, [agentId]);
     const isCloudUser = serverUrl?.includes("api.letta.com");
-    const adeConversationUrl = agentId && agentId !== "loading" ? `https://app.letta.com/agents/${agentId}${conversationId && conversationId !== "default" ? `?conversation=${conversationId}` : ""}` : "";
+    const adeConversationUrl = agentId && agentId !== "loading" ? buildChatUrl(agentId, { conversationId }) : "";
     const showBottomBar = agentId && agentId !== "loading";
     const reasoningLabel = formatReasoningLabel(currentReasoningEffort);
     const modelLine = currentModel ? `${currentModel}${reasoningLabel ? ` (${reasoningLabel})` : ""}` : null;
@@ -89090,7 +89675,7 @@ var init_AgentInfoBar = __esm(async () => {
                   children: "· "
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ jsx_dev_runtime41.jsxDEV(dist_default4, {
-                  url: "https://app.letta.com/settings/organization/usage",
+                  url: buildAppUrl("/settings/organization/usage"),
                   children: /* @__PURE__ */ jsx_dev_runtime41.jsxDEV(Text2, {
                     children: "View usage ↗"
                   }, undefined, false, undefined, this)
@@ -89103,7 +89688,7 @@ var init_AgentInfoBar = __esm(async () => {
               children: /* @__PURE__ */ jsx_dev_runtime41.jsxDEV(Text2, {
                 dimColor: true,
                 wrap: "truncate-end",
-                children: truncateText(`Open in ADE: ${adeConversationUrl} · Usage: https://app.letta.com/settings/organization/usage`, rightWidth)
+                children: truncateText(`Open in ADE: ${adeConversationUrl} · Usage: ${buildAppUrl("/settings/organization/usage")}`, rightWidth)
               }, undefined, false, undefined, this)
             }, undefined, false, undefined, this),
             !isCloudUser && /* @__PURE__ */ jsx_dev_runtime41.jsxDEV(Box_default, {
@@ -89179,8 +89764,8 @@ var init_AgentInfoBar = __esm(async () => {
 });
 
 // src/cli/helpers/fileSearch.ts
-import { readdirSync as readdirSync8, statSync as statSync5 } from "node:fs";
-import { join as join32, resolve as resolve27 } from "node:path";
+import { readdirSync as readdirSync9, statSync as statSync5 } from "node:fs";
+import { join as join33, resolve as resolve27 } from "node:path";
 function shouldExcludeEntry(entry) {
   if (entry.startsWith(".")) {
     return true;
@@ -89192,13 +89777,13 @@ function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [],
     return results;
   }
   try {
-    const entries = readdirSync8(dir);
+    const entries = readdirSync9(dir);
     for (const entry of entries) {
       if (shouldExcludeEntry(entry)) {
         continue;
       }
       try {
-        const fullPath = join32(dir, entry);
+        const fullPath = join33(dir, entry);
         const stats = statSync5(fullPath);
         const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
         const matches = pattern.length === 0 || relativePath.toLowerCase().includes(pattern.toLowerCase());
@@ -89246,14 +89831,14 @@ async function searchFiles(query, deep = false) {
     } else {
       let entries = [];
       try {
-        entries = readdirSync8(searchDir);
+        entries = readdirSync9(searchDir);
       } catch {
         return [];
       }
       const matchingEntries = entries.filter((entry) => !shouldExcludeEntry(entry)).filter((entry) => searchPattern.length === 0 || entry.toLowerCase().includes(searchPattern.toLowerCase()));
       for (const entry of matchingEntries.slice(0, 50)) {
         try {
-          const fullPath = join32(searchDir, entry);
+          const fullPath = join33(searchDir, entry);
           const stats = statSync5(fullPath);
           const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
           results.push({
@@ -90899,7 +91484,11 @@ var init_InputRich = __esm(async () => {
     }, [backgroundAgents.length]);
     const bgAgentText = backgroundAgents.length === 0 ? "" : backgroundAgents.map((a) => {
       const elapsedS = Math.round((Date.now() - a.startTime) / 1000);
-      return `${a.type.toLowerCase()} (${elapsedS}s)`;
+      const agentId = a.agentURL?.match(/\/agents\/([^/]+)/)?.[1];
+      const chatUrl = agentId ? buildChatUrl(agentId) : null;
+      const typeLabel = a.type.toLowerCase();
+      const linkedType = chatUrl ? `\x1B]8;;${chatUrl}\x1B\\${typeLabel}\x1B]8;;\x1B\\` : typeLabel;
+      return `${linkedType} (${elapsedS}s)`;
     }).join(" · ");
     const bgIndicatorWidth = backgroundAgents.length > 0 ? 2 + stringWidth(bgAgentText) + 3 : 0;
     const maxAgentChars = Math.max(10, Math.floor(rightColumnWidth * 0.45));
@@ -91206,15 +91795,15 @@ var init_InputRich = __esm(async () => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import {
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync15,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync16,
   mkdtempSync,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync as rmSync3,
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname13, join as join33 } from "node:path";
+import { dirname as dirname13, join as join34 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync3(command, args, {
@@ -91448,8 +92037,8 @@ async function createLettaAgent(apiKey, name) {
   return { id: data.id, name: data.name };
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync(join33(tmpdir4(), "letta-install-github-app-"));
-  const repoDir = join33(tempDir, "repo");
+  const tempDir = mkdtempSync(join34(tmpdir4(), "letta-install-github-app-"));
+  const repoDir = join34(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -91460,14 +92049,14 @@ function runGit2(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join33(repoDir, workflowPath);
-  if (!existsSync21(dirname13(absolutePath))) {
-    mkdirSync15(dirname13(absolutePath), { recursive: true });
+  const absolutePath = join34(repoDir, workflowPath);
+  if (!existsSync22(dirname13(absolutePath))) {
+    mkdirSync16(dirname13(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync21(absolutePath)) {
-    const previous = readFileSync7(absolutePath, "utf8");
+  if (existsSync22(absolutePath)) {
+    const previous = readFileSync8(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
@@ -91573,7 +92162,7 @@ async function installGithubApp(options) {
         committed: false,
         secretAction: "set",
         agentId: resolvedAgentId,
-        agentUrl: resolvedAgentId ? `https://app.letta.com/agents/${resolvedAgentId}` : null
+        agentUrl: resolvedAgentId ? buildChatUrl(resolvedAgentId) : null
       };
     }
     runGit2(["add", workflowPath], repoDir);
@@ -91590,7 +92179,7 @@ async function installGithubApp(options) {
       committed: true,
       secretAction: "set",
       agentId: resolvedAgentId,
-      agentUrl: resolvedAgentId ? `https://app.letta.com/agents/${resolvedAgentId}` : null
+      agentUrl: resolvedAgentId ? buildChatUrl(resolvedAgentId) : null
     };
   } finally {
     rmSync3(tempDir, { recursive: true, force: true });
@@ -93731,21 +94320,21 @@ var init_McpSelector = __esm(async () => {
 });
 
 // src/agent/memoryScanner.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
-import { join as join34, relative as relative9 } from "node:path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync9, statSync as statSync6 } from "node:fs";
+import { join as join35, relative as relative9 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
   const scanDir = (dir, depth, parentIsLast) => {
     let entries;
     try {
-      entries = readdirSync9(dir);
+      entries = readdirSync10(dir);
     } catch {
       return;
     }
     const filtered = entries.filter((name) => !name.startsWith("."));
     const sorted = filtered.sort((a, b) => {
-      const aPath = join34(dir, a);
-      const bPath = join34(dir, b);
+      const aPath = join35(dir, a);
+      const bPath = join35(dir, b);
       let aIsDir = false;
       let bIsDir = false;
       try {
@@ -93765,7 +94354,7 @@ function scanMemoryFilesystem(memoryRoot) {
       return a.localeCompare(b);
     });
     sorted.forEach((name, index) => {
-      const fullPath = join34(dir, name);
+      const fullPath = join35(dir, name);
       let isDir = false;
       try {
         isDir = statSync6(fullPath).isDirectory();
@@ -93796,7 +94385,7 @@ function getFileNodes(nodes) {
 }
 function readFileContent(fullPath) {
   try {
-    return readFileSync8(fullPath, "utf-8");
+    return readFileSync9(fullPath, "utf-8");
   } catch {
     return "(unable to read file)";
   }
@@ -94758,7 +95347,7 @@ html.dark .warning-badge { background: hsl(42, 30%, 18%); color: hsl(42, 80%, 70
     } else {
       adeBase = 'https://app.letta.com';
     }
-    agentIdEl.href = adeBase + '/agents/' + encodeURIComponent(agentId);
+    agentIdEl.href = adeBase + '/chat/' + encodeURIComponent(agentId);
     agentIdEl.target = '_blank';
   }
   document.getElementById('generated-at').textContent = 'Generated ' + new Date(DATA.generatedAt).toLocaleString();
@@ -95440,9 +96029,9 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb2 } from "node:child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync22, mkdirSync as mkdirSync16, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir24 } from "node:os";
-import { join as join35 } from "node:path";
+import { chmodSync as chmodSync3, existsSync as existsSync23, mkdirSync as mkdirSync17, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir25 } from "node:os";
+import { join as join36 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 async function runGitSafe(cwd2, args) {
   try {
@@ -95725,13 +96314,13 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   }
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync22(VIEWERS_DIR2)) {
-    mkdirSync16(VIEWERS_DIR2, { recursive: true, mode: 448 });
+  if (!existsSync23(VIEWERS_DIR2)) {
+    mkdirSync17(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync3(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join35(VIEWERS_DIR2, `memory-${encodeURIComponent(agentId)}.html`);
+  const filePath = join36(VIEWERS_DIR2, `memory-${encodeURIComponent(agentId)}.html`);
   writeFileSync11(filePath, html);
   chmodSync3(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -95755,12 +96344,12 @@ var init_generate_memory_viewer = __esm(async () => {
     init_memoryGit()
   ]);
   execFile10 = promisify10(execFileCb2);
-  VIEWERS_DIR2 = join35(homedir24(), ".letta", "viewers");
+  VIEWERS_DIR2 = join36(homedir25(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync24 } from "node:fs";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i = 0;i < node.depth; i++) {
@@ -95778,7 +96367,7 @@ function MemfsTreeViewer({
   const terminalWidth = useTerminalWidth();
   const solidLine = SOLID_LINE18.repeat(Math.max(terminalWidth, 10));
   const isTmux = Boolean(process.env.TMUX);
-  const adeUrl = `https://app.letta.com/agents/${agentId}?view=memory${conversationId && conversationId !== "default" ? `&conversation=${conversationId}` : ""}`;
+  const adeUrl = buildChatUrl(agentId, { view: "memory", conversationId });
   const [selectedIndex, setSelectedIndex] = import_react75.useState(0);
   const [treeScrollOffset, setTreeScrollOffset] = import_react75.useState(0);
   const [viewMode, setViewMode] = import_react75.useState("split");
@@ -95786,7 +96375,7 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react75.useState(null);
   const statusTimerRef = import_react75.useRef(null);
   const memoryRoot = getMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync23(memoryRoot);
+  const memoryExists = existsSync24(memoryRoot);
   const hasGitRepo = import_react75.useMemo(() => isGitRepo(agentId), [agentId]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
@@ -96258,7 +96847,7 @@ function MemoryTabViewer({
   const terminalWidth = useTerminalWidth();
   const solidLine = SOLID_LINE19.repeat(Math.max(terminalWidth, 10));
   const isTmux = Boolean(process.env.TMUX);
-  const adeUrl = `https://app.letta.com/agents/${agentId}?view=memory${conversationId && conversationId !== "default" ? `&conversation=${conversationId}` : ""}`;
+  const adeUrl = buildChatUrl(agentId, { view: "memory", conversationId });
   const [selectedTabIndex, setSelectedTabIndex] = import_react76.useState(0);
   const [scrollOffset, setScrollOffset] = import_react76.useState(0);
   const [freshBlocks, setFreshBlocks] = import_react76.useState(null);
@@ -97253,12 +97842,22 @@ var init_ModelReasoningSelector = __esm(async () => {
 });
 
 // src/cli/components/ModelSelector.tsx
-function getModelCategories(billingTier, isSelfHosted) {
+function getModelCategories(_billingTier, isSelfHosted) {
   if (isSelfHosted) {
     return ["server-recommended", "server-all"];
   }
-  const isFreeTier = billingTier?.toLowerCase() === "free";
-  return isFreeTier ? ["byok", "byok-all", "supported", "all"] : ["supported", "all", "byok", "byok-all"];
+  return ["supported", "all", "byok", "byok-all"];
+}
+function filterModelsByAvailabilityForSelector(typedModels, availableHandles, allApiHandles) {
+  if (availableHandles === null) {
+    return typedModels.filter((m) => {
+      if (!API_GATED_MODEL_HANDLES.has(m.handle)) {
+        return true;
+      }
+      return allApiHandles.includes(m.handle);
+    });
+  }
+  return typedModels.filter((m) => availableHandles.has(m.handle));
 }
 function ModelSelector({
   currentModelId,
@@ -97326,11 +97925,10 @@ function ModelSelector({
     const staticCandidates = typedModels.filter((m) => m.handle === handle);
     return staticCandidates.find((m) => m.isDefault) ?? staticCandidates.find((m) => m.isFeatured) ?? staticCandidates.find((m) => m.updateArgs?.reasoning_effort === "medium") ?? staticCandidates.find((m) => m.updateArgs?.reasoning_effort === "high") ?? staticCandidates[0];
   }, [typedModels]);
-  const isFreeTier = billingTier?.toLowerCase() === "free";
   const supportedModels = import_react79.useMemo(() => {
     if (availableHandles === undefined)
       return [];
-    let available = availableHandles === null ? typedModels : typedModels.filter((m) => availableHandles.has(m.handle));
+    let available = filterModelsByAvailabilityForSelector(typedModels, availableHandles, allApiHandles);
     if (filterProvider) {
       available = available.filter((m) => m.handle.startsWith(`${filterProvider}/`));
     }
@@ -97346,22 +97944,15 @@ function ModelSelector({
       seen.add(m.handle);
       deduped.push(pickPreferredStaticModel(m.handle) ?? m);
     }
-    if (isFreeTier) {
-      const freeModels = deduped.filter((m) => m.free);
-      const paidModels = deduped.filter((m) => !m.free);
-      const featured2 = paidModels.filter((m) => m.isFeatured);
-      const nonFeatured2 = paidModels.filter((m) => !m.isFeatured);
-      return [...freeModels, ...featured2, ...nonFeatured2];
-    }
     const featured = deduped.filter((m) => m.isFeatured);
     const nonFeatured = deduped.filter((m) => !m.isFeatured);
     return [...featured, ...nonFeatured];
   }, [
     typedModels,
     availableHandles,
+    allApiHandles,
     filterProvider,
     searchQuery,
-    isFreeTier,
     pickPreferredStaticModel
   ]);
   const isByokHandle = import_react79.useCallback((handle) => BYOK_PROVIDER_PREFIXES.some((prefix) => handle.startsWith(prefix)), []);
@@ -97816,7 +98407,7 @@ function ModelSelector({
     ]
   }, undefined, true, undefined, this);
 }
-var import_react79, jsx_dev_runtime56, SOLID_LINE22 = "─", VISIBLE_ITEMS2 = 8, BYOK_PROVIDER_PREFIXES;
+var import_react79, jsx_dev_runtime56, SOLID_LINE22 = "─", VISIBLE_ITEMS2 = 8, BYOK_PROVIDER_PREFIXES, API_GATED_MODEL_HANDLES;
 var init_ModelSelector = __esm(async () => {
   init_useTerminalWidth();
   init_colors();
@@ -97829,6 +98420,7 @@ var init_ModelSelector = __esm(async () => {
   import_react79 = __toESM(require_react(), 1);
   jsx_dev_runtime56 = __toESM(require_jsx_dev_runtime(), 1);
   BYOK_PROVIDER_PREFIXES = ["chatgpt-plus-pro/", "lc-"];
+  API_GATED_MODEL_HANDLES = new Set(["letta/auto", "letta/auto-fast"]);
 });
 
 // src/cli/components/PinDialog.tsx
@@ -98238,11 +98830,11 @@ var init_PendingApprovalStub = __esm(async () => {
 
 // src/utils/aws-credentials.ts
 import { readFile as readFile10 } from "node:fs/promises";
-import { homedir as homedir25 } from "node:os";
-import { join as join36 } from "node:path";
+import { homedir as homedir26 } from "node:os";
+import { join as join37 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join36(homedir25(), ".aws", "credentials");
-  const configPath = join36(homedir25(), ".aws", "config");
+  const credentialsPath = join37(homedir26(), ".aws", "credentials");
+  const configPath = join37(homedir26(), ".aws", "config");
   const profiles = new Map;
   try {
     const content = await readFile10(credentialsPath, "utf-8");
@@ -99318,7 +99910,7 @@ function formatUsageStats({
     const monthlyCredits = Math.round(balance.monthly_credit_balance);
     const purchasedCredits = Math.round(balance.purchased_credit_balance);
     const toDollars = (credits) => (credits / 1000).toFixed(2);
-    outputLines.push(`Plan: [${balance.billing_tier}]`, "https://app.letta.com/settings/organization/usage", "", `Available credits:     ◎${formatNumber(totalCredits)} ($${toDollars(totalCredits)})`, `Monthly credits:       ◎${formatNumber(monthlyCredits)} ($${toDollars(monthlyCredits)})`, `Purchased credits:     ◎${formatNumber(purchasedCredits)} ($${toDollars(purchasedCredits)})`);
+    outputLines.push(`Plan: [${balance.billing_tier}]`, buildAppUrl("/settings/organization/usage"), "", `Available credits:     ◎${formatNumber(totalCredits)} ($${toDollars(totalCredits)})`, `Monthly credits:       ◎${formatNumber(monthlyCredits)} ($${toDollars(monthlyCredits)})`, `Purchased credits:     ◎${formatNumber(purchasedCredits)} ($${toDollars(purchasedCredits)})`);
   }
   return outputLines.join(`
 `);
@@ -99350,8 +99942,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join37 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join37(process.cwd(), SKILLS_DIR3);
+        const { join: join38 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join38(process.cwd(), SKILLS_DIR3);
         const result = await discoverSkills3(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -103295,6 +103887,7 @@ ${recentCommits}
   }
 }
 function buildMemoryInitRuntimePrompt(args) {
+  const depth = args.depth ?? "deep";
   return `
 The user ran /init for the current project.
 
@@ -103302,6 +103895,7 @@ Runtime context:
 - parent_agent_id: ${args.agentId}
 - working_directory: ${args.workingDirectory}
 - memory_dir: ${args.memoryDir}
+- research_depth: ${depth}
 
 Git/project context:
 ${args.gitContext}
@@ -103309,6 +103903,8 @@ ${args.gitContext}
 Task:
 Initialize or reorganize the parent agent's filesystem-backed memory for this project.
 
+${depth === "shallow" ? SHALLOW_INSTRUCTIONS : DEEP_INSTRUCTIONS}
+
 Instructions:
 - Use the pre-loaded initializing-memory skill as your operating guide
 - Inspect existing memory before editing
@@ -103318,6 +103914,29 @@ Instructions:
 - If the memory filesystem is unavailable or unsafe to modify, stop and explain why
 `.trim();
 }
+async function fireAutoInit(agentId, onComplete) {
+  if (hasActiveInitSubagent())
+    return false;
+  if (!settingsManager.isMemfsEnabled(agentId))
+    return false;
+  const gitContext = gatherGitContext();
+  const initPrompt = buildMemoryInitRuntimePrompt({
+    agentId,
+    workingDirectory: process.cwd(),
+    memoryDir: getMemoryFilesystemRoot(agentId),
+    gitContext,
+    depth: "shallow"
+  });
+  const { spawnBackgroundSubagentTask: spawnBackgroundSubagentTask2 } = await init_Task2().then(() => exports_Task);
+  spawnBackgroundSubagentTask2({
+    subagentType: "init",
+    prompt: initPrompt,
+    description: "Initializing memory",
+    silentCompletion: true,
+    onComplete
+  });
+  return true;
+}
 function buildLegacyInitMessage(args) {
   return `${SYSTEM_REMINDER_OPEN}
 The user has requested memory initialization via /init.
@@ -103338,9 +103957,27 @@ Once invoked, follow the instructions from the \`initializing-memory\` skill to
 ${args.gitContext}
 ${SYSTEM_REMINDER_CLOSE}`;
 }
-var init_initCommand = __esm(() => {
+var SHALLOW_INSTRUCTIONS, DEEP_INSTRUCTIONS;
+var init_initCommand = __esm(async () => {
+  init_memoryFilesystem();
   init_constants();
   init_subagentState();
+  await init_settings_manager();
+  SHALLOW_INSTRUCTIONS = `
+Shallow init — fast project basics only (~5 tool calls max):
+- Only read: CLAUDE.md, AGENTS.md, package.json/pyproject.toml/Cargo.toml, README.md (first 100 lines), top-level directory listing
+- Detect user identity from the git context provided above (already in the prompt — no extra calls)
+- Run one git call: git log --format="%an <%ae>" | sort -u | head -5
+- Write exactly 4 files: project/overview.md, project/commands.md, project/conventions.md, human/identity.md
+- Skip: deep directory exploration, architecture mapping, config analysis, historical sessions, persona files, reflection/checkpoint phase
+`.trim();
+  DEEP_INSTRUCTIONS = `
+Deep init — full exploration (follow the initializing-memory skill fully):
+- Read all existing memory files first — do NOT recreate what already exists
+- Then follow the full initializing-memory skill as your operating guide
+- Expand and deepen existing shallow files, add new ones to reach 15-25 target
+- If shallow init already ran, build on its output rather than starting over
+`.trim();
 });
 
 // src/cli/helpers/queuedMessageParts.ts
@@ -103528,9 +104165,11 @@ var init_statusLineSchema = __esm(() => {
     { path: "workspace.current_dir" },
     { path: "workspace.project_dir" },
     { path: "session_id" },
+    { path: "last_run_id" },
     { path: "version" },
     { path: "model.id" },
     { path: "model.display_name" },
+    { path: "agent.id" },
     { path: "agent.name" },
     { path: "cost.total_duration_ms" },
     { path: "cost.total_api_duration_ms" },
@@ -103624,6 +104263,7 @@ function buildStatusLinePayload(input) {
       project_dir: input.projectDirectory
     },
     ...input.sessionId ? { session_id: input.sessionId } : {},
+    last_run_id: input.lastRunId ?? null,
     transcript_path: null,
     version: getVersion(),
     reasoning_effort: input.reasoningEffort ?? null,
@@ -103654,6 +104294,7 @@ function buildStatusLinePayload(input) {
     exceeds_200k_tokens: usedContextTokens > 200000,
     vim: null,
     agent: {
+      id: input.agentId ?? null,
       name: input.agentName ?? null
     },
     permission_mode: input.permissionMode ?? null,
@@ -104032,7 +104673,9 @@ function toPayloadInput(inputs) {
     currentDirectory: inputs.currentDirectory,
     projectDirectory: inputs.projectDirectory,
     sessionId: inputs.sessionId,
+    agentId: inputs.agentId,
     agentName: inputs.agentName,
+    lastRunId: inputs.lastRunId,
     totalDurationMs: inputs.totalDurationMs,
     totalApiDurationMs: inputs.totalApiDurationMs,
     totalInputTokens: inputs.totalInputTokens,
@@ -104238,16 +104881,16 @@ __export(exports_shellAliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync24, readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir26 } from "node:os";
-import { join as join37 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir27 } from "node:os";
+import { join as join38 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync24(filePath)) {
+  if (!existsSync25(filePath)) {
     return aliases;
   }
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const lines = content.split(`
 `);
     let inFunction = false;
@@ -104309,10 +104952,10 @@ function loadAliases(forceReload = false) {
   if (aliasCache && !forceReload) {
     return aliasCache;
   }
-  const home = homedir26();
+  const home = homedir27();
   const allAliases = new Map;
   for (const file of ALIAS_FILES) {
-    const filePath = join37(home, file);
+    const filePath = join38(home, file);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -104802,10 +105445,11 @@ Listener disconnected from Letta Cloud.`, true);
     return;
   }
   if (msg.includes("--help") || msg.includes("-h")) {
-    addCommandResult4(ctx.buffersRef, ctx.refreshDerived, msg, `Usage: /remote [--env-name <name>]
-       /remote off
+    addCommandResult4(ctx.buffersRef, ctx.refreshDerived, msg, `Usage: /server [--env-name <name>]
+       /server off
 
 Register this letta-code instance to receive messages from Letta Cloud.
+Alias: /remote
 
 Options:
   --env-name <name>  Friendly name for this environment (uses hostname if not provided)
@@ -104813,9 +105457,9 @@ Options:
   -h, --help         Show this help message
 
 Examples:
-  /remote                         # Start listener with hostname
-  /remote --env-name "work-laptop" # Start with custom name
-  /remote off                     # Stop listening
+  /server                         # Start listener with hostname
+  /server --env-name "work-laptop" # Start with custom name
+  /server off                     # Stop listening
 
 Once connected, this instance will listen for incoming messages from cloud agents.
 Messages will be executed locally using your letta-code environment.`, true);
@@ -104837,11 +105481,10 @@ Messages will be executed locally using your letta-code environment.`, true);
   const buildConnectionUrl = (connId) => {
     if (!ctx.agentId)
       return "";
-    let url = `https://app.letta.com/agents/${ctx.agentId}?deviceId=${connId}`;
-    if (ctx.conversationId) {
-      url += `&conversationId=${ctx.conversationId}`;
-    }
-    return url;
+    return buildChatUrl(ctx.agentId, {
+      deviceId: connId,
+      conversationId: ctx.conversationId ?? undefined
+    });
   };
   ctx.setCommandRunning(true);
   const cmdId = addCommandResult4(ctx.buffersRef, ctx.refreshDerived, msg, "Connecting to Letta Cloud...", true, "running");
@@ -105142,9 +105785,9 @@ var exports_App = {};
 __export(exports_App, {
   default: () => App2
 });
-import { existsSync as existsSync25, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir27, tmpdir as tmpdir5 } from "node:os";
-import { join as join38, relative as relative11 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import { homedir as homedir28, tmpdir as tmpdir5 } from "node:os";
+import { join as join39, relative as relative11 } from "node:path";
 function deriveReasoningEffort(modelSettings, llmConfig) {
   if (modelSettings && "provider_type" in modelSettings) {
     if (modelSettings.provider_type === "openai" && "reasoning" in modelSettings && modelSettings.reasoning) {
@@ -105371,18 +106014,18 @@ ${SYSTEM_REMINDER_CLOSE}
 }
 function planFileExists() {
   const planFilePath = permissionMode.getPlanFilePath();
-  return !!planFilePath && existsSync25(planFilePath);
+  return !!planFilePath && existsSync26(planFilePath);
 }
 function _readPlanFile() {
   const planFilePath = permissionMode.getPlanFilePath();
   if (!planFilePath) {
     return "No plan file path set.";
   }
-  if (!existsSync25(planFilePath)) {
+  if (!existsSync26(planFilePath)) {
     return `Plan file not found at ${planFilePath}`;
   }
   try {
-    return readFileSync10(planFilePath, "utf-8");
+    return readFileSync11(planFilePath, "utf-8");
   } catch {
     return `Failed to read plan file at ${planFilePath}`;
   }
@@ -105519,8 +106162,11 @@ function App2({
   import_react99.useEffect(() => {
     conversationIdRef.current = conversationId;
   }, [conversationId]);
+  const lastRunIdRef = import_react99.useRef(null);
   const resumeKey = useSuspend();
   const pendingConversationSwitchRef = import_react99.useRef(null);
+  const autoInitPendingAgentIdsRef = import_react99.useRef(new Set);
+  const startupAutoInitConsumedRef = import_react99.useRef(false);
   const prevInitialAgentIdRef = import_react99.useRef(initialAgentId);
   const prevInitialAgentStateRef = import_react99.useRef(initialAgentState);
   const prevInitialConversationIdRef = import_react99.useRef(initialConversationId);
@@ -105857,6 +106503,15 @@ function App2({
   }, []);
   const [showExitStats, setShowExitStats] = import_react99.useState(false);
   const sharedReminderStateRef = import_react99.useRef(createSharedReminderState());
+  const initProgressByAgentRef = import_react99.useRef(new Map);
+  const updateInitProgress = (forAgentId, update) => {
+    const progress2 = initProgressByAgentRef.current.get(forAgentId) ?? {
+      shallowCompleted: false,
+      deepFired: false
+    };
+    Object.assign(progress2, update);
+    initProgressByAgentRef.current.set(forAgentId, progress2);
+  };
   const hasSetConversationSummaryRef = import_react99.useRef(resumedExistingConversation);
   const firstUserQueryRef = import_react99.useRef(null);
   const resetBootstrapReminderState = import_react99.useCallback(() => {
@@ -106342,7 +106997,9 @@ function App2({
     currentDirectory: process.cwd(),
     projectDirectory,
     sessionId: conversationId,
+    agentId,
     agentName,
+    lastRunId: lastRunIdRef.current,
     totalDurationMs: sessionStatsSnapshot.totalWallMs,
     totalApiDurationMs: sessionStatsSnapshot.totalApiMs,
     totalInputTokens: sessionStatsSnapshot.usage.promptTokens,
@@ -106494,7 +107151,8 @@ function App2({
     enqueueCommandIoReminder(sharedReminderStateRef.current, {
       input,
       output: event.output,
-      success: event.success
+      success: event.success,
+      agentHint: event.agentHint
     });
   }, []);
   const maybeRecordToolsetChangeReminder = import_react99.useCallback((params) => {
@@ -106637,10 +107295,10 @@ function App2({
     if (!planFilePath)
       return;
     try {
-      const { readFileSync: readFileSync11, existsSync: existsSync26 } = __require("node:fs");
-      if (!existsSync26(planFilePath))
+      const { readFileSync: readFileSync12, existsSync: existsSync27 } = __require("node:fs");
+      if (!existsSync27(planFilePath))
         return;
-      const planContent = readFileSync11(planFilePath, "utf-8");
+      const planContent = readFileSync12(planFilePath, "utf-8");
       const previewItem = {
         kind: "approval_preview",
         id: `approval-preview-${toolCallId}`,
@@ -106853,6 +107511,7 @@ function App2({
       }
       try {
         const client = await getClient2();
+        debugLog("conversations", `retrieve(${conversationId}) [syncConversationModel]`);
         const conversation = await client.conversations.retrieve(conversationId);
         if (cancelled)
           return;
@@ -106886,7 +107545,7 @@ function App2({
         if (cancelled)
           return;
         debugLog("conversation-model", "Failed to sync conversation model override: %O", error);
-        applyAgentModelLocally();
+        debugLog("conversation-model", "Keeping current model state after sync error (override in DB is authoritative)");
       }
     };
     syncConversationModel();
@@ -107018,9 +107677,9 @@ Memory may be stale. Try running: git -C ~/.letta/agents/${agentId}/memory pull`
     (async () => {
       try {
         const { watch } = await import("node:fs");
-        const { existsSync: existsSync26 } = await import("node:fs");
+        const { existsSync: existsSync27 } = await import("node:fs");
         const memRoot = getMemoryFilesystemRoot(agentId);
-        if (!existsSync26(memRoot))
+        if (!existsSync27(memRoot))
           return;
         watcher = watch(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher;
@@ -107264,7 +107923,7 @@ ${newState.originalPrompt}`
           }
           if (preStreamAction === "retry_conversation_busy") {
             conversationBusyRetriesRef.current += 1;
-            const retryDelayMs = CONVERSATION_BUSY_RETRY_BASE_DELAY_MS * 2 ** (conversationBusyRetriesRef.current - 1);
+            const retryDelayMs = CONVERSATION_BUSY_RETRY_BASE_DELAY_MS2 * 2 ** (conversationBusyRetriesRef.current - 1);
             telemetry.trackError("retry_conversation_busy", formatTelemetryErrorMessage(errorDetail || "Conversation is busy"), "pre_stream_retry", {
               httpStatus: preStreamError instanceof APIError2 ? preStreamError.status : undefined,
               modelId: currentModelId || undefined
@@ -107441,6 +108100,8 @@ ${newState.originalPrompt}`
           fallbackError
         } = await drainStreamWithResume(stream2, buffersRef.current, refreshDerivedThrottled, signal, handleFirstMessage, undefined, contextTrackerRef.current);
         currentRunId = lastRunId ?? undefined;
+        if (lastRunId)
+          lastRunIdRef.current = lastRunId;
         sessionStatsRef.current.endTurn(apiDurationMs);
         const usageDelta = sessionStatsRef.current.updateUsageFromBuffers(buffersRef.current);
         const tokenDelta = Math.max(0, buffersRef.current.tokenCount - runTokenStart);
@@ -108293,8 +108954,12 @@ ${feedback}
       toolResultsInFlightRef.current = false;
       refreshDerived();
       getClient2().then((client) => {
-        const cancelId = conversationIdRef.current === "default" ? agentIdRef.current : conversationIdRef.current;
-        return client.conversations.cancel(cancelId);
+        if (conversationIdRef.current === "default") {
+          return client.conversations.cancel("default", {
+            agent_id: agentIdRef.current
+          });
+        }
+        return client.conversations.cancel(conversationIdRef.current);
       }).catch(() => {});
       setTimeout(() => {
         userCancelledRef.current = false;
@@ -108362,8 +109027,12 @@ ${feedback}
       setAutoHandledResults([]);
       setAutoDeniedApprovals([]);
       getClient2().then((client) => {
-        const cancelId = conversationIdRef.current === "default" ? agentIdRef.current : conversationIdRef.current;
-        return client.conversations.cancel(cancelId);
+        if (conversationIdRef.current === "default") {
+          return client.conversations.cancel("default", {
+            agent_id: agentIdRef.current
+          });
+        }
+        return client.conversations.cancel(conversationIdRef.current);
       }).catch(() => {});
       setTimeout(() => {
         userCancelledRef.current = false;
@@ -108374,8 +109043,13 @@ ${feedback}
       setInterruptRequested(true);
       try {
         const client = await getClient2();
-        const cancelId = conversationIdRef.current === "default" ? agentIdRef.current : conversationIdRef.current;
-        await client.conversations.cancel(cancelId);
+        if (conversationIdRef.current === "default") {
+          await client.conversations.cancel("default", {
+            agent_id: agentIdRef.current
+          });
+        } else {
+          await client.conversations.cancel(conversationIdRef.current);
+        }
         if (abortControllerRef.current) {
           abortControllerRef.current.abort();
           abortControllerRef.current = null;
@@ -108543,6 +109217,9 @@ ${feedback}
       const { agent } = await createAgent(name);
       const { enableMemfsIfCloud: enableMemfsIfCloud2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
       await enableMemfsIfCloud2(agent.id);
+      if (settingsManager.isMemfsEnabled(agent.id)) {
+        autoInitPendingAgentIdsRef.current.add(agent.id);
+      }
       await updateProjectSettings({ lastAgent: agent.id });
       const targetConversationId = "default";
       settingsManager.setLocalLastSession({ agentId: agent.id, conversationId: targetConversationId }, process.cwd());
@@ -108550,11 +109227,12 @@ ${feedback}
         agentId: agent.id,
         conversationId: targetConversationId
       });
-      const agentUrl = `https://app.letta.com/projects/default-project/agents/${agent.id}`;
+      const agentUrl = buildChatUrl(agent.id);
+      const memfsTip = settingsManager.isMemfsEnabled(agent.id) ? "Memory will be auto-initialized on your first message." : "Tip: use /init to initialize your agent's memory system!";
       const successOutput = [
         `Created **${agent.name || agent.id}** (use /pin to save)`,
         `⎿  ${agentUrl}`,
-        `⎿  Tip: use /init to initialize your agent's memory system!`
+        `⎿  ${memfsTip}`
       ].join(`
 `);
       cmd.finish(successOutput, true);
@@ -108969,7 +109647,9 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
         return { submitted: true };
       }
       if (trimmed === "/ade") {
-        const adeUrl = conversationIdRef.current === "default" ? `https://app.letta.com/agents/${agentId}` : `https://app.letta.com/agents/${agentId}?conversation=${conversationIdRef.current}`;
+        const adeUrl = buildChatUrl(agentId, {
+          conversationId: conversationIdRef.current
+        });
         const cmd = commandRunner.start("/ade", "Opening ADE...");
         Promise.resolve().then(() => (init_open(), exports_open)).then(({ default: open2 }) => open2(adeUrl, { wait: false })).catch(() => {});
         cmd.finish(`Opening ADE...
@@ -109115,7 +109795,7 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
         }
         return { submitted: true };
       }
-      if (trimmed === "/remote" || trimmed.startsWith("/remote ")) {
+      if (trimmed === "/server" || trimmed.startsWith("/server ") || trimmed === "/remote" || trimmed.startsWith("/remote ")) {
         const parts = Array.from(trimmed.matchAll(/"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g), (match3) => match3[1] ?? match3[2] ?? match3[3]);
         let name;
         let _listenAgentId;
@@ -109241,7 +109921,9 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
                 currentDirectory: wd,
                 projectDirectory,
                 sessionId: conversationIdRef.current,
+                agentId,
                 agentName,
+                lastRunId: lastRunIdRef.current,
                 totalDurationMs: stats.totalWallMs,
                 totalApiDurationMs: stats.totalApiMs,
                 totalInputTokens: stats.usage.promptTokens,
@@ -109611,8 +110293,12 @@ Type your task to begin the loop.`, true);
               mode: modeArg
             }
           } : undefined;
-          const compactId = conversationIdRef.current === "default" ? agentId : conversationIdRef.current;
-          const result2 = await client.conversations.messages.compact(compactId, compactParams);
+          const compactConversationId = conversationIdRef.current;
+          const compactBody = compactConversationId === "default" ? {
+            agent_id: agentId,
+            ...compactParams ?? {}
+          } : compactParams;
+          const result2 = await client.conversations.messages.compact(compactConversationId, compactBody);
           const outputLines = [
             `Compaction completed${modeDisplay}. Message buffer length reduced from ${result2.num_messages_before} to ${result2.num_messages_after}.`,
             "",
@@ -109708,6 +110394,7 @@ Type your task to begin the loop.`, true);
           const client = await getClient2();
           await client.agents.update(agentId, { name: newValue });
           updateAgentName(newValue);
+          cmd.agentHint = `Your name is now "${newValue}" — acknowledge this and save your new name to memory.`;
           cmd.finish(`Agent renamed to "${newValue}"`, true);
         } catch (error) {
           const errorDetails = formatErrorDetails2(error, agentId);
@@ -110079,7 +110766,7 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
         try {
           const client = await getClient2();
           const exportParams = {};
-          if (conversationId !== "default") {
+          if (conversationId !== "default" && conversationId !== agentId) {
             exportParams.conversation_id = conversationId;
           }
           const { packageSkills: packageSkills2 } = await Promise.resolve().then(() => (init_export(), exports_export));
@@ -110201,11 +110888,11 @@ Path: ${result2.memoryDir}`, true, msg);
           setCommandRunning(true);
           try {
             const memoryDir = getMemoryFilesystemRoot(agentId);
-            if (!existsSync25(memoryDir)) {
+            if (!existsSync26(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join38(tmpdir5(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join39(tmpdir5(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync2(memoryDir, backupDir);
             ensureMemoryFilesystemDirs(agentId);
             updateMemorySyncCommand(cmdId, `Memory filesystem reset.
@@ -110233,8 +110920,8 @@ Run \`/memfs sync\` to repopulate from API.`, true, msg);
             await removeGitMemoryTag2(agentId);
             let backupInfo = "";
             const memoryDir = getMemoryFilesystemRoot(agentId);
-            if (existsSync25(memoryDir)) {
-              const backupDir = join38(tmpdir5(), `letta-memfs-disable-${agentId}-${Date.now()}`);
+            if (existsSync26(memoryDir)) {
+              const backupDir = join39(tmpdir5(), `letta-memfs-disable-${agentId}-${Date.now()}`);
               renameSync2(memoryDir, backupDir);
               backupInfo = `
 Local files backed up to ${backupDir}`;
@@ -110358,7 +111045,8 @@ ${SYSTEM_REMINDER_CLOSE}`;
               agentId,
               workingDirectory: process.cwd(),
               memoryDir: getMemoryFilesystemRoot(agentId),
-              gitContext
+              gitContext,
+              depth: "deep"
             });
             const { spawnBackgroundSubagentTask: spawnBackgroundSubagentTask2 } = await init_Task2().then(() => exports_Task);
             spawnBackgroundSubagentTask2({
@@ -110367,10 +111055,14 @@ ${SYSTEM_REMINDER_CLOSE}`;
               description: "Initializing memory",
               silentCompletion: true,
               onComplete: ({ success, error }) => {
-                const msg2 = success ? "Built a memory palace of you. Visit it with /palace." : `Memory initialization failed: ${error}`;
+                if (success) {
+                  updateInitProgress(agentId, { deepFired: true });
+                }
+                const msg2 = success ? "Built a memory palace of you. Visit it with /palace." : `Memory initialization failed: ${error || "Unknown error"}`;
                 appendTaskNotificationEvents([msg2]);
               }
             });
+            autoInitPendingAgentIdsRef.current.delete(agentId);
             cmd.finish("Learning about you and your codebase in the background. You'll be notified when ready.", true);
             const reminders = sharedReminderStateRef.current.pendingCommandIoReminders;
             const idx = reminders.findIndex((r) => r.input === "/init");
@@ -110382,6 +111074,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
             cmd.fail(`Failed to start memory initialization: ${errorDetails}`);
           }
         } else {
+          autoInitPendingAgentIdsRef.current.delete(agentId);
           setCommandRunning(true);
           try {
             cmd.finish("Assimilating project context and defragmenting memories...", true);
@@ -110461,6 +111154,21 @@ ${SYSTEM_REMINDER_CLOSE}`)
         return { submitted: true };
       }
     }
+    if (autoInitPendingAgentIdsRef.current.has(agentId) && !isSystemOnly) {
+      try {
+        const fired = await fireAutoInit(agentId, ({ success, error }) => {
+          if (success) {
+            updateInitProgress(agentId, { shallowCompleted: true });
+          }
+          const msg2 = success ? "Built a memory palace of you. Visit it with /palace." : `Memory initialization failed: ${error || "Unknown error"}`;
+          appendTaskNotificationEvents([msg2]);
+        });
+        if (fired) {
+          autoInitPendingAgentIdsRef.current.delete(agentId);
+          sharedReminderStateRef.current.pendingAutoInitReminder = true;
+        }
+      } catch {}
+    }
     const contentParts = overrideContentParts ?? buildMessageContentFromDisplay(msg);
     let ralphModeReminder = "";
     if (ralphMode.getState().isActive) {
@@ -110558,7 +111266,45 @@ ${SYSTEM_REMINDER_CLOSE}
         return false;
       }
     };
+    const maybeLaunchDeepInitSubagent = async () => {
+      if (!memfsEnabledForAgent)
+        return false;
+      if (hasActiveInitSubagent())
+        return false;
+      try {
+        const gitContext = gatherGitContext();
+        const initPrompt = buildMemoryInitRuntimePrompt({
+          agentId,
+          workingDirectory: process.cwd(),
+          memoryDir: getMemoryFilesystemRoot(agentId),
+          gitContext,
+          depth: "deep"
+        });
+        const { spawnBackgroundSubagentTask: spawnBackgroundSubagentTask2 } = await init_Task2().then(() => exports_Task);
+        spawnBackgroundSubagentTask2({
+          subagentType: "init",
+          prompt: initPrompt,
+          description: "Deep memory initialization",
+          silentCompletion: true,
+          onComplete: ({ success, error }) => {
+            if (success) {
+              updateInitProgress(agentId, { deepFired: true });
+            }
+            const msg2 = success ? "Built a memory palace of you. Visit it with /palace." : `Deep memory initialization failed: ${error || "Unknown error"}`;
+            appendTaskNotificationEvents([msg2]);
+          }
+        });
+        debugLog("memory", "Auto-launched deep init subagent");
+        return true;
+      } catch (error) {
+        debugWarn("memory", `Failed to auto-launch deep init subagent: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+      }
+    };
     syncReminderStateFromContextTracker(sharedReminderStateRef.current, contextTrackerRef.current);
+    const initProgress = initProgressByAgentRef.current.get(agentId);
+    sharedReminderStateRef.current.shallowInitCompleted = initProgress?.shallowCompleted ?? false;
+    sharedReminderStateRef.current.deepInitFired = initProgress?.deepFired ?? false;
     const { getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
     const { parts: sharedReminderParts } = await buildSharedReminderParts({
       mode: "interactive",
@@ -110573,7 +111319,8 @@ ${SYSTEM_REMINDER_CLOSE}
       reflectionSettings,
       skillSources: getSkillSources2(),
       resolvePlanModeReminder: getPlanModeReminder,
-      maybeLaunchReflectionSubagent
+      maybeLaunchReflectionSubagent,
+      maybeLaunchDeepInitSubagent
     });
     for (const part of sharedReminderParts) {
       reminderParts.push(part);
@@ -112307,7 +113054,7 @@ ${guidance}`);
       }
       if (!planFileExists()) {
         const planFilePath = permissionMode.getPlanFilePath();
-        const plansDir = join38(homedir27(), ".letta", "plans");
+        const plansDir = join39(homedir28(), ".letta", "plans");
         handlePlanKeepPlanning(`You must write your plan to a plan file before exiting plan mode.
 ` + (planFilePath ? `Plan file path: ${planFilePath}
 ` : "") + `Use a write tool to create your plan in ${plansDir}, then use ExitPlanMode to present the plan to the user.`);
@@ -112512,6 +113259,14 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
       return estimatedLiveHeight < resumeThreshold;
     });
   }, [estimatedLiveHeight, terminalRows]);
+  import_react99.useEffect(() => {
+    if (loadingState === "ready" && agentProvenance?.isNew && agentId && !startupAutoInitConsumedRef.current) {
+      startupAutoInitConsumedRef.current = true;
+      if (settingsManager.isMemfsEnabled(agentId)) {
+        autoInitPendingAgentIdsRef.current.add(agentId);
+      }
+    }
+  }, [loadingState, agentProvenance, agentId]);
   import_react99.useEffect(() => {
     if (loadingState === "ready" && !welcomeCommittedRef.current && messageHistory.length === 0) {
       if (!continueSession && !agentProvenance) {
@@ -112822,7 +113577,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                       color: colors.link.url,
                       children: agentName && (settingsManager.getLocalPinnedAgents().includes(agentId) || settingsManager.getGlobalPinnedAgents().includes(agentId)) ? `letta -n "${agentName}"` : `letta --agent ${agentId}`
                     }, undefined, false, undefined, this),
-                    conversationId !== "default" && /* @__PURE__ */ jsx_dev_runtime76.jsxDEV(jsx_dev_runtime76.Fragment, {
+                    conversationId !== "default" && conversationId !== agentId && /* @__PURE__ */ jsx_dev_runtime76.jsxDEV(jsx_dev_runtime76.Fragment, {
                       children: [
                         /* @__PURE__ */ jsx_dev_runtime76.jsxDEV(Box_default, {
                           height: 1
@@ -113446,6 +114201,9 @@ Open /mcp to attach or detach tools for this server.`, true);
                     } else {
                       settingsManager.pinGlobal(agentId);
                     }
+                    if (newName && newName !== agentName) {
+                      cmd.agentHint = `Your name is now "${newName}" — acknowledge this and save your new name to memory.`;
+                    }
                     cmd.finish(`Pinned "${newName || agentName || agentId.slice(0, 12)}" ${scopeText}.`, true);
                   } catch (error) {
                     cmd.fail(`Failed to pin: ${error}`);
@@ -113463,7 +114221,7 @@ Open /mcp to attach or detach tools for this server.`, true);
     ]
   }, resumeKey, true, undefined, this);
 }
-var import_react99, jsx_dev_runtime76, CLEAR_SCREEN_AND_HOME = "\x1B[2J\x1B[H", MIN_RESIZE_DELTA = 2, RESIZE_SETTLE_MS = 250, MIN_CLEAR_INTERVAL_MS = 750, STABLE_WIDTH_SETTLE_MS = 180, TOOL_CALL_COMMIT_DEFER_MS = 50, ANIMATION_RESUME_HYSTERESIS_ROWS = 2, EAGER_CANCEL = true, LLM_API_ERROR_MAX_RETRIES3 = 3, EMPTY_RESPONSE_MAX_RETRIES2 = 2, CONVERSATION_BUSY_MAX_RETRIES2 = 3, CONVERSATION_BUSY_RETRY_BASE_DELAY_MS = 2500, INTERRUPT_MESSAGE = "Interrupted – tell the agent what to do differently. Something went wrong? Use /feedback to report issues.", ERROR_FEEDBACK_HINT = "Something went wrong? Use /feedback to report issues.", OPUS_BEDROCK_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to Bedrock Opus 4.5", PROVIDER_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to another provider", INTERACTIVE_SLASH_COMMANDS, NON_STATE_COMMANDS, APPROVAL_OPTIONS_HEIGHT = 8, APPROVAL_PREVIEW_BUFFER = 4, MIN_WRAP_WIDTH = 10, TEXT_WRAP_GUTTER = 6, DIFF_WRAP_GUTTER = 12, AUTO_REFLECTION_DESCRIPTION = "Reflect on recent conversations", AUTO_REFLECTION_PROMPT = "Review recent conversation history and update memory files with important information worth preserving.";
+var import_react99, jsx_dev_runtime76, CLEAR_SCREEN_AND_HOME = "\x1B[2J\x1B[H", MIN_RESIZE_DELTA = 2, RESIZE_SETTLE_MS = 250, MIN_CLEAR_INTERVAL_MS = 750, STABLE_WIDTH_SETTLE_MS = 180, TOOL_CALL_COMMIT_DEFER_MS = 50, ANIMATION_RESUME_HYSTERESIS_ROWS = 2, EAGER_CANCEL = true, LLM_API_ERROR_MAX_RETRIES3 = 3, EMPTY_RESPONSE_MAX_RETRIES2 = 2, CONVERSATION_BUSY_MAX_RETRIES2 = 3, CONVERSATION_BUSY_RETRY_BASE_DELAY_MS2 = 1e4, INTERRUPT_MESSAGE = "Interrupted – tell the agent what to do differently. Something went wrong? Use /feedback to report issues.", ERROR_FEEDBACK_HINT = "Something went wrong? Use /feedback to report issues.", OPUS_BEDROCK_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to Bedrock Opus 4.5", PROVIDER_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to another provider", INTERACTIVE_SLASH_COMMANDS, NON_STATE_COMMANDS, APPROVAL_OPTIONS_HEIGHT = 8, APPROVAL_PREVIEW_BUFFER = 4, MIN_WRAP_WIDTH = 10, TEXT_WRAP_GUTTER = 6, DIFF_WRAP_GUTTER = 12, AUTO_REFLECTION_DESCRIPTION = "Reflect on recent conversations", AUTO_REFLECTION_PROMPT = "Review recent conversation history and update memory files with important information worth preserving.";
 var init_App2 = __esm(async () => {
   init_error();
   init_check_approval();
@@ -113489,7 +114247,6 @@ var init_App2 = __esm(async () => {
   init_diff2();
   init_errorContext();
   init_errorFormatter();
-  init_initCommand();
   init_messageQueueBridge();
   init_pasteRegistry();
   init_planName();
@@ -113563,6 +114320,7 @@ var init_App2 = __esm(async () => {
     init_accumulator(),
     init_approvalClassification(),
     init_formatArgsDisplay(),
+    init_initCommand(),
     init_memoryReminder(),
     init_statusLineConfig(),
     init_stream(),
@@ -113628,13 +114386,13 @@ __export(exports_terminalKeybindingInstaller2, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync17,
-  readFileSync as readFileSync11,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync18,
+  readFileSync as readFileSync12,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { homedir as homedir28, platform as platform5 } from "node:os";
-import { dirname as dirname14, join as join39 } from "node:path";
+import { homedir as homedir29, platform as platform5 } from "node:os";
+import { dirname as dirname14, join as join40 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -113666,16 +114424,16 @@ function getKeybindingsPath2(terminal) {
   }[terminal];
   const os7 = platform5();
   if (os7 === "darwin") {
-    return join39(homedir28(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join40(homedir29(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os7 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join39(appData, appName, "User", "keybindings.json");
+    return join40(appData, appName, "User", "keybindings.json");
   }
   if (os7 === "linux") {
-    return join39(homedir28(), ".config", appName, "User", "keybindings.json");
+    return join40(homedir29(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -113697,10 +114455,10 @@ function parseKeybindings2(content) {
   }
 }
 function keybindingExists2(keybindingsPath) {
-  if (!existsSync26(keybindingsPath))
+  if (!existsSync27(keybindingsPath))
     return false;
   try {
-    const content = readFileSync11(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync12(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings2(content);
     if (!keybindings)
       return false;
@@ -113710,7 +114468,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync26(keybindingsPath))
+  if (!existsSync27(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -113726,14 +114484,14 @@ function installKeybinding2(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname14(keybindingsPath);
-    if (!existsSync26(parentDir)) {
-      mkdirSync17(parentDir, { recursive: true });
+    if (!existsSync27(parentDir)) {
+      mkdirSync18(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync26(keybindingsPath)) {
+    if (existsSync27(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
-      const content = readFileSync11(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync12(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
       if (parsed === null) {
         return {
@@ -113761,10 +114519,10 @@ function installKeybinding2(keybindingsPath) {
 }
 function removeKeybinding2(keybindingsPath) {
   try {
-    if (!existsSync26(keybindingsPath)) {
+    if (!existsSync27(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync11(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync12(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings2(content);
     if (!keybindings) {
       return {
@@ -113828,20 +114586,20 @@ function getWezTermConfigPath2() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join39(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync26(xdgPath))
+    const xdgPath = join40(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync27(xdgPath))
       return xdgPath;
   }
-  const configPath = join39(homedir28(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync26(configPath))
+  const configPath = join40(homedir29(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync27(configPath))
     return configPath;
-  return join39(homedir28(), ".wezterm.lua");
+  return join40(homedir29(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists2(configPath) {
-  if (!existsSync26(configPath))
+  if (!existsSync27(configPath))
     return false;
   try {
-    const content = readFileSync11(configPath, { encoding: "utf-8" });
+    const content = readFileSync12(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -113855,10 +114613,10 @@ function installWezTermDeleteFix2() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync26(configPath)) {
+    if (existsSync27(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync2(configPath, backupPath);
-      content = readFileSync11(configPath, { encoding: "utf-8" });
+      content = readFileSync12(configPath, { encoding: "utf-8" });
     }
     if (content.includes("return {") && !content.includes("local config")) {
       content = content.replace(/return\s*\{/, "local config = {");
@@ -113885,8 +114643,8 @@ ${WEZTERM_DELETE_FIX2}
 `;
     }
     const parentDir = dirname14(configPath);
-    if (!existsSync26(parentDir)) {
-      mkdirSync17(parentDir, { recursive: true });
+    if (!existsSync27(parentDir)) {
+      mkdirSync18(parentDir, { recursive: true });
     }
     writeFileSync13(configPath, content, { encoding: "utf-8" });
     return {
@@ -113933,10 +114691,10 @@ __export(exports_settings2, {
   loadProjectSettings: () => loadProjectSettings2,
   getSetting: () => getSetting2
 });
-import { homedir as homedir29 } from "node:os";
-import { join as join40 } from "node:path";
+import { homedir as homedir30 } from "node:os";
+import { join as join41 } from "node:path";
 function getSettingsPath2() {
-  return join40(homedir29(), ".letta", "settings.json");
+  return join41(homedir30(), ".letta", "settings.json");
 }
 async function loadSettings2() {
   const settingsPath = getSettingsPath2();
@@ -113973,7 +114731,7 @@ async function getSetting2(key) {
   return settings[key];
 }
 function getProjectSettingsPath2() {
-  return join40(process.cwd(), ".letta", "settings.local.json");
+  return join41(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings2() {
   const settingsPath = getProjectSettingsPath2();
@@ -113991,7 +114749,7 @@ async function loadProjectSettings2() {
 }
 async function saveProjectSettings2(settings) {
   const settingsPath = getProjectSettingsPath2();
-  const dirPath = join40(process.cwd(), ".letta");
+  const dirPath = join41(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -114530,7 +115288,7 @@ function parseRegistryHandle2(handle) {
 }
 async function importAgentFromRegistry2(options) {
   const { tmpdir: tmpdir6 } = await import("node:os");
-  const { join: join41 } = await import("node:path");
+  const { join: join42 } = await import("node:path");
   const { writeFile: writeFile5, unlink } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle2(options.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER2}/${AGENT_REGISTRY_REPO2}/refs/heads/${AGENT_REGISTRY_BRANCH2}/agents/@${author}/${name}/${name}.af`;
@@ -114542,7 +115300,7 @@ async function importAgentFromRegistry2(options) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join41(tmpdir6(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join42(tmpdir6(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile5(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile2({
@@ -114582,23 +115340,23 @@ __export(exports_memoryFilesystem2, {
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR2,
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR2
 });
-import { existsSync as existsSync27, mkdirSync as mkdirSync18 } from "node:fs";
-import { homedir as homedir30 } from "node:os";
-import { join as join41 } from "node:path";
-function getMemoryFilesystemRoot2(agentId, homeDir = homedir30()) {
-  return join41(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
+import { existsSync as existsSync28, mkdirSync as mkdirSync19 } from "node:fs";
+import { homedir as homedir31 } from "node:os";
+import { join as join42 } from "node:path";
+function getMemoryFilesystemRoot2(agentId, homeDir = homedir31()) {
+  return join42(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
 }
-function getMemorySystemDir2(agentId, homeDir = homedir30()) {
-  return join41(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
+function getMemorySystemDir2(agentId, homeDir = homedir31()) {
+  return join42(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
 }
-function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir30()) {
+function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir31()) {
   const root = getMemoryFilesystemRoot2(agentId, homeDir);
   const systemDir = getMemorySystemDir2(agentId, homeDir);
-  if (!existsSync27(root)) {
-    mkdirSync18(root, { recursive: true });
+  if (!existsSync28(root)) {
+    mkdirSync19(root, { recursive: true });
   }
-  if (!existsSync27(systemDir)) {
-    mkdirSync18(systemDir, { recursive: true });
+  if (!existsSync28(systemDir)) {
+    mkdirSync19(systemDir, { recursive: true });
   }
 }
 function labelFromRelativePath2(relativePath) {
@@ -114975,9 +115733,6 @@ async function getResumeData(client, agent, conversationId, options = {}) {
     let inContextMessageIds;
     let messages = [];
     const useConversationsApi = conversationId && conversationId !== "default";
-    if (process.env.DEBUG) {
-      console.log(`[DEBUG] getResumeData: conversationId=${conversationId}, useConversationsApi=${useConversationsApi}, agentId=${agent.id}`);
-    }
     if (useConversationsApi) {
       const conversation = await client.conversations.retrieve(conversationId);
       inContextMessageIds = conversation.in_context_message_ids;
@@ -115053,13 +115808,14 @@ async function getResumeData(client, agent, conversationId, options = {}) {
       const retrievedMessages = await client.messages.retrieve(lastInContextId);
       if (includeMessageHistory && isBackfillEnabled()) {
         try {
-          const messagesPage = await client.conversations.messages.list(agent.id, {
+          const messagesPage = await client.conversations.messages.list("default", {
+            agent_id: agent.id,
             limit: BACKFILL_PAGE_LIMIT,
             order: "desc"
           });
           messages = sortChronological(messagesPage.getPaginatedItems());
           if (process.env.DEBUG) {
-            console.log(`[DEBUG] conversations.messages.list(${agent.id}) returned ${messages.length} messages`);
+            console.log(`[DEBUG] conversations.messages.list(default, agent_id=${agent.id}) returned ${messages.length} messages`);
           }
         } catch (backfillError) {
           debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
@@ -115742,7 +116498,8 @@ function ConversationSelector({
       let defaultConversation = null;
       if (!afterCursor) {
         try {
-          const defaultMessages = await client.conversations.messages.list(agentId, {
+          const defaultMessages = await client.conversations.messages.list("default", {
+            agent_id: agentId,
             limit: 20,
             order: "desc"
           });
@@ -116152,8 +116909,8 @@ function parseJsonArrayFlag(rawValue, flagName) {
 init_error();
 init_errorContext();
 init_zaiErrors();
-var LETTA_USAGE_URL = "https://app.letta.com/settings/organization/usage";
-var LETTA_AGENTS_URL = "https://app.letta.com/projects/default-project/agents";
+var LETTA_USAGE_URL = buildAppUrl("/settings/organization/usage");
+var LETTA_AGENTS_URL = buildAppUrl("/projects/default-project/agents");
 function extractReasonList(value) {
   if (!Array.isArray(value))
     return [];
@@ -116585,7 +117342,7 @@ ${createAgentLink(runId, agentId, conversationId)}` : baseError;
   return String(e);
 }
 function createAgentLink(runId, agentId, conversationId) {
-  const url = `https://app.letta.com/agents/${agentId}${conversationId && conversationId !== "default" ? `?conversation=${conversationId}` : ""}`;
+  const url = buildChatUrl(agentId, { conversationId });
   return `View agent: \x1B]8;;${url}\x1B\\${agentId}\x1B]8;;\x1B\\ (run: ${runId})`;
 }
 
@@ -117792,7 +118549,7 @@ async function runListenSubcommand(argv) {
   });
   const debugMode = !!values.debug;
   if (values.help) {
-    console.log(`Usage: letta remote [--env-name <name>] [--debug]
+    console.log(`Usage: letta server [--env-name <name>] [--debug]
 `);
     console.log(`Register this letta-code instance to receive messages from Letta Cloud.
 `);
@@ -117802,9 +118559,9 @@ async function runListenSubcommand(argv) {
     console.log(`  -h, --help         Show this help message
 `);
     console.log("Examples:");
-    console.log("  letta remote                      # Uses hostname as default");
-    console.log('  letta remote --env-name "work-laptop"');
-    console.log(`  letta remote --debug              # Log all WS events
+    console.log("  letta server                      # Uses hostname as default");
+    console.log('  letta server --env-name "work-laptop"');
+    console.log(`  letta server --debug              # Log all WS events
 `);
     console.log("Once connected, this instance will listen for incoming messages from cloud agents.");
     console.log("Messages will be executed locally using your letta-code environment.");
@@ -118389,7 +119146,8 @@ async function runMessagesSubcommand(argv) {
         console.error(`Invalid --order "${orderRaw}". Use "asc" or "desc".`);
         return 1;
       }
-      const response = await client.conversations.messages.list(agentId, {
+      const response = await client.conversations.messages.list("default", {
+        agent_id: agentId,
         limit: parseLimit3(parsed.values.limit, 20),
         after: parsed.values.after,
         before: parsed.values.before,
@@ -118441,6 +119199,7 @@ async function runSubcommand(argv) {
       return runMessagesSubcommand(rest);
     case "blocks":
       return runBlocksSubcommand(rest);
+    case "server":
     case "remote":
       return runListenSubcommand(rest);
     case "connect":
@@ -120032,7 +120791,7 @@ function replaceRegistry2(newTools) {
     toolRegistry2.set(key, value);
   }
 }
-async function loadTools2(modelIdentifier) {
+async function loadTools2(modelIdentifier, options) {
   acquireSwitchLock2();
   try {
     const { toolFilter: toolFilter2 } = await Promise.resolve().then(() => (init_filter(), exports_filter));
@@ -120053,6 +120812,10 @@ async function loadTools2(modelIdentifier) {
     } else {
       baseToolNames = TOOL_NAMES2;
     }
+    if (options?.exclude && options.exclude.length > 0) {
+      const excludeSet = new Set(options.exclude);
+      baseToolNames = baseToolNames.filter((name) => !excludeSet.has(name));
+    }
     const newRegistry = new Map;
     for (const name of baseToolNames) {
       if (!toolFilter2.isEnabled(name)) {
@@ -120145,6 +120908,119 @@ ${agentsSection}
 ${after}`;
 }
 
+// src/utils/debug.ts
+import {
+  appendFileSync as appendFileSync3,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync10,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync4,
+  unlinkSync as unlinkSync6
+} from "node:fs";
+import { homedir as homedir18 } from "node:os";
+import { join as join21 } from "node:path";
+import { format as format2 } from "node:util";
+function isDebugEnabled2() {
+  const debug = process.env.LETTA_DEBUG;
+  return debug === "1" || debug === "true";
+}
+function getDebugFile2() {
+  const path20 = process.env.LETTA_DEBUG_FILE;
+  return path20 && path20.trim().length > 0 ? path20 : null;
+}
+function printDebugLine2(line) {
+  const debugFile = getDebugFile2();
+  if (debugFile) {
+    try {
+      appendFileSync3(debugFile, line, { encoding: "utf8" });
+      return;
+    } catch {}
+  }
+  console.log(line.trimEnd());
+}
+var DEBUG_LOG_DIR2 = join21(homedir18(), ".letta", "logs", "debug");
+var MAX_SESSION_FILES3 = 5;
+var DEFAULT_TAIL_LINES2 = 50;
+
+class DebugLogFile2 {
+  logPath = null;
+  agentDir = null;
+  dirCreated = false;
+  init(agentId, sessionId) {
+    const telem = process.env.LETTA_CODE_TELEM;
+    if (telem === "0" || telem === "false")
+      return;
+    this.agentDir = join21(DEBUG_LOG_DIR2, agentId);
+    this.logPath = join21(this.agentDir, `${sessionId}.log`);
+    this.dirCreated = false;
+    this.pruneOldSessions();
+  }
+  appendLine(line) {
+    if (!this.logPath)
+      return;
+    this.ensureDir();
+    try {
+      appendFileSync3(this.logPath, line, { encoding: "utf8" });
+    } catch {}
+  }
+  getTail(maxLines = DEFAULT_TAIL_LINES2) {
+    if (!this.logPath)
+      return;
+    try {
+      if (!existsSync12(this.logPath))
+        return;
+      const content = readFileSync4(this.logPath, "utf8");
+      const lines = content.trimEnd().split(`
+`);
+      return lines.slice(-maxLines).join(`
+`);
+    } catch {
+      return;
+    }
+  }
+  ensureDir() {
+    if (this.dirCreated || !this.agentDir)
+      return;
+    try {
+      if (!existsSync12(this.agentDir)) {
+        mkdirSync10(this.agentDir, { recursive: true });
+      }
+      this.dirCreated = true;
+    } catch {}
+  }
+  pruneOldSessions() {
+    if (!this.agentDir)
+      return;
+    try {
+      if (!existsSync12(this.agentDir))
+        return;
+      const files = readdirSync7(this.agentDir).filter((f) => f.endsWith(".log")).sort();
+      if (files.length >= MAX_SESSION_FILES3) {
+        const toDelete = files.slice(0, files.length - MAX_SESSION_FILES3 + 1);
+        for (const file of toDelete) {
+          try {
+            unlinkSync6(join21(this.agentDir, file));
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+}
+var debugLogFile2 = new DebugLogFile2;
+function writeDebugLine2(prefix, message, args) {
+  const ts = new Date().toISOString();
+  const body = format2(`[${prefix}] ${message}`, ...args);
+  const line = `${ts} ${body}
+`;
+  debugLogFile2.appendLine(line);
+  if (isDebugEnabled2()) {
+    printDebugLine2(line);
+  }
+}
+function debugLog2(prefix, message, ...args) {
+  writeDebugLine2(prefix, message, args);
+}
+
 // src/utils/timing.ts
 function isTimingsEnabled2() {
   const val = process.env.LETTA_DEBUG_TIMINGS;
@@ -120251,12 +121127,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join42 } = await import("path");
+  const { join: join43 } = await import("path");
   const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_version2(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills2(), exports_skills2));
   const { exists: exists3 } = await Promise.resolve().then(() => (init_fs2(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join42(cwd2, SKILLS_DIR3);
+  const skillsDir = join43(cwd2, SKILLS_DIR3);
   const skillsExist = exists3(skillsDir);
   await settingsManager2.loadLocalProjectSettings(cwd2);
   const localPinned = settingsManager2.getLocalPinnedAgents(cwd2);
@@ -120650,9 +121526,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     } else {
       const { resolve: resolve30 } = await import("path");
-      const { existsSync: existsSync28 } = await import("fs");
+      const { existsSync: existsSync29 } = await import("fs");
       const resolvedPath = resolve30(fromAfFile);
-      if (!existsSync28(resolvedPath)) {
+      if (!existsSync29(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
       }
@@ -120772,7 +121648,7 @@ Error: ${message}`);
   if (isHeadless) {
     markMilestone2("HEADLESS_MODE_START");
     const modelForTools = getModelForToolLoading(specifiedModel, specifiedToolset);
-    await loadTools2(modelForTools);
+    await loadTools2(modelForTools, { exclude: ["AskUserQuestion"] });
     markMilestone2("TOOLS_LOADED");
     const headlessValues = specifiedAgentId && values.agent !== specifiedAgentId ? { ...values, agent: specifiedAgentId } : values;
     const { handleHeadlessCommand: handleHeadlessCommand2 } = await init_headless().then(() => exports_headless);
@@ -120930,6 +121806,7 @@ Error: ${message}`);
             return;
           }
           try {
+            debugLog2("conversations", `retrieve(${specifiedConversationId}) [TUI conv\u2192agent lookup]`);
             const conversation = await client.conversations.retrieve(specifiedConversationId);
             setSelectedGlobalAgentId(conversation.agent_id);
             setSelectedConversationId(specifiedConversationId);
@@ -121531,4 +122408,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=9B975B5682ECA31464756E2164756E21
+//# debugId=FE66CA162A20D40F64756E2164756E21