@letta-ai/letta-code 0.34.6 → 0.34.8

package/letta.js

@@ -3930,6 +3930,7 @@ var init_toolset_catalog = __esm(() => {
         "Wake",
         "TaskStop",
         "Skill",
+        "Memory",
         "Workflow",
         "exec_command",
         "write_stdin",
@@ -3964,6 +3965,7 @@ var init_toolset_catalog = __esm(() => {
         "TaskStop",
         "Read",
         "Skill",
+        "Memory",
         "Workflow",
         "Task",
         "SendAgentMessage",
@@ -3990,6 +3992,7 @@ var init_toolset_catalog = __esm(() => {
         "Wake",
         "TaskStop",
         "Skill",
+        "Memory",
         "Workflow",
         "exec_command",
         "write_stdin",
@@ -5724,7 +5727,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.34.6",
+    version: "0.34.8",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -5999,7 +6002,7 @@ var init_package = __esm(() => {
     },
     lettaLifecycleProtocol: 1,
     lettaRuntimeGraphProtocol: 1,
-    lettaRuntimeGraphSha512: "sha512-XLLoGDBuKF5JywIzS03nqOmcuSbwY1oGBwkINW2htdSGxlMnDVGIKq6HZLoE6hDMudNN3mzVIBUhdIYIlj2zzw=="
+    lettaRuntimeGraphSha512: "sha512-NkEBUY1HKUlzrKrw9Z5465jdqkp+u7tLYNly5lGlHQKUAoN/8N4gGSsIXTsc3u2Eiz9f05ryN0l5zJOf1/q1iA=="
   };
 });
 
@@ -120190,6 +120193,226 @@ var init_personality = __esm(() => {
   execFile5 = promisify6(execFileCb3);
 });
 
+// src/browser-discovery-server.ts
+import {
+  createServer as createServer3
+} from "node:http";
+function startBrowserDiscoveryServer(options = {}) {
+  const port = options.port ?? BROWSER_DISCOVERY_PORT;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  let activeServer = null;
+  let pendingServer = null;
+  let retryTimer = null;
+  let stopped = false;
+  let readySettled = false;
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((resolve10, reject) => {
+    resolveReady = resolve10;
+    rejectReady = reject;
+  });
+  ready.catch(() => {
+    return;
+  });
+  const scheduleRetry = () => {
+    if (stopped || retryTimer)
+      return;
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      attemptListen();
+    }, retryDelayMs);
+    retryTimer.unref();
+  };
+  const attemptListen = () => {
+    if (stopped || activeServer || pendingServer)
+      return;
+    const candidate = createBrowserDiscoveryHttpServer();
+    pendingServer = candidate;
+    const onStartupError = (error4) => {
+      pendingServer = null;
+      candidate.close();
+      if (error4.code === "EADDRINUSE") {
+        scheduleRetry();
+        return;
+      }
+      if (!readySettled) {
+        readySettled = true;
+        rejectReady(error4);
+      }
+    };
+    candidate.once("error", onStartupError);
+    candidate.listen(port, BROWSER_DISCOVERY_HOST, () => {
+      candidate.off("error", onStartupError);
+      if (stopped) {
+        candidate.close();
+        return;
+      }
+      pendingServer = null;
+      activeServer = candidate;
+      candidate.unref();
+      const address = candidate.address();
+      if (!address || typeof address === "string") {
+        candidate.close();
+        return;
+      }
+      if (!readySettled) {
+        readySettled = true;
+        resolveReady(formatDiscoveryAddress(address));
+      }
+      candidate.on("error", () => {
+        if (activeServer !== candidate)
+          return;
+        activeServer = null;
+        candidate.close();
+        scheduleRetry();
+      });
+      candidate.once("close", () => {
+        if (activeServer === candidate)
+          activeServer = null;
+        scheduleRetry();
+      });
+    });
+  };
+  attemptListen();
+  return {
+    ready,
+    close: async () => {
+      if (stopped)
+        return;
+      stopped = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      if (!readySettled) {
+        readySettled = true;
+        rejectReady(new Error("Browser discovery server stopped before listening"));
+      }
+      const servers = [pendingServer, activeServer].filter((server2) => server2 !== null);
+      pendingServer = null;
+      activeServer = null;
+      await Promise.all(servers.map(closeServer));
+    }
+  };
+}
+function createBrowserDiscoveryHttpServer() {
+  let server2;
+  server2 = createServer3((request, response) => {
+    handleBrowserDiscoveryRequest(server2, request, response);
+  });
+  server2.headersTimeout = 5000;
+  server2.requestTimeout = 5000;
+  server2.keepAliveTimeout = 1000;
+  server2.maxHeadersCount = 32;
+  server2.on("connection", (socket) => socket.unref());
+  server2.on("timeout", (socket) => socket.destroy());
+  server2.on("clientError", (_error, socket) => {
+    if (!socket.writable)
+      return;
+    socket.end(`HTTP/1.1 400 Bad Request\r
+Connection: close\r
+Content-Length: 0\r
+\r
+`);
+  });
+  return server2;
+}
+function handleBrowserDiscoveryRequest(server2, request, response) {
+  if (!isLoopbackAddress(request.socket.remoteAddress)) {
+    respond(response, 403, "Browser connection must use loopback");
+    return;
+  }
+  const address = server2.address();
+  const expectedHost = address && typeof address !== "string" ? `${BROWSER_DISCOVERY_HOST}:${address.port}` : null;
+  if (!expectedHost || request.headers.host !== expectedHost) {
+    respond(response, 400, "Invalid discovery host");
+    return;
+  }
+  if (request.url !== BROWSER_DISCOVERY_PATH) {
+    respond(response, 404, "Not found");
+    return;
+  }
+  const requestOrigin = request.headers.origin;
+  const origin = allowedBrowserOrigin(requestOrigin);
+  if (requestOrigin && !origin) {
+    respond(response, 403, "Browser origin is not allowed");
+    return;
+  }
+  if (request.method === "OPTIONS") {
+    if (!origin || request.headers["access-control-request-method"] !== "GET") {
+      respond(response, 403, "Browser preflight is not allowed");
+      return;
+    }
+    response.writeHead(204, {
+      ...browserAccessHeaders(origin),
+      "Content-Length": "0"
+    });
+    response.end();
+    return;
+  }
+  if (request.method !== "GET") {
+    response.writeHead(405, {
+      ...browserAccessHeaders(origin),
+      Allow: "GET, OPTIONS",
+      "Content-Type": "text/plain; charset=utf-8"
+    });
+    response.end("Method not allowed");
+    return;
+  }
+  response.writeHead(200, {
+    ...browserAccessHeaders(origin),
+    "Content-Length": String(Buffer.byteLength(STATUS_BODY)),
+    "Content-Type": "application/json; charset=utf-8"
+  });
+  response.end(STATUS_BODY);
+}
+function allowedBrowserOrigin(value) {
+  if (!value)
+    return;
+  return ALLOWED_BROWSER_ORIGINS.has(value) || LOCAL_BROWSER_ORIGIN.test(value) ? value : undefined;
+}
+function isLoopbackAddress(value) {
+  return value === "127.0.0.1" || value === "::ffff:127.0.0.1";
+}
+function browserAccessHeaders(origin) {
+  return {
+    "Access-Control-Allow-Methods": "GET, OPTIONS",
+    ...origin ? { "Access-Control-Allow-Origin": origin } : {},
+    "Access-Control-Allow-Private-Network": "true",
+    "Cache-Control": "no-store",
+    Connection: "close",
+    Vary: "Origin, Access-Control-Request-Method, Access-Control-Request-Private-Network"
+  };
+}
+function respond(response, statusCode2, body) {
+  response.writeHead(statusCode2, {
+    "Content-Length": String(Buffer.byteLength(body)),
+    "Content-Type": "text/plain; charset=utf-8"
+  });
+  response.end(body);
+}
+function formatDiscoveryAddress(address) {
+  return {
+    host: BROWSER_DISCOVERY_HOST,
+    port: address.port,
+    url: `http://${BROWSER_DISCOVERY_HOST}:${address.port}${BROWSER_DISCOVERY_PATH}`
+  };
+}
+async function closeServer(server2) {
+  server2.closeAllConnections();
+  if (!server2.listening)
+    return;
+  await new Promise((resolve10) => {
+    server2.close(() => resolve10());
+  });
+}
+var BROWSER_DISCOVERY_HOST = "127.0.0.1", BROWSER_DISCOVERY_PORT = 32187, BROWSER_DISCOVERY_PATH = "/status", DEFAULT_RETRY_DELAY_MS = 1000, STATUS_BODY, LOCAL_BROWSER_ORIGIN, ALLOWED_BROWSER_ORIGINS;
+var init_browser_discovery_server = __esm(() => {
+  STATUS_BODY = JSON.stringify({ status: "ok" });
+  LOCAL_BROWSER_ORIGIN = /^https?:\/\/(?:localhost|127\.0\.0\.1)(?::\d+)?$/;
+  ALLOWED_BROWSER_ORIGINS = new Set(["https://chat.letta.com"]);
+});
+
 // src/cli/args.ts
 import { parseArgs } from "node:util";
 function formatHelpFlagLabel(flagName, definition) {
@@ -195921,6 +196144,23 @@ Lists files and directories in a given path. The path parameter must be an absol
 If a directory has more than 1,000 entries, only the first 1,000 will be shown.`;
 var init_LS = () => {};
 
+// src/tools/descriptions/Memory.md
+var Memory_default = `Read deferred memory from your memory filesystem.
+
+Your root memory files are already in your system prompt. Everything else is deferred: the <deferred-memory> section lists directories you have not opened. Use this tool to open them progressively instead of guessing what they contain.
+
+- Memory("projects") returns projects/MEMORY.md, then the files (<memory_files>) and subdirectories (<deferred-memory>) directly beneath it, with their descriptions.
+- Memory("projects/code") opens a subdirectory the same way.
+- Memory("projects/example.md") returns that file.
+
+Entries are listed most recently edited first, up to 10 per directory.
+
+Paths are relative to your memory directory. Before acting on a person, project, channel, or topic that your memory index points to, open the matching memory rather than working from assumptions. Open one level at a time and only what the task needs.
+
+Do not use this tool for root memory files (already loaded) or skills/ (use Skill).
+`;
+var init_Memory = () => {};
+
 // src/tools/descriptions/Monitor.md
 var Monitor_default = 'Start a background monitor that streams events from a long-running script. Each stdout line is an event — you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you\'re waiting for the user to answer a question.\n\nPick by how many notifications you need:\n- **One** ("tell me when the server is ready / the build finishes") → use **Bash with `run_in_background`** and a command that exits when the condition is true, e.g. `until grep -q "Ready in" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits.\n- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") → Monitor with an unbounded command (`tail -f`, `inotifywait -m`, `while true`).\n- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") → Monitor with a command that emits lines and then exits.\n\nYour script\'s stdout is the event stream. Each line becomes a notification. Exit ends the watch.\n  # Each matching log line is an event\n  tail -f /var/log/app.log | grep --line-buffered "ERROR"\n  # Each file change is an event\n  inotifywait -m --format \'%e %f\' /watched/dir\n  # Node script that emits events as they arrive (e.g. WebSocket listener)\n  node watch-for-events.js\n\nFor open github.com pull requests, use WatchPR instead. It covers the whole PR surface and keeps watching after CI finishes. Use Monitor only when WatchPR does not apply.\n\n**Don\'t use an unbounded command for a single notification.** `tail -f`, `inotifywait -m`, and `while true` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash `run_in_background` with an `until` loop instead (one notification, ends in seconds). Note that `tail -f log | grep -m 1 ...` does *not* fix this: if the log goes quiet after the match, `tail` never receives SIGPIPE and the pipeline hangs anyway.\n\n- Every pipe stage must flush per line or matches sit in its buffer unseen: `grep` needs `--line-buffered`, `awk` needs `fflush()`. `head` cannot flush at all — `| head -N` delivers nothing until N matches accumulate, then ends the stream.\n- In poll loops, handle transient failures (`curl ... || true`) — one failed request shouldn\'t kill the monitor.\n- Poll intervals: 30s+ for remote APIs (rate limits), 0.5–1s for local checks.\n- Write a specific `description` — it appears in every notification ("errors in deploy.log" not "watching logs").\n- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications — for a command you run directly (e.g. `python train.py 2>&1 | grep --line-buffered ...`), merge stderr with `2>&1` so its failures reach your filter. (No effect on `tail -f` of an existing log — that file only contains what its writer redirected.)\n\n**Coverage — silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit — and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.\n  # Wrong — silent on crash, hang, or any non-success exit\n  tail -f run.log | grep --line-buffered "elapsed_steps="\n  # Right — one alternation covering progress + the failure signatures you\'d act on\n  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"\n\nFor poll loops checking job state, emit on every terminal status (`succeeded|failed|cancelled|timeout`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it — some extra noise is better than missing a crashloop.\n\n**Output volume**: Every stdout line is a conversation message, so the filter should be selective — but selective means "the lines you\'d act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.\n\nStdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.\n\nThe script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). Timeout → killed. Set `persistent: true` for session-length watches (log tails, long-lived event streams) — the monitor runs until you call TaskStop or the session ends. Use TaskStop to cancel early.\n\n**ws source** — open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.\n    ws: {url: \'wss://events.example.com/stream\', protocols: [\'v1\']},\n    description: \'deploy events\',\n\nEach text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as `[binary frame, N bytes]` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash — a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.\n\nPrefer this over `command: \'websocat wss://…\'` — it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.\n';
 var init_Monitor = () => {};
@@ -196774,8 +197014,14 @@ function parseUpdateChunk(lines, startIndex, endIndex, allowMissingContext) {
   }
   const oldLines = [];
   const newLines = [];
+  const contextLineIndices = [];
   let isEndOfFile = false;
   let parsedLineCount = 0;
+  const pushContextLine = (text2) => {
+    contextLineIndices.push([oldLines.length, newLines.length]);
+    oldLines.push(text2);
+    newLines.push(text2);
+  };
   while (index < endIndex) {
     const line = lines[index] ?? "";
     if (line === EOF_MARKER) {
@@ -196788,17 +197034,14 @@ function parseUpdateChunk(lines, startIndex, endIndex, allowMissingContext) {
       break;
     }
     if (line.length === 0) {
-      oldLines.push("");
-      newLines.push("");
+      pushContextLine("");
       parsedLineCount += 1;
       index += 1;
       continue;
     }
     const prefix = line[0];
     if (prefix === " ") {
-      const text2 = line.slice(1);
-      oldLines.push(text2);
-      newLines.push(text2);
+      pushContextLine(line.slice(1));
       parsedLineCount += 1;
       index += 1;
       continue;
@@ -196825,6 +197068,7 @@ function parseUpdateChunk(lines, startIndex, endIndex, allowMissingContext) {
       changeContext,
       oldLines,
       newLines,
+      contextLineIndices,
       isEndOfFile
     },
     nextIndex: index
@@ -196898,18 +197142,41 @@ async function deriveNewContentsFromChunks(absolutePath, filePathForErrors, chun
     const message = error4 instanceof Error ? error4.message : String(error4);
     throw new Error(`Failed to read file to update ${filePathForErrors}: ${message}`);
   }
-  const originalLines = originalContents.split(`
-`);
-  if (originalLines[originalLines.length - 1] === "") {
-    originalLines.pop();
-  }
+  const sourceFile = parseSourceFile(originalContents);
+  const originalLines = sourceFile.lines.map((line) => line.text);
   const replacements = computeReplacements(originalLines, filePathForErrors, chunks);
-  const newLines = applyReplacements([...originalLines], replacements);
-  if (newLines[newLines.length - 1] !== "") {
-    newLines.push("");
+  return applyReplacements(sourceFile, replacements).map((line) => `${line.text}${line.ending ?? ""}`).join("");
+}
+function parseSourceFile(contents) {
+  const lines = [];
+  let preferredEnding = null;
+  let lineStart = 0;
+  let cursor = 0;
+  while (cursor < contents.length) {
+    const char = contents[cursor];
+    let ending;
+    if (char === "\r") {
+      ending = contents[cursor + 1] === `
+` ? `\r
+` : "\r";
+    } else if (char === `
+`) {
+      ending = `
+`;
+    } else {
+      cursor += 1;
+      continue;
+    }
+    preferredEnding ??= ending;
+    lines.push({ text: contents.slice(lineStart, cursor), ending });
+    cursor += ending.length;
+    lineStart = cursor;
   }
-  return newLines.join(`
-`);
+  if (lineStart < contents.length) {
+    lines.push({ text: contents.slice(lineStart), ending: null });
+  }
+  return { lines, preferredEnding: preferredEnding ?? `
+` };
 }
 function computeReplacements(originalLines, filePathForErrors, chunks) {
   const replacements = [];
@@ -196923,8 +197190,7 @@ function computeReplacements(originalLines, filePathForErrors, chunks) {
       lineIndex = contextIndex + 1;
     }
     if (chunk2.oldLines.length === 0) {
-      const insertionIndex = originalLines[originalLines.length - 1] === "" ? originalLines.length - 1 : originalLines.length;
-      replacements.push([insertionIndex, 0, [...chunk2.newLines]]);
+      replacements.push([originalLines.length, 0, [...chunk2.newLines]]);
       continue;
     }
     let pattern4 = [...chunk2.oldLines];
@@ -196942,23 +197208,47 @@ function computeReplacements(originalLines, filePathForErrors, chunks) {
 ${chunk2.oldLines.join(`
 `)}`);
     }
-    replacements.push([found, pattern4.length, newSlice]);
+    let oldStart = 0;
+    let newStart = 0;
+    for (const [oldContext, newContext] of chunk2.contextLineIndices) {
+      if (oldContext >= pattern4.length || newContext >= newSlice.length) {
+        break;
+      }
+      if (oldStart !== oldContext || newStart !== newContext) {
+        replacements.push([
+          found + oldStart,
+          oldContext - oldStart,
+          newSlice.slice(newStart, newContext)
+        ]);
+      }
+      oldStart = oldContext + 1;
+      newStart = newContext + 1;
+    }
+    if (oldStart !== pattern4.length || newStart !== newSlice.length) {
+      replacements.push([
+        found + oldStart,
+        pattern4.length - oldStart,
+        newSlice.slice(newStart)
+      ]);
+    }
     lineIndex = found + pattern4.length;
   }
   replacements.sort((left, right) => left[0] - right[0]);
   return replacements;
 }
-function applyReplacements(lines, replacements) {
-  for (let i4 = replacements.length - 1;i4 >= 0; i4 -= 1) {
-    const [startIndex, oldLength, newSegment] = replacements[i4];
-    for (let j2 = 0;j2 < oldLength; j2 += 1) {
-      if (startIndex < lines.length) {
-        lines.splice(startIndex, 1);
-      }
-    }
-    lines.splice(startIndex, 0, ...newSegment);
-  }
-  return lines;
+function applyReplacements({ lines, preferredEnding }, replacements) {
+  const newLines = [];
+  let sourceIndex = 0;
+  for (const [startIndex, oldLength, newSegment] of replacements) {
+    newLines.push(...lines.slice(sourceIndex, startIndex));
+    newLines.push(...newSegment.map((text2) => ({ text: text2, ending: preferredEnding })));
+    sourceIndex = startIndex + oldLength;
+  }
+  newLines.push(...lines.slice(sourceIndex));
+  return newLines.map((line) => ({
+    text: line.text,
+    ending: line.ending ?? preferredEnding
+  }));
 }
 function seekSequence(lines, pattern4, start, eof) {
   if (pattern4.length === 0) {
@@ -196968,7 +197258,7 @@ function seekSequence(lines, pattern4, start, eof) {
     return null;
   }
   const maxStart = lines.length - pattern4.length;
-  const searchStart = eof && lines.length >= pattern4.length ? lines.length - pattern4.length : start;
+  const searchStart = eof && lines.length >= pattern4.length ? Math.max(lines.length - pattern4.length, start) : start;
   const tryMatch = (matches3) => {
     for (let index = searchStart;index <= maxStart; index += 1) {
       let ok = true;
@@ -201222,6 +201512,7 @@ var init_truncation = __esm(() => {
     GREP_OUTPUT_CHARS: 1e4,
     GLOB_MAX_FILES: 2000,
     LS_MAX_ENTRIES: 1000,
+    MEMORY_MAX_ENTRIES: 10,
     TOOL_RETURN_MAX_CHARS: 32000
   };
 });
@@ -204618,6 +204909,7 @@ var init_approval_execution = __esm(async () => {
     "Read",
     "ViewImage",
     "Grep",
+    "Memory",
     "Glob",
     "conversation_search",
     "web_search",
@@ -206478,6 +206770,290 @@ var init_tool_name_mapping = __esm(() => {
   };
 });
 
+// src/tools/impl/memory.ts
+import { execFileSync as execFileSync9 } from "node:child_process";
+import {
+  closeSync as closeSync5,
+  existsSync as existsSync39,
+  openSync as openSync5,
+  readdirSync as readdirSync13,
+  readFileSync as readFileSync32,
+  readSync as readSync3,
+  realpathSync as realpathSync6,
+  statSync as statSync14
+} from "node:fs";
+import { extname as extname8, join as join51, sep as sep5 } from "node:path";
+function resolveMemoryToolDirectory(agentId) {
+  try {
+    const id2 = agentId === undefined ? getCurrentAgentId() : agentId;
+    const memoryDir = id2 ? getActiveMemoryDirectory(id2) : undefined;
+    return memoryDir && detectMemoryFormat(memoryDir, false) === "memfs-v2" ? memoryDir : null;
+  } catch {
+    return null;
+  }
+}
+function readDescription(path19) {
+  try {
+    const value = parseFrontmatter(readFileSync32(path19, "utf8")).frontmatter.description;
+    return typeof value === "string" ? value.trim() || undefined : undefined;
+  } catch {
+    return;
+  }
+}
+function readIndexDescription(path19) {
+  const fromFrontmatter = readDescription(path19);
+  if (fromFrontmatter)
+    return fromFrontmatter;
+  try {
+    const { body: body3 } = parseFrontmatter(readFileSync32(path19, "utf8"));
+    for (const block of body3.split(/\n\s*\n/)) {
+      const text2 = block.trim();
+      if (!text2 || /^(#|[-*+] |\d+\. |\||```|<)/.test(text2))
+        continue;
+      const paragraph = text2.replace(/\s*\n\s*/g, " ").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
+      return paragraph.length > 300 ? `${paragraph.slice(0, 297)}...` : paragraph;
+    }
+  } catch {}
+  return;
+}
+function isHidden2(name) {
+  return name.startsWith(".");
+}
+function findByBasename(dir, name, root2 = dir, found = []) {
+  for (const entry of readdirSync13(dir, { withFileTypes: true })) {
+    if (found.length >= 5)
+      break;
+    if (isHidden2(entry.name) || dir === root2 && entry.name === "skills") {
+      continue;
+    }
+    const path19 = join51(dir, entry.name);
+    if (entry.isDirectory())
+      findByBasename(path19, name, root2, found);
+    else if (entry.isFile() && entry.name === name && dir !== root2) {
+      found.push(path19.slice(root2.length + 1).split(sep5).join("/"));
+    }
+  }
+  return found;
+}
+function escapeXmlText2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function descriptionAttr(description) {
+  return description ? ` description="${escapeXmlText2(description).replace(/"/g, "&quot;")}"` : "";
+}
+function clampContent(content, fullPath, maxChars) {
+  const lines = content.split(`
+`);
+  const shown = lines.slice(0, LIMITS.READ_MAX_LINES);
+  let longLines = false;
+  let result2 = shown.map((line) => {
+    if (line.length <= LIMITS.READ_MAX_CHARS_PER_LINE)
+      return line;
+    longLines = true;
+    return `${line.slice(0, LIMITS.READ_MAX_CHARS_PER_LINE)}... [line truncated]`;
+  }).join(`
+`);
+  const byTotal = result2.length > maxChars;
+  if (byTotal)
+    result2 = truncateByChars(result2, maxChars, "Memory").content;
+  const byLines = shown.length < lines.length;
+  const notices = [];
+  if (byLines) {
+    notices.push(`[File truncated: showing lines 1-${shown.length} of ${lines.length} total lines. Use Read with offset and limit on the full file to read other sections.]`);
+  }
+  if (longLines) {
+    notices.push(`[Some lines exceeded ${LIMITS.READ_MAX_CHARS_PER_LINE.toLocaleString()} characters and were truncated.]`);
+  }
+  if (byTotal) {
+    notices.push("[Use Read with offset and limit on the full file to read it in smaller sections.]");
+  }
+  if (notices.length)
+    notices.push(`[Full file: ${fullPath}]`);
+  return notices.length ? `${result2}
+
+${notices.join(`
+
+`)}` : result2;
+}
+function lastEditedByChild(dir, names2) {
+  const edited = new Map;
+  const bump = (name, time) => {
+    if (time > (edited.get(name) ?? 0))
+      edited.set(name, time);
+  };
+  const git = (args) => execFileSync9("git", ["-C", dir, ...args], {
+    encoding: "utf8",
+    timeout: 5000,
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const walkMtime = (path19, name) => {
+    try {
+      const stat6 = statSync14(path19);
+      if (stat6.isFile())
+        return bump(name, stat6.mtimeMs);
+      if (!stat6.isDirectory())
+        return;
+      for (const entry of readdirSync13(path19, { withFileTypes: true })) {
+        if (!isHidden2(entry.name))
+          walkMtime(join51(path19, entry.name), name);
+      }
+    } catch {}
+  };
+  let dirty;
+  try {
+    let commitTime = 0;
+    for (const line of git([
+      "log",
+      "--format=%x00%ct",
+      "--name-only",
+      "--relative",
+      "--",
+      "."
+    ]).split(`
+`)) {
+      const child = line.split("/")[0] ?? line;
+      if (line.startsWith("\x00"))
+        commitTime = Number(line.slice(1)) * 1000;
+      else if (line && !edited.has(child))
+        edited.set(child, commitTime);
+    }
+    const prefix = git(["rev-parse", "--show-prefix"]).trim();
+    dirty = git([
+      "status",
+      "--porcelain=v1",
+      "-z",
+      "--untracked-files=all",
+      "--",
+      "."
+    ]).split("\x00").filter((record4) => record4.length > 3).map((record4) => record4.slice(3)).filter((path19) => path19.startsWith(prefix)).map((path19) => path19.slice(prefix.length));
+  } catch {
+    edited.clear();
+    dirty = names2;
+  }
+  for (const path19 of dirty)
+    walkMtime(join51(dir, path19), path19.split("/")[0] ?? path19);
+  return edited;
+}
+function renderDirectory(memoryDir, relPath, fullPath) {
+  const entries = readdirSync13(fullPath, { withFileTypes: true }).filter((entry) => !isHidden2(entry.name) && (entry.isDirectory() || entry.isFile() && entry.name !== INDEX));
+  const edited = lastEditedByChild(fullPath, entries.map((entry) => entry.name));
+  const shown = entries.sort((a2, b3) => (edited.get(b3.name) ?? 0) - (edited.get(a2.name) ?? 0) || a2.name.localeCompare(b3.name)).slice(0, LIMITS.MEMORY_MAX_ENTRIES);
+  const fileLines = shown.filter((entry) => entry.isFile()).map((entry) => {
+    const description = extname8(entry.name) === ".md" ? readDescription(join51(fullPath, entry.name)) : undefined;
+    return `  <file${descriptionAttr(description)}>${escapeXmlText2(`${relPath}/${entry.name}`)}</file>`;
+  });
+  const dirLines = shown.filter((entry) => entry.isDirectory()).map((entry) => {
+    const description = readIndexDescription(join51(fullPath, entry.name, INDEX));
+    return `  <directory${descriptionAttr(description)}>${escapeXmlText2(`${relPath}/${entry.name}`)}</directory>`;
+  });
+  const tail2 = [
+    `Memory directory: ${memoryDir}`,
+    "Paths in this memory are relative to the memory directory."
+  ];
+  if (fileLines.length) {
+    tail2.push("", "<memory_files>", ...fileLines, "</memory_files>");
+  }
+  if (dirLines.length) {
+    tail2.push("", "<deferred-memory>", ...dirLines, "</deferred-memory>");
+  }
+  if (entries.length > LIMITS.MEMORY_MAX_ENTRIES) {
+    tail2.push(`[Output truncated: showing ${LIMITS.MEMORY_MAX_ENTRIES.toLocaleString()} of ${entries.length.toLocaleString()} entries.]`, `[Full listing: ${fullPath}]`);
+  }
+  const tailText = tail2.join(`
+`);
+  const indexPath = join51(fullPath, INDEX);
+  const open4 = `<memory_content path="${escapeXmlText2(relPath).replace(/"/g, "&quot;")}">`;
+  const close = "</memory_content>";
+  let head4;
+  if (existsSync39(indexPath)) {
+    const budget = Math.max(2000, LIMITS.READ_OUTPUT_CHARS - tailText.length - open4.length - close.length - 16);
+    head4 = clampContent(readFileSync32(indexPath, "utf8").trimEnd(), indexPath, budget);
+  } else {
+    head4 = `<note>No ${INDEX} index in this directory.</note>`;
+  }
+  return `${open4}
+${head4}
+
+${tailText}
+${close}`;
+}
+function readPrefix(path19, bytes) {
+  const fd = openSync5(path19, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    return buffer.subarray(0, readSync3(fd, buffer, 0, bytes, 0));
+  } finally {
+    closeSync5(fd);
+  }
+}
+function renderFile(relPath, fullPath) {
+  const content = readFileSync32(fullPath, "utf8").trimEnd();
+  const open4 = `<memory_content path="${escapeXmlText2(relPath).replace(/"/g, "&quot;")}"${descriptionAttr(readDescription(fullPath))}>`;
+  const close = "</memory_content>";
+  return `${open4}
+${clampContent(content, fullPath, LIMITS.READ_OUTPUT_CHARS - open4.length - close.length - 2)}
+${close}`;
+}
+async function memory2(args) {
+  validateRequiredParams(args, ["path"], "Memory");
+  const memoryDir = resolveMemoryToolDirectory();
+  if (!memoryDir) {
+    throw new Error("Memory() is only available for agents with a MemFS v2 memory directory.");
+  }
+  const raw2 = String(args.path).trim();
+  const relPath = raw2.replace(/\\/g, "/").replace(/^(\.\/)+/, "").replace(/\/+$/, "");
+  if (!relPath || relPath === "." || relPath === INDEX) {
+    throw new Error("The memory root is already in your context. Pass a directory from <deferred-memory>.");
+  }
+  if (raw2.startsWith("/") || /^[A-Za-z]:/.test(raw2)) {
+    throw new Error('Paths are relative to the memory directory, e.g. "projects".');
+  }
+  const segments = relPath.split("/");
+  if (segments.some((s3) => s3 === ".." || s3 === "" || isHidden2(s3))) {
+    throw new Error(`Invalid memory path: ${raw2}`);
+  }
+  if (segments[0] === "skills") {
+    throw new Error(`skills/ is reserved for skills. Use Skill("${segments[1] ?? "<name>"}").`);
+  }
+  const fullPath = join51(memoryDir, ...segments);
+  if (!existsSync39(fullPath)) {
+    const candidates2 = !relPath.endsWith(".md") && existsSync39(`${fullPath}.md`) ? [`${relPath}.md`] : findByBasename(memoryDir, segments[segments.length - 1] ?? relPath);
+    const hint = candidates2.length ? ` Did you mean ${candidates2.join(" or ")}? Paths are relative to the memory directory.` : "";
+    throw new Error(`No memory at ${relPath}.${hint}`);
+  }
+  const realRoot = realpathSync6(memoryDir);
+  const realTarget = realpathSync6(fullPath);
+  if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep5)) {
+    throw new Error(`Invalid memory path: ${raw2}`);
+  }
+  const stat6 = statSync14(fullPath);
+  if (segments.length === 1 && stat6.isFile()) {
+    throw new Error(`${relPath} is root core memory and is already in your context.`);
+  }
+  if (stat6.isDirectory()) {
+    return { content: renderDirectory(memoryDir, relPath, fullPath) };
+  }
+  if (!stat6.isFile()) {
+    throw new Error(`Not a memory file or directory: ${relPath}`);
+  }
+  if (stat6.size > MAX_FILE_BYTES) {
+    throw new Error(`${relPath} is too large: ${stat6.size} bytes (max ${MAX_FILE_BYTES} bytes).`);
+  }
+  if (readPrefix(fullPath, 8000).includes(0)) {
+    throw new Error(`${relPath} is not a text file. Use Read on ${fullPath} instead.`);
+  }
+  return { content: renderFile(relPath, fullPath) };
+}
+var INDEX = "MEMORY.md", MAX_FILE_BYTES;
+var init_memory5 = __esm(() => {
+  init_context();
+  init_memory_format();
+  init_memory_runtime();
+  init_truncation();
+  MAX_FILE_BYTES = 10 * 1024 * 1024;
+});
+
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a2, b3, str) => {
   const ma = a2 instanceof RegExp ? maybeMatch(a2, str) : a2;
@@ -207799,7 +208375,7 @@ var minimatch = (p2, pattern4, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f4) => f4.length === len && f4 !== "." && f4 !== "..";
-}, defaultPlatform, path19, sep5, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter2 = (pattern4, options = {}) => (p2) => minimatch(p2, pattern4, options), ext = (a2, b3 = {}) => Object.assign({}, a2, b3), defaults5 = (def) => {
+}, defaultPlatform, path19, sep6, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter2 = (pattern4, options = {}) => (p2) => minimatch(p2, pattern4, options), ext = (a2, b3 = {}) => Object.assign({}, a2, b3), defaults5 = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -207861,8 +208437,8 @@ var init_esm3 = __esm(() => {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep5 = defaultPlatform === "win32" ? path19.win32.sep : path19.posix.sep;
-  minimatch.sep = sep5;
+  sep6 = defaultPlatform === "win32" ? path19.win32.sep : path19.posix.sep;
+  minimatch.sep = sep6;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
   star2 = qmark2 + "*?";
@@ -209753,6 +210329,16 @@ function checkPermissionForEngine(engine4, toolName2, toolArgs, permissions, wor
       trace
     };
   }
+  if (toolName2 === "Memory" && !isStrictMode) {
+    traceEvent(trace, "memory-auto-allow", "Memory tool is always allowed");
+    return {
+      result: {
+        decision: "allow",
+        reason: "Memory tool is always allowed (reads own memory)"
+      },
+      trace
+    };
+  }
   if (!isStrictMode && isShellToolName(canonicalTool)) {
     const shellCommand = extractShellCommand(toolArgs);
     if (shellCommand && isReadOnlyShellCommand(shellCommand, {
@@ -210068,15 +210654,15 @@ __export(exports_loader, {
   getUserSettingsPaths: () => getUserSettingsPaths
 });
 import { createHash as createHash4 } from "node:crypto";
-import { readFileSync as readFileSync32, statSync as statSync14, watch } from "node:fs";
+import { readFileSync as readFileSync33, statSync as statSync15, watch } from "node:fs";
 import { homedir as homedir26 } from "node:os";
-import { dirname as dirname21, join as join51, resolve as resolve25 } from "node:path";
+import { dirname as dirname21, join as join52, resolve as resolve25 } from "node:path";
 function getUserSettingsPaths(options = {}) {
   const homeDir = options.homeDir || homedir26();
-  const xdgConfigHome = options.xdgConfigHome || process.env.XDG_CONFIG_HOME || join51(homeDir, ".config");
+  const xdgConfigHome = options.xdgConfigHome || process.env.XDG_CONFIG_HOME || join52(homeDir, ".config");
   return {
-    canonical: join51(homeDir, ".letta", "settings.json"),
-    legacy: join51(xdgConfigHome, "letta", "settings.json")
+    canonical: join52(homeDir, ".letta", "settings.json"),
+    legacy: join52(xdgConfigHome, "letta", "settings.json")
   };
 }
 function getPermissionSourcePaths(workingDirectory) {
@@ -210084,13 +210670,13 @@ function getPermissionSourcePaths(workingDirectory) {
   return [
     legacyUserSettingsPath,
     userSettingsPath,
-    join51(workingDirectory, ".letta", "settings.json"),
-    join51(workingDirectory, ".letta", "settings.local.json")
+    join52(workingDirectory, ".letta", "settings.json"),
+    join52(workingDirectory, ".letta", "settings.local.json")
   ];
 }
 function getFileSignature(path20) {
   try {
-    const stat6 = statSync14(path20);
+    const stat6 = statSync15(path20);
     if (!stat6.isFile()) {
       return { exists: false };
     }
@@ -210098,7 +210684,7 @@ function getFileSignature(path20) {
       exists: true,
       mtimeMs: stat6.mtimeMs,
       size: stat6.size,
-      hash: createHash4("sha256").update(readFileSync32(path20)).digest("hex")
+      hash: createHash4("sha256").update(readFileSync33(path20)).digest("hex")
     };
   } catch {
     return { exists: false };
@@ -210279,10 +210865,10 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
       settingsPath = getUserSettingsPaths().canonical;
       break;
     case "project":
-      settingsPath = join51(normalizedWorkingDirectory, ".letta", "settings.json");
+      settingsPath = join52(normalizedWorkingDirectory, ".letta", "settings.json");
       break;
     case "local":
-      settingsPath = join51(normalizedWorkingDirectory, ".letta", "settings.local.json");
+      settingsPath = join52(normalizedWorkingDirectory, ".letta", "settings.local.json");
       break;
   }
   let settings3 = {};
@@ -210309,7 +210895,7 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
   }
 }
 async function ensureLocalSettingsIgnored(workingDirectory) {
-  const gitignorePath = join51(workingDirectory, ".gitignore");
+  const gitignorePath = join52(workingDirectory, ".gitignore");
   const pattern4 = ".letta/settings.local.json";
   try {
     let content = "";
@@ -211262,19 +211848,19 @@ var init_approval_result_normalization = __esm(() => {
 
 // src/agent/client-skills-watcher.ts
 import {
-  existsSync as existsSync39,
-  readdirSync as readdirSync13,
-  realpathSync as realpathSync6,
-  statSync as statSync15,
+  existsSync as existsSync40,
+  readdirSync as readdirSync14,
+  realpathSync as realpathSync7,
+  statSync as statSync16,
   watch as watch2
 } from "node:fs";
-import { dirname as dirname23, relative as relative6, resolve as resolve27, sep as sep6 } from "node:path";
+import { dirname as dirname23, relative as relative6, resolve as resolve27, sep as sep7 } from "node:path";
 function defaultWatchFunction(path20, options, listener) {
   return watch2(path20, options, listener);
 }
 function isDirectory(path20) {
   try {
-    return statSync15(path20).isDirectory();
+    return statSync16(path20).isDirectory();
   } catch {
     return false;
   }
@@ -211293,7 +211879,7 @@ function findNearestExistingDirectory(path20) {
 function collectSymlinkDirectoryTargets(path20, targets, visited2) {
   let realPath;
   try {
-    realPath = realpathSync6(path20);
+    realPath = realpathSync7(path20);
   } catch {
     return;
   }
@@ -211302,7 +211888,7 @@ function collectSymlinkDirectoryTargets(path20, targets, visited2) {
   }
   visited2.add(realPath);
   try {
-    const entries = readdirSync13(path20, {
+    const entries = readdirSync14(path20, {
       encoding: "utf8",
       withFileTypes: true
     });
@@ -211313,7 +211899,7 @@ function collectSymlinkDirectoryTargets(path20, targets, visited2) {
           continue;
         }
         try {
-          targets.add(realpathSync6(entryPath));
+          targets.add(realpathSync7(entryPath));
         } catch {
           continue;
         }
@@ -211362,13 +211948,13 @@ class ClientSkillsWatcher {
     const watchPaths = new Set;
     let recursive = false;
     let awaitedChild = null;
-    if (existsSync39(root2)) {
+    if (existsSync40(root2)) {
       recursive = true;
       watchPaths.add(root2);
       collectSymlinkDirectoryTargets(root2, watchPaths, new Set);
     } else {
       watchPaths.add(existingDirectory);
-      awaitedChild = relative6(existingDirectory, root2).split(sep6)[0] ?? null;
+      awaitedChild = relative6(existingDirectory, root2).split(sep7)[0] ?? null;
     }
     const watchers2 = [];
     const invalidate = () => {
@@ -211415,16 +212001,16 @@ __export(exports_skills2, {
   PROJECT_SKILLS_DIR: () => PROJECT_SKILLS_DIR,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR
 });
-import { existsSync as existsSync40 } from "node:fs";
+import { existsSync as existsSync41 } from "node:fs";
 import { readdir as readdir4, readFile as readFile12, realpath as realpath3, stat as stat6 } from "node:fs/promises";
-import { dirname as dirname24, join as join52 } from "node:path";
+import { dirname as dirname24, join as join53 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function getBundledSkillsPath() {
   const thisDir = dirname24(fileURLToPath6(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join52(thisDir, "../skills/builtin");
+    return join53(thisDir, "../skills/builtin");
   }
-  return join52(thisDir, "skills");
+  return join53(thisDir, "skills");
 }
 function compareSkills(a2, b3) {
   return a2.id.localeCompare(b3.id) || a2.source.localeCompare(b3.source) || a2.path.localeCompare(b3.path);
@@ -211471,7 +212057,7 @@ function isSkillAvailableForAgent(skill, agentId) {
   return true;
 }
 function getAgentSkillsDir(agentId) {
-  return join52(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
+  return join53(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
 }
 async function getBundledSkills() {
   const bundledPath = getBundledSkillsPath();
@@ -211480,7 +212066,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors4 = [];
-  if (!existsSync40(skillsPath)) {
+  if (!existsSync41(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -211494,7 +212080,7 @@ async function discoverSkillsFromDir(skillsPath, source) {
   }
   return { skills, errors: errors4 };
 }
-async function discoverSkills(projectSkillsPath = join52(process.cwd(), SKILLS_DIR), agentId, options) {
+async function discoverSkills(projectSkillsPath = join53(process.cwd(), SKILLS_DIR), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
@@ -211549,7 +212135,7 @@ async function findSkillFiles(currentPath, rootPath, skills, errors4, source, vi
   try {
     const entries = await readdir4(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join52(currentPath, entry.name);
+      const fullPath = join53(currentPath, entry.name);
       try {
         let isDirectory2 = entry.isDirectory();
         let isFile = entry.isFile();
@@ -211645,13 +212231,13 @@ var init_skills5 = __esm(() => {
     "managing-shared-memory",
     "working-across-computers"
   ]);
-  PROJECT_SKILLS_DIR = join52(".agents", "skills");
-  GLOBAL_SKILLS_DIR = join52(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  PROJECT_SKILLS_DIR = join53(".agents", "skills");
+  GLOBAL_SKILLS_DIR = join53(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/agent/shared-memory-skills.ts
-import { existsSync as existsSync41 } from "node:fs";
-import { dirname as dirname25, join as join53 } from "node:path";
+import { existsSync as existsSync42 } from "node:fs";
+import { dirname as dirname25, join as join54 } from "node:path";
 function getAttachedRepositoriesCache() {
   const global2 = globalThis;
   if (!global2[ATTACHED_REPOSITORIES_CACHE_KEY]) {
@@ -211726,7 +212312,7 @@ async function resolveSharedMemorySkillsContext(options) {
   for (const repository of repositories.sort((a2, b3) => a2.name.localeCompare(b3.name) || a2.id.localeCompare(b3.id))) {
     try {
       const repositoryName = validateAgentRepositoryName2(repository.name);
-      skillsDirs.push(join53(getRepositoryMountDir2(agentId, repositoryName), "skills"));
+      skillsDirs.push(join54(getRepositoryMountDir2(agentId, repositoryName), "skills"));
     } catch (error4) {
       errors4.push({
         path: `shared-memory:${repository.name}`,
@@ -211743,7 +212329,7 @@ async function discoverSharedMemorySkills(skillsDirs) {
     const repositoryMount = dirname25(dir);
     if (isCheckoutPending(repositoryMount))
       continue;
-    if (!existsSync41(repositoryMount)) {
+    if (!existsSync42(repositoryMount)) {
       errors4.push({
         path: repositoryMount,
         message: "Attached repository is not mounted locally"
@@ -211789,8 +212375,8 @@ __export(exports_client_skills, {
   buildClientSkillsUpdateReminder: () => buildClientSkillsUpdateReminder,
   buildClientSkillsPayload: () => buildClientSkillsPayload
 });
-import { existsSync as existsSync42 } from "node:fs";
-import { join as join54, resolve as resolve28 } from "node:path";
+import { existsSync as existsSync43 } from "node:fs";
+import { join as join55, resolve as resolve28 } from "node:path";
 function getCache2() {
   const global2 = globalThis;
   if (!global2[CLIENT_SKILLS_CACHE_KEY]) {
@@ -211917,12 +212503,12 @@ function buildClientSkillsUpdateReminder(previous, current) {
 function getMemorySkillsDirs(agentId) {
   const dirs = new Set;
   const scopedMemoryDir = resolveScopedMemoryDir({ agentId });
-  if (scopedMemoryDir && scopedMemoryDir.trim().length > 0 && existsSync42(scopedMemoryDir)) {
-    dirs.add(join54(scopedMemoryDir.trim(), "skills"));
+  if (scopedMemoryDir && scopedMemoryDir.trim().length > 0 && existsSync43(scopedMemoryDir)) {
+    dirs.add(join55(scopedMemoryDir.trim(), "skills"));
   } else {
     const fallbackMemoryDir = (process.env.LETTA_MEMORY_DIR || process.env.MEMORY_DIR || "").trim();
     if (fallbackMemoryDir) {
-      dirs.add(join54(fallbackMemoryDir, "skills"));
+      dirs.add(join55(fallbackMemoryDir, "skills"));
     }
   }
   return Array.from(dirs);
@@ -211964,8 +212550,8 @@ function toClientSkill(skill) {
 function resolveSkillDiscoveryContext(options) {
   const workingDirectory = options.workingDirectory ?? process.cwd();
   const configuredSkillsDirectory = options.skillsDirectory ?? getSkillsDirectory();
-  const legacySkillsDirectory = join54(workingDirectory, SKILLS_DIR);
-  const primaryProjectSkillsDirectory = join54(workingDirectory, PROJECT_SKILLS_DIR);
+  const legacySkillsDirectory = join55(workingDirectory, SKILLS_DIR);
+  const primaryProjectSkillsDirectory = join55(workingDirectory, PROJECT_SKILLS_DIR);
   const skillSources = options.skillSources ?? getSkillSources();
   return {
     workingDirectory,
@@ -212593,6 +213179,14 @@ function filterToolRegistryByClientAllowlist(registry3, clientToolAllowlist) {
   const allowSet = new Set(clientToolAllowlist);
   return new Map(Array.from(registry3.entries()).filter(([internalName]) => matchesClientToolAllowlistEntry(allowSet, getServerToolName(internalName), internalName)));
 }
+function filterMemoryToolByMemoryFormat(registry3, agentId) {
+  if (!registry3.has("Memory") || resolveMemoryToolDirectory(agentId)) {
+    return registry3;
+  }
+  const filtered = new Map(registry3);
+  filtered.delete("Memory");
+  return filtered;
+}
 function filterExternalToolsByRuntimeContext(externalTools, runtimeContext) {
   return new Map(Array.from(externalTools.entries()).filter(([, tool]) => {
     const matchesRuntime = !tool.runtime || (tool.runtime.agentId ?? null) === (runtimeContext.agentId ?? null) && tool.runtime.conversationId === runtimeContext.conversationId;
@@ -212809,7 +213403,7 @@ async function executeExternalTool(toolCallId, toolName2, input, executorOverrid
   }
 }
 function getClientToolsFromRegistry() {
-  return buildClientToolsFromSnapshot(toolRegistry, selectModelFacingExternalTools(filterExternalToolsByRuntimeContext(getExternalToolsRegistry(), {})), getAvailableModToolsRegistry());
+  return buildClientToolsFromSnapshot(filterMemoryToolByMemoryFormat(toolRegistry, undefined), selectModelFacingExternalTools(filterExternalToolsByRuntimeContext(getExternalToolsRegistry(), {})), getAvailableModToolsRegistry());
 }
 function buildClientToolsFromSnapshot(registry3, externalTools, modTools) {
   return serializeClientTools(registry3, externalTools, modTools, getServerToolName);
@@ -212817,7 +213411,7 @@ function buildClientToolsFromSnapshot(registry3, externalTools, modTools) {
 function capturePreparedToolExecutionContext(snapshot2, options) {
   const runtimeContext = buildExecutionRuntimeContextSnapshot(options);
   const clientToolAllowlist = options?.clientToolAllowlist ?? toolFilter.getEnabledTools() ?? undefined;
-  const toolRegistrySnapshot = applySubagentToolPolicy(filterToolRegistryByClientAllowlist(snapshot2.toolRegistry, clientToolAllowlist), readSubagentDepth(getRuntimeExecutionEnv(process.env, runtimeContext.executionSettings)));
+  const toolRegistrySnapshot = filterMemoryToolByMemoryFormat(applySubagentToolPolicy(filterToolRegistryByClientAllowlist(snapshot2.toolRegistry, clientToolAllowlist), readSubagentDepth(getRuntimeExecutionEnv(process.env, runtimeContext.executionSettings))), runtimeContext.agentId);
   const executionSnapshot = {
     toolRegistry: toolRegistrySnapshot,
     externalTools: selectModelFacingExternalTools(filterExternalToolsByClientAllowlist(filterExternalToolsByScopeIds(filterExternalToolsByRuntimeContext(snapshot2.externalTools, runtimeContext), options?.externalToolScopeIds), clientToolAllowlist), runtimeContext.connectionId),
@@ -213859,6 +214453,7 @@ var init_manager2 = __esm(async () => {
   init_subagent_tool_policy();
   init_task_tool_assets();
   init_tool_name_mapping();
+  init_memory5();
   init_toolset_catalog();
   await __promiseAll([
     init_approval_execution(),
@@ -217290,7 +217885,7 @@ var init_LS2 = __esm(() => {
 
 // src/tools/impl/ls.ts
 import { readdir as readdir7, stat as stat9 } from "node:fs/promises";
-import { isAbsolute as isAbsolute21, join as join55, resolve as resolve33 } from "node:path";
+import { isAbsolute as isAbsolute21, join as join56, resolve as resolve33 } from "node:path";
 async function ls(args) {
   validateRequiredParams(args, ["path"], "LS");
   validateParamTypes(args, LS_default2, "LS");
@@ -217301,7 +217896,7 @@ async function ls(args) {
     const items3 = await readdir7(dirPath);
     const filteredItems = items3.filter((item) => !ignore.some((pattern4) => import_picomatch.default.isMatch(item, pattern4)));
     const fileInfos = await Promise.all(filteredItems.map(async (item) => {
-      const fullPath = join55(dirPath, item);
+      const fullPath = join56(dirPath, item);
       try {
         const stats = await stat9(fullPath);
         return {
@@ -217523,7 +218118,7 @@ var init_monitor_event_stream = __esm(() => {
 });
 
 // src/tools/impl/monitor.ts
-import { appendFileSync as appendFileSync6, readFileSync as readFileSync33, writeFileSync as writeFileSync25 } from "node:fs";
+import { appendFileSync as appendFileSync6, readFileSync as readFileSync34, writeFileSync as writeFileSync25 } from "node:fs";
 import { WebSocket as WebSocket4 } from "ws";
 function buildMonitorResult(taskId, timeoutMs, persistent, outputFile) {
   const lifetime = persistent ? "persistent — runs until TaskStop or session end" : `timeout ${timeoutMs}ms`;
@@ -217579,7 +218174,7 @@ class MonitorOutputWriter {
 [output truncated at ${MONITOR_OUTPUT_FILE_BYTES} bytes]
 `, "utf8");
     try {
-      const content = validUtf8Prefix(Buffer.concat([readFileSync33(this.path), chunk2]), MONITOR_OUTPUT_FILE_BYTES - marker2.length);
+      const content = validUtf8Prefix(Buffer.concat([readFileSync34(this.path), chunk2]), MONITOR_OUTPUT_FILE_BYTES - marker2.length);
       const truncatedOutput = Buffer.concat([content, marker2]);
       writeFileSync25(this.path, truncatedOutput);
       this.bytesWritten = truncatedOutput.length;
@@ -219852,7 +220447,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.34.6"
+        version: "0.34.8"
       },
       capabilities: null
     });
@@ -221261,7 +221856,7 @@ var init_engine3 = __esm(() => {
 
 // src/tools/impl/native-session-capture.ts
 import { createHash as createHash5, randomUUID as randomUUID32 } from "node:crypto";
-import { readdirSync as readdirSync14, rmSync as rmSync14 } from "node:fs";
+import { readdirSync as readdirSync15, rmSync as rmSync14 } from "node:fs";
 import {
   mkdtemp as mkdtemp4,
   open as open4,
@@ -221270,7 +221865,7 @@ import {
   stat as stat10
 } from "node:fs/promises";
 import { homedir as homedir28, tmpdir as tmpdir12 } from "node:os";
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 async function hashNativeSessionPrefix(input, size2) {
   const hash3 = createHash5("sha256");
   const buffer = Buffer.allocUnsafe(NATIVE_SESSION_CAPTURE_CHUNK_BYTES);
@@ -221332,7 +221927,7 @@ function scavengeStaleSpoolDirectories() {
   staleSpoolsScavenged = true;
   let entries;
   try {
-    entries = readdirSync14(tmpdir12(), { withFileTypes: true });
+    entries = readdirSync15(tmpdir12(), { withFileTypes: true });
   } catch {
     return;
   }
@@ -221355,7 +221950,7 @@ function scavengeStaleSpoolDirectories() {
       }
     }
     if (!ownerIsAlive)
-      cleanupSpoolDirectorySync(join56(tmpdir12(), entry.name));
+      cleanupSpoolDirectorySync(join57(tmpdir12(), entry.name));
   }
 }
 function key2(source, sessionId) {
@@ -221508,9 +222103,9 @@ async function findNativeSessionPath(source, sessionId, env6 = process.env) {
     return;
   const home = env6.HOME || homedir28();
   if (source === "claude_code") {
-    const projects = join56(env6.CLAUDE_CONFIG_DIR || join56(home, ".claude"), "projects");
+    const projects = join57(env6.CLAUDE_CONFIG_DIR || join57(home, ".claude"), "projects");
     for (const project of await entries(projects, true)) {
-      const path29 = join56(projects, project, `${sessionId}.jsonl`);
+      const path29 = join57(projects, project, `${sessionId}.jsonl`);
       try {
         if ((await stat10(path29)).isFile())
           return path29;
@@ -221521,14 +222116,14 @@ async function findNativeSessionPath(source, sessionId, env6 = process.env) {
     }
     return;
   }
-  const root2 = join56(env6.CODEX_HOME || join56(home, ".codex"), "sessions");
+  const root2 = join57(env6.CODEX_HOME || join57(home, ".codex"), "sessions");
   for (const year of (await entries(root2, true)).filter((name) => /^\d{4}$/.test(name)))
-    for (const month of (await entries(join56(root2, year), true)).filter((name) => /^\d{2}$/.test(name)))
-      for (const day of (await entries(join56(root2, year, month), true)).filter((name) => /^\d{2}$/.test(name))) {
-        const directory = join56(root2, year, month, day);
+    for (const month of (await entries(join57(root2, year), true)).filter((name) => /^\d{2}$/.test(name)))
+      for (const day of (await entries(join57(root2, year, month), true)).filter((name) => /^\d{2}$/.test(name))) {
+        const directory = join57(root2, year, month, day);
         for (const file of await entries(directory, false))
           if (file.startsWith("rollout-") && file.endsWith(`-${sessionId}.jsonl`))
-            return join56(directory, file);
+            return join57(directory, file);
       }
   return;
 }
@@ -221545,9 +222140,9 @@ async function seal(state2, source, sessionId, scope, env6, requestOptions) {
       throw new Error("Native session file disappeared before EOF capture");
     throw error4;
   }
-  const directory = await mkdtemp4(join56(tmpdir12(), `letta-native-session-${process.pid}-${captureProcessInstanceId}-`));
+  const directory = await mkdtemp4(join57(tmpdir12(), `letta-native-session-${process.pid}-${captureProcessInstanceId}-`));
   spoolDirectories.add(directory);
-  const spoolPath = join56(directory, "segment");
+  const spoolPath = join57(directory, "segment");
   let output;
   let retained = false;
   try {
@@ -221664,7 +222259,7 @@ async function drain(state2, source, sessionId) {
       await spool.close();
     }
     state2.segments.shift();
-    const directory = join56(segment.path, "..");
+    const directory = join57(segment.path, "..");
     await cleanupSpoolDirectory(directory);
   }
 }
@@ -221696,7 +222291,7 @@ async function discardRejectedSegment(state2) {
   const segment = state2.segments.shift();
   if (!segment)
     return;
-  const directory = join56(segment.path, "..");
+  const directory = join57(segment.path, "..");
   await cleanupSpoolDirectory(directory);
   state2.ackedOffset = segment.end;
   state2.retryDelayMs = INITIAL_DRAIN_RETRY_MS;
@@ -222702,20 +223297,20 @@ var init_recall_subagent_local = () => {};
 
 // src/utils/transcript-paths.ts
 import { homedir as homedir29 } from "node:os";
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 function getTranscriptRoot() {
   const envRoot = process.env[TRANSCRIPT_ROOT_ENV]?.trim();
   if (envRoot) {
     return envRoot;
   }
-  return join57(homedir29(), ".letta", "transcripts");
+  return join58(homedir29(), ".letta", "transcripts");
 }
 var TRANSCRIPT_ROOT_ENV = "LETTA_TRANSCRIPT_ROOT";
 var init_transcript_paths = () => {};
 
 // src/agent/subagents/sandbox.ts
 import { mkdirSync as mkdirSync30 } from "node:fs";
-import { join as join58 } from "node:path";
+import { join as join59 } from "node:path";
 function wrapSubagentLauncher(input) {
   const env6 = input.env ?? process.env;
   if (!isFsSandboxEnabled(env6))
@@ -222758,7 +223353,7 @@ function wrapSubagentLauncher(input) {
   if (!wrapped || wrapped.length === 0)
     return null;
   const [command, ...args] = wrapped;
-  const scratchRoot = join58(getLettaHomeRoot(), "tmp");
+  const scratchRoot = join59(getLettaHomeRoot(), "tmp");
   mkdirSync30(scratchRoot, { recursive: true });
   return {
     command,
@@ -224065,7 +224660,7 @@ var MEMORY_WORKER_SESSION_ENV = "LETTA_MEMORY_WORKER_SESSION";
 
 // src/agent/subagents/subagent-launcher.ts
 import { homedir as homedir30 } from "node:os";
-import { join as join59 } from "node:path";
+import { join as join60 } from "node:path";
 function resolveSubagentWorkingDirectory(env6 = process.env, fallbackCwd = getCurrentWorkingDirectory(), options = {}) {
   if (options.subagentType === "reflection" && options.launchProfile === "memory-subagent" && options.memoryScope) {
     return env6.USER_CWD || fallbackCwd;
@@ -224123,9 +224718,9 @@ function resolveMemorySubagentScratchpad(parentProcessEnv, subagentId) {
     return configuredScratchpad;
   }
   const configuredTranscriptRoot = parentProcessEnv[TRANSCRIPT_ROOT_ENV];
-  const transcriptRoot = configuredTranscriptRoot?.trim() || join59(parentProcessEnv.HOME?.trim() || homedir30(), ".letta", "transcripts");
+  const transcriptRoot = configuredTranscriptRoot?.trim() || join60(parentProcessEnv.HOME?.trim() || homedir30(), ".letta", "transcripts");
   const scope = subagentId ? encodeURIComponent(subagentId) : crypto.randomUUID();
-  return join59(transcriptRoot, "background", scope);
+  return join60(transcriptRoot, "background", scope);
 }
 function composeSubagentChildEnv(options) {
   const {
@@ -224695,7 +225290,7 @@ var init_manager4 = __esm(async () => {
 import { execFile as execFile16 } from "node:child_process";
 import { randomUUID as randomUUID36 } from "node:crypto";
 import { readFile as readFile15, rm as rm9, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 async function readOptional(path29) {
   try {
@@ -224716,7 +225311,7 @@ async function describeMemoryConflict(memoryDir, gitDir) {
     ]);
     head4 = stdout.trim();
   } catch {}
-  const heads = await Promise.all(OPERATION_HEADS.map((name) => readOptional(join60(gitDir, name))));
+  const heads = await Promise.all(OPERATION_HEADS.map((name) => readOptional(join61(gitDir, name))));
   return [head4, ...heads].join(`
 `);
 }
@@ -224736,7 +225331,7 @@ ${stdout.trim()}`;
   }
 }
 async function attemptPath(memoryDir) {
-  return join60(await getMemoryGitDir(memoryDir), ATTEMPT_FILE);
+  return join61(await getMemoryGitDir(memoryDir), ATTEMPT_FILE);
 }
 async function readAttempt(path29) {
   try {
@@ -224770,7 +225365,7 @@ async function claimMemoryConflictRepair(memoryDir, kind = "conflict") {
   let signature;
   try {
     const gitDir = await getMemoryGitDir(memoryDir);
-    path29 = join60(gitDir, ATTEMPT_FILE);
+    path29 = join61(gitDir, ATTEMPT_FILE);
     signature = kind === "invalid" ? await describeInvalidMemoryHistory(memoryDir) : await describeMemoryConflict(memoryDir, gitDir);
   } catch {
     return { status: "claimed", token: token2 };
@@ -224832,7 +225427,7 @@ var init_memory_conflict_repair = __esm(() => {
 // src/agent/subagents/memory-handoff.ts
 import { randomUUID as randomUUID37 } from "node:crypto";
 import { mkdir as mkdir11, rm as rm10, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 async function withMemoryHandoff(params, run) {
   const handoff = await prepareMemoryHandoff(params);
   try {
@@ -224867,9 +225462,9 @@ async function prepareMemoryHandoff(params) {
         break;
       after2 = cursor;
     }
-    const directory = join61(getTranscriptRoot(), params.agentId, "memory-handoffs");
+    const directory = join62(getTranscriptRoot(), params.agentId, "memory-handoffs");
     await mkdir11(directory, { recursive: true, mode: 448 });
-    transcriptPath = join61(directory, `${randomUUID37()}.json`);
+    transcriptPath = join62(directory, `${randomUUID37()}.json`);
     await writeFile14(transcriptPath, JSON.stringify(messages, null, 2), {
       mode: 292,
       flag: "wx"
@@ -224932,9 +225527,9 @@ var init_memory_operation = __esm(() => {
 // src/agent/memory-worktree.ts
 import { execFile as execFileCb4 } from "node:child_process";
 import { randomUUID as randomUUID38 } from "node:crypto";
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import { mkdir as mkdir12 } from "node:fs/promises";
-import { dirname as dirname26, isAbsolute as isAbsolute23, join as join62, resolve as resolve36 } from "node:path";
+import { dirname as dirname26, isAbsolute as isAbsolute23, join as join63, resolve as resolve36 } from "node:path";
 import { promisify as promisify17 } from "node:util";
 async function runGit4(cwd2, args) {
   try {
@@ -224994,9 +225589,9 @@ async function buildReflectionMergeMessage(parentMemoryDir, branchName) {
 async function createReflectionMemoryWorktree(options) {
   const parentMemoryDir = resolve36(options.parentMemoryDir);
   const id2 = buildReflectionWorktreeId(options.now);
-  const worktreeBaseDir = join62(dirname26(parentMemoryDir), "memory-worktrees");
+  const worktreeBaseDir = join63(dirname26(parentMemoryDir), "memory-worktrees");
   const label = options.label ?? "reflection";
-  const worktreeDir = join62(worktreeBaseDir, `${label}-${id2}`);
+  const worktreeDir = join63(worktreeBaseDir, `${label}-${id2}`);
   const branchName = `letta/${label}/${id2}`;
   await mkdir12(worktreeBaseDir, { recursive: true });
   const { stdout: baseHeadOut } = await runGit4(parentMemoryDir, [
@@ -225124,7 +225719,7 @@ async function inspectReflectionMemoryWorktree(worktree) {
   };
 }
 async function cleanupWorktreeAndBranch(parentMemoryDir, worktreeDir, branchName, options = {}) {
-  const removedWorktree = existsSync43(worktreeDir);
+  const removedWorktree = existsSync44(worktreeDir);
   if (removedWorktree) {
     await runGit4(parentMemoryDir, [
       "worktree",
@@ -225140,7 +225735,7 @@ async function cleanupWorktreeAndBranch(parentMemoryDir, worktreeDir, branchName
   ]);
 }
 async function finalizeReflectionMemoryWorktreeUnlocked(worktree, options) {
-  if (!existsSync43(worktree.worktreeDir) && options.knownNoChanges) {
+  if (!existsSync44(worktree.worktreeDir) && options.knownNoChanges) {
     const branchHead = (await tryRunGit(worktree.parentMemoryDir, [
       "rev-parse",
       "--verify",
@@ -225327,7 +225922,7 @@ async function integrateMemoryWorkerWorktree(worktree, options = {}) {
     await cleanup(true);
     return { status: "no_changes" };
   }
-  if (existsSync43(worktree.worktreeDir)) {
+  if (existsSync44(worktree.worktreeDir)) {
     await runGit4(worktree.parentMemoryDir, [
       "worktree",
       "remove",
@@ -226628,9 +227223,9 @@ __export(exports_skill, {
   loadRenderedSkillContent: () => loadRenderedSkillContent,
   getResolvedSkillsDir: () => getResolvedSkillsDir
 });
-import { existsSync as existsSync44, readdirSync as readdirSync15 } from "node:fs";
+import { existsSync as existsSync45, readdirSync as readdirSync16 } from "node:fs";
 import { readFile as readFile16 } from "node:fs/promises";
-import { dirname as dirname27, join as join63 } from "node:path";
+import { dirname as dirname27, join as join64 } from "node:path";
 async function readSkillFromRoot(skillsRoot, skillId) {
   const discovery = await discoverSkills(skillsRoot, undefined, {
     sources: ["project"],
@@ -226650,12 +227245,12 @@ async function readSkillFromRoot(skillsRoot, skillId) {
 function getMemorySkillsDirs2(agentId) {
   const dirs = new Set;
   const scopedMemoryDir = resolveScopedMemoryDir({ agentId });
-  if (scopedMemoryDir && scopedMemoryDir.trim().length > 0 && existsSync44(scopedMemoryDir)) {
-    dirs.add(join63(scopedMemoryDir.trim(), "skills"));
+  if (scopedMemoryDir && scopedMemoryDir.trim().length > 0 && existsSync45(scopedMemoryDir)) {
+    dirs.add(join64(scopedMemoryDir.trim(), "skills"));
   } else {
     const fallbackMemoryDir = (process.env.LETTA_MEMORY_DIR || process.env.MEMORY_DIR || "").trim();
     if (fallbackMemoryDir) {
-      dirs.add(join63(fallbackMemoryDir, "skills"));
+      dirs.add(join64(fallbackMemoryDir, "skills"));
     }
   }
   return Array.from(dirs);
@@ -226667,7 +227262,7 @@ function listSkillResources(skillMdPath) {
   function walk3(directory, relativeDirectory) {
     let entries2;
     try {
-      entries2 = readdirSync15(directory, { withFileTypes: true });
+      entries2 = readdirSync16(directory, { withFileTypes: true });
     } catch {
       return;
     }
@@ -226681,7 +227276,7 @@ function listSkillResources(skillMdPath) {
         return;
       }
       if (entry.isDirectory()) {
-        walk3(join63(directory, entry.name), relativePath);
+        walk3(join64(directory, entry.name), relativePath);
         if (truncated) {
           return;
         }
@@ -226695,7 +227290,7 @@ function listSkillResources(skillMdPath) {
 }
 async function readSkillContent(skillId, skillsDir, agentId, options = {}) {
   const projectSkillsDirs = new Set([
-    join63(getCurrentWorkingDirectory(), PROJECT_SKILLS_DIR),
+    join64(getCurrentWorkingDirectory(), PROJECT_SKILLS_DIR),
     skillsDir
   ]);
   for (const projectSkillsDir of projectSkillsDirs) {
@@ -226743,8 +227338,8 @@ async function readSkillContent(skillId, skillsDir, agentId, options = {}) {
     } catch {}
   }
   try {
-    const bundledSkillsDir = join63(process.cwd(), "skills", "skills");
-    const bundledSkillPath = join63(bundledSkillsDir, skillId, "SKILL.md");
+    const bundledSkillsDir = join64(process.cwd(), "skills", "skills");
+    const bundledSkillPath = join64(bundledSkillsDir, skillId, "SKILL.md");
     const content = await readFile16(bundledSkillPath, "utf-8");
     return { content, path: bundledSkillPath };
   } catch {
@@ -226756,7 +227351,7 @@ async function getResolvedSkillsDir() {
   if (skillsDir) {
     return skillsDir;
   }
-  return join63(getCurrentWorkingDirectory(), SKILLS_DIR);
+  return join64(getCurrentWorkingDirectory(), SKILLS_DIR);
 }
 function getResolvedAgentId(args) {
   if (args.parentScope?.agentId) {
@@ -226776,7 +227371,7 @@ function renderSkillContent(skillName, skillContent, skillPath, options = {}) {
   const skillDir = dirname27(skillPath);
   const withSkillDir = skillContent.replace(/<SKILL_DIR>/g, skillDir).replace(/\$\{CLAUDE_SKILL_DIR\}/g, skillDir);
   const resources = listSkillResources(skillPath);
-  const resourceLines = resources.paths.map((resourcePath) => `  <file>${escapeXmlText2(resourcePath)}</file>`);
+  const resourceLines = resources.paths.map((resourcePath) => `  <file>${escapeXmlText3(resourcePath)}</file>`);
   if (resources.truncated) {
     resourceLines.push("  <truncated>true</truncated>");
   }
@@ -226796,11 +227391,11 @@ async function loadRenderedSkillContent(skillName, options = {}) {
   const { content: skillContent, path: skillPath } = await readSkillContent(skillName, skillsDir, options.agentId, options);
   return renderSkillContent(skillName, skillContent, skillPath, options);
 }
-function escapeXmlText2(value) {
+function escapeXmlText3(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function escapeXmlAttribute3(value) {
-  return escapeXmlText2(value).replace(/"/g, "&quot;");
+  return escapeXmlText3(value).replace(/"/g, "&quot;");
 }
 function wrapSkillContent(skillName, content) {
   return `<skill_content name="${escapeXmlAttribute3(skillName)}">
@@ -228740,9 +229335,9 @@ function formatWorkflowSummary(stats) {
 // src/tools/workflow/journal.ts
 import { appendFileSync as appendFileSync7, mkdirSync as mkdirSync31, writeFileSync as writeFileSync26 } from "node:fs";
 import { homedir as homedir32 } from "node:os";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 function defaultExecutionsDir() {
-  return join64(homedir32(), ".letta", "workflows", "executions");
+  return join65(homedir32(), ".letta", "workflows", "executions");
 }
 function newExecutionId() {
   const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -228753,17 +229348,17 @@ function newExecutionId() {
   return `wf-${suffix}`;
 }
 function createExecutionDir(executionsDir, executionId, script4, args) {
-  const executionDir = join64(executionsDir, executionId);
+  const executionDir = join65(executionsDir, executionId);
   mkdirSync31(executionDir, { recursive: true, mode: DIR_MODE });
-  const scriptPath = join64(executionDir, "script.js");
+  const scriptPath = join65(executionDir, "script.js");
   writeFileSync26(scriptPath, script4, { mode: FILE_MODE });
   if (args !== undefined) {
-    writeFileSync26(join64(executionDir, "args.json"), JSON.stringify(args, null, 2), { mode: FILE_MODE });
+    writeFileSync26(join65(executionDir, "args.json"), JSON.stringify(args, null, 2), { mode: FILE_MODE });
   }
   return {
     executionDir,
     scriptPath,
-    journalPath: join64(executionDir, "journal.jsonl")
+    journalPath: join65(executionDir, "journal.jsonl")
   };
 }
 function appendJournalEntry(journalPath, entry) {
@@ -228873,9 +229468,9 @@ var init_meta3 = __esm(() => {
 });
 
 // src/tools/workflow/sdk-loader.ts
-import { existsSync as existsSync45, readFileSync as readFileSync34 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync35 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { dirname as dirname28, join as join65 } from "node:path";
+import { dirname as dirname28, join as join66 } from "node:path";
 import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL3 } from "node:url";
 function supportsPublishedResume(version2) {
   if (!version2 || !MIN_RESUME_SDK_VERSION)
@@ -228897,14 +229492,14 @@ function preferRunningCliForSubagents() {
   if (process.env.LETTA_CLI_PATH)
     return;
   const entry = process.argv[1];
-  if (entry && /(^|[\\/])letta\.js$/.test(entry) && existsSync45(entry)) {
+  if (entry && /(^|[\\/])letta\.js$/.test(entry) && existsSync46(entry)) {
     process.env.LETTA_CLI_PATH = entry;
   }
 }
 function packageVersion(entry) {
   for (let dir = dirname28(entry);; dir = dirname28(dir)) {
     try {
-      const manifest = JSON.parse(readFileSync34(join65(dir, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync35(join66(dir, "package.json"), "utf8"));
       if (manifest.name === SDK_PACKAGE)
         return manifest.version;
     } catch {}
@@ -228914,10 +229509,10 @@ function packageVersion(entry) {
 }
 function packageEntry(packageDir) {
   try {
-    const manifest = JSON.parse(readFileSync34(join65(packageDir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync35(join66(packageDir, "package.json"), "utf8"));
     const root2 = manifest.exports?.["."];
     const entry = typeof root2 === "string" ? root2 : root2?.import ?? root2?.default ?? manifest.main;
-    return entry ? join65(packageDir, entry) : null;
+    return entry ? join66(packageDir, entry) : null;
   } catch {
     return null;
   }
@@ -228927,8 +229522,8 @@ function probeInstalledSdkDirs(startDirs) {
   for (const start of startDirs) {
     let dir = start;
     while (true) {
-      const candidate = join65(dir, "node_modules", ...SDK_PACKAGE.split("/"));
-      if (existsSync45(join65(candidate, "package.json")) && !found.includes(candidate)) {
+      const candidate = join66(dir, "node_modules", ...SDK_PACKAGE.split("/"));
+      if (existsSync46(join66(candidate, "package.json")) && !found.includes(candidate)) {
         found.push(candidate);
       }
       const parent = dirname28(dir);
@@ -228946,7 +229541,7 @@ async function loadAgentSdk() {
   const specifiers = [];
   if (envPath) {
     try {
-      const require2 = createRequire6(join65(envPath, "noop.js"));
+      const require2 = createRequire6(join66(envPath, "noop.js"));
       specifiers.push(pathToFileURL3(require2.resolve(envPath)).href);
     } catch {
       specifiers.push(pathToFileURL3(envPath).href);
@@ -228957,7 +229552,7 @@ async function loadAgentSdk() {
     specifiers.push(pathToFileURL3(require2.resolve(SDK_PACKAGE)).href);
   } catch {}
   try {
-    const require2 = createRequire6(join65(process.cwd(), "package.json"));
+    const require2 = createRequire6(join66(process.cwd(), "package.json"));
     specifiers.push(pathToFileURL3(require2.resolve(SDK_PACKAGE)).href);
   } catch {
     specifiers.push(SDK_PACKAGE);
@@ -246747,12 +247342,12 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.34.6"
+    version: "0.34.8"
   };
 });
 
 // src/mcp-oauth-callback.ts
-import { createServer as createServer3 } from "node:http";
+import { createServer as createServer4 } from "node:http";
 async function startOAuthCallbackServer2(preferredPort) {
   try {
     return await startOAuthCallbackServerOnPort(preferredPort ?? 0);
@@ -246791,7 +247386,7 @@ async function startOAuthCallbackServerOnPort(port) {
   codePromise.catch(() => {
     return;
   });
-  server2 = createServer3((request, response) => {
+  server2 = createServer4((request, response) => {
     if (request.method !== "GET" || !request.url?.startsWith("/") || request.url.startsWith("//") || request.url.includes("\\")) {
       response.writeHead(400, { "Content-Type": "text/plain" });
       response.end("Invalid request target");
@@ -246828,7 +247423,7 @@ async function startOAuthCallbackServerOnPort(port) {
       response.writeHead(400, { "Content-Type": "text/html" });
       reject2?.(new Error(`MCP OAuth authorization failed: ${error5}`));
       response.end(callbackPage("Authorization failed", error5), () => {
-        closeServer(true);
+        closeServer2(true);
       });
       return;
     }
@@ -246840,7 +247435,7 @@ async function startOAuthCallbackServerOnPort(port) {
     response.writeHead(200, { "Content-Type": "text/html" });
     settle3?.(code2);
     response.end(callbackPage("Authorization complete", "You can close this tab and return to Letta Code."), () => {
-      closeServer(true);
+      closeServer2(true);
     });
   });
   server2.on("clientError", (_error, socket) => {
@@ -246853,7 +247448,7 @@ Content-Length: 0\r
 `);
   });
   let serverClosing = false;
-  const closeServer = (force = false) => {
+  const closeServer2 = (force = false) => {
     if (serverClosing)
       return;
     serverClosing = true;
@@ -246873,7 +247468,7 @@ Content-Length: 0\r
   }
   const timeout = setTimeout(() => {
     reject2?.(new Error("Timed out waiting for MCP OAuth authorization"));
-    closeServer(true);
+    closeServer2(true);
   }, CALLBACK_TIMEOUT_MS);
   timeout.unref();
   return {
@@ -246884,7 +247479,7 @@ Content-Length: 0\r
       clearTimeout(timeout);
       if (!completed)
         reject2?.(new Error("MCP OAuth flow was cancelled"));
-      closeServer(true);
+      closeServer2(true);
     }
   };
 }
@@ -248538,8 +249133,8 @@ var init_mcp = __esm(() => {
 });
 
 // src/tools/impl/workflow.ts
-import { readFileSync as readFileSync35 } from "node:fs";
-import { join as join66, resolve as resolve38 } from "node:path";
+import { readFileSync as readFileSync36 } from "node:fs";
+import { join as join67, resolve as resolve38 } from "node:path";
 function isOwningAgentId(value) {
   return value?.startsWith("agent-") === true && !value.startsWith("agent-free:");
 }
@@ -248696,7 +249291,7 @@ function formatCompletionResult(run, executionDir) {
   return [
     payload,
     "",
-    `Per-call results: ${join66(executionDir, "journal.jsonl")} — one line per completed agent call with its full return value, plus one per decide() API attempt (retries included) with its model, cost, calibration, and tokens.`,
+    `Per-call results: ${join67(executionDir, "journal.jsonl")} — one line per completed agent call with its full return value, plus one per decide() API attempt (retries included) with its model, cost, calibration, and tokens.`,
     "If the result above is empty or unexpected, read that file BEFORE diagnosing — do not assume agents returned non-empty results."
   ].join(`
 `);
@@ -248705,7 +249300,7 @@ async function workflow(args) {
   let script4 = typeof args.script === "string" ? args.script : undefined;
   if (typeof args.scriptPath === "string" && args.scriptPath) {
     try {
-      script4 = readFileSync35(resolve38(getCurrentWorkingDirectory(), args.scriptPath), "utf8");
+      script4 = readFileSync36(resolve38(getCurrentWorkingDirectory(), args.scriptPath), "utf8");
     } catch (error5) {
       return {
         toolReturn: `Cannot read scriptPath ${args.scriptPath}: ${String(error5)}`,
@@ -249357,6 +249952,23 @@ var init_Grep2 = __esm(() => {
   };
 });
 
+// src/tools/schemas/Memory.json
+var Memory_default2;
+var init_Memory2 = __esm(() => {
+  Memory_default2 = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: 'Memory directory or file relative to the memory directory, e.g. "projects", "projects/code", or "projects/example.md".'
+      }
+    },
+    required: ["path"],
+    additionalProperties: false,
+    $schema: "https://json-schema.org/draft/2020-12/schema"
+  };
+});
+
 // src/tools/schemas/Monitor.json
 var Monitor_default2;
 var init_Monitor2 = __esm(() => {
@@ -249995,6 +250607,7 @@ var init_tool_definitions = __esm(async () => {
   init_Glob();
   init_Grep();
   init_LS();
+  init_Memory();
   init_Monitor();
   init_Read();
   init_ReadArtifactFile();
@@ -250023,6 +250636,7 @@ var init_tool_definitions = __esm(async () => {
   init_glob();
   init_grep();
   init_ls();
+  init_memory5();
   init_skill();
   init_task_create();
   init_task_get();
@@ -250041,6 +250655,7 @@ var init_tool_definitions = __esm(async () => {
   init_Glob2();
   init_Grep2();
   init_LS2();
+  init_Memory2();
   init_Monitor2();
   init_Read2();
   init_ReadArtifactFile2();
@@ -250173,6 +250788,11 @@ ${WINDOWS_UNIFIED_EXEC_GUIDANCE}`;
       description: SetWorkingDirectory_default.trim(),
       impl: set_working_directory
     }),
+    Memory: defineTool({
+      schema: Memory_default2,
+      description: Memory_default.trim(),
+      impl: memory2
+    }),
     Skill: defineTool({
       schema: Skill_default2,
       description: Skill_default.trim(),
@@ -250400,14 +251020,14 @@ var init_interrupted_turn_schema = __esm(async () => {
 // src/websocket/listener/interrupted-turn-storage.ts
 import { createHash as createHash7 } from "node:crypto";
 import {
-  closeSync as closeSync5,
+  closeSync as closeSync6,
   fsyncSync as fsyncSync3,
-  openSync as openSync5,
+  openSync as openSync6,
   renameSync as renameSync8,
   writeFileSync as writeFileSync27
 } from "node:fs";
 import { homedir as homedir33 } from "node:os";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 function writeInterruptedTurnRecordFile(temporary, destination, directory, record6, syncDirectory) {
   writeFileSync27(temporary, JSON.stringify(record6), {
     mode: 384,
@@ -250419,11 +251039,11 @@ function writeInterruptedTurnRecordFile(temporary, destination, directory, recor
 function fsyncInterruptedTurnDirectory(directory, platform9 = process.platform) {
   if (platform9 === "win32")
     return;
-  const fd = openSync5(directory, "r");
+  const fd = openSync6(directory, "r");
   try {
     fsyncSync3(fd);
   } finally {
-    closeSync5(fd);
+    closeSync6(fd);
   }
 }
 function defaultInterruptedTurnDirectory() {
@@ -250433,7 +251053,7 @@ function defaultInterruptedTurnDirectory() {
   } catch {
     serverUrl = process.env.LETTA_BASE_URL ?? "uninitialized";
   }
-  return join67(homedir33(), ".letta", "listener-state", createHash7("sha256").update(serverUrl).digest("hex").slice(0, 24));
+  return join68(homedir33(), ".letta", "listener-state", createHash7("sha256").update(serverUrl).digest("hex").slice(0, 24));
 }
 var init_interrupted_turn_storage = __esm(() => {
   init_server_url();
@@ -250502,23 +251122,23 @@ function createRecoveryAuthorityGuard(dependencies4) {
 // src/websocket/listener/recovery-lineage-sidecar.ts
 import { createHash as createHash8, randomUUID as randomUUID40 } from "node:crypto";
 import {
-  existsSync as existsSync46,
+  existsSync as existsSync47,
   mkdirSync as mkdirSync32,
-  readdirSync as readdirSync16,
-  readFileSync as readFileSync36,
+  readdirSync as readdirSync17,
+  readFileSync as readFileSync37,
   renameSync as renameSync9,
   rmSync as rmSync17,
-  statSync as statSync16,
+  statSync as statSync17,
   writeFileSync as writeFileSync28
 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 function createRecoveryLineageSidecarAccess(params) {
   const canonicalSidecarName = /\.json\.recovery-[0-9a-f]{24}$/;
   const temporarySidecarName = /^(.+\.json)\.recovery-[0-9a-f]{24}\.(\d+)\.([0-9a-f-]{36})\.[0-9a-f-]{36}\.tmp$/;
   const legacyTemporarySidecarName = /^(.+\.json)\.recovery-[0-9a-f]{24}\.(\d+)\.[0-9a-f-]{36}\.tmp$/;
   const staleTemporaryAgeMs = 60000;
   const maximumTemporaryAgeMs = 24 * 60 * 60 * 1000;
-  const path32 = (agentId, conversationId, lineageId) => join68(params.directory, `${encodeURIComponent(agentId)}_${encodeURIComponent(conversationId)}.json.recovery-${createHash8("sha256").update(lineageId).digest("hex").slice(0, 24)}`);
+  const path32 = (agentId, conversationId, lineageId) => join69(params.directory, `${encodeURIComponent(agentId)}_${encodeURIComponent(conversationId)}.json.recovery-${createHash8("sha256").update(lineageId).digest("hex").slice(0, 24)}`);
   const isSidecar = (value) => {
     if (!value || typeof value !== "object")
       return false;
@@ -250527,7 +251147,7 @@ function createRecoveryLineageSidecarAccess(params) {
   };
   const read2 = (agentId, conversationId, lineageId) => {
     try {
-      const parsed = JSON.parse(readFileSync36(path32(agentId, conversationId, lineageId), "utf8"));
+      const parsed = JSON.parse(readFileSync37(path32(agentId, conversationId, lineageId), "utf8"));
       if (!isSidecar(parsed) || parsed.agentId !== agentId || parsed.conversationId !== conversationId || parsed.lineageId !== lineageId) {
         throw new Error("Invalid recovery-lineage sidecar");
       }
@@ -250797,15 +251417,15 @@ function createRecoveryLineageSidecarAccess(params) {
     const removeMalformedOrphan = (file) => {
       const separator = file.indexOf(".recovery-");
       const mainFile = separator >= 0 ? file.slice(0, separator) : "";
-      if (!mainFile || existsSync46(join68(params.directory, mainFile)))
+      if (!mainFile || existsSync47(join69(params.directory, mainFile)))
         return;
       try {
-        rmSync17(join68(params.directory, file), { force: true });
+        rmSync17(join69(params.directory, file), { force: true });
         params.syncDirectory(params.directory);
       } catch {}
     };
     try {
-      const files = readdirSync16(params.directory);
+      const files = readdirSync17(params.directory);
       for (const file of files) {
         const temporaryMatch = file.match(temporarySidecarName) ?? file.match(legacyTemporarySidecarName);
         if (!temporaryMatch)
@@ -250827,13 +251447,13 @@ function createRecoveryLineageSidecarAccess(params) {
               ownerIsAlive = error5.code !== "ESRCH";
             }
           }
-          const ageMs = Date.now() - statSync16(join68(params.directory, file)).mtimeMs;
+          const ageMs = Date.now() - statSync17(join69(params.directory, file)).mtimeMs;
           if (!ownerIsCurrentWriter && (!ownerIsAlive && ageMs >= staleTemporaryAgeMs || ageMs >= maximumTemporaryAgeMs)) {
-            const release = acquireDurableFileLock(join68(params.directory, mainFile), { waitMs: params.lockWaitMs });
+            const release = acquireDurableFileLock(join69(params.directory, mainFile), { waitMs: params.lockWaitMs });
             try {
-              const currentAgeMs = Date.now() - statSync16(join68(params.directory, file)).mtimeMs;
+              const currentAgeMs = Date.now() - statSync17(join69(params.directory, file)).mtimeMs;
               if (!ownerIsCurrentWriter && (!ownerIsAlive && currentAgeMs >= staleTemporaryAgeMs || currentAgeMs >= maximumTemporaryAgeMs)) {
-                rmSync17(join68(params.directory, file), { force: true });
+                rmSync17(join69(params.directory, file), { force: true });
                 params.syncDirectory(params.directory);
               }
             } finally {
@@ -250844,8 +251464,8 @@ function createRecoveryLineageSidecarAccess(params) {
       }
       return files.filter((file) => canonicalSidecarName.test(file)).flatMap((file) => {
         try {
-          const value = JSON.parse(readFileSync36(join68(params.directory, file), "utf8"));
-          if (isSidecar(value) && join68(params.directory, file) === path32(value.agentId, value.conversationId, value.lineageId)) {
+          const value = JSON.parse(readFileSync37(join69(params.directory, file), "utf8"));
+          if (isSidecar(value) && join69(params.directory, file) === path32(value.agentId, value.conversationId, value.lineageId)) {
             return [value];
           }
           removeMalformedOrphan(file);
@@ -250887,14 +251507,14 @@ var init_recovery_lineage_sidecar = __esm(async () => {
 // src/websocket/listener/interrupted-turn-record.ts
 import { randomUUID as randomUUID41 } from "node:crypto";
 import {
-  existsSync as existsSync47,
+  existsSync as existsSync48,
   mkdirSync as mkdirSync33,
-  readFileSync as readFileSync37,
+  readFileSync as readFileSync38,
   rmSync as rmSync18,
   unlinkSync as unlinkSync9,
   writeFileSync as writeFileSync29
 } from "node:fs";
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(), dependencies4 = {}) {
   const sync = dependencies4.fsyncDirectory ?? fsyncInterruptedTurnDirectory;
   function persist(destination, record6) {
@@ -250906,11 +251526,11 @@ function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(
     }
   }
   function path32(agentId, conversationId) {
-    return join69(directory, `${encodeURIComponent(agentId)}_${encodeURIComponent(conversationId)}.json`);
+    return join70(directory, `${encodeURIComponent(agentId)}_${encodeURIComponent(conversationId)}.json`);
   }
   function readRecord2(file) {
     try {
-      const value = JSON.parse(readFileSync37(file, "utf8"));
+      const value = JSON.parse(readFileSync38(file, "utf8"));
       if (!isInterruptedTurnRecord(value, file, path32)) {
         throw new Error("Invalid interrupted-turn record");
       }
@@ -250944,7 +251564,7 @@ function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(
   const recoveryAuthority = createRecoveryAuthorityGuard({
     path: path32,
     readRecord: readRecord2,
-    exists: existsSync47,
+    exists: existsSync48,
     acquire: (destination) => acquireDurableFileLock(destination, {
       waitMs: dependencies4.lockWaitMs
     }),
@@ -250978,7 +251598,7 @@ function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(
           });
           try {
             const current = readRecord2(destination);
-            if (!existsSync47(destination)) {
+            if (!existsSync48(destination)) {
               removeSidecar(sidecar);
             } else if (current && current.recoveryClaimCompletion?.lineageId !== sidecar.lineageId) {
               removeSidecar(sidecar);
@@ -251003,7 +251623,7 @@ function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(
     },
     listDurableInputOwnership() {
       const snapshot2 = rawSnapshot();
-      return collectInterruptedTurnInputOwnershipWithSidecars(snapshot2.records, readMainView, listSidecars(), (agentId, conversationId) => existsSync47(path32(agentId, conversationId)), snapshot2.unreadableScopes);
+      return collectInterruptedTurnInputOwnershipWithSidecars(snapshot2.records, readMainView, listSidecars(), (agentId, conversationId) => existsSync48(path32(agentId, conversationId)), snapshot2.unreadableScopes);
     },
     read(agentId, conversationId) {
       const current = readRecord2(path32(agentId, conversationId));
@@ -251262,7 +251882,7 @@ function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(
         }
         if (current.revision === params.pendingRevision && !marker2.independentSuccessor) {
           const retiredAuthority = retireSidecar(current);
-          const evidence = readFileSync37(destination, "utf8");
+          const evidence = readFileSync38(destination, "utf8");
           unlinkSync9(destination);
           try {
             sync(directory);
@@ -251317,7 +251937,7 @@ function createInterruptedTurnStore(directory = defaultInterruptedTurnDirectory(
           if (expectedRevision !== undefined && (current.revision ?? null) !== expectedRevision) {
             return false;
           }
-          evidence = readFileSync37(destination, "utf8");
+          evidence = readFileSync38(destination, "utf8");
           unlinkSync9(destination);
         } catch (error5) {
           if (error5.code === "ENOENT")
@@ -253305,10 +253925,10 @@ var init_input_disposition_expiry = __esm(() => {
 // src/websocket/listener/input-disposition-path.ts
 import { createHash as createHash9 } from "node:crypto";
 import { homedir as homedir34 } from "node:os";
-import { join as join70 } from "node:path";
+import { join as join71 } from "node:path";
 function inputDispositionPersistentPath(serverUrl) {
   const namespace = createHash9("sha256").update(serverUrl).digest("hex").slice(0, 24);
-  return join70(homedir34(), ".letta", "state", namespace, "input-dispositions-v2.json");
+  return join71(homedir34(), ".letta", "state", namespace, "input-dispositions-v2.json");
 }
 var init_input_disposition_path = () => {};
 
@@ -253334,14 +253954,14 @@ var init_input_disposition_validation = __esm(async () => {
 import { randomUUID as randomUUID42 } from "node:crypto";
 import {
   chmodSync as chmodSync7,
-  closeSync as closeSync6,
-  existsSync as existsSync48,
+  closeSync as closeSync7,
+  existsSync as existsSync49,
   fsyncSync as fsyncSync4,
   mkdirSync as mkdirSync34,
-  openSync as openSync6,
-  readFileSync as readFileSync38,
+  openSync as openSync7,
+  readFileSync as readFileSync39,
   renameSync as renameSync10,
-  statSync as statSync17,
+  statSync as statSync18,
   unlinkSync as unlinkSync10,
   writeFileSync as writeFileSync30
 } from "node:fs";
@@ -253479,13 +254099,13 @@ function validateDurableStore(value) {
   return value;
 }
 function readDurableStore(path32) {
-  if (!existsSync48(path32))
+  if (!existsSync49(path32))
     return emptyDurableStore();
-  const size2 = statSync17(path32).size;
+  const size2 = statSync18(path32).size;
   if (size2 > MAX_INPUT_DISPOSITION_STORE_BYTES) {
     throw new Error("Accepted-input disposition store exceeds its size limit");
   }
-  return validateDurableStore(JSON.parse(readFileSync38(path32, "utf8")));
+  return validateDurableStore(JSON.parse(readFileSync39(path32, "utf8")));
 }
 function prepareStateDirectory(path32) {
   const dir = dirname30(path32);
@@ -253501,11 +254121,11 @@ function writeDurableStore(path32, store3) {
   const temporaryPath = `${path32}.${process.pid}.${randomUUID42()}.tmp`;
   try {
     writeFileSync30(temporaryPath, serialized, { mode: 384, flag: "wx" });
-    const fd = openSync6(temporaryPath, "r+");
+    const fd = openSync7(temporaryPath, "r+");
     try {
       fsyncSync4(fd);
     } finally {
-      closeSync6(fd);
+      closeSync7(fd);
     }
     renameSync10(temporaryPath, path32);
     fsyncDirectory(dirname30(path32));
@@ -253927,18 +254547,18 @@ var init_input_disposition = __esm(async () => {
 // src/websocket/listener/turn-finished-replay.ts
 import { randomUUID as randomUUID43 } from "node:crypto";
 import {
-  closeSync as closeSync7,
+  closeSync as closeSync8,
   fsyncSync as fsyncSync5,
   mkdirSync as mkdirSync35,
-  openSync as openSync7,
-  readdirSync as readdirSync17,
-  readFileSync as readFileSync39,
+  openSync as openSync8,
+  readdirSync as readdirSync18,
+  readFileSync as readFileSync40,
   renameSync as renameSync11,
   rmSync as rmSync19,
   writeFileSync as writeFileSync31
 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 function terminalAuthorityStatus(runtime, terminal, terminals, interruptedStore = createInterruptedTurnStore()) {
   const { owner } = terminal;
   if (!owner.recoveryLineageId)
@@ -253978,7 +254598,7 @@ function defaultDirectory() {
   } catch {
     serverUrl = process.env.LETTA_BASE_URL ?? "uninitialized";
   }
-  return join71(homedir35(), ".letta", "listener-terminal-state", Buffer.from(serverUrl).toString("base64url"));
+  return join72(homedir35(), ".letta", "listener-terminal-state", Buffer.from(serverUrl).toString("base64url"));
 }
 function encodeTurnFinishedScope(agentId, conversationId) {
   return Buffer.from(JSON.stringify([agentId, conversationId])).toString("base64url");
@@ -253997,19 +254617,19 @@ function decodeTurnFinishedScope(encoded) {
 function fsyncDirectory2(directory) {
   if (process.platform === "win32")
     return;
-  const fd = openSync7(directory, "r");
+  const fd = openSync8(directory, "r");
   try {
     fsyncSync5(fd);
   } finally {
-    closeSync7(fd);
+    closeSync8(fd);
   }
 }
 function createTurnFinishedStore(directory = defaultDirectory(), options = {}) {
   const claimantToken = randomUUID43();
-  const path32 = (agentId, conversationId) => join71(directory, `${encodeTurnFinishedScope(agentId, conversationId)}.json`);
+  const path32 = (agentId, conversationId) => join72(directory, `${encodeTurnFinishedScope(agentId, conversationId)}.json`);
   const readRecord2 = (agentId, conversationId) => {
     try {
-      const record6 = JSON.parse(readFileSync39(path32(agentId, conversationId), "utf8"));
+      const record6 = JSON.parse(readFileSync40(path32(agentId, conversationId), "utf8"));
       if (record6.agentId !== agentId || record6.conversationId !== conversationId || !Array.isArray(record6.terminals) || !record6.terminals.every((terminal) => typeof terminal.id === "string" && Number.isFinite(terminal.createdAt) && terminal.message?.type === "turn_finished" && typeof terminal.message.turn_id === "string" && Array.isArray(terminal.requiredConsumerIds) && terminal.requiredConsumerIds.every((id2) => typeof id2 === "string") && Array.isArray(terminal.acknowledgedConsumerIds) && terminal.acknowledgedConsumerIds.every((id2) => typeof id2 === "string") && !!terminal.owner && (terminal.owner.connectionId === null || typeof terminal.owner.connectionId === "string") && typeof terminal.owner.canRotate === "boolean" && (terminal.owner.terminalIdentity === undefined || typeof terminal.owner.terminalIdentity === "string") && (terminal.owner.interruptedRevision === undefined || typeof terminal.owner.interruptedRevision === "string") && (terminal.owner.recoveryLineageId === undefined || typeof terminal.owner.recoveryLineageId === "string") && (terminal.owner.interruptedAuthorityRevision === undefined || typeof terminal.owner.interruptedAuthorityRevision === "string") && (terminal.owner.preparationSequence === undefined || Number.isSafeInteger(terminal.owner.preparationSequence) && terminal.owner.preparationSequence >= 0))) {
         throw new Error("Invalid turn-finished record");
       }
@@ -254075,7 +254695,7 @@ function createTurnFinishedStore(directory = defaultDirectory(), options = {}) {
   const sweepExpiredRecords = () => {
     let entries2;
     try {
-      entries2 = readdirSync17(directory, { withFileTypes: true });
+      entries2 = readdirSync18(directory, { withFileTypes: true });
     } catch (error5) {
       if (error5.code === "ENOENT")
         return;
@@ -259315,7 +259935,7 @@ function printListenUsage() {
 }
 
 // src/cli/subcommands/listener-readiness.ts
-async function completeListenerConnectionStartup(expectedConnection, readiness) {
+async function completeListenerConnectionStartup(expectedConnection, readiness, startGateway = async () => {}) {
   const { getActiveRuntime: getActiveRuntime2 } = await init_runtime6().then(() => exports_runtime);
   const runtime = getActiveRuntime2();
   const connection = runtime?.connections.get(expectedConnection.id);
@@ -259325,8 +259945,11 @@ async function completeListenerConnectionStartup(expectedConnection, readiness)
   const { isListenerTransportOpen: isListenerTransportOpen2 } = await Promise.resolve().then(() => (init_transport(), exports_transport));
   if (!isListenerTransportOpen2(connection.writer))
     return false;
+  await startGateway();
   if (getActiveRuntime2()?.connections.get(connection.id) !== connection)
     return false;
+  if (!connection.initialized || !connection.ingressReady || connection.cancellation.signal.aborted || !isListenerTransportOpen2(connection.writer))
+    return false;
   readiness.completeCloudStartup(epoch);
   return true;
 }
@@ -259448,13 +260071,13 @@ var init_service_protocol = __esm(() => {
 // src/websocket/listen-log.ts
 import {
   appendFileSync as appendFileSync8,
-  existsSync as existsSync49,
+  existsSync as existsSync50,
   mkdirSync as mkdirSync36,
-  readdirSync as readdirSync18,
+  readdirSync as readdirSync19,
   unlinkSync as unlinkSync11
 } from "node:fs";
 import { homedir as homedir36 } from "node:os";
-import { join as join72 } from "node:path";
+import { join as join73 } from "node:path";
 function formatTimestamp2() {
   const now2 = new Date;
   const h3 = String(now2.getHours()).padStart(2, "0");
@@ -259468,14 +260091,14 @@ function formatFileTimestamp(now2) {
 }
 function pruneOldLogs(dir, maxFiles) {
   try {
-    if (!existsSync49(dir))
+    if (!existsSync50(dir))
       return;
-    const files = readdirSync18(dir).filter((f4) => f4.endsWith(".log")).sort();
+    const files = readdirSync19(dir).filter((f4) => f4.endsWith(".log")).sort();
     if (files.length >= maxFiles) {
       const toDelete = files.slice(0, files.length - maxFiles + 1);
       for (const file of toDelete) {
         try {
-          unlinkSync11(join72(dir, file));
+          unlinkSync11(join73(dir, file));
         } catch {}
       }
     }
@@ -259514,13 +260137,13 @@ class RemoteSessionLog {
   freshPath() {
     const stamp = formatFileTimestamp(new Date);
     const suffix = this.rotation > 0 ? `.${this.rotation}` : "";
-    return join72(this.dir, `${stamp}${suffix}.log`);
+    return join73(this.dir, `${stamp}${suffix}.log`);
   }
   rotate() {
     const previous = this.path;
     this.rotation += 1;
     this.path = this.freshPath();
-    while (existsSync49(this.path)) {
+    while (existsSync50(this.path)) {
       this.rotation += 1;
       this.path = this.freshPath();
     }
@@ -259544,7 +260167,7 @@ class RemoteSessionLog {
     if (this.dirCreated)
       return;
     try {
-      if (!existsSync49(this.dir)) {
+      if (!existsSync50(this.dir)) {
         mkdirSync36(this.dir, { recursive: true });
       }
       this.dirCreated = true;
@@ -259553,7 +260176,7 @@ class RemoteSessionLog {
 }
 var REMOTE_LOG_DIR, MAX_LOG_FILES = 10, MAX_LOG_BYTES2;
 var init_listen_log = __esm(() => {
-  REMOTE_LOG_DIR = join72(homedir36(), ".letta", "logs", "remote");
+  REMOTE_LOG_DIR = join73(homedir36(), ".letta", "logs", "remote");
   MAX_LOG_BYTES2 = 10 * 1024 * 1024;
 });
 
@@ -262296,28 +262919,28 @@ __export(exports_memory_scanner, {
   readFileContent: () => readFileContent,
   getFileNodes: () => getFileNodes
 });
-import { readdirSync as readdirSync19, readFileSync as readFileSync40, statSync as statSync18 } from "node:fs";
-import { join as join73, relative as relative7 } from "node:path";
+import { readdirSync as readdirSync20, readFileSync as readFileSync41, statSync as statSync19 } from "node:fs";
+import { join as join74, relative as relative7 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
   const scanDir = (dir, depth, parentIsLast) => {
     let entries2;
     try {
-      entries2 = readdirSync19(dir);
+      entries2 = readdirSync20(dir);
     } catch {
       return;
     }
     const filtered = entries2.filter((name) => !name.startsWith("."));
     const sorted = filtered.sort((a2, b3) => {
-      const aPath = join73(dir, a2);
-      const bPath = join73(dir, b3);
+      const aPath = join74(dir, a2);
+      const bPath = join74(dir, b3);
       let aIsDir = false;
       let bIsDir = false;
       try {
-        aIsDir = statSync18(aPath).isDirectory();
+        aIsDir = statSync19(aPath).isDirectory();
       } catch {}
       try {
-        bIsDir = statSync18(bPath).isDirectory();
+        bIsDir = statSync19(bPath).isDirectory();
       } catch {}
       if (aIsDir !== bIsDir)
         return aIsDir ? -1 : 1;
@@ -262330,10 +262953,10 @@ function scanMemoryFilesystem(memoryRoot) {
       return a2.localeCompare(b3);
     });
     sorted.forEach((name, index) => {
-      const fullPath = join73(dir, name);
+      const fullPath = join74(dir, name);
       let isDir = false;
       try {
-        isDir = statSync18(fullPath).isDirectory();
+        isDir = statSync19(fullPath).isDirectory();
       } catch {
         return;
       }
@@ -262361,7 +262984,7 @@ function getFileNodes(nodes) {
 }
 function readFileContent(fullPath) {
   try {
-    return readFileSync40(fullPath, "utf-8");
+    return readFileSync41(fullPath, "utf-8");
   } catch {
     return "(unable to read file)";
   }
@@ -262432,10 +263055,10 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     const isMemfsEnabledOnServer2 = overrides.isMemfsEnabledOnServer ?? actualIsMemfsEnabledOnServer;
     const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memory_scanner(), exports_memory_scanner));
     const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-    const { existsSync: existsSync50, statSync: statSync19 } = await import("node:fs");
-    const { join: join74, posix: posix3 } = await import("node:path");
+    const { existsSync: existsSync51, statSync: statSync20 } = await import("node:fs");
+    const { join: join75, posix: posix3 } = await import("node:path");
     const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
-    let memfsInitialized = existsSync50(join74(memoryRoot, ".git"));
+    let memfsInitialized = existsSync51(join75(memoryRoot, ".git"));
     const memfsEnabled = memfsInitialized ? true : await isMemfsEnabledOnServer2(parsed.agent_id);
     if (!memfsEnabled) {
       safeSocketSend(socket, {
@@ -262453,7 +263076,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     await ensureLocalMemfsCheckout2(parsed.agent_id, {
       pullOnExistingRepo: true
     });
-    memfsInitialized = existsSync50(join74(memoryRoot, ".git"));
+    memfsInitialized = existsSync51(join75(memoryRoot, ".git"));
     if (!memfsInitialized) {
       throw new Error("MemFS is enabled, but the local memory checkout could not be initialized.");
     }
@@ -262529,7 +263152,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
         if (imageMimeType) {
           let size2 = 0;
           try {
-            size2 = statSync19(node.fullPath).size;
+            size2 = statSync20(node.fullPath).size;
           } catch {}
           return {
             relative_path: node.relativePath,
@@ -262753,34 +263376,34 @@ function handleMemoryProtocolCommand(parsed, context3) {
           isMemfsEnabledOnServer: isMemfsEnabledOnServer2
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { readFile: readFile20 } = await import("node:fs/promises");
-        const { existsSync: existsSync50 } = await import("node:fs");
-        const { isAbsolute: isAbsolute25, join: join74, normalize: normalize4, relative: relative8, sep: sep7 } = await import("node:path");
+        const { existsSync: existsSync51 } = await import("node:fs");
+        const { isAbsolute: isAbsolute25, join: join75, normalize: normalize4, relative: relative8, sep: sep8 } = await import("node:path");
         if (isAbsolute25(parsed.path) || parsed.path.length === 0) {
           sendFailure("path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize4(join74(memoryRoot, parsed.path));
+        const absolutePath = normalize4(join75(memoryRoot, parsed.path));
         const rel = relative8(memoryRoot, absolutePath);
-        if (rel.startsWith("..") || rel === "" || isAbsolute25(rel) || rel.split(sep7).includes("..")) {
+        if (rel.startsWith("..") || rel === "" || isAbsolute25(rel) || rel.split(sep8).includes("..")) {
           sendFailure("path must resolve inside the memory root");
           return;
         }
-        if (!existsSync50(join74(memoryRoot, ".git"))) {
+        if (!existsSync51(join75(memoryRoot, ".git"))) {
           const enabled = await isMemfsEnabledOnServer2(parsed.agent_id);
           if (!enabled) {
             sendFailure("memfs is not enabled for this agent");
             return;
           }
           await ensureLocalMemfsCheckout2(parsed.agent_id);
-          if (!existsSync50(join74(memoryRoot, ".git"))) {
+          if (!existsSync51(join75(memoryRoot, ".git"))) {
             sendFailure("failed to initialize local memory checkout");
             return;
           }
         }
         const buffer = await readFile20(absolutePath);
         const content = encoding === "base64" ? buffer.toString("base64") : buffer.toString("utf-8");
-        const pathspec = rel.split(sep7).join("/");
+        const pathspec = rel.split(sep8).join("/");
         safeSocketSend(socket, {
           type: "read_memory_file_response",
           request_id: parsed.request_id,
@@ -262819,27 +263442,27 @@ function handleMemoryProtocolCommand(parsed, context3) {
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { writeFile: writeFile16, mkdir: mkdir14 } = await import("node:fs/promises");
-        const { existsSync: existsSync50 } = await import("node:fs");
-        const { dirname: dirname31, isAbsolute: isAbsolute25, join: join74, normalize: normalize4, relative: relative8, sep: sep7 } = await import("node:path");
+        const { existsSync: existsSync51 } = await import("node:fs");
+        const { dirname: dirname31, isAbsolute: isAbsolute25, join: join75, normalize: normalize4, relative: relative8, sep: sep8 } = await import("node:path");
         if (isAbsolute25(parsed.path) || parsed.path.length === 0) {
           sendFailure("write_memory_file: path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize4(join74(memoryRoot, parsed.path));
+        const absolutePath = normalize4(join75(memoryRoot, parsed.path));
         const rel = relative8(memoryRoot, absolutePath);
-        if (rel.startsWith("..") || rel === "" || isAbsolute25(rel) || rel.split(sep7).includes("..")) {
+        if (rel.startsWith("..") || rel === "" || isAbsolute25(rel) || rel.split(sep8).includes("..")) {
           sendFailure("write_memory_file: path must resolve inside the memory root");
           return;
         }
-        if (!existsSync50(join74(memoryRoot, ".git"))) {
+        if (!existsSync51(join75(memoryRoot, ".git"))) {
           const enabled = await isMemfsEnabledOnServer2(parsed.agent_id);
           if (!enabled) {
             sendFailure("write_memory_file: memfs is not enabled for this agent");
             return;
           }
           await ensureLocalMemfsCheckout2(parsed.agent_id);
-          if (!existsSync50(join74(memoryRoot, ".git"))) {
+          if (!existsSync51(join75(memoryRoot, ".git"))) {
             sendFailure("write_memory_file: failed to initialize local memory checkout");
             return;
           }
@@ -262857,7 +263480,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
             agentName = agent.name.trim();
           }
         } catch {}
-        const pathspec = rel.split(sep7).join("/");
+        const pathspec = rel.split(sep8).join("/");
         const reason = parsed.commit_message?.trim() || `Update memory file ${pathspec}`;
         const commitResult = await commitMemoryWrite2({
           memoryDir: memoryRoot,
@@ -262917,34 +263540,34 @@ function handleMemoryProtocolCommand(parsed, context3) {
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { unlink: unlink4 } = await import("node:fs/promises");
-        const { existsSync: existsSync50 } = await import("node:fs");
-        const { isAbsolute: isAbsolute25, join: join74, normalize: normalize4, relative: relative8, sep: sep7 } = await import("node:path");
+        const { existsSync: existsSync51 } = await import("node:fs");
+        const { isAbsolute: isAbsolute25, join: join75, normalize: normalize4, relative: relative8, sep: sep8 } = await import("node:path");
         if (isAbsolute25(parsed.path) || parsed.path.length === 0) {
           sendFailure("delete_memory_file: path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize4(join74(memoryRoot, parsed.path));
+        const absolutePath = normalize4(join75(memoryRoot, parsed.path));
         const rel = relative8(memoryRoot, absolutePath);
-        if (rel.startsWith("..") || rel === "" || isAbsolute25(rel) || rel.split(sep7).includes("..")) {
+        if (rel.startsWith("..") || rel === "" || isAbsolute25(rel) || rel.split(sep8).includes("..")) {
           sendFailure("delete_memory_file: path must resolve inside the memory root");
           return;
         }
-        if (!existsSync50(join74(memoryRoot, ".git"))) {
+        if (!existsSync51(join75(memoryRoot, ".git"))) {
           const enabled = await isMemfsEnabledOnServer2(parsed.agent_id);
           if (!enabled) {
             sendFailure("delete_memory_file: memfs is not enabled for this agent");
             return;
           }
           await ensureLocalMemfsCheckout2(parsed.agent_id);
-          if (!existsSync50(join74(memoryRoot, ".git"))) {
+          if (!existsSync51(join75(memoryRoot, ".git"))) {
             sendFailure("delete_memory_file: failed to initialize local memory checkout");
             return;
           }
         }
-        const pathspec = rel.split(sep7).join("/");
+        const pathspec = rel.split(sep8).join("/");
         const removeIfPresent = async () => {
-          if (!existsSync50(absolutePath))
+          if (!existsSync51(absolutePath))
             return false;
           await unlink4(absolutePath);
           return true;
@@ -263013,7 +263636,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
   return false;
 }
 var warnMemoryCommand, WIKI_LINK_REGEX, IMAGE_MIME_BY_EXTENSION, MEMORY_PUSH_AWAIT_CAP_MS = 8000;
-var init_memory5 = __esm(async () => {
+var init_memory6 = __esm(async () => {
   init_error_reporting();
   init_debug();
   await init_protocol_inbound();
@@ -263118,12 +263741,12 @@ __export(exports_remote_model_catalog, {
   applyCatalogModels: () => applyCatalogModels,
   __testResetRemoteModelCatalog: () => __testResetRemoteModelCatalog
 });
-import { existsSync as existsSync50, mkdirSync as mkdirSync37, readFileSync as readFileSync41, writeFileSync as writeFileSync32 } from "node:fs";
+import { existsSync as existsSync51, mkdirSync as mkdirSync37, readFileSync as readFileSync42, writeFileSync as writeFileSync32 } from "node:fs";
 import { homedir as homedir38 } from "node:os";
-import { dirname as dirname31, join as join74 } from "node:path";
+import { dirname as dirname31, join as join75 } from "node:path";
 function catalogCachePath() {
-  const dir = process.env.LETTA_MODEL_CATALOG_CACHE_DIR || join74(homedir38(), ".letta", "cache");
-  return join74(dir, "model-catalog.json");
+  const dir = process.env.LETTA_MODEL_CATALOG_CACHE_DIR || join75(homedir38(), ".letta", "cache");
+  return join75(dir, "model-catalog.json");
 }
 function normalizeCatalogSource(source) {
   try {
@@ -263222,10 +263845,10 @@ function persistCatalogCache(entries2, source) {
 function loadPersistedModelCatalog(source) {
   try {
     const path33 = catalogCachePath();
-    if (!existsSync50(path33)) {
+    if (!existsSync51(path33)) {
       return false;
     }
-    const parsed = JSON.parse(readFileSync41(path33, "utf-8"));
+    const parsed = JSON.parse(readFileSync42(path33, "utf-8"));
     if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION || parsed.source !== normalizeCatalogSource(source) || !Array.isArray(parsed.models)) {
       return false;
     }
@@ -263911,7 +264534,7 @@ function recordStaleHandleUse(collector, owner, capability, onDiagnostic) {
 var MOD_DIAGNOSTICS_MAX_COUNT = 200, MOD_DIAGNOSTICS_RESET_COUNT = 50, MOD_DYNAMIC_CONTEXT_MIGRATION_HINT = "Dynamic context is now passed as ctx to commands, tools, events, permissions, and UI renderers. Use ctx.agent, ctx.cwd, ctx.conversation, ctx.model, etc.", MOD_LETTA_GET_CONTEXT_MIGRATION_HINT = "letta.getContext has been removed. Activation has no dynamic invocation context. Move dynamic work into a command, tool, event, permission, status, or statusline callback that receives ctx, or use explicit/global state such as process.cwd() for activation-time background work.", MOD_CTX_GET_CONTEXT_MIGRATION_HINT = "ctx.getContext has been removed. Use ctx directly; scoped fields are available as ctx.agent, ctx.cwd, ctx.conversation, ctx.model, etc.", MOD_GENERIC_GET_CONTEXT_MIGRATION_HINT = "getContext helpers have been removed. If this is callback ctx, use ctx directly; if activation/background code needs runtime state, move it into a callback that receives ctx or use explicit/global state such as process.cwd().";
 
 // src/mods/paths.ts
-import { existsSync as existsSync51 } from "node:fs";
+import { existsSync as existsSync52 } from "node:fs";
 import { homedir as homedir39 } from "node:os";
 import path33 from "node:path";
 function getGlobalModsDirectory(homeDirectory = homedir39()) {
@@ -263925,10 +264548,10 @@ function resolveDefaultGlobalModsDirectory(homeDirectory = homedir39(), env6 = p
   if (environmentDirectory)
     return environmentDirectory;
   const modsDirectory = getGlobalModsDirectory(homeDirectory);
-  if (existsSync51(modsDirectory))
+  if (existsSync52(modsDirectory))
     return modsDirectory;
   const legacyDirectory = getLegacyGlobalExtensionsDirectory(homeDirectory);
-  if (existsSync51(legacyDirectory))
+  if (existsSync52(legacyDirectory))
     return legacyDirectory;
   return modsDirectory;
 }
@@ -272078,7 +272701,7 @@ ${lanes.join(`
             return process.memoryUsage().heapUsed;
           },
           getFileSize(path35) {
-            const stat12 = statSync19(path35);
+            const stat12 = statSync20(path35);
             if (stat12 == null ? undefined : stat12.isFile()) {
               return stat12.size;
             }
@@ -272121,7 +272744,7 @@ ${lanes.join(`
           }
         };
         return nodeSystem;
-        function statSync19(path35) {
+        function statSync20(path35) {
           try {
             return _fs.statSync(path35, statSyncOptions);
           } catch {
@@ -272173,7 +272796,7 @@ ${lanes.join(`
             activeSession.post("Profiler.stop", (err, { profile }) => {
               var _a10;
               if (!err) {
-                if ((_a10 = statSync19(profilePath)) == null ? undefined : _a10.isDirectory()) {
+                if ((_a10 = statSync20(profilePath)) == null ? undefined : _a10.isDirectory()) {
                   profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                 }
                 try {
@@ -272282,7 +272905,7 @@ ${lanes.join(`
               let stat12;
               if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                 const name = combinePaths(path35, entry);
-                stat12 = statSync19(name);
+                stat12 = statSync20(name);
                 if (!stat12) {
                   continue;
                 }
@@ -272306,7 +272929,7 @@ ${lanes.join(`
           return matchFiles(path35, extensions, excludes, includes2, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath6);
         }
         function fileSystemEntryExists(path35, entryKind) {
-          const stat12 = statSync19(path35);
+          const stat12 = statSync20(path35);
           if (!stat12) {
             return false;
           }
@@ -272340,7 +272963,7 @@ ${lanes.join(`
         }
         function getModifiedTime3(path35) {
           var _a10;
-          return (_a10 = statSync19(path35)) == null ? undefined : _a10.mtime;
+          return (_a10 = statSync20(path35)) == null ? undefined : _a10.mtime;
         }
         function setModifiedTime(path35, time3) {
           try {
@@ -295182,7 +295805,7 @@ ${lanes.join(`
       var contextFlags;
       var topLevel = true;
       var parseErrorBeforeNextFinishedNode = false;
-      function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride, jsDocParsingMode = 0) {
+      function parseSourceFile2(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride, jsDocParsingMode = 0) {
         var _a10;
         scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
         if (scriptKind2 === 6) {
@@ -295201,7 +295824,7 @@ ${lanes.join(`
         clearState();
         return result3;
       }
-      Parser22.parseSourceFile = parseSourceFile;
+      Parser22.parseSourceFile = parseSourceFile2;
       function parseIsolatedEntityName2(content, languageVersion2) {
         initializeState("", content, languageVersion2, undefined, 1, 0);
         nextToken();
@@ -305466,11 +306089,11 @@ ${lanes.join(`
           if (i4 < rootLength) {
             return;
           }
-          const sep7 = directory.lastIndexOf(directorySeparator, i4 - 1);
-          if (sep7 === -1) {
+          const sep8 = directory.lastIndexOf(directorySeparator, i4 - 1);
+          if (sep8 === -1) {
             return;
           }
-          return directory.substr(0, Math.max(sep7, rootLength));
+          return directory.substr(0, Math.max(sep8, rootLength));
         }
       }
     }
@@ -432746,7 +433369,7 @@ function createModChangeBatcher(onChange) {
 }
 
 // src/mods/package-manifest.ts
-import { readFileSync as readFileSync42 } from "node:fs";
+import { readFileSync as readFileSync43 } from "node:fs";
 import path35 from "node:path";
 function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -432956,7 +433579,7 @@ function parseLettaPackageManifest(packageJson) {
 }
 function readLettaPackageManifest(packageJsonPath) {
   try {
-    const packageJson = JSON.parse(readFileSync42(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync43(packageJsonPath, "utf8"));
     return parseLettaPackageManifest(packageJson);
   } catch (error5) {
     return {
@@ -432986,9 +433609,9 @@ var init_package_manifest = __esm(() => {
 
 // src/mods/package-registry.ts
 import {
-  existsSync as existsSync52,
+  existsSync as existsSync53,
   mkdirSync as mkdirSync39,
-  readFileSync as readFileSync43,
+  readFileSync as readFileSync44,
   rmSync as rmSync20,
   writeFileSync as writeFileSync34
 } from "node:fs";
@@ -433044,7 +433667,7 @@ function parseJsonFile(filePath) {
   try {
     return {
       ok: true,
-      value: JSON.parse(readFileSync43(filePath, "utf8"))
+      value: JSON.parse(readFileSync44(filePath, "utf8"))
     };
   } catch (error5) {
     return {
@@ -433058,7 +433681,7 @@ function getRegistryPath(modsRoot) {
 }
 function readRegistryObject(modsRoot) {
   const registryPath = getRegistryPath(modsRoot);
-  if (!existsSync52(registryPath)) {
+  if (!existsSync53(registryPath)) {
     return { diagnostics: [], ok: false, registryExists: false, registryPath };
   }
   const registryResult = parseJsonFile(registryPath);
@@ -433490,7 +434113,7 @@ function writePackageRegistry(registryPath, registry4) {
 }
 function validateManagedModPackageRegistryForMutation(modsRoot) {
   const registryPath = getRegistryPath(modsRoot);
-  const contents = existsSync52(registryPath) ? readFileSync43(registryPath, "utf8") : null;
+  const contents = existsSync53(registryPath) ? readFileSync44(registryPath, "utf8") : null;
   const registry4 = readMutablePackageRegistry(modsRoot, {
     createIfMissing: true
   });
@@ -433613,12 +434236,12 @@ var init_package_registry = __esm(() => {
 });
 
 // src/mods/mod-sources.ts
-import { existsSync as existsSync53, readdirSync as readdirSync20 } from "node:fs";
+import { existsSync as existsSync54, readdirSync as readdirSync21 } from "node:fs";
 import path37 from "node:path";
 function listModFiles(directory) {
-  if (!existsSync53(directory))
+  if (!existsSync54(directory))
     return [];
-  return readdirSync20(directory, { withFileTypes: true }).filter((entry) => {
+  return readdirSync21(directory, { withFileTypes: true }).filter((entry) => {
     if (!entry.isFile())
       return false;
     if (entry.name.startsWith("."))
@@ -433632,7 +434255,7 @@ function resolveLocalModSources(options = {}) {
   const includeGlobalMods = options.includeGlobalMods !== false;
   const managedPackages = includeGlobalMods ? resolveManagedModPackages(globalModsDirectory) : { diagnostics: [], files: [], packages: [] };
   const sources = [];
-  if (includeGlobalMods && legacyGlobalExtensionsDirectory && path37.resolve(legacyGlobalExtensionsDirectory) !== path37.resolve(globalModsDirectory) && existsSync53(legacyGlobalExtensionsDirectory)) {
+  if (includeGlobalMods && legacyGlobalExtensionsDirectory && path37.resolve(legacyGlobalExtensionsDirectory) !== path37.resolve(globalModsDirectory) && existsSync54(legacyGlobalExtensionsDirectory)) {
     sources.push({
       files: listModFiles(legacyGlobalExtensionsDirectory),
       legacyMigrationTargetRoot: globalModsDirectory,
@@ -433811,11 +434434,11 @@ function createNoopModPanelHandle() {
 // src/mods/mod-engine.ts
 import { createHash as createHash12 } from "node:crypto";
 import {
-  existsSync as existsSync54,
+  existsSync as existsSync55,
   mkdirSync as mkdirSync41,
-  readdirSync as readdirSync21,
-  readFileSync as readFileSync44,
-  statSync as statSync19,
+  readdirSync as readdirSync22,
+  readFileSync as readFileSync45,
+  statSync as statSync20,
   unlinkSync as unlinkSync13,
   writeFileSync as writeFileSync35
 } from "node:fs";
@@ -433990,7 +434613,7 @@ function prepareModForImport(modPath, source) {
 }
 function createImportableModPath(modPath, cacheDirectory, source) {
   const importCacheDirectory = getManagedPackageImportCacheDirectory(modPath, source) ?? cacheDirectory;
-  const sourceText = readFileSync44(modPath, "utf8");
+  const sourceText = readFileSync45(modPath, "utf8");
   const hash3 = createHash12("sha256").update(sourceText).digest("hex").slice(0, 16);
   const fileExtension = path39.extname(modPath);
   const importableSource = prepareModForImport(modPath, sourceText);
@@ -434001,11 +434624,11 @@ function createImportableModPath(modPath, cacheDirectory, source) {
   }
   const baseName = path39.basename(modPath, fileExtension).replace(/[^a-zA-Z0-9_-]/g, "-");
   const importPath = path39.join(importCacheDirectory, `.letta-mod-${baseName}-${hash3}.mjs`);
-  if (!existsSync54(importPath)) {
+  if (!existsSync55(importPath)) {
     writeFileSync35(importPath, importableSource, "utf8");
   }
   try {
-    for (const entry of readdirSync21(importCacheDirectory)) {
+    for (const entry of readdirSync22(importCacheDirectory)) {
       if (entry.startsWith(`.letta-mod-${baseName}-`) && entry !== path39.basename(importPath)) {
         unlinkSync13(path39.join(importCacheDirectory, entry));
       }
@@ -434644,8 +435267,8 @@ async function loadLocalMods(options) {
         recordLegacyExtensionLoadedDiagnostic(registry4, owner, source, options.onDiagnostic);
       }
       try {
-        const mtimeMs = statSync19(modPath).mtimeMs;
-        const sourceText = readFileSync44(modPath, "utf8");
+        const mtimeMs = statSync20(modPath).mtimeMs;
+        const sourceText = readFileSync45(modPath, "utf8");
         recordDeprecatedContextApiSourceDiagnostics(sourceText, (diagnostic) => {
           recordModDiagnostic(registry4, {
             ...diagnostic,
@@ -435167,7 +435790,7 @@ var init_memfs_sync = __esm(() => {
 
 // src/websocket/listener/mod-adapter.ts
 import { createHash as createHash13 } from "node:crypto";
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 async function getUnavailableListenerClient() {
   throw new Error("letta.client is not available in listener mods");
 }
@@ -435243,14 +435866,14 @@ function ensureListenerModAdapter(runtime) {
 }
 function resolveListenerAgentModsDirectory(agentId) {
   try {
-    return settingsManager.isMemfsEnabled(agentId) ? join75(getScopedMemoryFilesystemRoot(agentId), "mods") : null;
+    return settingsManager.isMemfsEnabled(agentId) ? join76(getScopedMemoryFilesystemRoot(agentId), "mods") : null;
   } catch {
     return null;
   }
 }
 function resolveListenerAgentModCacheDirectory(agentId) {
   const cacheKey = createHash13("sha256").update(agentId).digest("hex");
-  return join75(getModCacheDirectory(), "listener-agents", cacheKey);
+  return join76(getModCacheDirectory(), "listener-agents", cacheKey);
 }
 async function ensureListenerAgentModAdapter(runtime, agentId) {
   runtime.agentModAdapters ??= new Map;
@@ -436790,7 +437413,8 @@ function finishClaimedTeleport(runtime, pending, commit, options = {}) {
       agentId: pending.agentId,
       conversationId: pending.conversationId,
       persistTerminalWithoutConsumers: intentRevision !== undefined,
-      expectedInterruptedRevision: intentRevision
+      expectedInterruptedRevision: intentRevision,
+      teleportHandoff: pending.activeTurn
     });
   } catch (error5) {
     abandonTeleportIntent(runtime.listener, pending, intentRevision);
@@ -437407,19 +438031,19 @@ function emitSkillsUpdated(socket, safeSocketSend) {
 }
 async function handleSkillCommand(parsed, socket, safeSocketSend) {
   const {
-    existsSync: existsSync55,
+    existsSync: existsSync56,
     lstatSync: lstatSync3,
     mkdirSync: mkdirSync42,
     rmdirSync: rmdirSync2,
     symlinkSync: symlinkSync2,
     unlinkSync: unlinkSync14
   } = await import("node:fs");
-  const { basename: basename21, join: join76 } = await import("node:path");
-  const lettaHome = process.env.LETTA_HOME || join76(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
-  const globalSkillsDir = join76(lettaHome, "skills");
+  const { basename: basename21, join: join77 } = await import("node:path");
+  const lettaHome = process.env.LETTA_HOME || join77(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
+  const globalSkillsDir = join77(lettaHome, "skills");
   if (parsed.type === "skill_enable") {
     try {
-      if (!existsSync55(parsed.skill_path)) {
+      if (!existsSync56(parsed.skill_path)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
           request_id: parsed.request_id,
@@ -437428,8 +438052,8 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const skillMdPath = join76(parsed.skill_path, "SKILL.md");
-      if (!existsSync55(skillMdPath)) {
+      const skillMdPath = join77(parsed.skill_path, "SKILL.md");
+      if (!existsSync56(skillMdPath)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
           request_id: parsed.request_id,
@@ -437439,9 +438063,9 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         return true;
       }
       const linkName = basename21(parsed.skill_path);
-      const linkPath = join76(globalSkillsDir, linkName);
+      const linkPath = join77(globalSkillsDir, linkName);
       mkdirSync42(globalSkillsDir, { recursive: true });
-      if (existsSync55(linkPath)) {
+      if (existsSync56(linkPath)) {
         const stat12 = lstatSync3(linkPath);
         if (stat12.isSymbolicLink()) {
           if (process.platform === "win32") {
@@ -437482,8 +438106,8 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
   }
   if (parsed.type === "skill_disable") {
     try {
-      const linkPath = join76(globalSkillsDir, parsed.name);
-      if (!existsSync55(linkPath)) {
+      const linkPath = join77(globalSkillsDir, parsed.name);
+      if (!existsSync56(linkPath)) {
         safeSocketSend(socket, {
           type: "skill_disable_response",
           request_id: parsed.request_id,
@@ -438403,7 +439027,7 @@ var init_control_inputs = __esm(async () => {
 });
 
 // src/websocket/terminal-handler.ts
-import { existsSync as existsSync55 } from "node:fs";
+import { existsSync as existsSync56 } from "node:fs";
 import * as os7 from "node:os";
 import WebSocket6 from "ws";
 function getTerminalKey(connectionId, terminalId) {
@@ -438419,7 +439043,7 @@ function getDefaultShell() {
     "/bin/bash"
   ];
   for (const candidate of candidates2) {
-    if (candidate && existsSync55(candidate)) {
+    if (candidate && existsSync56(candidate)) {
       return candidate;
     }
   }
@@ -440373,14 +440997,14 @@ var init_tui_perf = __esm(() => {
 
 // src/cli/helpers/chunk-log.ts
 import {
-  existsSync as existsSync56,
+  existsSync as existsSync57,
   mkdirSync as mkdirSync43,
-  readdirSync as readdirSync22,
+  readdirSync as readdirSync23,
   unlinkSync as unlinkSync14,
   writeFileSync as writeFileSync36
 } from "node:fs";
 import { homedir as homedir41 } from "node:os";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 function truncateStr(value, maxLen) {
   if (value === null || value === undefined)
     return "";
@@ -440444,8 +441068,8 @@ class ChunkLog {
   agentDir = null;
   dirCreated = false;
   init(agentId, sessionId) {
-    this.agentDir = join76(LOG_BASE_DIR, agentId);
-    this.logPath = join76(this.agentDir, `${sessionId}.jsonl`);
+    this.agentDir = join77(LOG_BASE_DIR, agentId);
+    this.logPath = join77(this.agentDir, `${sessionId}.jsonl`);
     this.buffer = [];
     this.dirty = false;
     this.dirCreated = false;
@@ -440474,7 +441098,7 @@ class ChunkLog {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync56(this.agentDir)) {
+      if (!existsSync57(this.agentDir)) {
         mkdirSync43(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
@@ -440499,14 +441123,14 @@ class ChunkLog {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync56(this.agentDir))
+      if (!existsSync57(this.agentDir))
         return;
-      const files = readdirSync22(this.agentDir).filter((f4) => f4.endsWith(".jsonl")).sort();
+      const files = readdirSync23(this.agentDir).filter((f4) => f4.endsWith(".jsonl")).sort();
       if (files.length >= MAX_SESSION_FILES2) {
         const toDelete = files.slice(0, files.length - MAX_SESSION_FILES2 + 1);
         for (const file of toDelete) {
           try {
-            unlinkSync14(join76(this.agentDir, file));
+            unlinkSync14(join77(this.agentDir, file));
           } catch (e2) {
             debugWarn("chunkLog", `Failed to delete old session log ${file}: ${e2 instanceof Error ? e2.message : String(e2)}`);
           }
@@ -440520,7 +441144,7 @@ class ChunkLog {
 var MAX_ENTRIES = 100, CONTENT_TRUNCATE_LEN = 200, MAX_SESSION_FILES2 = 5, LOG_BASE_DIR, chunkLog;
 var init_chunk_log = __esm(() => {
   init_debug();
-  LOG_BASE_DIR = join76(homedir41(), ".letta", "logs", "chunk-logs");
+  LOG_BASE_DIR = join77(homedir41(), ".letta", "logs", "chunk-logs");
   chunkLog = new ChunkLog;
 });
 
@@ -441904,7 +442528,7 @@ function finishListenerTurn(runtime, lease, options) {
     type: "turn_finished",
     turn_id: options.turnId,
     stop_reason: options.stopReason,
-    ...options.terminalConsumerIds?.length ? {
+    ...options.terminalConsumerIds?.length && !options.teleportHandoff ? {
       terminal_consumer_ids: [
         ...new Set(options.terminalConsumerIds)
       ]
@@ -442029,7 +442653,7 @@ function finishListenerTurn(runtime, lease, options) {
       conversation_id: options.conversationId
     });
   }
-  if (mayEmit && options.socket && turnFinishedMessage && preparedTurnFinished) {
+  if (mayEmit && options.socket && turnFinishedMessage && preparedTurnFinished && !options.teleportHandoff) {
     emitDurableTurnFinished(options.socket, runtime, turnFinishedMessage, TO_SUBSCRIBERS, options.turnFinishedStore, preparedTurnFinished);
   }
   if (options.stopReason === "end_turn" || options.stopReason === "cancelled" && transition2.interruptionCause !== "transport") {
@@ -446547,8 +447171,8 @@ var init_turn_approval = __esm(async () => {
 });
 
 // src/agent/attached-repository-git-sync.ts
-import { existsSync as existsSync57 } from "node:fs";
-import { join as join77 } from "node:path";
+import { existsSync as existsSync58 } from "node:fs";
+import { join as join78 } from "node:path";
 async function getPendingCommitCount(path42) {
   const divergence = await getMemoryAheadBehind(path42);
   if (divergence) {
@@ -446578,7 +447202,7 @@ async function syncPendingAttachedRepositoryCommitsUnlocked(params) {
     path: path42,
     permissions: params.repository.permissions ?? "unknown"
   };
-  if (!existsSync57(join77(path42, ".git"))) {
+  if (!existsSync58(join78(path42, ".git"))) {
     return {
       ...resultBase,
       status: "skipped",
@@ -446748,8 +447372,8 @@ var init_attached_repository_git_sync = __esm(() => {
 });
 
 // src/reminders/memory-git-sync.ts
-import { existsSync as existsSync58 } from "node:fs";
-import { join as join78 } from "node:path";
+import { existsSync as existsSync59 } from "node:fs";
+import { join as join79 } from "node:path";
 function formatMemoryRepairInProgressReminder(result3) {
   return `${SYSTEM_REMINDER_OPEN}
 MEMORY REPAIR RUNNING: A background worker is repairing the memory repository.
@@ -446859,7 +447483,7 @@ async function runPostTurnMemorySync(params, dependencies4 = {}) {
   if (memorySyncEnabled) {
     try {
       const memoryDir = getScopedMemoryFilesystemRoot(params.agentId);
-      const release = existsSync58(join78(memoryDir, ".git")) ? await (dependencies4.claimOperation ?? claimMemoryOperation)(memoryDir) : undefined;
+      const release = existsSync59(join79(memoryDir, ".git")) ? await (dependencies4.claimOperation ?? claimMemoryOperation)(memoryDir) : undefined;
       if (release !== null) {
         try {
           const result3 = await syncMemory(params.agentId);
@@ -449098,7 +449722,7 @@ var init_core5 = __esm(() => {
 import { spawn as spawn10 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants6 } from "node:fs";
 import { homedir as homedir42 } from "node:os";
-import { join as join79 } from "node:path";
+import { join as join80 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 async function normalizeCheckpoint(input) {
   const { decoded, bounds, filters } = await decodeCheckpoint(input);
@@ -449122,7 +449746,7 @@ async function decodeCheckpoint(input) {
 }
 async function loadDeepAgentsCheckpoint(checkpoint) {
   validateLocation(checkpoint);
-  const path42 = checkpoint.path ?? join79(homedir42(), ".deepagents", "sessions.db");
+  const path42 = checkpoint.path ?? join80(homedir42(), ".deepagents", "sessions.db");
   const python = checkpoint.pythonExecutable ?? process.env.PYTHON ?? "python3";
   const helper = resolveHelperPath();
   return await new Promise((resolve39, reject2) => {
@@ -449341,8 +449965,8 @@ var init_deepagents = __esm(() => {
 });
 
 // node_modules/@letta-ai/trajectory/dist/adapters/listing-shared.js
-import { readdirSync as readdirSync23, statSync as statSync20 } from "node:fs";
-import { join as join80 } from "node:path";
+import { readdirSync as readdirSync24, statSync as statSync21 } from "node:fs";
+import { join as join81 } from "node:path";
 function sortListings(items3) {
   return items3.sort((left, right) => {
     const l3 = left.updatedAt ?? "";
@@ -449354,7 +449978,7 @@ function sortListings(items3) {
 }
 function safeReadDir(path42) {
   try {
-    return readdirSync23(path42, { withFileTypes: true }).map((entry) => ({
+    return readdirSync24(path42, { withFileTypes: true }).map((entry) => ({
       name: entry.name,
       isDirectory: entry.isDirectory(),
       isFile: entry.isFile()
@@ -449365,7 +449989,7 @@ function safeReadDir(path42) {
 }
 function safeStat(path42) {
   try {
-    const stats = statSync20(path42);
+    const stats = statSync21(path42);
     return { mtimeMs: stats.mtimeMs, sizeBytes: stats.size };
   } catch {
     return;
@@ -449387,7 +450011,7 @@ function collectFiles(root2, extension, depth) {
     return [];
   const collected = [];
   for (const entry of safeReadDir(root2)) {
-    const full = join80(root2, entry.name);
+    const full = join81(root2, entry.name);
     if (entry.isFile && entry.name.endsWith(extension)) {
       collected.push(full);
     } else if (entry.isDirectory) {
@@ -449472,18 +450096,18 @@ var init_listing_shared = __esm(() => {
 
 // node_modules/@letta-ai/trajectory/dist/adapters/claude-code/list.js
 import { homedir as homedir43 } from "node:os";
-import { basename as basename23, join as join81 } from "node:path";
+import { basename as basename23, join as join82 } from "node:path";
 async function listClaudeCodeTrajectories(root2) {
-  const base2 = root2 ?? join81(homedir43(), ".claude", "projects");
+  const base2 = root2 ?? join82(homedir43(), ".claude", "projects");
   const items3 = [];
   for (const project of safeReadDir(base2)) {
     if (!project.isDirectory)
       continue;
-    const projectPath = join81(base2, project.name);
+    const projectPath = join82(base2, project.name);
     for (const entry of safeReadDir(projectPath)) {
       if (!entry.isFile || !entry.name.endsWith(".jsonl"))
         continue;
-      const path42 = join81(projectPath, entry.name);
+      const path42 = join82(projectPath, entry.name);
       const listing = listingFromFile(basename23(entry.name, ".jsonl"), path42);
       if (listing)
         items3.push(listing);
@@ -449497,9 +450121,9 @@ var init_list = __esm(() => {
 
 // node_modules/@letta-ai/trajectory/dist/adapters/codex/list.js
 import { homedir as homedir44 } from "node:os";
-import { basename as basename24, join as join82 } from "node:path";
+import { basename as basename24, join as join83 } from "node:path";
 async function listCodexTrajectories(root2) {
-  const base2 = root2 ?? join82(homedir44(), ".codex", "sessions");
+  const base2 = root2 ?? join83(homedir44(), ".codex", "sessions");
   const items3 = [];
   for (const path42 of collectFiles(base2, ".jsonl", 4)) {
     const listing = listingFromFile(basename24(path42, ".jsonl"), path42);
@@ -449514,7 +450138,7 @@ var init_list2 = __esm(() => {
 
 // node_modules/@letta-ai/trajectory/dist/adapters/deepagents/list.js
 import { homedir as homedir45 } from "node:os";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 async function listDeepAgentsTrajectories(root2) {
   const path42 = resolveStorePath(root2);
   if (!safeStat(path42))
@@ -449535,8 +450159,8 @@ async function listDeepAgentsTrajectories(root2) {
 }
 function resolveStorePath(root2) {
   if (root2 === undefined)
-    return join83(homedir45(), ".deepagents", "sessions.db");
-  return root2.endsWith(".db") ? root2 : join83(root2, "sessions.db");
+    return join84(homedir45(), ".deepagents", "sessions.db");
+  return root2.endsWith(".db") ? root2 : join84(root2, "sessions.db");
 }
 var init_list3 = __esm(() => {
   init_listing_shared();
@@ -449544,7 +450168,7 @@ var init_list3 = __esm(() => {
 
 // node_modules/@letta-ai/trajectory/dist/adapters/hermes/list.js
 import { homedir as homedir46 } from "node:os";
-import { join as join84 } from "node:path";
+import { join as join85 } from "node:path";
 async function listHermesTrajectories(root2) {
   const path42 = resolveStorePath2(root2);
   if (!safeStat(path42))
@@ -449571,8 +450195,8 @@ async function listHermesTrajectories(root2) {
 }
 function resolveStorePath2(root2) {
   if (root2 === undefined)
-    return join84(homedir46(), ".hermes", "state.db");
-  return root2.endsWith(".db") ? root2 : join84(root2, "state.db");
+    return join85(homedir46(), ".hermes", "state.db");
+  return root2.endsWith(".db") ? root2 : join85(root2, "state.db");
 }
 function numeric2(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
@@ -449583,18 +450207,18 @@ var init_list4 = __esm(() => {
 
 // node_modules/@letta-ai/trajectory/dist/adapters/letta-code/list.js
 import { homedir as homedir47 } from "node:os";
-import { join as join85 } from "node:path";
+import { join as join86 } from "node:path";
 async function listLettaCodeTrajectories(root2) {
-  const base2 = root2 ?? join85(homedir47(), ".letta", "transcripts");
+  const base2 = root2 ?? join86(homedir47(), ".letta", "transcripts");
   const items3 = [];
   for (const agent of safeReadDir(base2)) {
     if (!agent.isDirectory)
       continue;
-    const agentPath2 = join85(base2, agent.name);
+    const agentPath2 = join86(base2, agent.name);
     for (const conversation of safeReadDir(agentPath2)) {
       if (!conversation.isDirectory)
         continue;
-      const path42 = join85(agentPath2, conversation.name, "transcript.jsonl");
+      const path42 = join86(agentPath2, conversation.name, "transcript.jsonl");
       const listing = listingFromFile(`${agent.name}/${conversation.name}`, path42);
       if (listing && (listing.sizeBytes ?? 0) > 0)
         items3.push(listing);
@@ -449607,21 +450231,21 @@ var init_list5 = __esm(() => {
 });
 
 // node_modules/@letta-ai/trajectory/dist/adapters/openclaw/list.js
-import { existsSync as existsSync59 } from "node:fs";
+import { existsSync as existsSync60 } from "node:fs";
 import { homedir as homedir48 } from "node:os";
-import { basename as basename25, join as join86 } from "node:path";
+import { basename as basename25, join as join87 } from "node:path";
 async function listOpenClawTrajectories(root2) {
   const base2 = root2 ?? defaultStateDir();
   const items3 = [];
-  const agentsPath = join86(base2, "agents");
+  const agentsPath = join87(base2, "agents");
   for (const agent of safeReadDir(agentsPath)) {
     if (!agent.isDirectory)
       continue;
-    const sessionsPath = join86(agentsPath, agent.name, "sessions");
+    const sessionsPath = join87(agentsPath, agent.name, "sessions");
     for (const entry of safeReadDir(sessionsPath)) {
       if (!entry.isFile || !entry.name.endsWith(".jsonl"))
         continue;
-      const path42 = join86(sessionsPath, entry.name);
+      const path42 = join87(sessionsPath, entry.name);
       const listing = listingFromFile(basename25(entry.name, ".jsonl"), path42);
       if (listing)
         items3.push(listing);
@@ -449633,10 +450257,10 @@ function defaultStateDir() {
   const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
   if (override)
     return override;
-  const current = join86(homedir48(), ".openclaw");
-  if (existsSync59(current))
+  const current = join87(homedir48(), ".openclaw");
+  if (existsSync60(current))
     return current;
-  return join86(homedir48(), ".clawdbot");
+  return join87(homedir48(), ".clawdbot");
 }
 var init_list6 = __esm(() => {
   init_listing_shared();
@@ -449644,14 +450268,14 @@ var init_list6 = __esm(() => {
 
 // node_modules/@letta-ai/trajectory/dist/adapters/openhands/list.js
 import { homedir as homedir49 } from "node:os";
-import { join as join87 } from "node:path";
+import { join as join88 } from "node:path";
 async function listOpenHandsTrajectories(root2) {
-  const base2 = root2 ?? join87(homedir49(), ".openhands", "sessions");
+  const base2 = root2 ?? join88(homedir49(), ".openhands", "sessions");
   const items3 = [];
   for (const entry of safeReadDir(base2)) {
     if (!entry.isDirectory)
       continue;
-    const path42 = join87(base2, entry.name);
+    const path42 = join88(base2, entry.name);
     const facts = safeStat(path42);
     items3.push({
       id: entry.name,
@@ -449897,7 +450521,7 @@ import {
   stat as stat13,
   writeFile as writeFile16
 } from "node:fs/promises";
-import { join as join88 } from "node:path";
+import { join as join89 } from "node:path";
 function buildReflectionSelectorPrompt(options) {
   const lines = [
     'You are selecting conversation transcripts for memory reflection. The transcript candidates path is available as the `$TRANSCRIPT_PATH` env var — read it via Bash (e.g. `wc -c "$TRANSCRIPT_PATH"`). Note: `$TRANSCRIPT_PATH` only expands in shell commands; Edit file_path is literal and does NOT expand env vars.',
@@ -449931,7 +450555,7 @@ async function collectParentMemoryFiles(memoryDir) {
       return a2.name.localeCompare(b3.name);
     });
     for (const entry of sortedEntries) {
-      const entryPath = join88(currentDir, entry.name);
+      const entryPath = join89(currentDir, entry.name);
       const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         await walk3(entryPath, relativePath);
@@ -450347,17 +450971,17 @@ async function writeState(paths, state2) {
 }
 function buildPayloadPath(rootDir, kind) {
   const nonce = Math.random().toString(36).slice(2, 8);
-  return join88(rootDir, `payload-${kind}-${nonce}.json`);
+  return join89(rootDir, `payload-${kind}-${nonce}.json`);
 }
 function getAgentTranscriptRoot(agentId) {
-  return join88(getTranscriptRoot(), sanitizePathSegment2(agentId));
+  return join89(getTranscriptRoot(), sanitizePathSegment2(agentId));
 }
 function getReflectionTranscriptPaths(agentId, conversationId) {
-  const rootDir = join88(getTranscriptRoot(), sanitizePathSegment2(agentId), sanitizePathSegment2(conversationId));
+  const rootDir = join89(getTranscriptRoot(), sanitizePathSegment2(agentId), sanitizePathSegment2(conversationId));
   return {
     rootDir,
-    transcriptPath: join88(rootDir, "transcript.jsonl"),
-    statePath: join88(rootDir, "state.json")
+    transcriptPath: join89(rootDir, "transcript.jsonl"),
+    statePath: join89(rootDir, "state.json")
   };
 }
 async function appendTranscriptDeltaJsonl(agentId, conversationId, lines) {
@@ -450447,7 +451071,7 @@ async function getTranscriptLastUpdatedAt(paths) {
   }
 }
 async function ensureAgentPayloadRoot(agentId) {
-  const root2 = join88(getAgentTranscriptRoot(agentId), "multi-reflection-payloads");
+  const root2 = join89(getAgentTranscriptRoot(agentId), "multi-reflection-payloads");
   await mkdir14(root2, { recursive: true });
   return root2;
 }
@@ -455229,9 +455853,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync60 } from "node:fs";
+import { existsSync as existsSync61 } from "node:fs";
 import { readdir as readdir11, readFile as readFile24 } from "node:fs/promises";
-import { basename as basename27, dirname as dirname33, join as join89 } from "node:path";
+import { basename as basename27, dirname as dirname33, join as join90 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -455242,7 +455866,7 @@ async function getCustomCommands() {
 function refreshCustomCommands() {
   cachedCommands = null;
 }
-async function discoverCustomCommands(projectPath = join89(process.cwd(), COMMANDS_DIR)) {
+async function discoverCustomCommands(projectPath = join90(process.cwd(), COMMANDS_DIR)) {
   const commandsById = new Map;
   const userCommands = await discoverFromDirectory(GLOBAL_COMMANDS_DIR, "user");
   for (const cmd of userCommands) {
@@ -455263,7 +455887,7 @@ async function discoverCustomCommands(projectPath = join89(process.cwd(), COMMAN
   return result3;
 }
 async function discoverFromDirectory(dirPath, source) {
-  if (!existsSync60(dirPath)) {
+  if (!existsSync61(dirPath)) {
     return [];
   }
   const commands = [];
@@ -455274,7 +455898,7 @@ async function findCommandFiles(currentPath, rootPath, commands, source) {
   try {
     const entries2 = await readdir11(currentPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = join89(currentPath, entry.name);
+      const fullPath = join90(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findCommandFiles(fullPath, rootPath, commands, source);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -455359,7 +455983,7 @@ async function findCustomCommand(commandName) {
 }
 var COMMANDS_DIR = ".commands", GLOBAL_COMMANDS_DIR, cachedCommands = null;
 var init_custom = __esm(() => {
-  GLOBAL_COMMANDS_DIR = join89(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
+  GLOBAL_COMMANDS_DIR = join90(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
 });
 
 // src/cli/helpers/doctor-command.ts
@@ -457001,7 +457625,7 @@ function handleMemfsSyncedMemoryProtocolCommand(parsed, context3) {
 }
 var init_memory_command_sync = __esm(async () => {
   init_memfs_sync();
-  await init_memory5();
+  await init_memory6();
 });
 
 // src/websocket/listener/commands/queue.ts
@@ -458052,7 +458676,7 @@ function createListenerMessageHandler(params) {
         return;
       }
       if (parsed.type === "runtime_external_tools_update") {
-        const respond = (success, error5) => {
+        const respond2 = (success, error5) => {
           safeSocketSend(socket, {
             type: "runtime_external_tools_update_response",
             request_id: parsed.request_id,
@@ -458061,11 +458685,11 @@ function createListenerMessageHandler(params) {
           }, "runtime_external_tools_update_response", "runtime_external_tools_update");
         };
         if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
-          respond(false, "Runtime is no longer active");
+          respond2(false, "Runtime is no longer active");
           return;
         }
         updateRuntimeExternalTools(runtime, connectionId, parsed.updates);
-        respond(true);
+        respond2(true);
         return;
       }
       if (parsed.type === "sync") {
@@ -460613,7 +461237,7 @@ var init_client9 = __esm(async () => {
     init_approval(),
     init_agents_conversations(),
     init_cron3(),
-    init_memory5(),
+    init_memory6(),
     init_model_toolset(),
     init_runtime_start(),
     init_settings3(),
@@ -462543,7 +463167,7 @@ __export(exports_app_server, {
   startAppServer: () => startAppServer,
   parseAppServerListenUrl: () => parseAppServerListenUrl
 });
-import { createServer as createServer4 } from "node:http";
+import { createServer as createServer5 } from "node:http";
 import { hostname as hostname4 } from "node:os";
 import WebSocket11, { WebSocketServer } from "ws";
 function getRequiredAddressInfo(server2) {
@@ -462676,7 +463300,7 @@ async function startAppServer(options = {}) {
       closeSocket(socket, 1011, "failed to start connection");
     });
   };
-  const server2 = createServer4((request, response) => {
+  const server2 = createServer5((request, response) => {
     const requestUrl = getRequestUrl(request, listen.host);
     if (request.headers.origin) {
       options.onLog?.(`Rejecting app-server request with Origin header: ${request.url ?? "/"}`);
@@ -463601,11 +464225,9 @@ async function runListenSubcommand(argv) {
             console.log(`[${formatTimestamp3()}] status: ${status}`);
           }
         },
-        onConnected: async () => {
-          await startChannelGateway();
-        },
+        onConnected: () => {},
         onConnectionReady: async (connectedId) => {
-          const ready = await completeListenerConnectionStartup(connectedId, readiness);
+          const ready = await completeListenerConnectionStartup(connectedId, readiness, startChannelGateway);
           if (!ready)
             return;
           sessionLog.log("Local channel listener ready.");
@@ -463708,11 +464330,9 @@ async function runListenSubcommand(argv) {
             }
           },
           onLog: logListenerMessage,
-          onConnected: async () => {
-            await startChannelGateway();
-          },
+          onConnected: () => {},
           onConnectionReady: async (connectedId) => {
-            const ready = await completeListenerConnectionStartup(connectedId, readiness);
+            const ready = await completeListenerConnectionStartup(connectedId, readiness, startChannelGateway);
             if (!ready)
               return;
             sessionLog.log("Connected. Awaiting instructions.");
@@ -463789,9 +464409,12 @@ async function runListenSubcommand(argv) {
             updateStatusCallback?.(status);
           },
           onLog: logListenerMessage,
-          onConnected: async () => {
+          onConnected: () => {},
+          onConnectionReady: async (connectedId) => {
+            const ready = await completeListenerConnectionStartup(connectedId, readiness, startChannelGateway);
+            if (!ready)
+              return;
             sessionLog.log("Connected. Awaiting instructions.");
-            await startChannelGateway();
             clearRetryStatusCallback?.();
             updateStatusCallback?.("idle");
           },
@@ -463888,17 +464511,17 @@ var init_listen = __esm(async () => {
 import { randomUUID as randomUUID51 } from "node:crypto";
 import {
   copyFileSync as copyFileSync3,
-  existsSync as existsSync61,
+  existsSync as existsSync62,
   mkdirSync as mkdirSync44,
-  readdirSync as readdirSync24,
-  readFileSync as readFileSync45,
+  readdirSync as readdirSync25,
+  readFileSync as readFileSync46,
   writeFileSync as writeFileSync37
 } from "node:fs";
-import { join as join90 } from "node:path";
+import { join as join91 } from "node:path";
 function readJsonl(path45) {
-  if (!existsSync61(path45))
+  if (!existsSync62(path45))
     return [];
-  return readFileSync45(path45, "utf8").split(`
+  return readFileSync46(path45, "utf8").split(`
 `).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 function isLegacyUiMessage(value) {
@@ -464177,23 +464800,23 @@ function convertMessages4(messages, mode, nextId2) {
 }
 function migrateLocalBackendTranscripts(input) {
   const storageDir = input.storageDir;
-  const conversationsDir = join90(storageDir, "conversations");
+  const conversationsDir = join91(storageDir, "conversations");
   const result3 = {
     storageDir,
     converted: [],
     skipped: [],
     dryRun: input.dryRun === true
   };
-  if (!existsSync61(conversationsDir))
+  if (!existsSync62(conversationsDir))
     return result3;
-  for (const name of readdirSync24(conversationsDir)) {
-    const conversationDir = join90(conversationsDir, name);
-    const messagesPath = join90(conversationDir, "messages.jsonl");
-    const manifestPath = join90(conversationDir, "manifest.json");
-    const hasManifest = existsSync61(manifestPath);
+  for (const name of readdirSync25(conversationsDir)) {
+    const conversationDir = join91(conversationsDir, name);
+    const messagesPath = join91(conversationDir, "messages.jsonl");
+    const manifestPath = join91(conversationDir, "manifest.json");
+    const hasManifest = existsSync62(manifestPath);
     const existingManifest = hasManifest ? (() => {
       try {
-        return JSON.parse(readFileSync45(manifestPath, "utf8"));
+        return JSON.parse(readFileSync46(manifestPath, "utf8"));
       } catch {
         return;
       }
@@ -464232,11 +464855,11 @@ function migrateLocalBackendTranscripts(input) {
     const backupPath = `${messagesPath}.pre-pi-backup-${timestampSuffix()}`;
     if (!input.dryRun) {
       copyFileSync3(messagesPath, backupPath);
-      const conversationPath = join90(conversationDir, "conversation.json");
+      const conversationPath = join91(conversationDir, "conversation.json");
       let conversation;
-      if (existsSync61(conversationPath)) {
+      if (existsSync62(conversationPath)) {
         try {
-          conversation = JSON.parse(readFileSync45(conversationPath, "utf8"));
+          conversation = JSON.parse(readFileSync46(conversationPath, "utf8"));
         } catch {
           conversation = undefined;
         }
@@ -464428,9 +465051,9 @@ var init_memory_tokens = __esm(() => {
 });
 
 // src/cli/subcommands/memory.ts
-import { cpSync, existsSync as existsSync62, mkdirSync as mkdirSync45, rmSync as rmSync21, statSync as statSync21 } from "node:fs";
+import { cpSync, existsSync as existsSync63, mkdirSync as mkdirSync45, rmSync as rmSync21, statSync as statSync22 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
-import { dirname as dirname34, join as join91 } from "node:path";
+import { dirname as dirname34, join as join92 } from "node:path";
 import { parseArgs as parseArgs11 } from "node:util";
 function printUsage8() {
   console.log(`
@@ -464490,7 +465113,7 @@ function formatBackupTimestamp(date5 = new Date) {
 }
 async function listBackups(agentId) {
   const agentRoot = getAgentRoot(agentId);
-  if (!existsSync62(agentRoot)) {
+  if (!existsSync63(agentRoot)) {
     return [];
   }
   const entries2 = await readdir12(agentRoot, { withFileTypes: true });
@@ -464500,10 +465123,10 @@ async function listBackups(agentId) {
       continue;
     if (!entry.name.startsWith("memory-backup-"))
       continue;
-    const path45 = join91(agentRoot, entry.name);
+    const path45 = join92(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat15 = statSync21(path45);
+      const stat15 = statSync22(path45);
       createdAt = stat15.mtime.toISOString();
     } catch {
       createdAt = null;
@@ -464517,7 +465140,7 @@ function resolveBackupPath(agentId, from) {
   if (from.startsWith("/") || /^[A-Za-z]:[/\\]/.test(from)) {
     return from;
   }
-  return join91(getAgentRoot(agentId), from);
+  return join92(getAgentRoot(agentId), from);
 }
 async function runMemorySubcommand(argv, deps = {}) {
   let parsed;
@@ -464595,14 +465218,14 @@ async function runMemorySubcommand(argv, deps = {}) {
     }
     if (action3 === "backup") {
       const root2 = getMemoryRoot(agentId);
-      if (!existsSync62(root2)) {
+      if (!existsSync63(root2)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
       const agentRoot = getAgentRoot(agentId);
       const backupName = `memory-backup-${formatBackupTimestamp()}`;
-      const backupPath = join91(agentRoot, backupName);
-      if (existsSync62(backupPath)) {
+      const backupPath = join92(agentRoot, backupName);
+      if (existsSync63(backupPath)) {
         console.error(`Backup already exists at ${backupPath}`);
         return 1;
       }
@@ -464626,11 +465249,11 @@ async function runMemorySubcommand(argv, deps = {}) {
         return 1;
       }
       const backupPath = resolveBackupPath(agentId, from);
-      if (!existsSync62(backupPath)) {
+      if (!existsSync63(backupPath)) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat15 = statSync21(backupPath);
+      const stat15 = statSync22(backupPath);
       if (!stat15.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
@@ -464648,12 +465271,12 @@ async function runMemorySubcommand(argv, deps = {}) {
         return 1;
       }
       const root2 = getMemoryRoot(agentId);
-      if (!existsSync62(root2)) {
+      if (!existsSync63(root2)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
-      if (existsSync62(out)) {
-        const stat15 = statSync21(out);
+      if (existsSync63(out)) {
+        const stat15 = statSync22(out);
         if (stat15.isDirectory()) {
           const contents = await readdir12(out);
           if (contents.length > 0) {
@@ -464680,7 +465303,7 @@ async function runMemorySubcommand(argv, deps = {}) {
   return 1;
 }
 var MEMORY_OPTIONS;
-var init_memory6 = __esm(() => {
+var init_memory7 = __esm(() => {
   init_memory_filesystem2();
   init_memory_git();
   init_paths();
@@ -464701,22 +465324,22 @@ var init_memory6 = __esm(() => {
 });
 
 // src/backend/local/transcript-search.ts
-import { existsSync as existsSync63, readdirSync as readdirSync25, readFileSync as readFileSync46, statSync as statSync22 } from "node:fs";
-import { join as join92 } from "node:path";
+import { existsSync as existsSync64, readdirSync as readdirSync26, readFileSync as readFileSync47, statSync as statSync23 } from "node:fs";
+import { join as join93 } from "node:path";
 function readJsonFile3(path45) {
-  if (!existsSync63(path45))
+  if (!existsSync64(path45))
     return;
   try {
-    return JSON.parse(readFileSync46(path45, "utf8"));
+    return JSON.parse(readFileSync47(path45, "utf8"));
   } catch {
     return;
   }
 }
 function readJsonlFile2(path45) {
-  if (!existsSync63(path45))
+  if (!existsSync64(path45))
     return [];
   try {
-    return readFileSync46(path45, "utf8").split(`
+    return readFileSync47(path45, "utf8").split(`
 `).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
   } catch {
     return [];
@@ -464957,11 +465580,11 @@ function collectConversationMessages(input) {
     return [];
   if (input.conversationId && conversation.id !== input.conversationId)
     return [];
-  const messagesPath = join92(conversationDir, "messages.jsonl");
+  const messagesPath = join93(conversationDir, "messages.jsonl");
   const rows = readJsonlFile2(messagesPath);
   if (rows.length === 0)
     return [];
-  const manifest2 = readJsonFile3(join92(conversationDir, "manifest.json"));
+  const manifest2 = readJsonFile3(join93(conversationDir, "manifest.json"));
   const format5 = transcriptFormat(manifest2, rows);
   if (!format5)
     return [];
@@ -464990,11 +465613,11 @@ function collectConversationMessages(input) {
   }).filter((record6) => record6.tokens.length > 0);
 }
 function conversationDirectories(storageDir) {
-  const conversationsDir = join92(storageDir, "conversations");
-  if (!existsSync63(conversationsDir))
+  const conversationsDir = join93(storageDir, "conversations");
+  if (!existsSync64(conversationsDir))
     return [];
   try {
-    return readdirSync25(conversationsDir).map((entry) => join92(conversationsDir, entry)).filter((entryPath) => statSync22(entryPath).isDirectory());
+    return readdirSync26(conversationsDir).map((entry) => join93(conversationsDir, entry)).filter((entryPath) => statSync23(entryPath).isDirectory());
   } catch {
     return [];
   }
@@ -465021,7 +465644,7 @@ function searchLocalTranscriptMessages(storageDir, body3, options = {}) {
   const endDate = typeof body3.end_date === "string" ? body3.end_date : undefined;
   const includeHidden = body3.include_hidden === true;
   const records2 = conversationDirectories(storageDir).flatMap((conversationDir) => {
-    const conversation = conversationSearchRecord(readJsonFile3(join92(conversationDir, "conversation.json")));
+    const conversation = conversationSearchRecord(readJsonFile3(join93(conversationDir, "conversation.json")));
     if (!conversation)
       return [];
     if (conversation.hidden && !includeHidden)
@@ -465905,12 +466528,12 @@ var init_model2 = __esm(() => {
 import { spawn as spawn13 } from "node:child_process";
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync64,
+  existsSync as existsSync65,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync46,
   mkdtempSync as mkdtempSync5,
-  readdirSync as readdirSync26,
-  readFileSync as readFileSync47,
+  readdirSync as readdirSync27,
+  readFileSync as readFileSync48,
   renameSync as renameSync12,
   rmSync as rmSync22,
   writeFileSync as writeFileSync38
@@ -465929,7 +466552,7 @@ function isPathInsideOrEqual2(childPath, parentPath) {
 function readPackageJson(packageJsonPath) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync47(packageJsonPath, "utf8"));
+    parsed = JSON.parse(readFileSync48(packageJsonPath, "utf8"));
   } catch (error5) {
     throw new Error(`Could not read package.json: ${error5 instanceof Error ? error5.message : String(error5)}`);
   }
@@ -466050,7 +466673,7 @@ function validatePackageSource(packageDirectory) {
 }
 function copyPackageDirectory(sourceRoot, targetRoot) {
   mkdirSync46(targetRoot, { recursive: true });
-  for (const entry of readdirSync26(sourceRoot, { withFileTypes: true })) {
+  for (const entry of readdirSync27(sourceRoot, { withFileTypes: true })) {
     if (SKIPPED_PACKAGE_COPY_NAMES.has(entry.name))
       continue;
     const sourcePath = path45.join(sourceRoot, entry.name);
@@ -466082,7 +466705,7 @@ function shouldSkipDependencyPath(relativeParts, installedPackageName) {
 function copyDependencyDirectoryFiltered(params) {
   let copied = false;
   const relativeParts = params.relativeParts ?? [];
-  for (const entry of readdirSync26(params.sourceRoot, { withFileTypes: true })) {
+  for (const entry of readdirSync27(params.sourceRoot, { withFileTypes: true })) {
     const nextRelativeParts = [...relativeParts, entry.name];
     if (shouldSkipDependencyPath(nextRelativeParts, params.installedPackageName)) {
       continue;
@@ -466114,7 +466737,7 @@ function copyDependencyDirectoryFiltered(params) {
   return copied;
 }
 function copyDependencyNodeModules(params) {
-  if (!existsSync64(params.sourceNodeModulesDirectory))
+  if (!existsSync65(params.sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     installedPackageName: params.installedPackageName,
@@ -466124,7 +466747,7 @@ function copyDependencyNodeModules(params) {
 }
 function copyPackageInternalNodeModules(params) {
   const sourceNodeModulesDirectory = path45.join(params.packageDirectory, "node_modules");
-  if (!existsSync64(sourceNodeModulesDirectory))
+  if (!existsSync65(sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     sourceRoot: sourceNodeModulesDirectory,
@@ -466146,12 +466769,12 @@ function removeIfExists(targetPath) {
 }
 function restoreDestination(params) {
   rmSync22(params.destinationRoot, { force: true, recursive: true });
-  if (params.backupRoot && existsSync64(params.backupRoot)) {
+  if (params.backupRoot && existsSync65(params.backupRoot)) {
     renameSync12(params.backupRoot, params.destinationRoot);
   }
 }
 function restoreDestinationIfNeeded(params) {
-  if (!params.backupRoot || !existsSync64(params.backupRoot)) {
+  if (!params.backupRoot || !existsSync65(params.backupRoot)) {
     rmSync22(params.destinationRoot, { force: true, recursive: true });
     return;
   }
@@ -466192,7 +466815,7 @@ function installPreparedManagedModPackage(params) {
         targetPackageRoot: stagingRoot
       });
     }
-    if (existsSync64(destinationRoot)) {
+    if (existsSync65(destinationRoot)) {
       backupRoot = makeSiblingTempDirectory(destinationRoot, "backup");
       rmSync22(backupRoot, { force: true, recursive: true });
       renameSync12(destinationRoot, backupRoot);
@@ -466477,7 +467100,7 @@ function hasRuntimeDependencies(packageJson) {
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path45.join(packageDirectory, "package.json");
-  if (!existsSync64(packageJsonPath))
+  if (!existsSync65(packageJsonPath))
     return null;
   return readPackageJson(packageJsonPath);
 }
@@ -466491,13 +467114,13 @@ function isRegularModFile(filePath) {
 }
 function inferCompatibilityModEntries(packageDirectory) {
   const modsDirectory = path45.join(packageDirectory, "mods");
-  if (existsSync64(modsDirectory)) {
+  if (existsSync65(modsDirectory)) {
     const stats = lstatSync3(modsDirectory);
     if (stats.isSymbolicLink()) {
       throw new Error(`Package mods directory must not be a symlink: mods`);
     }
     if (stats.isDirectory()) {
-      const entries2 = readdirSync26(modsDirectory, { withFileTypes: true }).filter((entry) => entry.isFile() && isModFileExtension(path45.extname(entry.name))).map((entry) => `mods/${entry.name}`).sort();
+      const entries2 = readdirSync27(modsDirectory, { withFileTypes: true }).filter((entry) => entry.isFile() && isModFileExtension(path45.extname(entry.name))).map((entry) => `mods/${entry.name}`).sort();
       if (entries2.length > 0)
         return entries2;
     }
@@ -466766,7 +467389,7 @@ var init_package_installer = __esm(() => {
 // src/mods/package-scaffolder.ts
 import {
   copyFileSync as copyFileSync5,
-  existsSync as existsSync65,
+  existsSync as existsSync66,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync47,
   rmSync as rmSync23,
@@ -466859,7 +467482,7 @@ function scaffoldLocalModPackage(options) {
   const sourceFile = readSourceFile(options.sourceFile);
   const packageName = assertValidPackageName(options.packageName);
   const outputDirectory = path46.resolve(options.outputDirectory ?? defaultOutputDirectory(sourceFile, packageName));
-  if (existsSync65(outputDirectory)) {
+  if (existsSync66(outputDirectory)) {
     throw new Error(`Output directory already exists: ${outputDirectory}`);
   }
   const modFileName = path46.basename(sourceFile);
@@ -466901,7 +467524,7 @@ var init_package_scaffolder = __esm(() => {
 });
 
 // src/cli/subcommands/mods.ts
-import { dirname as dirname35, join as join93 } from "node:path";
+import { dirname as dirname35, join as join94 } from "node:path";
 import { parseArgs as parseArgs14 } from "node:util";
 function printUsage11() {
   console.log(`
@@ -466940,7 +467563,7 @@ function getExplicitAgentId(values4) {
   return typeof explicitAgent === "string" && explicitAgent.trim() ? explicitAgent.trim() : null;
 }
 function getAgentModsDirectory(agentId) {
-  return join93(getScopedMemoryFilesystemRoot(agentId), "mods");
+  return join94(getScopedMemoryFilesystemRoot(agentId), "mods");
 }
 function directFilesForSource(source) {
   return source.files.filter((file) => dirname35(file) === source.root);
@@ -468480,8 +469103,8 @@ var init_setup7 = __esm(async () => {
 });
 
 // src/cli/subcommands/shared-memory.ts
-import { existsSync as existsSync66 } from "node:fs";
-import { join as join94 } from "node:path";
+import { existsSync as existsSync67 } from "node:fs";
+import { join as join95 } from "node:path";
 import { parseArgs as parseArgs19 } from "node:util";
 function printUsage16() {
   console.log(`
@@ -468673,7 +469296,7 @@ async function runSharedMemorySubcommand(argv, deps = {}) {
         invalidateClientSkills(agentId);
         const recompileError = await recompileAndReportFailure(recompileAgent, agentId);
         const mountDir = getRepositoryMountDir(agentId, repository.name);
-        const mounted = existsSync66(join94(mountDir, ".git"));
+        const mounted = existsSync67(join95(mountDir, ".git"));
         console.log(JSON.stringify({
           attached: true,
           repository: { id: repository.id, name: repository.name },
@@ -470202,16 +470825,16 @@ var init_AgentSelector = __esm(async () => {
 // src/cli/subcommands/skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync67,
+  existsSync as existsSync68,
   mkdtempSync as mkdtempSync6,
-  readFileSync as readFileSync48,
+  readFileSync as readFileSync49,
   rmSync as rmSync24,
-  statSync as statSync23,
+  statSync as statSync24,
   writeFileSync as writeFileSync40
 } from "node:fs";
 import { mkdir as mkdir15, readdir as readdir13 } from "node:fs/promises";
 import { tmpdir as tmpdir14 } from "node:os";
-import { basename as basename29, dirname as dirname36, join as join95, normalize as normalize4, resolve as resolve41, sep as sep7 } from "node:path";
+import { basename as basename29, dirname as dirname36, join as join96, normalize as normalize4, resolve as resolve41, sep as sep8 } from "node:path";
 import { parseArgs as parseArgs20, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
 function printUsage17() {
   console.log(`
@@ -470503,14 +471126,14 @@ async function resolveBranchAndSubdir(location) {
 }
 async function cloneSkillSource(location) {
   const resolvedLocation = await resolveBranchAndSubdir(location);
-  const tmpDir = mkdtempSync6(join95(tmpdir14(), "letta-skill-install-"));
+  const tmpDir = mkdtempSync6(join96(tmpdir14(), "letta-skill-install-"));
   const args = ["clone", "--depth", "1"];
   if (resolvedLocation.branch) {
     args.push("--branch", resolvedLocation.branch);
   }
   args.push(resolvedLocation.repoUrl, tmpDir);
   await execFile22("git", args, { timeout: 120000 });
-  const sourceDir = resolvedLocation.subdir ? join95(tmpDir, resolvedLocation.subdir) : tmpDir;
+  const sourceDir = resolvedLocation.subdir ? join96(tmpDir, resolvedLocation.subdir) : tmpDir;
   return { tmpDir, sourceDir };
 }
 function assertDirectSkillFileSize(receivedBytes, maxBytes) {
@@ -470565,11 +471188,11 @@ async function downloadDirectSkillFileSource(location, options = {}) {
     throw new Error(`Direct skill file download failed for ${location.url}: ${response.status}`);
   }
   const skillText = await readResponseTextWithLimit(response, MAX_DIRECT_SKILL_FILE_BYTES);
-  const tmpDir = mkdtempSync6(join95(tmpdir14(), "letta-direct-skill-"));
+  const tmpDir = mkdtempSync6(join96(tmpdir14(), "letta-direct-skill-"));
   try {
-    const sourceDir = join95(tmpDir, "skill");
+    const sourceDir = join96(tmpDir, "skill");
     await mkdir15(sourceDir, { recursive: true });
-    writeFileSync40(join95(sourceDir, "SKILL.md"), skillText, "utf8");
+    writeFileSync40(join96(sourceDir, "SKILL.md"), skillText, "utf8");
     return { tmpDir, sourceDir };
   } catch (error5) {
     rmSync24(tmpDir, { recursive: true, force: true });
@@ -470610,9 +471233,9 @@ function assertSafeZipMember(name) {
 }
 async function downloadClawHubSkillSource(location) {
   const version3 = await resolveClawHubVersion(location);
-  const tmpDir = mkdtempSync6(join95(tmpdir14(), "letta-clawhub-skill-"));
-  const zipPath = join95(tmpDir, "skill.zip");
-  const sourceDir = join95(tmpDir, "skill");
+  const tmpDir = mkdtempSync6(join96(tmpdir14(), "letta-clawhub-skill-"));
+  const zipPath = join96(tmpDir, "skill.zip");
+  const sourceDir = join96(tmpDir, "skill");
   await mkdir15(sourceDir, { recursive: true });
   const url2 = new URL(`${CLAWHUB_API_BASE_URL}/download`);
   url2.searchParams.set("slug", location.slug);
@@ -470639,7 +471262,7 @@ async function downloadClawHubSkillSource(location) {
 function assertInside(parent, child) {
   const parentPath = resolve41(parent);
   const childPath = resolve41(child);
-  if (childPath !== parentPath && !childPath.startsWith(`${parentPath}${sep7}`)) {
+  if (childPath !== parentPath && !childPath.startsWith(`${parentPath}${sep8}`)) {
     throw new Error(`Resolved path is outside target directory: ${child}`);
   }
 }
@@ -470651,7 +471274,7 @@ function sanitizeSkillName(name) {
   return trimmed;
 }
 function getSkillName(sourceDir) {
-  const skillMd = readFileSync48(join95(sourceDir, "SKILL.md"), "utf8");
+  const skillMd = readFileSync49(join96(sourceDir, "SKILL.md"), "utf8");
   const { frontmatter } = parseFrontmatter(skillMd);
   const frontmatterName = frontmatter.name;
   const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename29(sourceDir);
@@ -470660,18 +471283,18 @@ function getSkillName(sourceDir) {
 async function installSkillDirectory(params) {
   const sourceDir = resolve41(params.sourceDir);
   const memoryDir = resolve41(params.memoryDir);
-  const skillMdPath = join95(sourceDir, "SKILL.md");
-  if (!existsSync67(skillMdPath)) {
+  const skillMdPath = join96(sourceDir, "SKILL.md");
+  if (!existsSync68(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
-  if (!statSync23(sourceDir).isDirectory()) {
+  if (!statSync24(sourceDir).isDirectory()) {
     throw new Error(`Skill source is not a directory: ${sourceDir}`);
   }
   const name = getSkillName(sourceDir);
-  const skillsDir = join95(memoryDir, "skills");
-  const targetPath = join95(skillsDir, name);
+  const skillsDir = join96(memoryDir, "skills");
+  const targetPath = join96(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (existsSync67(targetPath)) {
+  if (existsSync68(targetPath)) {
     if (!params.force) {
       throw new Error(`Skill "${name}" already exists at ${targetPath}. Re-run with --force to replace it.`);
     }
@@ -470686,22 +471309,22 @@ async function installSkillDirectory(params) {
 }
 async function listSkillDirectories(params) {
   const memoryDir = resolve41(params.memoryDir);
-  const skillsDir = join95(memoryDir, "skills");
-  if (!existsSync67(skillsDir))
+  const skillsDir = join96(memoryDir, "skills");
+  if (!existsSync68(skillsDir))
     return [];
   const entries2 = await readdir13(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries2) {
     if (!entry.isDirectory())
       continue;
-    const skillDir = join95(skillsDir, entry.name);
-    const skillMdPath = join95(skillDir, "SKILL.md");
-    if (!existsSync67(skillMdPath))
+    const skillDir = join96(skillsDir, entry.name);
+    const skillMdPath = join96(skillDir, "SKILL.md");
+    if (!existsSync68(skillMdPath))
       continue;
     let name = entry.name;
     let description;
     try {
-      const skillMd = readFileSync48(skillMdPath, "utf8");
+      const skillMd = readFileSync49(skillMdPath, "utf8");
       const { frontmatter } = parseFrontmatter(skillMd);
       if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
         name = frontmatter.name.trim();
@@ -470716,14 +471339,14 @@ async function listSkillDirectories(params) {
 }
 async function deleteSkillDirectory(params) {
   const memoryDir = resolve41(params.memoryDir);
-  const skillsDir = join95(memoryDir, "skills");
+  const skillsDir = join96(memoryDir, "skills");
   const name = sanitizeSkillName(params.name);
-  const targetPath = join95(skillsDir, name);
+  const targetPath = join96(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (!existsSync67(targetPath)) {
+  if (!existsSync68(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
   }
-  if (!statSync23(targetPath).isDirectory()) {
+  if (!statSync24(targetPath).isDirectory()) {
     throw new Error(`Skill path is not a directory: ${targetPath}`);
   }
   rmSync24(targetPath, { recursive: true, force: true });
@@ -470769,7 +471392,7 @@ async function installSkill(specifier, agentId, force) {
     tmpDir = downloaded.tmpDir;
     const sourceDir = resolve41(downloaded.sourceDir);
     assertInside(tmpDir, sourceDir);
-    if (!existsSync67(sourceDir)) {
+    if (!existsSync68(sourceDir)) {
       const missingPath = source.type === "git" ? source.location.subdir ?? "." : source.type === "direct-file" ? source.location.url : source.location.slug;
       throw new Error(`Skill path not found: ${missingPath}`);
     }
@@ -471304,7 +471927,7 @@ var init_teleport2 = __esm(() => {
 
 // src/cli/subcommands/trajectories/readers.ts
 import { readdir as readdir14, readFile as readFile27, stat as stat16 } from "node:fs/promises";
-import { join as join96 } from "node:path";
+import { join as join97 } from "node:path";
 async function loadSessionTranscript(item) {
   const stats = await stat16(item.path);
   if (stats.isDirectory()) {
@@ -471316,13 +471939,13 @@ async function loadSessionTranscript(item) {
   return readFile27(item.path, "utf-8");
 }
 async function assembleEventDirectory(sessionDir) {
-  const eventsSubdir = join96(sessionDir, "events");
+  const eventsSubdir = join97(sessionDir, "events");
   const eventsDir = (await stat16(eventsSubdir).catch(() => null))?.isDirectory() ? eventsSubdir : sessionDir;
   const names2 = (await readdir14(eventsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a2, b3) => Number.parseInt(a2, 10) - Number.parseInt(b3, 10) || a2.localeCompare(b3));
   if (names2.length === 0) {
     throw new Error(`No event files found in ${eventsDir}`);
   }
-  const events = await Promise.all(names2.map(async (name) => JSON.parse(await readFile27(join96(eventsDir, name), "utf-8"))));
+  const events = await Promise.all(names2.map(async (name) => JSON.parse(await readFile27(join97(eventsDir, name), "utf-8"))));
   return JSON.stringify(events);
 }
 async function openReadOnlyDatabase(path47) {
@@ -471400,7 +472023,7 @@ import {
   stat as stat17,
   writeFile as writeFile19
 } from "node:fs/promises";
-import { basename as basename30, join as join97 } from "node:path";
+import { basename as basename30, join as join98 } from "node:path";
 function fileTimestamp(startedAt) {
   if (!startedAt)
     return "unknown-date";
@@ -471470,7 +472093,7 @@ async function prepareOutDir(outDir) {
       throw new Error(`--out ${outDir} is not empty and has no ${MANIFEST_NAME}; refusing to overwrite a directory this tool did not create`);
     }
     for (const entry of entries2) {
-      await rm12(join97(outDir, entry), { recursive: true, force: true });
+      await rm12(join98(outDir, entry), { recursive: true, force: true });
     }
   } catch (error5) {
     if (error5.code !== "ENOENT")
@@ -471513,14 +472136,14 @@ async function runTrajectoryExport(options) {
       }
       const sessionId = sessionHash(source, id2);
       const base2 = `${fileTimestamp(stats.startedAt)}_${sessionId}`;
-      let file = join97(source, `${base2}.json`);
+      let file = join98(source, `${base2}.json`);
       for (let suffix = 2;usedFiles.has(file); suffix += 1) {
-        file = join97(source, `${base2}-${suffix}.json`);
+        file = join98(source, `${base2}-${suffix}.json`);
       }
       usedFiles.add(file);
       const body3 = JSON.stringify(records2);
-      await mkdir16(join97(options.outDir, source), { recursive: true });
-      await writeFile19(join97(options.outDir, file), body3, "utf-8");
+      await mkdir16(join98(options.outDir, source), { recursive: true });
+      await writeFile19(join98(options.outDir, file), body3, "utf-8");
       counts.exported += 1;
       manifest2.sessions.push({
         source,
@@ -471574,7 +472197,7 @@ async function runTrajectoryExport(options) {
     await exportCheckpoint(checkpoint, `${basename30(checkpoint.path)}-${checkpoint.threadId}`);
   }
   manifest2.sessions.sort((a2, b3) => (a2.startedAt ?? "").localeCompare(b3.startedAt ?? ""));
-  await writeFile19(join97(options.outDir, MANIFEST_NAME), JSON.stringify(manifest2, null, 2), "utf-8");
+  await writeFile19(join98(options.outDir, MANIFEST_NAME), JSON.stringify(manifest2, null, 2), "utf-8");
   return manifest2;
 }
 var MANIFEST_NAME = "manifest.json", FIRST_PROMPT_MAX_CHARS = 200, LIST_PAGE_LIMIT = 1000;
@@ -471586,13 +472209,13 @@ var init_export = __esm(() => {
 
 // src/cli/subcommands/trajectories/review.ts
 import { readFile as readFile29 } from "node:fs/promises";
-import { isAbsolute as isAbsolute26, join as join98 } from "node:path";
+import { isAbsolute as isAbsolute26, join as join99 } from "node:path";
 async function readManifest(dir) {
   let raw2;
   try {
-    raw2 = await readFile29(join98(dir, "manifest.json"), "utf-8");
+    raw2 = await readFile29(join99(dir, "manifest.json"), "utf-8");
   } catch {
-    throw new Error(`No manifest at ${join98(dir, "manifest.json")}. Run: letta trajectories export --out ${dir}`);
+    throw new Error(`No manifest at ${join99(dir, "manifest.json")}. Run: letta trajectories export --out ${dir}`);
   }
   return JSON.parse(raw2);
 }
@@ -471601,7 +472224,7 @@ function filterSessions(sessions3, filter3) {
 }
 async function resolveSessionFile(dir, target2) {
   if (target2.endsWith(".json")) {
-    const direct = isAbsolute26(target2) ? target2 : join98(dir, target2);
+    const direct = isAbsolute26(target2) ? target2 : join99(dir, target2);
     try {
       await readFile29(direct, "utf-8");
       return direct;
@@ -471612,7 +472235,7 @@ async function resolveSessionFile(dir, target2) {
   if (!entry) {
     throw new Error(`No session "${target2}" in ${dir} (pass a file path, a manifest-relative file, or a sessionId)`);
   }
-  return join98(dir, entry.file);
+  return join99(dir, entry.file);
 }
 function stamp(timestamp) {
   return (timestamp ?? "").slice(0, 19);
@@ -471655,7 +472278,7 @@ async function searchSessions(dir, keyword, options = {}) {
   for (const session2 of filterSessions(manifest2.sessions, options)) {
     let records2;
     try {
-      records2 = JSON.parse(await readFile29(join98(dir, session2.file), "utf-8"));
+      records2 = JSON.parse(await readFile29(join99(dir, session2.file), "utf-8"));
     } catch {
       continue;
     }
@@ -475019,7 +475642,7 @@ var init_message_channel_gateway_tool = __esm(() => {
 });
 
 // src/channels/custom/scaffolding.ts
-import { existsSync as existsSync68, mkdirSync as mkdirSync48, rmSync as rmSync25, writeFileSync as writeFileSync41 } from "node:fs";
+import { existsSync as existsSync69, mkdirSync as mkdirSync48, rmSync as rmSync25, writeFileSync as writeFileSync41 } from "node:fs";
 function removeUserPlugin(channelId) {
   if (FIRST_PARTY_SET.has(channelId)) {
     return;
@@ -475028,7 +475651,7 @@ function removeUserPlugin(channelId) {
     return;
   }
   const channelDir = getChannelDir(channelId);
-  if (!existsSync68(channelDir)) {
+  if (!existsSync69(channelDir)) {
     return;
   }
   try {
@@ -476770,7 +477393,7 @@ var init_router = __esm(async () => {
   init_feedback3();
   init_local_backend2();
   init_mcp();
-  init_memory6();
+  init_memory7();
   init_messages10();
   init_model2();
   init_permissions2();
@@ -477908,7 +478531,7 @@ function resolveHeadlessMemfsPolicy(options) {
 }
 
 // src/headless-mod-adapter.ts
-import { join as join99 } from "node:path";
+import { join as join100 } from "node:path";
 function isHeadlessMemfsEnabled(agentId) {
   try {
     return settingsManager.isMemfsEnabled(agentId);
@@ -477979,7 +478602,7 @@ function createHeadlessModContext(options) {
   };
 }
 function createHeadlessModAdapter(options) {
-  const agentModsDirectory = isHeadlessMemfsEnabled(options.agent.id) ? join99(getScopedMemoryFilesystemRoot(options.agent.id), "mods") : undefined;
+  const agentModsDirectory = isHeadlessMemfsEnabled(options.agent.id) ? join100(getScopedMemoryFilesystemRoot(options.agent.id), "mods") : undefined;
   return createModAdapter({
     ...agentModsDirectory ? { agentModsDirectory } : {},
     ...options.cacheDirectory ? { cacheDirectory: options.cacheDirectory } : {},
@@ -482649,10 +483272,10 @@ var init_cli_mod_context = __esm(() => {
 
 // src/cli/helpers/reflection-arena-hf-upload.ts
 import { execFile as execFileCb5 } from "node:child_process";
-import { existsSync as existsSync70 } from "node:fs";
+import { existsSync as existsSync71 } from "node:fs";
 import { appendFile as appendFile2, chmod, mkdir as mkdir17, writeFile as writeFile20 } from "node:fs/promises";
 import { homedir as homedir53 } from "node:os";
-import { join as join101 } from "node:path";
+import { join as join102 } from "node:path";
 import { promisify as promisify20 } from "node:util";
 function buildGitEnv(token2, askpassPath) {
   return {
@@ -482688,7 +483311,7 @@ async function runGit6(cwd2, args, env6) {
   }
 }
 async function writeGitAskpass(repoRoot) {
-  const askpassPath = join101(repoRoot, "hf-askpass.sh");
+  const askpassPath = join102(repoRoot, "hf-askpass.sh");
   await writeFile20(askpassPath, [
     "#!/bin/sh",
     'case "$1" in',
@@ -482703,7 +483326,7 @@ async function writeGitAskpass(repoRoot) {
 }
 async function prepareHfRepo(env6) {
   await mkdir17(HF_CACHE_ROOT, { recursive: true });
-  if (!existsSync70(join101(HF_REPO_DIR, ".git"))) {
+  if (!existsSync71(join102(HF_REPO_DIR, ".git"))) {
     await runGit6(HF_CACHE_ROOT, ["clone", "--depth", "1", HF_REPO_URL, HF_REPO_DIR], env6);
     return HF_REPO_DIR;
   }
@@ -482738,8 +483361,8 @@ async function maybeUploadReflectionArenaChoiceToHf(row) {
   const env6 = buildGitEnv(token2, askpassPath);
   try {
     const repoDir = await prepareHfRepo(env6);
-    await mkdir17(join101(repoDir, "data"), { recursive: true });
-    await appendFile2(join101(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
+    await mkdir17(join102(repoDir, "data"), { recursive: true });
+    await appendFile2(join102(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
 `, {
       encoding: "utf-8"
     });
@@ -482767,8 +483390,8 @@ var init_reflection_arena_hf_upload = __esm(() => {
   init_version();
   execFile23 = promisify20(execFileCb5);
   HF_REPO_URL = `https://huggingface.co/datasets/${HF_REPO_ID}`;
-  HF_CACHE_ROOT = join101(homedir53(), ".letta", "reflection-arena", "hf-upload");
-  HF_REPO_DIR = join101(HF_CACHE_ROOT, "repo");
+  HF_CACHE_ROOT = join102(homedir53(), ".letta", "reflection-arena", "hf-upload");
+  HF_REPO_DIR = join102(HF_CACHE_ROOT, "repo");
 });
 
 // src/cli/helpers/reflection-arena.ts
@@ -482776,7 +483399,7 @@ import { execFile as execFileCb6 } from "node:child_process";
 import { randomInt as randomInt2, randomUUID as randomUUID57 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir18, readFile as readFile31, writeFile as writeFile21 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
-import { join as join102 } from "node:path";
+import { join as join103 } from "node:path";
 import { promisify as promisify21 } from "node:util";
 function sampleReflectionArenaComparisonModel(excludedModels = []) {
   const excluded = new Set(excludedModels);
@@ -482825,16 +483448,16 @@ function candidateIsConfirmedNoOp(candidate) {
   return candidate.result?.success === true && candidate.result.memoryNoChanges === true && candidate.result.memoryHead === candidate.worktree.baseHead;
 }
 function getReflectionArenaRoot() {
-  return join102(homedir54(), ".letta", "reflection-arena");
+  return join103(homedir54(), ".letta", "reflection-arena");
 }
 function getReflectionArenaRunsDir() {
-  return join102(getReflectionArenaRoot(), "runs");
+  return join103(getReflectionArenaRoot(), "runs");
 }
 function getReflectionArenaChoiceLogPath() {
-  return join102(getReflectionArenaRoot(), "choices.jsonl");
+  return join103(getReflectionArenaRoot(), "choices.jsonl");
 }
 function getReflectionArenaRunPath(runId) {
-  return join102(getReflectionArenaRunsDir(), `${runId}.json`);
+  return join103(getReflectionArenaRunsDir(), `${runId}.json`);
 }
 async function saveReflectionArenaRun(run) {
   await mkdir18(getReflectionArenaRunsDir(), { recursive: true });
@@ -484262,13 +484885,13 @@ __export(exports_terminal_keybinding_installer, {
 });
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync71,
+  existsSync as existsSync72,
   mkdirSync as mkdirSync50,
-  readFileSync as readFileSync50,
+  readFileSync as readFileSync51,
   writeFileSync as writeFileSync43
 } from "node:fs";
 import { homedir as homedir55, platform as platform10 } from "node:os";
-import { dirname as dirname37, join as join103 } from "node:path";
+import { dirname as dirname37, join as join104 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -484300,16 +484923,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os9 = platform10();
   if (os9 === "darwin") {
-    return join103(homedir55(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join104(homedir55(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os9 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join103(appData, appName, "User", "keybindings.json");
+    return join104(appData, appName, "User", "keybindings.json");
   }
   if (os9 === "linux") {
-    return join103(homedir55(), ".config", appName, "User", "keybindings.json");
+    return join104(homedir55(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -484331,10 +484954,10 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync71(keybindingsPath))
+  if (!existsSync72(keybindingsPath))
     return false;
   try {
-    const content = readFileSync50(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync51(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings)
       return false;
@@ -484344,7 +484967,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync71(keybindingsPath))
+  if (!existsSync72(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -484360,14 +484983,14 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname37(keybindingsPath);
-    if (!existsSync71(parentDir)) {
+    if (!existsSync72(parentDir)) {
       mkdirSync50(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync71(keybindingsPath)) {
+    if (existsSync72(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
-      const content = readFileSync50(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync51(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
       if (parsed === null) {
         return {
@@ -484395,10 +485018,10 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync71(keybindingsPath)) {
+    if (!existsSync72(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync50(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync51(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings) {
       return {
@@ -484462,14 +485085,14 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join103(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync71(xdgPath))
+    const xdgPath = join104(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync72(xdgPath))
       return xdgPath;
   }
-  const configPath = join103(homedir55(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync71(configPath))
+  const configPath = join104(homedir55(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync72(configPath))
     return configPath;
-  return join103(homedir55(), ".wezterm.lua");
+  return join104(homedir55(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine(line, blockCommentEnd) {
   let code2 = "";
@@ -484572,10 +485195,10 @@ ${WEZTERM_DELETE_FIX}
 `;
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync71(configPath))
+  if (!existsSync72(configPath))
     return false;
   try {
-    const content = readFileSync50(configPath, { encoding: "utf-8" });
+    const content = readFileSync51(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;
@@ -484589,14 +485212,14 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync71(configPath)) {
+    if (existsSync72(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync6(configPath, backupPath);
-      content = readFileSync50(configPath, { encoding: "utf-8" });
+      content = readFileSync51(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix(content);
     const parentDir = dirname37(configPath);
-    if (!existsSync71(parentDir)) {
+    if (!existsSync72(parentDir)) {
       mkdirSync50(parentDir, { recursive: true });
     }
     writeFileSync43(configPath, content, { encoding: "utf-8" });
@@ -484648,9 +485271,9 @@ __export(exports_settings2, {
   getSetting: () => getSetting
 });
 import { homedir as homedir56 } from "node:os";
-import { join as join104 } from "node:path";
+import { join as join105 } from "node:path";
 function getSettingsPath() {
-  return join104(homedir56(), ".letta", "settings.json");
+  return join105(homedir56(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -484687,7 +485310,7 @@ async function getSetting(key3) {
   return settings3[key3];
 }
 function getProjectSettingsPath() {
-  return join104(process.cwd(), ".letta", "settings.local.json");
+  return join105(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -484705,7 +485328,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings3) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join104(process.cwd(), ".letta");
+  const dirPath = join105(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -486593,9 +487216,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative13(cwd2, fileEdit.filePath);
   const displayPath = relPath.startsWith("..") ? fileEdit.filePath : relPath;
   if (t2 === "write") {
-    const { existsSync: existsSync72 } = __require("node:fs");
+    const { existsSync: existsSync73 } = __require("node:fs");
     try {
-      if (existsSync72(fileEdit.filePath)) {
+      if (existsSync73(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -495512,20 +496135,20 @@ var init_InputRich = __esm(async () => {
 });
 
 // src/cli/commands/install-github-app.ts
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 import {
-  existsSync as existsSync72,
+  existsSync as existsSync73,
   mkdirSync as mkdirSync51,
   mkdtempSync as mkdtempSync7,
-  readFileSync as readFileSync51,
+  readFileSync as readFileSync52,
   rmSync as rmSync26,
   writeFileSync as writeFileSync44
 } from "node:fs";
 import { tmpdir as tmpdir15 } from "node:os";
-import { dirname as dirname38, join as join105 } from "node:path";
+import { dirname as dirname38, join as join106 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
-    return execFileSync9(command, args, {
+    return execFileSync10(command, args, {
       cwd: cwd2,
       encoding: "utf8",
       stdio: [input ? "pipe" : "ignore", "pipe", "pipe"],
@@ -495743,8 +496366,8 @@ async function createLettaAgent(apiKey, name) {
   return createMinimalAgent(apiKey, name);
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync7(join105(tmpdir15(), "letta-install-github-app-"));
-  const repoDir = join105(tempDir, "repo");
+  const tempDir = mkdtempSync7(join106(tmpdir15(), "letta-install-github-app-"));
+  const repoDir = join106(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -495755,14 +496378,14 @@ function runGit7(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join105(repoDir, workflowPath);
-  if (!existsSync72(dirname38(absolutePath))) {
+  const absolutePath = join106(repoDir, workflowPath);
+  if (!existsSync73(dirname38(absolutePath))) {
     mkdirSync51(dirname38(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync72(absolutePath)) {
-    const previous = readFileSync51(absolutePath, "utf8");
+  if (existsSync73(absolutePath)) {
+    const previous = readFileSync52(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
@@ -499651,9 +500274,9 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb7 } from "node:child_process";
-import { chmodSync as chmodSync8, existsSync as existsSync73, mkdirSync as mkdirSync52, writeFileSync as writeFileSync45 } from "node:fs";
+import { chmodSync as chmodSync8, existsSync as existsSync74, mkdirSync as mkdirSync52, writeFileSync as writeFileSync45 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
-import { join as join106 } from "node:path";
+import { join as join107 } from "node:path";
 import { promisify as promisify22 } from "node:util";
 function messagesFromOverview(overview) {
   return overview.messages?.map((message) => ({
@@ -499962,7 +500585,7 @@ ${m4.body}` : m4.subject;
 async function generateAndOpenMemoryViewer(agentId, options) {
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const repoDir = memoryRoot;
-  if (!existsSync73(join106(repoDir, ".git"))) {
+  if (!existsSync74(join107(repoDir, ".git"))) {
     throw new Error("Memory viewer requires memfs. Run /memfs enable first.");
   }
   const data = await collectMemoryData(agentId, repoDir, memoryRoot, options?.conversationId);
@@ -499972,13 +500595,13 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   data.context = applyContextUsageSnapshot(data.context, options?.contextUsage);
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html5 = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync73(VIEWERS_DIR)) {
+  if (!existsSync74(VIEWERS_DIR)) {
     mkdirSync52(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync8(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join106(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
+  const filePath = join107(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
   writeFileSync45(filePath, html5);
   chmodSync8(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -500004,13 +500627,13 @@ var init_generate_memory_viewer = __esm(() => {
   init_local_memory_context();
   init_memory_viewer_template();
   execFile25 = promisify22(execFileCb7);
-  VIEWERS_DIR = join106(homedir58(), ".letta", "viewers");
+  VIEWERS_DIR = join107(homedir58(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync74 } from "node:fs";
-import { join as join107 } from "node:path";
+import { existsSync as existsSync75 } from "node:fs";
+import { join as join108 } from "node:path";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i4 = 0;i4 < node.depth; i4++) {
@@ -500038,8 +500661,8 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react88.useState(null);
   const statusTimerRef = import_react88.useRef(null);
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync74(memoryRoot);
-  const hasGitRepo = import_react88.useMemo(() => existsSync74(join107(memoryRoot, ".git")), [memoryRoot]);
+  const memoryExists = existsSync75(memoryRoot);
+  const hasGitRepo = import_react88.useMemo(() => existsSync75(join108(memoryRoot, ".git")), [memoryRoot]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
       clearTimeout(statusTimerRef.current);
@@ -502415,10 +503038,10 @@ var init_PersonalitySelector = __esm(async () => {
 // src/utils/aws-credentials.ts
 import { readFile as readFile32 } from "node:fs/promises";
 import { homedir as homedir59 } from "node:os";
-import { join as join108 } from "node:path";
+import { join as join109 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join108(homedir59(), ".aws", "credentials");
-  const configPath = join108(homedir59(), ".aws", "config");
+  const credentialsPath = join109(homedir59(), ".aws", "credentials");
+  const configPath = join109(homedir59(), ".aws", "config");
   const profiles = new Map;
   try {
     const content = await readFile32(credentialsPath, "utf-8");
@@ -504083,8 +504706,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills2, SKILLS_DIR: SKILLS_DIR2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join109 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join109(process.cwd(), SKILLS_DIR2);
+        const { join: join110 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join110(process.cwd(), SKILLS_DIR2);
         const result3 = await discoverSkills2(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -508407,9 +509030,9 @@ function getFileEditHeader(toolName2, toolArgs) {
     const relPath = relative13(cwd2, filePath);
     const displayPath = relPath.startsWith("..") ? filePath : relPath;
     if (t2 === "write") {
-      const { existsSync: existsSync75 } = __require("node:fs");
+      const { existsSync: existsSync76 } = __require("node:fs");
       try {
-        if (existsSync75(filePath)) {
+        if (existsSync76(filePath)) {
           return `Overwrite ${displayPath}?`;
         }
       } catch {}
@@ -510177,9 +510800,9 @@ __export(exports_generate_diff_viewer, {
   generateAndOpenDiffViewer: () => generateAndOpenDiffViewer
 });
 import { execFile as execFileCb8 } from "node:child_process";
-import { chmodSync as chmodSync9, existsSync as existsSync75, mkdirSync as mkdirSync53, writeFileSync as writeFileSync46 } from "node:fs";
+import { chmodSync as chmodSync9, existsSync as existsSync76, mkdirSync as mkdirSync53, writeFileSync as writeFileSync46 } from "node:fs";
 import { homedir as homedir60 } from "node:os";
-import { isAbsolute as isAbsolute27, join as join109, resolve as resolve44 } from "node:path";
+import { isAbsolute as isAbsolute27, join as join110, resolve as resolve44 } from "node:path";
 import { promisify as promisify23 } from "node:util";
 async function runGit8(cwd2, args) {
   try {
@@ -510402,13 +511025,13 @@ async function generateAndOpenDiffViewer(targetPath) {
   };
   const jsonPayload = JSON.stringify(payload).replace(/</g, "\\u003c");
   const html5 = diff_viewer_template_default.replace("<!--LETTA_DIFF_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync75(VIEWERS_DIR2)) {
+  if (!existsSync76(VIEWERS_DIR2)) {
     mkdirSync53(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync9(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join109(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
+  const filePath = join110(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
   writeFileSync46(filePath, html5);
   chmodSync9(filePath, 384);
   const skipOpen = shouldSkipOpen();
@@ -510477,7 +511100,7 @@ var execFile26, VIEWERS_DIR2, GIT_TIMEOUT_MS3 = 60000, GIT_MAX_BUFFER, MAX_RENDE
 var init_generate_diff_viewer = __esm(() => {
   init_diff_viewer_template();
   execFile26 = promisify23(execFileCb8);
-  VIEWERS_DIR2 = join109(homedir60(), ".letta", "viewers");
+  VIEWERS_DIR2 = join110(homedir60(), ".letta", "viewers");
   GIT_MAX_BUFFER = 50 * 1024 * 1024;
 });
 
@@ -512422,16 +513045,16 @@ __export(exports_shell_aliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync76, readFileSync as readFileSync52 } from "node:fs";
+import { existsSync as existsSync77, readFileSync as readFileSync53 } from "node:fs";
 import { homedir as homedir61 } from "node:os";
-import { join as join110 } from "node:path";
+import { join as join111 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync76(filePath)) {
+  if (!existsSync77(filePath)) {
     return aliases;
   }
   try {
-    const content = readFileSync52(filePath, "utf-8");
+    const content = readFileSync53(filePath, "utf-8");
     const lines = content.split(`
 `);
     let inFunction = false;
@@ -512496,7 +513119,7 @@ function loadAliases(forceReload = false) {
   const home = homedir61();
   const allAliases = new Map;
   for (const file of ALIAS_FILES) {
-    const filePath = join110(home, file);
+    const filePath = join111(home, file);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -520696,9 +521319,9 @@ var init_conversation_switch_alert = __esm(() => {
 
 // src/cli/app/use-submit-handler.ts
 import { randomUUID as randomUUID62 } from "node:crypto";
-import { existsSync as existsSync77, readFileSync as readFileSync53, renameSync as renameSync13 } from "node:fs";
+import { existsSync as existsSync78, readFileSync as readFileSync54, renameSync as renameSync13 } from "node:fs";
 import { tmpdir as tmpdir16 } from "node:os";
-import { join as join111 } from "node:path";
+import { join as join112 } from "node:path";
 async function findCustomCommandByName(commandName) {
   const { findCustomCommand: findCustomCommand2 } = await Promise.resolve().then(() => (init_custom(), exports_custom));
   return findCustomCommand2(commandName);
@@ -521306,12 +521929,12 @@ ${SYSTEM_REMINDER_CLOSE}`),
           try {
             const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
             const personaCandidates = [
-              join111(memoryRoot, "system", "persona.md"),
-              join111(memoryRoot, "memory", "system", "persona.md")
+              join112(memoryRoot, "system", "persona.md"),
+              join112(memoryRoot, "memory", "system", "persona.md")
             ];
-            const personaPath = personaCandidates.find((candidate) => existsSync77(candidate));
+            const personaPath = personaCandidates.find((candidate) => existsSync78(candidate));
             if (personaPath) {
-              const personaContent = readFileSync53(personaPath, "utf-8");
+              const personaContent = readFileSync54(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
             } else {
               setCurrentPersonalityId(null);
@@ -522155,11 +522778,11 @@ Path: ${memoryDir}`, true);
           setCommandRunning(true);
           try {
             const memoryDir = getScopedMemoryFilesystemRoot(agentId);
-            if (!existsSync77(memoryDir)) {
+            if (!existsSync78(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join111(tmpdir16(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join112(tmpdir16(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync13(memoryDir, backupDir);
             if (getBackend().capabilities.localMemfs) {
               const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
@@ -523074,7 +523697,7 @@ var init_use_submit_handler = __esm(async () => {
 });
 
 // src/cli/app/AppCoordinator.tsx
-import { join as join112 } from "node:path";
+import { join as join113 } from "node:path";
 function buildStartupCommandHints(options) {
   const {
     isResumingConversation,
@@ -524356,7 +524979,7 @@ function App2({
       agentId: a2.agentId ?? null
     }))
   });
-  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join112(modContext.memfs.memoryDir, "mods") : null;
+  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join113(modContext.memfs.memoryDir, "mods") : null;
   const modAdapter = useLocalModAdapter(modContext, {
     agentModsDirectory,
     disabled: modsDisabled,
@@ -525112,9 +525735,9 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     (async () => {
       try {
         const { watch: watch4 } = await import("node:fs");
-        const { existsSync: existsSync78 } = await import("node:fs");
+        const { existsSync: existsSync79 } = await import("node:fs");
         const memRoot = getScopedMemoryFilesystemRoot(agentId);
-        if (!existsSync78(memRoot))
+        if (!existsSync79(memRoot))
           return;
         watcher2 = watch4(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher2;
@@ -526684,12 +527307,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join113 } = await import("node:path");
+  const { join: join114 } = await import("node:path");
   const { getVersion: getVersion2 } = await Promise.resolve().then(() => (init_version(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
   const { exists: exists2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join113(cwd2, SKILLS_DIR2);
+  const skillsDir = join114(cwd2, SKILLS_DIR2);
   const skillsExist = exists2(skillsDir);
   await settingsManager.loadLocalProjectSettings(cwd2);
   const pinned = settingsManager.getPinnedAgents();
@@ -528129,6 +528752,7 @@ var init_src5 = __esm(async () => {
   init_backend2();
   init_metadata();
   init_paths();
+  init_browser_discovery_server();
   init_args();
   init_app_urls();
   init_error_formatter();
@@ -528152,6 +528776,9 @@ var init_src5 = __esm(async () => {
   EMPTY_APPROVAL_ARRAY = [];
   EMPTY_MESSAGE_ARRAY = [];
   assertSupportedBunRuntime();
+  startBrowserDiscoveryServer().ready.catch(() => {
+    return;
+  });
   main();
 });
 
@@ -530516,4 +531143,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=9CF03C78F5A48E9A64756E2164756E21
+//# debugId=F46164B649518D8764756E2164756E21