@letta-ai/letta-code 0.23.6 → 0.23.8

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.23.6",
+    version: "0.23.8",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -39657,6 +39657,9 @@ var init_personality = __esm(() => {
 import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join9 } from "node:path";
+function getChannelsRoot() {
+  return CHANNELS_ROOT;
+}
 function getChannelDir(channelId) {
   return join9(CHANNELS_ROOT, channelId);
 }
@@ -39675,6 +39678,9 @@ function getChannelPairingPath(channelId) {
 function getChannelTargetsPath(channelId) {
   return join9(getChannelDir(channelId), "targets.json");
 }
+function getPendingChannelControlRequestsPath() {
+  return join9(getChannelsRoot(), "pending-control-requests.json");
+}
 function parseSimpleYaml(text) {
   const result = {};
   const lines = text.split(`
@@ -40138,6 +40144,357 @@ var init_types = __esm(() => {
   SUPPORTED_CHANNEL_IDS = ["telegram", "slack"];
 });
 
+// src/channels/interactive.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isAffirmativeResponse(text) {
+  const normalized = normalizeWhitespace(text).toLowerCase();
+  return [
+    "approve",
+    "approved",
+    "allow",
+    "yes",
+    "y",
+    "ok",
+    "okay",
+    "continue",
+    "go ahead",
+    "looks good",
+    "lgtm",
+    "sgtm",
+    "ship it"
+  ].includes(normalized);
+}
+function isNegativeResponse(text) {
+  const normalized = normalizeWhitespace(text).toLowerCase();
+  return [
+    "deny",
+    "denied",
+    "reject",
+    "rejected",
+    "no",
+    "n",
+    "cancel",
+    "skip",
+    "keep planning"
+  ].includes(normalized);
+}
+function stripApprovalPrefix(text) {
+  return normalizeWhitespace(text.replace(/^(approve|allow|yes|y|ok|okay|deny|reject|no|n)\s*[:-]?\s*/i, ""));
+}
+function summarizeControlRequestInput(input) {
+  const serialized = JSON.stringify(input, null, 2);
+  if (!serialized || serialized === "{}") {
+    return null;
+  }
+  if (serialized.length <= 1200) {
+    return serialized;
+  }
+  return `${serialized.slice(0, 1197).trimEnd()}...`;
+}
+function summarizePlanPreview(planContent) {
+  const normalized = planContent.trim();
+  if (!normalized) {
+    return "";
+  }
+  const maxLength = 1800;
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength).trimEnd()}
+
+[Plan preview truncated for channel delivery.]`;
+}
+function buildQuestionPrompt(question, index) {
+  const lines = [
+    `${index + 1}. ${question.question ?? `Question ${index + 1}`}`
+  ];
+  const options = question.options ?? [];
+  options.forEach((option, optionIndex) => {
+    const label = option.label?.trim() || `Option ${optionIndex + 1}`;
+    const description = option.description?.trim();
+    lines.push(description ? `   ${optionIndex + 1}) ${label} — ${description}` : `   ${optionIndex + 1}) ${label}`);
+  });
+  if (question.multiSelect) {
+    lines.push("   Choose one or more options. Separate multiple answers with commas.");
+  }
+  return lines;
+}
+function matchQuestionOption(question, text) {
+  const trimmed = normalizeWhitespace(text);
+  const options = question.options ?? [];
+  if (!trimmed || options.length === 0) {
+    return trimmed;
+  }
+  const numberMatch = trimmed.match(/^(\d+)$/);
+  if (numberMatch?.[1]) {
+    const option = options[Number(numberMatch[1]) - 1];
+    if (option?.label?.trim()) {
+      return option.label.trim();
+    }
+  }
+  const exactLabel = options.find((option) => option.label && normalizeWhitespace(option.label).toLowerCase() === trimmed.toLowerCase());
+  if (exactLabel?.label?.trim()) {
+    return exactLabel.label.trim();
+  }
+  return trimmed;
+}
+function matchQuestionAnswer(question, text) {
+  if (!question.multiSelect) {
+    return matchQuestionOption(question, text);
+  }
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return normalized;
+  }
+  const selections = normalized.replace(/\band\b/gi, ",").split(/\s*(?:,|\/|;)\s*/).map((entry) => normalizeWhitespace(entry)).filter(Boolean);
+  if (selections.length <= 1) {
+    return matchQuestionOption(question, normalized);
+  }
+  const matchedSelections = Array.from(new Set(selections.map((selection) => matchQuestionOption(question, selection)).filter(Boolean)));
+  return matchedSelections.length > 0 ? matchedSelections.join(", ") : normalized;
+}
+function parseNumberedAnswers(rawText, questions) {
+  const matches = Array.from(rawText.matchAll(/(?:^|\n)\s*(\d+)[).:-]\s*(.+?)(?=(?:\n\s*\d+[).:-]\s*)|$)/gs));
+  if (matches.length === 0) {
+    return null;
+  }
+  const answers = {};
+  for (const match of matches) {
+    const questionIndex = Number(match[1]) - 1;
+    const question = questions[questionIndex];
+    const answerText = match[2]?.trim();
+    if (!question?.question || !answerText) {
+      continue;
+    }
+    answers[question.question] = matchQuestionAnswer(question, answerText);
+  }
+  return Object.keys(answers).length > 0 ? answers : null;
+}
+function buildAllowResponse(requestId, decision) {
+  return {
+    request_id: requestId,
+    decision
+  };
+}
+function buildDenyResponse(requestId, message) {
+  return {
+    request_id: requestId,
+    decision: {
+      behavior: "deny",
+      message
+    }
+  };
+}
+function getAskUserQuestionInput(input) {
+  return input;
+}
+function formatAskUserQuestionPrompt(event) {
+  const input = getAskUserQuestionInput(event.input);
+  const questions = (input.questions ?? []).filter((question) => normalizeWhitespace(question.question ?? ""));
+  const lines = [
+    "The agent needs an answer before it can continue.",
+    "",
+    ...questions.flatMap((question, index) => buildQuestionPrompt(question, index)),
+    ""
+  ];
+  if (questions.length <= 1) {
+    const singleQuestion = questions[0];
+    lines.push(singleQuestion?.multiSelect ? "Reply with one or more option numbers/labels separated by commas, or just send a freeform answer in your next message." : "Reply with an option number/label, or just send a freeform answer in your next message.");
+  } else {
+    lines.push("Reply with numbered lines, for example:", "1: your answer", "2: your answer", "", "You can also use option numbers or option labels. For multi-select questions, separate multiple answers with commas.");
+  }
+  return lines.join(`
+`);
+}
+function formatEnterPlanModePrompt() {
+  return [
+    "The agent wants to enter plan mode before making changes.",
+    "",
+    "Reply `approve` to let it plan first, or reply `deny` to skip planning and continue normally."
+  ].join(`
+`);
+}
+function formatExitPlanModePrompt(event) {
+  const lines = [
+    "The agent is ready to leave plan mode and start implementing."
+  ];
+  if (event.planContent?.trim()) {
+    lines.push("", "Proposed plan:", summarizePlanPreview(event.planContent));
+    if (event.planFilePath?.trim()) {
+      lines.push("", `Plan file: ${event.planFilePath.trim()}`);
+    }
+  }
+  lines.push("", "Reply `approve` to accept the plan and start coding.", "Reply with feedback instead if you want the agent to keep planning.");
+  return lines.join(`
+`);
+}
+function formatGenericToolApprovalPrompt(event) {
+  const inputSummary = summarizeControlRequestInput(event.input);
+  const lines = [`The agent wants approval to run \`${event.toolName}\`.`];
+  if (inputSummary) {
+    lines.push("", "Tool input:", inputSummary);
+  }
+  lines.push("", "Reply `approve` to allow it.", "Reply with feedback instead if you want to deny it.");
+  return lines.join(`
+`);
+}
+function formatChannelControlRequestPrompt(event) {
+  switch (event.kind) {
+    case "ask_user_question":
+      return formatAskUserQuestionPrompt(event);
+    case "enter_plan_mode":
+      return formatEnterPlanModePrompt();
+    case "exit_plan_mode":
+      return formatExitPlanModePrompt(event);
+    case "generic_tool_approval":
+      return formatGenericToolApprovalPrompt(event);
+    default: {
+      const exhaustiveCheck = event.kind;
+      return exhaustiveCheck;
+    }
+  }
+}
+function parseAskUserQuestionResponse(event, rawText) {
+  const input = getAskUserQuestionInput(event.input);
+  const questions = (input.questions ?? []).filter((question) => normalizeWhitespace(question.question ?? ""));
+  if (questions.length === 0) {
+    return {
+      type: "reprompt",
+      message: "I couldn't find the original question payload. Please ask the agent to try again."
+    };
+  }
+  if (questions.length === 1) {
+    const [question] = questions;
+    if (!question?.question) {
+      return {
+        type: "reprompt",
+        message: "I couldn't find the original question text. Please ask the agent to try again."
+      };
+    }
+    const answer = matchQuestionAnswer(question, rawText);
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow",
+        updated_input: {
+          ...event.input,
+          answers: {
+            ...input.answers ?? {},
+            [question.question]: answer
+          }
+        }
+      })
+    };
+  }
+  const numberedAnswers = parseNumberedAnswers(rawText, questions);
+  if (!numberedAnswers) {
+    return {
+      type: "reprompt",
+      message: `Please answer with numbered lines so I can map each reply to the right question.
+Example:
+1: your answer
+2: your answer`
+    };
+  }
+  const missingQuestions = questions.filter((question) => question.question && !Object.hasOwn(numberedAnswers, question.question));
+  if (missingQuestions.length > 0) {
+    return {
+      type: "reprompt",
+      message: `I still need answers for: ${missingQuestions.map((question) => question.question).join(", ")}`
+    };
+  }
+  return {
+    type: "response",
+    response: buildAllowResponse(event.requestId, {
+      behavior: "allow",
+      updated_input: {
+        ...event.input,
+        answers: {
+          ...input.answers ?? {},
+          ...numberedAnswers
+        }
+      }
+    })
+  };
+}
+function parseEnterPlanModeResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow"
+      })
+    };
+  }
+  if (isNegativeResponse(rawText)) {
+    return {
+      type: "response",
+      response: buildDenyResponse(event.requestId, "User chose to skip plan mode and continue implementing directly.")
+    };
+  }
+  return {
+    type: "reprompt",
+    message: "Reply `approve` to let the agent enter plan mode, or `deny` to skip planning."
+  };
+}
+function parseExitPlanModeResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow"
+      })
+    };
+  }
+  const feedback = stripApprovalPrefix(rawText);
+  return {
+    type: "response",
+    response: buildDenyResponse(event.requestId, feedback || "Please keep planning and revise the proposal.")
+  };
+}
+function parseGenericToolApprovalResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    const message = stripApprovalPrefix(rawText);
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow",
+        ...message ? { message } : {}
+      })
+    };
+  }
+  const feedback = stripApprovalPrefix(rawText);
+  return {
+    type: "response",
+    response: buildDenyResponse(event.requestId, feedback || "Denied by channel user.")
+  };
+}
+function parseChannelControlRequestResponse(event, rawText) {
+  const trimmed = rawText.trim();
+  if (!trimmed) {
+    return {
+      type: "reprompt",
+      message: formatChannelControlRequestPrompt(event)
+    };
+  }
+  switch (event.kind) {
+    case "ask_user_question":
+      return parseAskUserQuestionResponse(event, trimmed);
+    case "enter_plan_mode":
+      return parseEnterPlanModeResponse(event, trimmed);
+    case "exit_plan_mode":
+      return parseExitPlanModeResponse(event, trimmed);
+    case "generic_tool_approval":
+      return parseGenericToolApprovalResponse(event, trimmed);
+    default: {
+      const exhaustiveCheck = event.kind;
+      return exhaustiveCheck;
+    }
+  }
+}
+
 // src/channels/telegram/media.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
@@ -41121,6 +41478,13 @@ function createTelegramAdapter(config) {
       } : undefined;
       await telegramBot.api.sendMessage(chatId, text, reply_parameters ? { reply_parameters } : {});
     },
+    async handleControlRequestEvent(event) {
+      const telegramBot = await ensureBot();
+      const reply_parameters = event.source.messageId || event.source.threadId ? {
+        message_id: Number(event.source.threadId ?? event.source.messageId)
+      } : undefined;
+      await telegramBot.api.sendMessage(event.source.chatId, formatChannelControlRequestPrompt(event), reply_parameters ? { reply_parameters } : {});
+    },
     onMessage: undefined
   };
   return adapter;
@@ -42280,6 +42644,16 @@ function createSlackAdapter(config) {
       });
       rememberMessageThread(response.ts, options?.replyToMessageId ?? response.ts ?? null);
     },
