@letta-ai/letta-code 0.23.0 → 0.23.1

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.23.0",
+    version: "0.23.1",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -43143,6 +43143,7 @@ __export(exports_service, {
   removeChannelAccountLive: () => removeChannelAccountLive,
   refreshChannelAccountDisplayNameLive: () => refreshChannelAccountDisplayNameLive,
   listPendingPairingSnapshots: () => listPendingPairingSnapshots,
+  listEnabledChannelIds: () => listEnabledChannelIds,
   listChannelTargetSnapshots: () => listChannelTargetSnapshots,
   listChannelSummaries: () => listChannelSummaries,
   listChannelRouteSnapshots: () => listChannelRouteSnapshots,
@@ -43400,6 +43401,9 @@ function listChannelSummaries() {
     };
   });
 }
+function listEnabledChannelIds() {
+  return getSupportedChannelIds().filter((channelId) => listChannelAccounts(channelId).some((account) => account.enabled));
+}
 function getChannelConfigSnapshot(channelId, accountId) {
   assertSupportedChannelId(channelId);
   const account = getSelectedChannelAccount(channelId, accountId);
@@ -55627,7 +55631,8 @@ async function executeSingleDecision(decision, onChunk, options) {
         toolCallId: decision.approval.toolCallId,
         toolContextId: options?.toolContextId,
         parentScope: options?.parentScope,
-        onOutput: options?.onStreamingOutput ? (chunk, stream) => options.onStreamingOutput?.(decision.approval.toolCallId, chunk, stream === "stderr") : undefined
+        onOutput: options?.onStreamingOutput ? (chunk, stream) => options.onStreamingOutput?.(decision.approval.toolCallId, chunk, stream === "stderr") : undefined,
+        onFileWrite: options?.onFileWrite
       });
       if (onChunk) {
         onChunk({
@@ -77520,6 +77525,8 @@ var init_analyzer = __esm(() => {
 });
 
 // src/tools/manager.ts
+import * as nodeFs from "node:fs/promises";
+import * as nodePath from "node:path";
 function maybeAppendChannelTools(toolNames) {
   if (getActiveChannelIds().length > 0 && !toolNames.includes("MessageChannel")) {
     return [...toolNames, "MessageChannel"];
@@ -77590,8 +77597,8 @@ function acquireSwitchLock() {
   const lock = getSwitchLock();
   lock.refCount++;
   if (lock.refCount === 1) {
-    lock.promise = new Promise((resolve24) => {
-      lock.resolve = resolve24;
+    lock.promise = new Promise((resolve25) => {
+      lock.resolve = resolve25;
     });
   }
 }
@@ -78120,6 +78127,16 @@ async function executeTool(name, args, options) {
     const result = await withExecutionWorkingDirectory(workingDirectory, () => tool.fn(enhancedArgs));
     const duration = Date.now() - startTime;
     refreshFileIndex();
+    if (options?.onFileWrite && FILE_MUTATING_TOOLS.has(internalName)) {
+      const filePath = enhancedArgs.file_path;
+      if (filePath) {
+        try {
+          const resolvedPath = nodePath.isAbsolute(filePath) ? filePath : nodePath.resolve(process.env.USER_CWD || process.cwd(), filePath);
+          const content = await nodeFs.readFile(resolvedPath, "utf-8");
+          options.onFileWrite(resolvedPath, content);
+        } catch {}
+      }
+    }
     const recordResult = isRecord(result) ? result : undefined;
     const stdoutValue = recordResult?.stdout;
     const stderrValue = recordResult?.stderr;
@@ -78253,7 +78270,7 @@ function clearToolsWithLock() {
     releaseSwitchLock();
   }
 }
-var TOOL_NAMES, STREAMING_SHELL_TOOLS, TOOL_NAME_MAPPINGS, ANTHROPIC_DEFAULT_TOOLS, OPENAI_DEFAULT_TOOLS, GEMINI_DEFAULT_TOOLS, OPENAI_PASCAL_TOOLS, GEMINI_PASCAL_TOOLS, REGISTRY_KEY, SWITCH_LOCK_KEY, EXECUTION_CONTEXTS_KEY, toolRegistry, toolExecutionContextCounter = 0, EXTERNAL_TOOLS_KEY, EXTERNAL_EXECUTOR_KEY;
+var TOOL_NAMES, STREAMING_SHELL_TOOLS, FILE_MUTATING_TOOLS, TOOL_NAME_MAPPINGS, ANTHROPIC_DEFAULT_TOOLS, OPENAI_DEFAULT_TOOLS, GEMINI_DEFAULT_TOOLS, OPENAI_PASCAL_TOOLS, GEMINI_PASCAL_TOOLS, REGISTRY_KEY, SWITCH_LOCK_KEY, EXECUTION_CONTEXTS_KEY, toolRegistry, toolExecutionContextCounter = 0, EXTERNAL_TOOLS_KEY, EXTERNAL_EXECUTOR_KEY;
 var init_manager3 = __esm(async () => {
   init_model2();
   init_subagents();
@@ -78283,6 +78300,7 @@ var init_manager3 = __esm(async () => {
     "run_shell_command",
     "RunShellCommand"
   ]);
+  FILE_MUTATING_TOOLS = new Set(["Edit", "Write", "MultiEdit", "replace"]);
   TOOL_NAME_MAPPINGS = {
     glob_gemini: "glob",
     write_todos: "write_todos",
@@ -81705,7 +81723,7 @@ import {
   appendFile,
   mkdir as mkdir7,
   readdir as readdir5,
-  readFile as readFile9,
+  readFile as readFile10,
   writeFile as writeFile7
 } from "node:fs/promises";
 import { homedir as homedir21, tmpdir as tmpdir3 } from "node:os";
@@ -81752,7 +81770,7 @@ async function collectParentMemoryFiles(memoryDir) {
         continue;
       }
       try {
-        const content = await readFile9(entryPath, "utf-8");
+        const content = await readFile10(entryPath, "utf-8");
         const { frontmatter } = parseFrontmatter(content);
         const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
         files.push({
@@ -82012,7 +82030,7 @@ async function ensurePaths(paths) {
 }
 async function readState(paths) {
   try {
-    const raw = await readFile9(paths.statePath, "utf-8");
+    const raw = await readFile10(paths.statePath, "utf-8");
     const parsed = parseJsonLine(raw);
     if (!parsed) {
       return defaultState();
@@ -82032,7 +82050,7 @@ async function writeState(paths, state) {
 }
 async function readTranscriptLines(paths) {
   try {
-    const raw = await readFile9(paths.transcriptPath, "utf-8");
+    const raw = await readFile10(paths.transcriptPath, "utf-8");
     return raw.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
   } catch {
@@ -82391,11 +82409,11 @@ async function discoverFallbackRunIdWithTimeout(client, ctx) {
   return withTimeout(discoverFallbackRunIdForResume(client, ctx), FALLBACK_RUN_DISCOVERY_TIMEOUT_MS, `Fallback run discovery timed out after ${FALLBACK_RUN_DISCOVERY_TIMEOUT_MS}ms`);
 }
 function withTimeout(promise, timeoutMs, timeoutMessage) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
     promise.then((value) => {
       clearTimeout(timer);
-      resolve24(value);
+      resolve25(value);
     }, (error) => {
       clearTimeout(timer);
       reject(error);
@@ -83535,7 +83553,7 @@ function requestApprovalOverWS(runtime, socket, requestId, controlRequest) {
   if (isInterrupted()) {
     return Promise.reject(new Error("Cancelled by user"));
   }
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     let settled = false;
     const cleanupAbortListener = () => {
       abortSignal?.removeEventListener("abort", handleAbort);
@@ -83546,7 +83564,7 @@ function requestApprovalOverWS(runtime, socket, requestId, controlRequest) {
       }
       settled = true;
       cleanupAbortListener();
-      resolve24(response);
+      resolve25(response);
     };
     const wrappedReject = (error) => {
       if (settled) {
@@ -87209,7 +87227,7 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
             conversationId
           });
         }
-        await new Promise((resolve24) => setTimeout(resolve24, delayMs));
+        await new Promise((resolve25) => setTimeout(resolve25, delayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -87264,7 +87282,7 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
           agentId: runtime.agentId ?? undefined,
           conversationId
         });
-        await new Promise((resolve24) => setTimeout(resolve24, delayMs));
+        await new Promise((resolve25) => setTimeout(resolve25, delayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -87339,7 +87357,7 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
           retryAfterMs
         });
         transientRetries = attempt;
-        await new Promise((resolve24) => setTimeout(resolve24, delayMs));
+        await new Promise((resolve25) => setTimeout(resolve25, delayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -87384,7 +87402,7 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
           category: "conversation_busy",
           attempt: conversationBusyRetries
         });
-        await new Promise((resolve24) => setTimeout(resolve24, retryDelayMs));
+        await new Promise((resolve25) => setTimeout(resolve25, retryDelayMs));
         if (abortSignal?.aborted) {
           throw new Error("Cancelled by user");
         }
@@ -87422,6 +87440,7 @@ var init_send = __esm(async () => {
 });
 
 // src/websocket/listener/turn-approval.ts
+import WebSocket2 from "ws";
 async function handleApprovalStop(params) {
   const {
     approvals,
@@ -87647,11 +87666,24 @@ async function handleApprovalStop(params) {
   if (shouldInterrupt()) {
     return interruptTermination();
   }
+  const onFileWrite = (filePath, content) => {
+    if (socket.readyState === WebSocket2.OPEN) {
+      socket.send(JSON.stringify({
+        type: "file_ops",
+        path: filePath,
+        cg_entries: [],
+        ops: [],
+        source: "agent",
+        document_content: content
+      }));
+    }
+  };
   const executionResults = await executeApprovalBatch(decisions, undefined, {
     toolContextId: turnToolContextId ?? undefined,
     abortSignal: abortController.signal,
     workingDirectory: turnWorkingDirectory,
-    parentScope: agentId && conversationId ? { agentId, conversationId } : undefined
+    parentScope: agentId && conversationId ? { agentId, conversationId } : undefined,
+    onFileWrite
   });
   const persistedExecutionResults = normalizeExecutionResultsForInterruptParity(runtime, executionResults, lastExecutingToolCallIds);
   validateApprovalResultIds(decisions.map((decision) => ({
@@ -88276,7 +88308,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             agentId,
             conversationId
           });
-          await new Promise((resolve24) => setTimeout(resolve24, delayMs));
+          await new Promise((resolve25) => setTimeout(resolve25, delayMs));
           if (turnAbortSignal.aborted) {
             throw new Error("Cancelled by user");
           }
@@ -88321,7 +88353,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             agentId,
             conversationId
           });
-          await new Promise((resolve24) => setTimeout(resolve24, delayMs));
+          await new Promise((resolve25) => setTimeout(resolve25, delayMs));
           if (turnAbortSignal.aborted) {
             throw new Error("Cancelled by user");
           }
@@ -88811,7 +88843,7 @@ var init_commands = __esm(async () => {
 });
 
 // src/websocket/listener/protocol-outbound.ts
-import WebSocket2 from "ws";
+import WebSocket3 from "ws";
 function getCachedDeviceGitContext(cwd2) {
   const now = Date.now();
   const cached = gitContextCache.get(cwd2);
@@ -88928,7 +88960,7 @@ function buildDeviceStatus(runtime, params) {
   return {
     current_connection_id: listener.connectionId,
     connection_name: listener.connectionName,
-    is_online: listener.socket?.readyState === WebSocket2.OPEN,
+    is_online: listener.socket?.readyState === WebSocket3.OPEN,
     is_processing: !!conversationRuntime?.isProcessing,
     current_permission_mode: conversationPermissionModeState.mode,
     current_working_directory: resolvedCwd,
@@ -88996,7 +89028,7 @@ function setLoopStatus(runtime, status, scope) {
   emitLoopStatusIfOpen(runtime, scope);
 }
 function emitProtocolV2Message(socket, runtime, message, scope) {
-  if (socket.readyState !== WebSocket2.OPEN) {
+  if (socket.readyState !== WebSocket3.OPEN) {
     return;
   }
   const listener = getListenerRuntime(runtime);
@@ -89048,13 +89080,13 @@ function emitLoopStatusUpdate(socket, runtime, scope) {
 }
 function emitLoopStatusIfOpen(runtime, scope) {
   const listener = getListenerRuntime(runtime);
-  if (listener?.socket?.readyState === WebSocket2.OPEN) {
+  if (listener?.socket?.readyState === WebSocket3.OPEN) {
     emitLoopStatusUpdate(listener.socket, runtime, scope);
   }
 }
 function emitDeviceStatusIfOpen(runtime, scope) {
   const listener = getListenerRuntime(runtime);
-  if (listener?.socket?.readyState === WebSocket2.OPEN) {
+  if (listener?.socket?.readyState === WebSocket3.OPEN) {
     emitDeviceStatusUpdate(listener.socket, runtime, scope);
   }
 }
@@ -89113,7 +89145,7 @@ function emitDequeuedUserMessage(socket, runtime, incoming, batch) {
 }
 function emitQueueUpdateIfOpen(runtime, scope) {
   const listener = getListenerRuntime(runtime);
-  if (listener?.socket?.readyState === WebSocket2.OPEN) {
+  if (listener?.socket?.readyState === WebSocket3.OPEN) {
     emitQueueUpdate(listener.socket, runtime, scope);
   }
 }
@@ -89169,7 +89201,7 @@ function emitSubagentStateUpdate(socket, runtime, scope) {
 }
 function emitSubagentStateIfOpen(runtime, scope) {
   const listener = getListenerRuntime(runtime);
-  if (listener?.socket?.readyState === WebSocket2.OPEN) {
+  if (listener?.socket?.readyState === WebSocket3.OPEN) {
     emitSubagentStateUpdate(listener.socket, runtime, scope);
   }
 }
@@ -89787,7 +89819,7 @@ var init_toolset_labels = __esm(() => {
 
 // src/websocket/terminalHandler.ts
 import * as os4 from "node:os";
-import WebSocket3 from "ws";
+import WebSocket4 from "ws";
 function getDefaultShell() {
   if (os4.platform() === "win32") {
     return process.env.COMSPEC || "cmd.exe";
@@ -89795,7 +89827,7 @@ function getDefaultShell() {
   return process.env.SHELL || "/bin/zsh";
 }
 function sendTerminalMessage(socket, message) {
-  if (socket.readyState === WebSocket3.OPEN) {
+  if (socket.readyState === WebSocket4.OPEN) {
     socket.send(JSON.stringify(message));
   }
 }
@@ -90163,6 +90195,12 @@ function isEditFileCommand(value) {
   const c = value;
   return c.type === "edit_file" && typeof c.file_path === "string" && typeof c.old_string === "string" && typeof c.new_string === "string" && typeof c.request_id === "string" && (c.replace_all === undefined || typeof c.replace_all === "boolean") && (c.expected_replacements === undefined || typeof c.expected_replacements === "number" && Number.isInteger(c.expected_replacements) && c.expected_replacements > 0);
 }
+function isFileOpsCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "file_ops" && typeof c.path === "string" && Array.isArray(c.cg_entries) && Array.isArray(c.ops) && typeof c.source === "string";
+}
 function isListMemoryCommand(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -90453,7 +90491,7 @@ function parseServerMessage(data) {
   try {
     const raw = typeof data === "string" ? data : data.toString();
     const parsed = JSON.parse(raw);
-    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isChannelsListCommand(parsed) || isChannelAccountsListCommand(parsed) || isChannelAccountCreateCommand(parsed) || isChannelAccountUpdateCommand(parsed) || isChannelAccountBindCommand(parsed) || isChannelAccountUnbindCommand(parsed) || isChannelAccountDeleteCommand(parsed) || isChannelAccountStartCommand(parsed) || isChannelAccountStopCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelTargetsListCommand(parsed) || isChannelTargetBindCommand(parsed) || isChannelRouteUpdateCommand(parsed) || isChannelRouteRemoveCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
+    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isFileOpsCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isChannelsListCommand(parsed) || isChannelAccountsListCommand(parsed) || isChannelAccountCreateCommand(parsed) || isChannelAccountUpdateCommand(parsed) || isChannelAccountBindCommand(parsed) || isChannelAccountUnbindCommand(parsed) || isChannelAccountDeleteCommand(parsed) || isChannelAccountStartCommand(parsed) || isChannelAccountStopCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelTargetsListCommand(parsed) || isChannelTargetBindCommand(parsed) || isChannelRouteUpdateCommand(parsed) || isChannelRouteRemoveCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
       return parsed;
     }
     const invalidInput = getInvalidInputReason(parsed);
@@ -90474,6 +90512,135 @@ var init_protocol_inbound = __esm(async () => {
   await init_approval();
 });
 
+// src/websocket/listener/worktree-watcher.ts
+import { readdir as readdir6, stat as stat5, watch } from "node:fs/promises";
+import path22 from "node:path";
+function startWorktreeWatcher(params) {
+  const { runtime, agentId, conversationId } = params;
+  const cwd2 = getConversationWorkingDirectory(runtime, agentId, conversationId);
+  const worktreesDir = path22.join(cwd2, WORKTREES_DIR);
+  const abort = new AbortController;
+  const state = { abort, watchedDir: worktreesDir };
+  runWatchLoop({
+    worktreesDir,
+    abort,
+    runtime,
+    agentId,
+    conversationId
+  }).catch((err) => {
+    if (err.name === "AbortError")
+      return;
+    console.error("[WorktreeWatcher] watch loop error:", err);
+  });
+  return state;
+}
+function stopWorktreeWatcher(state) {
+  state.abort.abort();
+}
+function stopAllWorktreeWatchers(runtime) {
+  for (const watcher of runtime.worktreeWatcherByConversation.values()) {
+    stopWorktreeWatcher(watcher);
+  }
+  runtime.worktreeWatcherByConversation.clear();
+}
+function restartWorktreeWatcher(params) {
+  const { runtime, agentId, conversationId } = params;
+  const scopeKey = getWorkingDirectoryScopeKey(agentId, conversationId);
+  const existing = runtime.worktreeWatcherByConversation.get(scopeKey);
+  if (existing) {
+    stopWorktreeWatcher(existing);
+    runtime.worktreeWatcherByConversation.delete(scopeKey);
+  }
+  const state = startWorktreeWatcher(params);
+  if (state) {
+    runtime.worktreeWatcherByConversation.set(scopeKey, state);
+  }
+}
+async function runWatchLoop(params) {
+  const { worktreesDir, abort, runtime, agentId, conversationId } = params;
+  const dirExists = await directoryExists(worktreesDir);
+  if (!dirExists) {
+    const lettaDir = path22.dirname(worktreesDir);
+    const lettaDirExists = await directoryExists(lettaDir);
+    if (!lettaDirExists) {
+      return;
+    }
+    await waitForDirectoryCreation(lettaDir, "worktrees", abort.signal);
+  }
+  const existingEntries = new Set(await safeReaddir(worktreesDir));
+  let debounceTimer = null;
+  const watcher = watch(worktreesDir, { signal: abort.signal });
+  for await (const event of watcher) {
+    if (event.eventType !== "rename" || !event.filename)
+      continue;
+    if (existingEntries.has(event.filename))
+      continue;
+    if (debounceTimer)
+      clearTimeout(debounceTimer);
+    const filename = event.filename;
+    debounceTimer = setTimeout(() => {
+      handleNewWorktree({
+        worktreesDir,
+        filename,
+        runtime,
+        agentId,
+        conversationId
+      });
+    }, DEBOUNCE_MS);
+  }
+}
+async function handleNewWorktree(params) {
+  const { worktreesDir, filename, runtime, agentId, conversationId } = params;
+  const newWorktreePath = path22.join(worktreesDir, filename);
+  if (!await directoryExists(newWorktreePath))
+    return;
+  const currentCwd = getConversationWorkingDirectory(runtime, agentId, conversationId);
+  if (currentCwd === newWorktreePath)
+    return;
+  console.log(`[WorktreeWatcher] New worktree detected: ${newWorktreePath} — switching CWD`);
+  setConversationWorkingDirectory(runtime, agentId, conversationId, newWorktreePath);
+  const scopeKey = getWorkingDirectoryScopeKey(agentId, conversationId);
+  const reminderState = runtime.reminderStateByConversation.get(scopeKey);
+  if (reminderState) {
+    reminderState.hasSentSessionContext = false;
+    reminderState.pendingSessionContextReason = "cwd_changed";
+  }
+  if (runtime.socket) {
+    emitDeviceStatusUpdate(runtime.socket, runtime, {
+      agent_id: agentId,
+      conversation_id: conversationId
+    });
+  }
+}
+async function waitForDirectoryCreation(parentDir, targetName, signal) {
+  const watcher = watch(parentDir, { signal });
+  for await (const event of watcher) {
+    if (event.eventType === "rename" && event.filename === targetName && await directoryExists(path22.join(parentDir, targetName))) {
+      return;
+    }
+  }
+}
+async function directoryExists(dir) {
+  try {
+    const stats = await stat5(dir);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function safeReaddir(dir) {
+  try {
+    return await readdir6(dir);
+  } catch {
+    return [];
+  }
+}
+var WORKTREES_DIR = ".letta/worktrees", DEBOUNCE_MS = 500;
+var init_worktree_watcher = __esm(async () => {
+  init_cwd();
+  await init_protocol_outbound();
+});
+
 // src/agent/memoryScanner.ts
 var exports_memoryScanner = {};
 __export(exports_memoryScanner, {
@@ -90555,10 +90722,10 @@ var init_memoryScanner = () => {};
 
 // src/websocket/listener/client.ts
 import { execFile as execFile13 } from "node:child_process";
-import { realpath as realpath3, stat as stat5 } from "node:fs/promises";
-import path22 from "node:path";
+import { realpath as realpath3, stat as stat6 } from "node:fs/promises";
+import path23 from "node:path";
 import { promisify as promisify13 } from "node:util";
-import WebSocket4 from "ws";
+import WebSocket5 from "ws";
 async function loadChannelsService() {
   if (channelsServiceLoaderOverride) {
     return channelsServiceLoaderOverride();
@@ -90573,7 +90740,7 @@ function trackListenerError(errorType, error, context3) {
   });
 }
 function safeSocketSend(socket, payload, errorType, context3) {
-  if (socket.readyState !== WebSocket4.OPEN) {
+  if (socket.readyState !== WebSocket5.OPEN) {
     return false;
   }
   try {
@@ -91760,8 +91927,8 @@ async function handleSkillCommand(parsed, socket) {
       const linkPath = join31(globalSkillsDir, linkName);
       mkdirSync19(globalSkillsDir, { recursive: true });
       if (existsSync26(linkPath)) {
-        const stat6 = lstatSync2(linkPath);
-        if (stat6.isSymbolicLink()) {
+        const stat7 = lstatSync2(linkPath);
+        if (stat7.isSymbolicLink()) {
           if (process.platform === "win32") {
             rmdirSync(linkPath);
           } else {
@@ -91810,8 +91977,8 @@ async function handleSkillCommand(parsed, socket) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const stat6 = lstatSync2(linkPath);
-      if (!stat6.isSymbolicLink()) {
+      const stat7 = lstatSync2(linkPath);
+      if (!stat7.isSymbolicLink()) {
         safeSocketSend(socket, {
           type: "skill_disable_response",
           request_id: parsed.request_id,
@@ -92263,9 +92430,9 @@ async function handleCwdChange(msg, socket, runtime) {
     if (!requestedPath) {
       throw new Error("Working directory cannot be empty");
     }
-    const resolvedPath = path22.isAbsolute(requestedPath) ? requestedPath : path22.resolve(currentWorkingDirectory, requestedPath);
+    const resolvedPath = path23.isAbsolute(requestedPath) ? requestedPath : path23.resolve(currentWorkingDirectory, requestedPath);
     const normalizedPath = await realpath3(resolvedPath);
-    const stats = await stat5(normalizedPath);
+    const stats = await stat6(normalizedPath);
     if (!stats.isDirectory()) {
       throw new Error(`Not a directory: ${normalizedPath}`);
     }
@@ -92280,6 +92447,11 @@ async function handleCwdChange(msg, socket, runtime) {
       agent_id: agentId,
       conversation_id: conversationId
     });
+    restartWorktreeWatcher({
+      runtime: runtime.listener,
+      agentId,
+      conversationId
+    });
   } catch (error) {
     emitLoopErrorNotice(socket, runtime, {
       message: error instanceof Error ? error.message : "Working directory change failed",
@@ -92309,6 +92481,7 @@ function createRuntime() {
     reminderState: createSharedReminderState(),
     bootWorkingDirectory,
     workingDirectoryByConversation: loadPersistedCwdMap(),
+    worktreeWatcherByConversation: new Map,
     permissionModeByConversation: loadPersistedPermissionModeMap(),
     reminderStateByConversation: new Map,
     contextTrackerByConversation: new Map,
@@ -92340,6 +92513,7 @@ function stopRuntime(runtime, suppressCallbacks) {
   runtime.contextTrackerByConversation.clear();
   runtime.systemPromptRecompileByConversation.clear();
   runtime.queuedSystemPromptRecompileByConversation.clear();
+  stopAllWorktreeWatchers(runtime);
   if (!runtime.socket) {
     return;
   }
@@ -92348,7 +92522,7 @@ function stopRuntime(runtime, suppressCallbacks) {
   if (suppressCallbacks) {
     socket.removeAllListeners();
   }
-  if (socket.readyState === WebSocket4.OPEN || socket.readyState === WebSocket4.CONNECTING) {
+  if (socket.readyState === WebSocket5.OPEN || socket.readyState === WebSocket5.CONNECTING) {
     socket.close();
   }
 }
@@ -92383,8 +92557,8 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     const delay = Math.min(INITIAL_RETRY_DELAY_MS * 2 ** (attempt - 1), MAX_RETRY_DELAY_MS);
     const maxAttempts = Math.ceil(Math.log2(MAX_RETRY_DURATION_MS / INITIAL_RETRY_DELAY_MS));
     opts.onRetrying?.(attempt, maxAttempts, delay, opts.connectionId);
-    await new Promise((resolve24) => {
-      runtime.reconnectTimeout = setTimeout(resolve24, delay);
+    await new Promise((resolve25) => {
+      runtime.reconnectTimeout = setTimeout(resolve25, delay);
     });
     runtime.reconnectTimeout = null;
     if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
@@ -92403,7 +92577,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
   const url = new URL(opts.wsUrl);
   url.searchParams.set("deviceId", opts.deviceId);
   url.searchParams.set("connectionName", opts.connectionName);
-  const socket = new WebSocket4(url.toString(), {
+  const socket = new WebSocket5(url.toString(), {
     headers: {
       Authorization: `Bearer ${apiKey}`
     }
@@ -92457,7 +92631,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     });
     runtime._unsubscribeSubagentStreamEvents?.();
     runtime._unsubscribeSubagentStreamEvents = subscribeToStreamEvents((subagentId, event) => {
-      if (socket.readyState !== WebSocket4.OPEN)
+      if (socket.readyState !== WebSocket5.OPEN)
         return;
       const subagent = getSubagents().find((entry) => entry.id === subagentId);
       if (subagent?.silent === true) {
@@ -92483,7 +92657,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       scheduleQueuePump(targetRuntime, socket, opts, processQueuedTurn);
     });
     runtime.heartbeatInterval = setInterval(() => {
-      if (socket.readyState === WebSocket4.OPEN) {
+      if (socket.readyState === WebSocket5.OPEN) {
         safeSocketSend(socket, { type: "ping" }, "listener_ping_send_failed", "listener_heartbeat");
       }
     }, 30000);
@@ -92644,14 +92818,14 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           try {
             if (parsed.cwd) {
               const currentRoot = getIndexRoot();
-              if (!parsed.cwd.startsWith(currentRoot + path22.sep) && parsed.cwd !== currentRoot) {
+              if (!parsed.cwd.startsWith(currentRoot + path23.sep) && parsed.cwd !== currentRoot) {
                 setIndexRoot(parsed.cwd);
               }
             }
             await ensureFileIndex2();
             let searchDir = ".";
             if (parsed.cwd) {
-              const rel = path22.relative(getIndexRoot(), parsed.cwd);
+              const rel = path23.relative(getIndexRoot(), parsed.cwd);
               if (rel && !rel.startsWith("..") && rel !== "") {
                 searchDir = rel;
               }
@@ -92685,9 +92859,9 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         console.log(`[Listen] Received list_in_directory command: path=${parsed.path}`);
         runDetachedListenerTask("list_in_directory", async () => {
           try {
-            const { readdir: readdir6 } = await import("node:fs/promises");
+            const { readdir: readdir7 } = await import("node:fs/promises");
             console.log(`[Listen] Reading directory: ${parsed.path}`);
-            const entries = await readdir6(parsed.path, { withFileTypes: true });
+            const entries = await readdir7(parsed.path, { withFileTypes: true });
             console.log(`[Listen] Directory read success, ${entries.length} entries`);
             const IGNORED_NAMES = new Set([
               ".DS_Store",
@@ -92746,8 +92920,8 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         console.log(`[Listen] Received read_file command: path=${parsed.path}, request_id=${parsed.request_id}`);
         runDetachedListenerTask("read_file", async () => {
           try {
-            const { readFile: readFile10 } = await import("node:fs/promises");
-            const content = await readFile10(parsed.path, "utf-8");
+            const { readFile: readFile11 } = await import("node:fs/promises");
+            const content = await readFile11(parsed.path, "utf-8");
             console.log(`[Listen] read_file success: ${parsed.path} (${content.length} bytes)`);
             safeSocketSend(socket, {
               type: "read_file_response",
@@ -92777,10 +92951,10 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           try {
             const { edit: edit2 } = await Promise.resolve().then(() => (init_Edit2(), exports_Edit));
             const { write: write2 } = await Promise.resolve().then(() => (init_Write2(), exports_Write));
-            const { readFile: readFile10 } = await import("node:fs/promises");
+            const { readFile: readFile11 } = await import("node:fs/promises");
             let currentContent = null;
             try {
-              currentContent = await readFile10(parsed.path, "utf-8");
+              currentContent = await readFile11(parsed.path, "utf-8");
             } catch (readErr) {
               const e = readErr;
               if (e.code !== "ENOENT")
@@ -92829,11 +93003,11 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
             return;
           }
           try {
-            const { watch } = await import("node:fs");
-            const { stat: stat6 } = await import("node:fs/promises");
+            const { watch: watch2 } = await import("node:fs");
+            const { stat: stat7 } = await import("node:fs/promises");
             if (cancelledWatches.delete(parsed.path))
               return;
-            const watcher = watch(parsed.path, { persistent: false }, (eventType) => {
+            const watcher = watch2(parsed.path, { persistent: false }, (eventType) => {
               if (eventType !== "change" && eventType !== "rename")
                 return;
               const existing2 = watchDebounceTimers.get(parsed.path);
@@ -92841,7 +93015,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
                 clearTimeout(existing2);
               watchDebounceTimers.set(parsed.path, setTimeout(() => {
                 watchDebounceTimers.delete(parsed.path);
-                stat6(parsed.path).then((s) => {
+                stat7(parsed.path).then((s) => {
                   safeSocketSend(socket, {
                     type: "file_changed",
                     path: parsed.path,
@@ -92887,6 +93061,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         console.log(`[Listen] Received edit_file command: file_path=${parsed.file_path}, request_id=${parsed.request_id}`);
         runDetachedListenerTask("edit_file", async () => {
           try {
+            const { readFile: readFile11 } = await import("node:fs/promises");
             const { edit: edit2 } = await Promise.resolve().then(() => (init_Edit2(), exports_Edit));
             console.log(`[Listen] Executing edit: old_string="${parsed.old_string.slice(0, 50)}${parsed.old_string.length > 50 ? "..." : ""}"`);
             const result = await edit2({
@@ -92897,6 +93072,19 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
               expected_replacements: parsed.expected_replacements
             });
             console.log(`[Listen] edit_file success: ${result.replacements} replacement(s) at line ${result.startLine}`);
+            if (result.replacements > 0) {
+              try {
+                const contentAfter = await readFile11(parsed.file_path, "utf-8");
+                safeSocketSend(socket, {
+                  type: "file_ops",
+                  path: parsed.file_path,
+                  cg_entries: [],
+                  ops: [],
+                  source: "agent",
+                  document_content: contentAfter
+                }, "listener_edit_file_ops_send_failed", "listener_edit_file");
+              } catch {}
+            }
             safeSocketSend(socket, {
               type: "edit_file_response",
               request_id: parsed.request_id,
@@ -92922,6 +93110,21 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         });
         return;
       }
+      if (isFileOpsCommand(parsed)) {
+        if (parsed.document_content !== undefined) {
+          runDetachedListenerTask("file_ops", async () => {
+            try {
+              const { writeFile: writeFile9 } = await import("node:fs/promises");
+              const content = parsed.document_content;
+              await writeFile9(parsed.path, content, "utf-8");
+              console.log(`[Listen] file_ops: wrote ${content.length} bytes to ${parsed.path}`);
+            } catch (err) {
+              console.error(`[Listen] file_ops error: ${err instanceof Error ? err.message : "Unknown error"}`);
+            }
+          });
+        }
+        return;
+      }
       if (isListMemoryCommand(parsed)) {
         runDetachedListenerTask("list_memory", async () => {
           try {
@@ -93606,6 +93809,12 @@ function createLegacyTestRuntime() {
         listener.memfsSyncedAgents = value;
       }
     },
+    worktreeWatcherByConversation: {
+      get: () => listener.worktreeWatcherByConversation,
+      set: (value) => {
+        listener.worktreeWatcherByConversation = value;
+      }
+    },
     lastEmittedStatus: {
       get: () => listener.lastEmittedStatus,
       set: (value) => {
@@ -93675,6 +93884,7 @@ var init_client4 = __esm(async () => {
     init_recovery(),
     init_send(),
     init_turn(),
+    init_worktree_watcher(),
     init_approval(),
     init_protocol_inbound(),
     init_protocol_outbound()
@@ -93788,8 +93998,8 @@ function isDebugEnabled2() {
   return lettaDebug === "1" || lettaDebug === "true" || legacyDebug === "1" || legacyDebug === "true";
 }
 function getDebugFile2() {
-  const path23 = process.env.LETTA_DEBUG_FILE;
-  return path23 && path23.trim().length > 0 ? path23 : null;
+  const path24 = process.env.LETTA_DEBUG_FILE;
+  return path24 && path24.trim().length > 0 ? path24 : null;
 }
 function printDebugLine2(line, level = "log") {
   const debugFile = getDebugFile2();
@@ -93913,7 +94123,7 @@ __export(exports_skills2, {
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
 import { existsSync as existsSync28 } from "node:fs";
-import { readdir as readdir7, readFile as readFile10, realpath as realpath4, stat as stat6 } from "node:fs/promises";
+import { readdir as readdir8, readFile as readFile11, realpath as realpath4, stat as stat7 } from "node:fs/promises";
 import { dirname as dirname13, join as join35 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
@@ -94003,14 +94213,14 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
     return;
   }
   try {
-    const entries = await readdir7(currentPath, { withFileTypes: true });
+    const entries = await readdir8(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = join35(currentPath, entry.name);
       try {
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
-          const entryStat = await stat6(fullPath);
+          const entryStat = await stat7(fullPath);
           isDirectory = entryStat.isDirectory();
           isFile = entryStat.isFile();
         }
@@ -94044,7 +94254,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
   }
 }
 async function parseSkillFile2(filePath, rootPath, source) {
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile11(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const normalizedRoot = rootPath.endsWith("/") ? rootPath.slice(0, -1) : rootPath;
   const relativePath = filePath.slice(normalizedRoot.length + 1);
@@ -94103,7 +94313,7 @@ __export(exports_fs, {
   writeJsonFile: () => writeJsonFile,
   writeFile: () => writeFile10,
   readJsonFile: () => readJsonFile,
-  readFile: () => readFile11,
+  readFile: () => readFile12,
   mkdir: () => mkdir9,
   exists: () => exists2
 });
@@ -94114,31 +94324,31 @@ import {
   mkdirSync as mkdirSync21
 } from "node:fs";
 import { dirname as dirname14 } from "node:path";
-async function readFile11(path23) {
-  return fsReadFileSync2(path23, { encoding: "utf-8" });
+async function readFile12(path24) {
+  return fsReadFileSync2(path24, { encoding: "utf-8" });
 }
-async function writeFile10(path23, content) {
-  const dir = dirname14(path23);
+async function writeFile10(path24, content) {
+  const dir = dirname14(path24);
   if (!existsSync29(dir)) {
     mkdirSync21(dir, { recursive: true });
   }
-  fsWriteFileSync2(path23, content, { encoding: "utf-8", flush: true });
+  fsWriteFileSync2(path24, content, { encoding: "utf-8", flush: true });
 }
-function exists2(path23) {
-  return existsSync29(path23);
+function exists2(path24) {
+  return existsSync29(path24);
 }
-async function mkdir9(path23, options) {
-  mkdirSync21(path23, options);
+async function mkdir9(path24, options) {
+  mkdirSync21(path24, options);
 }
-async function readJsonFile(path23) {
-  const text = await readFile11(path23);
+async function readJsonFile(path24) {
+  const text = await readFile12(path24);
   return JSON.parse(text);
 }
-async function writeJsonFile(path23, data, options) {
+async function writeJsonFile(path24, data, options) {
   const indent = options?.indent ?? 2;
   const content = `${JSON.stringify(data, null, indent)}
 `;
-  await writeFile10(path23, content);
+  await writeFile10(path24, content);
 }
 var init_fs2 = () => {};
 
@@ -94163,7 +94373,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
   }
   const wasRaw = process.stdin.isRaw;
   const wasFlowing = process.stdin.readableFlowing;
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     let response = "";
     let resolved = false;
     const cleanup = () => {
@@ -94180,7 +94390,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
     };
     const timeout = setTimeout(() => {
       cleanup();
-      resolve26(null);
+      resolve27(null);
     }, timeoutMs);
     const onData = (data) => {
       response += data.toString();
@@ -94190,7 +94400,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
       if (match3) {
         clearTimeout(timeout);
         cleanup();
-        resolve26({
+        resolve27({
           r: parseHexComponent(match3[1] ?? "0"),
           g: parseHexComponent(match3[2] ?? "0"),
           b: parseHexComponent(match3[3] ?? "0")
@@ -94205,7 +94415,7 @@ async function queryTerminalBackground(timeoutMs = 100) {
     } catch {
       clearTimeout(timeout);
       cleanup();
-      resolve26(null);
+      resolve27(null);
     }
   });
 }
@@ -94291,7 +94501,7 @@ __export(exports_manager2, {
   lspManager: () => lspManager2,
   LSPManager: () => LSPManager2
 });
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 
 class LSPManager2 {
   static instance = null;
@@ -94319,7 +94529,7 @@ class LSPManager2 {
   async getOrStartServer(filePath) {
     if (!this.enabled)
       return null;
-    const ext3 = path23.extname(filePath).toLowerCase();
+    const ext3 = path24.extname(filePath).toLowerCase();
     const serverDef = this.serverDefinitions.find((s) => s.extensions.includes(ext3));
     if (!serverDef) {
       return null;
@@ -94387,7 +94597,7 @@ class LSPManager2 {
     const client = await this.getOrStartServer(filePath);
     if (!client)
       return;
-    const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.resolve(process.cwd(), filePath);
+    const absolutePath = path24.isAbsolute(filePath) ? filePath : path24.resolve(process.cwd(), filePath);
     const uri = `file://${absolutePath}`;
     const existing = this.openDocuments.get(absolutePath);
     if (!existing) {
@@ -94415,7 +94625,7 @@ class LSPManager2 {
     if (!this.enabled)
       return [];
     if (filePath) {
-      const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.resolve(process.cwd(), filePath);
+      const absolutePath = path24.isAbsolute(filePath) ? filePath : path24.resolve(process.cwd(), filePath);
       return this.diagnostics.get(absolutePath) || [];
     }
     const all = [];
@@ -94425,7 +94635,7 @@ class LSPManager2 {
     return all;
   }
   getLanguageId(filePath) {
-    const ext3 = path23.extname(filePath).toLowerCase();
+    const ext3 = path24.extname(filePath).toLowerCase();
     const languageMap = {
       ".ts": "typescript",
       ".tsx": "typescriptreact",
@@ -94476,7 +94686,7 @@ __export(exports_auto_update, {
 });
 import { execFile as execFile14 } from "node:child_process";
 import { realpathSync as realpathSync3 } from "node:fs";
-import { readdir as readdir8, rm as rm3 } from "node:fs/promises";
+import { readdir as readdir9, rm as rm3 } from "node:fs/promises";
 import { join as join37 } from "node:path";
 import { promisify as promisify14 } from "node:util";
 function debugLog4(...args) {
@@ -94644,7 +94854,7 @@ async function getNpmGlobalPath() {
 async function cleanupOrphanedDirs(globalPath) {
   const lettaAiDir = join37(globalPath, "lib/node_modules/@letta-ai");
   try {
-    const entries = await readdir8(lettaAiDir);
+    const entries = await readdir9(lettaAiDir);
     for (const entry of entries) {
       if (entry.startsWith(".letta-code-")) {
         const orphanPath = join37(lettaAiDir, entry);
@@ -94895,13 +95105,13 @@ __export(exports_overflow, {
 import { randomUUID as randomUUID10 } from "node:crypto";
 import * as fs15 from "node:fs";
 import * as os5 from "node:os";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 function getOverflowDirectory2(workingDirectory) {
   const homeDir = os5.homedir();
-  const lettaDir = path24.join(homeDir, ".letta");
-  const normalizedPath = path24.normalize(workingDirectory);
+  const lettaDir = path25.join(homeDir, ".letta");
+  const normalizedPath = path25.normalize(workingDirectory);
   const sanitizedPath = normalizedPath.replace(/^[/\\]/, "").replace(/[/\\:]/g, "_").replace(/\s+/g, "_");
-  const overflowDir = path24.join(lettaDir, "projects", sanitizedPath, "agent-tools");
+  const overflowDir = path25.join(lettaDir, "projects", sanitizedPath, "agent-tools");
   return overflowDir;
 }
 function ensureOverflowDirectory2(workingDirectory) {
@@ -94915,7 +95125,7 @@ function writeOverflowFile2(content, workingDirectory, toolName) {
   const overflowDir = ensureOverflowDirectory2(workingDirectory);
   const uuid = randomUUID10();
   const filename = toolName ? `${toolName.toLowerCase()}-${uuid}.txt` : `${uuid}.txt`;
-  const filePath = path24.join(overflowDir, filename);
+  const filePath = path25.join(overflowDir, filename);
   fs15.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
@@ -94933,7 +95143,7 @@ function cleanupOldOverflowFiles(workingDirectory, maxAgeMs = 24 * 60 * 60 * 100
   const now = Date.now();
   let deletedCount = 0;
   for (const file of files) {
-    const filePath = path24.join(overflowDir, file);
+    const filePath = path25.join(overflowDir, file);
     try {
       const stats = fs15.statSync(filePath);
       if (stats.isDirectory()) {
@@ -94960,7 +95170,7 @@ function getOverflowStats(workingDirectory) {
   const files = fs15.readdirSync(overflowDir);
   let totalSize = 0;
   for (const file of files) {
-    const filePath = path24.join(overflowDir, file);
+    const filePath = path25.join(overflowDir, file);
     const stats = fs15.statSync(filePath);
     totalSize += stats.size;
   }
@@ -95438,10 +95648,10 @@ __export(exports_setup, {
   runSetup: () => runSetup
 });
 async function runSetup() {
-  return new Promise((resolve27) => {
+  return new Promise((resolve28) => {
     const { waitUntilExit } = render_default(import_react32.default.createElement(SetupUI, {
       onComplete: () => {
-        resolve27();
+        resolve28();
       }
     }));
     waitUntilExit().catch((error) => {
@@ -95936,8 +96146,8 @@ __export(exports_github_utils, {
   parseDirNames: () => parseDirNames,
   fetchGitHubContents: () => fetchGitHubContents
 });
-async function fetchGitHubContents(owner, repo, branch, path25) {
-  const apiPath = path25 ? `repos/${owner}/${repo}/contents/${path25}?ref=${branch}` : `repos/${owner}/${repo}/contents?ref=${branch}`;
+async function fetchGitHubContents(owner, repo, branch, path26) {
+  const apiPath = path26 ? `repos/${owner}/${repo}/contents/${path26}?ref=${branch}` : `repos/${owner}/${repo}/contents?ref=${branch}`;
   try {
     const { execSync: execSync2 } = await import("node:child_process");
     const result = execSync2(`gh api ${apiPath}`, {
@@ -95946,7 +96156,7 @@ async function fetchGitHubContents(owner, repo, branch, path25) {
     });
     return JSON.parse(result);
   } catch {}
-  const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path25}?ref=${branch}`;
+  const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path26}?ref=${branch}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/vnd.github.v3+json",
@@ -95954,7 +96164,7 @@ async function fetchGitHubContents(owner, repo, branch, path25) {
     }
   });
   if (!response.ok) {
-    throw new Error(`Failed to fetch from ${owner}/${repo}/${branch}/${path25}: ${response.statusText}`);
+    throw new Error(`Failed to fetch from ${owner}/${repo}/${branch}/${path26}: ${response.statusText}`);
   }
   return await response.json();
 }
@@ -95970,11 +96180,11 @@ __export(exports_import, {
   extractSkillsFromAf: () => extractSkillsFromAf
 });
 import { createReadStream } from "node:fs";
-import { chmod, mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname15, resolve as resolve27 } from "node:path";
+import { chmod, mkdir as mkdir10, readFile as readFile13, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve28 } from "node:path";
 async function importAgentFromFile(options) {
   const client = await getClient();
-  const resolvedPath = resolve27(options.filePath);
+  const resolvedPath = resolve28(options.filePath);
   const file = createReadStream(resolvedPath);
   const importResponse = await client.agents.importFile({
     file,
@@ -96003,13 +96213,13 @@ async function importAgentFromFile(options) {
 }
 async function extractSkillsFromAf(afPath, destDir) {
   const extracted = [];
-  const content = await readFile12(afPath, "utf-8");
+  const content = await readFile13(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
   }
   for (const skill2 of afData.skills) {
-    const skillDir = resolve27(destDir, skill2.name);
+    const skillDir = resolve28(destDir, skill2.name);
     await mkdir10(skillDir, { recursive: true });
     if (skill2.files) {
       await writeSkillFiles(skillDir, skill2.files);
@@ -96029,7 +96239,7 @@ async function writeSkillFiles(skillDir, files) {
   }
 }
 async function writeSkillFile(skillDir, filePath, content) {
-  const fullPath = resolve27(skillDir, filePath);
+  const fullPath = resolve28(skillDir, filePath);
   await mkdir10(dirname15(fullPath), { recursive: true });
   await writeFile11(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
@@ -96048,13 +96258,13 @@ async function fetchSkillFromUrl(skillDir, sourceUrl) {
   const owner = parts[0];
   const repo = parts[1];
   const branch = parts[2];
-  const path25 = parts.slice(3).join("/");
+  const path26 = parts.slice(3).join("/");
   const { fetchGitHubContents: fetchGitHubContents2 } = await Promise.resolve().then(() => exports_github_utils);
-  const entries = await fetchGitHubContents2(owner, repo, branch, path25);
+  const entries = await fetchGitHubContents2(owner, repo, branch, path26);
   if (!Array.isArray(entries)) {
     throw new Error(`Expected directory at ${sourceUrl}, got file`);
   }
-  await downloadGitHubDirectory(entries, skillDir, owner, repo, branch, path25);
+  await downloadGitHubDirectory(entries, skillDir, owner, repo, branch, path26);
 }
 async function downloadGitHubDirectory(entries, destDir, owner, repo, branch, basePath) {
   const { fetchGitHubContents: fetchGitHubContents2 } = await Promise.resolve().then(() => exports_github_utils);
@@ -96361,12 +96571,12 @@ async function prepareHeadlessToolExecutionContext(params) {
   };
 }
 async function flushAndExit(code) {
-  const flushWritable = (stream2) => new Promise((resolve28) => {
+  const flushWritable = (stream2) => new Promise((resolve29) => {
     if (stream2.destroyed || stream2.writableEnded) {
-      resolve28();
+      resolve29();
       return;
     }
-    stream2.write("", () => resolve28());
+    stream2.write("", () => resolve29());
   });
   await Promise.allSettled([
     flushWritable(process.stdout),
@@ -97325,7 +97535,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
             }
-            await new Promise((resolve28) => setTimeout(resolve28, retryDelayMs));
+            await new Promise((resolve29) => setTimeout(resolve29, retryDelayMs));
             continue;
           }
         }
@@ -97374,7 +97584,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`Transient API error before streaming (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve28) => setTimeout(resolve28, delayMs));
+          await new Promise((resolve29) => setTimeout(resolve29, delayMs));
           conversationBusyRetries = 0;
           continue;
         }
@@ -97613,7 +97823,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve28) => setTimeout(resolve28, delayMs));
+          await new Promise((resolve29) => setTimeout(resolve29, delayMs));
           refreshCurrentInputOtids();
           continue;
         }
@@ -97703,7 +97913,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Empty LLM response, retrying (attempt ${attempt} of ${EMPTY_RESPONSE_MAX_RETRIES2})...`);
             }
-            await new Promise((resolve28) => setTimeout(resolve28, delayMs));
+            await new Promise((resolve29) => setTimeout(resolve29, delayMs));
             refreshCurrentInputOtids();
             continue;
           }
@@ -97731,7 +97941,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve28) => setTimeout(resolve28, delayMs));
+            await new Promise((resolve29) => setTimeout(resolve29, delayMs));
             refreshCurrentInputOtids();
             continue;
           }
@@ -97761,7 +97971,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve28) => setTimeout(resolve28, delayMs));
+            await new Promise((resolve29) => setTimeout(resolve29, delayMs));
             refreshCurrentInputOtids();
             continue;
           }
@@ -98101,9 +98311,9 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
     const syntheticUserLine = serializeQueuedMessageAsUserLine(queuedMessage);
     maybeNotifyBlocked(syntheticUserLine);
     if (lineResolver) {
-      const resolve28 = lineResolver;
+      const resolve29 = lineResolver;
       lineResolver = null;
-      resolve28(syntheticUserLine);
+      resolve29(syntheticUserLine);
       return;
     }
     lineQueue.push(syntheticUserLine);
@@ -98111,9 +98321,9 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
   rl.on("line", (line) => {
     maybeNotifyBlocked(line);
     if (lineResolver) {
-      const resolve28 = lineResolver;
+      const resolve29 = lineResolver;
       lineResolver = null;
-      resolve28(line);
+      resolve29(line);
     } else {
       lineQueue.push(line);
     }
@@ -98122,17 +98332,17 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
     setMessageQueueAdder(null);
     msgQueueRuntime.clear("shutdown");
     if (lineResolver) {
-      const resolve28 = lineResolver;
+      const resolve29 = lineResolver;
       lineResolver = null;
-      resolve28(null);
+      resolve29(null);
     }
   });
   async function getNextLine() {
     if (lineQueue.length > 0) {
       return lineQueue.shift() ?? null;
     }
-    return new Promise((resolve28) => {
-      lineResolver = resolve28;
+    return new Promise((resolve29) => {
+      lineResolver = resolve29;
     });
   }
   async function requestPermission(toolCallId, toolName, toolInput) {
@@ -98623,7 +98833,7 @@ async function runBidirectionalMode(agent, conversationId, client, _outputFormat
                 uuid: `retry-bidir-${randomUUID13()}`
               };
               console.log(JSON.stringify(retryMsg));
-              await new Promise((resolve28) => setTimeout(resolve28, delayMs));
+              await new Promise((resolve29) => setTimeout(resolve29, delayMs));
               continue;
             }
             throw preStreamError;
@@ -98925,10 +99135,10 @@ async function detectAndEnableKittyProtocol() {
     detectionComplete = true;
     return;
   }
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
       detectionComplete = true;
-      resolve28();
+      resolve29();
       return;
     }
     const originalRawMode = process.stdin.isRaw;
@@ -98961,7 +99171,7 @@ async function detectAndEnableKittyProtocol() {
         console.error("[kitty] protocol query unsupported; enabled anyway (best-effort)");
       }
       detectionComplete = true;
-      resolve28();
+      resolve29();
     };
     const handleData = (data) => {
       if (timeoutId === undefined) {
@@ -99174,13 +99384,13 @@ var init_reconcileExistingAgentState = __esm(() => {
 // src/agent/sessionHistory.ts
 import * as fs17 from "node:fs";
 import * as os6 from "node:os";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 function getHistoryDir() {
   const homeDir = os6.homedir();
-  return path25.join(homeDir, ".letta");
+  return path26.join(homeDir, ".letta");
 }
 function getHistoryFilePath() {
-  return path25.join(getHistoryDir(), "sessions.jsonl");
+  return path26.join(getHistoryDir(), "sessions.jsonl");
 }
 function recordSessionEnd(agentId, sessionId, stats, sessionInfo, cost, metadata) {
   const entry = {
@@ -117444,8 +117654,8 @@ function getHeader(command) {
       return `Run memory ${command}?`;
   }
 }
-function displayPath(path26) {
-  return path26.replace(/\.md$/, "");
+function displayPath(path27) {
+  return path27.replace(/\.md$/, "");
 }
 function truncate2(text, max) {
   if (text.length <= max)
@@ -117549,7 +117759,7 @@ var init_InlineMemoryApproval = __esm(async () => {
       const {
         command,
         reason,
-        path: path26,
+        path: path27,
         oldPath,
         newPath,
         oldString,
@@ -117596,9 +117806,9 @@ var init_InlineMemoryApproval = __esm(async () => {
                     }, undefined, false, undefined, this)
                   ]
                 }, undefined, true, undefined, this)
-              }, undefined, false, undefined, this) : path26 && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text2, {
+              }, undefined, false, undefined, this) : path27 && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text2, {
                 bold: true,
-                children: displayPath(path26)
+                children: displayPath(path27)
               }, undefined, false, undefined, this),
               command === "str_replace" && oldString != null && newString != null && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
                 flexDirection: "column",
@@ -121237,7 +121447,7 @@ var init_pasteRegistry = __esm(() => {
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync34, readFileSync as readFileSync20, statSync as statSync10, unlinkSync as unlinkSync10 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename9, extname as extname8, isAbsolute as isAbsolute19, join as join42, resolve as resolve28 } from "node:path";
+import { basename as basename9, extname as extname8, isAbsolute as isAbsolute20, join as join42, resolve as resolve29 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
 }
@@ -121284,8 +121494,8 @@ function translatePasteForImages(paste) {
           }
         } catch {}
       }
-      if (!isAbsolute19(filePath))
-        filePath = resolve28(process.cwd(), filePath);
+      if (!isAbsolute20(filePath))
+        filePath = resolve29(process.cwd(), filePath);
       const ext3 = extname8(filePath || "").toLowerCase();
       if (IMAGE_EXTS.has(ext3) && existsSync34(filePath) && statSync10(filePath).isFile()) {
         const buf = readFileSync20(filePath);
@@ -122220,14 +122430,14 @@ function installKeybindingForCurrentTerminal() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path26 = getKeybindingsPath(terminal);
-  if (!path26) {
+  const path27 = getKeybindingsPath(terminal);
+  if (!path27) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return installKeybinding(path26);
+  return installKeybinding(path27);
 }
 function removeKeybindingForCurrentTerminal() {
   const terminal = detectTerminalType();
@@ -122237,14 +122447,14 @@ function removeKeybindingForCurrentTerminal() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path26 = getKeybindingsPath(terminal);
-  if (!path26) {
+  const path27 = getKeybindingsPath(terminal);
+  if (!path27) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return removeKeybinding(path26);
+  return removeKeybinding(path27);
 }
 function isWezTerm() {
   return process.env.TERM_PROGRAM === "WezTerm";
@@ -122900,7 +123110,7 @@ __export(exports_custom, {
   COMMANDS_DIR: () => COMMANDS_DIR
 });
 import { existsSync as existsSync36 } from "node:fs";
-import { readdir as readdir9, readFile as readFile13 } from "node:fs/promises";
+import { readdir as readdir10, readFile as readFile14 } from "node:fs/promises";
 import { basename as basename10, dirname as dirname17, join as join44 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
@@ -122942,7 +123152,7 @@ async function discoverFromDirectory(dirPath, source2) {
 }
 async function findCommandFiles(currentPath, rootPath, commands2, source2) {
   try {
-    const entries = await readdir9(currentPath, { withFileTypes: true });
+    const entries = await readdir10(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = join44(currentPath, entry.name);
       if (entry.isDirectory()) {
@@ -122959,7 +123169,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source2) {
   } catch (_error) {}
 }
 async function parseCommandFile(filePath, rootPath, source2) {
-  const content = await readFile13(filePath, "utf-8");
+  const content = await readFile14(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const id = basename10(filePath, ".md");
   const relativePath = dirname17(filePath).slice(rootPath.length);
@@ -123311,11 +123521,11 @@ var init_HelpDialog = __esm(async () => {
 
 // src/hooks/writer.ts
 import { homedir as homedir34 } from "node:os";
-import { resolve as resolve29 } from "node:path";
+import { resolve as resolve30 } from "node:path";
 function isProjectSettingsPathCollidingWithGlobal2(workingDirectory) {
   const home = process.env.HOME || homedir34();
-  const globalSettingsPath = resolve29(home, ".letta", "settings.json");
-  const projectSettingsPath = resolve29(workingDirectory, ".letta", "settings.json");
+  const globalSettingsPath = resolve30(home, ".letta", "settings.json");
+  const projectSettingsPath = resolve30(workingDirectory, ".letta", "settings.json");
   return globalSettingsPath === projectSettingsPath;
 }
 function loadHooksFromLocation(location, workingDirectory = process.cwd()) {
@@ -125953,7 +126163,7 @@ var init_AgentInfoBar = __esm(async () => {
 
 // src/cli/helpers/fileSearch.ts
 import { readdirSync as readdirSync12, statSync as statSync11 } from "node:fs";
-import { join as join45, relative as relative16, resolve as resolve30 } from "node:path";
+import { join as join45, relative as relative16, resolve as resolve31 } from "node:path";
 function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [], depth = 0, maxDepth = 10, lowerPattern = pattern.toLowerCase()) {
   if (results.length >= maxResults || depth >= maxDepth) {
     return results;
@@ -125996,7 +126206,7 @@ async function searchFiles(query, deep = false) {
       const dirPart = query.slice(0, lastSlashIndex);
       const pattern = query.slice(lastSlashIndex + 1);
       try {
-        const resolvedDir = resolve30(getIndexRoot(), dirPart);
+        const resolvedDir = resolve31(getIndexRoot(), dirPart);
         try {
           statSync11(resolvedDir);
           searchDir = resolvedDir;
@@ -128321,9 +128531,9 @@ function buildInstallPrBody(workflowPath) {
   ].join(`
 `);
 }
-function checkRemoteFileExists(repo, path26) {
+function checkRemoteFileExists(repo, path27) {
   try {
-    runCommand("gh", ["api", `repos/${repo}/contents/${path26}`]);
+    runCommand("gh", ["api", `repos/${repo}/contents/${path27}`]);
     return true;
   } catch {
     return false;
@@ -135684,7 +135894,7 @@ var init_PersonalitySelector = __esm(async () => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import { homedir as homedir36 } from "node:os";
 import { join as join48 } from "node:path";
 async function parseAwsCredentials() {
@@ -135692,11 +135902,11 @@ async function parseAwsCredentials() {
   const configPath = join48(homedir36(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile14(credentialsPath, "utf-8");
+    const content = await readFile15(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile14(configPath, "utf-8");
+    const content = await readFile15(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -138303,8 +138513,8 @@ function MemoryDiffRenderer({
       }, undefined, false, undefined, this);
     }
     const command = args.command;
-    const path26 = args.path || args.old_path || "unknown";
-    const blockName = path26.split("/").pop() || path26;
+    const path27 = args.path || args.old_path || "unknown";
+    const blockName = path27.split("/").pop() || path27;
     switch (command) {
       case "str_replace": {
         const oldStr = args.old_string || args.old_str || "";
@@ -141176,7 +141386,7 @@ async function executeStatusLineCommand(command, payload, options) {
   };
 }
 function runWithLauncher(launcher, inputJson, timeout, signal, workingDirectory, startTime) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const [executable, ...args] = launcher;
     if (!executable) {
       reject(new Error("Empty launcher"));
@@ -141189,7 +141399,7 @@ function runWithLauncher(launcher, inputJson, timeout, signal, workingDirectory,
     const safeResolve = (result) => {
       if (!resolved) {
         resolved = true;
-        resolve31(result);
+        resolve32(result);
       }
     };
     let child;
@@ -142361,28 +142571,28 @@ var exports_export = {};
 __export(exports_export, {
   packageSkills: () => packageSkills
 });
-import { readdir as readdir10, readFile as readFile15 } from "node:fs/promises";
-import { relative as relative17, resolve as resolve31 } from "node:path";
+import { readdir as readdir11, readFile as readFile16 } from "node:fs/promises";
+import { relative as relative17, resolve as resolve32 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
   const skillNames = new Set;
   const dirsToCheck = skillsDir ? [skillsDir] : [
     agentId && getAgentSkillsDir(agentId),
-    resolve31(process.cwd(), ".skills"),
-    resolve31(process.env.HOME || "~", ".letta", "skills")
+    resolve32(process.cwd(), ".skills"),
+    resolve32(process.env.HOME || "~", ".letta", "skills")
   ].filter((dir) => Boolean(dir));
   for (const baseDir of dirsToCheck) {
     try {
-      const entries = await readdir10(baseDir, { withFileTypes: true });
+      const entries = await readdir11(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
         if (skillNames.has(entry.name))
           continue;
-        const skillDir = resolve31(baseDir, entry.name);
-        const skillMdPath = resolve31(skillDir, "SKILL.md");
+        const skillDir = resolve32(baseDir, entry.name);
+        const skillMdPath = resolve32(skillDir, "SKILL.md");
         try {
-          await readFile15(skillMdPath, "utf-8");
+          await readFile16(skillMdPath, "utf-8");
         } catch {
           console.warn(`Skipping invalid skill ${entry.name}: missing SKILL.md`);
           continue;
@@ -142408,13 +142618,13 @@ async function packageSkills(agentId, skillsDir) {
 async function readSkillFiles(skillDir) {
   const files = {};
   async function walk(dir) {
-    const entries = await readdir10(dir, { withFileTypes: true });
+    const entries = await readdir11(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = resolve31(dir, entry.name);
+      const fullPath = resolve32(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        const content = await readFile15(fullPath, "utf-8");
+        const content = await readFile16(fullPath, "utf-8");
         const relativePath = relative17(skillDir, fullPath).replace(/\\/g, "/");
         files[relativePath] = content;
       }
@@ -142434,8 +142644,8 @@ async function findSkillSourceUrl(skillName) {
   }
   return null;
 }
-async function fetchGitHubDirs(path26) {
-  const [owner, repo, branch, ...pathParts] = path26.split("/");
+async function fetchGitHubDirs(path27) {
+  const [owner, repo, branch, ...pathParts] = path27.split("/");
   if (!owner || !repo || !branch)
     return new Set;
   try {
@@ -144592,12 +144802,12 @@ Memory may be stale. Try running: git -C ~/.letta/agents/${agentId}/memory pull`
     let watcher = null;
     (async () => {
       try {
-        const { watch } = await import("node:fs");
+        const { watch: watch2 } = await import("node:fs");
         const { existsSync: existsSync43 } = await import("node:fs");
         const memRoot = getMemoryFilesystemRoot(agentId);
         if (!existsSync43(memRoot))
           return;
-        watcher = watch(memRoot, { recursive: true }, () => {});
+        watcher = watch2(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher;
         debugLog("memfs", `Watching memory directory: ${memRoot}`);
         watcher.on("error", (err) => {
@@ -144924,7 +145134,7 @@ ${newState.originalPrompt}`,
                   cancelled = true;
                   break;
                 }
-                await new Promise((resolve32) => setTimeout(resolve32, 100));
+                await new Promise((resolve33) => setTimeout(resolve33, 100));
               }
               buffersRef.current.byId.delete(statusId);
               buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
@@ -144988,7 +145198,7 @@ ${newState.originalPrompt}`,
                 cancelled = true;
                 break;
               }
-              await new Promise((resolve32) => setTimeout(resolve32, 100));
+              await new Promise((resolve33) => setTimeout(resolve33, 100));
             }
             if (retryStatusId) {
               buffersRef.current.byId.delete(retryStatusId);
@@ -145746,7 +145956,7 @@ ${feedback}
           });
           buffersRef.current.order.push(statusId);
           refreshDerived();
-          await new Promise((resolve32) => setTimeout(resolve32, delayMs));
+          await new Promise((resolve33) => setTimeout(resolve33, delayMs));
           buffersRef.current.byId.delete(statusId);
           buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
           refreshDerived();
@@ -145806,7 +146016,7 @@ ${feedback}
               cancelled = true;
               break;
             }
-            await new Promise((resolve32) => setTimeout(resolve32, 100));
+            await new Promise((resolve33) => setTimeout(resolve33, 100));
           }
           if (retryStatusId) {
             buffersRef.current.byId.delete(retryStatusId);
@@ -152514,14 +152724,14 @@ function installKeybindingForCurrentTerminal2() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path26 = getKeybindingsPath2(terminal);
-  if (!path26) {
+  const path27 = getKeybindingsPath2(terminal);
+  if (!path27) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return installKeybinding2(path26);
+  return installKeybinding2(path27);
 }
 function removeKeybindingForCurrentTerminal2() {
   const terminal = detectTerminalType2();
@@ -152531,14 +152741,14 @@ function removeKeybindingForCurrentTerminal2() {
       error: "Not running in a VS Code-like terminal"
     };
   }
-  const path26 = getKeybindingsPath2(terminal);
-  if (!path26) {
+  const path27 = getKeybindingsPath2(terminal);
+  if (!path27) {
     return {
       success: false,
       error: `Could not determine keybindings.json path for ${terminal}`
     };
   }
-  return removeKeybinding2(path26);
+  return removeKeybinding2(path27);
 }
 function isWezTerm2() {
   return process.env.TERM_PROGRAM === "WezTerm";
@@ -153174,11 +153384,11 @@ __export(exports_import2, {
   extractSkillsFromAf: () => extractSkillsFromAf2
 });
 import { createReadStream as createReadStream2 } from "node:fs";
-import { chmod as chmod2, mkdir as mkdir11, readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname20, resolve as resolve32 } from "node:path";
+import { chmod as chmod2, mkdir as mkdir11, readFile as readFile17, writeFile as writeFile12 } from "node:fs/promises";
+import { dirname as dirname20, resolve as resolve33 } from "node:path";
 async function importAgentFromFile2(options) {
   const client = await getClient();
-  const resolvedPath = resolve32(options.filePath);
+  const resolvedPath = resolve33(options.filePath);
   const file = createReadStream2(resolvedPath);
   const importResponse = await client.agents.importFile({
     file,
@@ -153207,13 +153417,13 @@ async function importAgentFromFile2(options) {
 }
 async function extractSkillsFromAf2(afPath, destDir) {
   const extracted = [];
-  const content = await readFile16(afPath, "utf-8");
+  const content = await readFile17(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
   }
   for (const skill2 of afData.skills) {
-    const skillDir = resolve32(destDir, skill2.name);
+    const skillDir = resolve33(destDir, skill2.name);
     await mkdir11(skillDir, { recursive: true });
     if (skill2.files) {
       await writeSkillFiles2(skillDir, skill2.files);
@@ -153233,7 +153443,7 @@ async function writeSkillFiles2(skillDir, files) {
   }
 }
 async function writeSkillFile2(skillDir, filePath, content) {
-  const fullPath = resolve32(skillDir, filePath);
+  const fullPath = resolve33(skillDir, filePath);
   await mkdir11(dirname20(fullPath), { recursive: true });
   await writeFile12(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
@@ -153252,13 +153462,13 @@ async function fetchSkillFromUrl2(skillDir, sourceUrl) {
   const owner = parts[0];
   const repo = parts[1];
   const branch = parts[2];
-  const path26 = parts.slice(3).join("/");
+  const path27 = parts.slice(3).join("/");
   const { fetchGitHubContents: fetchGitHubContents2 } = await Promise.resolve().then(() => exports_github_utils);
-  const entries = await fetchGitHubContents2(owner, repo, branch, path26);
+  const entries = await fetchGitHubContents2(owner, repo, branch, path27);
   if (!Array.isArray(entries)) {
     throw new Error(`Expected directory at ${sourceUrl}, got file`);
   }
-  await downloadGitHubDirectory2(entries, skillDir, owner, repo, branch, path26);
+  await downloadGitHubDirectory2(entries, skillDir, owner, repo, branch, path27);
 }
 async function downloadGitHubDirectory2(entries, destDir, owner, repo, branch, basePath) {
   const { fetchGitHubContents: fetchGitHubContents2 } = await Promise.resolve().then(() => exports_github_utils);
@@ -158271,23 +158481,21 @@ async function runListenSubcommand(argv) {
     process.exit(code);
   };
   await settingsManager.loadLocalProjectSettings();
-  if (values.channels) {
-    const channelNames = values.channels.split(",").map((s) => s.trim()).filter(Boolean);
-    if (channelNames.length > 0) {
-      if (values["install-channel-runtimes"]) {
-        const { ensureChannelRuntimeInstalled: ensureChannelRuntimeInstalled2 } = await Promise.resolve().then(() => (init_runtimeDeps(), exports_runtimeDeps));
-        const { isSupportedChannelId: isSupportedChannelId2 } = await Promise.resolve().then(() => (init_pluginRegistry(), exports_pluginRegistry));
-        for (const channelName of channelNames) {
-          if (!isSupportedChannelId2(channelName)) {
-            console.error(`Unknown channel "${channelName}" passed to --channels.`);
-            return 1;
-          }
-          await ensureChannelRuntimeInstalled2(channelName);
+  const channelNames = values.channels ? values.channels.split(",").map((s) => s.trim()).filter(Boolean) : process.env.LETTA_RESTORE_ENABLED_CHANNELS === "1" ? (await Promise.resolve().then(() => (init_service(), exports_service))).listEnabledChannelIds() : [];
+  if (channelNames.length > 0) {
+    if (values.channels && values["install-channel-runtimes"]) {
+      const { ensureChannelRuntimeInstalled: ensureChannelRuntimeInstalled2 } = await Promise.resolve().then(() => (init_runtimeDeps(), exports_runtimeDeps));
+      const { isSupportedChannelId: isSupportedChannelId2 } = await Promise.resolve().then(() => (init_pluginRegistry(), exports_pluginRegistry));
+      for (const channelName of channelNames) {
+        if (!isSupportedChannelId2(channelName)) {
+          console.error(`Unknown channel "${channelName}" passed to --channels.`);
+          return 1;
         }
+        await ensureChannelRuntimeInstalled2(channelName);
       }
-      const { initializeChannels: initializeChannels2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
-      await initializeChannels2(channelNames);
     }
+    const { initializeChannels: initializeChannels2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
+    await initializeChannels2(channelNames);
   }
   let connectionName;
   if (values["env-name"]) {
@@ -158301,11 +158509,11 @@ async function runListenSubcommand(argv) {
       connectionName = hostname3();
       settingsManager.setListenerEnvName(connectionName);
     } else {
-      connectionName = await new Promise((resolve24) => {
+      connectionName = await new Promise((resolve25) => {
         const { unmount } = render_default(/* @__PURE__ */ jsx_dev_runtime9.jsxDEV(PromptEnvName, {
           onSubmit: (name) => {
             unmount();
-            resolve24(name);
+            resolve25(name);
           }
         }, undefined, false, undefined, this));
       });
@@ -158508,7 +158716,7 @@ async function runListenSubcommand(argv) {
 // src/cli/subcommands/memfs.ts
 init_memoryGit();
 import { cpSync, existsSync as existsSync26, mkdirSync as mkdirSync19, rmSync as rmSync3, statSync as statSync8 } from "node:fs";
-import { readdir as readdir6 } from "node:fs/promises";
+import { readdir as readdir7 } from "node:fs/promises";
 import { homedir as homedir24 } from "node:os";
 import { join as join31 } from "node:path";
 import { parseArgs as parseArgs8 } from "node:util";
@@ -158575,22 +158783,22 @@ async function listBackups(agentId) {
   if (!existsSync26(agentRoot)) {
     return [];
   }
-  const entries = await readdir6(agentRoot, { withFileTypes: true });
+  const entries = await readdir7(agentRoot, { withFileTypes: true });
   const backups = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (!entry.name.startsWith("memory-backup-"))
       continue;
-    const path23 = join31(agentRoot, entry.name);
+    const path24 = join31(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat6 = statSync8(path23);
-      createdAt = stat6.mtime.toISOString();
+      const stat7 = statSync8(path24);
+      createdAt = stat7.mtime.toISOString();
     } catch {
       createdAt = null;
     }
-    backups.push({ name: entry.name, path: path23, createdAt });
+    backups.push({ name: entry.name, path: path24, createdAt });
   }
   backups.sort((a, b) => a.name.localeCompare(b.name));
   return backups;
@@ -158694,8 +158902,8 @@ async function runMemfsSubcommand(argv) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat6 = statSync8(backupPath);
-      if (!stat6.isDirectory()) {
+      const stat7 = statSync8(backupPath);
+      if (!stat7.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
       }
@@ -158717,9 +158925,9 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       if (existsSync26(out)) {
-        const stat6 = statSync8(out);
-        if (stat6.isDirectory()) {
-          const contents = await readdir6(out);
+        const stat7 = statSync8(out);
+        if (stat7.isDirectory()) {
+          const contents = await readdir7(out);
           if (contents.length > 0) {
             console.error(`Export directory not empty: ${out}`);
             return 1;
@@ -158748,7 +158956,7 @@ async function runMemfsSubcommand(argv) {
 init_client2();
 init_settings_manager();
 import { writeFile as writeFile9 } from "node:fs/promises";
-import { resolve as resolve24 } from "node:path";
+import { resolve as resolve25 } from "node:path";
 import { parseArgs as parseArgs9 } from "node:util";
 function printUsage6() {
   console.log(`
@@ -159053,7 +159261,7 @@ async function runMessagesSubcommand(argv) {
 
 `).trim();
       if (outputPathRaw && typeof outputPathRaw === "string") {
-        const outputPath = resolve24(process.cwd(), outputPathRaw);
+        const outputPath = resolve25(process.cwd(), outputPathRaw);
         await writeFile9(outputPath, `${transcript}
 `, "utf-8");
         console.log(JSON.stringify({
@@ -159115,13 +159323,13 @@ init_memoryScope();
 init_readOnlyShell();
 init_shell_command_normalization();
 import { homedir as homedir25 } from "node:os";
-import { isAbsolute as isAbsolute17, join as join32, relative as relative13 } from "node:path";
+import { isAbsolute as isAbsolute18, join as join32, relative as relative13 } from "node:path";
 var MODE_KEY2 = Symbol.for("@letta/permissionMode");
 var PLAN_FILE_KEY2 = Symbol.for("@letta/planFilePath");
 var MODE_BEFORE_PLAN_KEY2 = Symbol.for("@letta/permissionModeBeforePlan");
 function everyResolvedTargetIsWithinRoots2(candidatePaths, roots, workingDirectory) {
-  return candidatePaths.length > 0 && candidatePaths.every((path23) => {
-    const resolvedPath = resolveScopedTargetPath(path23, workingDirectory);
+  return candidatePaths.length > 0 && candidatePaths.every((path24) => {
+    const resolvedPath = resolveScopedTargetPath(path24, workingDirectory);
     return resolvedPath ? isPathWithinRoots(resolvedPath, roots) : false;
   });
 }
@@ -159155,11 +159363,11 @@ function setGlobalModeBeforePlan2(value) {
 function resolvePlanTargetPath2(targetPath, workingDirectory) {
   return resolveScopedTargetPath(targetPath, workingDirectory);
 }
-function isPathInPlansDir2(path23, plansDir) {
-  if (!path23.endsWith(".md"))
+function isPathInPlansDir2(path24, plansDir) {
+  if (!path24.endsWith(".md"))
     return false;
-  const rel = relative13(plansDir, path23);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute17(rel);
+  const rel = relative13(plansDir, path24);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute18(rel);
 }
 function extractApplyPatchPaths2(input) {
   const paths = [];
@@ -159260,8 +159468,8 @@ class PermissionModeManager2 {
   getMode() {
     return this.currentMode;
   }
-  setPlanFilePath(path23) {
-    setGlobalPlanFilePath2(path23);
+  setPlanFilePath(path24) {
+    setGlobalPlanFilePath2(path24);
   }
   getPlanFilePath() {
     return getGlobalPlanFilePath2();
@@ -159356,8 +159564,8 @@ class PermissionModeManager2 {
           } else if (typeof targetPath === "string") {
             candidatePaths = [targetPath];
           }
-          if (candidatePaths.length > 0 && candidatePaths.every((path23) => {
-            const resolvedPath = resolvePlanTargetPath2(path23, workingDirectory);
+          if (candidatePaths.length > 0 && candidatePaths.every((path24) => {
+            const resolvedPath = resolvePlanTargetPath2(path24, workingDirectory);
             return resolvedPath ? isPathInPlansDir2(resolvedPath, plansDir) : false;
           })) {
             return "allow";
@@ -159516,7 +159724,7 @@ init_fs();
 init_secrets();
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { homedir as homedir26 } from "node:os";
-import { join as join33, resolve as resolve25 } from "node:path";
+import { join as join33, resolve as resolve26 } from "node:path";
 var DEFAULT_SETTINGS3 = {
   lastAgent: null,
   tokenStreaming: false,
@@ -159970,7 +160178,7 @@ class SettingsManager2 {
     return join33(workingDirectory, ".letta", "settings.json");
   }
   isProjectSettingsPathCollidingWithGlobal(workingDirectory) {
-    return resolve25(this.getProjectSettingsPath(workingDirectory)) === resolve25(this.getSettingsPath());
+    return resolve26(this.getProjectSettingsPath(workingDirectory)) === resolve26(this.getSettingsPath());
   }
   getLocalProjectSettingsPath(workingDirectory) {
     return join33(workingDirectory, ".letta", "settings.local.json");
@@ -160915,6 +161123,7 @@ var STREAMING_SHELL_TOOLS2 = new Set([
   "run_shell_command",
   "RunShellCommand"
 ]);
+var FILE_MUTATING_TOOLS2 = new Set(["Edit", "Write", "MultiEdit", "replace"]);
 var ANTHROPIC_DEFAULT_TOOLS2 = [
   "AskUserQuestion",
   "Bash",
@@ -160985,8 +161194,8 @@ function acquireSwitchLock2() {
   const lock = getSwitchLock2();
   lock.refCount++;
   if (lock.refCount === 1) {
-    lock.promise = new Promise((resolve26) => {
-      lock.resolve = resolve26;
+    lock.promise = new Promise((resolve27) => {
+      lock.resolve = resolve27;
     });
   }
 }
@@ -161475,7 +161684,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     printHelp();
     const helpDelayMs = Number.parseInt(process.env.LETTA_TEST_HELP_EXIT_DELAY_MS ?? "", 10);
     if (Number.isFinite(helpDelayMs) && helpDelayMs > 0) {
-      await new Promise((resolve33) => setTimeout(resolve33, helpDelayMs));
+      await new Promise((resolve34) => setTimeout(resolve34, helpDelayMs));
     }
     process.exit(0);
   }
@@ -161697,9 +161906,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
         process.exit(1);
       }
     } else {
-      const { resolve: resolve33 } = await import("path");
+      const { resolve: resolve34 } = await import("path");
       const { existsSync: existsSync45 } = await import("fs");
-      const resolvedPath = resolve33(fromAfFile);
+      const resolvedPath = resolve34(fromAfFile);
       if (!existsSync45(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
@@ -162579,4 +162788,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=F6C28381AA0FA8FC64756E2164756E21
+//# debugId=6821E41BE6A3D26164756E2164756E21