@letta-ai/letta-code 0.27.23 → 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.23",
+    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);
@@ -6533,11 +6534,13 @@ var init_skill_sources = __esm(() => {
 // src/agent/context.ts
 var exports_context = {};
 __export(exports_context, {
+  setCurrentAgentName: () => setCurrentAgentName,
   setCurrentAgentId: () => setCurrentAgentId,
   setConversationId: () => setConversationId,
   setAgentContext: () => setAgentContext,
   getSkillsDirectory: () => getSkillsDirectory,
   getSkillSources: () => getSkillSources,
+  getCurrentAgentName: () => getCurrentAgentName,
   getCurrentAgentId: () => getCurrentAgentId,
   getConversationId: () => getConversationId
 });
@@ -6546,6 +6549,7 @@ function getContext() {
   if (!global2[CONTEXT_KEY]) {
     global2[CONTEXT_KEY] = {
       agentId: null,
+      agentName: null,
       skillsDirectory: null,
       skillSources: [...ALL_SKILL_SOURCES],
       conversationId: null
@@ -6553,24 +6557,43 @@ function getContext() {
   }
   return global2[CONTEXT_KEY];
 }
-function setAgentContext(agentId, skillsDirectory, skillSources) {
+function setAgentContext(agentId, skillsDirectory, skillSources, agentName) {
   context.agentId = agentId;
+  context.agentName = normalizeAgentName(agentName);
   context.skillsDirectory = skillsDirectory || null;
   context.skillSources = skillSources !== undefined ? [...skillSources] : [...ALL_SKILL_SOURCES];
   if (getRuntimeContext()) {
     updateRuntimeContext({
       agentId,
+      agentName: context.agentName,
       skillsDirectory: skillsDirectory || null,
       skillSources: skillSources !== undefined ? [...skillSources] : [...ALL_SKILL_SOURCES]
     });
   }
 }
 function setCurrentAgentId(agentId) {
+  const agentChanged = context.agentId !== agentId;
   context.agentId = agentId;
+  if (agentId === null || agentChanged) {
+    context.agentName = null;
+  }
   if (getRuntimeContext()) {
-    updateRuntimeContext({ agentId });
+    updateRuntimeContext({
+      agentId,
+      ...agentId === null || agentChanged ? { agentName: null } : {}
+    });
   }
 }
+function setCurrentAgentName(agentName) {
+  context.agentName = normalizeAgentName(agentName);
+  if (getRuntimeContext()) {
+    updateRuntimeContext({ agentName: context.agentName });
+  }
+}
+function normalizeAgentName(agentName) {
+  const trimmed = typeof agentName === "string" ? agentName.trim() : "";
+  return trimmed || null;
+}
 function getCurrentAgentId() {
   const runtimeContext = getRuntimeContext();
   if (runtimeContext && "agentId" in runtimeContext) {
@@ -6584,6 +6607,14 @@ function getCurrentAgentId() {
   }
   return context.agentId;
 }
+function getCurrentAgentName() {
+  const runtimeContext = getRuntimeContext();
+  if (runtimeContext && "agentName" in runtimeContext) {
+    const trimmed = runtimeContext.agentName?.trim();
+    return trimmed || null;
+  }
+  return context.agentName;
+}
 function getSkillsDirectory() {
   const runtimeContext = getRuntimeContext();
   if (runtimeContext && "skillsDirectory" in runtimeContext) {
@@ -141240,6 +141271,10 @@ There are two ways to change memory:
 - **The \`memory\` tool (shorthand).** Use it for small, targeted edits. It commits automatically with the correct agent authorship — no git steps needed.
 - **Direct file edits (full control).** For larger changes — restructuring directories, rewriting several blocks — edit the projected files directly, then commit:
 
+Memory markdown files must start with YAML frontmatter containing a non-empty \`description:\` field. The \`memory\` and \`memory_apply_patch\` tools add and preserve this automatically; when using raw file edits, preserve existing frontmatter or add it before committing. The MemFS pre-commit hook enforces this requirement, rejects unknown keys, and prevents changes to protected \`read_only\` files. Skill \`SKILL.md\` files use their own skill frontmatter format.
+
+\`$AGENT_NAME\` is normally populated when the runtime knows the current agent name, but direct shell environments can still miss it. Use a non-empty author name fallback when committing directly.
+
 \`\`\`bash
 cd "$MEMORY_DIR"
 
@@ -141247,8 +141282,9 @@ cd "$MEMORY_DIR"
 git status
 
 # Commit your changes
-git add .
-git commit --author="$AGENT_NAME <$AGENT_ID@letta.com>" -m "<type>: <what changed>"
+git add <specific files>
+author_name="\${AGENT_NAME:-$AGENT_ID}"
+git commit --author="$author_name <$AGENT_ID@letta.com>" -m "<type>: <what changed>"
 \`\`\`
 
 Your context is git-tracked, so you can always inspect or revert past changes:
@@ -144697,7 +144733,8 @@ var init_models7 = __esm(() => {
           context_window: 140000,
           max_output_tokens: 28000,
           parallel_tool_calls: true
-        }
+        },
+        isFeatured: true
       },
       {
         id: "auto-chat",
@@ -144722,7 +144759,8 @@ var init_models7 = __esm(() => {
           context_window: 200000,
           max_output_tokens: 28000,
           parallel_tool_calls: true
-        }
+        },
+        isFeatured: true
       },
       {
         id: "fable",
@@ -144731,7 +144769,7 @@ var init_models7 = __esm(() => {
         description: "Fable 5 (high reasoning)",
         isFeatured: true,
         updateArgs: {
-          context_window: 1e6,
+          context_window: 200000,
           max_output_tokens: 128000,
           enable_reasoner: true,
           reasoning_effort: "high",
@@ -144744,7 +144782,7 @@ var init_models7 = __esm(() => {
         label: "Fable 5",
         description: "Fable 5 (low reasoning)",
         updateArgs: {
-          context_window: 1e6,
+          context_window: 200000,
           max_output_tokens: 128000,
           enable_reasoner: true,
           reasoning_effort: "low",
@@ -144758,7 +144796,7 @@ var init_models7 = __esm(() => {
         label: "Fable 5",
         description: "Fable 5 (med reasoning)",
         updateArgs: {
-          context_window: 1e6,
+          context_window: 200000,
           max_output_tokens: 128000,
           enable_reasoner: true,
           reasoning_effort: "medium",
@@ -144772,7 +144810,7 @@ var init_models7 = __esm(() => {
         label: "Fable 5",
         description: "Fable 5 (extra-high reasoning)",
         updateArgs: {
-          context_window: 1e6,
+          context_window: 200000,
           max_output_tokens: 128000,
           enable_reasoner: true,
           reasoning_effort: "xhigh",
@@ -144785,7 +144823,74 @@ var init_models7 = __esm(() => {
         label: "Fable 5",
         description: "Fable 5 (max reasoning)",
         updateArgs: {
-          context_window: 1e6,
+          context_window: 200000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "max",
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "fable-1m",
+        handle: "anthropic/claude-fable-5",
+        label: "Fable 5 1M",
+        description: "Claude Fable 5 with 1M token context window (high reasoning)",
+        updateArgs: {
+          context_window: 950000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "high",
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "fable-1m-low",
+        handle: "anthropic/claude-fable-5",
+        label: "Fable 5 1M",
+        description: "Fable 5 1M (low reasoning)",
+        updateArgs: {
+          context_window: 950000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "low",
+          max_reasoning_tokens: 4000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "fable-1m-medium",
+        handle: "anthropic/claude-fable-5",
+        label: "Fable 5 1M",
+        description: "Fable 5 1M (med reasoning)",
+        updateArgs: {
+          context_window: 950000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "medium",
+          max_reasoning_tokens: 12000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "fable-1m-xhigh",
+        handle: "anthropic/claude-fable-5",
+        label: "Fable 5 1M",
+        description: "Fable 5 1M (extra-high reasoning)",
+        updateArgs: {
+          context_window: 950000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "xhigh",
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "fable-1m-max",
+        handle: "anthropic/claude-fable-5",
+        label: "Fable 5 1M",
+        description: "Fable 5 1M (max reasoning)",
+        updateArgs: {
+          context_window: 950000,
           max_output_tokens: 128000,
           enable_reasoner: true,
           reasoning_effort: "max",
@@ -144884,8 +144989,7 @@ var init_models7 = __esm(() => {
           reasoning_effort: "high",
           enable_reasoner: true,
           parallel_tool_calls: true
-        },
-        isFeatured: true
+        }
       },
       {
         id: "opus-4.8-1m-no-reasoning",
@@ -145148,7 +145252,6 @@ var init_models7 = __esm(() => {
         handle: "anthropic/claude-sonnet-4-6",
         label: "Sonnet 4.6 1M",
         description: "Claude Sonnet 4.6 with 1M token context window (high reasoning)",
-        isFeatured: true,
         updateArgs: {
           context_window: 9500000,
           max_output_tokens: 128000,
@@ -146030,7 +146133,6 @@ var init_models7 = __esm(() => {
         handle: "openai/gpt-5.4",
         label: "GPT-5.4",
         description: "OpenAI's most capable model (high reasoning)",
-        isFeatured: true,
         updateArgs: {
           reasoning_effort: "high",
           verbosity: "medium",
@@ -146187,7 +146289,6 @@ var init_models7 = __esm(() => {
         handle: "openai/gpt-5.4-mini",
         label: "GPT-5.4 Mini",
         description: "Fast, efficient GPT-5.4 variant (med reasoning)",
-        isFeatured: true,
         updateArgs: {
           reasoning_effort: "medium",
           verbosity: "low",
@@ -146400,7 +146501,8 @@ var init_models7 = __esm(() => {
           context_window: 1048576,
           max_output_tokens: 384000,
           parallel_tool_calls: true
-        }
+        },
+        isFeatured: true
       },
       {
         id: "glm-5.2",
@@ -146444,7 +146546,6 @@ var init_models7 = __esm(() => {
         handle: "minimax/MiniMax-M2.7",
         label: "MiniMax 2.7",
         description: "MiniMax's M2.7 coding model",
-        isFeatured: true,
         free: true,
         updateArgs: {
           context_window: 160000,
@@ -151819,12 +151920,14 @@ var init_commands = __esm(() => {
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile6 } from "node:fs/promises";
 import { basename as basename6, extname as extname3, join as join12 } from "node:path";
-function mapSlackThreadMessage(message) {
+async function mapSlackThreadMessage(message, attachmentOptions) {
+  const attachments = await resolveSlackMessageAttachments(message, attachmentOptions);
   return {
     text: resolveSlackThreadMessageText(message),
     userId: isNonEmptyString2(message.user) ? message.user : undefined,
     botId: isNonEmptyString2(message.bot_id) ? message.bot_id : undefined,
-    ts: isNonEmptyString2(message.ts) ? message.ts : undefined
+    ts: isNonEmptyString2(message.ts) ? message.ts : undefined,
+    ...attachments.length > 0 ? { attachments } : {}
   };
 }
 function asRecord(value) {
@@ -152128,12 +152231,11 @@ function collectSlackFiles(rawEvent) {
   }
   return Array.from(deduped.values()).slice(0, MAX_SLACK_ATTACHMENTS);
 }
-async function resolveSlackInboundAttachments(params) {
-  const files = collectSlackFiles(params.rawEvent);
-  if (files.length === 0) {
+async function resolveSlackFilesAsAttachments(params) {
+  if (params.files.length === 0) {
     return [];
   }
-  const resolved = await Promise.all(files.map((file3) => downloadSlackAttachment({
+  const resolved = await Promise.all(params.files.map((file3) => downloadSlackAttachment({
     accountId: params.accountId,
     token: params.token,
     file: file3,
@@ -152141,6 +152243,44 @@ async function resolveSlackInboundAttachments(params) {
   }).catch(() => null)));
   return resolved.filter((attachment) => Boolean(attachment));
 }
+function resolveSlackThreadAttachmentOptions(params) {
+  if (!isNonEmptyString2(params.accountId) || !isNonEmptyString2(params.token)) {
+    return;
+  }
+  return {
+    accountId: params.accountId,
+    token: params.token,
+    transcribeVoice: params.transcribeVoice
+  };
+}
+function hasSlackThreadMessageContent(message, attachmentOptions) {
+  if (resolveSlackThreadMessageText(message)) {
+    return true;
+  }
+  return Boolean(attachmentOptions && collectSlackFiles(message).length > 0);
+}
+function hasHydratedSlackThreadMessageContent(message) {
+  return message.text.length > 0 || Boolean(message.attachments?.length);
+}
+async function resolveSlackMessageAttachments(message, attachmentOptions) {
+  if (!attachmentOptions) {
+    return [];
+  }
+  return resolveSlackFilesAsAttachments({
+    accountId: attachmentOptions.accountId,
+    token: attachmentOptions.token,
+    files: collectSlackFiles(message),
+    transcribeVoice: attachmentOptions.transcribeVoice
+  });
+}
+async function resolveSlackInboundAttachments(params) {
+  return resolveSlackFilesAsAttachments({
+    accountId: params.accountId,
+    token: params.token,
+    files: collectSlackFiles(params.rawEvent),
+    transcribeVoice: params.transcribeVoice
+  });
+}
 async function resolveSlackThreadStarter(params) {
   try {
     const response = await params.client.conversations.replies({
@@ -152153,16 +152293,12 @@ async function resolveSlackThreadStarter(params) {
     if (!message) {
       return null;
     }
-    const text = resolveSlackThreadMessageText(message);
-    if (!text) {
+    const attachmentOptions = resolveSlackThreadAttachmentOptions(params);
+    if (!hasSlackThreadMessageContent(message, attachmentOptions)) {
       return null;
     }
-    return {
-      text,
-      userId: isNonEmptyString2(message.user) ? message.user : undefined,
-      botId: isNonEmptyString2(message.bot_id) ? message.bot_id : undefined,
-      ts: isNonEmptyString2(message.ts) ? message.ts : undefined
-    };
+    const mapped3 = await mapSlackThreadMessage(message, attachmentOptions);
+    return hasHydratedSlackThreadMessageContent(mapped3) ? mapped3 : null;
   } catch {
     return null;
   }
@@ -152174,6 +152310,7 @@ async function resolveSlackThreadHistory(params) {
   }
   const fetchLimit = 200;
   const retained = [];
+  const attachmentOptions = resolveSlackThreadAttachmentOptions(params);
   let cursor;
   try {
     do {
@@ -152185,8 +152322,7 @@ async function resolveSlackThreadHistory(params) {
         ...cursor ? { cursor } : {}
       });
       for (const message of response.messages ?? []) {
-        const text = resolveSlackThreadMessageText(message);
-        if (!text) {
+        if (!hasSlackThreadMessageContent(message, attachmentOptions)) {
           continue;
         }
         if (params.currentMessageTs && message.ts === params.currentMessageTs) {
@@ -152203,7 +152339,8 @@ async function resolveSlackThreadHistory(params) {
       const nextCursor = response.response_metadata?.next_cursor;
       cursor = typeof nextCursor === "string" && nextCursor.trim().length > 0 ? nextCursor.trim() : undefined;
     } while (cursor);
-    return retained.map(mapSlackThreadMessage);
+    const mapped3 = await Promise.all(retained.map((message) => mapSlackThreadMessage(message, attachmentOptions)));
+    return mapped3.filter(hasHydratedSlackThreadMessageContent);
   } catch {
     return [];
   }
@@ -152214,6 +152351,7 @@ async function resolveSlackChannelHistory(params) {
     return [];
   }
   const fetchLimit = Math.min(Math.max(maxMessages * 3, maxMessages), 100);
+  const attachmentOptions = resolveSlackThreadAttachmentOptions(params);
   try {
     const response = await params.client.conversations.history({
       channel: params.channelId,
@@ -152225,9 +152363,10 @@ async function resolveSlackChannelHistory(params) {
       if (message.ts === params.beforeTs) {
         return false;
       }
-      return Boolean(resolveSlackThreadMessageText(message));
+      return hasSlackThreadMessageContent(message, attachmentOptions);
     }).slice(0, fetchLimit).reverse();
-    return retained.slice(-maxMessages).map(mapSlackThreadMessage);
+    const mapped3 = await Promise.all(retained.slice(-maxMessages).map((message) => mapSlackThreadMessage(message, attachmentOptions)));
+    return mapped3.filter(hasHydratedSlackThreadMessageContent);
   } catch {
     return [];
   }
@@ -153193,22 +153332,30 @@ function createSlackAdapter(config3) {
         return msg;
       }
       const slackApp = await ensureApp();
+      const threadAttachmentParams = {
+        accountId: config3.accountId,
+        token: config3.botToken,
+        transcribeVoice: config3.transcribeVoice === true
+      };
       const starter = shouldHydrateExistingThreadContext && isFirstRouteTurn ? await resolveSlackThreadStarter({
         channelId: msg.chatId,
         threadTs: msg.threadId,
-        client: slackApp.client
+        client: slackApp.client,
+        ...threadAttachmentParams
       }) : null;
       const resolvedHistory = shouldHydrateExistingThreadContext ? await resolveSlackThreadHistory({
         channelId: msg.chatId,
         threadTs: msg.threadId,
         client: slackApp.client,
         currentMessageTs: msg.messageId,
-        limit: INITIAL_SLACK_THREAD_HISTORY_LIMIT
+        limit: INITIAL_SLACK_THREAD_HISTORY_LIMIT,
+        ...threadAttachmentParams
       }) : await resolveSlackChannelHistory({
         channelId: msg.chatId,
         beforeTs: msg.messageId,
         client: slackApp.client,
-        limit: INITIAL_SLACK_THREAD_HISTORY_LIMIT
+        limit: INITIAL_SLACK_THREAD_HISTORY_LIMIT,
+        ...threadAttachmentParams
       });
       const history = shouldHydrateExistingThreadContext && !isFirstRouteTurn ? resolvedHistory.filter((entry) => isNonEmptyString3(entry.botId)) : resolvedHistory;
       if (!starter && history.length === 0) {
@@ -153244,7 +153391,8 @@ function createSlackAdapter(config3) {
               messageId: starter.ts,
               senderId: starter.userId ?? starter.botId,
               senderName: resolveThreadSenderName(starter.userId, starter.botId),
-              text: starter.text
+              text: starter.text,
+              ...starter.attachments?.length ? { attachments: starter.attachments } : {}
             }
           } : {},
           ...history.length > 0 ? {
@@ -153252,7 +153400,8 @@ function createSlackAdapter(config3) {
               messageId: entry.ts,
               senderId: entry.userId ?? entry.botId,
               senderName: resolveThreadSenderName(entry.userId, entry.botId),
-              text: entry.text
+              text: entry.text,
+              ...entry.attachments?.length ? { attachments: entry.attachments } : {}
             }))
           } : {}
         }
@@ -159822,6 +159971,15 @@ function escapeXmlText(text) {
 function escapeXmlAttribute(text) {
   return escapeXmlText(text).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
+function hasNotificationAttachmentPaths(msg) {
+  if (msg.attachments?.length) {
+    return true;
+  }
+  if (msg.threadContext?.starter?.attachments?.length) {
+    return true;
+  }
+  return Boolean(msg.threadContext?.history?.some((entry) => entry.attachments?.length));
+}
 function buildChannelReminderText(msg) {
   const localTime = escapeXmlText(getLocalTime());
   const escapedChannel = escapeXmlText(msg.channel);
@@ -159857,7 +160015,7 @@ function buildChannelReminderText(msg) {
   if (msg.channel === "signal") {
     lines.splice(lines.length - 2, 0, 'On Signal, MessageChannel also supports action="react" with emoji + messageId, and action="upload-file" with media. Replies are sent as the linked Signal account through signal-cli-rest-api.');
   }
-  if (msg.attachments?.length) {
+  if (hasNotificationAttachmentPaths(msg)) {
     lines.splice(lines.length - 2, 0, "If this notification includes attachment local_path values, you may be able to inspect those files using local file or image tools available in your current toolset (for example Read or ViewImage), using the local_path.");
   }
   return lines.join(`
@@ -159948,8 +160106,13 @@ function buildThreadContextEntryXml(tagName, entry) {
     attrs.push(`message_id="${escapeXmlAttribute(entry.messageId)}"`);
   }
   const attrString = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  const body = [
+    ...entry.text ? [escapeXmlText(entry.text)] : [],
+    ...(entry.attachments ?? []).map(buildAttachmentXml)
+  ].join(`
+`);
   return `<${tagName}${attrString}>
-${escapeXmlText(entry.text)}
+${body}
 </${tagName}>`;
 }
 function buildThreadContextXml(msg) {
@@ -167949,6 +168112,10 @@ function getShellEnv() {
   if (agentId) {
     env3.LETTA_AGENT_ID = agentId;
     env3.AGENT_ID = agentId;
+    const agentName = getCurrentAgentName()?.trim() || env3.AGENT_NAME?.trim();
+    if (agentName) {
+      env3.AGENT_NAME = agentName;
+    }
     try {
       const localBackendNoMemfs = isLocalBackendMemfsDisabledForProcess();
       const localBackendEnabled = process.env.LETTA_LOCAL_BACKEND_EXPERIMENTAL === "1" || process.env.LETTA_LOCAL_BACKEND_EXPERIMENTAL?.toLowerCase() === "true";
@@ -363661,7 +363828,7 @@ function getMemoryGitIdentityEnvOverrides(command, workdir) {
   if (!scopedToMemoryDir) {
     return;
   }
-  const agentName = (process.env.AGENT_NAME || "").trim() || agentId;
+  const agentName = getCurrentAgentNameOrEnv() || agentId;
   const agentEmail = `${agentId}@letta.com`;
   return {
     GIT_AUTHOR_NAME: agentName,
@@ -363679,6 +363846,14 @@ function getCurrentAgentIdOrEnv() {
   } catch {}
   return (process.env.LETTA_AGENT_ID || process.env.AGENT_ID || "").trim();
 }
+function getCurrentAgentNameOrEnv() {
+  const scopedName = getCurrentAgentName()?.trim();
+  if (scopedName) {
+    return scopedName;
+  }
+  const envName = process.env.AGENT_NAME?.trim();
+  return envName || null;
+}
 function containsGitCommitInvocation(command) {
   const segments = command.split(/&&|\|\||;|\|/).map((segment) => segment.trim()).filter(Boolean);
   for (const segment of segments) {
@@ -373739,6 +373914,7 @@ async function prepareToolExecutionContextForScope(params) {
     agent: agent2,
     runtimeContext: {
       agentId,
+      agentName: agent2.name ?? null,
       conversationId: scopedConversationId,
       workingDirectory,
       ...channelToolScope.channels.length > 0 ? { channelToolScope } : {},
@@ -438900,6 +439076,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       conversationId
     });
     setCurrentAgentId(agentId);
+    setCurrentAgentName(listenAgentMetadata?.name ?? null);
     setConversationId(conversationId);
     if (isDebugEnabled()) {
       console.log(`[Listen] Handling message: agentId=${agentId}, requestedConversationId=${requestedConversationId}, conversationId=${conversationId}`);
@@ -438959,6 +439136,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             lastRunAt: cachedAgent.last_run_completion ?? null
           };
         }
+        setCurrentAgentName(listenAgentMetadata?.name ?? cachedAgent?.name ?? null);
         const { parts: reminderParts } = await buildSharedReminderParts(buildListenReminderContext({
           agentId: agentId || "",
           conversationId,
@@ -440884,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)
@@ -441286,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.
@@ -441307,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:`;
@@ -441411,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);
@@ -441698,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);
@@ -441711,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,
@@ -441898,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();
@@ -442088,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,
@@ -442150,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",
@@ -443606,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) => {
@@ -443618,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 {
@@ -443639,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,
@@ -443711,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, {
@@ -443731,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.");
     }
@@ -444030,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, {
@@ -444096,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;
@@ -444201,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;
           }
@@ -444640,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)) {
@@ -444654,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",
@@ -444664,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 {
@@ -444708,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",
@@ -444718,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,
@@ -449652,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;
@@ -449873,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 [];
@@ -449898,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 [];
   }
@@ -449926,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)
@@ -451805,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;
@@ -451836,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();
   }
@@ -451885,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 {}
         }
       }
@@ -451910,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;
 });
 
@@ -451945,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);
@@ -452000,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();
@@ -452023,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);
@@ -452076,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();
         }
@@ -452117,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);
@@ -452169,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
 });
@@ -452189,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 });
   }
@@ -452207,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 = () => {};
 
@@ -452413,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) {
@@ -452489,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;
@@ -452528,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,
@@ -452638,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 });
       }
@@ -453175,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;
@@ -453183,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) {
@@ -453194,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
@@ -453637,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);
@@ -453708,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 } : {},
@@ -453793,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('"')) {
@@ -453890,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" };
   }
@@ -453953,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.`);
     }
@@ -454057,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)) {
@@ -454069,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}`);
   }
@@ -454158,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 [];
@@ -454186,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 {
@@ -454239,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);
@@ -454251,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,
@@ -454283,6 +454630,7 @@ var exports_defaults = {};
 __export(exports_defaults, {
   selectDefaultAgentModel: () => selectDefaultAgentModel,
   ensureDefaultAgents: () => ensureDefaultAgents,
+  TUTOR_TAG: () => TUTOR_TAG,
   MEMO_TAG: () => MEMO_TAG,
   DEFAULT_AGENT_CONFIGS: () => DEFAULT_AGENT_CONFIGS
 });
@@ -454350,29 +454698,39 @@ async function ensureDefaultAgents(backend4, options3) {
   if (!settingsManager.shouldCreateDefaultAgents()) {
     return null;
   }
+  const personality = options3?.personality ?? "memo";
   try {
     const { isLettaCloud: isLettaCloud2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
     const willAutoEnableMemfs = backend4.capabilities.remoteMemfs && await isLettaCloud2();
     const memoryPromptMode = backend4.capabilities.localMemfs ? "local-memfs" : willAutoEnableMemfs ? "memfs" : undefined;
-    const { agent: agent2 } = await createAgent({
+    const model = await resolveDefaultAgentModel(backend4, options3?.preferredModel);
+    const createOptions = personality === "tutorial" ? {
+      ...await buildCreateAgentOptionsForPersonality2({
+        personalityId: "tutorial",
+        model
+      }),
+      memoryPromptMode
+    } : {
       ...DEFAULT_AGENT_CONFIGS.memo,
-      model: await resolveDefaultAgentModel(backend4, options3?.preferredModel),
+      model,
       memoryPromptMode
-    });
-    await addTagToAgent(backend4, agent2.id, MEMO_TAG);
+    };
+    const { agent: agent2 } = await createAgent(createOptions);
+    await addTagToAgent(backend4, agent2.id, personality === "tutorial" ? TUTOR_TAG : MEMO_TAG);
     settingsManager.pinAgent(agent2.id);
     return agent2;
   } catch (err) {
     throw new Error(`Failed to create default agents: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-var MEMO_TAG = "default:memo", MEMO_PERSONA, MEMO_HUMAN, MEMO_DESCRIPTION = "The default Letta Code agent with persistent memory", DEFAULT_AGENT_CONFIGS;
+var MEMO_TAG = "default:memo", TUTOR_TAG = "default:tutorial", MEMO_PERSONA, MEMO_HUMAN, MEMO_DESCRIPTION = "The default Letta Code agent with persistent memory", DEFAULT_AGENT_CONFIGS;
 var init_defaults = __esm(() => {
   init_client2();
   init_settings_manager();
   init_create6();
   init_memory5();
   init_model();
+  init_personality();
   init_prompt_assets();
   MEMO_PERSONA = parseMdxFrontmatter(MEMORY_PROMPTS["persona_memo.mdx"] ?? "").body;
   MEMO_HUMAN = parseMdxFrontmatter(MEMORY_PROMPTS["human_memo.mdx"] ?? "").body;
@@ -455269,7 +455627,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
     await settingsManager.loadLocalProjectSettings();
     settingsManager.persistSession(agent2.id, conversationId);
   }
-  setAgentContext(agent2.id, skillsDirectory, resolvedSkillSources);
+  setAgentContext(agent2.id, skillsDirectory, resolvedSkillSources, agent2.name ?? null);
   const outputFormat = values2["output-format"] || "text";
   const includePartialMessages = Boolean(values2["include-partial-messages"]);
   if (!["text", "json", "stream-json"].includes(outputFormat)) {
@@ -457863,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);
 }
@@ -458022,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) {
@@ -459297,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";
@@ -459329,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;
 }
@@ -459388,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 });
     }
@@ -459491,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 = "";
@@ -459624,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 });
     }
@@ -459677,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();
@@ -459716,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();
@@ -459734,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 });
@@ -460765,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;
   }
@@ -461127,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) {
@@ -461412,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 = [];
@@ -461435,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, {
@@ -461486,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)"
                 ]