+    async handleControlRequestEvent(event) {
+      await ensureApp();
+      const slackClient = await ensureWriteClient();
+      const response = await slackClient.chat.postMessage({
+        channel: event.source.chatId,
+        text: formatChannelControlRequestPrompt(event),
+        ...event.source.threadId ?? event.source.messageId ? { thread_ts: event.source.threadId ?? event.source.messageId } : {}
+      });
+      rememberMessageThread(response.ts, event.source.threadId ?? event.source.messageId ?? response.ts ?? null);
+    },
     async prepareInboundMessage(msg, options) {
       if (!options?.isFirstRouteTurn || msg.channel !== "slack" || msg.chatType !== "channel" || !isNonEmptyString2(msg.threadId) || !isNonEmptyString2(msg.messageId)) {
         return msg;
@@ -42614,6 +42988,93 @@ var init_pluginRegistry = __esm(() => {
   };
 });
 
+// src/channels/pendingControlRequests.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+function cloneEvent(event) {
+  return structuredClone(event);
+}
+function cloneStore(nextStore) {
+  return {
+    requests: nextStore.requests.map((event) => cloneEvent(event))
+  };
+}
+function isChannelControlRequestEvent(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.requestId === "string" && candidate.source !== undefined && typeof candidate.source === "object" && candidate.source !== null && typeof candidate.source.channel === "string" && typeof candidate.source.chatId === "string" && typeof candidate.source.agentId === "string" && typeof candidate.source.conversationId === "string" && typeof candidate.toolName === "string" && candidate.input !== null && typeof candidate.input === "object";
+}
+function ensureStoreLoaded() {
+  if (storeLoaded) {
+    return;
+  }
+  storeLoaded = true;
+  if (loadPendingControlRequestStoreOverride) {
+    const overridden = loadPendingControlRequestStoreOverride();
+    store = overridden ? cloneStore(overridden) : EMPTY_STORE();
+    return;
+  }
+  const storePath = getPendingChannelControlRequestsPath();
+  if (!existsSync13(storePath)) {
+    store = EMPTY_STORE();
+    return;
+  }
+  try {
+    const text = readFileSync10(storePath, "utf-8");
+    const parsed = JSON.parse(text);
+    store = {
+      requests: Array.isArray(parsed.requests) ? parsed.requests.filter(isChannelControlRequestEvent).map(cloneEvent) : []
+    };
+  } catch {
+    store = EMPTY_STORE();
+  }
+}
+function saveStore() {
+  ensureStoreLoaded();
+  const snapshot = cloneStore(store);
+  if (savePendingControlRequestStoreOverride) {
+    savePendingControlRequestStoreOverride(snapshot);
+    return;
+  }
+  const storePath = getPendingChannelControlRequestsPath();
+  mkdirSync10(dirname4(storePath), { recursive: true });
+  writeFileSync8(storePath, `${JSON.stringify(snapshot, null, 2)}
+`, "utf-8");
+}
+function listPendingControlRequests() {
+  ensureStoreLoaded();
+  return store.requests.map((event) => cloneEvent(event));
+}
+function upsertPendingControlRequest(event) {
+  ensureStoreLoaded();
+  const nextEvent = cloneEvent(event);
+  const existingIndex = store.requests.findIndex((candidate) => candidate.requestId === event.requestId);
+  if (existingIndex >= 0) {
+    store.requests[existingIndex] = nextEvent;
+  } else {
+    store.requests.push(nextEvent);
+  }
+  saveStore();
+  return cloneEvent(nextEvent);
+}
+function removePendingControlRequest(requestId) {
+  ensureStoreLoaded();
+  const nextRequests = store.requests.filter((candidate) => candidate.requestId !== requestId);
+  if (nextRequests.length === store.requests.length) {
+    return false;
+  }
+  store.requests = nextRequests;
+  saveStore();
+  return true;
+}
+var EMPTY_STORE = () => ({ requests: [] }), store, storeLoaded = false, loadPendingControlRequestStoreOverride = null, savePendingControlRequestStoreOverride = null;
+var init_pendingControlRequests = __esm(() => {
+  init_config();
+  store = EMPTY_STORE();
+});
+
 // src/channels/routing.ts
 var exports_routing = {};
 __export(exports_routing, {
@@ -42633,7 +43094,7 @@ __export(exports_routing, {
   __testOverrideSaveRoutes: () => __testOverrideSaveRoutes,
   __testOverrideLoadRoutes: () => __testOverrideLoadRoutes
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
 function normalizeAccountId2(accountId) {
   return accountId ?? LEGACY_CHANNEL_ACCOUNT_ID;
 }
@@ -42674,10 +43135,10 @@ function loadRoutes(channelId) {
     return;
   }
   const path2 = getChannelRoutingPath(channelId);
-  if (!existsSync13(path2))
+  if (!existsSync14(path2))
     return;
   try {
-    const text = readFileSync10(path2, "utf-8");
+    const text = readFileSync11(path2, "utf-8");
     const parsed = JSON.parse(text);
     const routes = parsed.routes ?? [];
     for (const route of routes) {
@@ -42709,10 +43170,10 @@ function saveRoutes(channelId) {
     return;
   }
   const dir = getChannelDir(channelId);
-  mkdirSync10(dir, { recursive: true });
+  mkdirSync11(dir, { recursive: true });
   const routes = getRoutesForChannel(channelId);
   const data = { routes };
-  writeFileSync8(getChannelRoutingPath(channelId), `${JSON.stringify(data, null, 2)}
+  writeFileSync9(getChannelRoutingPath(channelId), `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 function getRoute(channel, chatId, accountId, threadId) {
@@ -42802,14 +43263,14 @@ var init_routing = __esm(() => {
 });
 
 // src/channels/targets.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "node:fs";
 function getStore3(channelId) {
-  let store = stores3.get(channelId);
-  if (!store) {
-    store = { targets: [] };
-    stores3.set(channelId, store);
+  let store2 = stores3.get(channelId);
+  if (!store2) {
+    store2 = { targets: [] };
+    stores3.set(channelId, store2);
   }
-  return store;
+  return store2;
 }
 function loadTargetStore(channelId) {
   if (loadTargetStoreOverride) {
@@ -42817,11 +43278,11 @@ function loadTargetStore(channelId) {
     return;
   }
   const path2 = getChannelTargetsPath(channelId);
-  if (!existsSync14(path2)) {
+  if (!existsSync15(path2)) {
     return;
   }
   try {
-    const text = readFileSync11(path2, "utf-8");
+    const text = readFileSync12(path2, "utf-8");
     const parsed = JSON.parse(text);
     stores3.set(channelId, {
       targets: parsed.targets ?? []
@@ -42834,8 +43295,8 @@ function saveTargetStore(channelId) {
     return;
   }
   const dir = getChannelDir(channelId);
-  mkdirSync11(dir, { recursive: true });
-  writeFileSync9(getChannelTargetsPath(channelId), `${JSON.stringify(getStore3(channelId), null, 2)}
+  mkdirSync12(dir, { recursive: true });
+  writeFileSync10(getChannelTargetsPath(channelId), `${JSON.stringify(getStore3(channelId), null, 2)}
 `, "utf-8");
 }
 function listChannelTargets(channelId, accountId) {
@@ -42843,11 +43304,11 @@ function listChannelTargets(channelId, accountId) {
   return getStore3(channelId).targets.filter((target) => normalizedAccountId === undefined || normalizeAccountId3(target.accountId) === normalizedAccountId);
 }
 function upsertChannelTarget(channelId, target) {
-  const store = getStore3(channelId);
+  const store2 = getStore3(channelId);
   const normalizedAccountId = normalizeAccountId3(target.accountId);
-  const existingIndex = store.targets.findIndex((candidate) => candidate.targetId === target.targetId && normalizeAccountId3(candidate.accountId) === normalizedAccountId);
+  const existingIndex = store2.targets.findIndex((candidate) => candidate.targetId === target.targetId && normalizeAccountId3(candidate.accountId) === normalizedAccountId);
   if (existingIndex >= 0) {
-    const existing = store.targets[existingIndex];
+    const existing = store2.targets[existingIndex];
     if (!existing) {
       throw new Error(`Target index ${existingIndex} missing for ${target.targetId}`);
     }
@@ -42858,11 +43319,11 @@ function upsertChannelTarget(channelId, target) {
       discoveredAt: existing.discoveredAt,
       lastSeenAt: target.lastSeenAt
     };
-    store.targets[existingIndex] = merged;
+    store2.targets[existingIndex] = merged;
     saveTargetStore(channelId);
     return merged;
   }
-  store.targets.push({
+  store2.targets.push({
     ...target,
     accountId: normalizedAccountId
   });
@@ -42873,25 +43334,25 @@ function upsertChannelTarget(channelId, target) {
   };
 }
 function removeChannelTarget(channelId, targetId, accountId) {
-  const store = getStore3(channelId);
+  const store2 = getStore3(channelId);
   const normalizedAccountId = normalizeAccountId3(accountId);
-  const nextTargets = store.targets.filter((target) => !(target.targetId === targetId && normalizeAccountId3(target.accountId) === normalizedAccountId));
-  if (nextTargets.length === store.targets.length) {
+  const nextTargets = store2.targets.filter((target) => !(target.targetId === targetId && normalizeAccountId3(target.accountId) === normalizedAccountId));
+  if (nextTargets.length === store2.targets.length) {
     return false;
   }
-  store.targets = nextTargets;
+  store2.targets = nextTargets;
   saveTargetStore(channelId);
   return true;
 }
 function removeChannelTargetsForAccount(channelId, accountId) {
-  const store = getStore3(channelId);
+  const store2 = getStore3(channelId);
   const normalizedAccountId = normalizeAccountId3(accountId);
-  const nextTargets = store.targets.filter((target) => normalizeAccountId3(target.accountId) !== normalizedAccountId);
-  const removed = store.targets.length - nextTargets.length;
+  const nextTargets = store2.targets.filter((target) => normalizeAccountId3(target.accountId) !== normalizedAccountId);
+  const removed = store2.targets.length - nextTargets.length;
   if (removed === 0) {
     return 0;
   }
-  store.targets = nextTargets;
+  store2.targets = nextTargets;
   saveTargetStore(channelId);
   return removed;
 }
@@ -43347,6 +43808,14 @@ function buildChannelTurnSource(route, msg) {
     conversationId: route.conversationId
   };
 }
+function getChannelApprovalScopeKey(params) {
+  return [
+    params.channel,
+    params.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID,
+    params.chatId,
+    params.threadId ?? ""
+  ].join(":");
+}
 function getChannelRegistry() {
   return instance;
 }
@@ -43364,12 +43833,16 @@ class ChannelRegistry {
   ready = false;
   messageHandler = null;
   eventHandler = null;
+  approvalResponseHandler = null;
   buffer = [];
+  pendingControlRequestsById = new Map;
+  pendingControlRequestIdByScope = new Map;
   constructor() {
     if (instance) {
       throw new Error("ChannelRegistry is a singleton — use getChannelRegistry()");
     }
     instance = this;
+    this.primePersistedPendingControlRequests();
   }
   getAdapterKey(channelId, accountId = LEGACY_CHANNEL_ACCOUNT_ID) {
     return `${channelId}:${accountId}`;
@@ -43434,9 +43907,99 @@ class ChannelRegistry {
   setMessageHandler(handler) {
     this.messageHandler = handler;
   }
+  setApprovalResponseHandler(handler) {
+    this.approvalResponseHandler = handler;
+  }
   setEventHandler(handler) {
     this.eventHandler = handler;
   }
+  hasPendingControlRequest(requestId) {
+    return this.pendingControlRequestsById.has(requestId);
+  }
+  getPendingControlRequests() {
+    return Array.from(this.pendingControlRequestsById.values()).map((pending) => ({
+      event: structuredClone(pending.event),
+      deliveredThisProcess: pending.deliveredThisProcess
+    }));
+  }
+  primePersistedPendingControlRequests() {
+    for (const event of listPendingControlRequests()) {
+      this.pendingControlRequestsById.set(event.requestId, {
+        event,
+        deliveredThisProcess: false
+      });
+      this.pendingControlRequestIdByScope.set(getChannelApprovalScopeKey({
+        channel: event.source.channel,
+        accountId: event.source.accountId,
+        chatId: event.source.chatId,
+        threadId: event.source.threadId
+      }), event.requestId);
+    }
+  }
+  async deliverPendingControlRequest(requestId) {
+    const pending = this.pendingControlRequestsById.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    const event = pending.event;
+    const adapter = this.getAdapter(event.source.channel, event.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
+    if (!adapter) {
+      return false;
+    }
+    try {
+      if (adapter.handleControlRequestEvent) {
+        await adapter.handleControlRequestEvent(event);
+      } else {
+        await adapter.sendDirectReply(event.source.chatId, formatChannelControlRequestPrompt(event), {
+          replyToMessageId: event.source.threadId ?? event.source.messageId
+        });
+      }
+      pending.deliveredThisProcess = true;
+      return true;
+    } catch (error) {
+      console.error(`[Channels] Failed to deliver control request prompt for ${event.source.channel}/${event.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID}:`, error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+  async registerPendingControlRequest(event) {
+    const scopeKey = getChannelApprovalScopeKey({
+      channel: event.source.channel,
+      accountId: event.source.accountId,
+      chatId: event.source.chatId,
+      threadId: event.source.threadId
+    });
+    const existingRequestId = this.pendingControlRequestIdByScope.get(scopeKey);
+    if (existingRequestId) {
+      this.clearPendingControlRequest(existingRequestId);
+    }
+    this.pendingControlRequestsById.set(event.requestId, {
+      event,
+      deliveredThisProcess: false
+    });
+    this.pendingControlRequestIdByScope.set(scopeKey, event.requestId);
+    upsertPendingControlRequest(event);
+    await this.deliverPendingControlRequest(event.requestId);
+  }
+  async redeliverPendingControlRequest(requestId) {
+    return this.deliverPendingControlRequest(requestId);
+  }
+  clearPendingControlRequest(requestId) {
+    removePendingControlRequest(requestId);
+    const pending = this.pendingControlRequestsById.get(requestId);
+    if (!pending) {
+      return;
+    }
+    this.pendingControlRequestsById.delete(requestId);
+    const scopeKey = getChannelApprovalScopeKey({
+      channel: pending.event.source.channel,
+      accountId: pending.event.source.accountId,
+      chatId: pending.event.source.chatId,
+      threadId: pending.event.source.threadId
+    });
+    if (this.pendingControlRequestIdByScope.get(scopeKey) === requestId) {
+      this.pendingControlRequestIdByScope.delete(scopeKey);
+    }
+  }
   setReady() {
     this.ready = true;
     this.flushBuffer();
@@ -43528,6 +44091,7 @@ class ChannelRegistry {
     this.ready = false;
     this.messageHandler = null;
     this.eventHandler = null;
+    this.approvalResponseHandler = null;
   }
   async stopAll() {
     for (const adapter of Array.from(this.adapters.values())) {
@@ -43538,13 +44102,63 @@ class ChannelRegistry {
     this.ready = false;
     this.messageHandler = null;
     this.eventHandler = null;
+    this.approvalResponseHandler = null;
+    this.pendingControlRequestsById.clear();
+    this.pendingControlRequestIdByScope.clear();
     instance = null;
   }
+  async tryHandlePendingControlRequest(adapter, msg) {
+    const scopeKey = getChannelApprovalScopeKey({
+      channel: msg.channel,
+      accountId: msg.accountId,
+      chatId: msg.chatId,
+      threadId: msg.threadId
+    });
+    const requestId = this.pendingControlRequestIdByScope.get(scopeKey);
+    if (!requestId) {
+      return false;
+    }
+    const pending = this.pendingControlRequestsById.get(requestId);
+    if (!pending) {
+      this.pendingControlRequestIdByScope.delete(scopeKey);
+      return false;
+    }
+    const parsed = parseChannelControlRequestResponse(pending.event, msg.text);
+    if (parsed.type === "reprompt") {
+      await adapter.sendDirectReply(msg.chatId, parsed.message, {
+        replyToMessageId: msg.threadId ?? msg.messageId
+      });
+      return true;
+    }
+    if (!this.approvalResponseHandler) {
+      await adapter.sendDirectReply(msg.chatId, "I’m reconnecting to Letta Code right now, so I couldn’t use that reply yet. Please send it again in a moment.", {
+        replyToMessageId: msg.threadId ?? msg.messageId
+      });
+      return true;
+    }
+    const handled = await this.approvalResponseHandler({
+      runtime: {
+        agent_id: pending.event.source.agentId,
+        conversation_id: pending.event.source.conversationId
+      },
+      response: parsed.response
+    });
+    this.clearPendingControlRequest(requestId);
+    if (!handled) {
+      await adapter.sendDirectReply(msg.chatId, "That approval prompt expired before I could use your reply. Please ask the agent to try again.", {
+        replyToMessageId: msg.threadId ?? msg.messageId
+      });
+    }
+    return true;
+  }
   async handleInboundMessage(msg) {
     const accountId = msg.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID;
     const adapter = this.getAdapter(msg.channel, accountId);
     if (!adapter)
       return;
+    if (await this.tryHandlePendingControlRequest(adapter, msg)) {
+      return;
+    }
     const config = getChannelAccount(msg.channel, accountId);
     if (!config)
       return;
@@ -43772,6 +44386,7 @@ var init_registry = __esm(() => {
   init_memory();
   init_accounts();
   init_pairing();
+  init_pendingControlRequests();
   init_pluginRegistry();
   init_routing();
   init_targets();
@@ -44167,13 +44782,13 @@ var init_messageTool = __esm(() => {
 // src/cli/helpers/fileIndex.ts
 import { createHash as createHash2 } from "node:crypto";
 import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync13,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   statSync as statSync2,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join13, normalize as normalize3, relative as relative2, sep as sep2 } from "node:path";
@@ -44192,7 +44807,7 @@ function hashFile2(fullPath, entryPath, stat) {
     return hashValue2(`meta:${entryPath}:${stat.size}:${stat.mtimeMs}:${stat.ino ?? 0}`);
   }
   try {
-    const content = readFileSync12(fullPath);
+    const content = readFileSync13(fullPath);
     return createHash2("sha256").update(content).digest("hex");
   } catch (err) {
     debugLog("file-index", `Cannot read file for hashing ${fullPath}: ${err}`);
@@ -44445,8 +45060,8 @@ function getProjectStorageDir2() {
 }
 function ensureProjectStorageDir2() {
   const storageDir = getProjectStorageDir2();
-  if (!existsSync15(storageDir)) {
-    mkdirSync12(storageDir, { recursive: true });
+  if (!existsSync16(storageDir)) {
+    mkdirSync13(storageDir, { recursive: true });
   }
   return storageDir;
 }
@@ -44455,7 +45070,7 @@ function getProjectIndexPath2() {
 }
 function loadCachedIndex2() {
   const indexPath = getProjectIndexPath2();
-  if (!existsSync15(indexPath)) {
+  if (!existsSync16(indexPath)) {
     return null;
   }
   try {
@@ -44470,7 +45085,7 @@ function loadCachedIndex2() {
       }
       return null;
     }
-    const content = readFileSync12(indexPath, "utf-8");
+    const content = readFileSync13(indexPath, "utf-8");
     const parsed = JSON.parse(content);
     if (parsed?.metadata && typeof parsed.metadata.rootHash === "string" && Array.isArray(parsed.entries) && parsed.merkle && typeof parsed.merkle === "object") {
       if (parsed.metadata.version !== CACHE_VERSION2) {
@@ -44550,7 +45165,7 @@ function cacheProjectIndex2(result) {
       merkle: cappedMerkle,
       stats: cappedStats
     };
-    writeFileSync10(indexPath, JSON.stringify(payload), "utf-8");
+    writeFileSync11(indexPath, JSON.stringify(payload), "utf-8");
   } catch (err) {
     debugLog("file-index", `Failed to persist index cache: ${err}`);
   }
@@ -46226,7 +46841,7 @@ __export(exports_memoryFilesystem, {
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR,
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync13 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync14 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { join as join14 } from "node:path";
 function getMemoryFilesystemRoot(agentId, homeDir = homedir10()) {
@@ -46238,11 +46853,11 @@ function getMemorySystemDir(agentId, homeDir = homedir10()) {
 function ensureMemoryFilesystemDirs(agentId, homeDir = homedir10()) {
   const root = getMemoryFilesystemRoot(agentId, homeDir);
   const systemDir = getMemorySystemDir(agentId, homeDir);
-  if (!existsSync16(root)) {
-    mkdirSync13(root, { recursive: true });
+  if (!existsSync17(root)) {
+    mkdirSync14(root, { recursive: true });
   }
-  if (!existsSync16(systemDir)) {
-    mkdirSync13(systemDir, { recursive: true });
+  if (!existsSync17(systemDir)) {
+    mkdirSync14(systemDir, { recursive: true });
   }
 }
 async function isMemfsEnabledOnServer(agentId) {
@@ -46468,7 +47083,7 @@ var init_memoryFilesystem = __esm(() => {
 
 // src/permissions/memoryScope.ts
 import { homedir as homedir11 } from "node:os";
-import { basename as basename5, dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
+import { basename as basename5, dirname as dirname5, isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
 function normalizeScopedPath(path3) {
   const resolvedPath = resolve4(expandHomePath(path3));
   const normalized = resolvedPath.replace(/\\/g, "/");
@@ -46515,7 +47130,7 @@ function addRootAndSiblingWorktree(root, acc) {
   acc.add(normalizedRoot);
   const leaf = basename5(normalizedRoot);
   if (leaf === "memory") {
-    acc.add(normalizeScopedPath(resolve4(dirname4(normalizedRoot), "memory-worktrees")));
+    acc.add(normalizeScopedPath(resolve4(dirname5(normalizedRoot), "memory-worktrees")));
   }
 }
 function getExplicitEnvRoots(env3) {
@@ -50445,7 +51060,7 @@ __export(exports_shellEnv, {
   getShellEnv: () => getShellEnv,
   ensureLettaShimDir: () => ensureLettaShimDir
 });
-import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync12 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { tmpdir } from "node:os";
 import * as path4 from "node:path";
@@ -50531,19 +51146,19 @@ function ensureLettaShimDir(invocation) {
   if (!invocation.command)
     return null;
   const shimDir = path4.join(tmpdir(), "letta-code-shell-shim");
-  mkdirSync14(shimDir, { recursive: true });
+  mkdirSync15(shimDir, { recursive: true });
   if (process.platform === "win32") {
     const cmdPath = path4.join(shimDir, "letta.cmd");
     const quotedCommand = `"${invocation.command.replaceAll('"', '""')}"`;
     const quotedArgs = invocation.args.map((arg) => `"${arg.replaceAll('"', '""')}"`).join(" ");
-    writeFileSync11(cmdPath, `@echo off\r
+    writeFileSync12(cmdPath, `@echo off\r
 ${quotedCommand} ${quotedArgs} %*\r
 `);
     return shimDir;
   }
   const shimPath = path4.join(shimDir, "letta");
   const commandWithArgs = [invocation.command, ...invocation.args].map(shellEscape).join(" ");
-  writeFileSync11(shimPath, `#!/bin/sh
+  writeFileSync12(shimPath, `#!/bin/sh
 exec ${commandWithArgs} "$@"
 `, {
     mode: 493
@@ -51199,7 +51814,7 @@ var init_Bash2 = __esm(() => {
 });
 
 // src/tools/impl/BashOutput.ts
-import { readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
+import { readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
 function sleep2(ms) {
   return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
@@ -51216,7 +51831,7 @@ function readOutputFile(filePath) {
         fallbackNotice: `[Output file too large to load fully here (${stats.size.toLocaleString()} bytes). Showing the bounded in-memory buffer instead. Full transcript: ${filePath}]`
       };
     }
-    return { content: readFileSync13(filePath, "utf-8") };
+    return { content: readFileSync14(filePath, "utf-8") };
   } catch {
     return { content: null };
   }
@@ -52599,6 +53214,7 @@ function createConversationRuntime(listener, agentId, conversationId) {
     key: runtimeKey,
     agentId: normalizedAgentId,
     conversationId: normalizedConversationId,
+    activeChannelTurnSources: null,
     messageQueue: Promise.resolve(),
     pendingApprovalResolvers: new Map,
     recoveredApprovalState: null,
@@ -52748,7 +53364,7 @@ var init_runtime3 = () => {};
 
 // src/tools/impl/Memory.ts
 import { execFile as execFileCb3 } from "node:child_process";
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import {
   mkdir as mkdir5,
   readFile as readFile5,
@@ -52759,7 +53375,7 @@ import {
   writeFile as writeFile5
 } from "node:fs/promises";
 import { homedir as homedir16 } from "node:os";
-import { dirname as dirname7, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve13 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve13 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 async function getAgentIdentity() {
   const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
@@ -52801,14 +53417,14 @@ async function memory(args) {
     const label = normalizeMemoryLabel(memoryDir, pathArg, "file_path");
     const filePath = resolveMemoryFilePath(memoryDir, label);
     const relPath = toRepoRelative(memoryDir, filePath);
-    if (existsSync18(filePath)) {
+    if (existsSync19(filePath)) {
       throw new Error(`memory create: block already exists at ${pathArg}`);
     }
     const body = args.file_text ?? "";
     const rendered = renderMemoryFile({
       description
     }, body);
-    await mkdir5(dirname7(filePath), { recursive: true });
+    await mkdir5(dirname8(filePath), { recursive: true });
     await writeFile5(filePath, rendered, "utf8");
     affectedPaths = [relPath];
   } else if (command === "str_replace") {
@@ -52853,7 +53469,7 @@ async function memory(args) {
     const pathArg = requireString(args.file_path, "file_path", "delete");
     const label = normalizeMemoryLabel(memoryDir, pathArg, "file_path");
     const targetPath = resolveMemoryPath(memoryDir, label);
-    if (existsSync18(targetPath) && (await stat2(targetPath)).isDirectory()) {
+    if (existsSync19(targetPath) && (await stat2(targetPath)).isDirectory()) {
       const relPath = toRepoRelative(memoryDir, targetPath);
       await rm(targetPath, { recursive: true, force: false });
       affectedPaths = [relPath];
@@ -52873,11 +53489,11 @@ async function memory(args) {
     const newFilePath = resolveMemoryFilePath(memoryDir, newLabel);
     const oldRelPath = toRepoRelative(memoryDir, oldFilePath);
     const newRelPath = toRepoRelative(memoryDir, newFilePath);
-    if (existsSync18(newFilePath)) {
+    if (existsSync19(newFilePath)) {
       throw new Error(`memory rename: destination already exists at ${newPathArg}`);
     }
     await loadEditableMemoryFile(oldFilePath, oldPathArg);
-    await mkdir5(dirname7(newFilePath), { recursive: true });
+    await mkdir5(dirname8(newFilePath), { recursive: true });
     await rename(oldFilePath, newFilePath);
     affectedPaths = [oldRelPath, newRelPath];
   } else if (command === "update_description") {
@@ -52930,10 +53546,10 @@ function resolveMemoryDir() {
   throw new Error("memory: unable to resolve memory directory. Ensure MEMORY_DIR (or AGENT_ID) is available.");
 }
 function ensureMemoryRepo(memoryDir) {
-  if (!existsSync18(memoryDir)) {
+  if (!existsSync19(memoryDir)) {
     throw new Error(`memory: memory directory does not exist: ${memoryDir}`);
   }
-  if (!existsSync18(resolve13(memoryDir, ".git"))) {
+  if (!existsSync19(resolve13(memoryDir, ".git"))) {
     throw new Error(`memory: ${memoryDir} is not a git repository. This tool requires a git-backed memory filesystem.`);
   }
 }
@@ -53178,7 +53794,7 @@ var init_Memory2 = __esm(() => {
 
 // src/tools/impl/MemoryApplyPatch.ts
 import { execFile as execFileCb4 } from "node:child_process";
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import {
   access,
   mkdir as mkdir6,
@@ -53189,7 +53805,7 @@ import {
   writeFile as writeFile6
 } from "node:fs/promises";
 import { homedir as homedir17 } from "node:os";
-import { dirname as dirname8, isAbsolute as isAbsolute10, relative as relative6, resolve as resolve14 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute10, relative as relative6, resolve as resolve14 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 async function getAgentIdentity2() {
   const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
@@ -53302,7 +53918,7 @@ async function memory_apply_patch(args) {
     }
   }
   for (const [absPath, content] of pendingWrites.entries()) {
-    await mkdir6(dirname8(absPath), { recursive: true });
+    await mkdir6(dirname9(absPath), { recursive: true });
     await writeFile6(absPath, content, "utf8");
   }
   for (const absPath of pendingDeletes) {
@@ -53481,10 +54097,10 @@ function resolveMemoryDir2() {
   throw new Error("memory_apply_patch: unable to resolve memory directory. Ensure MEMORY_DIR (or AGENT_ID) is available.");
 }
 function ensureMemoryRepo2(memoryDir) {
-  if (!existsSync19(memoryDir)) {
+  if (!existsSync20(memoryDir)) {
     throw new Error(`memory_apply_patch: memory directory does not exist: ${memoryDir}`);
   }
-  if (!existsSync19(resolve14(memoryDir, ".git"))) {
+  if (!existsSync20(resolve14(memoryDir, ".git"))) {
     throw new Error(`memory_apply_patch: ${memoryDir} is not a git repository. This tool requires a git-backed memory filesystem.`);
   }
 }
@@ -54246,12 +54862,12 @@ __export(exports_imageResize_magick, {
   MAX_IMAGE_BYTES: () => MAX_IMAGE_BYTES
 });
 import { execSync } from "node:child_process";
-import { readFileSync as readFileSync14, unlinkSync as unlinkSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { readFileSync as readFileSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync14 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join21 } from "node:path";
 async function getImageDimensions(buffer) {
   const tempInput = join21(tmpdir2(), `image-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync13(tempInput, buffer);
+  writeFileSync14(tempInput, buffer);
   try {
     const output = execSync(`magick identify -format "%w %h %m" "${tempInput}"`, {
       encoding: "utf-8"
@@ -54274,7 +54890,7 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
     return null;
   }
   const tempInput = join21(tmpdir2(), `compress-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync13(tempInput, buffer);
+  writeFileSync14(tempInput, buffer);
   try {
     const qualities = [85, 70, 55, 40];
     for (const quality of qualities) {
@@ -54283,7 +54899,7 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
         execSync(`magick "${tempInput}" -quality ${quality} "${tempOutput}"`, {
           stdio: "ignore"
         });
-        const compressed = readFileSync14(tempOutput);
+        const compressed = readFileSync15(tempOutput);
         if (compressed.length <= MAX_IMAGE_BYTES) {
           const { width, height } = await getImageDimensions(compressed);
           return {
@@ -54309,7 +54925,7 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
         execSync(`magick "${tempInput}" -resize ${scaledWidth}x${scaledHeight} -quality 70 "${tempOutput}"`, {
           stdio: "ignore"
         });
-        const reduced = readFileSync14(tempOutput);
+        const reduced = readFileSync15(tempOutput);
         if (reduced.length <= MAX_IMAGE_BYTES) {
           const { width, height } = await getImageDimensions(reduced);
           return {
@@ -54349,7 +54965,7 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
     };
   }
   const tempInput = join21(tmpdir2(), `resize-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync13(tempInput, buffer);
+  writeFileSync14(tempInput, buffer);
   try {
     if (needsResize) {
       const tempOutput2 = join21(tmpdir2(), `resize-output-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -54359,14 +54975,14 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
         execSync(`magick "${tempInput}" -resize ${MAX_IMAGE_WIDTH}x${MAX_IMAGE_HEIGHT}> -quality 85 "${tempOutput2}.jpg"`, {
           stdio: "ignore"
         });
-        outputBuffer2 = readFileSync14(`${tempOutput2}.jpg`);
+        outputBuffer2 = readFileSync15(`${tempOutput2}.jpg`);
         outputMediaType = "image/jpeg";
         unlinkSync5(`${tempOutput2}.jpg`);
       } else {
         execSync(`magick "${tempInput}" -resize ${MAX_IMAGE_WIDTH}x${MAX_IMAGE_HEIGHT}> "${tempOutput2}.png"`, {
           stdio: "ignore"
         });
-        outputBuffer2 = readFileSync14(`${tempOutput2}.png`);
+        outputBuffer2 = readFileSync15(`${tempOutput2}.png`);
         outputMediaType = "image/png";
         unlinkSync5(`${tempOutput2}.png`);
       }
@@ -54387,7 +55003,7 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
     execSync(`magick "${tempInput}" "${tempOutput}"`, {
       stdio: "ignore"
     });
-    const outputBuffer = readFileSync14(tempOutput);
+    const outputBuffer = readFileSync15(tempOutput);
     unlinkSync5(tempOutput);
     const compressed = await compressToFitByteLimit(outputBuffer, width, height);
     if (compressed) {
@@ -54494,7 +55110,7 @@ var require_filesystem = __commonJS((exports, module) => {
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync15 = (path11) => {
+  var readFileSync16 = (path11) => {
     const fd = fs7.openSync(path11, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
     const bytesRead = fs7.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -54517,7 +55133,7 @@ var require_filesystem = __commonJS((exports, module) => {
   module.exports = {
     LDD_PATH,
     SELF_PATH,
-    readFileSync: readFileSync15,
+    readFileSync: readFileSync16,
     readFile: readFile7
   };
 });
@@ -54560,7 +55176,7 @@ var require_elf = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux: isLinux2, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile: readFile7, readFileSync: readFileSync15 } = require_filesystem();
+  var { LDD_PATH, SELF_PATH, readFile: readFile7, readFileSync: readFileSync16 } = require_filesystem();
   var { interpreterPath } = require_elf();
   var cachedFamilyInterpreter;
   var cachedFamilyFilesystem;
@@ -54651,7 +55267,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync15(LDD_PATH);
+      const lddContent = readFileSync16(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -54674,7 +55290,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = readFileSync15(SELF_PATH);
+      const selfContent = readFileSync16(SELF_PATH);
       const path11 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path11);
     } catch (e) {}
@@ -54736,7 +55352,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync15(LDD_PATH);
+      const lddContent = readFileSync16(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -66532,8 +67148,8 @@ var init_ignore = __esm(() => {
 // node_modules/glob/dist/esm/processor.js
 class HasWalkedCache {
   store;
-  constructor(store = new Map) {
-    this.store = store;
+  constructor(store2 = new Map) {
+    this.store = store2;
   }
   copy() {
     return new HasWalkedCache(new Map(this.store));
@@ -67434,7 +68050,7 @@ var init_ReplaceGemini2 = __esm(() => {
 });
 
 // src/tools/impl/Shell.ts
-import { existsSync as existsSync20, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync21, statSync as statSync5 } from "node:fs";
 import * as path15 from "node:path";
 function resolveShellWorkdir(workdir) {
   const defaultCwd = process.env.USER_CWD || process.cwd();
@@ -67528,7 +68144,7 @@ function arraysEqual(a, b) {
 }
 function isUsableDirectory(candidate) {
   try {
-    return existsSync20(candidate) && statSync5(candidate).isDirectory();
+    return existsSync21(candidate) && statSync5(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -67783,12 +68399,12 @@ __export(exports_skills, {
   SKILLS_DIR: () => SKILLS_DIR,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR
 });
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { readdir as readdir4, readFile as readFile7, realpath as realpath2, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname9, join as join22 } from "node:path";
+import { dirname as dirname10, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function getBundledSkillsPath() {
-  const thisDir = dirname9(fileURLToPath6(import.meta.url));
+  const thisDir = dirname10(fileURLToPath6(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
     return join22(thisDir, "../skills/builtin");
   }
@@ -67807,7 +68423,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors = [];
-  if (!existsSync21(skillsPath)) {
+  if (!existsSync22(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -67990,7 +68606,7 @@ var init_skillContentRegistry = __esm(() => {
 // src/tools/impl/Skill.ts
 import { readdirSync as readdirSync6 } from "node:fs";
 import { readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname10, join as join23 } from "node:path";
+import { dirname as dirname11, join as join23 } from "node:path";
 function getMemorySkillsDirs(agentId) {
   const dirs = new Set;
   const memoryDir = process.env.MEMORY_DIR || process.env.LETTA_MEMORY_DIR;
@@ -68004,7 +68620,7 @@ function getMemorySkillsDirs(agentId) {
 }
 function hasAdditionalFiles(skillMdPath) {
   try {
-    const skillDir = dirname10(skillMdPath);
+    const skillDir = dirname11(skillMdPath);
     const entries = readdirSync6(skillDir);
     return entries.some((e) => e.toUpperCase() !== "SKILL.MD");
   } catch {
@@ -68080,7 +68696,7 @@ async function skill(args) {
     const agentId = getResolvedAgentId(args);
     const skillsDir = await getResolvedSkillsDir();
     const { content: skillContent, path: skillPath } = await readSkillContent(skillName, skillsDir, agentId);
-    const skillDir = dirname10(skillPath);
+    const skillDir = dirname11(skillPath);
     const hasExtras = hasAdditionalFiles(skillPath);
     const processedContent = hasExtras ? skillContent.replace(/<SKILL_DIR>/g, skillDir) : skillContent;
     const dirHeader = hasExtras ? `# Skill Directory: ${skillDir}
@@ -68109,13 +68725,13 @@ var init_Skill2 = __esm(() => {
 // src/cli/helpers/subagentState.ts
 function updateSnapshot() {
   cachedSnapshot = {
-    agents: Array.from(store.agents.values()),
-    expanded: store.expanded
+    agents: Array.from(store2.agents.values()),
+    expanded: store2.expanded
   };
 }
 function notifyListeners() {
   updateSnapshot();
-  for (const listener of store.listeners) {
+  for (const listener of store2.listeners) {
     listener();
   }
 }
@@ -68133,18 +68749,18 @@ function unrefTimer2(timer) {
   }
 }
 function scheduleCompletedSubagentCleanup(id) {
-  const agent = store.agents.get(id);
+  const agent = store2.agents.get(id);
   if (!agent || agent.status !== "completed" && agent.status !== "error") {
     return;
   }
   clearCompletedSubagentCleanup(id);
   const timer = setTimeout(() => {
-    const current = store.agents.get(id);
+    const current = store2.agents.get(id);
     if (!current || current.status !== "completed" && current.status !== "error") {
       completedSubagentCleanupTimers.delete(id);
       return;
     }
-    store.agents.delete(id);
+    store2.agents.delete(id);
     completedSubagentCleanupTimers.delete(id);
     notifyListeners();
   }, completedSubagentRetentionMs);
@@ -68155,7 +68771,7 @@ function generateSubagentId() {
   return `subagent-${Date.now()}-${++subagentCounter}`;
 }
 function getSubagentByToolCallId(toolCallId) {
-  for (const agent of store.agents.values()) {
+  for (const agent of store2.agents.values()) {
     if (agent.toolCallId === toolCallId) {
       return agent;
     }
@@ -68182,11 +68798,11 @@ function registerSubagent(id, type, description, toolCallId, isBackground, silen
     parentConversationId: parentScope?.conversationId && parentScope.conversationId.length > 0 ? parentScope.conversationId : undefined
   };
   clearCompletedSubagentCleanup(id);
-  store.agents.set(id, agent);
+  store2.agents.set(id, agent);
   notifyListeners();
 }
 function updateSubagent(id, updates) {
-  const agent = store.agents.get(id);
+  const agent = store2.agents.get(id);
   if (!agent)
     return;
   if (updates.agentURL && agent.status === "pending") {
@@ -68199,7 +68815,7 @@ function updateSubagent(id, updates) {
   if (isNoop)
     return;
   const updatedAgent = { ...agent, ...updates, maxToolCallsSeen: nextMax };
-  store.agents.set(id, updatedAgent);
+  store2.agents.set(id, updatedAgent);
   if (updatedAgent.status === "completed" || updatedAgent.status === "error") {
     scheduleCompletedSubagentCleanup(id);
   } else {
@@ -68208,7 +68824,7 @@ function updateSubagent(id, updates) {
   notifyListeners();
 }
 function addToolCall(subagentId, toolCallId, toolName, toolArgs) {
-  const agent = store.agents.get(subagentId);
+  const agent = store2.agents.get(subagentId);
   if (!agent)
     return;
   if (agent.toolCalls.some((tc) => tc.id === toolCallId))
@@ -68221,11 +68837,11 @@ function addToolCall(subagentId, toolCallId, toolName, toolArgs) {
     ],
     maxToolCallsSeen: Math.max(agent.maxToolCallsSeen, agent.toolCalls.length + 1)
   };
-  store.agents.set(subagentId, updatedAgent);
+  store2.agents.set(subagentId, updatedAgent);
   notifyListeners();
 }
 function completeSubagent(id, result) {
-  const agent = store.agents.get(id);
+  const agent = store2.agents.get(id);
   if (!agent)
     return;
   const updatedAgent = {
@@ -68236,7 +68852,7 @@ function completeSubagent(id, result) {
     totalTokens: result.totalTokens ?? agent.totalTokens,
     maxToolCallsSeen: Math.max(agent.maxToolCallsSeen, agent.toolCalls.length)
   };
-  store.agents.set(id, updatedAgent);
+  store2.agents.set(id, updatedAgent);
   scheduleCompletedSubagentCleanup(id);
   notifyListeners();
 }
@@ -68244,21 +68860,21 @@ function getSubagentToolCount(agent) {
   return Math.max(agent.toolCalls.length, agent.maxToolCallsSeen);
 }
 function toggleExpanded() {
-  store.expanded = !store.expanded;
+  store2.expanded = !store2.expanded;
   notifyListeners();
 }
 function getSubagents() {
-  return Array.from(store.agents.values());
+  return Array.from(store2.agents.values());
 }
 function getActiveBackgroundAgents() {
-  return Array.from(store.agents.values()).filter((a) => a.silent === true && (a.status === "pending" || a.status === "running"));
+  return Array.from(store2.agents.values()).filter((a) => a.silent === true && (a.status === "pending" || a.status === "running"));
 }
 function clearCompletedSubagents() {
   let removedAny = false;
-  for (const [id, agent] of store.agents.entries()) {
+  for (const [id, agent] of store2.agents.entries()) {
     if (agent.status === "completed" || agent.status === "error") {
       clearCompletedSubagentCleanup(id);
-      store.agents.delete(id);
+      store2.agents.delete(id);
       removedAny = true;
     }
   }
@@ -68270,14 +68886,14 @@ function clearSubagentsByIds(ids) {
   let removedAny = false;
   for (const id of ids) {
     clearCompletedSubagentCleanup(id);
-    removedAny = store.agents.delete(id) || removedAny;
+    removedAny = store2.agents.delete(id) || removedAny;
   }
   if (removedAny) {
     notifyListeners();
   }
 }
 function hasActiveSubagents() {
-  for (const agent of store.agents.values()) {
+  for (const agent of store2.agents.values()) {
     if (agent.status === "pending" || agent.status === "running") {
       return true;
     }
@@ -68286,7 +68902,7 @@ function hasActiveSubagents() {
 }
 function interruptActiveSubagents(errorMessage) {
   let anyInterrupted = false;
-  for (const [id, agent] of store.agents.entries()) {
+  for (const [id, agent] of store2.agents.entries()) {
     if (agent.status === "pending" || agent.status === "running") {
       const updatedAgent = {
         ...agent,
@@ -68294,7 +68910,7 @@ function interruptActiveSubagents(errorMessage) {
         error: errorMessage,
         durationMs: Date.now() - agent.startTime
       };
-      store.agents.set(id, updatedAgent);
+      store2.agents.set(id, updatedAgent);
       scheduleCompletedSubagentCleanup(id);
       anyInterrupted = true;
     }
@@ -68304,9 +68920,9 @@ function interruptActiveSubagents(errorMessage) {
   }
 }
 function subscribe2(listener) {
-  store.listeners.add(listener);
+  store2.listeners.add(listener);
   return () => {
-    store.listeners.delete(listener);
+    store2.listeners.delete(listener);
   };
 }
 function getSnapshot2() {
@@ -68323,9 +68939,9 @@ function emitStreamEvent(subagentId, event) {
     listener(subagentId, event);
   }
 }
-var store, cachedSnapshot, DEFAULT_COMPLETED_SUBAGENT_RETENTION_MS = 30000, completedSubagentRetentionMs, completedSubagentCleanupTimers, subagentCounter = 0, streamEventListeners;
+var store2, cachedSnapshot, DEFAULT_COMPLETED_SUBAGENT_RETENTION_MS = 30000, completedSubagentRetentionMs, completedSubagentCleanupTimers, subagentCounter = 0, streamEventListeners;
 var init_subagentState = __esm(() => {
-  store = {
+  store2 = {
     agents: new Map,
     expanded: false,
     listeners: new Set
@@ -68697,11 +69313,20 @@ function swapProviderPrefix(parentHandle, recommendedHandle) {
   const modelPortion = recommendedHandle.slice(recommendedProvider.length + 1);
   return `${parentProvider}/${modelPortion}`;
 }
+function isEnvFlagEnabled(name) {
+  const value = process.env[name]?.trim();
+  if (!value)
+    return false;
+  return value === "1" || value.toLowerCase() === "true";
+}
 async function resolveSubagentModel(options) {
   const { userModel, recommendedModel, parentModelHandle, billingTier } = options;
   const isFreeTier = billingTier?.toLowerCase() === "free";
   if (userModel)
     return userModel;
+  if (options.subagentType === "reflection" && isEnvFlagEnabled("AUTO_MEMORY")) {
+    return "letta/auto-memory";
+  }
   let recommendedHandle = null;
   if (recommendedModel && recommendedModel !== "inherit") {
     recommendedHandle = resolveModel2(recommendedModel);
@@ -69187,7 +69812,8 @@ async function spawnSubagent(type, prompt, userModel, subagentId, signal, existi
     userModel,
     recommendedModel: config.recommendedModel,
     parentModelHandle,
-    billingTier
+    billingTier,
+    subagentType: type
   });
   const baseURL = getBaseURL();
   let finalPrompt = prompt;
@@ -73592,7 +74218,7 @@ __export(exports_analyzer, {
   analyzeApprovalContext: () => analyzeApprovalContext
 });
 import { homedir as homedir19 } from "node:os";
-import { dirname as dirname12, relative as relative8, resolve as resolve23, win32 as win322 } from "node:path";
+import { dirname as dirname13, relative as relative8, resolve as resolve23, win32 as win322 } from "node:path";
 function normalizeOsPath(path19) {
   return path19.replace(/\\/g, "/");
 }
@@ -73618,7 +74244,7 @@ function isPathWithinDirectory(path19, directory) {
   return !relativePath.startsWith("../") && relativePath !== ".." && !relativePath.startsWith("/") && !/^[a-zA-Z]:\//.test(relativePath);
 }
 function dirnameForContext(path19) {
-  return isWindowsPath(path19) ? win322.dirname(path19) : dirname12(path19);
+  return isWindowsPath(path19) ? win322.dirname(path19) : dirname13(path19);
 }
 function formatAbsoluteRulePath(path19) {
   const normalized = normalizeOsPath(path19).replace(/\/+$/, "");
@@ -73679,7 +74305,7 @@ function analyzeReadApproval(filePath, workingDir) {
     };
   }
   const relativePath = normalizeOsPath(relativePathForContext(workingDir, absolutePath));
-  const relativeDir = dirname12(relativePath);
+  const relativeDir = dirname13(relativePath);
   const pattern = relativeDir === "." || relativeDir === "" ? "**" : `${relativeDir}/**`;
   return {
     recommendedRule: `Read(${pattern})`,
@@ -77235,13 +77861,13 @@ var init_parseInterval = __esm(() => {
 // src/cron/cronFile.ts
 import { randomBytes } from "node:crypto";
 import {
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync16,
-  readFileSync as readFileSync15,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync17,
+  readFileSync as readFileSync16,
   renameSync as renameSync2,
   rmSync as rmSync2,
   statSync as statSync6,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "node:fs";
 import { join as join25 } from "node:path";
 function getLettaDir() {
@@ -77260,10 +77886,10 @@ function emptyFile() {
 }
 function readCronFile() {
   const path20 = getCronFilePath();
-  if (!existsSync22(path20))
+  if (!existsSync23(path20))
     return emptyFile();
   try {
-    const raw = readFileSync15(path20, "utf-8");
+    const raw = readFileSync16(path20, "utf-8");
     const data = JSON.parse(raw);
     if (data.version !== 1)
       return emptyFile();
@@ -77275,31 +77901,76 @@ function readCronFile() {
 function writeCronFile(data) {
   const path20 = getCronFilePath();
   const dir = getLettaDir();
-  if (!existsSync22(dir)) {
-    mkdirSync16(dir, { recursive: true });
+  if (!existsSync23(dir)) {
+    mkdirSync17(dir, { recursive: true });
   }
   const tmp = `${path20}.tmp`;
-  writeFileSync14(tmp, JSON.stringify(data, null, 2), { flush: true });
+  writeFileSync15(tmp, JSON.stringify(data, null, 2), { flush: true });
   renameSync2(tmp, path20);
 }
-function isProcessAlive(pid) {
+function readLinuxProcessIdentity(pid) {
+  try {
+    const stat5 = readFileSync16(`/proc/${pid}/stat`, "utf8");
+    const endCommand = stat5.lastIndexOf(")");
+    if (endCommand === -1) {
+      return null;
+    }
+    const fields = stat5.slice(endCommand + 2).trim().split(/\s+/);
+    const startTicks = fields[19] ?? null;
+    if (!startTicks) {
+      return null;
+    }
+    let bootId = null;
+    try {
+      bootId = readFileSync16("/proc/sys/kernel/random/boot_id", "utf8").trim() || null;
+    } catch {}
+    return { startTicks, bootId };
+  } catch {
+    return null;
+  }
+}
+function readProcessIdentity(pid) {
+  if (readProcessIdentityOverride) {
+    return readProcessIdentityOverride(pid);
+  }
+  return readLinuxProcessIdentity(pid);
+}
+function captureProcessIdentity(pid) {
+  const identity = readProcessIdentity(pid);
+  return {
+    process_start_ticks: identity?.startTicks ?? null,
+    boot_id: identity?.bootId ?? null
+  };
+}
+function isProcessAlive(pid, owner) {
   try {
     process.kill(pid, 0);
-    return true;
   } catch {
     return false;
   }
+  if (owner) {
+    const identity = readProcessIdentity(pid);
+    if (identity) {
+      if (owner.boot_id && identity.bootId && owner.boot_id !== identity.bootId) {
+        return false;
+      }
+      if (owner.process_start_ticks && identity.startTicks && owner.process_start_ticks !== identity.startTicks) {
+        return false;
+      }
+    }
+  }
+  return true;
 }
 function readLockOwner(lockDir) {
   try {
-    const raw = readFileSync15(join25(lockDir, LOCK_TOKEN_FILE), "utf-8");
+    const raw = readFileSync16(join25(lockDir, LOCK_TOKEN_FILE), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function writeLockOwner(lockDir, owner) {
-  writeFileSync14(join25(lockDir, LOCK_TOKEN_FILE), JSON.stringify(owner));
+  writeFileSync15(join25(lockDir, LOCK_TOKEN_FILE), JSON.stringify(owner));
 }
 function isLockStale(lockDir) {
   const owner = readLockOwner(lockDir);
@@ -77311,7 +77982,7 @@ function isLockStale(lockDir) {
       return true;
     }
   }
-  const pidDead = !isProcessAlive(owner.pid);
+  const pidDead = !isProcessAlive(owner.pid, owner);
   const isOld = Date.now() - owner.acquired_at > LOCK_STALE_AGE_MS;
   return pidDead && isOld;
 }
@@ -77326,11 +77997,12 @@ function acquireLock() {
   const token = randomBytes(4).toString("hex");
   while (Date.now() < deadline) {
     try {
-      mkdirSync16(lockDir, { recursive: false });
+      mkdirSync17(lockDir, { recursive: false });
       const owner = {
         pid: process.pid,
         token,
-        acquired_at: Date.now()
+        acquired_at: Date.now(),
+        ...captureProcessIdentity(process.pid)
       };
       writeLockOwner(lockDir, owner);
       return {
@@ -77435,7 +78107,7 @@ function addTask(input) {
     data.tasks.push(task2);
     writeCronFile(data);
     let warning;
-    if (!data.scheduler_owner || !isProcessAlive(data.scheduler_owner.pid)) {
+    if (!data.scheduler_owner || !isProcessAlive(data.scheduler_owner.pid, data.scheduler_owner)) {
       warning = "No letta server is currently running. This task will only execute when a WS listener is active.";
     }
     return { task: task2, warning };
@@ -77483,15 +78155,17 @@ function claimSchedulerLease() {
     const data = readCronFile();
     const token = randomBytes(4).toString("hex");
     if (data.scheduler_owner) {
-      const { pid, token: existingToken } = data.scheduler_owner;
-      if (isProcessAlive(pid)) {
+      const existingOwner = data.scheduler_owner;
+      const { pid, token: existingToken } = existingOwner;
+      if (isProcessAlive(pid, existingOwner)) {
         throw new Error(`Scheduler lease held by PID ${pid} (token ${existingToken}). Cannot claim.`);
       }
     }
     data.scheduler_owner = {
       pid: process.pid,
       token,
-      started_at: new Date().toISOString()
+      started_at: new Date().toISOString(),
+      ...captureProcessIdentity(process.pid)
     };
     writeCronFile(data);
     return token;
@@ -77551,7 +78225,7 @@ function getCronFileMtime() {
     return 0;
   }
 }
-var CRON_FILE_NAME = "crons.json", LOCK_DIR_NAME = "crons.lock", LOCK_TOKEN_FILE = "owner.json", LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 50, LOCK_STALE_AGE_MS = 30000, MAX_ACTIVE_TASKS_PER_AGENT = 50, TASK_ID_BYTES = 4, GC_AGE_MS;
+var CRON_FILE_NAME = "crons.json", LOCK_DIR_NAME = "crons.lock", LOCK_TOKEN_FILE = "owner.json", LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 50, LOCK_STALE_AGE_MS = 30000, MAX_ACTIVE_TASKS_PER_AGENT = 50, TASK_ID_BYTES = 4, GC_AGE_MS, readProcessIdentityOverride = null;
 var init_cronFile = __esm(() => {
   init_parseInterval();
   GC_AGE_MS = 24 * 60 * 60 * 1000;
@@ -81837,6 +82511,18 @@ var MIN_SPLIT_LENGTH = 1500;
 function isInteractiveApprovalTool(toolName) {
   return INTERACTIVE_APPROVAL_TOOLS.has(toolName);
 }
+function getInteractiveApprovalKind(toolName) {
+  switch (toolName) {
+    case "AskUserQuestion":
+      return "ask_user_question";
+    case "EnterPlanMode":
+      return "enter_plan_mode";
+    case "ExitPlanMode":
+      return "exit_plan_mode";
+    default:
+      return null;
+  }
+}
 function isHeadlessAutoAllowTool(toolName) {
   return HEADLESS_AUTO_ALLOW_TOOLS.has(toolName);
 }
@@ -83127,11 +83813,11 @@ var init_reflectionTranscript = __esm(() => {
 
 // src/cli/helpers/chunkLog.ts
 import {
-  existsSync as existsSync24,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync19,
   readdirSync as readdirSync8,
   unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "node:fs";
 import { homedir as homedir22 } from "node:os";
 import { join as join29 } from "node:path";
@@ -83228,8 +83914,8 @@ class ChunkLog {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync24(this.agentDir)) {
-        mkdirSync18(this.agentDir, { recursive: true });
+      if (!existsSync25(this.agentDir)) {
+        mkdirSync19(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
     } catch (e) {
@@ -83243,7 +83929,7 @@ class ChunkLog {
     try {
       const content = this.buffer.map((entry) => JSON.stringify(entry)).join(`
 `);
-      writeFileSync15(this.logPath, `${content}
+      writeFileSync16(this.logPath, `${content}
 `, "utf8");
     } catch (e) {
       debugWarn("chunkLog", `Failed to write ${this.logPath}: ${e instanceof Error ? e.message : String(e)}`);
@@ -83253,7 +83939,7 @@ class ChunkLog {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync24(this.agentDir))
+      if (!existsSync25(this.agentDir))
         return;
       const files = readdirSync8(this.agentDir).filter((f) => f.endsWith(".jsonl")).sort();
       if (files.length >= MAX_SESSION_FILES2) {
@@ -84272,7 +84958,7 @@ var init_constants2 = __esm(() => {
 });
 
 // src/websocket/listener/remote-settings.ts
-import { existsSync as existsSync25, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync17 } from "node:fs";
 import { mkdir as mkdir8, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir23 } from "node:os";
 import path20 from "node:path";
@@ -84286,8 +84972,8 @@ function loadRemoteSettings() {
   let loaded = {};
   try {
     const settingsPath = getRemoteSettingsPath();
-    if (existsSync25(settingsPath)) {
-      const raw = readFileSync16(settingsPath, "utf-8");
+    if (existsSync26(settingsPath)) {
+      const raw = readFileSync17(settingsPath, "utf-8");
       const parsed = JSON.parse(raw);
       loaded = parsed;
     }
@@ -84295,7 +84981,7 @@ function loadRemoteSettings() {
   if (loaded.cwdMap) {
     const validCwdMap = {};
     for (const [key, value] of Object.entries(loaded.cwdMap)) {
-      if (typeof value === "string" && existsSync25(value)) {
+      if (typeof value === "string" && existsSync26(value)) {
         validCwdMap[key] = value;
       }
     }
@@ -84322,13 +85008,13 @@ function saveRemoteSettings(updates) {
 function loadLegacyCwdCache() {
   try {
     const legacyPath = path20.join(homedir23(), ".letta", "cwd-cache.json");
-    if (!existsSync25(legacyPath))
+    if (!existsSync26(legacyPath))
       return {};
-    const raw = readFileSync16(legacyPath, "utf-8");
+    const raw = readFileSync17(legacyPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = {};
     for (const [key, value] of Object.entries(parsed)) {
-      if (typeof value === "string" && existsSync25(value)) {
+      if (typeof value === "string" && existsSync26(value)) {
         result[key] = value;
       }
     }
@@ -88493,7 +89179,46 @@ var init_send = __esm(async () => {
 });
 
 // src/websocket/listener/turn-approval.ts
+import { readFile as readFile11 } from "node:fs/promises";
 import WebSocket2 from "ws";
+function getChannelApprovalSourceScopeKey(source) {
+  return [
+    source.channel,
+    source.accountId ?? "",
+    source.chatId,
+    source.threadId ?? ""
+  ].join(":");
+}
+function resolveChannelApprovalSource(runtime) {
+  const sources = runtime.activeChannelTurnSources ?? [];
+  if (sources.length === 0) {
+    return null;
+  }
+  const sourcesByScope = new Map;
+  for (const source of sources) {
+    sourcesByScope.set(getChannelApprovalSourceScopeKey(source), source);
+  }
+  if (sourcesByScope.size !== 1) {
+    return null;
+  }
+  return [...sourcesByScope.values()].at(-1) ?? null;
+}
+async function maybeReadPlanPreview(toolName, turnPermissionModeState) {
+  if (toolName !== "ExitPlanMode" || !turnPermissionModeState.planFilePath) {
+    return {};
+  }
+  try {
+    const planContent = await readFile11(turnPermissionModeState.planFilePath, "utf8");
+    return {
+      planFilePath: turnPermissionModeState.planFilePath,
+      planContent
+    };
+  } catch {
+    return {
+      planFilePath: turnPermissionModeState.planFilePath
+    };
+  }
+}
 async function handleApprovalStop(params) {
   const {
     approvals,
@@ -88631,6 +89356,18 @@ async function handleApprovalStop(params) {
         agent_id: agentId,
         conversation_id: conversationId
       };
+      const registry = getChannelRegistry();
+      const channelSource = resolveChannelApprovalSource(runtime);
+      if (registry && channelSource) {
+        await registry.registerPendingControlRequest({
+          requestId,
+          kind: getInteractiveApprovalKind(ac.approval.toolName) ?? "generic_tool_approval",
+          source: channelSource,
+          toolName: ac.approval.toolName,
+          input: ac.parsedArgs,
+          ...await maybeReadPlanPreview(ac.approval.toolName, turnPermissionModeState)
+        });
+      }
       let responseBody;
       try {
         responseBody = await requestApprovalOverWS(runtime, socket, requestId, controlRequest);
@@ -88639,6 +89376,8 @@ async function handleApprovalStop(params) {
           return interruptTermination();
         }
         throw error;
+      } finally {
+        registry?.clearPendingControlRequest(requestId);
       }
       if (shouldInterrupt()) {
         return interruptTermination();
@@ -88841,6 +89580,7 @@ async function handleApprovalStop(params) {
   };
 }
 var init_turn_approval = __esm(async () => {
+  init_registry();
   init_diffPreview();
   init_interactivePolicy();
   init_skill_injection();
@@ -90684,6 +91424,7 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
       }
       let turnError;
       let didThrow = false;
+      runtime.activeChannelTurnSources = channelTurnSources;
       try {
         await processQueuedTurn(queuedTurn, dequeuedBatch);
       } catch (error) {
@@ -90691,6 +91432,7 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
         turnError = error instanceof Error ? error.message : String(error);
         throw error;
       } finally {
+        runtime.activeChannelTurnSources = null;
         if (channelTurnSources.length > 0) {
           await dispatchChannelTurnLifecycleEvent({
             type: "finished",
@@ -91787,7 +92529,7 @@ __export(exports_memoryScanner, {
   readFileContent: () => readFileContent,
   getFileNodes: () => getFileNodes
 });
-import { readdirSync as readdirSync9, readFileSync as readFileSync17, statSync as statSync7 } from "node:fs";
+import { readdirSync as readdirSync9, readFileSync as readFileSync18, statSync as statSync7 } from "node:fs";
 import { join as join30, relative as relative12 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
@@ -91852,7 +92594,7 @@ function getFileNodes(nodes) {
 }
 function readFileContent(fullPath) {
   try {
-    return readFileSync17(fullPath, "utf-8");
+    return readFileSync18(fullPath, "utf-8");
   } catch {
     return "(unable to read file)";
   }
@@ -91915,6 +92657,63 @@ async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
   }
   emitStateSync(socket, listenerRuntime, scope);
 }
+async function recoverPendingChannelControlRequests(listener, opts) {
+  const registry = getChannelRegistry();
+  if (!registry) {
+    return;
+  }
+  const pendingEntries = registry.getPendingControlRequests();
+  if (pendingEntries.length === 0) {
+    return;
+  }
+  const recoverFn = opts?.recoverApprovalStateForSync ?? recoverApprovalStateForSync;
+  const entriesByScope = new Map;
+  for (const entry of pendingEntries) {
+    const scope = {
+      agent_id: entry.event.source.agentId,
+      conversation_id: entry.event.source.conversationId
+    };
+    const scopeKey = `${scope.agent_id}:${scope.conversation_id}`;
+    const existing = entriesByScope.get(scopeKey);
+    if (existing) {
+      existing.entries.push(entry);
+      continue;
+    }
+    entriesByScope.set(scopeKey, {
+      scope,
+      entries: [entry]
+    });
+  }
+  for (const { scope, entries } of entriesByScope.values()) {
+    const runtime = getOrCreateScopedRuntime(listener, scope.agent_id, scope.conversation_id);
+    const livePendingRequestIds = new Set(runtime.pendingApprovalResolvers.keys());
+    const shouldRecoverFromBackend = entries.some((entry) => !livePendingRequestIds.has(entry.event.requestId));
+    if (shouldRecoverFromBackend) {
+      try {
+        await recoverFn(runtime, scope);
+      } catch (error) {
+        trackListenerError("listener_channel_control_request_recovery_failed", error, "listener_channel_control_request_recovery");
+        if (isDebugEnabled()) {
+          console.warn("[Listen] Channel control request recovery failed:", error);
+        }
+        continue;
+      }
+    }
+    const recoveredPendingRequestIds = getRecoveredApprovalStateForScope(listener, scope)?.pendingRequestIds ?? new Set;
+    for (const entry of entries) {
+      const requestId = entry.event.requestId;
+      const stillPending = livePendingRequestIds.has(requestId) || recoveredPendingRequestIds.has(requestId);
+      if (!stillPending) {
+        registry.clearPendingControlRequest(requestId);
+        continue;
+      }
+      if (entry.deliveredThisProcess) {
+        continue;
+      }
+      await registry.redeliverPendingControlRequest(requestId);
+    }
+  }
+}
 function getParsedRuntimeScope(parsed) {
   if (!parsed || typeof parsed !== "object" || !("runtime" in parsed)) {
     return null;
@@ -92215,10 +93014,10 @@ async function handleListMemoryCommand(parsed, socket, overrides = {}) {
     const isMemfsEnabledOnServer2 = overrides.isMemfsEnabledOnServer ?? actualIsMemfsEnabledOnServer;
     const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memoryScanner(), exports_memoryScanner));
     const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-    const { existsSync: existsSync26 } = await import("node:fs");
+    const { existsSync: existsSync27 } = await import("node:fs");
     const { join: join31, posix: posix2 } = await import("node:path");
     const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
-    let memfsInitialized = existsSync26(join31(memoryRoot, ".git"));
+    let memfsInitialized = existsSync27(join31(memoryRoot, ".git"));
     const memfsEnabled = memfsInitialized ? true : await isMemfsEnabledOnServer2(parsed.agent_id);
     if (!memfsEnabled) {
       safeSocketSend(socket, {
@@ -92235,7 +93034,7 @@ async function handleListMemoryCommand(parsed, socket, overrides = {}) {
     }
     if (!memfsInitialized) {
       await ensureLocalMemfsCheckout2(parsed.agent_id);
-      memfsInitialized = existsSync26(join31(memoryRoot, ".git"));
+      memfsInitialized = existsSync27(join31(memoryRoot, ".git"));
     }
     if (!memfsInitialized) {
       throw new Error("MemFS is enabled, but the local memory checkout could not be initialized.");
@@ -92852,7 +93651,7 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
   if (parsed.type === "channel_account_start") {
     try {
       const account = await startChannelAccountLive2(parsed.channel_id, parsed.account_id);
-      wireChannelIngress(runtime, socket, opts, processQueuedTurn);
+      await wireChannelIngress(runtime, socket, opts, processQueuedTurn);
       safeSocketSend(socket, {
         type: "channel_account_start_response",
         request_id: parsed.request_id,
@@ -92934,7 +93733,7 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
         allowedUsers: parsed.config.allowed_users
       }, parsed.account_id);
       if (snapshot.enabled) {
-        wireChannelIngress(runtime, socket, opts, processQueuedTurn);
+        await wireChannelIngress(runtime, socket, opts, processQueuedTurn);
       }
       safeSocketSend(socket, {
         type: "channel_set_config_response",
@@ -92961,7 +93760,7 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
   if (parsed.type === "channel_start") {
     try {
       const summary = await startChannelLive2(parsed.channel_id, parsed.account_id);
-      wireChannelIngress(runtime, socket, opts, processQueuedTurn);
+      await wireChannelIngress(runtime, socket, opts, processQueuedTurn);
       safeSocketSend(socket, {
         type: "channel_start_response",
         request_id: parsed.request_id,
@@ -93211,9 +94010,9 @@ function emitSkillsUpdated(socket) {
 }
 async function handleSkillCommand(parsed, socket) {
   const {
-    existsSync: existsSync26,
+    existsSync: existsSync27,
     lstatSync: lstatSync2,
-    mkdirSync: mkdirSync19,
+    mkdirSync: mkdirSync20,
     rmdirSync,
     symlinkSync,
     unlinkSync: unlinkSync8
@@ -93223,7 +94022,7 @@ async function handleSkillCommand(parsed, socket) {
   const globalSkillsDir = join31(lettaHome, "skills");
   if (parsed.type === "skill_enable") {
     try {
-      if (!existsSync26(parsed.skill_path)) {
+      if (!existsSync27(parsed.skill_path)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
           request_id: parsed.request_id,
@@ -93233,7 +94032,7 @@ async function handleSkillCommand(parsed, socket) {
         return true;
       }
       const skillMdPath = join31(parsed.skill_path, "SKILL.md");
-      if (!existsSync26(skillMdPath)) {
+      if (!existsSync27(skillMdPath)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
           request_id: parsed.request_id,
@@ -93244,8 +94043,8 @@ async function handleSkillCommand(parsed, socket) {
       }
       const linkName = basename10(parsed.skill_path);
       const linkPath = join31(globalSkillsDir, linkName);
-      mkdirSync19(globalSkillsDir, { recursive: true });
-      if (existsSync26(linkPath)) {
+      mkdirSync20(globalSkillsDir, { recursive: true });
+      if (existsSync27(linkPath)) {
         const stat7 = lstatSync2(linkPath);
         if (stat7.isSymbolicLink()) {
           if (process.platform === "win32") {
@@ -93287,7 +94086,7 @@ async function handleSkillCommand(parsed, socket) {
   if (parsed.type === "skill_disable") {
     try {
       const linkPath = join31(globalSkillsDir, parsed.name);
-      if (!existsSync26(linkPath)) {
+      if (!existsSync27(linkPath)) {
         safeSocketSend(socket, {
           type: "skill_disable_response",
           request_id: parsed.request_id,
@@ -93450,7 +94249,7 @@ async function handleReflectionSettingsCommand(parsed, socket, listener) {
   }
   return true;
 }
-function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
+async function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
   const registry = getChannelRegistry();
   if (!registry)
     return;
@@ -93474,6 +94273,14 @@ function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
   registry.setEventHandler((event) => {
     handleChannelRegistryEvent(event, socket, listener);
   });
+  await recoverPendingChannelControlRequests(listener);
+  registry.setApprovalResponseHandler(async ({ runtime, response }) => handleApprovalResponseInput(listener, {
+    runtime,
+    response,
+    socket,
+    opts,
+    processQueuedTurn
+  }));
   registry.setReady();
 }
 function handleChannelRegistryEvent(event, socket, runtime) {
@@ -93996,7 +94803,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     const scopedRuntime = getOrCreateScopedRuntime(runtime, queuedTurn.agentId, queuedTurn.conversationId);
     await handleIncomingMessage(queuedTurn, socket, scopedRuntime, opts.onStatusChange, opts.connectionId, dequeuedBatch.batchId);
   };
-  socket.on("open", () => {
+  socket.on("open", async () => {
     if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
       return;
     }
@@ -94068,7 +94875,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       }
     }, 30000);
     startScheduler(socket, opts, processQueuedTurn);
-    wireChannelIngress(runtime, socket, opts, processQueuedTurn);
+    await wireChannelIngress(runtime, socket, opts, processQueuedTurn);
   });
   socket.on("message", async (data) => {
     const raw = data.toString();
@@ -94380,8 +95187,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: readFile11 } = await import("node:fs/promises");
-            const content = await readFile11(parsed.path, "utf-8");
+            const { readFile: readFile12 } = await import("node:fs/promises");
+            const content = await readFile12(parsed.path, "utf-8");
             console.log(`[Listen] read_file success: ${parsed.path} (${content.length} bytes)`);
             safeSocketSend(socket, {
               type: "read_file_response",
@@ -94411,10 +95218,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: readFile11 } = await import("node:fs/promises");
+            const { readFile: readFile12 } = await import("node:fs/promises");
             let currentContent = null;
             try {
-              currentContent = await readFile11(parsed.path, "utf-8");
+              currentContent = await readFile12(parsed.path, "utf-8");
             } catch (readErr) {
               const e = readErr;
               if (e.code !== "ENOENT")
@@ -94522,7 +95329,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 { readFile: readFile12 } = 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({
@@ -94538,7 +95345,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
             }
             if (result.replacements > 0) {
               try {
-                const contentAfter = await readFile11(parsed.file_path, "utf-8");
+                const contentAfter = await readFile12(parsed.file_path, "utf-8");
                 safeSocketSend(socket, {
                   type: "file_ops",
                   path: parsed.file_path,
@@ -95280,6 +96087,7 @@ var init_client4 = __esm(async () => {
     enqueueChannelTurn,
     scheduleQueuePump,
     replaySyncStateForRuntime,
+    recoverPendingChannelControlRequests,
     recoverApprovalStateForSync,
     clearRecoveredApprovalStateForScope: (runtime, scope) => clearRecoveredApprovalStateForScope(asListenerRuntimeForTests(runtime), scope),
     emitStateSync
@@ -95313,10 +96121,10 @@ __export(exports_debug2, {
 });
 import {
   appendFileSync as appendFileSync3,
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync28,
+  mkdirSync as mkdirSync21,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   unlinkSync as unlinkSync8
 } from "node:fs";
 import { homedir as homedir27 } from "node:os";
@@ -95368,9 +96176,9 @@ class DebugLogFile2 {
     if (!this.logPath)
       return;
     try {
-      if (!existsSync27(this.logPath))
+      if (!existsSync28(this.logPath))
         return;
-      const content = readFileSync18(this.logPath, "utf8");
+      const content = readFileSync19(this.logPath, "utf8");
       const lines = content.trimEnd().split(`
 `);
       return lines.slice(-maxLines).join(`
@@ -95383,8 +96191,8 @@ class DebugLogFile2 {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync27(this.agentDir)) {
-        mkdirSync20(this.agentDir, { recursive: true });
+      if (!existsSync28(this.agentDir)) {
+        mkdirSync21(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
     } catch {}
@@ -95393,7 +96201,7 @@ class DebugLogFile2 {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync27(this.agentDir))
+      if (!existsSync28(this.agentDir))
         return;
       const files = readdirSync10(this.agentDir).filter((f) => f.endsWith(".log")).sort();
       if (files.length >= MAX_SESSION_FILES3) {
@@ -95452,12 +96260,12 @@ __export(exports_skills2, {
   SKILLS_DIR: () => SKILLS_DIR2,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
-import { existsSync as existsSync28 } from "node:fs";
-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 { existsSync as existsSync29 } from "node:fs";
+import { readdir as readdir8, readFile as readFile12, realpath as realpath4, stat as stat7 } from "node:fs/promises";
+import { dirname as dirname14, join as join35 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
-  const thisDir = dirname13(fileURLToPath8(import.meta.url));
+  const thisDir = dirname14(fileURLToPath8(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
     return join35(thisDir, "../skills/builtin");
   }
@@ -95476,7 +96284,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source) {
   const errors = [];
-  if (!existsSync28(skillsPath)) {
+  if (!existsSync29(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -95584,7 +96392,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
   }
 }
 async function parseSkillFile2(filePath, rootPath, source) {
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile12(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const normalizedRoot = rootPath.endsWith("/") ? rootPath.slice(0, -1) : rootPath;
   const relativePath = filePath.slice(normalizedRoot.length + 1);
@@ -95643,35 +96451,35 @@ __export(exports_fs, {
   writeJsonFile: () => writeJsonFile,
   writeFile: () => writeFile10,
   readJsonFile: () => readJsonFile,
-  readFile: () => readFile12,
+  readFile: () => readFile13,
   mkdir: () => mkdir9,
   exists: () => exists2
 });
 import {
-  existsSync as existsSync29,
+  existsSync as existsSync30,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
-  mkdirSync as mkdirSync21
+  mkdirSync as mkdirSync22
 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
-async function readFile12(path24) {
+import { dirname as dirname15 } from "node:path";
+async function readFile13(path24) {
   return fsReadFileSync2(path24, { encoding: "utf-8" });
 }
 async function writeFile10(path24, content) {
-  const dir = dirname14(path24);
-  if (!existsSync29(dir)) {
-    mkdirSync21(dir, { recursive: true });
+  const dir = dirname15(path24);
+  if (!existsSync30(dir)) {
+    mkdirSync22(dir, { recursive: true });
   }
   fsWriteFileSync2(path24, content, { encoding: "utf-8", flush: true });
 }
 function exists2(path24) {
-  return existsSync29(path24);
+  return existsSync30(path24);
 }
 async function mkdir9(path24, options) {
-  mkdirSync21(path24, options);
+  mkdirSync22(path24, options);
 }
 async function readJsonFile(path24) {
-  const text = await readFile12(path24);
+  const text = await readFile13(path24);
   return JSON.parse(text);
 }
 async function writeJsonFile(path24, data, options) {
@@ -95801,18 +96609,18 @@ var exports_bootstrap_tools = {};
 __export(exports_bootstrap_tools, {
   bootstrapBaseToolsIfNeeded: () => bootstrapBaseToolsIfNeeded
 });
-import { existsSync as existsSync30, mkdirSync as mkdirSync22, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync23, writeFileSync as writeFileSync17 } from "node:fs";
 import { homedir as homedir28 } from "node:os";
 import { join as join36 } from "node:path";
 async function bootstrapBaseToolsIfNeeded() {
-  if (existsSync30(MARKER_PATH))
+  if (existsSync31(MARKER_PATH))
     return;
   debugLog("bootstrap", "No marker found, bootstrapping base tools...");
   try {
     const success = await addBaseToolsToServer();
     if (success) {
-      mkdirSync22(join36(homedir28(), ".letta"), { recursive: true });
-      writeFileSync16(MARKER_PATH, new Date().toISOString(), "utf-8");
+      mkdirSync23(join36(homedir28(), ".letta"), { recursive: true });
+      writeFileSync17(MARKER_PATH, new Date().toISOString(), "utf-8");
     }
   } catch (err) {
     debugWarn("bootstrap", `Failed to bootstrap base tools: ${err instanceof Error ? err.message : String(err)}`);
@@ -97510,8 +98318,8 @@ __export(exports_import, {
   extractSkillsFromAf: () => extractSkillsFromAf
 });
 import { createReadStream } from "node:fs";
-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";
+import { chmod, mkdir as mkdir10, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname16, resolve as resolve28 } from "node:path";
 async function importAgentFromFile(options) {
   const client = await getClient();
   const resolvedPath = resolve28(options.filePath);
@@ -97543,7 +98351,7 @@ async function importAgentFromFile(options) {
 }
 async function extractSkillsFromAf(afPath, destDir) {
   const extracted = [];
-  const content = await readFile13(afPath, "utf-8");
+  const content = await readFile14(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
@@ -97570,7 +98378,7 @@ async function writeSkillFiles(skillDir, files) {
 }
 async function writeSkillFile(skillDir, filePath, content) {
   const fullPath = resolve28(skillDir, filePath);
-  await mkdir10(dirname15(fullPath), { recursive: true });
+  await mkdir10(dirname16(fullPath), { recursive: true });
   await writeFile11(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
@@ -117533,9 +118341,9 @@ function getFileEditHeader(toolName, toolArgs) {
     const relPath = relative16(cwd2, filePath);
     const displayPath = relPath.startsWith("..") ? filePath : relPath;
     if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-      const { existsSync: existsSync33 } = __require("node:fs");
+      const { existsSync: existsSync34 } = __require("node:fs");
       try {
-        if (existsSync33(filePath)) {
+        if (existsSync34(filePath)) {
           return `Overwrite ${displayPath}?`;
         }
       } catch {}
@@ -118312,9 +119120,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative16(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: existsSync33 } = __require("node:fs");
+    const { existsSync: existsSync34 } = __require("node:fs");
     try {
-      if (existsSync33(fileEdit.filePath)) {
+      if (existsSync34(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -120400,7 +121208,7 @@ html.dark .agent-name { color: var(--text-dim); }
 var init_plan_viewer_template = () => {};
 
 // src/web/generate-plan-viewer.ts
-import { chmodSync as chmodSync2, existsSync as existsSync33, mkdirSync as mkdirSync25, writeFileSync as writeFileSync19 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync34, mkdirSync as mkdirSync26, writeFileSync as writeFileSync20 } from "node:fs";
 import { homedir as homedir32 } from "node:os";
 import { join as join41 } from "node:path";
 async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
@@ -120412,14 +121220,14 @@ async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
   };
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html = plan_viewer_template_default.replace("<!--LETTA_PLAN_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync33(VIEWERS_DIR)) {
-    mkdirSync25(VIEWERS_DIR, { recursive: true, mode: 448 });
+  if (!existsSync34(VIEWERS_DIR)) {
+    mkdirSync26(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync2(VIEWERS_DIR, 448);
   } catch {}
   const filePath = join41(VIEWERS_DIR, "plan.html");
-  writeFileSync19(filePath, html);
+  writeFileSync20(filePath, html);
   chmodSync2(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
   if (!skipOpen) {
@@ -122775,7 +123583,7 @@ var init_pasteRegistry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 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 { existsSync as existsSync35, readFileSync as readFileSync21, statSync as statSync10, unlinkSync as unlinkSync10 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename as basename10, extname as extname8, isAbsolute as isAbsolute20, join as join42, resolve as resolve29 } from "node:path";
 function countLines2(text) {
@@ -122827,8 +123635,8 @@ function translatePasteForImages(paste) {
       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);
+      if (IMAGE_EXTS.has(ext3) && existsSync35(filePath) && statSync10(filePath).isFile()) {
+        const buf = readFileSync21(filePath);
         const b64 = buf.toString("base64");
         const mt = ext3 === ".png" ? "image/png" : ext3 === ".jpg" || ext3 === ".jpeg" ? "image/jpeg" : ext3 === ".gif" ? "image/gif" : ext3 === ".webp" ? "image/webp" : ext3 === ".bmp" ? "image/bmp" : ext3 === ".svg" ? "image/svg+xml" : ext3 === ".tif" || ext3 === ".tiff" ? "image/tiff" : ext3 === ".heic" ? "image/heic" : ext3 === ".heif" ? "image/heif" : ext3 === ".avif" ? "image/avif" : "application/octet-stream";
         const id = allocateImage({
@@ -122868,11 +123676,11 @@ function getClipboardImageToTempFile() {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    if (!uti || !existsSync34(tempPath))
+    if (!uti || !existsSync35(tempPath))
       return null;
     return { tempPath, uti };
   } catch {
-    if (existsSync34(tempPath)) {
+    if (existsSync35(tempPath)) {
       try {
         unlinkSync10(tempPath);
       } catch {}
@@ -122888,7 +123696,7 @@ async function tryImportClipboardImageMac() {
     return null;
   const { tempPath, uti } = clipboardResult;
   try {
-    const buffer = readFileSync20(tempPath);
+    const buffer = readFileSync21(tempPath);
     try {
       unlinkSync10(tempPath);
     } catch {}
@@ -122905,7 +123713,7 @@ async function tryImportClipboardImageMac() {
       height: resized.height
     };
   } catch (err) {
-    if (existsSync34(tempPath)) {
+    if (existsSync35(tempPath)) {
       try {
         unlinkSync10(tempPath);
       } catch {}
@@ -123595,13 +124403,13 @@ __export(exports_terminalKeybindingInstaller, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync35,
-  mkdirSync as mkdirSync26,
-  readFileSync as readFileSync21,
-  writeFileSync as writeFileSync20
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync27,
+  readFileSync as readFileSync22,
+  writeFileSync as writeFileSync21
 } from "node:fs";
 import { homedir as homedir33, platform as platform6 } from "node:os";
-import { dirname as dirname16, join as join43 } from "node:path";
+import { dirname as dirname17, join as join43 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -123664,10 +124472,10 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync35(keybindingsPath))
+  if (!existsSync36(keybindingsPath))
     return false;
   try {
-    const content = readFileSync21(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync22(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings)
       return false;
@@ -123677,7 +124485,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync35(keybindingsPath))
+  if (!existsSync36(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -123692,15 +124500,15 @@ function installKeybinding(keybindingsPath) {
     if (keybindingExists(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname16(keybindingsPath);
-    if (!existsSync35(parentDir)) {
-      mkdirSync26(parentDir, { recursive: true });
+    const parentDir = dirname17(keybindingsPath);
+    if (!existsSync36(parentDir)) {
+      mkdirSync27(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync35(keybindingsPath)) {
+    if (existsSync36(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
-      const content = readFileSync21(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync22(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
       if (parsed === null) {
         return {
@@ -123713,7 +124521,7 @@ function installKeybinding(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync20(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync21(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -123728,10 +124536,10 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync35(keybindingsPath)) {
+    if (!existsSync36(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync21(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync22(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings) {
       return {
@@ -123742,7 +124550,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)}
 `;
-    writeFileSync20(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync21(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -123796,19 +124604,19 @@ function getWezTermConfigPath() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
     const xdgPath = join43(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync35(xdgPath))
+    if (existsSync36(xdgPath))
       return xdgPath;
   }
   const configPath = join43(homedir33(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync35(configPath))
+  if (existsSync36(configPath))
     return configPath;
   return join43(homedir33(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync35(configPath))
+  if (!existsSync36(configPath))
     return false;
   try {
-    const content = readFileSync21(configPath, { encoding: "utf-8" });
+    const content = readFileSync22(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -123822,10 +124630,10 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync35(configPath)) {
+    if (existsSync36(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync(configPath, backupPath);
-      content = readFileSync21(configPath, { encoding: "utf-8" });
+      content = readFileSync22(configPath, { encoding: "utf-8" });
     }
     if (content.includes("return {") && !content.includes("local config")) {
       content = content.replace(/return\s*\{/, "local config = {");
@@ -123851,11 +124659,11 @@ return config`);
 ${WEZTERM_DELETE_FIX}
 `;
     }
-    const parentDir = dirname16(configPath);
-    if (!existsSync35(parentDir)) {
-      mkdirSync26(parentDir, { recursive: true });
+    const parentDir = dirname17(configPath);
+    if (!existsSync36(parentDir)) {
+      mkdirSync27(parentDir, { recursive: true });
     }
-    writeFileSync20(configPath, content, { encoding: "utf-8" });
+    writeFileSync21(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -124439,9 +125247,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync36 } from "node:fs";
-import { readdir as readdir10, readFile as readFile14 } from "node:fs/promises";
-import { basename as basename11, dirname as dirname17, join as join44 } from "node:path";
+import { existsSync as existsSync37 } from "node:fs";
+import { readdir as readdir10, readFile as readFile15 } from "node:fs/promises";
+import { basename as basename11, dirname as dirname18, join as join44 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -124473,7 +125281,7 @@ async function discoverCustomCommands(projectPath = join44(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source2) {
-  if (!existsSync36(dirPath)) {
+  if (!existsSync37(dirPath)) {
     return [];
   }
   const commands2 = [];
@@ -124499,10 +125307,10 @@ async function findCommandFiles(currentPath, rootPath, commands2, source2) {
   } catch (_error) {}
 }
 async function parseCommandFile(filePath, rootPath, source2) {
-  const content = await readFile14(filePath, "utf-8");
+  const content = await readFile15(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const id = basename11(filePath, ".md");
-  const relativePath = dirname17(filePath).slice(rootPath.length);
+  const relativePath = dirname18(filePath).slice(rootPath.length);
   const namespace = relativePath.replace(/^[/\\]/, "") || undefined;
   let description = getStringField(frontmatter, "description");
   if (!description) {
@@ -129661,15 +130469,15 @@ var init_InputRich = __esm(async () => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import {
-  existsSync as existsSync37,
-  mkdirSync as mkdirSync27,
+  existsSync as existsSync38,
+  mkdirSync as mkdirSync28,
   mkdtempSync,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync21
+  writeFileSync as writeFileSync22
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { dirname as dirname18, join as join46 } from "node:path";
+import { dirname as dirname19, join as join46 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync4(command, args, {
@@ -129916,18 +130724,18 @@ function runGit6(args, cwd2) {
 }
 function writeWorkflow(repoDir, workflowPath, content) {
   const absolutePath = join46(repoDir, workflowPath);
-  if (!existsSync37(dirname18(absolutePath))) {
-    mkdirSync27(dirname18(absolutePath), { recursive: true });
+  if (!existsSync38(dirname19(absolutePath))) {
+    mkdirSync28(dirname19(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync37(absolutePath)) {
-    const previous = readFileSync22(absolutePath, "utf8");
+  if (existsSync38(absolutePath)) {
+    const previous = readFileSync23(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
   }
-  writeFileSync21(absolutePath, next, "utf8");
+  writeFileSync22(absolutePath, next, "utf8");
   return true;
 }
 function getDefaultBaseBranch(repoDir) {
@@ -134159,7 +134967,7 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb5 } from "node:child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync38, mkdirSync as mkdirSync28, writeFileSync as writeFileSync22 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync39, mkdirSync as mkdirSync29, writeFileSync as writeFileSync23 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
 import { join as join47 } from "node:path";
 import { promisify as promisify15 } from "node:util";
@@ -134479,14 +135287,14 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   }
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync38(VIEWERS_DIR2)) {
-    mkdirSync28(VIEWERS_DIR2, { recursive: true, mode: 448 });
+  if (!existsSync39(VIEWERS_DIR2)) {
+    mkdirSync29(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync3(VIEWERS_DIR2, 448);
   } catch {}
   const filePath = join47(VIEWERS_DIR2, `memory-${encodeURIComponent(agentId)}.html`);
-  writeFileSync22(filePath, html);
+  writeFileSync23(filePath, html);
   chmodSync3(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
   if (!skipOpen) {
@@ -134512,7 +135320,7 @@ var init_generate_memory_viewer = __esm(() => {
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync39 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i = 0;i < node.depth; i++) {
@@ -134538,7 +135346,7 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react79.useState(null);
   const statusTimerRef = import_react79.useRef(null);
   const memoryRoot = getMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync39(memoryRoot);
+  const memoryExists = existsSync40(memoryRoot);
   const hasGitRepo = import_react79.useMemo(() => isGitRepo(agentId), [agentId]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
@@ -137231,7 +138039,7 @@ var init_PersonalitySelector = __esm(async () => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 import { homedir as homedir36 } from "node:os";
 import { join as join48 } from "node:path";
 async function parseAwsCredentials() {
@@ -137239,11 +138047,11 @@ async function parseAwsCredentials() {
   const configPath = join48(homedir36(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile15(credentialsPath, "utf-8");
+    const content = await readFile16(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile15(configPath, "utf-8");
+    const content = await readFile16(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -142342,18 +143150,18 @@ var init_reasoningTabToggle = __esm(() => {
 });
 
 // src/cli/helpers/startupSystemPromptWarning.ts
-import { existsSync as existsSync40, readdirSync as readdirSync13, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync41, readdirSync as readdirSync13, readFileSync as readFileSync24 } from "node:fs";
 import { join as join49 } from "node:path";
 function estimateSystemTokens(text) {
   return Math.ceil(Buffer.byteLength(text, "utf8") / STARTUP_SYSTEM_PROMPT_ESTIMATED_BYTES_PER_TOKEN);
 }
 function estimateSystemPromptTokensFromMemoryDir(memoryDir) {
   const systemDir = join49(memoryDir, "system");
-  if (!existsSync40(systemDir)) {
+  if (!existsSync41(systemDir)) {
     return 0;
   }
   const walkMarkdownFiles = (dir) => {
-    if (!existsSync40(dir)) {
+    if (!existsSync41(dir)) {
       return [];
     }
     const out = [];
@@ -142377,7 +143185,7 @@ function estimateSystemPromptTokensFromMemoryDir(memoryDir) {
     return out;
   };
   return walkMarkdownFiles(systemDir).sort().reduce((sum, filePath) => {
-    const text = readFileSync23(filePath, "utf8");
+    const text = readFileSync24(filePath, "utf8");
     return sum + estimateSystemTokens(text);
   }, 0);
 }
@@ -143181,16 +143989,16 @@ __export(exports_shellAliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync41, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync25 } from "node:fs";
 import { homedir as homedir37 } from "node:os";
 import { join as join50 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync41(filePath)) {
+  if (!existsSync42(filePath)) {
     return aliases;
   }
   try {
-    const content = readFileSync24(filePath, "utf-8");
+    const content = readFileSync25(filePath, "utf-8");
     const lines = content.split(`
 `);
     let inFunction = false;
@@ -143908,7 +144716,7 @@ var exports_export = {};
 __export(exports_export, {
   packageSkills: () => packageSkills
 });
-import { readdir as readdir11, readFile as readFile16 } from "node:fs/promises";
+import { readdir as readdir11, readFile as readFile17 } from "node:fs/promises";
 import { relative as relative17, resolve as resolve32 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
@@ -143929,7 +144737,7 @@ async function packageSkills(agentId, skillsDir) {
         const skillDir = resolve32(baseDir, entry.name);
         const skillMdPath = resolve32(skillDir, "SKILL.md");
         try {
-          await readFile16(skillMdPath, "utf-8");
+          await readFile17(skillMdPath, "utf-8");
         } catch {
           console.warn(`Skipping invalid skill ${entry.name}: missing SKILL.md`);
           continue;
@@ -143961,7 +144769,7 @@ async function readSkillFiles(skillDir) {
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        const content = await readFile16(fullPath, "utf-8");
+        const content = await readFile17(fullPath, "utf-8");
         const relativePath = relative17(skillDir, fullPath).replace(/\\/g, "/");
         files[relativePath] = content;
       }
@@ -144101,7 +144909,7 @@ __export(exports_App, {
   default: () => App2
 });
 import { randomUUID as randomUUID14 } from "node:crypto";
-import { existsSync as existsSync42, readFileSync as readFileSync25, renameSync as renameSync3, writeFileSync as writeFileSync23 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync26, renameSync as renameSync3, writeFileSync as writeFileSync24 } from "node:fs";
 import { homedir as homedir38, tmpdir as tmpdir6 } from "node:os";
 import { join as join51, relative as relative18 } from "node:path";
 function deriveReasoningEffort(modelSettings, llmConfig) {
@@ -144357,18 +145165,18 @@ function saveLastSessionBeforeExit(conversationId) {
 }
 function planFileExists(fallbackPlanFilePath) {
   const planFilePath = permissionMode.getPlanFilePath() ?? fallbackPlanFilePath;
-  return !!planFilePath && existsSync42(planFilePath);
+  return !!planFilePath && existsSync43(planFilePath);
 }
 function _readPlanFile(fallbackPlanFilePath) {
   const planFilePath = permissionMode.getPlanFilePath() ?? fallbackPlanFilePath;
   if (!planFilePath) {
     return "No plan file path set.";
   }
-  if (!existsSync42(planFilePath)) {
+  if (!existsSync43(planFilePath)) {
     return `Plan file not found at ${planFilePath}`;
   }
   try {
-    return readFileSync25(planFilePath, "utf-8");
+    return readFileSync26(planFilePath, "utf-8");
   } catch {
     return `Failed to read plan file at ${planFilePath}`;
   }
@@ -145715,10 +146523,10 @@ function App2({
     if (!planFilePath)
       return;
     try {
-      const { readFileSync: readFileSync26, existsSync: existsSync43 } = __require("node:fs");
-      if (!existsSync43(planFilePath))
+      const { readFileSync: readFileSync27, existsSync: existsSync44 } = __require("node:fs");
+      if (!existsSync44(planFilePath))
         return;
-      const planContent = readFileSync26(planFilePath, "utf-8");
+      const planContent = readFileSync27(planFilePath, "utf-8");
       const previewItem = {
         kind: "approval_preview",
         id: `approval-preview-${toolCallId}`,
@@ -146144,9 +146952,9 @@ Memory may be stale. Try running: git -C ~/.letta/agents/${agentId}/memory pull`
     (async () => {
       try {
         const { watch: watch2 } = await import("node:fs");
-        const { existsSync: existsSync43 } = await import("node:fs");
+        const { existsSync: existsSync44 } = await import("node:fs");
         const memRoot = getMemoryFilesystemRoot(agentId);
-        if (!existsSync43(memRoot))
+        if (!existsSync44(memRoot))
           return;
         watcher = watch2(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher;
@@ -148687,9 +149495,9 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
               join51(memoryRoot, "system", "persona.md"),
               join51(memoryRoot, "memory", "system", "persona.md")
             ];
-            const personaPath = personaCandidates.find((candidate) => existsSync42(candidate));
+            const personaPath = personaCandidates.find((candidate) => existsSync43(candidate));
             if (personaPath) {
-              const personaContent = readFileSync25(personaPath, "utf-8");
+              const personaContent = readFileSync26(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
             } else {
               setCurrentPersonalityId(null);
@@ -149883,7 +150691,7 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
             fileContent.skills = skills;
           }
           const fileName = exportParams.conversation_id ? `${exportParams.conversation_id}.af` : `${agentId}.af`;
-          writeFileSync23(fileName, JSON.stringify(fileContent, null, 2));
+          writeFileSync24(fileName, JSON.stringify(fileContent, null, 2));
           let summary = `AgentFile exported to ${fileName}`;
           if (skills.length > 0) {
             summary += `
@@ -149973,7 +150781,7 @@ Path: ${result2.memoryDir}`, true, msg);
           setCommandRunning(true);
           try {
             const memoryDir = getMemoryFilesystemRoot(agentId);
-            if (!existsSync42(memoryDir)) {
+            if (!existsSync43(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
@@ -150005,7 +150813,7 @@ Run \`/memfs sync\` to repopulate from API.`, true, msg);
             await removeGitMemoryTag2(agentId);
             let backupInfo = "";
             const memoryDir = getMemoryFilesystemRoot(agentId);
-            if (existsSync42(memoryDir)) {
+            if (existsSync43(memoryDir)) {
               const backupDir = join51(tmpdir6(), `letta-memfs-disable-${agentId}-${Date.now()}`);
               renameSync3(memoryDir, backupDir);
               backupInfo = `
@@ -153914,13 +154722,13 @@ __export(exports_terminalKeybindingInstaller2, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync43,
-  mkdirSync as mkdirSync29,
-  readFileSync as readFileSync26,
-  writeFileSync as writeFileSync24
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync30,
+  readFileSync as readFileSync27,
+  writeFileSync as writeFileSync25
 } from "node:fs";
 import { homedir as homedir39, platform as platform7 } from "node:os";
-import { dirname as dirname19, join as join52 } from "node:path";
+import { dirname as dirname20, join as join52 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -153983,10 +154791,10 @@ function parseKeybindings2(content) {
   }
 }
 function keybindingExists2(keybindingsPath) {
-  if (!existsSync43(keybindingsPath))
+  if (!existsSync44(keybindingsPath))
     return false;
   try {
-    const content = readFileSync26(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync27(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings2(content);
     if (!keybindings)
       return false;
@@ -153996,7 +154804,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync43(keybindingsPath))
+  if (!existsSync44(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -154011,15 +154819,15 @@ function installKeybinding2(keybindingsPath) {
     if (keybindingExists2(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname19(keybindingsPath);
-    if (!existsSync43(parentDir)) {
-      mkdirSync29(parentDir, { recursive: true });
+    const parentDir = dirname20(keybindingsPath);
+    if (!existsSync44(parentDir)) {
+      mkdirSync30(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync43(keybindingsPath)) {
+    if (existsSync44(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
-      const content = readFileSync26(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync27(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
       if (parsed === null) {
         return {
@@ -154032,7 +154840,7 @@ function installKeybinding2(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING2);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync24(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync25(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -154047,10 +154855,10 @@ function installKeybinding2(keybindingsPath) {
 }
 function removeKeybinding2(keybindingsPath) {
   try {
-    if (!existsSync43(keybindingsPath)) {
+    if (!existsSync44(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync26(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync27(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings2(content);
     if (!keybindings) {
       return {
@@ -154061,7 +154869,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)}
 `;
-    writeFileSync24(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync25(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -154115,19 +154923,19 @@ function getWezTermConfigPath2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
     const xdgPath = join52(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync43(xdgPath))
+    if (existsSync44(xdgPath))
       return xdgPath;
   }
   const configPath = join52(homedir39(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync43(configPath))
+  if (existsSync44(configPath))
     return configPath;
   return join52(homedir39(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists2(configPath) {
-  if (!existsSync43(configPath))
+  if (!existsSync44(configPath))
     return false;
   try {
-    const content = readFileSync26(configPath, { encoding: "utf-8" });
+    const content = readFileSync27(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -154141,10 +154949,10 @@ function installWezTermDeleteFix2() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync43(configPath)) {
+    if (existsSync44(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync2(configPath, backupPath);
-      content = readFileSync26(configPath, { encoding: "utf-8" });
+      content = readFileSync27(configPath, { encoding: "utf-8" });
     }
     if (content.includes("return {") && !content.includes("local config")) {
       content = content.replace(/return\s*\{/, "local config = {");
@@ -154170,11 +154978,11 @@ return config`);
 ${WEZTERM_DELETE_FIX2}
 `;
     }
-    const parentDir = dirname19(configPath);
-    if (!existsSync43(parentDir)) {
-      mkdirSync29(parentDir, { recursive: true });
+    const parentDir = dirname20(configPath);
+    if (!existsSync44(parentDir)) {
+      mkdirSync30(parentDir, { recursive: true });
     }
-    writeFileSync24(configPath, content, { encoding: "utf-8" });
+    writeFileSync25(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -154739,8 +155547,8 @@ __export(exports_import2, {
   extractSkillsFromAf: () => extractSkillsFromAf2
 });
 import { createReadStream as createReadStream2 } from "node:fs";
-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";
+import { chmod as chmod2, mkdir as mkdir11, readFile as readFile18, writeFile as writeFile12 } from "node:fs/promises";
+import { dirname as dirname21, resolve as resolve33 } from "node:path";
 async function importAgentFromFile2(options) {
   const client = await getClient();
   const resolvedPath = resolve33(options.filePath);
@@ -154772,7 +155580,7 @@ async function importAgentFromFile2(options) {
 }
 async function extractSkillsFromAf2(afPath, destDir) {
   const extracted = [];
-  const content = await readFile17(afPath, "utf-8");
+  const content = await readFile18(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
@@ -154799,7 +155607,7 @@ async function writeSkillFiles2(skillDir, files) {
 }
 async function writeSkillFile2(skillDir, filePath, content) {
   const fullPath = resolve33(skillDir, filePath);
-  await mkdir11(dirname20(fullPath), { recursive: true });
+  await mkdir11(dirname21(fullPath), { recursive: true });
   await writeFile12(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
@@ -154908,7 +155716,7 @@ __export(exports_memoryFilesystem2, {
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR2,
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR2
 });
-import { existsSync as existsSync44, mkdirSync as mkdirSync30 } from "node:fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync31 } from "node:fs";
 import { homedir as homedir41 } from "node:os";
 import { join as join54 } from "node:path";
 function getMemoryFilesystemRoot2(agentId, homeDir = homedir41()) {
@@ -154920,11 +155728,11 @@ function getMemorySystemDir2(agentId, homeDir = homedir41()) {
 function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir41()) {
   const root = getMemoryFilesystemRoot2(agentId, homeDir);
   const systemDir = getMemorySystemDir2(agentId, homeDir);
-  if (!existsSync44(root)) {
-    mkdirSync30(root, { recursive: true });
+  if (!existsSync45(root)) {
+    mkdirSync31(root, { recursive: true });
   }
-  if (!existsSync44(systemDir)) {
-    mkdirSync30(systemDir, { recursive: true });
+  if (!existsSync45(systemDir)) {
+    mkdirSync31(systemDir, { recursive: true });
   }
 }
 async function isMemfsEnabledOnServer2(agentId) {
@@ -159578,8 +160386,8 @@ import { parseArgs as parseArgs7 } from "node:util";
 // src/websocket/listen-log.ts
 import {
   appendFileSync as appendFileSync2,
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync17,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync18,
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync6
 } from "node:fs";
@@ -159597,7 +160405,7 @@ function formatTimestamp2() {
 }
 function pruneOldLogs() {
   try {
-    if (!existsSync23(REMOTE_LOG_DIR))
+    if (!existsSync24(REMOTE_LOG_DIR))
       return;
     const files = readdirSync7(REMOTE_LOG_DIR).filter((f) => f.endsWith(".log")).sort();
     if (files.length >= MAX_LOG_FILES) {
@@ -159644,8 +160452,8 @@ class RemoteSessionLog {
     if (this.dirCreated)
       return;
     try {
-      if (!existsSync23(REMOTE_LOG_DIR)) {
-        mkdirSync17(REMOTE_LOG_DIR, { recursive: true });
+      if (!existsSync24(REMOTE_LOG_DIR)) {
+        mkdirSync18(REMOTE_LOG_DIR, { recursive: true });
       }
       this.dirCreated = true;
     } catch {}
@@ -160146,7 +160954,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 { cpSync, existsSync as existsSync27, mkdirSync as mkdirSync20, rmSync as rmSync3, statSync as statSync8 } from "node:fs";
 import { readdir as readdir7 } from "node:fs/promises";
 import { homedir as homedir24 } from "node:os";
 import { join as join31 } from "node:path";
@@ -160211,7 +161019,7 @@ function formatBackupTimestamp(date = new Date) {
 }
 async function listBackups(agentId) {
   const agentRoot = getAgentRoot(agentId);
-  if (!existsSync26(agentRoot)) {
+  if (!existsSync27(agentRoot)) {
     return [];
   }
   const entries = await readdir7(agentRoot, { withFileTypes: true });
@@ -160298,14 +161106,14 @@ async function runMemfsSubcommand(argv) {
     }
     if (action === "backup") {
       const root = getMemoryRoot(agentId);
-      if (!existsSync26(root)) {
+      if (!existsSync27(root)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
       const agentRoot = getAgentRoot(agentId);
       const backupName = `memory-backup-${formatBackupTimestamp()}`;
       const backupPath = join31(agentRoot, backupName);
-      if (existsSync26(backupPath)) {
+      if (existsSync27(backupPath)) {
         console.error(`Backup already exists at ${backupPath}`);
         return 1;
       }
@@ -160329,7 +161137,7 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       const backupPath = resolveBackupPath(agentId, from);
-      if (!existsSync26(backupPath)) {
+      if (!existsSync27(backupPath)) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
@@ -160351,11 +161159,11 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       const root = getMemoryRoot(agentId);
-      if (!existsSync26(root)) {
+      if (!existsSync27(root)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
-      if (existsSync26(out)) {
+      if (existsSync27(out)) {
         const stat7 = statSync8(out);
         if (stat7.isDirectory()) {
           const contents = await readdir7(out);
@@ -160368,7 +161176,7 @@ async function runMemfsSubcommand(argv) {
           return 1;
         }
       } else {
-        mkdirSync19(out, { recursive: true });
+        mkdirSync20(out, { recursive: true });
       }
       cpSync(root, out, { recursive: true });
       console.log(JSON.stringify({ exportedFrom: root, exportedTo: out, agentId }, null, 2));
@@ -163349,9 +164157,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     } else {
       const { resolve: resolve34 } = await import("path");
-      const { existsSync: existsSync45 } = await import("fs");
+      const { existsSync: existsSync46 } = await import("fs");
       const resolvedPath = resolve34(fromAfFile);
-      if (!existsSync45(resolvedPath)) {
+      if (!existsSync46(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
       }
@@ -164230,4 +165038,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=B587994115421B1064756E2164756E21
+//# debugId=D837155EA6C28D1764756E2164756E21