@letta-ai/letta-code 0.27.24 → 0.27.25

package/letta.js

@@ -4672,7 +4672,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.27.24",
+    version: "0.27.25",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -4769,6 +4769,7 @@ var init_package = __esm(() => {
       "check:filename-casing": "node scripts/check-filename-casing.js",
       "check:test-mock-isolation": "bun run scripts/check-test-mock-isolation.js",
       "check:test-coverage": "node scripts/check-test-coverage.cjs",
+      "check:skill-frontmatter": "node scripts/check-skill-frontmatter.js",
       "check:bundled-skill-scripts": "node scripts/check-bundled-skill-scripts.js",
       check: "bun run scripts/check.js",
       dev: "node scripts/dev.cjs",
@@ -4909,7 +4910,7 @@ async function forkConversation(conversationId, options = {}) {
     ...options.agentId ? { agent_id: options.agentId } : {},
     ...options.hidden !== undefined ? { hidden: options.hidden } : {}
   };
-  return apiRequest("POST", `/v1/conversations/${encodeURIComponent(conversationId)}/fork`, undefined, { query });
+  return apiRequest("POST", `/v1/conversations/${encodeURIComponent(conversationId)}/fork`, undefined, { query, ...options.headers ? { headers: options.headers } : {} });
 }
 async function updateConversationDescription(conversationId, body) {
   return apiRequest("PATCH", `/v1/conversations/${encodeURIComponent(conversationId)}`, body);
@@ -441061,6 +441062,15 @@ var init_file_commands = __esm(async () => {
   ignoreConfigCache = new Map;
 });
 
+// src/agent/acting-user.ts
+function actingUserRequestOptions(actingUserId) {
+  if (!actingUserId) {
+    return;
+  }
+  return { headers: { [ACTING_USER_ID_HEADER]: actingUserId } };
+}
+var ACTING_USER_ID_HEADER = "X-Letta-Acting-User-Id";
+
 // src/agent/max-context.ts
 function buildModelHandleFromConfig4(config3) {
   if (!config3)
@@ -441463,10 +441473,15 @@ function buildDoctorMessage(args) {
 ## Memory filesystem
 
 Memory filesystem is enabled. Memory directory: \`${args.memoryDir}\`
+` : "";
+  const skillRepairSection = args.skillNameFrontmatterRepairReport ? `
+## Automatic skill metadata repair
+
+${args.skillNameFrontmatterRepairReport}
 ` : "";
   return `${SYSTEM_REMINDER_OPEN}
 The user has requested a memory structure check via /doctor.
-${memfsSection}
+${memfsSection}${skillRepairSection}
 ## 1. Invoke the context-doctor skill
 
 Use the \`Skill\` tool with \`skill: "context-doctor"\` to load guidance for memory structure refinement.
@@ -441484,6 +441499,150 @@ var init_init_command = __esm(() => {
   init_git_context();
 });
 
+// src/cli/helpers/skill-name-frontmatter-repair.ts
+import { readdir as readdir11, readFile as readFile18, stat as stat13, writeFile as writeFile14 } from "node:fs/promises";
+import { basename as basename23, dirname as dirname24, join as join48, relative as relative10 } from "node:path";
+async function pathExists(path36) {
+  try {
+    await stat13(path36);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findSkillMarkdownFiles(root2) {
+  const entries = await readdir11(root2, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") {
+      continue;
+    }
+    const fullPath = join48(root2, entry.name);
+    if (entry.isSymbolicLink()) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      files.push(...await findSkillMarkdownFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name === "SKILL.md") {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function formatYamlScalar(value) {
+  if (/^[A-Za-z0-9_-]+$/.test(value)) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function isNonEmptyNameLine(line) {
+  const match4 = line.match(/^\s*name\s*:\s*(.*?)\s*$/);
+  return !!match4?.[1]?.trim();
+}
+function repairSkillNameFrontmatterContent(content, skillName) {
+  if (!skillName.trim()) {
+    return {
+      content,
+      changed: false,
+      reason: "skill directory name is empty"
+    };
+  }
+  const match4 = content.match(FRONTMATTER_REGEX2);
+  if (!match4) {
+    return {
+      content,
+      changed: false,
+      reason: "missing YAML frontmatter"
+    };
+  }
+  const opening2 = match4[1] ?? "";
+  const frontmatter = match4[2] ?? "";
+  const closing2 = match4[3] ?? "";
+  const newline = opening2.includes(`\r
+`) ? `\r
+` : `
+`;
+  const lines = frontmatter.replace(/\r\n/g, `
+`).split(`
+`);
+  const nameLineIndex = lines.findIndex((line) => /^\s*name\s*:/.test(line));
+  if (nameLineIndex >= 0 && isNonEmptyNameLine(lines[nameLineIndex] ?? "")) {
+    return { content, changed: false };
+  }
+  const nameLine = `name: ${formatYamlScalar(skillName.trim())}`;
+  if (nameLineIndex >= 0) {
+    lines[nameLineIndex] = nameLine;
+  } else {
+    lines.unshift(nameLine);
+  }
+  const nextContent = `${opening2}${lines.join(newline)}${closing2}${content.slice(match4[0].length)}`;
+  return { content: nextContent, changed: true };
+}
+async function repairMissingSkillNameFrontmatter(memoryDir) {
+  const result = {
+    scanned: 0,
+    repaired: [],
+    skipped: []
+  };
+  if (!memoryDir) {
+    return result;
+  }
+  const skillsDir = join48(memoryDir, "skills");
+  if (!await pathExists(skillsDir)) {
+    return result;
+  }
+  let skillFiles;
+  try {
+    skillFiles = await findSkillMarkdownFiles(skillsDir);
+  } catch (error54) {
+    result.skipped.push({
+      path: "skills/",
+      reason: `failed to scan skills directory: ${error54 instanceof Error ? error54.message : String(error54)}`
+    });
+    return result;
+  }
+  for (const skillFile of skillFiles.sort()) {
+    const displayPath = relative10(memoryDir, skillFile).replace(/\\/g, "/");
+    result.scanned++;
+    try {
+      const content = await readFile18(skillFile, "utf8");
+      const repair3 = repairSkillNameFrontmatterContent(content, basename23(dirname24(skillFile)));
+      if (repair3.reason) {
+        result.skipped.push({ path: displayPath, reason: repair3.reason });
+        continue;
+      }
+      if (!repair3.changed) {
+        continue;
+      }
+      await writeFile14(skillFile, repair3.content, "utf8");
+      result.repaired.push(displayPath);
+    } catch (error54) {
+      result.skipped.push({
+        path: displayPath,
+        reason: error54 instanceof Error ? error54.message : String(error54)
+      });
+    }
+  }
+  return result;
+}
+function formatSkillNameFrontmatterRepairReport(result) {
+  const sections = [];
+  if (result.repaired.length > 0) {
+    sections.push(`- Added missing \`name:\` frontmatter to ${result.repaired.length} skill${result.repaired.length === 1 ? "" : "s"}: ${result.repaired.map((path36) => `\`${path36}\``).join(", ")}`);
+  }
+  if (result.skipped.length > 0) {
+    sections.push(`- Could not automatically repair ${result.skipped.length} skill${result.skipped.length === 1 ? "" : "s"}: ${result.skipped.map((item) => `\`${item.path}\` (${item.reason})`).join(", ")}`);
+  }
+  return sections.join(`
+`);
+}
+var FRONTMATTER_REGEX2;
+var init_skill_name_frontmatter_repair = __esm(() => {
+  FRONTMATTER_REGEX2 = /^(---\r?\n)([\s\S]*?)(\r?\n---(?:\r?\n|$))/;
+});
+
 // src/websocket/listener/commands/secrets.ts
 function markSecretsReminderRefreshPending(runtime, agentId) {
   const prefix = `agent:${agentId}::conversation:`;
@@ -441588,7 +441747,10 @@ async function handleExecuteCommand(command, socket, conversationRuntime, opts)
     let output;
     switch (command.command_id) {
       case "clear":
-        output = await handleClearCommand(socket, conversationRuntime, opts);
+        output = await handleClearCommand(socket, conversationRuntime, {
+          ...opts,
+          actingUserId: command.runtime.acting_user_id
+        });
         break;
       case "doctor":
         output = await handleDoctorCommand(socket, conversationRuntime, opts);
@@ -441875,7 +442037,7 @@ async function handleClearCommand(_socket, conversationRuntime, opts) {
   }
   const conversation = await backend4.createConversation({
     agent_id: agentId
-  });
+  }, actingUserRequestOptions(opts.actingUserId));
   clearConversationRuntimeState(conversationRuntime);
   conversationRuntime.conversationId = conversation.id;
   emitListenerStatus(conversationRuntime.listener, opts.onStatusChange, opts.connectionId);
@@ -441888,7 +442050,13 @@ async function handleDoctorCommand(socket, conversationRuntime, opts) {
   }
   const { context: gitContext } = gatherInitGitContext();
   const memoryDir = settingsManager.isMemfsEnabled(agentId) ? getScopedMemoryFilesystemRoot(agentId) : undefined;
-  const doctorMessage = buildDoctorMessage({ gitContext, memoryDir });
+  const skillNameFrontmatterRepair = await repairMissingSkillNameFrontmatter(memoryDir);
+  const skillNameFrontmatterRepairReport = formatSkillNameFrontmatterRepairReport(skillNameFrontmatterRepair);
+  const doctorMessage = buildDoctorMessage({
+    gitContext,
+    memoryDir,
+    skillNameFrontmatterRepairReport
+  });
   await handleIncomingMessage({
     type: "message",
     agentId,
@@ -442075,6 +442243,7 @@ var init_commands2 = __esm(async () => {
   init_error_formatter();
   init_init_command();
   init_memory_reminder();
+  init_skill_name_frontmatter_repair();
   init_command_runtime();
   init_constants();
   init_hooks2();
@@ -442265,7 +442434,7 @@ async function handleAgentConversationManagementCommand(parsed, socket, safeSock
   }
   if (parsed.type === "conversation_create") {
     try {
-      const conversation = await backend4.createConversation(parsed.body);
+      const conversation = await backend4.createConversation(parsed.body, actingUserRequestOptions(parsed.acting_user_id));
       safeSocketSend(socket, {
         type: "conversation_create_response",
         request_id: parsed.request_id,
@@ -442327,7 +442496,8 @@ async function handleAgentConversationManagementCommand(parsed, socket, safeSock
     try {
       const conversation = await backend4.forkConversation(parsed.conversation_id, {
         ...typeof parsed.body?.agent_id === "string" ? { agentId: parsed.body.agent_id } : {},
-        ...typeof parsed.body?.hidden === "boolean" ? { hidden: parsed.body.hidden } : {}
+        ...typeof parsed.body?.hidden === "boolean" ? { hidden: parsed.body.hidden } : {},
+        ...actingUserRequestOptions(parsed.acting_user_id) ?? {}
       });
       safeSocketSend(socket, {
         type: "conversation_fork_response",
@@ -443783,7 +443953,7 @@ __export(exports_memory_scanner, {
   getFileNodes: () => getFileNodes
 });
 import { readdirSync as readdirSync15, readFileSync as readFileSync31, statSync as statSync16 } from "node:fs";
-import { join as join48, relative as relative10 } from "node:path";
+import { join as join49, relative as relative11 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
   const scanDir = (dir, depth, parentIsLast) => {
@@ -443795,8 +443965,8 @@ function scanMemoryFilesystem(memoryRoot) {
     }
     const filtered = entries.filter((name) => !name.startsWith("."));
     const sorted = filtered.sort((a2, b3) => {
-      const aPath = join48(dir, a2);
-      const bPath = join48(dir, b3);
+      const aPath = join49(dir, a2);
+      const bPath = join49(dir, b3);
       let aIsDir = false;
       let bIsDir = false;
       try {
@@ -443816,14 +443986,14 @@ function scanMemoryFilesystem(memoryRoot) {
       return a2.localeCompare(b3);
     });
     sorted.forEach((name, index) => {
-      const fullPath = join48(dir, name);
+      const fullPath = join49(dir, name);
       let isDir = false;
       try {
         isDir = statSync16(fullPath).isDirectory();
       } catch {
         return;
       }
-      const relativePath = relative10(memoryRoot, fullPath).replace(/\\/g, "/");
+      const relativePath = relative11(memoryRoot, fullPath).replace(/\\/g, "/");
       const isLast = index === sorted.length - 1;
       nodes.push({
         name: isDir ? `${name}/` : name,
@@ -443888,9 +444058,9 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     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: existsSync46, statSync: statSync17 } = await import("node:fs");
-    const { join: join49, posix: posix4 } = await import("node:path");
+    const { join: join50, posix: posix4 } = await import("node:path");
     const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
-    let memfsInitialized = existsSync46(join49(memoryRoot, ".git"));
+    let memfsInitialized = existsSync46(join50(memoryRoot, ".git"));
     const memfsEnabled = memfsInitialized ? true : await isMemfsEnabledOnServer2(parsed.agent_id);
     if (!memfsEnabled) {
       safeSocketSend(socket, {
@@ -443908,7 +444078,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     await ensureLocalMemfsCheckout2(parsed.agent_id, {
       pullOnExistingRepo: true
     });
-    memfsInitialized = existsSync46(join49(memoryRoot, ".git"));
+    memfsInitialized = existsSync46(join50(memoryRoot, ".git"));
     if (!memfsInitialized) {
       throw new Error("MemFS is enabled, but the local memory checkout could not be initialized.");
     }
@@ -444207,33 +444377,33 @@ function handleMemoryProtocolCommand(parsed, context3) {
           ensureLocalMemfsCheckout: ensureLocalMemfsCheckout2,
           isMemfsEnabledOnServer: isMemfsEnabledOnServer2
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
-        const { readFile: readFile18 } = await import("node:fs/promises");
+        const { readFile: readFile19 } = await import("node:fs/promises");
         const { existsSync: existsSync46 } = await import("node:fs");
-        const { isAbsolute: isAbsolute23, join: join49, normalize: normalize5, relative: relative11, sep: sep5 } = await import("node:path");
+        const { isAbsolute: isAbsolute23, join: join50, normalize: normalize5, relative: relative12, sep: sep5 } = await import("node:path");
         if (isAbsolute23(parsed.path) || parsed.path.length === 0) {
           sendFailure("path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize5(join49(memoryRoot, parsed.path));
-        const rel = relative11(memoryRoot, absolutePath);
+        const absolutePath = normalize5(join50(memoryRoot, parsed.path));
+        const rel = relative12(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute23(rel) || rel.split(sep5).includes("..")) {
           sendFailure("path must resolve inside the memory root");
           return;
         }
-        if (!existsSync46(join49(memoryRoot, ".git"))) {
+        if (!existsSync46(join50(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 (!existsSync46(join49(memoryRoot, ".git"))) {
+          if (!existsSync46(join50(memoryRoot, ".git"))) {
             sendFailure("failed to initialize local memory checkout");
             return;
           }
         }
-        const buffer = await readFile18(absolutePath);
+        const buffer = await readFile19(absolutePath);
         const content = encoding === "base64" ? buffer.toString("base64") : buffer.toString("utf-8");
         const pathspec = rel.split(sep5).join("/");
         safeSocketSend(socket, {
@@ -444273,35 +444443,35 @@ function handleMemoryProtocolCommand(parsed, context3) {
           isMemfsEnabledOnServer: isMemfsEnabledOnServer2
         } = 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: writeFile14, mkdir: mkdir12 } = await import("node:fs/promises");
+        const { writeFile: writeFile15, mkdir: mkdir12 } = await import("node:fs/promises");
         const { existsSync: existsSync46 } = await import("node:fs");
-        const { dirname: dirname24, isAbsolute: isAbsolute23, join: join49, normalize: normalize5, relative: relative11, sep: sep5 } = await import("node:path");
+        const { dirname: dirname25, isAbsolute: isAbsolute23, join: join50, normalize: normalize5, relative: relative12, sep: sep5 } = await import("node:path");
         if (isAbsolute23(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 = normalize5(join49(memoryRoot, parsed.path));
-        const rel = relative11(memoryRoot, absolutePath);
+        const absolutePath = normalize5(join50(memoryRoot, parsed.path));
+        const rel = relative12(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute23(rel) || rel.split(sep5).includes("..")) {
           sendFailure("write_memory_file: path must resolve inside the memory root");
           return;
         }
-        if (!existsSync46(join49(memoryRoot, ".git"))) {
+        if (!existsSync46(join50(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 (!existsSync46(join49(memoryRoot, ".git"))) {
+          if (!existsSync46(join50(memoryRoot, ".git"))) {
             sendFailure("write_memory_file: failed to initialize local memory checkout");
             return;
           }
         }
         const buffer = encoding === "base64" ? Buffer.from(parsed.content, "base64") : Buffer.from(parsed.content, "utf-8");
-        await mkdir12(dirname24(absolutePath), { recursive: true });
-        await writeFile14(absolutePath, buffer);
+        await mkdir12(dirname25(absolutePath), { recursive: true });
+        await writeFile15(absolutePath, buffer);
         const { getBackend: getBackend2 } = await Promise.resolve().then(() => (init_backend2(), exports_backend));
         const backend4 = getBackend2();
         const memorySyncMode = backend4.capabilities.localMemfs && !backend4.capabilities.remoteMemfs ? "local" : undefined;
@@ -444378,26 +444548,26 @@ function handleMemoryProtocolCommand(parsed, context3) {
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { unlink: unlink5 } = await import("node:fs/promises");
         const { existsSync: existsSync46 } = await import("node:fs");
-        const { isAbsolute: isAbsolute23, join: join49, normalize: normalize5, relative: relative11, sep: sep5 } = await import("node:path");
+        const { isAbsolute: isAbsolute23, join: join50, normalize: normalize5, relative: relative12, sep: sep5 } = await import("node:path");
         if (isAbsolute23(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 = normalize5(join49(memoryRoot, parsed.path));
-        const rel = relative11(memoryRoot, absolutePath);
+        const absolutePath = normalize5(join50(memoryRoot, parsed.path));
+        const rel = relative12(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute23(rel) || rel.split(sep5).includes("..")) {
           sendFailure("delete_memory_file: path must resolve inside the memory root");
           return;
         }
-        if (!existsSync46(join49(memoryRoot, ".git"))) {
+        if (!existsSync46(join50(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 (!existsSync46(join49(memoryRoot, ".git"))) {
+          if (!existsSync46(join50(memoryRoot, ".git"))) {
             sendFailure("delete_memory_file: failed to initialize local memory checkout");
             return;
           }
@@ -444817,9 +444987,9 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
     symlinkSync: symlinkSync2,
     unlinkSync: unlinkSync7
   } = await import("node:fs");
-  const { basename: basename23, join: join49 } = await import("node:path");
-  const lettaHome = process.env.LETTA_HOME || join49(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
-  const globalSkillsDir = join49(lettaHome, "skills");
+  const { basename: basename24, join: join50 } = await import("node:path");
+  const lettaHome = process.env.LETTA_HOME || join50(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
+  const globalSkillsDir = join50(lettaHome, "skills");
   if (parsed.type === "skill_enable") {
     try {
       if (!existsSync46(parsed.skill_path)) {
@@ -444831,7 +445001,7 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const skillMdPath = join49(parsed.skill_path, "SKILL.md");
+      const skillMdPath = join50(parsed.skill_path, "SKILL.md");
       if (!existsSync46(skillMdPath)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
@@ -444841,12 +445011,12 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const linkName = basename23(parsed.skill_path);
-      const linkPath = join49(globalSkillsDir, linkName);
+      const linkName = basename24(parsed.skill_path);
+      const linkPath = join50(globalSkillsDir, linkName);
       mkdirSync31(globalSkillsDir, { recursive: true });
       if (existsSync46(linkPath)) {
-        const stat13 = lstatSync3(linkPath);
-        if (stat13.isSymbolicLink()) {
+        const stat14 = lstatSync3(linkPath);
+        if (stat14.isSymbolicLink()) {
           if (process.platform === "win32") {
             rmdirSync(linkPath);
           } else {
@@ -444885,7 +445055,7 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
   }
   if (parsed.type === "skill_disable") {
     try {
-      const linkPath = join49(globalSkillsDir, parsed.name);
+      const linkPath = join50(globalSkillsDir, parsed.name);
       if (!existsSync46(linkPath)) {
         safeSocketSend(socket, {
           type: "skill_disable_response",
@@ -444895,8 +445065,8 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const stat13 = lstatSync3(linkPath);
-      if (!stat13.isSymbolicLink()) {
+      const stat14 = lstatSync3(linkPath);
+      if (!stat14.isSymbolicLink()) {
         safeSocketSend(socket, {
           type: "skill_disable_response",
           request_id: parsed.request_id,
@@ -449829,7 +449999,7 @@ var init_listen_client = __esm(async () => {
 
 // src/backend/local/transcript-search.ts
 import { existsSync as existsSync49, readdirSync as readdirSync18, readFileSync as readFileSync33, statSync as statSync18 } from "node:fs";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 function readJsonFile3(path37) {
   if (!existsSync49(path37))
     return;
@@ -450050,11 +450220,11 @@ function collectConversationMessages(input) {
     return [];
   if (input.conversationId && conversation.id !== input.conversationId)
     return [];
-  const messagesPath = join52(conversationDir, "messages.jsonl");
+  const messagesPath = join53(conversationDir, "messages.jsonl");
   const rows = readJsonlFile2(messagesPath);
   if (rows.length === 0)
     return [];
-  const manifest2 = readJsonFile3(join52(conversationDir, "manifest.json"));
+  const manifest2 = readJsonFile3(join53(conversationDir, "manifest.json"));
   const format5 = transcriptFormat(manifest2, rows);
   if (!format5)
     return [];
@@ -450075,11 +450245,11 @@ function collectConversationMessages(input) {
   });
 }
 function conversationDirectories(storageDir) {
-  const conversationsDir = join52(storageDir, "conversations");
+  const conversationsDir = join53(storageDir, "conversations");
   if (!existsSync49(conversationsDir))
     return [];
   try {
-    return readdirSync18(conversationsDir).map((entry) => join52(conversationsDir, entry)).filter((entryPath) => statSync18(entryPath).isDirectory());
+    return readdirSync18(conversationsDir).map((entry) => join53(conversationsDir, entry)).filter((entryPath) => statSync18(entryPath).isDirectory());
   } catch {
     return [];
   }
@@ -450103,7 +450273,7 @@ function searchLocalTranscriptMessages(storageDir, body3) {
   const endDate = typeof body3.end_date === "string" ? body3.end_date : undefined;
   const includeHidden = body3.include_hidden === true;
   const records = conversationDirectories(storageDir).flatMap((conversationDir) => {
-    const conversation = conversationSearchRecord(readJsonFile3(join52(conversationDir, "conversation.json")));
+    const conversation = conversationSearchRecord(readJsonFile3(join53(conversationDir, "conversation.json")));
     if (!conversation)
       return [];
     if (conversation.hidden && !includeHidden)
@@ -451982,7 +452152,7 @@ import {
   unlinkSync as unlinkSync8
 } from "node:fs";
 import { homedir as homedir32 } from "node:os";
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 import { format as format5 } from "node:util";
 function isDebugEnabled2() {
   const lettaDebug = process.env.LETTA_DEBUG;
@@ -452013,8 +452183,8 @@ class DebugLogFile2 {
     const telem = process.env.LETTA_CODE_TELEM;
     if (telem === "0" || telem === "false")
       return;
-    this.agentDir = join56(DEBUG_LOG_DIR2, agentId);
-    this.logPath = join56(this.agentDir, `${sessionId}.log`);
+    this.agentDir = join57(DEBUG_LOG_DIR2, agentId);
+    this.logPath = join57(this.agentDir, `${sessionId}.log`);
     this.dirCreated = false;
     this.pruneOldSessions();
   }
@@ -452062,7 +452232,7 @@ class DebugLogFile2 {
         const toDelete = files.slice(0, files.length - MAX_SESSION_FILES3 + 1);
         for (const file3 of toDelete) {
           try {
-            unlinkSync8(join56(this.agentDir, file3));
+            unlinkSync8(join57(this.agentDir, file3));
           } catch {}
         }
       }
@@ -452087,7 +452257,7 @@ function debugWarn2(prefix, message, ...args) {
 }
 var DEBUG_LOG_DIR2, MAX_SESSION_FILES3 = 5, DEFAULT_TAIL_LINES2 = 50, debugLogFile2;
 var init_debug2 = __esm(() => {
-  DEBUG_LOG_DIR2 = join56(homedir32(), ".letta", "logs", "debug");
+  DEBUG_LOG_DIR2 = join57(homedir32(), ".letta", "logs", "debug");
   debugLogFile2 = new DebugLogFile2;
 });
 
@@ -452122,15 +452292,15 @@ __export(exports_skills3, {
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
 import { existsSync as existsSync54 } from "node:fs";
-import { readdir as readdir13, readFile as readFile18, realpath as realpath5, stat as stat13 } from "node:fs/promises";
-import { dirname as dirname27, join as join57 } from "node:path";
+import { readdir as readdir14, readFile as readFile19, realpath as realpath5, stat as stat14 } from "node:fs/promises";
+import { dirname as dirname28, join as join58 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
-  const thisDir = dirname27(fileURLToPath8(import.meta.url));
+  const thisDir = dirname28(fileURLToPath8(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join57(thisDir, "../skills/builtin");
+    return join58(thisDir, "../skills/builtin");
   }
-  return join57(thisDir, "skills");
+  return join58(thisDir, "skills");
 }
 function compareSkills2(a2, b3) {
   return a2.id.localeCompare(b3.id) || a2.source.localeCompare(b3.source) || a2.path.localeCompare(b3.path);
@@ -452177,7 +452347,7 @@ function isSkillAvailableForAgent2(skill2, agentId) {
   return true;
 }
 function getAgentSkillsDir2(agentId) {
-  return join57(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
+  return join58(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
 }
 async function getBundledSkills2() {
   const bundledPath = getBundledSkillsPath2();
@@ -452200,7 +452370,7 @@ async function discoverSkillsFromDir2(skillsPath, source2) {
   }
   return { skills, errors: errors7 };
 }
-async function discoverSkills2(projectSkillsPath = join57(process.cwd(), SKILLS_DIR2), agentId, options3) {
+async function discoverSkills2(projectSkillsPath = join58(process.cwd(), SKILLS_DIR2), agentId, options3) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options3?.sources ?? ALL_SKILL_SOURCES);
@@ -452253,14 +452423,14 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors7, source2,
     return;
   }
   try {
-    const entries = await readdir13(currentPath, { withFileTypes: true });
+    const entries = await readdir14(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join57(currentPath, entry.name);
+      const fullPath = join58(currentPath, entry.name);
       try {
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
-          const entryStat = await stat13(fullPath);
+          const entryStat = await stat14(fullPath);
           isDirectory = entryStat.isDirectory();
           isFile = entryStat.isFile();
         }
@@ -452294,7 +452464,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors7, source2,
   }
 }
 async function parseSkillFile2(filePath, rootPath, source2) {
-  const content = await readFile18(filePath, "utf-8");
+  const content = await readFile19(filePath, "utf-8");
   const { frontmatter, body: body3 } = parseFrontmatter(content);
   const normalizedRoot = rootPath.endsWith("/") ? rootPath.slice(0, -1) : rootPath;
   const relativePath = filePath.slice(normalizedRoot.length + 1);
@@ -452346,17 +452516,17 @@ var LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS2, PROJECT_SKILLS_DIR2, SKILLS_DIR2 = ".s
 var init_skills4 = __esm(() => {
   init_skill_sources();
   LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS2 = new Set(["image-generation"]);
-  PROJECT_SKILLS_DIR2 = join57(".agents", "skills");
-  GLOBAL_SKILLS_DIR2 = join57(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  PROJECT_SKILLS_DIR2 = join58(".agents", "skills");
+  GLOBAL_SKILLS_DIR2 = join58(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/utils/fs.ts
 var exports_fs = {};
 __export(exports_fs, {
   writeJsonFile: () => writeJsonFile2,
-  writeFile: () => writeFile15,
+  writeFile: () => writeFile16,
   readJsonFile: () => readJsonFile4,
-  readFile: () => readFile19,
+  readFile: () => readFile20,
   mkdir: () => mkdir13,
   exists: () => exists2
 });
@@ -452366,12 +452536,12 @@ import {
   writeFileSync as fsWriteFileSync2,
   mkdirSync as mkdirSync37
 } from "node:fs";
-import { dirname as dirname28 } from "node:path";
-async function readFile19(path39) {
+import { dirname as dirname29 } from "node:path";
+async function readFile20(path39) {
   return fsReadFileSync2(path39, { encoding: "utf-8" });
 }
-async function writeFile15(path39, content) {
-  const dir = dirname28(path39);
+async function writeFile16(path39, content) {
+  const dir = dirname29(path39);
   if (!existsSync55(dir)) {
     mkdirSync37(dir, { recursive: true });
   }
@@ -452384,14 +452554,14 @@ async function mkdir13(path39, options3) {
   mkdirSync37(path39, options3);
 }
 async function readJsonFile4(path39) {
-  const text2 = await readFile19(path39);
+  const text2 = await readFile20(path39);
   return JSON.parse(text2);
 }
 async function writeJsonFile2(path39, data, options3) {
   const indent = options3?.indent ?? 2;
   const content = `${JSON.stringify(data, null, indent)}
 `;
-  await writeFile15(path39, content);
+  await writeFile16(path39, content);
 }
 var init_fs2 = () => {};
 
@@ -452590,8 +452760,8 @@ import {
   execFile as execFile16
 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants4, realpathSync as realpathSync6 } from "node:fs";
-import { readdir as readdir14, rm as rm5 } from "node:fs/promises";
-import { dirname as dirname29, join as join58 } from "node:path";
+import { readdir as readdir15, rm as rm5 } from "node:fs/promises";
+import { dirname as dirname30, join as join59 } from "node:path";
 import { promisify as promisify14 } from "node:util";
 function debugLog4(...args) {
   if (DEBUG2) {
@@ -452666,7 +452836,7 @@ function getResolvedEntrypoint2() {
   }
 }
 function findInstalledPackagePath2(resolvedPath) {
-  const marker = `${join58("node_modules", "@letta-ai", "letta-code")}`;
+  const marker = `${join59("node_modules", "@letta-ai", "letta-code")}`;
   const index = resolvedPath.lastIndexOf(marker);
   if (index === -1) {
     return null;
@@ -452705,7 +452875,7 @@ function getSelfUpdateStatus2() {
       manual_command: manualCommand
     };
   }
-  const packageParentPath = dirname29(installPath);
+  const packageParentPath = dirname30(installPath);
   const writable = canWritePath2(installPath) && canWritePath2(packageParentPath);
   return {
     supported: true,
@@ -452815,12 +452985,12 @@ async function getNpmGlobalPath2() {
   }
 }
 async function cleanupOrphanedDirs2(globalPath) {
-  const lettaAiDir = join58(globalPath, "lib/node_modules/@letta-ai");
+  const lettaAiDir = join59(globalPath, "lib/node_modules/@letta-ai");
   try {
-    const entries = await readdir14(lettaAiDir);
+    const entries = await readdir15(lettaAiDir);
     for (const entry of entries) {
       if (entry.startsWith(".letta-code-")) {
-        const orphanPath = join58(lettaAiDir, entry);
+        const orphanPath = join59(lettaAiDir, entry);
         debugLog4("Cleaning orphaned temp directory:", orphanPath);
         await rm5(orphanPath, { recursive: true, force: true });
       }
@@ -453352,7 +453522,7 @@ __export(exports_bootstrap_tools, {
 });
 import { existsSync as existsSync57, mkdirSync as mkdirSync39, writeFileSync as writeFileSync28 } from "node:fs";
 import { homedir as homedir34 } from "node:os";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 async function bootstrapBaseToolsIfNeeded() {
   if (existsSync57(MARKER_PATH))
     return;
@@ -453360,7 +453530,7 @@ async function bootstrapBaseToolsIfNeeded() {
   try {
     const success2 = await addBaseToolsToServer();
     if (success2) {
-      mkdirSync39(join60(homedir34(), ".letta"), { recursive: true });
+      mkdirSync39(join61(homedir34(), ".letta"), { recursive: true });
       writeFileSync28(MARKER_PATH, new Date().toISOString(), "utf-8");
     }
   } catch (err) {
@@ -453371,7 +453541,7 @@ var MARKER_PATH;
 var init_bootstrap_tools = __esm(() => {
   init_debug();
   init_create6();
-  MARKER_PATH = join60(homedir34(), ".letta", ".bootstrapped");
+  MARKER_PATH = join61(homedir34(), ".letta", ".bootstrapped");
 });
 
 // src/tools/filter.ts
@@ -453814,7 +453984,7 @@ function validateRegistryHandleOrThrow2(handle2) {
 }
 
 // src/headless-mod-adapter.ts
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 function isHeadlessMemfsEnabled(agentId) {
   try {
     return settingsManager.isMemfsEnabled(agentId);
@@ -453885,7 +454055,7 @@ function createHeadlessModContext(options3) {
   };
 }
 function createHeadlessModAdapter(options3) {
-  const agentModsDirectory = isHeadlessMemfsEnabled(options3.agent.id) ? join61(getScopedMemoryFilesystemRoot(options3.agent.id), "mods") : undefined;
+  const agentModsDirectory = isHeadlessMemfsEnabled(options3.agent.id) ? join62(getScopedMemoryFilesystemRoot(options3.agent.id), "mods") : undefined;
   return createModAdapter({
     ...agentModsDirectory ? { agentModsDirectory } : {},
     ...options3.cacheDirectory ? { cacheDirectory: options3.cacheDirectory } : {},
@@ -453970,7 +454140,7 @@ async function writeWireMessageAsync(msg) {
 
 // src/skills/builtin/creating-skills/scripts/validate-skill.ts
 import { existsSync as existsSync58, readFileSync as readFileSync38 } from "node:fs";
-import { basename as basename24, join as join62, resolve as resolve34 } from "node:path";
+import { basename as basename25, join as join63, resolve as resolve34 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function parseQuotedScalar(value) {
   if (value.startsWith('"')) {
@@ -454067,7 +454237,7 @@ function parseFrontmatter2(source2) {
   return parseFrontmatterFallback(source2);
 }
 function validateSkill(skillPath) {
-  const skillMdPath = join62(skillPath, "SKILL.md");
+  const skillMdPath = join63(skillPath, "SKILL.md");
   if (!existsSync58(skillMdPath)) {
     return { valid: false, message: "SKILL.md not found" };
   }
@@ -454130,7 +454300,7 @@ function validateSkill(skillPath) {
         message: `Name is too long (${trimmedName.length} characters). Maximum is ${MAX_SKILL_NAME_LENGTH} characters.`
       };
     }
-    const dirName = basename24(skillPath);
+    const dirName = basename25(skillPath);
     if (trimmedName !== dirName) {
       warnings.push(`Name '${trimmedName}' doesn't match directory name '${dirName}'. For portability, these should match.`);
     }
@@ -454234,8 +454404,8 @@ __export(exports_import, {
   extractSkillsFromAf: () => extractSkillsFromAf
 });
 import { createReadStream as createReadStream2 } from "node:fs";
-import { access as access2, chmod, mkdir as mkdir14, readFile as readFile20, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname30, isAbsolute as isAbsolute24, relative as relative11, resolve as resolve35, sep as sep6, win32 as win325 } from "node:path";
+import { access as access2, chmod, mkdir as mkdir14, readFile as readFile21, writeFile as writeFile17 } from "node:fs/promises";
+import { dirname as dirname31, isAbsolute as isAbsolute24, relative as relative12, resolve as resolve35, sep as sep6, win32 as win325 } from "node:path";
 function validateImportedSkillName(name) {
   const trimmedName = name.trim();
   if (trimmedName !== name || trimmedName.length === 0 || trimmedName.length > MAX_SKILL_NAME_LENGTH || trimmedName === "." || trimmedName === ".." || !IMPORTED_SKILL_NAME_PATTERN.test(trimmedName)) {
@@ -454246,7 +454416,7 @@ function validateImportedSkillName(name) {
 function assertPathInside(parent, child) {
   const parentPath = resolve35(parent);
   const childPath = resolve35(child);
-  const relativePath = relative11(parentPath, childPath);
+  const relativePath = relative12(parentPath, childPath);
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep6}`) || isAbsolute24(relativePath)) {
     throw new Error(`Imported skill file path escapes skill directory: ${child}`);
   }
@@ -454335,7 +454505,7 @@ async function importAgentFromFile(options3) {
 }
 async function extractSkillsFromAf(afPath, destDir) {
   const extracted = [];
-  const content = await readFile20(afPath, "utf-8");
+  const content = await readFile21(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
@@ -454363,8 +454533,8 @@ async function writeSkillFiles(skillDir, files) {
 }
 async function writeSkillFile(skillDir, filePath, content) {
   const fullPath = resolveImportedSkillFilePath(skillDir, filePath);
-  await mkdir14(dirname30(fullPath), { recursive: true });
-  await writeFile16(fullPath, content, "utf-8");
+  await mkdir14(dirname31(fullPath), { recursive: true });
+  await writeFile17(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
     try {
@@ -454416,8 +454586,8 @@ function parseRegistryHandle(handle2) {
 }
 async function importAgentFromRegistry(options3) {
   const { tmpdir: tmpdir10 } = await import("node:os");
-  const { join: join63 } = await import("node:path");
-  const { writeFile: writeFile17, unlink: unlink5 } = await import("node:fs/promises");
+  const { join: join64 } = await import("node:path");
+  const { writeFile: writeFile18, unlink: unlink5 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options3.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
   const response = await fetch(rawUrl);
@@ -454428,8 +454598,8 @@ async function importAgentFromRegistry(options3) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join63(tmpdir10(), `letta-import-${author}-${name}-${Date.now()}.af`);
-  await writeFile17(tempPath, afContent, "utf-8");
+  const tempPath = join64(tmpdir10(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  await writeFile18(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
       filePath: tempPath,
@@ -458051,7 +458221,7 @@ var BYTES_PER_TOKEN = 4;
 
 // src/cli/helpers/window-title-config.ts
 import { homedir as homedir36 } from "node:os";
-import { basename as basename25, resolve as resolve36 } from "node:path";
+import { basename as basename26, resolve as resolve36 } from "node:path";
 function isWindowTitleField(value) {
   return WINDOW_TITLE_FIELDS.includes(value);
 }
@@ -458210,7 +458380,7 @@ function terminalTitleProjectName(data) {
   if (!directory)
     return null;
   const resolved = resolve36(directory);
-  const name = basename25(resolved) || formatDirectoryDisplay(resolved) || resolved;
+  const name = basename26(resolved) || formatDirectoryDisplay(resolved) || resolved;
   return truncateTerminalTitlePart(name, 24);
 }
 function titleDirectory(data) {
@@ -459485,7 +459655,7 @@ import {
   writeFileSync as writeFileSync30
 } from "node:fs";
 import { homedir as homedir37, platform as platform9 } from "node:os";
-import { dirname as dirname31, join as join64 } from "node:path";
+import { dirname as dirname32, join as join65 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -459517,16 +459687,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os9 = platform9();
   if (os9 === "darwin") {
-    return join64(homedir37(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join65(homedir37(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os9 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join64(appData, appName, "User", "keybindings.json");
+    return join65(appData, appName, "User", "keybindings.json");
   }
   if (os9 === "linux") {
-    return join64(homedir37(), ".config", appName, "User", "keybindings.json");
+    return join65(homedir37(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -459576,7 +459746,7 @@ function installKeybinding(keybindingsPath) {
     if (keybindingExists(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname31(keybindingsPath);
+    const parentDir = dirname32(keybindingsPath);
     if (!existsSync60(parentDir)) {
       mkdirSync41(parentDir, { recursive: true });
     }
@@ -459679,14 +459849,14 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join64(xdgConfig, "wezterm", "wezterm.lua");
+    const xdgPath = join65(xdgConfig, "wezterm", "wezterm.lua");
     if (existsSync60(xdgPath))
       return xdgPath;
   }
-  const configPath = join64(homedir37(), ".config", "wezterm", "wezterm.lua");
+  const configPath = join65(homedir37(), ".config", "wezterm", "wezterm.lua");
   if (existsSync60(configPath))
     return configPath;
-  return join64(homedir37(), ".wezterm.lua");
+  return join65(homedir37(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine(line, blockCommentEnd) {
   let code2 = "";
@@ -459812,7 +459982,7 @@ function installWezTermDeleteFix() {
       content = readFileSync40(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix(content);
-    const parentDir = dirname31(configPath);
+    const parentDir = dirname32(configPath);
     if (!existsSync60(parentDir)) {
       mkdirSync41(parentDir, { recursive: true });
     }
@@ -459865,9 +460035,9 @@ __export(exports_settings2, {
   getSetting: () => getSetting
 });
 import { homedir as homedir38 } from "node:os";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 function getSettingsPath() {
-  return join65(homedir38(), ".letta", "settings.json");
+  return join66(homedir38(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -459904,7 +460074,7 @@ async function getSetting(key2) {
   return settings3[key2];
 }
 function getProjectSettingsPath() {
-  return join65(process.cwd(), ".letta", "settings.local.json");
+  return join66(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -459922,7 +460092,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings3) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join65(process.cwd(), ".letta");
+  const dirPath = join66(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -460953,10 +461123,10 @@ var init_InlineBashApproval = __esm(async () => {
 });
 
 // src/cli/components/DiffRenderer.tsx
-import { relative as relative12 } from "node:path";
+import { relative as relative13 } from "node:path";
 function formatDisplayPath4(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative12(cwd2, filePath);
+  const relativePath = relative13(cwd2, filePath);
   if (relativePath.startsWith("..")) {
     return filePath;
   }
@@ -461315,10 +461485,10 @@ var init_DiffRenderer = __esm(async () => {
 });
 
 // src/cli/components/AdvancedDiffRenderer.tsx
-import { relative as relative13 } from "node:path";
+import { relative as relative14 } from "node:path";
 function formatRelativePath(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative13(cwd2, filePath);
+  const relativePath = relative14(cwd2, filePath);
   return relativePath.startsWith("..") ? relativePath : `./${relativePath}`;
 }
 function padLeft(n, width) {
@@ -461600,7 +461770,7 @@ function AdvancedDiffRenderer(props) {
   }
   const { hunks } = result;
   const filePath = props.filePath;
-  const relative14 = formatRelativePath(filePath);
+  const relative15 = formatRelativePath(filePath);
   const lang41 = languageFromPath(filePath);
   const shouldHighlight = lang41 && !exceedsAdvancedDiffHighlightLimits(hunks);
   const hunkSyntaxLines = [];
@@ -461623,7 +461793,7 @@ function AdvancedDiffRenderer(props) {
   const rows = buildAdvancedDiffRows(hunks, hunkSyntaxLines);
   const maxDisplayNo = rows.reduce((m4, r5) => Math.max(m4, r5.displayNo), 1);
   const gutterWidth = String(maxDisplayNo).length;
-  const header = props.kind === "write" ? `Wrote changes to ${relative14}` : `Updated ${relative14}`;
+  const header = props.kind === "write" ? `Wrote changes to ${relative15}` : `Updated ${relative15}`;
   if (rows.length === 0) {
     const noChangesGutter = 4;
     return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
@@ -461674,7 +461844,7 @@ function AdvancedDiffRenderer(props) {
                   "No changes to ",
                   /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text2, {
                     bold: true,
-                    children: relative14
+                    children: relative15
                   }, undefined, false, undefined, this),
                   " (file content identical)"
                 ]
@@ -461780,9 +461950,9 @@ function getHeaderText(fileEdit) {
       } else if (operations.length === 1) {
         const op = operations[0];
         if (op) {
-          const { relative: relative15 } = __require("node:path");
+          const { relative: relative16 } = __require("node:path");
           const cwd3 = process.cwd();
-          const relPath2 = relative15(cwd3, op.path);
+          const relPath2 = relative16(cwd3, op.path);
           const displayPath2 = relPath2.startsWith("..") ? op.path : relPath2;
           if (op.kind === "add") {
             return `Write to ${displayPath2}?`;
@@ -461796,9 +461966,9 @@ function getHeaderText(fileEdit) {
     }
     return "Apply patch?";
   }
-  const { relative: relative14 } = __require("node:path");
+  const { relative: relative15 } = __require("node:path");
   const cwd2 = process.cwd();
-  const relPath = relative14(cwd2, fileEdit.filePath);
+  const relPath = relative15(cwd2, fileEdit.filePath);
   const displayPath = relPath.startsWith("..") ? fileEdit.filePath : relPath;
   if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
     const { existsSync: existsSync61 } = __require("node:fs");
@@ -461981,9 +462151,9 @@ var init_InlineFileEditApproval = __esm(async () => {
           children: fileEdit.patchInput ? /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
             flexDirection: "column",
             children: parsePatchOperations2(fileEdit.patchInput).map((op, idx) => {
-              const { relative: relative14 } = __require("node:path");
+              const { relative: relative15 } = __require("node:path");
               const cwd2 = process.cwd();
-              const relPath = relative14(cwd2, op.path);
+              const relPath = relative15(cwd2, op.path);
               const displayPath = relPath.startsWith("..") ? op.path : relPath;
               const diffKey = fileEdit.toolCallId ? `${fileEdit.toolCallId}:${op.path}` : undefined;
               const opDiff = diffKey && allDiffs ? allDiffs.get(diffKey) : undefined;
@@ -469316,7 +469486,7 @@ import {
   statSync as statSync21
 } from "node:fs";
 import { arch as arch4, homedir as homedir40, platform as platform10 } from "node:os";
-import { basename as basename26, join as join66 } from "node:path";
+import { basename as basename27, join as join67 } from "node:path";
 function toDisplayPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -469558,7 +469728,7 @@ class FileAutocompleteProvider {
   }
   expandHomePath(path42) {
     if (path42.startsWith("~/")) {
-      const expandedPath = join66(homedir40(), path42.slice(2));
+      const expandedPath = join67(homedir40(), path42.slice(2));
       return path42.endsWith("/") && !expandedPath.endsWith("/") ? `${expandedPath}/` : expandedPath;
     } else if (path42 === "~") {
       return homedir40();
@@ -469579,7 +469749,7 @@ class FileAutocompleteProvider {
     } else if (displayBase.startsWith("/")) {
       baseDir = displayBase;
     } else {
-      baseDir = join66(this.basePath, displayBase);
+      baseDir = join67(this.basePath, displayBase);
     }
     try {
       if (!statSync21(baseDir).isDirectory()) {
@@ -469598,7 +469768,7 @@ class FileAutocompleteProvider {
     return `${toDisplayPath(displayBase)}${normalizedRelativePath}`;
   }
   scoreEntry(filePath, query2, isDirectory) {
-    const fileName = basename26(filePath);
+    const fileName = basename27(filePath);
     const lowerFileName = fileName.toLowerCase();
     const lowerQuery = query2.toLowerCase();
     let score = 0;
@@ -469636,7 +469806,7 @@ class FileAutocompleteProvider {
       for (const { path: entryPath, isDirectory } of topEntries) {
         const pathWithoutSlash = isDirectory ? entryPath.slice(0, -1) : entryPath;
         const displayPath2 = scopedQuery ? this.scopedPathForDisplay(scopedQuery.displayBase, pathWithoutSlash) : pathWithoutSlash;
-        const entryName = basename26(pathWithoutSlash);
+        const entryName = basename27(pathWithoutSlash);
         const completionPath = isDirectory ? `${displayPath2}/` : displayPath2;
         const value = buildCompletionValue(completionPath, {
           isDirectory,
@@ -469658,9 +469828,9 @@ class FileAutocompleteProvider {
 var PATH_DELIMITERS2, FD_TOOLS_DIR2, FD_BINARY_NAME2, FD_LOCAL_PATH2;
 var init_file_autocomplete = __esm(() => {
   PATH_DELIMITERS2 = new Set([" ", "\t", '"', "'", "="]);
-  FD_TOOLS_DIR2 = join66(homedir40(), ".letta", "bin");
+  FD_TOOLS_DIR2 = join67(homedir40(), ".letta", "bin");
   FD_BINARY_NAME2 = platform10() === "win32" ? "fd.exe" : "fd";
-  FD_LOCAL_PATH2 = join66(FD_TOOLS_DIR2, FD_BINARY_NAME2);
+  FD_LOCAL_PATH2 = join67(FD_TOOLS_DIR2, FD_BINARY_NAME2);
 });
 
 // src/cli/hooks/use-autocomplete-navigation.ts
@@ -472487,7 +472657,7 @@ import {
   writeFileSync as writeFileSync31
 } from "node:fs";
 import { tmpdir as tmpdir10 } from "node:os";
-import { dirname as dirname32, join as join67 } from "node:path";
+import { dirname as dirname33, join as join68 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync7(command, args, {
@@ -472708,8 +472878,8 @@ async function createLettaAgent(apiKey, name) {
   return createMinimalAgent(apiKey, name);
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync5(join67(tmpdir10(), "letta-install-github-app-"));
-  const repoDir = join67(tempDir, "repo");
+  const tempDir = mkdtempSync5(join68(tmpdir10(), "letta-install-github-app-"));
+  const repoDir = join68(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -472720,9 +472890,9 @@ function runGit5(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join67(repoDir, workflowPath);
-  if (!existsSync62(dirname32(absolutePath))) {
-    mkdirSync43(dirname32(absolutePath), { recursive: true });
+  const absolutePath = join68(repoDir, workflowPath);
+  if (!existsSync62(dirname33(absolutePath))) {
+    mkdirSync43(dirname33(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
@@ -477151,7 +477321,7 @@ __export(exports_generate_memory_viewer, {
 import { execFile as execFileCb4 } from "node:child_process";
 import { chmodSync as chmodSync8, existsSync as existsSync63, mkdirSync as mkdirSync44, writeFileSync as writeFileSync32 } from "node:fs";
 import { homedir as homedir41 } from "node:os";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 import { promisify as promisify15 } from "node:util";
 function messagesFromOverview(overview) {
   return overview.messages?.map((message) => ({
@@ -477460,7 +477630,7 @@ ${m4.body}` : m4.subject;
 async function generateAndOpenMemoryViewer(agentId, options3) {
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const repoDir = memoryRoot;
-  if (!existsSync63(join68(repoDir, ".git"))) {
+  if (!existsSync63(join69(repoDir, ".git"))) {
     throw new Error("Memory viewer requires memfs. Run /memfs enable first.");
   }
   const data = await collectMemoryData(agentId, repoDir, memoryRoot, options3?.conversationId);
@@ -477476,7 +477646,7 @@ async function generateAndOpenMemoryViewer(agentId, options3) {
   try {
     chmodSync8(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join68(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
+  const filePath = join69(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
   writeFileSync32(filePath, html5);
   chmodSync8(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -477501,13 +477671,13 @@ var init_generate_memory_viewer = __esm(() => {
   init_local_memory_context();
   init_memory_viewer_template();
   execFile17 = promisify15(execFileCb4);
-  VIEWERS_DIR = join68(homedir41(), ".letta", "viewers");
+  VIEWERS_DIR = join69(homedir41(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
 import { existsSync as existsSync64 } from "node:fs";
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i4 = 0;i4 < node.depth; i4++) {
@@ -477536,7 +477706,7 @@ function MemfsTreeViewer({
   const statusTimerRef = import_react90.useRef(null);
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const memoryExists = existsSync64(memoryRoot);
-  const hasGitRepo = import_react90.useMemo(() => existsSync64(join69(memoryRoot, ".git")), [memoryRoot]);
+  const hasGitRepo = import_react90.useMemo(() => existsSync64(join70(memoryRoot, ".git")), [memoryRoot]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
       clearTimeout(statusTimerRef.current);
@@ -479957,19 +480127,19 @@ var init_PersonalitySelector = __esm(async () => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { homedir as homedir42 } from "node:os";
-import { join as join70 } from "node:path";
+import { join as join71 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join70(homedir42(), ".aws", "credentials");
-  const configPath = join70(homedir42(), ".aws", "config");
+  const credentialsPath = join71(homedir42(), ".aws", "credentials");
+  const configPath = join71(homedir42(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile21(credentialsPath, "utf-8");
+    const content = await readFile22(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile21(configPath, "utf-8");
+    const content = await readFile22(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -481538,8 +481708,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join71 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join71(process.cwd(), SKILLS_DIR3);
+        const { join: join72 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join72(process.cwd(), SKILLS_DIR3);
         const result = await discoverSkills3(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -485443,9 +485613,9 @@ function getFileEditHeader(toolName, toolArgs) {
         } else if (operations.length === 1) {
           const op = operations[0];
           if (op) {
-            const { relative: relative15 } = __require("node:path");
+            const { relative: relative16 } = __require("node:path");
             const cwd3 = process.cwd();
-            const relPath2 = relative15(cwd3, op.path);
+            const relPath2 = relative16(cwd3, op.path);
             const displayPath3 = relPath2.startsWith("..") ? op.path : relPath2;
             if (op.kind === "add")
               return `Write to ${displayPath3}?`;
@@ -485459,9 +485629,9 @@ function getFileEditHeader(toolName, toolArgs) {
       return "Apply patch?";
     }
     const filePath = args.file_path || "";
-    const { relative: relative14 } = __require("node:path");
+    const { relative: relative15 } = __require("node:path");
     const cwd2 = process.cwd();
-    const relPath = relative14(cwd2, filePath);
+    const relPath = relative15(cwd2, filePath);
     const displayPath2 = relPath.startsWith("..") ? filePath : relPath;
     if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
       const { existsSync: existsSync65 } = __require("node:fs");
@@ -485549,9 +485719,9 @@ var init_ApprovalPreview = __esm(async () => {
               /* @__PURE__ */ jsx_dev_runtime89.jsxDEV(Box_default, {
                 flexDirection: "column",
                 children: operations.map((op, idx) => {
-                  const { relative: relative14 } = __require("node:path");
+                  const { relative: relative15 } = __require("node:path");
                   const cwd2 = process.cwd();
-                  const relPath = relative14(cwd2, op.path);
+                  const relPath = relative15(cwd2, op.path);
                   const displayPath2 = relPath.startsWith("..") ? op.path : relPath;
                   const diffKey = toolCallId ? `${toolCallId}:${op.path}` : undefined;
                   const opDiff = diffKey && allDiffs ? allDiffs.get(diffKey) : undefined;
@@ -500808,7 +500978,7 @@ __export(exports_generate_diff_viewer, {
 import { execFile as execFileCb5 } from "node:child_process";
 import { chmodSync as chmodSync9, existsSync as existsSync65, mkdirSync as mkdirSync45, writeFileSync as writeFileSync33 } from "node:fs";
 import { homedir as homedir43 } from "node:os";
-import { isAbsolute as isAbsolute25, join as join71, resolve as resolve38 } from "node:path";
+import { isAbsolute as isAbsolute25, join as join72, resolve as resolve38 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 async function runGit6(cwd2, args) {
   try {
@@ -501033,7 +501203,7 @@ async function generateAndOpenDiffViewer(targetPath) {
   try {
     chmodSync9(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join71(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
+  const filePath = join72(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
   writeFileSync33(filePath, html5);
   chmodSync9(filePath, 384);
   const skipOpen = shouldSkipOpen();
@@ -501104,7 +501274,7 @@ var init_generate_diff_viewer = __esm(() => {
   init_ssr();
   init_diff_viewer_template();
   execFile18 = promisify16(execFileCb5);
-  VIEWERS_DIR2 = join71(homedir43(), ".letta", "viewers");
+  VIEWERS_DIR2 = join72(homedir43(), ".letta", "viewers");
   GIT_MAX_BUFFER = 50 * 1024 * 1024;
 });
 
@@ -503090,7 +503260,7 @@ __export(exports_shell_aliases, {
 });
 import { existsSync as existsSync66, readFileSync as readFileSync42 } from "node:fs";
 import { homedir as homedir44 } from "node:os";
-import { join as join72 } from "node:path";
+import { join as join73 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
   if (!existsSync66(filePath)) {
@@ -503162,7 +503332,7 @@ function loadAliases(forceReload = false) {
   const home = homedir44();
   const allAliases = new Map;
   for (const file3 of ALIAS_FILES) {
-    const filePath = join72(home, file3);
+    const filePath = join73(home, file3);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -507345,7 +507515,7 @@ The deployment target for this project is CITATION-DOGFOOD-OK.
 
 // src/mods/learning-harness.ts
 import { spawn as spawn13 } from "node:child_process";
-import { access as access3, copyFile as copyFile2, mkdir as mkdir15, readFile as readFile22, writeFile as writeFile17 } from "node:fs/promises";
+import { access as access3, copyFile as copyFile2, mkdir as mkdir15, readFile as readFile23, writeFile as writeFile18 } from "node:fs/promises";
 import path42 from "node:path";
 function slugify2(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -507593,14 +507763,14 @@ async function existingPath(filePath) {
   return await fileExists(filePath) ? filePath : undefined;
 }
 async function writeJsonArtifact(filePath, value) {
-  await writeFile17(filePath, `${JSON.stringify(value, null, 2)}
+  await writeFile18(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function writeCommandArtifacts(prefix, command, args, result) {
-  await writeFile17(`${prefix}.command.txt`, `${renderCommand(command, args)}
+  await writeFile18(`${prefix}.command.txt`, `${renderCommand(command, args)}
 `, "utf8");
-  await writeFile17(`${prefix}.stdout`, result.stdout, "utf8");
-  await writeFile17(`${prefix}.stderr`, result.stderr, "utf8");
+  await writeFile18(`${prefix}.stdout`, result.stdout, "utf8");
+  await writeFile18(`${prefix}.stderr`, result.stderr, "utf8");
   await writeJsonArtifact(`${prefix}.result.json`, result);
 }
 async function prepareMemoryFiles(memoryDir, memoryFiles) {
@@ -507608,7 +507778,7 @@ async function prepareMemoryFiles(memoryDir, memoryFiles) {
   for (const [relativePath, content] of Object.entries(memoryFiles ?? {})) {
     const filePath = safeJoin(memoryDir, relativePath);
     await mkdir15(path42.dirname(filePath), { recursive: true });
-    await writeFile17(filePath, content, "utf8");
+    await writeFile18(filePath, content, "utf8");
   }
 }
 function renderEvaluationPrompt(prompt, memoryDir) {
@@ -508271,7 +508441,7 @@ function renderProposerGuide(params) {
 `;
 }
 async function writeHistoryArtifacts(params) {
-  await writeFile17(params.historyPath, renderHistoryIndex({
+  await writeFile18(params.historyPath, renderHistoryIndex({
     attempts: params.attempts,
     historyManifestPath: params.historyManifestPath,
     proposerGuidePath: params.proposerGuidePath,
@@ -508279,7 +508449,7 @@ async function writeHistoryArtifacts(params) {
     spec: params.spec
   }), "utf8");
   await writeJsonArtifact(params.historyManifestPath, buildHistoryManifest(params));
-  await writeFile17(params.proposerGuidePath, renderProposerGuide(params), "utf8");
+  await writeFile18(params.proposerGuidePath, renderProposerGuide(params), "utf8");
 }
 async function defaultCommandRunner(command, args, options3) {
   const startedAt = Date.now();
@@ -508370,7 +508540,7 @@ function createScenarioSuiteEvaluator(params) {
               outputFormat
             })
           ];
-          await writeFile17(hasConfiguredScenarios ? path42.join(scenarioDir, "prompt.md") : path42.join(context3.runDir, "eval-prompt.md"), evalPrompt, "utf8");
+          await writeFile18(hasConfiguredScenarios ? path42.join(scenarioDir, "prompt.md") : path42.join(context3.runDir, "eval-prompt.md"), evalPrompt, "utf8");
           const scenarioEvalResult = await context3.runner(context3.cliCommand, evalArgs, {
             cwd: context3.repoRoot,
             env: {
@@ -508562,7 +508732,7 @@ async function runModLearningCandidate(params) {
         outputFormat: "json"
       })
     ];
-    await writeFile17(path42.join(runDir, "generation-prompt.md"), generationPrompt, "utf8");
+    await writeFile18(path42.join(runDir, "generation-prompt.md"), generationPrompt, "utf8");
     generationResult = await params.runner(params.cliCommand, generationArgs, {
       cwd: repoRoot,
       env: {
@@ -508641,7 +508811,7 @@ async function runModLearningCandidate(params) {
     spec: options3.spec
   };
   await writeJsonArtifact(path42.join(runDir, "report.json"), report);
-  await writeFile17(reportPath, renderMarkdownReport(report), "utf8");
+  await writeFile18(reportPath, renderMarkdownReport(report), "utf8");
   await writeCandidateManifest(report);
   emitProgress("done", params.candidateCount > 1 ? `Optimization iteration ${params.candidateIndex}/${params.candidateCount} complete` : "mod optimization complete", {
     attempts: [...params.previousAttempts, summarizeAttempt(report)],
@@ -508819,7 +508989,7 @@ async function runModLearning(options3) {
     spec: normalizedOptions.spec
   });
   await writeJsonArtifact(path42.join(runDir, "report.json"), report);
-  await writeFile17(reportPath, renderMarkdownReport(report), "utf8");
+  await writeFile18(reportPath, renderMarkdownReport(report), "utf8");
   normalizedOptions.onProgress?.({
     candidateCount,
     candidateIndex: selectedCandidateIndex,
@@ -508837,7 +509007,7 @@ async function runModLearning(options3) {
   return report;
 }
 async function readModLearningEnv(envPath) {
-  return JSON.parse(await readFile22(envPath, "utf8"));
+  return JSON.parse(await readFile23(envPath, "utf8"));
 }
 var init_learning_harness = __esm(async () => {
   await init_mod_engine();
@@ -509405,7 +509575,7 @@ var init_mods = __esm(async () => {
 });
 
 // src/cli/helpers/chdir-command.ts
-import { realpath as realpath6, stat as stat14 } from "node:fs/promises";
+import { realpath as realpath6, stat as stat15 } from "node:fs/promises";
 import { homedir as homedir45 } from "node:os";
 import path44 from "node:path";
 function parseChdirCommand(input) {
@@ -509444,7 +509614,7 @@ async function resolveChdirTarget(pathArg, currentWorkingDirectory) {
   const expanded = expandHome(pathArg);
   const resolved = path44.isAbsolute(expanded) ? expanded : path44.resolve(currentWorkingDirectory, expanded);
   const normalized = await realpath6(resolved);
-  const stats = await stat14(normalized);
+  const stats = await stat15(normalized);
   if (!stats.isDirectory()) {
     throw new Error(`Not a directory: ${normalized}`);
   }
@@ -511085,7 +511255,7 @@ __export(exports_worktree_diff_list, {
   listWorktreeDiffOptions: () => listWorktreeDiffOptions
 });
 import { execFile as execFileCb6 } from "node:child_process";
-import { basename as basename27 } from "node:path";
+import { basename as basename28 } from "node:path";
 import { promisify as promisify17 } from "node:util";
 async function runGit7(cwd2, args) {
   try {
@@ -511134,7 +511304,7 @@ function parseWorktreeList(output, currentPath) {
       if (current?.path) {
         worktrees.push({
           path: current.path,
-          name: basename27(current.path),
+          name: basename28(current.path),
           branch: current.branch ?? "detached",
           head: current.head ?? "",
           isCurrent: current.path === currentPath,
@@ -511160,7 +511330,7 @@ function parseWorktreeList(output, currentPath) {
   if (current?.path) {
     worktrees.push({
       path: current.path,
-      name: basename27(current.path),
+      name: basename28(current.path),
       branch: current.branch ?? "detached",
       head: current.head ?? "",
       isCurrent: current.path === currentPath,
@@ -511229,8 +511399,8 @@ var exports_export = {};
 __export(exports_export, {
   packageSkills: () => packageSkills
 });
-import { readdir as readdir15, readFile as readFile23 } from "node:fs/promises";
-import { relative as relative14, resolve as resolve39 } from "node:path";
+import { readdir as readdir16, readFile as readFile24 } from "node:fs/promises";
+import { relative as relative15, resolve as resolve39 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
   const skillNames = new Set;
@@ -511241,7 +511411,7 @@ async function packageSkills(agentId, skillsDir) {
   ].filter((dir) => Boolean(dir));
   for (const baseDir of dirsToCheck) {
     try {
-      const entries = await readdir15(baseDir, { withFileTypes: true });
+      const entries = await readdir16(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
@@ -511250,7 +511420,7 @@ async function packageSkills(agentId, skillsDir) {
         const skillDir = resolve39(baseDir, entry.name);
         const skillMdPath = resolve39(skillDir, "SKILL.md");
         try {
-          await readFile23(skillMdPath, "utf-8");
+          await readFile24(skillMdPath, "utf-8");
         } catch {
           console.warn(`Skipping invalid skill ${entry.name}: missing SKILL.md`);
           continue;
@@ -511276,14 +511446,14 @@ async function packageSkills(agentId, skillsDir) {
 async function readSkillFiles(skillDir) {
   const files = {};
   async function walk(dir) {
-    const entries = await readdir15(dir, { withFileTypes: true });
+    const entries = await readdir16(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = resolve39(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        const content = await readFile23(fullPath, "utf-8");
-        const relativePath = relative14(skillDir, fullPath).replace(/\\/g, "/");
+        const content = await readFile24(fullPath, "utf-8");
+        const relativePath = relative15(skillDir, fullPath).replace(/\\/g, "/");
         files[relativePath] = content;
       }
     }
@@ -511420,7 +511590,7 @@ var init_conversation_switch_alert = __esm(() => {
 import { randomUUID as randomUUID33 } from "node:crypto";
 import { existsSync as existsSync67, readFileSync as readFileSync43, renameSync as renameSync7, writeFileSync as writeFileSync34 } from "node:fs";
 import { tmpdir as tmpdir11 } from "node:os";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 async function findCustomCommandByName(commandName) {
   const { findCustomCommand: findCustomCommand2 } = await Promise.resolve().then(() => (init_custom(), exports_custom));
   return findCustomCommand2(commandName);
@@ -512021,8 +512191,8 @@ ${SYSTEM_REMINDER_CLOSE}`),
           try {
             const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
             const personaCandidates = [
-              join73(memoryRoot, "system", "persona.md"),
-              join73(memoryRoot, "memory", "system", "persona.md")
+              join74(memoryRoot, "system", "persona.md"),
+              join74(memoryRoot, "memory", "system", "persona.md")
             ];
             const personaPath = personaCandidates.find((candidate) => existsSync67(candidate));
             if (personaPath) {
@@ -512881,7 +513051,7 @@ Path: ${memoryDir}`, true);
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join73(tmpdir11(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join74(tmpdir11(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync7(memoryDir, backupDir);
             if (getBackend().capabilities.localMemfs) {
               const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
@@ -513320,9 +513490,12 @@ ${SYSTEM_REMINDER_CLOSE}`;
           cmd.finish("Running memory doctor... I'll ask a few questions to refine memory structure.", true);
           const { context: gitContext } = gatherInitGitContext();
           const memoryDir = getActiveMemoryDirectory(agentId);
+          const skillNameFrontmatterRepair = await repairMissingSkillNameFrontmatter(memoryDir);
+          const skillNameFrontmatterRepairReport = formatSkillNameFrontmatterRepairReport(skillNameFrontmatterRepair);
           const doctorMessage = buildDoctorMessage({
             gitContext,
-            memoryDir
+            memoryDir,
+            skillNameFrontmatterRepairReport
           });
           await processConversationWithQueuedApprovals([
             {
@@ -513699,6 +513872,7 @@ var init_use_submit_handler = __esm(async () => {
   init_reasoning_tab_toggle();
   init_reflection_launcher();
   init_reflection_transcript();
+  init_skill_name_frontmatter_repair();
   init_system_prompt_warning();
   init_thinking_messages();
   init_command_runtime();
@@ -513731,7 +513905,7 @@ var init_use_submit_handler = __esm(async () => {
 });
 
 // src/cli/app/AppCoordinator.tsx
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 function buildStartupCommandHints(options3) {
   const {
     isResumingConversation,
@@ -515036,7 +515210,7 @@ function App2({
       agentId: a2.agentId ?? null
     }))
   });
-  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join74(modContext.memfs.memoryDir, "mods") : null;
+  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join75(modContext.memfs.memoryDir, "mods") : null;
   const modAdapter = useLocalModAdapter(modContext, {
     agentModsDirectory,
     disabled: modsDisabled
@@ -517063,7 +517237,7 @@ import {
   writeFileSync as writeFileSync35
 } from "node:fs";
 import { homedir as homedir46, platform as platform11 } from "node:os";
-import { dirname as dirname33, join as join75 } from "node:path";
+import { dirname as dirname34, join as join76 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -517095,16 +517269,16 @@ function getKeybindingsPath2(terminal) {
   }[terminal];
   const os10 = platform11();
   if (os10 === "darwin") {
-    return join75(homedir46(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join76(homedir46(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os10 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join75(appData, appName, "User", "keybindings.json");
+    return join76(appData, appName, "User", "keybindings.json");
   }
   if (os10 === "linux") {
-    return join75(homedir46(), ".config", appName, "User", "keybindings.json");
+    return join76(homedir46(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -517154,7 +517328,7 @@ function installKeybinding2(keybindingsPath) {
     if (keybindingExists2(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname33(keybindingsPath);
+    const parentDir = dirname34(keybindingsPath);
     if (!existsSync68(parentDir)) {
       mkdirSync46(parentDir, { recursive: true });
     }
@@ -517257,14 +517431,14 @@ function getWezTermConfigPath2() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join75(xdgConfig, "wezterm", "wezterm.lua");
+    const xdgPath = join76(xdgConfig, "wezterm", "wezterm.lua");
     if (existsSync68(xdgPath))
       return xdgPath;
   }
-  const configPath = join75(homedir46(), ".config", "wezterm", "wezterm.lua");
+  const configPath = join76(homedir46(), ".config", "wezterm", "wezterm.lua");
   if (existsSync68(configPath))
     return configPath;
-  return join75(homedir46(), ".wezterm.lua");
+  return join76(homedir46(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine2(line, blockCommentEnd) {
   let code2 = "";
@@ -517390,7 +517564,7 @@ function installWezTermDeleteFix2() {
       content = readFileSync44(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix2(content);
-    const parentDir = dirname33(configPath);
+    const parentDir = dirname34(configPath);
     if (!existsSync68(parentDir)) {
       mkdirSync46(parentDir, { recursive: true });
     }
@@ -517443,9 +517617,9 @@ __export(exports_settings3, {
   getSetting: () => getSetting2
 });
 import { homedir as homedir47 } from "node:os";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 function getSettingsPath2() {
-  return join76(homedir47(), ".letta", "settings.json");
+  return join77(homedir47(), ".letta", "settings.json");
 }
 async function loadSettings2() {
   const settingsPath = getSettingsPath2();
@@ -517482,7 +517656,7 @@ async function getSetting2(key2) {
   return settings3[key2];
 }
 function getProjectSettingsPath2() {
-  return join76(process.cwd(), ".letta", "settings.local.json");
+  return join77(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings2() {
   const settingsPath = getProjectSettingsPath2();
@@ -517500,7 +517674,7 @@ async function loadProjectSettings2() {
 }
 async function saveProjectSettings2(settings3) {
   const settingsPath = getProjectSettingsPath2();
-  const dirPath = join76(process.cwd(), ".letta");
+  const dirPath = join77(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -517991,8 +518165,8 @@ __export(exports_import2, {
   extractSkillsFromAf: () => extractSkillsFromAf2
 });
 import { createReadStream as createReadStream3 } from "node:fs";
-import { access as access4, chmod as chmod2, mkdir as mkdir16, readFile as readFile24, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname34, isAbsolute as isAbsolute26, relative as relative15, resolve as resolve40, sep as sep7, win32 as win326 } from "node:path";
+import { access as access4, chmod as chmod2, mkdir as mkdir16, readFile as readFile25, writeFile as writeFile19 } from "node:fs/promises";
+import { dirname as dirname35, isAbsolute as isAbsolute26, relative as relative16, resolve as resolve40, sep as sep7, win32 as win326 } from "node:path";
 function validateImportedSkillName2(name) {
   const trimmedName = name.trim();
   if (trimmedName !== name || trimmedName.length === 0 || trimmedName.length > MAX_SKILL_NAME_LENGTH || trimmedName === "." || trimmedName === ".." || !IMPORTED_SKILL_NAME_PATTERN2.test(trimmedName)) {
@@ -518003,7 +518177,7 @@ function validateImportedSkillName2(name) {
 function assertPathInside2(parent, child) {
   const parentPath = resolve40(parent);
   const childPath = resolve40(child);
-  const relativePath = relative15(parentPath, childPath);
+  const relativePath = relative16(parentPath, childPath);
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep7}`) || isAbsolute26(relativePath)) {
     throw new Error(`Imported skill file path escapes skill directory: ${child}`);
   }
@@ -518092,7 +518266,7 @@ async function importAgentFromFile2(options3) {
 }
 async function extractSkillsFromAf2(afPath, destDir) {
   const extracted = [];
-  const content = await readFile24(afPath, "utf-8");
+  const content = await readFile25(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
@@ -518120,8 +518294,8 @@ async function writeSkillFiles2(skillDir, files) {
 }
 async function writeSkillFile2(skillDir, filePath, content) {
   const fullPath = resolveImportedSkillFilePath2(skillDir, filePath);
-  await mkdir16(dirname34(fullPath), { recursive: true });
-  await writeFile18(fullPath, content, "utf-8");
+  await mkdir16(dirname35(fullPath), { recursive: true });
+  await writeFile19(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
     try {
@@ -518173,8 +518347,8 @@ function parseRegistryHandle2(handle2) {
 }
 async function importAgentFromRegistry2(options3) {
   const { tmpdir: tmpdir12 } = await import("node:os");
-  const { join: join77 } = await import("node:path");
-  const { writeFile: writeFile19, unlink: unlink5 } = await import("node:fs/promises");
+  const { join: join78 } = await import("node:path");
+  const { writeFile: writeFile20, unlink: unlink5 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle2(options3.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER2}/${AGENT_REGISTRY_REPO2}/refs/heads/${AGENT_REGISTRY_BRANCH2}/agents/@${author}/${name}/${name}.af`;
   const response = await fetch(rawUrl);
@@ -518185,8 +518359,8 @@ async function importAgentFromRegistry2(options3) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join77(tmpdir12(), `letta-import-${author}-${name}-${Date.now()}.af`);
-  await writeFile19(tempPath, afContent, "utf-8");
+  const tempPath = join78(tmpdir12(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  await writeFile20(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile2({
       filePath: tempPath,
@@ -518241,12 +518415,12 @@ __export(exports_memory_filesystem2, {
 });
 import { existsSync as existsSync69, mkdirSync as mkdirSync47 } from "node:fs";
 import { homedir as homedir48 } from "node:os";
-import { join as join77, resolve as resolve41 } from "node:path";
+import { join as join78, resolve as resolve41 } from "node:path";
 function getMemoryFilesystemRoot2(agentId, homeDir = homedir48()) {
-  return join77(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
+  return join78(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
 }
 function getMemorySystemDir2(agentId, homeDir = homedir48()) {
-  return join77(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
+  return join78(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
 }
 function getScopedMemoryFilesystemRoot2(agentId, options3 = {}) {
   const env6 = options3.env ?? process.env;
@@ -518592,7 +518766,7 @@ __export(exports_secrets_store2, {
   __testOverrideLocalSecretStorage: () => __testOverrideLocalSecretStorage2
 });
 import { existsSync as existsSync70, mkdirSync as mkdirSync48, readFileSync as readFileSync45, writeFileSync as writeFileSync36 } from "node:fs";
-import { dirname as dirname35, join as join78 } from "node:path";
+import { dirname as dirname36, join as join79 } from "node:path";
 function __testOverrideSecretsBackend2(backend4) {
   testBackendOverride2 = backend4;
 }
@@ -518603,7 +518777,7 @@ function getSecretsBackend2() {
   return testBackendOverride2 ?? getBackend();
 }
 function getFileBackedLocalSecretsPath2() {
-  return join78(getLocalBackendStorageDir(), FILE_BACKED_LOCAL_SECRETS_PATH2);
+  return join79(getLocalBackendStorageDir(), FILE_BACKED_LOCAL_SECRETS_PATH2);
 }
 function readFileBackedLocalSecrets2() {
   const filePath = getFileBackedLocalSecretsPath2();
@@ -518620,7 +518794,7 @@ function readFileBackedLocalSecrets2() {
 }
 function writeFileBackedLocalSecrets2(secrets2) {
   const filePath = getFileBackedLocalSecretsPath2();
-  mkdirSync48(dirname35(filePath), { mode: 448, recursive: true });
+  mkdirSync48(dirname36(filePath), { mode: 448, recursive: true });
   writeFileSync36(filePath, `${JSON.stringify({ secrets: secrets2 }, null, 2)}
 `, {
     encoding: "utf8",
@@ -518916,7 +519090,7 @@ var init_secrets_store2 = __esm(() => {
   init_backend2();
   init_paths();
   init_secrets();
-  FILE_BACKED_LOCAL_SECRETS_PATH2 = join78("secrets", "local-agent-secrets.json");
+  FILE_BACKED_LOCAL_SECRETS_PATH2 = join79("secrets", "local-agent-secrets.json");
   SECRETS_CACHE_KEY2 = Symbol.for("@letta/secretsCache");
   LOCAL_SECRET_NAME_PATTERN2 = /^[A-Z_][A-Z0-9_]*$/;
 });
@@ -525430,8 +525604,8 @@ import {
   unlinkSync as unlinkSync7
 } from "node:fs";
 import { homedir as homedir30 } from "node:os";
-import { join as join49 } from "node:path";
-var REMOTE_LOG_DIR = join49(homedir30(), ".letta", "logs", "remote");
+import { join as join50 } from "node:path";
+var REMOTE_LOG_DIR = join50(homedir30(), ".letta", "logs", "remote");
 var MAX_LOG_FILES = 10;
 function formatTimestamp2() {
   const now = new Date;
@@ -525450,7 +525624,7 @@ function pruneOldLogs() {
       const toDelete = files.slice(0, files.length - MAX_LOG_FILES + 1);
       for (const file3 of toDelete) {
         try {
-          unlinkSync7(join49(REMOTE_LOG_DIR, file3));
+          unlinkSync7(join50(REMOTE_LOG_DIR, file3));
         } catch {}
       }
     }
@@ -525463,7 +525637,7 @@ class RemoteSessionLog {
   constructor() {
     const now = new Date;
     const stamp = now.toISOString().replace(/[:.]/g, "-");
-    this.path = join49(REMOTE_LOG_DIR, `${stamp}.log`);
+    this.path = join50(REMOTE_LOG_DIR, `${stamp}.log`);
   }
   init() {
     this.ensureDir();
@@ -526092,7 +526266,7 @@ import {
   readFileSync as readFileSync32,
   writeFileSync as writeFileSync23
 } from "node:fs";
-import { join as join50 } from "node:path";
+import { join as join51 } from "node:path";
 function readJsonl(path37) {
   if (!existsSync47(path37))
     return [];
@@ -526375,7 +526549,7 @@ function convertMessages4(messages, mode, nextId2) {
 }
 function migrateLocalBackendTranscripts(input) {
   const storageDir = input.storageDir;
-  const conversationsDir = join50(storageDir, "conversations");
+  const conversationsDir = join51(storageDir, "conversations");
   const result = {
     storageDir,
     converted: [],
@@ -526385,9 +526559,9 @@ function migrateLocalBackendTranscripts(input) {
   if (!existsSync47(conversationsDir))
     return result;
   for (const name of readdirSync17(conversationsDir)) {
-    const conversationDir = join50(conversationsDir, name);
-    const messagesPath = join50(conversationDir, "messages.jsonl");
-    const manifestPath = join50(conversationDir, "manifest.json");
+    const conversationDir = join51(conversationsDir, name);
+    const messagesPath = join51(conversationDir, "messages.jsonl");
+    const manifestPath = join51(conversationDir, "manifest.json");
     const hasManifest = existsSync47(manifestPath);
     const existingManifest = hasManifest ? (() => {
       try {
@@ -526430,7 +526604,7 @@ function migrateLocalBackendTranscripts(input) {
     const backupPath = `${messagesPath}.pre-pi-backup-${timestampSuffix()}`;
     if (!input.dryRun) {
       copyFileSync2(messagesPath, backupPath);
-      const conversationPath = join50(conversationDir, "conversation.json");
+      const conversationPath = join51(conversationDir, "conversation.json");
       let conversation;
       if (existsSync47(conversationPath)) {
         try {
@@ -526543,8 +526717,8 @@ init_memory_filesystem2();
 init_memory_git();
 init_paths();
 import { cpSync, existsSync as existsSync48, mkdirSync as mkdirSync33, rmSync as rmSync10, statSync as statSync17 } from "node:fs";
-import { readdir as readdir11 } from "node:fs/promises";
-import { dirname as dirname24, join as join51 } from "node:path";
+import { readdir as readdir12 } from "node:fs/promises";
+import { dirname as dirname25, join as join52 } from "node:path";
 import { parseArgs as parseArgs9 } from "node:util";
 
 // src/cli/subcommands/memory-tokens.ts
@@ -526682,7 +526856,7 @@ function getMemoryRoot(agentId) {
   return getScopedMemoryFilesystemRoot(agentId);
 }
 function getAgentRoot(agentId) {
-  return dirname24(getMemoryRoot(agentId));
+  return dirname25(getMemoryRoot(agentId));
 }
 function formatBackupTimestamp(date6 = new Date) {
   const pad = (value) => String(value).padStart(2, "0");
@@ -526699,18 +526873,18 @@ async function listBackups(agentId) {
   if (!existsSync48(agentRoot)) {
     return [];
   }
-  const entries = await readdir11(agentRoot, { withFileTypes: true });
+  const entries = await readdir12(agentRoot, { withFileTypes: true });
   const backups = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (!entry.name.startsWith("memory-backup-"))
       continue;
-    const path37 = join51(agentRoot, entry.name);
+    const path37 = join52(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat13 = statSync17(path37);
-      createdAt = stat13.mtime.toISOString();
+      const stat14 = statSync17(path37);
+      createdAt = stat14.mtime.toISOString();
     } catch {
       createdAt = null;
     }
@@ -526723,7 +526897,7 @@ function resolveBackupPath(agentId, from) {
   if (from.startsWith("/") || /^[A-Za-z]:[/\\]/.test(from)) {
     return from;
   }
-  return join51(getAgentRoot(agentId), from);
+  return join52(getAgentRoot(agentId), from);
 }
 async function runMemorySubcommand(argv) {
   let parsed;
@@ -526805,7 +526979,7 @@ async function runMemorySubcommand(argv) {
       }
       const agentRoot = getAgentRoot(agentId);
       const backupName = `memory-backup-${formatBackupTimestamp()}`;
-      const backupPath = join51(agentRoot, backupName);
+      const backupPath = join52(agentRoot, backupName);
       if (existsSync48(backupPath)) {
         console.error(`Backup already exists at ${backupPath}`);
         return 1;
@@ -526834,8 +527008,8 @@ async function runMemorySubcommand(argv) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat13 = statSync17(backupPath);
-      if (!stat13.isDirectory()) {
+      const stat14 = statSync17(backupPath);
+      if (!stat14.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
       }
@@ -526857,9 +527031,9 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       if (existsSync48(out)) {
-        const stat13 = statSync17(out);
-        if (stat13.isDirectory()) {
-          const contents = await readdir11(out);
+        const stat14 = statSync17(out);
+        if (stat14.isDirectory()) {
+          const contents = await readdir12(out);
           if (contents.length > 0) {
             console.error(`Export directory not empty: ${out}`);
             return 1;
@@ -526888,7 +527062,7 @@ async function runMemorySubcommand(argv) {
 init_backend2();
 init_message_search();
 init_settings_manager();
-import { writeFile as writeFile14 } from "node:fs/promises";
+import { writeFile as writeFile15 } from "node:fs/promises";
 import { resolve as resolve30 } from "node:path";
 import { parseArgs as parseArgs10 } from "node:util";
 function printUsage7() {
@@ -527233,7 +527407,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
 `).trim();
       if (outputPathRaw && typeof outputPathRaw === "string") {
         const outputPath = resolve30(process.cwd(), outputPathRaw);
-        await writeFile14(outputPath, `${transcript}
+        await writeFile15(outputPath, `${transcript}
 `, "utf-8");
         console.log(JSON.stringify({
           conversation_id: conversationId,
@@ -527263,7 +527437,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
 // src/cli/subcommands/mods.ts
 init_memory_filesystem2();
 await init_mod_engine();
-import { dirname as dirname25, join as join53 } from "node:path";
+import { dirname as dirname26, join as join54 } from "node:path";
 import { parseArgs as parseArgs11 } from "node:util";
 
 // src/mods/package-installer.ts
@@ -527297,8 +527471,8 @@ function isRecord10(value) {
 function isPathInsideOrEqual2(childPath, parentPath) {
   const child = path37.resolve(childPath);
   const parent = path37.resolve(parentPath);
-  const relative11 = path37.relative(parent, child);
-  return relative11 === "" || !!relative11 && !relative11.startsWith("..") && !path37.isAbsolute(relative11);
+  const relative12 = path37.relative(parent, child);
+  return relative12 === "" || !!relative12 && !relative12.startsWith("..") && !path37.isAbsolute(relative12);
 }
 function readPackageJson(packageJsonPath) {
   let parsed;
@@ -528316,10 +528490,10 @@ function getExplicitAgentId(values2) {
   return typeof explicitAgent === "string" && explicitAgent.trim() ? explicitAgent.trim() : null;
 }
 function getAgentModsDirectory(agentId) {
-  return join53(getScopedMemoryFilesystemRoot(agentId), "mods");
+  return join54(getScopedMemoryFilesystemRoot(agentId), "mods");
 }
 function directFilesForSource(source2) {
-  return source2.files.filter((file3) => dirname25(file3) === source2.root);
+  return source2.files.filter((file3) => dirname26(file3) === source2.root);
 }
 function toSection(source2) {
   return {
@@ -528652,9 +528826,9 @@ import {
   statSync as statSync19,
   writeFileSync as writeFileSync26
 } from "node:fs";
-import { mkdir as mkdir12, readdir as readdir12 } from "node:fs/promises";
+import { mkdir as mkdir12, readdir as readdir13 } from "node:fs/promises";
 import { tmpdir as tmpdir9 } from "node:os";
-import { basename as basename23, dirname as dirname26, join as join54, normalize as normalize5, resolve as resolve31, sep as sep5 } from "node:path";
+import { basename as basename24, dirname as dirname27, join as join55, normalize as normalize5, resolve as resolve31, sep as sep5 } from "node:path";
 import { parseArgs as parseArgs12, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
 init_paths2();
 var HERMES_REPO_URL = "https://github.com/NousResearch/hermes-agent.git";
@@ -528829,7 +529003,7 @@ function parseGitHubSpecifier(input) {
       return {
         repoUrl,
         branch: null,
-        subdir: marker === "blob" ? dirname26(treePath) : treePath
+        subdir: marker === "blob" ? dirname27(treePath) : treePath
       };
     }
     return { repoUrl, branch: null, subdir: null };
@@ -528862,7 +529036,7 @@ function parseDirectSkillFileUrlSpecifier(input) {
   if (url2.protocol !== "https:" && !(url2.protocol === "http:" && isLocalhostHostname(url2.hostname))) {
     return null;
   }
-  if (basename23(url2.pathname).toLowerCase() !== "skill.md")
+  if (basename24(url2.pathname).toLowerCase() !== "skill.md")
     return null;
   return { url: url2.toString() };
 }
@@ -528959,14 +529133,14 @@ async function resolveBranchAndSubdir(location) {
 }
 async function cloneSkillSource(location) {
   const resolvedLocation = await resolveBranchAndSubdir(location);
-  const tmpDir = mkdtempSync4(join54(tmpdir9(), "letta-skill-install-"));
+  const tmpDir = mkdtempSync4(join55(tmpdir9(), "letta-skill-install-"));
   const args = ["clone", "--depth", "1"];
   if (resolvedLocation.branch) {
     args.push("--branch", resolvedLocation.branch);
   }
   args.push(resolvedLocation.repoUrl, tmpDir);
   await execFile15("git", args, { timeout: 120000 });
-  const sourceDir = resolvedLocation.subdir ? join54(tmpDir, resolvedLocation.subdir) : tmpDir;
+  const sourceDir = resolvedLocation.subdir ? join55(tmpDir, resolvedLocation.subdir) : tmpDir;
   return { tmpDir, sourceDir };
 }
 function assertDirectSkillFileSize(receivedBytes, maxBytes) {
@@ -529021,11 +529195,11 @@ async function downloadDirectSkillFileSource(location, options3 = {}) {
     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 = mkdtempSync4(join54(tmpdir9(), "letta-direct-skill-"));
+  const tmpDir = mkdtempSync4(join55(tmpdir9(), "letta-direct-skill-"));
   try {
-    const sourceDir = join54(tmpDir, "skill");
+    const sourceDir = join55(tmpDir, "skill");
     await mkdir12(sourceDir, { recursive: true });
-    writeFileSync26(join54(sourceDir, "SKILL.md"), skillText, "utf8");
+    writeFileSync26(join55(sourceDir, "SKILL.md"), skillText, "utf8");
     return { tmpDir, sourceDir };
   } catch (error54) {
     rmSync13(tmpDir, { recursive: true, force: true });
@@ -529066,9 +529240,9 @@ function assertSafeZipMember(name) {
 }
 async function downloadClawHubSkillSource(location) {
   const version2 = await resolveClawHubVersion(location);
-  const tmpDir = mkdtempSync4(join54(tmpdir9(), "letta-clawhub-skill-"));
-  const zipPath = join54(tmpDir, "skill.zip");
-  const sourceDir = join54(tmpDir, "skill");
+  const tmpDir = mkdtempSync4(join55(tmpdir9(), "letta-clawhub-skill-"));
+  const zipPath = join55(tmpDir, "skill.zip");
+  const sourceDir = join55(tmpDir, "skill");
   await mkdir12(sourceDir, { recursive: true });
   const url2 = new URL(`${CLAWHUB_API_BASE_URL}/download`);
   url2.searchParams.set("slug", location.slug);
@@ -529107,16 +529281,16 @@ function sanitizeSkillName(name) {
   return trimmed;
 }
 function getSkillName(sourceDir) {
-  const skillMd = readFileSync35(join54(sourceDir, "SKILL.md"), "utf8");
+  const skillMd = readFileSync35(join55(sourceDir, "SKILL.md"), "utf8");
   const { frontmatter } = parseFrontmatter(skillMd);
   const frontmatterName = frontmatter.name;
-  const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename23(sourceDir);
+  const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename24(sourceDir);
   return sanitizeSkillName(name);
 }
 async function installSkillDirectory(params) {
   const sourceDir = resolve31(params.sourceDir);
   const memoryDir = resolve31(params.memoryDir);
-  const skillMdPath = join54(sourceDir, "SKILL.md");
+  const skillMdPath = join55(sourceDir, "SKILL.md");
   if (!existsSync52(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
@@ -529124,8 +529298,8 @@ async function installSkillDirectory(params) {
     throw new Error(`Skill source is not a directory: ${sourceDir}`);
   }
   const name = getSkillName(sourceDir);
-  const skillsDir = join54(memoryDir, "skills");
-  const targetPath = join54(skillsDir, name);
+  const skillsDir = join55(memoryDir, "skills");
+  const targetPath = join55(skillsDir, name);
   assertInside(skillsDir, targetPath);
   if (existsSync52(targetPath)) {
     if (!params.force) {
@@ -529136,22 +529310,22 @@ async function installSkillDirectory(params) {
   await mkdir12(skillsDir, { recursive: true });
   cpSync2(sourceDir, targetPath, {
     recursive: true,
-    filter: (source2) => basename23(source2) !== ".git"
+    filter: (source2) => basename24(source2) !== ".git"
   });
   return { name, path: normalize5(targetPath) };
 }
 async function listSkillDirectories(params) {
   const memoryDir = resolve31(params.memoryDir);
-  const skillsDir = join54(memoryDir, "skills");
+  const skillsDir = join55(memoryDir, "skills");
   if (!existsSync52(skillsDir))
     return [];
-  const entries = await readdir12(skillsDir, { withFileTypes: true });
+  const entries = await readdir13(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const skillDir = join54(skillsDir, entry.name);
-    const skillMdPath = join54(skillDir, "SKILL.md");
+    const skillDir = join55(skillsDir, entry.name);
+    const skillMdPath = join55(skillDir, "SKILL.md");
     if (!existsSync52(skillMdPath))
       continue;
     let name = entry.name;
@@ -529172,9 +529346,9 @@ async function listSkillDirectories(params) {
 }
 async function deleteSkillDirectory(params) {
   const memoryDir = resolve31(params.memoryDir);
-  const skillsDir = join54(memoryDir, "skills");
+  const skillsDir = join55(memoryDir, "skills");
   const name = sanitizeSkillName(params.name);
-  const targetPath = join54(skillsDir, name);
+  const targetPath = join55(skillsDir, name);
   assertInside(skillsDir, targetPath);
   if (!existsSync52(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
@@ -529671,7 +529845,7 @@ init_secrets();
 import { randomUUID as randomUUID24 } from "node:crypto";
 import { readFileSync as readFileSync36 } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { join as join55, resolve as resolve32 } from "node:path";
+import { join as join56, resolve as resolve32 } from "node:path";
 var OBSOLETE_SETTINGS_KEYS2 = [
   "reflectionBehavior",
   "enableSleeptime",
@@ -530114,7 +530288,7 @@ class SettingsManager2 {
       return;
     const settingsPath = this.getSettingsPath();
     const home = process.env.HOME || homedir31();
-    const dirPath = join55(home, ".letta");
+    const dirPath = join56(home, ".letta");
     try {
       if (!exists(dirPath)) {
         await mkdir(dirPath, { recursive: true });
@@ -530155,7 +530329,7 @@ class SettingsManager2 {
     if (!settings3)
       return;
     const settingsPath = this.getProjectSettingsPath(workingDirectory);
-    const dirPath = join55(workingDirectory, ".letta");
+    const dirPath = join56(workingDirectory, ".letta");
     try {
       let existingSettings = {};
       if (exists(settingsPath)) {
@@ -530177,16 +530351,16 @@ class SettingsManager2 {
   }
   getSettingsPath() {
     const home = process.env.HOME || homedir31();
-    return join55(home, ".letta", "settings.json");
+    return join56(home, ".letta", "settings.json");
   }
   getProjectSettingsPath(workingDirectory) {
-    return join55(workingDirectory, ".letta", "settings.json");
+    return join56(workingDirectory, ".letta", "settings.json");
   }
   isProjectSettingsPathCollidingWithGlobal(workingDirectory) {
     return resolve32(this.getProjectSettingsPath(workingDirectory)) === resolve32(this.getSettingsPath());
   }
   getLocalProjectSettingsPath(workingDirectory) {
-    return join55(workingDirectory, ".letta", "settings.local.json");
+    return join56(workingDirectory, ".letta", "settings.local.json");
   }
   async loadLocalProjectSettings(workingDirectory = process.cwd()) {
     const cached3 = this.localProjectSettings.get(workingDirectory);
@@ -530247,7 +530421,7 @@ class SettingsManager2 {
     if (!settings3)
       return;
     const settingsPath = this.getLocalProjectSettingsPath(workingDirectory);
-    const dirPath = join55(workingDirectory, ".letta");
+    const dirPath = join56(workingDirectory, ".letta");
     try {
       if (!exists(dirPath)) {
         await mkdir(dirPath, { recursive: true });
@@ -530596,7 +530770,7 @@ class SettingsManager2 {
     });
   }
   hasLocalLettaDir(workingDirectory = process.cwd()) {
-    const dirPath = join55(workingDirectory, ".letta");
+    const dirPath = join56(workingDirectory, ".letta");
     return exists(dirPath);
   }
   storeOAuthState(state, codeVerifier, redirectUri, provider) {
@@ -531229,8 +531403,8 @@ function markMilestone2(name) {
     firstMilestoneTime2 = now;
   }
   if (isTimingsEnabled2()) {
-    const relative11 = now - firstMilestoneTime2;
-    console.error(`[timing] MILESTONE ${name} at +${formatDuration3(relative11)} (${formatTimestamp4(new Date)})`);
+    const relative12 = now - firstMilestoneTime2;
+    console.error(`[timing] MILESTONE ${name} at +${formatDuration3(relative12)} (${formatTimestamp4(new Date)})`);
   }
 }
 
@@ -531367,12 +531541,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join79 } = await import("path");
+  const { join: join80 } = await import("path");
   const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_version2(), exports_version2));
   const { SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills4(), exports_skills3));
   const { exists: exists3 } = await Promise.resolve().then(() => (init_fs2(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join79(cwd2, SKILLS_DIR3);
+  const skillsDir = join80(cwd2, SKILLS_DIR3);
   const skillsExist = exists3(skillsDir);
   await settingsManager2.loadLocalProjectSettings(cwd2);
   const pinned = settingsManager2.getPinnedAgents();
@@ -532978,4 +533152,4 @@ Error during initialization: ${message}`);
 }
 main2();
 
-//# debugId=653353B267C6711064756E2164756E21
+//# debugId=CD2C04A4505B2DC064756E2164756E21