@letta-ai/letta-code 0.13.1 → 0.13.3

package/letta.js

@@ -3065,7 +3065,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.13.1",
+    version: "0.13.3",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -5916,32 +5916,30 @@ var init_plan = () => {};
 var recall_default = `---
 name: recall
 description: Search conversation history to recall past discussions, decisions, and context
-tools: Skill, Bash, Read, BashOutput
-model: haiku
-memoryBlocks: human, persona, skills, loaded_skills
+tools: Bash, Read, BashOutput
+model: opus
+memoryBlocks: skills, loaded_skills
+skills: searching-messages
 mode: stateless
 ---
 
 You are a subagent launched via the Task tool to search conversation history. You run autonomously and return a single final report when done. You CANNOT ask questions mid-execution.
 
-## Instructions
-
-### Step 1: Load the searching-messages skill
-\`\`\`
-Skill({ command: "load", skills: ["searching-messages"] })
-\`\`\`
+## CRITICAL WARNINGS
 
-After loading, your \`loaded_skills\` memory block contains the full instructions with ready-to-use bash commands. Follow them directly - do not search for files or guess at commands.
+1. **NEVER use \`conversation_search\`** - It only searches YOUR empty history, not the parent's.
+2. **NEVER invent commands** - There is NO \`letta messages search\` or \`letta messages list\`. These don't exist.
 
-### Step 2: Search the parent agent's history
-
-**CRITICAL - Two rules:**
+## Instructions
 
-1. **DO NOT use \`conversation_search\`** - That tool only searches YOUR history (empty). You MUST use the Bash scripts from the skill.
+The \`searching-messages\` skill is pre-loaded in your \`<loaded_skills>\` memory block below. Read it carefully - it contains:
+- \`# Skill Directory:\` - the exact path to use in commands
+- Multiple search strategies (needle + expand, date-bounded, broad discovery)
+- Command options and examples
 
-2. **ALWAYS add \`--agent-id $LETTA_PARENT_AGENT_ID\`** - This searches the parent agent's history. The only exception is \`--all-agents\` searches.
+**Follow the skill's strategies thoroughly.** Use multiple searches if needed to gather comprehensive context. Always add \`--agent-id $LETTA_PARENT_AGENT_ID\` to search the parent agent's history.
 
-Follow the strategies documented in the loaded skill.
+After gathering results, compile a comprehensive report.
 
 ## Output Format
 
@@ -8621,6 +8619,8 @@ Launch a subagent to perform a task. Parameters:
 - **prompt**: Detailed, self-contained instructions for the agent (agents cannot ask questions mid-execution)
 - **description**: Short 3-5 word summary for tracking
 - **model** (optional): Override the model for this agent
+- **agent_id** (optional): Deploy an existing agent instead of creating a new one
+- **conversation_id** (optional): Resume from an existing conversation
 
 ### Refresh
 Re-scan the \`.letta/agents/\` directories to discover new or updated custom subagents:
@@ -8652,6 +8652,57 @@ Use this after creating or modifying custom subagent definitions.
 - **Parallel execution**: Launch multiple agents concurrently by calling Task multiple times in a single response
 - **Specify return format**: Tell agents exactly what information to include in their report
 
+## Deploying an Existing Agent
+
+Instead of spawning a fresh subagent from a template, you can deploy an existing agent to work in your local codebase.
+
+### Access Levels (subagent_type)
+Use subagent_type to control what tools the deployed agent can access:
+- **explore**: Read-only access (Read, Glob, Grep) - safer for exploration tasks
+- **general-purpose**: Full read-write access (Bash, Edit, Write, etc.) - for implementation tasks
+
+If subagent_type is not specified when deploying an existing agent, it defaults to "general-purpose".
+
+### Parameters
+
+- **agent_id**: The ID of an existing agent to deploy (e.g., "agent-abc123")
+  - Starts a new conversation with that agent
+  - The agent keeps its own system prompt and memory
+  - Tool access is controlled by subagent_type
+
+- **conversation_id**: Resume from an existing conversation (e.g., "conv-xyz789")
+  - Does NOT require agent_id (conversation IDs are unique and encode the agent)
+  - Continues from the conversation's existing message history
+  - Use this to continue context from:
+    - A prior Task tool invocation that returned a conversation_id
+    - A message thread started via the messaging-agents skill
+
+### Examples
+
+\`\`\`typescript
+// Deploy agent with read-only access
+Task({
+  agent_id: "agent-abc123",
+  subagent_type: "explore",
+  description: "Find auth code",
+  prompt: "Find all auth-related code in this codebase"
+})
+
+// Deploy agent with full access (default)
+Task({
+  agent_id: "agent-abc123",
+  description: "Fix auth bug",
+  prompt: "Fix the bug in auth.ts"
+})
+
+// Continue an existing conversation
+Task({
+  conversation_id: "conv-xyz789",
+  description: "Continue implementation",
+  prompt: "Now implement the fix we discussed"
+})
+\`\`\`
+
 ## Examples:
 
 \`\`\`typescript
@@ -9675,6 +9726,7 @@ var init_truncation = __esm(() => {
   init_overflow();
   LIMITS = {
     BASH_OUTPUT_CHARS: 30000,
+    TASK_OUTPUT_CHARS: 30000,
     READ_MAX_LINES: 2000,
     READ_MAX_CHARS_PER_LINE: 2000,
     GREP_OUTPUT_CHARS: 1e4,
@@ -19528,6 +19580,33 @@ ${pathLine}${processedContent}`;
     throw new Error(`Failed to ${command} skill(s): ${String(error)}`);
   }
 }