@@ -461592,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}?`;
@@ -461608,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");
@@ -461793,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;
@@ -469128,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, "/");
 }
@@ -469370,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();
@@ -469391,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()) {
@@ -469410,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;
@@ -469448,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,
@@ -469470,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
@@ -472299,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, {
@@ -472520,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 };
 }
@@ -472532,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()}
 `;
@@ -476963,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) => ({
@@ -477272,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);
@@ -477288,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);
@@ -477313,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++) {
@@ -477348,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);
@@ -479769,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());
@@ -481350,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()
         });
@@ -485255,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}?`;
@@ -485271,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");
@@ -485361,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;
@@ -500620,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 {
@@ -500845,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();
@@ -500916,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;
 });
 
@@ -502902,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)) {
@@ -502974,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);
@@ -507157,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, "");
@@ -507405,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) {
@@ -507420,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) {
@@ -508083,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,
@@ -508091,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();
@@ -508182,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: {
@@ -508374,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: {
@@ -508453,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)],
@@ -508631,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,
@@ -508649,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();
@@ -509217,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) {
@@ -509256,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}`);
   }
@@ -510897,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 {
@@ -510946,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,
@@ -510972,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,
@@ -511041,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;
@@ -511053,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;
@@ -511062,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;
@@ -511088,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;
       }
     }