+async function preloadSkillsContent(skillIds, skillsDir) {
+  if (skillIds.length === 0) {
+    return "No skills currently loaded.";
+  }
+  let content = "";
+  for (const skillId of skillIds) {
+    try {
+      const { content: skillContent, path: skillPath } = await readSkillContent(skillId, skillsDir);
+      const skillDir = dirname5(skillPath);
+      const hasExtras = hasAdditionalFiles(skillPath);
+      const pathLine = hasExtras ? `# Skill Directory: ${skillDir}
+
+` : "";
+      const processedContent = hasExtras ? skillContent.replace(/<SKILL_DIR>/g, skillDir) : skillContent;
+      const separator = content ? `
+
+---
+
+` : "";
+      content = `${content}${separator}# Skill: ${skillId}
+${pathLine}${processedContent}`;
+    } catch (error) {
+      console.error(`Warning: Could not pre-load skill "${skillId}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return content || "No skills currently loaded.";
+}
 var init_Skill2 = __esm(async () => {
   init_context();
   init_skills2();
@@ -19822,6 +19901,9 @@ function handleInitEvent(event, state, baseURL, subagentId) {
     const agentURL = `${baseURL}/agents/${event.agent_id}`;
     updateSubagent(subagentId, { agentURL });
   }
+  if (event.conversation_id) {
+    state.conversationId = event.conversation_id;
+  }
 }
 function handleApprovalRequestEvent(event, state) {
   const toolCalls = Array.isArray(event.tool_calls) ? event.tool_calls : event.tool_call ? [event.tool_call] : [];
@@ -19921,18 +20003,24 @@ function parseResultFromStdout(stdout, agentId) {
     };
   }
 }
-function buildSubagentArgs(type, config, model, userPrompt) {
-  const args = [
-    "--new-agent",
-    "--system",
-    type,
-    "--model",
-    model,
-    "-p",
-    userPrompt,
-    "--output-format",
-    "stream-json"
-  ];
+function buildSubagentArgs(type, config, model, userPrompt, existingAgentId, existingConversationId, preloadedSkillsContent) {
+  const args = [];
+  const isDeployingExisting = Boolean(existingAgentId || existingConversationId);
+  if (isDeployingExisting) {
+    if (existingConversationId) {
+      args.push("--conv", existingConversationId);
+    } else if (existingAgentId) {
+      args.push("--agent", existingAgentId);
+    }
+    args.push("--no-skills");
+  } else {
+    args.push("--new-agent", "--system", type);
+    if (model) {
+      args.push("--model", model);
+    }
+  }
+  args.push("-p", userPrompt);
+  args.push("--output-format", "stream-json");
   const subagentMode = config.permissionMode;
   const parentMode = permissionMode.getMode();
   const modeToUse = subagentMode || parentMode;
@@ -19941,8 +20029,9 @@ function buildSubagentArgs(type, config, model, userPrompt) {
   }
   const parentAllowedTools = cliPermissions.getAllowedTools();
   const sessionAllowRules = sessionPermissions.getRules().allow || [];
+  const subagentTools = config.allowedTools !== "all" && Array.isArray(config.allowedTools) ? config.allowedTools : [];
   const combinedAllowedTools = [
-    ...new Set([...parentAllowedTools, ...sessionAllowRules])
+    ...new Set([...parentAllowedTools, ...sessionAllowRules, ...subagentTools])
   ];
   if (combinedAllowedTools.length > 0) {
     args.push("--allowedTools", combinedAllowedTools.join(","));
@@ -19951,17 +20040,22 @@ function buildSubagentArgs(type, config, model, userPrompt) {
   if (parentDisallowedTools.length > 0) {
     args.push("--disallowedTools", parentDisallowedTools.join(","));
   }
-  if (config.memoryBlocks === "none") {
-    args.push("--init-blocks", "none");
-  } else if (Array.isArray(config.memoryBlocks) && config.memoryBlocks.length > 0) {
-    args.push("--init-blocks", config.memoryBlocks.join(","));
+  if (!isDeployingExisting) {
+    if (config.memoryBlocks === "none") {
+      args.push("--init-blocks", "none");
+    } else if (Array.isArray(config.memoryBlocks) && config.memoryBlocks.length > 0) {
+      args.push("--init-blocks", config.memoryBlocks.join(","));
+    }
   }
   if (config.allowedTools !== "all" && Array.isArray(config.allowedTools) && config.allowedTools.length > 0) {
     args.push("--tools", config.allowedTools.join(","));
   }
+  if (!isDeployingExisting && preloadedSkillsContent) {
+    args.push("--block-value", `loaded_skills=${preloadedSkillsContent}`);
+  }
   return args;
 }
-async function executeSubagent(type, config, model, userPrompt, baseURL, subagentId, isRetry = false, signal) {
+async function executeSubagent(type, config, model, userPrompt, baseURL, subagentId, isRetry = false, signal, existingAgentId, existingConversationId) {
   if (signal?.aborted) {
     return {
       agentId: "",
@@ -19970,10 +20064,17 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
       error: INTERRUPTED_BY_USER
     };
   }
-  updateSubagent(subagentId, { model });
+  if (model) {
+    updateSubagent(subagentId, { model });
+  }
   try {
-    const cliArgs = buildSubagentArgs(type, config, model, userPrompt);
-    const lettaCmd = process.env.LETTA_CODE_BIN || "letta";
+    let preloadedSkillsContent;
+    if (config.skills && config.skills.length > 0) {
+      preloadedSkillsContent = await preloadSkillsContent(config.skills, SKILLS_DIR);
+    }
+    const cliArgs = buildSubagentArgs(type, config, model, userPrompt, existingAgentId, existingConversationId, preloadedSkillsContent);
+    const currentScript = process.argv[1] || "";
+    const lettaCmd = process.env.LETTA_CODE_BIN || (currentScript.endsWith(".js") ? currentScript : null) || (currentScript.includes("src/index.ts") ? "./letta.js" : null) || "letta";
     let parentAgentId;
     try {
       parentAgentId = getCurrentAgentId();
@@ -19995,7 +20096,8 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
     const stdoutChunks = [];
     const stderrChunks = [];
     const state = {
-      agentId: null,
+      agentId: existingAgentId || null,
+      conversationId: existingConversationId || null,
       finalResult: null,
       finalError: null,
       resultStats: null,
@@ -20022,6 +20124,7 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
     if (wasAborted) {
       return {
         agentId: state.agentId || "",
+        conversationId: state.conversationId || undefined,
         report: "",
         success: false,
         error: INTERRUPTED_BY_USER
@@ -20037,6 +20140,7 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
       }
       return {
         agentId: state.agentId || "",
+        conversationId: state.conversationId || undefined,
         report: "",
         success: false,
         error: stderr || `Subagent exited with code ${exitCode}`
@@ -20045,6 +20149,7 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
     if (state.finalResult !== null) {
       return {
         agentId: state.agentId || "",
+        conversationId: state.conversationId || undefined,
         report: state.finalResult,
         success: !state.finalError,
         error: state.finalError || undefined,
@@ -20054,6 +20159,7 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
     if (state.finalError) {
       return {
         agentId: state.agentId || "",
+        conversationId: state.conversationId || undefined,
         report: "",
         success: false,
         error: state.finalError,
@@ -20079,7 +20185,17 @@ function getBaseURL() {
   }
   return baseURL;
 }
-async function spawnSubagent(type, prompt, userModel, subagentId, signal) {
+function buildDeploySystemReminder(senderAgentName, senderAgentId, subagentType) {
+  const toolDescription = subagentType === "explore" ? "read-only tools (Read, Glob, Grep)" : "local tools (Bash, Read, Write, Edit, etc.)";
+  return `<system-reminder>
+This task is from "${senderAgentName}" (agent ID: ${senderAgentId}), which deployed you as a subagent inside the Letta Code CLI (docs.letta.com/letta-code).
+You have access to ${toolDescription} in their codebase.
+Your final message will be returned to the caller.
+</system-reminder>
+
+`;
+}
+async function spawnSubagent(type, prompt, userModel, subagentId, signal, existingAgentId, existingConversationId) {
   const allConfigs = await getAllSubagentConfigs();
   const config = allConfigs[type];
   if (!config) {
@@ -20090,9 +20206,20 @@ async function spawnSubagent(type, prompt, userModel, subagentId, signal) {
       error: `Unknown subagent type: ${type}`
     };
   }
-  const model = userModel || config.recommendedModel;
+  const isDeployingExisting = Boolean(existingAgentId || existingConversationId);
+  const model = isDeployingExisting ? null : userModel || config.recommendedModel;
   const baseURL = getBaseURL();
-  const result = await executeSubagent(type, config, model, prompt, baseURL, subagentId, false, signal);
+  let finalPrompt = prompt;
+  if (isDeployingExisting) {
+    try {
+      const parentAgentId = getCurrentAgentId();
+      const client = await getClient2();
+      const parentAgent = await client.agents.retrieve(parentAgentId);
+      const systemReminder = buildDeploySystemReminder(parentAgent.name, parentAgentId, type);
+      finalPrompt = systemReminder + prompt;
+    } catch {}
+  }
+  const result = await executeSubagent(type, config, model, finalPrompt, baseURL, subagentId, false, signal, existingAgentId, existingConversationId);
   return result;
 }
 var init_manager2 = __esm(async () => {
@@ -20103,9 +20230,11 @@ var init_manager2 = __esm(async () => {
   init_session();
   init_context();
   init_model();
+  init_skills2();
   init_subagents();
   await __promiseAll([
     init_settings_manager(),
+    init_Skill2(),
     init_client2()
   ]);
 });
@@ -20127,19 +20256,27 @@ async function task(args) {
     const errorSuffix = errors.length > 0 ? `, ${errors.length} error(s)` : "";
     return `Refreshed subagents list: found ${totalCount} total (${customCount} custom)${errorSuffix}`;
   }
-  validateRequiredParams(args, ["subagent_type", "prompt", "description"], "Task");
-  const subagent_type = args.subagent_type;
+  const isDeployingExisting = Boolean(args.agent_id || args.conversation_id);
+  if (isDeployingExisting) {
+    validateRequiredParams(args, ["prompt", "description"], "Task");
+  } else {
+    validateRequiredParams(args, ["subagent_type", "prompt", "description"], "Task");
+  }
   const prompt = args.prompt;
   const description = args.description;
+  const subagent_type = isDeployingExisting ? args.subagent_type || "general-purpose" : args.subagent_type;
   const allConfigs = await getAllSubagentConfigs();
   if (!(subagent_type in allConfigs)) {
     const available = Object.keys(allConfigs).join(", ");
     return `Error: Invalid subagent type "${subagent_type}". Available types: ${available}`;
   }
+  if (isDeployingExisting && !VALID_DEPLOY_TYPES.has(subagent_type)) {
+    return `Error: When deploying an existing agent, subagent_type must be "explore" (read-only) or "general-purpose" (read-write). Got: "${subagent_type}"`;
+  }
   const subagentId = generateSubagentId();
   registerSubagent(subagentId, subagent_type, description, toolCallId);
   try {
-    const result = await spawnSubagent(subagent_type, prompt, model, subagentId, signal);
+    const result = await spawnSubagent(subagent_type, prompt, model, subagentId, signal, args.agent_id, args.conversation_id);
     completeSubagent(subagentId, {
       success: result.success,
       error: result.error,
@@ -20150,21 +20287,28 @@ async function task(args) {
     }
     const header = [
       `subagent_type=${subagent_type}`,
-      result.agentId ? `agent_id=${result.agentId}` : undefined
+      result.agentId ? `agent_id=${result.agentId}` : undefined,
+      result.conversationId ? `conversation_id=${result.conversationId}` : undefined
     ].filter(Boolean).join(" ");
-    return `${header}
+    const fullOutput = `${header}
 
 ${result.report}`;
+    const userCwd = process.env.USER_CWD || process.cwd();
+    const { content: truncatedOutput } = truncateByChars(fullOutput, LIMITS.TASK_OUTPUT_CHARS, "Task", { workingDirectory: userCwd, toolName: "Task" });
+    return truncatedOutput;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     completeSubagent(subagentId, { success: false, error: errorMessage });
     return `Error: ${errorMessage}`;
   }
 }
+var VALID_DEPLOY_TYPES;
 var init_Task2 = __esm(async () => {
   init_subagents();
   init_subagentState();
+  init_truncation();
   await init_manager2();
+  VALID_DEPLOY_TYPES = new Set(["explore", "general-purpose"]);
 });
 
 // src/tools/impl/TodoWrite.ts
@@ -24267,7 +24411,7 @@ var init_manager3 = __esm(async () => {
 
 // src/agent/create.ts
 import { join as join11 } from "node:path";
-async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingModel = "openai/text-embedding-3-small", updateArgs, skillsDirectory, parallelToolCalls = true, enableSleeptime = false, systemPromptPreset, initBlocks, baseTools) {
+async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingModel, updateArgs, skillsDirectory, parallelToolCalls = true, enableSleeptime = false, systemPromptPreset, initBlocks, baseTools) {
   let options;
   if (typeof nameOrOptions === "object") {
     options = nameOrOptions;
@@ -24286,7 +24430,7 @@ async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingM
     };
   }
   const name = options.name ?? DEFAULT_AGENT_NAME;
-  const embeddingModelVal = options.embeddingModel ?? "openai/text-embedding-3-small";
+  const embeddingModelVal = options.embeddingModel;
   const parallelToolCallsVal = options.parallelToolCalls ?? true;
   const enableSleeptimeVal = options.enableSleeptime ?? false;
   let modelHandle;
@@ -24408,7 +24552,7 @@ ${options.systemPromptAppend}`;
     system: systemPromptContent,
     name,
     description: agentDescription,
-    embedding: embeddingModelVal,
+    embedding: embeddingModelVal || undefined,
     model: modelHandle,
     context_window_limit: contextWindow,
     tools: toolNames,
@@ -50487,6 +50631,103 @@ var init_auto_update = __esm(() => {
   DEBUG = process.env.LETTA_DEBUG_AUTOUPDATE === "1";
 });
 
+// src/tools/impl/overflow.ts
+var exports_overflow = {};
+__export(exports_overflow, {
+  writeOverflowFile: () => writeOverflowFile2,
+  getOverflowStats: () => getOverflowStats,
+  getOverflowDirectory: () => getOverflowDirectory2,
+  ensureOverflowDirectory: () => ensureOverflowDirectory2,
+  cleanupOldOverflowFiles: () => cleanupOldOverflowFiles,
+  OVERFLOW_CONFIG: () => OVERFLOW_CONFIG2
+});
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as fs10 from "node:fs";
+import * as os3 from "node:os";
+import * as path18 from "node:path";
+function getOverflowDirectory2(workingDirectory) {
+  const homeDir = os3.homedir();
+  const lettaDir = path18.join(homeDir, ".letta");
+  const normalizedPath = path18.normalize(workingDirectory);
+  const sanitizedPath = normalizedPath.replace(/^[/\\]/, "").replace(/[/\\:]/g, "_").replace(/\s+/g, "_");
+  const overflowDir = path18.join(lettaDir, "projects", sanitizedPath, "agent-tools");
+  return overflowDir;
+}
+function ensureOverflowDirectory2(workingDirectory) {
+  const overflowDir = getOverflowDirectory2(workingDirectory);
+  if (!fs10.existsSync(overflowDir)) {
+    fs10.mkdirSync(overflowDir, { recursive: true });
+  }
+  return overflowDir;
+}
+function writeOverflowFile2(content, workingDirectory, toolName) {
+  const overflowDir = ensureOverflowDirectory2(workingDirectory);
+  const uuid = randomUUID2();
+  const filename = toolName ? `${toolName.toLowerCase()}-${uuid}.txt` : `${uuid}.txt`;
+  const filePath = path18.join(overflowDir, filename);
+  fs10.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function cleanupOldOverflowFiles(workingDirectory, maxAgeMs = 24 * 60 * 60 * 1000) {
+  const overflowDir = getOverflowDirectory2(workingDirectory);
+  if (!fs10.existsSync(overflowDir)) {
+    return 0;
+  }
+  let files;
+  try {
+    files = fs10.readdirSync(overflowDir);
+  } catch {
+    return 0;
+  }
+  const now = Date.now();
+  let deletedCount = 0;
+  for (const file of files) {
+    const filePath = path18.join(overflowDir, file);
+    try {
+      const stats = fs10.statSync(filePath);
+      if (stats.isDirectory()) {
+        continue;
+      }
+      if (now - stats.mtimeMs > maxAgeMs) {
+        fs10.unlinkSync(filePath);
+        deletedCount++;
+      }
+    } catch {}
+  }
+  return deletedCount;
+}
+function getOverflowStats(workingDirectory) {
+  const overflowDir = getOverflowDirectory2(workingDirectory);
+  if (!fs10.existsSync(overflowDir)) {
+    return {
+      directory: overflowDir,
+      exists: false,
+      fileCount: 0,
+      totalSize: 0
+    };
+  }
+  const files = fs10.readdirSync(overflowDir);
+  let totalSize = 0;
+  for (const file of files) {
+    const filePath = path18.join(overflowDir, file);
+    const stats = fs10.statSync(filePath);
+    totalSize += stats.size;
+  }
+  return {
+    directory: overflowDir,
+    exists: true,
+    fileCount: files.length,
+    totalSize
+  };
+}
+var OVERFLOW_CONFIG2;
+var init_overflow2 = __esm(() => {
+  OVERFLOW_CONFIG2 = {
+    ENABLED: process.env.LETTA_TOOL_OVERFLOW_TO_FILE?.toLowerCase() !== "false",
+    MIDDLE_TRUNCATE: process.env.LETTA_TOOL_MIDDLE_TRUNCATE?.toLowerCase() !== "false"
+  };
+});
+
 // src/agent/promptAssets.ts
 var exports_promptAssets2 = {};
 __export(exports_promptAssets2, {
@@ -50620,9 +50861,9 @@ __export(exports_subagents2, {
   GLOBAL_AGENTS_DIR: () => GLOBAL_AGENTS_DIR2,
   AGENTS_DIR: () => AGENTS_DIR2
 });
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { readdir as readdir6, readFile as readFile7 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function isValidName2(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
@@ -50704,7 +50945,7 @@ function getBuiltinSubagentNames2() {
   return new Set(Object.keys(getBuiltinSubagents2()));
 }
 async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors) {
-  if (!existsSync8(agentsDir)) {
+  if (!existsSync9(agentsDir)) {
     return;
   }
   try {
@@ -50713,7 +50954,7 @@ async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors
       if (!entry.isFile() || !entry.name.endsWith(".md")) {
         continue;
       }
-      const filePath = join15(agentsDir, entry.name);
+      const filePath = join16(agentsDir, entry.name);
       try {
         const config = await parseSubagentFile2(filePath);
         if (config) {
@@ -50745,7 +50986,7 @@ async function discoverSubagents2(workingDirectory = process.cwd()) {
   const subagents = [];
   const seenNames = new Set;
   await discoverSubagentsFromDir2(GLOBAL_AGENTS_DIR2, seenNames, subagents, errors);
-  const projectAgentsDir = join15(workingDirectory, AGENTS_DIR2);
+  const projectAgentsDir = join16(workingDirectory, AGENTS_DIR2);
   await discoverSubagentsFromDir2(projectAgentsDir, seenNames, subagents, errors);
   return { subagents, errors };
 }
@@ -50784,7 +51025,7 @@ var init_subagents2 = __esm(() => {
     plan_default,
     recall_default
   ];
-  GLOBAL_AGENTS_DIR2 = join15(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
+  GLOBAL_AGENTS_DIR2 = join16(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS2 = new Set(MEMORY_BLOCK_LABELS);
   cache4 = {
     builtins: null,
@@ -50794,10 +51035,10 @@ var init_subagents2 = __esm(() => {
 });
 
 // node_modules/is-docker/index.js
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 function hasDockerEnv() {
   try {
-    fs10.statSync("/.dockerenv");
+    fs11.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -50805,7 +51046,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs10.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs11.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -50820,7 +51061,7 @@ var isDockerCached;
 var init_is_docker = () => {};
 
 // node_modules/is-inside-container/index.js
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 function isInsideContainer() {
   if (cachedResult === undefined) {
     cachedResult = hasContainerEnv() || isDocker();
@@ -50829,7 +51070,7 @@ function isInsideContainer() {
 }
 var cachedResult, hasContainerEnv = () => {
   try {
-    fs11.statSync("/run/.containerenv");
+    fs12.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -50841,20 +51082,20 @@ var init_is_inside_container = __esm(() => {
 
 // node_modules/is-wsl/index.js
 import process13 from "node:process";
-import os3 from "node:os";
-import fs12 from "node:fs";
+import os4 from "node:os";
+import fs13 from "node:fs";
 var isWsl = () => {
   if (process13.platform !== "linux") {
     return false;
   }
-  if (os3.release().toLowerCase().includes("microsoft")) {
+  if (os4.release().toLowerCase().includes("microsoft")) {
     if (isInsideContainer()) {
       return false;
     }
     return true;
   }
   try {
-    return fs12.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+    return fs13.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
   } catch {
     return false;
   }
@@ -50866,7 +51107,7 @@ var init_is_wsl = __esm(() => {
 
 // node_modules/wsl-utils/index.js
 import process14 from "node:process";
-import fs13, { constants as fsConstants } from "node:fs/promises";
+import fs14, { constants as fsConstants } from "node:fs/promises";
 var wslDrivesMountPoint, powerShellPathFromWsl = async () => {
   const mountPoint = await wslDrivesMountPoint();
   return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
@@ -50889,13 +51130,13 @@ var init_wsl_utils = __esm(() => {
       const configFilePath = "/etc/wsl.conf";
       let isConfigFileExists = false;
       try {
-        await fs13.access(configFilePath, fsConstants.F_OK);
+        await fs14.access(configFilePath, fsConstants.F_OK);
         isConfigFileExists = true;
       } catch {}
       if (!isConfigFileExists) {
         return defaultMountPoint;
       }
-      const configContent = await fs13.readFile(configFilePath, { encoding: "utf8" });
+      const configContent = await fs14.readFile(configFilePath, { encoding: "utf8" });
       const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
       if (!configMountPoint) {
         return defaultMountPoint;
@@ -51049,11 +51290,11 @@ __export(exports_open, {
 });
 import process18 from "node:process";
 import { Buffer as Buffer3 } from "node:buffer";
-import path18 from "node:path";
+import path19 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import { promisify as promisify8 } from "node:util";
 import childProcess from "node:child_process";
-import fs14, { constants as fsConstants2 } from "node:fs/promises";
+import fs15, { constants as fsConstants2 } from "node:fs/promises";
 async function getWindowsDefaultBrowserFromWsl() {
   const powershellPath = await powerShellPath();
   const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
@@ -51210,7 +51451,7 @@ var execFile7, __dirname2, localXdgOpenPath, platform2, arch, pTryEach = async (
       const isBundled = !__dirname2 || __dirname2 === "/";
       let exeLocalXdgOpen = false;
       try {
-        await fs14.access(localXdgOpenPath, fsConstants2.X_OK);
+        await fs15.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {}
       const useSystemXdgOpen = process18.versions.electron ?? (platform2 === "android" || isBundled || !exeLocalXdgOpen);
@@ -51274,8 +51515,8 @@ var init_open = __esm(() => {
   init_default_browser();
   init_is_inside_container();
   execFile7 = promisify8(childProcess.execFile);
-  __dirname2 = path18.dirname(fileURLToPath8(import.meta.url));
-  localXdgOpenPath = path18.join(__dirname2, "xdg-open");
+  __dirname2 = path19.dirname(fileURLToPath8(import.meta.url));
+  localXdgOpenPath = path19.join(__dirname2, "xdg-open");
   ({ platform: platform2, arch } = process18);
   apps = {};
   defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
@@ -52998,7 +53239,7 @@ __export(exports_approval_execution, {
   executeAutoAllowedTools: () => executeAutoAllowedTools,
   executeApprovalBatch: () => executeApprovalBatch
 });
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function isParallelSafe(toolName) {
   return PARALLEL_SAFE_TOOLS.has(toolName);
 }
@@ -53010,7 +53251,7 @@ function getResourceKey(toolName, toolArgs) {
     const filePath = toolArgs.file_path;
     if (typeof filePath === "string") {
       const userCwd = process.env.USER_CWD || process.cwd();
-      return path19.isAbsolute(filePath) ? path19.normalize(filePath) : path19.resolve(userCwd, filePath);
+      return path20.isAbsolute(filePath) ? path20.normalize(filePath) : path20.resolve(userCwd, filePath);
     }
   }
   return "__global__";
@@ -53281,7 +53522,8 @@ async function handleHeadlessCommand(argv, model, skillsDirectory) {
       sleeptime: { type: "boolean" },
       "init-blocks": { type: "string" },
       "base-tools": { type: "string" },
-      "from-af": { type: "string" }
+      "from-af": { type: "string" },
+      "no-skills": { type: "boolean" }
     },
     strict: false,
     allowPositionals: true
@@ -53596,7 +53838,18 @@ Usage: letta -p "..." --new-agent`);
     }
   }
   let conversationId;
-  const isolatedBlockLabels = initBlocks === undefined ? [...ISOLATED_BLOCK_LABELS] : ISOLATED_BLOCK_LABELS.filter((label) => initBlocks.includes(label));
+  const noSkillsFlag = values["no-skills"];
+  const isSubagent = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
+  if (!noSkillsFlag && !isSubagent) {
+    const createdBlocks = await ensureSkillsBlocks(agent.id);
+    if (createdBlocks.length > 0) {
+      console.log("Created missing skills blocks for agent compatibility");
+    }
+  }
+  let isolatedBlockLabels = [];
+  if (!noSkillsFlag) {
+    isolatedBlockLabels = initBlocks === undefined ? [...ISOLATED_BLOCK_LABELS] : ISOLATED_BLOCK_LABELS.filter((label) => initBlocks.includes(label));
+  }
   if (specifiedConversationId) {
     if (specifiedConversationId === "default") {
       conversationId = "default";
@@ -53642,7 +53895,6 @@ Usage: letta -p "..." --new-agent`);
     conversationId = conversation.id;
   }
   markMilestone("HEADLESS_CONVERSATION_READY");
-  const isSubagent = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
   if (!isSubagent) {
     await settingsManager.loadLocalProjectSettings();
     settingsManager.setLocalLastSession({ agentId: agent.id, conversationId }, process.cwd());
@@ -53651,24 +53903,22 @@ Usage: letta -p "..." --new-agent`);
       conversationId
     });
   }
-  const createdBlocks = await ensureSkillsBlocks(agent.id);
-  if (createdBlocks.length > 0) {
-    console.log("Created missing skills blocks for agent compatibility");
-  }
   setAgentContext2(agent.id, skillsDirectory);