@@ -511232,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);
@@ -511833,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) {
@@ -512693,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));
@@ -513132,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([
             {
@@ -513511,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();
@@ -513543,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,
@@ -514848,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
@@ -516875,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";
@@ -516907,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;
 }
@@ -516966,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 });
     }
@@ -517069,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 = "";
@@ -517202,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 });
     }
@@ -517255,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();
@@ -517294,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();
@@ -517312,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 });
@@ -517431,7 +517793,7 @@ __export(exports_resolve_startup_agent, {
 });
 function resolveStartupTarget(input) {
   if (input.forceNew) {
-    return { action: "create" };
+    return { action: "create", trigger: "force-new" };
   }
   if (input.pinnedAgentId && input.pinnedAgentExists) {
     const conversationId = input.pinnedAgentId === input.localAgentId ? input.localConversationId ?? undefined : undefined;
@@ -517470,7 +517832,7 @@ function resolveStartupTarget(input) {
   if (input.pinnedCount > 0) {
     return { action: "select" };
   }
-  return { action: "create" };
+  return { action: "create", trigger: "fresh-start" };
 }
 
 // src/agent/defaults.ts
@@ -517478,6 +517840,7 @@ var exports_defaults2 = {};
 __export(exports_defaults2, {
   selectDefaultAgentModel: () => selectDefaultAgentModel2,
   ensureDefaultAgents: () => ensureDefaultAgents2,
+  TUTOR_TAG: () => TUTOR_TAG2,
   MEMO_TAG: () => MEMO_TAG2,
   DEFAULT_AGENT_CONFIGS: () => DEFAULT_AGENT_CONFIGS2
 });
@@ -517545,29 +517908,39 @@ async function ensureDefaultAgents2(backend4, options3) {
   if (!settingsManager.shouldCreateDefaultAgents()) {
     return null;
   }
+  const personality = options3?.personality ?? "memo";
   try {
     const { isLettaCloud: isLettaCloud2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
     const willAutoEnableMemfs = backend4.capabilities.remoteMemfs && await isLettaCloud2();
     const memoryPromptMode = backend4.capabilities.localMemfs ? "local-memfs" : willAutoEnableMemfs ? "memfs" : undefined;
-    const { agent: agent2 } = await createAgent({
+    const model = await resolveDefaultAgentModel2(backend4, options3?.preferredModel);
+    const createOptions = personality === "tutorial" ? {
+      ...await buildCreateAgentOptionsForPersonality2({
+        personalityId: "tutorial",
+        model
+      }),
+      memoryPromptMode
+    } : {
       ...DEFAULT_AGENT_CONFIGS2.memo,
-      model: await resolveDefaultAgentModel2(backend4, options3?.preferredModel),
+      model,
       memoryPromptMode
-    });
-    await addTagToAgent2(backend4, agent2.id, MEMO_TAG2);
+    };
+    const { agent: agent2 } = await createAgent(createOptions);
+    await addTagToAgent2(backend4, agent2.id, personality === "tutorial" ? TUTOR_TAG2 : MEMO_TAG2);
     settingsManager.pinAgent(agent2.id);
     return agent2;
   } catch (err) {
     throw new Error(`Failed to create default agents: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-var MEMO_TAG2 = "default:memo", MEMO_PERSONA2, MEMO_HUMAN2, MEMO_DESCRIPTION2 = "The default Letta Code agent with persistent memory", DEFAULT_AGENT_CONFIGS2;
+var MEMO_TAG2 = "default:memo", TUTOR_TAG2 = "default:tutorial", MEMO_PERSONA2, MEMO_HUMAN2, MEMO_DESCRIPTION2 = "The default Letta Code agent with persistent memory", DEFAULT_AGENT_CONFIGS2;
 var init_defaults2 = __esm(() => {
   init_client2();
   init_settings_manager();
   init_create6();
   init_memory5();
   init_model();
+  init_personality();
   init_prompt_assets();
   MEMO_PERSONA2 = parseMdxFrontmatter(MEMORY_PROMPTS["persona_memo.mdx"] ?? "").body;
   MEMO_HUMAN2 = parseMdxFrontmatter(MEMORY_PROMPTS["human_memo.mdx"] ?? "").body;
@@ -517792,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)) {
@@ -517804,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}`);
   }
@@ -517893,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 [];
@@ -517921,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 {
@@ -517974,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);
@@ -517986,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,
@@ -518042,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;
@@ -518393,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;
 }
@@ -518404,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();
@@ -518421,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",
@@ -518717,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_]*$/;
 });