-  initializeLoadedSkillsFlag2().catch(() => {});
-  (async () => {
-    try {
-      const { syncSkillsToAgent: syncSkillsToAgent3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills2(), exports_skills));
-      const { join: join16 } = await import("node:path");
-      const resolvedSkillsDirectory = skillsDirectory || join16(process.cwd(), SKILLS_DIR3);
-      await syncSkillsToAgent3(client, agent.id, resolvedSkillsDirectory, {
-        skipIfUnchanged: true
-      });
-    } catch (error) {
-      console.warn(`[skills] Background sync failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  })();
+  if (!noSkillsFlag && !isSubagent) {
+    initializeLoadedSkillsFlag2().catch(() => {});
+    (async () => {
+      try {
+        const { syncSkillsToAgent: syncSkillsToAgent3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills2(), exports_skills));
+        const { join: join17 } = await import("node:path");
+        const resolvedSkillsDirectory = skillsDirectory || join17(process.cwd(), SKILLS_DIR3);
+        await syncSkillsToAgent3(client, agent.id, resolvedSkillsDirectory, {
+          skipIfUnchanged: true
+        });
+      } catch (error) {
+        console.warn(`[skills] Background sync failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    })();
+  }
   const outputFormat = values["output-format"] || "text";
   const includePartialMessages = Boolean(values["include-partial-messages"]);
   if (!["text", "json", "stream-json"].includes(outputFormat)) {
@@ -54607,7 +54857,7 @@ __export(exports_kittyProtocolDetector, {
   isKittyProtocolEnabled: () => isKittyProtocolEnabled,
   detectAndEnableKittyProtocol: () => detectAndEnableKittyProtocol
 });
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 async function detectAndEnableKittyProtocol() {
   if (detectionComplete) {
     return;
@@ -54680,7 +54930,7 @@ async function detectAndEnableKittyProtocol() {
     if (DEBUG2) {
       console.error("[kitty] querying support");
     }
-    fs15.writeSync(process.stdout.fd, "\x1B[?u\x1B[c");
+    fs16.writeSync(process.stdout.fd, "\x1B[?u\x1B[c");
     timeoutId = setTimeout(finish, 200);
   });
 }
@@ -54689,14 +54939,14 @@ function isKittyProtocolEnabled() {
 }
 function enableKittyKeyboardProtocol() {
   try {
-    fs15.writeSync(process.stdout.fd, "\x1B[>1u");
+    fs16.writeSync(process.stdout.fd, "\x1B[>1u");
     kittyEnabled = true;
   } catch {}
 }
 function disableKittyKeyboardProtocol() {
   try {
     if (kittyEnabled) {
-      fs15.writeSync(process.stdout.fd, "\x1B[<u");
+      fs16.writeSync(process.stdout.fd, "\x1B[<u");
       kittyEnabled = false;
     }
   } catch {}
@@ -54928,10 +55178,10 @@ __export(exports_settings, {
   loadProjectSettings: () => loadProjectSettings,
   getSetting: () => getSetting
 });
-import { homedir as homedir9 } from "node:os";
-import { join as join16 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join17 } from "node:path";
 function getSettingsPath() {
-  return join16(homedir9(), ".letta", "settings.json");
+  return join17(homedir10(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -54968,7 +55218,7 @@ async function getSetting(key) {
   return settings[key];
 }
 function getProjectSettingsPath() {
-  return join16(process.cwd(), ".letta", "settings.local.json");
+  return join17(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -54986,7 +55236,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join16(process.cwd(), ".letta");
+  const dirPath = join17(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -56157,7 +56407,7 @@ function parsePatchOperations(input) {
       continue;
     }
     if (line.startsWith("*** Add File:")) {
-      const path20 = line.replace("*** Add File:", "").trim();
+      const path21 = line.replace("*** Add File:", "").trim();
       i++;
       const contentLines = [];
       const patchLines = [];
@@ -56173,7 +56423,7 @@ function parsePatchOperations(input) {
       }
       operations.push({
         kind: "add",
-        path: path20,
+        path: path21,
         content: contentLines.join(`
 `),
         patchLines
@@ -56181,7 +56431,7 @@ function parsePatchOperations(input) {
       continue;
     }
     if (line.startsWith("*** Update File:")) {
-      const path20 = line.replace("*** Update File:", "").trim();
+      const path21 = line.replace("*** Update File:", "").trim();
       i++;
       if (i < stopIdx && lines[i]?.startsWith("*** Move to:")) {
         i++;
@@ -56217,7 +56467,7 @@ function parsePatchOperations(input) {
       }
       operations.push({
         kind: "update",
-        path: path20,
+        path: path21,
         oldString: oldParts.join(`
 `),
         newString: newParts.join(`
@@ -56227,8 +56477,8 @@ function parsePatchOperations(input) {
       continue;
     }
     if (line.startsWith("*** Delete File:")) {
-      const path20 = line.replace("*** Delete File:", "").trim();
-      operations.push({ kind: "delete", path: path20 });
+      const path21 = line.replace("*** Delete File:", "").trim();
+      operations.push({ kind: "delete", path: path21 });
       i++;
       continue;
     }
@@ -56460,16 +56710,16 @@ class Diff {
       }
     }
   }
-  addToPath(path20, added, removed, oldPosInc, options) {
-    const last = path20.lastComponent;
+  addToPath(path21, added, removed, oldPosInc, options) {
+    const last = path21.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path20.oldPos + oldPosInc,
+        oldPos: path21.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path20.oldPos + oldPosInc,
+        oldPos: path21.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -58206,9 +58456,9 @@ function getFileEditHeader(toolName, toolArgs) {
     const relPath = relative4(cwd2, filePath);
     const displayPath = relPath.startsWith("..") ? filePath : relPath;
     if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-      const { existsSync: existsSync9 } = __require("node:fs");
+      const { existsSync: existsSync10 } = __require("node:fs");
       try {
-        if (existsSync9(filePath)) {
+        if (existsSync10(filePath)) {
           return `Overwrite ${displayPath}?`;
         }
       } catch {}
@@ -58891,9 +59141,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative4(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: existsSync9 } = __require("node:fs");
+    const { existsSync: existsSync10 } = __require("node:fs");
     try {
-      if (existsSync9(fileEdit.filePath)) {
+      if (existsSync10(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -60568,7 +60818,7 @@ var init_ApprovalSwitch = __esm(async () => {
 });
 
 // src/cli/components/AssistantMessageRich.tsx
-var import_react43, jsx_dev_runtime21, normalize4 = (s) => s.replace(/\r\n/g, `
+var import_react43, jsx_dev_runtime21, normalize5 = (s) => s.replace(/\r\n/g, `
 `).replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, `
 
 `).replace(/^\n+|\n+$/g, ""), AssistantMessage;
@@ -60583,7 +60833,7 @@ var init_AssistantMessageRich = __esm(async () => {
   AssistantMessage = import_react43.memo(({ line }) => {
     const columns = useTerminalWidth();
     const contentWidth = Math.max(0, columns - 2);
-    const normalizedText = normalize4(line.text);
+    const normalizedText = normalize5(line.text);
     return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
       flexDirection: "row",
       children: [
@@ -61802,7 +62052,7 @@ var init_pasteRegistry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
 import { basename as basename2, extname as extname3, isAbsolute as isAbsolute12, resolve as resolve18 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
@@ -61853,7 +62103,7 @@ function translatePasteForImages(paste) {
       if (!isAbsolute12(filePath))
         filePath = resolve18(process.cwd(), filePath);
       const ext3 = extname3(filePath || "").toLowerCase();
-      if (IMAGE_EXTS.has(ext3) && existsSync9(filePath) && statSync2(filePath).isFile()) {
+      if (IMAGE_EXTS.has(ext3) && existsSync10(filePath) && statSync3(filePath).isFile()) {
         const buf = readFileSync2(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";
@@ -62441,13 +62691,13 @@ __export(exports_terminalKeybindingInstaller, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync3,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir10, platform as platform3 } from "node:os";
-import { dirname as dirname10, join as join17 } from "node:path";
+import { homedir as homedir11, platform as platform3 } from "node:os";
+import { dirname as dirname10, join as join18 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -62477,18 +62727,18 @@ function getKeybindingsPath(terminal) {
     cursor: "Cursor",
     windsurf: "Windsurf"
   }[terminal];
-  const os4 = platform3();
-  if (os4 === "darwin") {
-    return join17(homedir10(), "Library", "Application Support", appName, "User", "keybindings.json");
+  const os5 = platform3();
+  if (os5 === "darwin") {
+    return join18(homedir11(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
-  if (os4 === "win32") {
+  if (os5 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join17(appData, appName, "User", "keybindings.json");
+    return join18(appData, appName, "User", "keybindings.json");
   }
-  if (os4 === "linux") {
-    return join17(homedir10(), ".config", appName, "User", "keybindings.json");
+  if (os5 === "linux") {
+    return join18(homedir11(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -62510,7 +62760,7 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync10(keybindingsPath))
+  if (!existsSync11(keybindingsPath))
     return false;
   try {
     const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
@@ -62523,7 +62773,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync10(keybindingsPath))
+  if (!existsSync11(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -62539,12 +62789,12 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname10(keybindingsPath);
-    if (!existsSync10(parentDir)) {
-      mkdirSync4(parentDir, { recursive: true });
+    if (!existsSync11(parentDir)) {
+      mkdirSync5(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync10(keybindingsPath)) {
+    if (existsSync11(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
       const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
@@ -62559,7 +62809,7 @@ function installKeybinding(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync2(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync3(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -62574,7 +62824,7 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync10(keybindingsPath)) {
+    if (!existsSync11(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
@@ -62588,7 +62838,7 @@ function removeKeybinding(keybindingsPath) {
     const filtered = keybindings.filter((kb) => !(kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus")));
     const newContent = `${JSON.stringify(filtered, null, 2)}
 `;
-    writeFileSync2(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync3(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -62606,14 +62856,14 @@ function installKeybindingForCurrentTerminal() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path20 = getKeybindingsPath(terminal);
-  if (!path20) {
+  const path21 = getKeybindingsPath(terminal);
+  if (!path21) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return installKeybinding(path20);
+  return installKeybinding(path21);
 }
 function removeKeybindingForCurrentTerminal() {
   const terminal = detectTerminalType();
@@ -62623,14 +62873,14 @@ function removeKeybindingForCurrentTerminal() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path20 = getKeybindingsPath(terminal);
-  if (!path20) {
+  const path21 = getKeybindingsPath(terminal);
+  if (!path21) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return removeKeybinding(path20);
+  return removeKeybinding(path21);
 }
 function isWezTerm() {
   return process.env.TERM_PROGRAM === "WezTerm";
@@ -62641,17 +62891,17 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join17(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync10(xdgPath))
+    const xdgPath = join18(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync11(xdgPath))
       return xdgPath;
   }
-  const configPath = join17(homedir10(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync10(configPath))
+  const configPath = join18(homedir11(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync11(configPath))
     return configPath;
-  return join17(homedir10(), ".wezterm.lua");
+  return join18(homedir11(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync10(configPath))
+  if (!existsSync11(configPath))
     return false;
   try {
     const content = readFileSync3(configPath, { encoding: "utf-8" });
@@ -62668,7 +62918,7 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync10(configPath)) {
+    if (existsSync11(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync(configPath, backupPath);
       content = readFileSync3(configPath, { encoding: "utf-8" });
@@ -62698,10 +62948,10 @@ ${WEZTERM_DELETE_FIX}
 `;
     }
     const parentDir = dirname10(configPath);
-    if (!existsSync10(parentDir)) {
-      mkdirSync4(parentDir, { recursive: true });
+    if (!existsSync11(parentDir)) {
+      mkdirSync5(parentDir, { recursive: true });
     }
-    writeFileSync2(configPath, content, { encoding: "utf-8" });
+    writeFileSync3(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -63098,9 +63348,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { readdir as readdir7, readFile as readFile8 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname11, join as join18 } from "node:path";
+import { basename as basename3, dirname as dirname11, join as join19 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -63111,7 +63361,7 @@ async function getCustomCommands() {
 function refreshCustomCommands() {
   cachedCommands = null;
 }
-async function discoverCustomCommands(projectPath = join18(process.cwd(), COMMANDS_DIR)) {
+async function discoverCustomCommands(projectPath = join19(process.cwd(), COMMANDS_DIR)) {
   const commandsById = new Map;
   const userCommands = await discoverFromDirectory(GLOBAL_COMMANDS_DIR, "user");
   for (const cmd of userCommands) {
@@ -63132,7 +63382,7 @@ async function discoverCustomCommands(projectPath = join18(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source) {
-  if (!existsSync11(dirPath)) {
+  if (!existsSync12(dirPath)) {
     return [];
   }
   const commands2 = [];
@@ -63143,7 +63393,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source) {
   try {
     const entries = await readdir7(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join18(currentPath, entry.name);
+      const fullPath = join19(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findCommandFiles(fullPath, rootPath, commands2, source);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -63228,7 +63478,7 @@ async function findCustomCommand(commandName) {
 }
 var COMMANDS_DIR = ".commands", GLOBAL_COMMANDS_DIR, cachedCommands = null;
 var init_custom = __esm(() => {
-  GLOBAL_COMMANDS_DIR = join18(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
+  GLOBAL_COMMANDS_DIR = join19(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
 });
 
 // src/cli/components/HelpDialog.tsx
@@ -66077,7 +66327,7 @@ var require_jsx_runtime = __commonJS((exports, module) => {
 
 // node_modules/supports-color/index.js
 import process19 from "node:process";
-import os4 from "node:os";
+import os5 from "node:os";
 import tty2 from "node:tty";
 function hasFlag2(flag, argv = globalThis.Deno ? globalThis.Deno.args : process19.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
@@ -66143,7 +66393,7 @@ function _supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process19.platform === "win32") {
-    const osRelease = os4.release().split(".");
+    const osRelease = os5.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -66498,21 +66748,21 @@ var init_AgentInfoBar = __esm(async () => {
 });
 
 // src/cli/helpers/fileSearch.ts
-import { readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
-import { join as join19, resolve as resolve19 } from "node:path";
+import { readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
+import { join as join20, resolve as resolve19 } from "node:path";
 function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = []) {
   if (results.length >= maxResults) {
     return results;
   }
   try {
-    const entries = readdirSync4(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") {
         continue;
       }
       try {
-        const fullPath = join19(dir, entry);
-        const stats = statSync3(fullPath);
+        const fullPath = join20(dir, entry);
+        const stats = statSync4(fullPath);
         const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
         const matches = pattern.length === 0 || relativePath.toLowerCase().includes(pattern.toLowerCase());
         if (matches) {
@@ -66544,7 +66794,7 @@ async function searchFiles(query, deep = false) {
       try {
         const resolvedDir = resolve19(process.cwd(), dirPart);
         try {
-          statSync3(resolvedDir);
+          statSync4(resolvedDir);
           searchDir = resolvedDir;
           searchPattern = pattern;
         } catch {}
@@ -66556,15 +66806,15 @@ async function searchFiles(query, deep = false) {
     } else {
       let entries = [];
       try {
-        entries = readdirSync4(searchDir);
+        entries = readdirSync5(searchDir);
       } catch {
         return [];
       }
       const matchingEntries = searchPattern.length === 0 ? entries : entries.filter((entry) => entry.toLowerCase().includes(searchPattern.toLowerCase()));
       for (const entry of matchingEntries.slice(0, 50)) {
         try {
-          const fullPath = join19(searchDir, entry);
-          const stats = statSync3(fullPath);
+          const fullPath = join20(searchDir, entry);
+          const stats = statSync4(fullPath);
           const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
           results.push({
             path: relativePath,
@@ -70679,7 +70929,7 @@ var init_PendingApprovalStub = __esm(async () => {
 });
 
 // src/cli/components/ReasoningMessageRich.tsx
-var import_react73, jsx_dev_runtime49, normalize5 = (s) => s.replace(/\r\n/g, `
+var import_react73, jsx_dev_runtime49, normalize6 = (s) => s.replace(/\r\n/g, `
 `).replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, `
 
 `).replace(/^\n+|\n+$/g, ""), ReasoningMessage;
@@ -70694,7 +70944,7 @@ var init_ReasoningMessageRich = __esm(async () => {
   ReasoningMessage = import_react73.memo(({ line }) => {
     const columns = useTerminalWidth();
     const contentWidth = Math.max(0, columns - 2);
-    const normalizedText = normalize5(line.text);
+    const normalizedText = normalize6(line.text);
     return /* @__PURE__ */ jsx_dev_runtime49.jsxDEV(Box_default, {
       flexDirection: "column",
       children: [
@@ -71654,8 +71904,8 @@ function MemoryDiffRenderer({
       }, undefined, false, undefined, this);
     }
     const command = args.command;
-    const path20 = args.path || args.old_path || "unknown";
-    const blockName = path20.split("/").pop() || path20;
+    const path21 = args.path || args.old_path || "unknown";
+    const blockName = path21.split("/").pop() || path21;
     switch (command) {
       case "str_replace": {
         const oldStr = args.old_string || args.old_str || "";
@@ -74198,9 +74448,9 @@ async function getLettaConfig2() {
   const apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY || "";
   return { baseUrl, apiKey };
 }
-async function providersRequest2(method, path20, body) {
+async function providersRequest2(method, path21, body) {
   const { baseUrl, apiKey } = await getLettaConfig2();
-  const url = `${baseUrl}${path20}`;
+  const url = `${baseUrl}${path21}`;
   const response = await fetch(url, {
     method,
     headers: {
@@ -74731,9 +74981,9 @@ var exports_App = {};
 __export(exports_App, {
   default: () => App2
 });
-import { existsSync as existsSync12, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { join as join21 } from "node:path";
 function uid4(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -74845,7 +75095,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 }
 function planFileExists() {
   const planFilePath = permissionMode.getPlanFilePath();
-  return !!planFilePath && existsSync12(planFilePath);
+  return !!planFilePath && existsSync13(planFilePath);
 }
 function getQuestionsFromApproval(approval) {
   const parsed = safeJsonParseOr(approval.toolArgs, {});
@@ -75003,6 +75253,20 @@ function App2({
   const [autoDeniedApprovals, setAutoDeniedApprovals] = import_react84.useState([]);
   const executingToolCallIdsRef = import_react84.useRef([]);
   const interruptQueuedRef = import_react84.useRef(false);
+  const toolResultsInFlightRef = import_react84.useRef(false);
+  const autoAllowedExecutionRef = import_react84.useRef(null);
+  const queuedApprovalMetadataRef = import_react84.useRef(null);
+  const queueApprovalResults = import_react84.useCallback((results, metadata) => {
+    setQueuedApprovalResults(results);
+    if (results) {
+      queuedApprovalMetadataRef.current = metadata ?? {
+        conversationId: conversationIdRef.current,
+        generation: conversationGenerationRef.current
+      };
+    } else {
+      queuedApprovalMetadataRef.current = null;
+    }
+  }, []);
   const bashCommandCacheRef = import_react84.useRef([]);
   const [pendingRalphConfig, setPendingRalphConfig] = import_react84.useState(null);
   const [uiRalphActive, setUiRalphActive] = import_react84.useState(ralphMode.getState().isActive);
@@ -75363,8 +75627,8 @@ function App2({
     if (!planFilePath)
       return;
     try {
-      const { readFileSync: readFileSync5, existsSync: existsSync13 } = __require("node:fs");
-      if (!existsSync13(planFilePath))
+      const { readFileSync: readFileSync5, existsSync: existsSync14 } = __require("node:fs");
+      if (!existsSync14(planFilePath))
         return;
       const planContent = readFileSync5(planFilePath, "utf-8");
       const previewItem = {
@@ -75794,7 +76058,7 @@ ${newState.originalPrompt}`
                 });
               }
               refreshDerived();
-              setQueuedApprovalResults(denialResults);
+              queueApprovalResults(denialResults);
               const concatenatedMessage = queueSnapshotRef.current.join(`
 `);
               setMessageQueue([]);
@@ -75902,36 +76166,48 @@ ${newState.originalPrompt}`
               }
             } catch {}
           }
-          setToolCallsRunning(buffersRef.current, autoAllowed.map((ac) => ac.approval.toolCallId));
-          refreshDerived();
-          const autoAllowedResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), {
-            abortSignal: signal,
-            onStreamingOutput: updateStreamingOutput
-          });
-          const autoDeniedResults = autoDenied.map((ac) => {
-            const reason = ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : ("matchedRule" in ac.permission) && ac.permission.matchedRule ? `Permission denied by rule: ${ac.permission.matchedRule}` : "Permission denied: Unknown reason";
-            onChunk(buffersRef.current, {
-              message_type: "tool_return_message",
-              id: "dummy",
-              date: new Date().toISOString(),
-              tool_call_id: ac.approval.toolCallId,
-              tool_return: `Error: request to call tool denied. User reason: ${reason}`,
-              status: "error",
-              stdout: null,
-              stderr: null
-            });
-            return {
-              approval: ac.approval,
-              reason
+          const autoAllowedToolCallIds = autoAllowed.map((ac) => ac.approval.toolCallId);
+          const autoAllowedAbortController = abortControllerRef.current ?? new AbortController;
+          const shouldTrackAutoAllowed = autoAllowedToolCallIds.length > 0;
+          let autoAllowedResults = [];
+          let autoDeniedResults = [];
+          if (shouldTrackAutoAllowed) {
+            setIsExecutingTool(true);
+            executingToolCallIdsRef.current = autoAllowedToolCallIds;
+            toolAbortControllerRef.current = autoAllowedAbortController;
+            autoAllowedExecutionRef.current = {
+              toolCallIds: autoAllowedToolCallIds,
+              results: null,
+              conversationId: conversationIdRef.current,
+              generation: conversationGenerationRef.current
             };
-          });
-          if (needsUserInput.length === 0) {
-            if (userCancelledRef.current || abortControllerRef.current?.signal.aborted) {
-              setStreaming(false);
-              markIncompleteToolsAsCancelled(buffersRef.current);
+          }
+          try {
+            if (autoAllowedToolCallIds.length > 0) {
+              setToolCallsRunning(buffersRef.current, autoAllowedToolCallIds);
               refreshDerived();
-              return;
             }
+            autoAllowedResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), {
+              abortSignal: autoAllowedAbortController.signal,
+              onStreamingOutput: updateStreamingOutput
+            }) : [];
+            autoDeniedResults = autoDenied.map((ac) => {
+              const reason = ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : ("matchedRule" in ac.permission) && ac.permission.matchedRule ? `Permission denied by rule: ${ac.permission.matchedRule}` : "Permission denied: Unknown reason";
+              onChunk(buffersRef.current, {
+                message_type: "tool_return_message",
+                id: "dummy",
+                date: new Date().toISOString(),
+                tool_call_id: ac.approval.toolCallId,
+                tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+                status: "error",
+                stdout: null,
+                stderr: null
+              });
+              return {
+                approval: ac.approval,
+                reason
+              };
+            });
             const allResults = [
               ...autoAllowedResults.map((ar) => ({
                 type: "tool",
@@ -75948,11 +76224,79 @@ ${newState.originalPrompt}`
                 reason: ad.reason
               }))
             ];
+            if (autoAllowedExecutionRef.current) {
+              autoAllowedExecutionRef.current.results = allResults;
+            }
+            const autoAllowedMetadata = autoAllowedExecutionRef.current ? {
+              conversationId: autoAllowedExecutionRef.current.conversationId,
+              generation: conversationGenerationRef.current
+            } : undefined;
+            if (needsUserInput.length === 0) {
+              if (userCancelledRef.current || abortControllerRef.current?.signal.aborted || interruptQueuedRef.current) {
+                if (allResults.length > 0) {
+                  queueApprovalResults(allResults, autoAllowedMetadata);
+                }
+                setStreaming(false);
+                markIncompleteToolsAsCancelled(buffersRef.current);
+                refreshDerived();
+                return;
+              }
+              if (waitingForQueueCancelRef.current) {
+                if (restoreQueueOnCancelRef.current) {
+                  setRestoreQueueOnCancel(false);
+                } else {
+                  if (allResults.length > 0) {
+                    queueApprovalResults(allResults, autoAllowedMetadata);
+                  }
+                  const concatenatedMessage = queueSnapshotRef.current.join(`
+`);
+                  setMessageQueue([]);
+                  if (concatenatedMessage.trim()) {
+                    onSubmitRef.current(concatenatedMessage);
+                  }
+                }
+                waitingForQueueCancelRef.current = false;
+                queueSnapshotRef.current = [];
+                setStreaming(false);
+                return;
+              }
+              setThinkingMessage(getRandomThinkingVerb());
+              refreshDerived();
+              toolResultsInFlightRef.current = true;
+              await processConversation([
+                {
+                  type: "approval",
+                  approvals: allResults
+                }
+              ], { allowReentry: true });
+              toolResultsInFlightRef.current = false;
+              return;
+            }
             if (waitingForQueueCancelRef.current) {
               if (restoreQueueOnCancelRef.current) {
                 setRestoreQueueOnCancel(false);
               } else {
-                setQueuedApprovalResults(allResults);
+                const denialResults = needsUserInput.map((ac) => ({
+                  type: "approval",
+                  tool_call_id: ac.approval.toolCallId,
+                  approve: false,
+                  reason: "User cancelled - new message queued"
+                }));
+                for (const ac of needsUserInput) {
+                  onChunk(buffersRef.current, {
+                    message_type: "tool_return_message",
+                    id: "dummy",
+                    date: new Date().toISOString(),
+                    tool_call_id: ac.approval.toolCallId,
+                    tool_return: "Cancelled - user sent new message",
+                    status: "error"
+                  });
+                }
+                refreshDerived();
+                const queuedResults = [...allResults, ...denialResults];
+                if (queuedResults.length > 0) {
+                  queueApprovalResults(queuedResults, autoAllowedMetadata);
+                }
                 const concatenatedMessage = queueSnapshotRef.current.join(`
 `);
                 setMessageQueue([]);
@@ -75965,64 +76309,14 @@ ${newState.originalPrompt}`
               setStreaming(false);
               return;
             }
-            setThinkingMessage(getRandomThinkingVerb());
-            refreshDerived();
-            await processConversation([
-              {
-                type: "approval",
-                approvals: allResults
-              }
-            ], { allowReentry: true });
-            return;
-          }
-          if (waitingForQueueCancelRef.current) {
-            if (restoreQueueOnCancelRef.current) {
-              setRestoreQueueOnCancel(false);
-            } else {
-              const denialResults = needsUserInput.map((ac) => ({
-                type: "approval",
-                tool_call_id: ac.approval.toolCallId,
-                approve: false,
-                reason: "User cancelled - new message queued"
-              }));
-              for (const ac of needsUserInput) {
-                onChunk(buffersRef.current, {
-                  message_type: "tool_return_message",
-                  id: "dummy",
-                  date: new Date().toISOString(),
-                  tool_call_id: ac.approval.toolCallId,
-                  tool_return: "Cancelled - user sent new message",
-                  status: "error"
-                });
-              }
-              refreshDerived();
-              const allResults = [
-                ...autoAllowedResults.map((ar) => ({
-                  type: "tool",
-                  tool_call_id: ar.toolCallId,
-                  tool_return: ar.result.toolReturn,
-                  status: ar.result.status
-                })),
-                ...autoDeniedResults.map((ad) => ({
-                  type: "approval",
-                  tool_call_id: ad.approval.toolCallId,
-                  approve: false,
-                  reason: ad.reason
-                })),
-                ...denialResults
-              ];
-              setQueuedApprovalResults(allResults);
-              const concatenatedMessage = queueSnapshotRef.current.join(`
-`);
-              setMessageQueue([]);
-              if (concatenatedMessage.trim()) {
-                onSubmitRef.current(concatenatedMessage);
-              }
+          } finally {
+            if (shouldTrackAutoAllowed) {
+              setIsExecutingTool(false);
+              toolAbortControllerRef.current = null;
+              executingToolCallIdsRef.current = [];
+              autoAllowedExecutionRef.current = null;
+              toolResultsInFlightRef.current = false;
             }
-            waitingForQueueCancelRef.current = false;
-            queueSnapshotRef.current = [];
-            setStreaming(false);
-            return;
           }
           if (userCancelledRef.current || abortControllerRef.current?.signal.aborted) {
             setStreaming(false);
@@ -76094,33 +76388,11 @@ ${newState.originalPrompt}`
         const approvalPendingDetected = isApprovalPendingError(detailFromRun) || isApprovalPendingError(latestErrorText);
         if (!hasApprovalInPayload && approvalPendingDetected && llmApiErrorRetriesRef.current < LLM_API_ERROR_MAX_RETRIES2) {
           llmApiErrorRetriesRef.current += 1;
-          const statusId = uid4("status");
-          buffersRef.current.byId.set(statusId, {
-            kind: "status",
-            id: statusId,
-            lines: [
-              "[LAZY RECOVERY] Detected CONFLICT: server has pending approval",
-              "[LAZY RECOVERY] Fetching stale approvals to auto-deny..."
-            ]
-          });
-          buffersRef.current.order.push(statusId);
-          refreshDerived();
           try {
             const client = await getClient2();
             const agent = await client.agents.retrieve(agentIdRef.current);
             const { pendingApprovals: existingApprovals } = await getResumeData2(client, agent, conversationIdRef.current);
             if (existingApprovals && existingApprovals.length > 0) {
-              buffersRef.current.byId.set(statusId, {
-                kind: "status",
-                id: statusId,
-                lines: [
-                  "[LAZY RECOVERY] Detected CONFLICT: server has pending approval",
-                  `[LAZY RECOVERY] Found ${existingApprovals.length} stale approval(s):`,
-                  ...existingApprovals.map((a) => `  - ${a.toolName} (${a.toolCallId.slice(0, 8)}...)`),
-                  "[LAZY RECOVERY] Auto-denying and batching with user message..."
-                ]
-              });
-              refreshDerived();
               const denialResults = existingApprovals.map((approval2) => ({
                 type: "approval",
                 tool_call_id: approval2.toolCallId,
@@ -76132,32 +76404,8 @@ ${newState.originalPrompt}`
                 approvals: denialResults
               };
               currentInput.unshift(approvalPayload);
-            } else {
-              buffersRef.current.byId.set(statusId, {
-                kind: "status",
-                id: statusId,
-                lines: [
-                  "[LAZY RECOVERY] Detected CONFLICT but no pending approvals found",
-                  "[LAZY RECOVERY] Retrying message..."
-                ]
-              });
-              refreshDerived();
             }
-          } catch (_recoveryError) {
-            buffersRef.current.byId.set(statusId, {
-              kind: "status",
-              id: statusId,
-              lines: [
-                "[LAZY RECOVERY] Failed to fetch pending approvals",
-                "[LAZY RECOVERY] Retrying message anyway..."
-              ]
-            });
-            refreshDerived();
-          }
-          await new Promise((resolve20) => setTimeout(resolve20, 500));
-          buffersRef.current.byId.delete(statusId);
-          buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
-          refreshDerived();
+          } catch {}
           buffersRef.current.interrupted = false;
           continue;
         }
@@ -76276,7 +76524,8 @@ ${newState.originalPrompt}`
     setStreaming,
     currentModelId,
     updateStreamingOutput,
-    needsEagerApprovalCheck
+    needsEagerApprovalCheck,
+    queueApprovalResults
   ]);
   const handleExit = import_react84.useCallback(async () => {
     saveLastAgentBeforeExit();
@@ -76292,19 +76541,31 @@ ${newState.originalPrompt}`
     setMessageQueue([]);
   }, []);
   const handleInterrupt = import_react84.useCallback(async () => {
-    if (isExecutingTool && toolAbortControllerRef.current) {
+    const hasTrackedTools = executingToolCallIdsRef.current.length > 0 || autoAllowedExecutionRef.current?.results;
+    if (isExecutingTool && toolAbortControllerRef.current && hasTrackedTools && !toolResultsInFlightRef.current) {
       toolAbortControllerRef.current.abort();
-      if (executingToolCallIdsRef.current.length > 0) {
+      conversationGenerationRef.current += 1;
+      processingConversationRef.current = 0;
+      const autoAllowedResults = autoAllowedExecutionRef.current?.results;
+      const autoAllowedMetadata = autoAllowedExecutionRef.current ? {
+        conversationId: autoAllowedExecutionRef.current.conversationId,
+        generation: conversationGenerationRef.current
+      } : undefined;
+      if (autoAllowedResults && autoAllowedResults.length > 0) {
+        queueApprovalResults(autoAllowedResults, autoAllowedMetadata);
+        interruptQueuedRef.current = true;
+      } else if (executingToolCallIdsRef.current.length > 0) {
         const interruptedResults = executingToolCallIdsRef.current.map((toolCallId) => ({
           type: "tool",
           tool_call_id: toolCallId,
           tool_return: INTERRUPTED_BY_USER,
           status: "error"
         }));
-        setQueuedApprovalResults(interruptedResults);
-        executingToolCallIdsRef.current = [];
+        queueApprovalResults(interruptedResults);
         interruptQueuedRef.current = true;
       }
+      executingToolCallIdsRef.current = [];
+      autoAllowedExecutionRef.current = null;
       buffersRef.current.abortGeneration = (buffersRef.current.abortGeneration || 0) + 1;
       const toolsCancelled = markIncompleteToolsAsCancelled(buffersRef.current);
       interruptActiveSubagents(INTERRUPTED_BY_USER);
@@ -76318,6 +76579,7 @@ ${newState.originalPrompt}`
       userCancelledRef.current = true;
       setStreaming(false);
       setIsExecutingTool(false);
+      toolResultsInFlightRef.current = false;
       refreshDerived();
       setTimeout(() => {
         userCancelledRef.current = false;
@@ -76343,18 +76605,38 @@ ${newState.originalPrompt}`
       conversationGenerationRef.current += 1;
       processingConversationRef.current = 0;
       setStreaming(false);
+      toolResultsInFlightRef.current = false;
       if (!toolsCancelled) {
         appendError(INTERRUPT_MESSAGE, true);
       }
       refreshDerived();
-      if (pendingApprovals.length > 0) {
-        const denialResults = pendingApprovals.map((approval) => ({
+      const denialResults = pendingApprovals.map((approval) => ({
+        type: "approval",
+        tool_call_id: approval.toolCallId,
+        approve: false,
+        reason: "User interrupted the stream"
+      }));
+      const autoHandledSnapshot = [...autoHandledResults];
+      const autoDeniedSnapshot = [...autoDeniedApprovals];
+      const queuedResults = [
+        ...autoHandledSnapshot.map((ar) => ({
+          type: "tool",
+          tool_call_id: ar.toolCallId,
+          tool_return: ar.result.toolReturn,
+          status: ar.result.status,
+          stdout: ar.result.stdout,
+          stderr: ar.result.stderr
+        })),
+        ...autoDeniedSnapshot.map((ad) => ({
           type: "approval",
-          tool_call_id: approval.toolCallId,
+          tool_call_id: ad.approval.toolCallId,
           approve: false,
-          reason: "User interrupted the stream"
-        }));
-        setQueuedApprovalResults(denialResults);
+          reason: ad.reason
+        })),
+        ...denialResults
+      ];
+      if (queuedResults.length > 0) {
+        queueApprovalResults(queuedResults);
       }
       setPendingApprovals([]);
       setApprovalContexts([]);
@@ -76389,7 +76671,10 @@ ${newState.originalPrompt}`
     isExecutingTool,
     refreshDerived,
     setStreaming,
-    pendingApprovals
+    pendingApprovals,
+    autoHandledResults,
+    autoDeniedApprovals,
+    queueApprovalResults
   ]);
   const processConversationRef = import_react84.useRef(processConversation);
   import_react84.useEffect(() => {
@@ -76671,42 +76956,85 @@ ${newState.originalPrompt}`
         return { blocked: true };
       }
       const allResults = [];
-      if (autoAllowed.length > 0) {
-        setToolCallsRunning(buffersRef.current, autoAllowed.map((ac) => ac.approval.toolCallId));
-        refreshDerived();
-        const autoAllowedResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), { onStreamingOutput: updateStreamingOutput });
-        allResults.push(...autoAllowedResults.map((ar) => ({
-          type: "tool",
-          tool_call_id: ar.toolCallId,
-          tool_return: ar.result.toolReturn,
-          status: ar.result.status,
-          stdout: ar.result.stdout,
-          stderr: ar.result.stderr
-        })));
-      }
-      for (const ac of autoDenied) {
-        const reason = ac.permission.reason || "Permission denied";
-        onChunk(buffersRef.current, {
-          message_type: "tool_return_message",
-          id: "dummy",
-          date: new Date().toISOString(),
-          tool_call_id: ac.approval.toolCallId,
-          tool_return: `Error: request to call tool denied. User reason: ${reason}`,
-          status: "error",
-          stdout: null,
-          stderr: null
-        });
-        allResults.push({
-          type: "approval",
-          tool_call_id: ac.approval.toolCallId,
-          approve: false,
-          reason
-        });
+      const autoAllowedToolCallIds = autoAllowed.map((ac) => ac.approval.toolCallId);
+      const autoAllowedAbortController = abortControllerRef.current ?? new AbortController;
+      const shouldTrackAutoAllowed = autoAllowedToolCallIds.length > 0;
+      let autoAllowedResults = [];
+      if (shouldTrackAutoAllowed) {
+        setIsExecutingTool(true);
+        executingToolCallIdsRef.current = autoAllowedToolCallIds;
+        toolAbortControllerRef.current = autoAllowedAbortController;
+        autoAllowedExecutionRef.current = {
+          toolCallIds: autoAllowedToolCallIds,
+          results: null,
+          conversationId: conversationIdRef.current,
+          generation: conversationGenerationRef.current
+        };
       }
-      if (allResults.length > 0) {
-        await processConversation([
-          { type: "approval", approvals: allResults }
-        ]);
+      try {
+        if (autoAllowed.length > 0) {
+          setToolCallsRunning(buffersRef.current, autoAllowedToolCallIds);
+          refreshDerived();
+          autoAllowedResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), {
+            abortSignal: autoAllowedAbortController.signal,
+            onStreamingOutput: updateStreamingOutput
+          });
+          allResults.push(...autoAllowedResults.map((ar) => ({
+            type: "tool",
+            tool_call_id: ar.toolCallId,
+            tool_return: ar.result.toolReturn,
+            status: ar.result.status,
+            stdout: ar.result.stdout,
+            stderr: ar.result.stderr
+          })));
+        }
+        for (const ac of autoDenied) {
+          const reason = ac.permission.reason || "Permission denied";
+          onChunk(buffersRef.current, {
+            message_type: "tool_return_message",
+            id: "dummy",
+            date: new Date().toISOString(),
+            tool_call_id: ac.approval.toolCallId,
+            tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+            status: "error",
+            stdout: null,
+            stderr: null
+          });
+          allResults.push({
+            type: "approval",
+            tool_call_id: ac.approval.toolCallId,
+            approve: false,
+            reason
+          });
+        }
+        if (autoAllowedExecutionRef.current) {
+          autoAllowedExecutionRef.current.results = allResults;
+        }
+        const autoAllowedMetadata = autoAllowedExecutionRef.current ? {
+          conversationId: autoAllowedExecutionRef.current.conversationId,
+          generation: conversationGenerationRef.current
+        } : undefined;
+        if (userCancelledRef.current || autoAllowedAbortController.signal.aborted || interruptQueuedRef.current) {
+          if (allResults.length > 0) {
+            queueApprovalResults(allResults, autoAllowedMetadata);
+          }
+          return { blocked: false };
+        }
+        if (allResults.length > 0) {
+          toolResultsInFlightRef.current = true;
+          await processConversation([
+            { type: "approval", approvals: allResults }
+          ]);
+          toolResultsInFlightRef.current = false;
+        }
+      } finally {
+        if (shouldTrackAutoAllowed) {
+          setIsExecutingTool(false);
+          toolAbortControllerRef.current = null;
+          executingToolCallIdsRef.current = [];
+          autoAllowedExecutionRef.current = null;
+          toolResultsInFlightRef.current = false;
+        }
       }
       return { blocked: false };
     } catch {
@@ -76717,7 +77045,8 @@ ${newState.originalPrompt}`
     processConversation,
     refreshDerived,
     updateStreamingOutput,
-    needsEagerApprovalCheck
+    needsEagerApprovalCheck,
+    queueApprovalResults
   ]);
   const onSubmit = import_react84.useCallback(async (message) => {
     const msg = message?.trim() ?? "";
@@ -77687,7 +78016,7 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
           const client = await getClient2();
           const fileContent = await client.agents.exportFile(agentId);
           const fileName = `${agentId}.af`;
-          writeFileSync3(fileName, JSON.stringify(fileContent, null, 2));
+          writeFileSync4(fileName, JSON.stringify(fileContent, null, 2));
           buffersRef.current.byId.set(cmdId2, {
             kind: "command",
             id: cmdId2,
@@ -78267,52 +78596,112 @@ DO NOT respond to these messages or otherwise consider them in your response unl
                 }
               } catch {}
             }
-            setToolCallsRunning(buffersRef.current, autoAllowed.map((ac) => ac.approval.toolCallId));
-            refreshDerived();
-            const autoAllowedResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), { onStreamingOutput: updateStreamingOutput });
-            const autoDeniedResults = autoDenied.map((ac) => {
-              const reason = ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : ("matchedRule" in ac.permission) && ac.permission.matchedRule ? `Permission denied by rule: ${ac.permission.matchedRule}` : "Permission denied: Unknown";
-              onChunk(buffersRef.current, {
-                message_type: "tool_return_message",
-                id: "dummy",
-                date: new Date().toISOString(),
-                tool_call_id: ac.approval.toolCallId,
-                tool_return: `Error: request to call tool denied. User reason: ${reason}`,
-                status: "error",
-                stdout: null,
-                stderr: null
-              });
-              return {
-                type: "approval",
-                tool_call_id: ac.approval.toolCallId,
-                approve: false,
-                reason
+            const autoAllowedToolCallIds = autoAllowed.map((ac) => ac.approval.toolCallId);
+            const autoAllowedAbortController = abortControllerRef.current ?? new AbortController;
+            const shouldTrackAutoAllowed = autoAllowedToolCallIds.length > 0;
+            let autoAllowedResults = [];
+            let autoDeniedResults = [];
+            if (shouldTrackAutoAllowed) {
+              setIsExecutingTool(true);
+              executingToolCallIdsRef.current = autoAllowedToolCallIds;
+              toolAbortControllerRef.current = autoAllowedAbortController;
+              autoAllowedExecutionRef.current = {
+                toolCallIds: autoAllowedToolCallIds,
+                results: null,
+                conversationId: conversationIdRef.current,
+                generation: conversationGenerationRef.current
               };
-            });
-            refreshDerived();
-            const recoveryApprovalResults = [
-              ...autoAllowedResults.map((ar) => ({
-                type: "approval",
-                tool_call_id: ar.toolCallId,
-                approve: true,
-                tool_return: ar.result.toolReturn
-              })),
-              ...autoDeniedResults
-            ];
-            const initialInput2 = [
-              {
-                type: "approval",
-                approvals: recoveryApprovalResults
-              },
-              {
-                type: "message",
-                role: "user",
-                content: messageContent
+            }
+            try {
+              if (autoAllowedToolCallIds.length > 0) {
+                setToolCallsRunning(buffersRef.current, autoAllowedToolCallIds);
+                refreshDerived();
               }
-            ];
-            await processConversation(initialInput2);
-            clearPlaceholdersInText(msg);
-            return { submitted: true };
+              autoAllowedResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), {
+                abortSignal: autoAllowedAbortController.signal,
+                onStreamingOutput: updateStreamingOutput
+              }) : [];
+              autoDeniedResults = autoDenied.map((ac) => {
+                const reason = ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : ("matchedRule" in ac.permission) && ac.permission.matchedRule ? `Permission denied by rule: ${ac.permission.matchedRule}` : "Permission denied: Unknown";
+                onChunk(buffersRef.current, {
+                  message_type: "tool_return_message",
+                  id: "dummy",
+                  date: new Date().toISOString(),
+                  tool_call_id: ac.approval.toolCallId,
+                  tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+                  status: "error",
+                  stdout: null,
+                  stderr: null
+                });
+                return {
+                  type: "approval",
+                  tool_call_id: ac.approval.toolCallId,
+                  approve: false,
+                  reason
+                };
+              });
+              const queuedResults = [
+                ...autoAllowedResults.map((ar) => ({
+                  type: "tool",
+                  tool_call_id: ar.toolCallId,
+                  tool_return: ar.result.toolReturn,
+                  status: ar.result.status,
+                  stdout: ar.result.stdout,
+                  stderr: ar.result.stderr
+                })),
+                ...autoDeniedResults
+              ];
+              if (autoAllowedExecutionRef.current) {
+                autoAllowedExecutionRef.current.results = queuedResults;
+              }
+              const autoAllowedMetadata = autoAllowedExecutionRef.current ? {
+                conversationId: autoAllowedExecutionRef.current.conversationId,
+                generation: conversationGenerationRef.current
+              } : undefined;
+              if (userCancelledRef.current || autoAllowedAbortController.signal.aborted || interruptQueuedRef.current) {
+                if (queuedResults.length > 0) {
+                  queueApprovalResults(queuedResults, autoAllowedMetadata);
+                }
+                setStreaming(false);
+                markIncompleteToolsAsCancelled(buffersRef.current);
+                refreshDerived();
+                return { submitted: false };
+              }
+              refreshDerived();
+              const recoveryApprovalResults = [
+                ...autoAllowedResults.map((ar) => ({
+                  type: "approval",
+                  tool_call_id: ar.toolCallId,
+                  approve: true,
+                  tool_return: ar.result.toolReturn
+                })),
+                ...autoDeniedResults
+              ];
+              const initialInput2 = [
+                {
+                  type: "approval",
+                  approvals: recoveryApprovalResults
+                },
+                {
+                  type: "message",
+                  role: "user",
+                  content: messageContent
+                }
+              ];
+              toolResultsInFlightRef.current = true;
+              await processConversation(initialInput2);
+              toolResultsInFlightRef.current = false;
+              clearPlaceholdersInText(msg);
+              return { submitted: true };
+            } finally {
+              if (shouldTrackAutoAllowed) {
+                setIsExecutingTool(false);
+                toolAbortControllerRef.current = null;
+                executingToolCallIdsRef.current = [];
+                autoAllowedExecutionRef.current = null;
+                toolResultsInFlightRef.current = false;
+              }
+            }
           } else {
             buffersRef.current.byId.delete(userId);
             const orderIndex = buffersRef.current.order.indexOf(userId);
@@ -78378,39 +78767,105 @@ DO NOT respond to these messages or otherwise consider them in your response unl
                 }
               } catch {}
             }
-            const autoAllowedWithResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), { onStreamingOutput: updateStreamingOutput });
-            const autoDeniedWithReasons = autoDenied.map((ac) => {
-              const reason = ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : ("matchedRule" in ac.permission) && ac.permission.matchedRule ? `Permission denied by rule: ${ac.permission.matchedRule}` : "Permission denied: Unknown";
-              onChunk(buffersRef.current, {
-                message_type: "tool_return_message",
-                id: "dummy",
-                date: new Date().toISOString(),
-                tool_call_id: ac.approval.toolCallId,
-                tool_return: `Error: request to call tool denied. User reason: ${reason}`,
-                status: "error",
-                stdout: null,
-                stderr: null
-              });
-              return {
-                approval: ac.approval,
-                reason
+            const autoAllowedToolCallIds = autoAllowed.map((ac) => ac.approval.toolCallId);
+            const autoAllowedAbortController = abortControllerRef.current ?? new AbortController;
+            const shouldTrackAutoAllowed = autoAllowedToolCallIds.length > 0;
+            let autoAllowedWithResults = [];
+            let autoDeniedWithReasons = [];
+            if (shouldTrackAutoAllowed) {
+              setIsExecutingTool(true);
+              executingToolCallIdsRef.current = autoAllowedToolCallIds;
+              toolAbortControllerRef.current = autoAllowedAbortController;
+              autoAllowedExecutionRef.current = {
+                toolCallIds: autoAllowedToolCallIds,
+                results: null,
+                conversationId: conversationIdRef.current,
+                generation: conversationGenerationRef.current
               };
-            });
-            setAutoHandledResults(autoAllowedWithResults);
-            setAutoDeniedApprovals(autoDeniedWithReasons);
-            refreshDerived();
-            return { submitted: false };
+            }
+            try {
+              autoAllowedWithResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk), {
+                abortSignal: autoAllowedAbortController.signal,
+                onStreamingOutput: updateStreamingOutput
+              }) : [];
+              autoDeniedWithReasons = autoDenied.map((ac) => {
+                const reason = ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : ("matchedRule" in ac.permission) && ac.permission.matchedRule ? `Permission denied by rule: ${ac.permission.matchedRule}` : "Permission denied: Unknown";
+                onChunk(buffersRef.current, {
+                  message_type: "tool_return_message",
+                  id: "dummy",
+                  date: new Date().toISOString(),
+                  tool_call_id: ac.approval.toolCallId,
+                  tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+                  status: "error",
+                  stdout: null,
+                  stderr: null
+                });
+                return {
+                  approval: ac.approval,
+                  reason
+                };
+              });
+              const queuedResults = [
+                ...autoAllowedWithResults.map((ar) => ({
+                  type: "tool",
+                  tool_call_id: ar.toolCallId,
+                  tool_return: ar.result.toolReturn,
+                  status: ar.result.status,
+                  stdout: ar.result.stdout,
+                  stderr: ar.result.stderr
+                })),
+                ...autoDeniedWithReasons.map((ad) => ({
+                  type: "approval",
+                  tool_call_id: ad.approval.toolCallId,
+                  approve: false,
+                  reason: ad.reason
+                }))
+              ];
+              if (autoAllowedExecutionRef.current) {
+                autoAllowedExecutionRef.current.results = queuedResults;
+              }
+              const autoAllowedMetadata = autoAllowedExecutionRef.current ? {
+                conversationId: autoAllowedExecutionRef.current.conversationId,
+                generation: conversationGenerationRef.current
+              } : undefined;
+              if (userCancelledRef.current || autoAllowedAbortController.signal.aborted || interruptQueuedRef.current) {
+                if (queuedResults.length > 0) {
+                  queueApprovalResults(queuedResults, autoAllowedMetadata);
+                }
+                setStreaming(false);
+                markIncompleteToolsAsCancelled(buffersRef.current);
+                refreshDerived();
+                return { submitted: false };
+              }
+              setAutoHandledResults(autoAllowedWithResults);
+              setAutoDeniedApprovals(autoDeniedWithReasons);
+              refreshDerived();
+              return { submitted: false };
+            } finally {
+              if (shouldTrackAutoAllowed) {
+                setIsExecutingTool(false);
+                toolAbortControllerRef.current = null;
+                executingToolCallIdsRef.current = [];
+                autoAllowedExecutionRef.current = null;
+              }
+            }
           }
         }
       } catch (_error) {}
     }
     const initialInput = [];
     if (queuedApprovalResults) {
-      initialInput.push({
-        type: "approval",
-        approvals: queuedApprovalResults
-      });
-      setQueuedApprovalResults(null);
+      const queuedMetadata = queuedApprovalMetadataRef.current;
+      const isQueuedValid = queuedMetadata && queuedMetadata.conversationId === conversationIdRef.current && queuedMetadata.generation === conversationGenerationRef.current;
+      if (isQueuedValid) {
+        initialInput.push({
+          type: "approval",
+          approvals: queuedApprovalResults
+        });
+      } else {
+        console.warn("[WARN] Dropping stale queued approval results for mismatched conversation or generation");
+      }
+      queueApprovalResults(null);
       interruptQueuedRef.current = false;
     }
     initialInput.push({
@@ -78433,6 +78888,7 @@ DO NOT respond to these messages or otherwise consider them in your response unl
     handleExit,
     isExecutingTool,
     queuedApprovalResults,
+    queueApprovalResults,
     pendingApprovals,
     profileConfirmPending,
     handleAgentSelect,
@@ -78544,24 +79000,27 @@ DO NOT respond to these messages or otherwise consider them in your response unl
       const userCancelled = userCancelledRef.current;
       if (wasAborted || userCancelled) {
         if (!interruptQueuedRef.current) {
-          setQueuedApprovalResults(allResults);
+          queueApprovalResults(allResults);
         }
         setStreaming(false);
         waitingForQueueCancelRef.current = false;
         queueSnapshotRef.current = [];
       } else {
+        toolResultsInFlightRef.current = true;
         await processConversation([
           {
             type: "approval",
             approvals: allResults
           }
         ]);
+        toolResultsInFlightRef.current = false;
       }
     } finally {
       setIsExecutingTool(false);
       toolAbortControllerRef.current = null;
       executingToolCallIdsRef.current = [];
       interruptQueuedRef.current = false;
+      toolResultsInFlightRef.current = false;
     }
   }, [
     approvalResults,
@@ -78572,7 +79031,8 @@ DO NOT respond to these messages or otherwise consider them in your response unl
     refreshDerived,
     appendError,
     setStreaming,
-    updateStreamingOutput
+    updateStreamingOutput,
+    queueApprovalResults
   ]);
   const handleApproveCurrent = import_react84.useCallback(async (diffs) => {
     if (isExecutingTool)
@@ -78770,7 +79230,7 @@ DO NOT respond to these messages or otherwise consider them in your response unl
       approve: false,
       reason: "User cancelled the approval"
     }));
-    setQueuedApprovalResults(denialResults);
+    queueApprovalResults(denialResults);
     markIncompleteToolsAsCancelled(buffersRef.current);
     refreshDerived();
     setPendingApprovals([]);
@@ -78778,7 +79238,7 @@ DO NOT respond to these messages or otherwise consider them in your response unl
     setApprovalResults([]);
     setAutoHandledResults([]);
     setAutoDeniedApprovals([]);
-  }, [pendingApprovals, refreshDerived]);
+  }, [pendingApprovals, refreshDerived, queueApprovalResults]);
   const handleModelSelect = import_react84.useCallback(async (modelId) => {
     await withCommandLock(async () => {
       let cmdId = null;
@@ -79160,7 +79620,7 @@ Consider switching to a different system prompt using /system to match.` : null;
             reason: "Plan mode session expired (CLI restarted). Use EnterPlanMode to re-enter plan mode, or request the user to re-enter plan mode."
           }
         ];
-        setQueuedApprovalResults(denialResults);
+        queueApprovalResults(denialResults);
         markIncompleteToolsAsCancelled(buffersRef.current);
         refreshDerived();
         setPendingApprovals([]);
@@ -79172,7 +79632,7 @@ Consider switching to a different system prompt using /system to match.` : null;
       }
       if (!planFileExists()) {
         const planFilePath = permissionMode.getPlanFilePath();
-        const plansDir = join20(homedir11(), ".letta", "plans");
+        const plansDir = join21(homedir12(), ".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.`);
@@ -79182,7 +79642,8 @@ Consider switching to a different system prompt using /system to match.` : null;
     pendingApprovals,
     approvalResults.length,
     handlePlanKeepPlanning,
-    refreshDerived
+    refreshDerived,
+    queueApprovalResults
   ]);
   const handleQuestionSubmit = import_react84.useCallback(async (answers) => {
     const currentIndex = approvalResults.length;
@@ -80043,13 +80504,13 @@ __export(exports_terminalKeybindingInstaller2, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync6,
   readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { homedir as homedir12, platform as platform5 } from "node:os";
-import { dirname as dirname12, join as join21 } from "node:path";
+import { homedir as homedir13, platform as platform5 } from "node:os";
+import { dirname as dirname12, join as join22 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -80079,18 +80540,18 @@ function getKeybindingsPath2(terminal) {
     cursor: "Cursor",
     windsurf: "Windsurf"
   }[terminal];
-  const os5 = platform5();
-  if (os5 === "darwin") {
-    return join21(homedir12(), "Library", "Application Support", appName, "User", "keybindings.json");
+  const os6 = platform5();
+  if (os6 === "darwin") {
+    return join22(homedir13(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
-  if (os5 === "win32") {
+  if (os6 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join21(appData, appName, "User", "keybindings.json");
+    return join22(appData, appName, "User", "keybindings.json");
   }
-  if (os5 === "linux") {
-    return join21(homedir12(), ".config", appName, "User", "keybindings.json");
+  if (os6 === "linux") {
+    return join22(homedir13(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -80112,7 +80573,7 @@ function parseKeybindings2(content) {
   }
 }
 function keybindingExists2(keybindingsPath) {
-  if (!existsSync13(keybindingsPath))
+  if (!existsSync14(keybindingsPath))
     return false;
   try {
     const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
@@ -80125,7 +80586,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync13(keybindingsPath))
+  if (!existsSync14(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -80141,12 +80602,12 @@ function installKeybinding2(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname12(keybindingsPath);
-    if (!existsSync13(parentDir)) {
-      mkdirSync5(parentDir, { recursive: true });
+    if (!existsSync14(parentDir)) {
+      mkdirSync6(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync13(keybindingsPath)) {
+    if (existsSync14(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
       const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
@@ -80161,7 +80622,7 @@ function installKeybinding2(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING2);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync4(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync5(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -80176,7 +80637,7 @@ function installKeybinding2(keybindingsPath) {
 }
 function removeKeybinding2(keybindingsPath) {
   try {
-    if (!existsSync13(keybindingsPath)) {
+    if (!existsSync14(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
@@ -80190,7 +80651,7 @@ function removeKeybinding2(keybindingsPath) {
     const filtered = keybindings.filter((kb) => !(kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus")));
     const newContent = `${JSON.stringify(filtered, null, 2)}
 `;
-    writeFileSync4(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync5(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -80208,14 +80669,14 @@ function installKeybindingForCurrentTerminal2() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path20 = getKeybindingsPath2(terminal);
-  if (!path20) {
+  const path21 = getKeybindingsPath2(terminal);
+  if (!path21) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return installKeybinding2(path20);
+  return installKeybinding2(path21);
 }
 function removeKeybindingForCurrentTerminal2() {
   const terminal = detectTerminalType2();
@@ -80225,14 +80686,14 @@ function removeKeybindingForCurrentTerminal2() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path20 = getKeybindingsPath2(terminal);
-  if (!path20) {
+  const path21 = getKeybindingsPath2(terminal);
+  if (!path21) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return removeKeybinding2(path20);
+  return removeKeybinding2(path21);
 }
 function isWezTerm2() {
   return process.env.TERM_PROGRAM === "WezTerm";
@@ -80243,17 +80704,17 @@ function getWezTermConfigPath2() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join21(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync13(xdgPath))
+    const xdgPath = join22(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync14(xdgPath))
       return xdgPath;
   }
-  const configPath = join21(homedir12(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync13(configPath))
+  const configPath = join22(homedir13(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync14(configPath))
     return configPath;
-  return join21(homedir12(), ".wezterm.lua");
+  return join22(homedir13(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists2(configPath) {
-  if (!existsSync13(configPath))
+  if (!existsSync14(configPath))
     return false;
   try {
     const content = readFileSync5(configPath, { encoding: "utf-8" });
@@ -80270,7 +80731,7 @@ function installWezTermDeleteFix2() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync13(configPath)) {
+    if (existsSync14(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync2(configPath, backupPath);
       content = readFileSync5(configPath, { encoding: "utf-8" });
@@ -80300,10 +80761,10 @@ ${WEZTERM_DELETE_FIX2}
 `;
     }
     const parentDir = dirname12(configPath);
-    if (!existsSync13(parentDir)) {
-      mkdirSync5(parentDir, { recursive: true });
+    if (!existsSync14(parentDir)) {
+      mkdirSync6(parentDir, { recursive: true });
     }
-    writeFileSync4(configPath, content, { encoding: "utf-8" });
+    writeFileSync5(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -80348,10 +80809,10 @@ __export(exports_settings2, {
   loadProjectSettings: () => loadProjectSettings2,
   getSetting: () => getSetting2
 });
-import { homedir as homedir13 } from "node:os";
-import { join as join22 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join23 } from "node:path";
 function getSettingsPath2() {
-  return join22(homedir13(), ".letta", "settings.json");
+  return join23(homedir14(), ".letta", "settings.json");
 }
 async function loadSettings2() {
   const settingsPath = getSettingsPath2();
@@ -80388,7 +80849,7 @@ async function getSetting2(key) {
   return settings[key];
 }
 function getProjectSettingsPath2() {
-  return join22(process.cwd(), ".letta", "settings.local.json");
+  return join23(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings2() {
   const settingsPath = getProjectSettingsPath2();
@@ -80406,7 +80867,7 @@ async function loadProjectSettings2() {
 }
 async function saveProjectSettings2(settings) {
   const settingsPath = getProjectSettingsPath2();
-  const dirPath = join22(process.cwd(), ".letta");
+  const dirPath = join23(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -80485,8 +80946,8 @@ var exports_create = {};
 __export(exports_create, {
   createAgent: () => createAgent2
 });
-import { join as join23 } from "node:path";
-async function createAgent2(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingModel = "openai/text-embedding-3-small", updateArgs, skillsDirectory, parallelToolCalls = true, enableSleeptime = false, systemPromptPreset, initBlocks, baseTools) {
+import { join as join24 } from "node:path";
+async function createAgent2(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingModel, updateArgs, skillsDirectory, parallelToolCalls = true, enableSleeptime = false, systemPromptPreset, initBlocks, baseTools) {
   let options;
   if (typeof nameOrOptions === "object") {
     options = nameOrOptions;
@@ -80505,7 +80966,7 @@ async function createAgent2(nameOrOptions = DEFAULT_AGENT_NAME, model, embedding
     };
   }
   const name = options.name ?? DEFAULT_AGENT_NAME;
-  const embeddingModelVal = options.embeddingModel ?? "openai/text-embedding-3-small";
+  const embeddingModelVal = options.embeddingModel;
   const parallelToolCallsVal = options.parallelToolCalls ?? true;
   const enableSleeptimeVal = options.enableSleeptime ?? false;
   let modelHandle;
@@ -80580,7 +81041,7 @@ async function createAgent2(nameOrOptions = DEFAULT_AGENT_NAME, model, embedding
       }
     }
   }
-  const resolvedSkillsDirectory = options.skillsDirectory || join23(process.cwd(), SKILLS_DIR);
+  const resolvedSkillsDirectory = options.skillsDirectory || join24(process.cwd(), SKILLS_DIR);
   try {
     const { skills, errors } = await discoverSkills(resolvedSkillsDirectory);
     if (errors.length > 0) {
@@ -80627,7 +81088,7 @@ ${options.systemPromptAppend}`;
     system: systemPromptContent,
     name,
     description: agentDescription,
-    embedding: embeddingModelVal,
+    embedding: embeddingModelVal || undefined,
     model: modelHandle,
     context_window_limit: contextWindow,
     tools: toolNames,
@@ -83416,12 +83877,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join24 } = await import("path");
+  const { join: join25 } = await import("path");
   const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_version2(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
   const { exists: exists3 } = await Promise.resolve().then(() => (init_fs2(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join24(cwd2, SKILLS_DIR3);
+  const skillsDir = join25(cwd2, SKILLS_DIR3);
   const skillsExist = exists3(skillsDir);
   await settingsManager2.loadLocalProjectSettings(cwd2);
   const localPinned = settingsManager2.getLocalPinnedAgents(cwd2);
@@ -83560,6 +84021,12 @@ async function main() {
   telemetry2.init();
   const { checkAndAutoUpdate: checkAndAutoUpdate2 } = await Promise.resolve().then(() => (init_auto_update(), exports_auto_update));
   checkAndAutoUpdate2().catch(() => {});
+  const { cleanupOldOverflowFiles: cleanupOldOverflowFiles2 } = await Promise.resolve().then(() => (init_overflow2(), exports_overflow));
+  Promise.resolve().then(() => {
+    try {
+      cleanupOldOverflowFiles2(process.cwd());
+    } catch {}
+  });
   const processedArgs = process.argv.map((arg) => arg === "--conv" ? "--conversation" : arg);
   let values;
   let positionals;
@@ -83599,7 +84066,8 @@ async function main() {
         "include-partial-messages": { type: "boolean" },
         skills: { type: "string" },
         sleeptime: { type: "boolean" },
-        "from-af": { type: "string" }
+        "from-af": { type: "string" },
+        "no-skills": { type: "boolean" }
       },
       strict: true,
       allowPositionals: true
@@ -83796,9 +84264,9 @@ Usage: letta --new-agent`);
       process.exit(1);
     }
     const { resolve: resolve21 } = await import("path");
-    const { existsSync: existsSync14 } = await import("fs");
+    const { existsSync: existsSync15 } = await import("fs");
     const resolvedPath = resolve21(fromAfFile);
-    if (!existsSync14(resolvedPath)) {
+    if (!existsSync15(resolvedPath)) {
       console.error(`Error: AgentFile not found: ${resolvedPath}`);
       process.exit(1);
     }
@@ -84300,8 +84768,8 @@ Error: ${message}`);
         (async () => {
           try {
             const { syncSkillsToAgent: syncSkillsToAgent3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
-            const { join: join24 } = await import("path");
-            const resolvedSkillsDirectory = skillsDirectory2 || join24(process.cwd(), SKILLS_DIR3);
+            const { join: join25 } = await import("path");
+            const resolvedSkillsDirectory = skillsDirectory2 || join25(process.cwd(), SKILLS_DIR3);
             await syncSkillsToAgent3(client, agent.id, resolvedSkillsDirectory, {
               skipIfUnchanged: true
             });
@@ -84542,4 +85010,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=0420C9226EBBB2BA64756E2164756E21
+//# debugId=A2D04DEC6336411264756E2164756E21