@@ -519791,6 +520164,7 @@ function getContext2() {
   if (!global2[CONTEXT_KEY2]) {
     global2[CONTEXT_KEY2] = {
       agentId: null,
+      agentName: null,
       skillsDirectory: null,
       skillSources: [...ALL_SKILL_SOURCES],
       conversationId: null
@@ -519799,18 +520173,24 @@ function getContext2() {
   return global2[CONTEXT_KEY2];
 }
 var context2 = getContext2();
-function setAgentContext2(agentId, skillsDirectory, skillSources) {
+function setAgentContext2(agentId, skillsDirectory, skillSources, agentName) {
   context2.agentId = agentId;
+  context2.agentName = normalizeAgentName2(agentName);
   context2.skillsDirectory = skillsDirectory || null;
   context2.skillSources = skillSources !== undefined ? [...skillSources] : [...ALL_SKILL_SOURCES];
   if (getRuntimeContext()) {
     updateRuntimeContext({
       agentId,
+      agentName: context2.agentName,
       skillsDirectory: skillsDirectory || null,
       skillSources: skillSources !== undefined ? [...skillSources] : [...ALL_SKILL_SOURCES]
     });
   }
 }
+function normalizeAgentName2(agentName) {
+  const trimmed = typeof agentName === "string" ? agentName.trim() : "";
+  return trimmed || null;
+}
 function setConversationId2(conversationId) {
   context2.conversationId = conversationId;
   if (getRuntimeContext()) {
@@ -525224,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;
@@ -525244,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 {}
       }
     }
@@ -525257,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();
@@ -525886,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 [];
@@ -526169,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: [],
@@ -526179,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 {
@@ -526224,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 {
@@ -526337,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
@@ -526476,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");
@@ -526493,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;
     }
@@ -526517,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;
@@ -526599,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;
@@ -526628,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;
       }
@@ -526651,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;
@@ -526682,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() {
@@ -527027,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,
@@ -527057,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
@@ -527091,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;
@@ -528110,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 {
@@ -528446,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";
@@ -528623,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 };
@@ -528656,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() };
 }
@@ -528753,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) {
@@ -528815,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 });
@@ -528860,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);
@@ -528901,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.");
   }
@@ -528918,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) {
@@ -528930,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;
@@ -528966,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}.`);
@@ -528979,6 +529359,27 @@ async function deleteSkillDirectory(params) {
   rmSync13(targetPath, { recursive: true, force: true });
   return { name, path: normalize5(targetPath) };
 }
+async function loadSkillMemorySyncFn() {
+  const { syncPendingMemoryCommitsAfterTurn: syncPendingMemoryCommitsAfterTurn2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
+  return syncPendingMemoryCommitsAfterTurn2;
+}
+async function syncCommittedRemoteSkillMemoryChange(params) {
+  if (!params.committed || isLocalAgentId(params.agentId)) {
+    return;
+  }
+  try {
+    const syncFn = params.syncFn ?? await loadSkillMemorySyncFn();
+    const result = await syncFn(params.agentId, {
+      memoryDir: params.memoryDir
+    });
+    return { status: result.status, summary: result.summary };
+  } catch (error54) {
+    return {
+      status: "push_failed",
+      summary: error54 instanceof Error ? error54.message : String(error54)
+    };
+  }
+}
 async function installSkill(specifier, agentId, force) {
   const source2 = resolveSkillSourceSpecifier(specifier);
   if (!source2) {
@@ -529014,7 +529415,8 @@ async function installSkill(specifier, agentId, force) {
       source: specifier,
       ...result,
       committed: commit.committed,
-      commitSha: commit.sha
+      commitSha: commit.sha,
+      memorySync: commit.memorySync
     };
   } finally {
     if (tmpDir)
@@ -529054,7 +529456,12 @@ async function commitSkillMemoryChange(params) {
     },
     syncMode: isLocalAgentId(params.agentId) ? "local" : "remote"
   });
-  return { committed: result.committed, sha: result.sha };
+  const memorySync = await syncCommittedRemoteSkillMemoryChange({
+    agentId: params.agentId,
+    memoryDir: params.memoryDir,
+    committed: result.committed
+  });
+  return { committed: result.committed, sha: result.sha, memorySync };
 }
 async function listSkills(agentId) {
   const memoryDir = await getAgentMemoryDir(agentId);
@@ -529075,7 +529482,8 @@ async function deleteSkill(skillName, agentId) {
     deleted: true,
     ...result,
     committed: commit.committed,
-    commitSha: commit.sha
+    commitSha: commit.sha,
+    memorySync: commit.memorySync
   };
 }
 async function initializeAndResolveAgent(values2, promptStatusMessage) {
@@ -529437,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",
@@ -529880,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 });
@@ -529921,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)) {
@@ -529943,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);
@@ -530013,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 });
@@ -530362,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) {
@@ -530995,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)})`);
   }
 }
 
@@ -531133,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();
@@ -532205,7 +532613,8 @@ Error: ${message}`);
             const { ensureDefaultAgents: ensureDefaultAgents3 } = await Promise.resolve().then(() => (init_defaults2(), exports_defaults2));
             try {
               const defaultAgent = await ensureDefaultAgents3(getBackend(), {
-                preferredModel: model
+                preferredModel: model,
+                personality: target2.trigger === "fresh-start" ? "tutorial" : "memo"
               });
               if (defaultAgent) {
                 startupCreatedAgentRef.current = defaultAgent;
@@ -532415,7 +532824,7 @@ Error: ${message}`);
         } catch {
           await settingsManager2.loadLocalProjectSettings();
         }
-        setAgentContext2(agent2.id, skillsDirectory2, resolvedSkillSources);
+        setAgentContext2(agent2.id, skillsDirectory2, resolvedSkillSources, agent2.name ?? null);
         let startupMemfsFlag = autoEnableMemfsForFreshAgent ? true : memfsFlag;
         if (backend4.capabilities.remoteMemfs && !autoEnableMemfsForFreshAgent) {
           const { hydrateMemfsSettingFromAgent: hydrateMemfsSettingFromAgent3, isLettaCloud: isLettaCloud3 } = await Promise.resolve().then(() => (init_memory_filesystem3(), exports_memory_filesystem2));
@@ -532743,4 +533152,4 @@ Error during initialization: ${message}`);
 }
 main2();
 
-//# debugId=E2E63DE64562692D64756E2164756E21
+//# debugId=CD2C04A4505B2DC064756E2164756E21