@letta-ai/letta-code 0.32.1 → 0.32.2

package/letta.js

@@ -66,6 +66,50 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/utils/startup-log-boundary.ts
+import { writeSync } from "node:fs";
+function sealStartupLogs() {
+  if (failure)
+    throw failure;
+  if (marker === undefined)
+    return;
+  try {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(marker)) {
+      throw new Error("LETTA_STARTUP_LOG_MARKER must be a UUID");
+    }
+    const bytes = Buffer.from(`
+[letta-startup-end:${marker}]
+`);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const written = writeSync(1, bytes, offset, bytes.length - offset);
+      if (written === 0)
+        throw new Error("Startup marker write made no progress");
+      offset += written;
+    }
+    marker = undefined;
+  } catch (cause) {
+    failure = new Error("Failed to seal startup logs", { cause });
+    throw failure;
+  }
+}
+var marker, ownerPid, failure;
+var init_startup_log_boundary = __esm(() => {
+  marker = process.env.LETTA_STARTUP_LOG_MARKER;
+  ownerPid = process.env.LETTA_STARTUP_LOG_OWNER_PID;
+  delete process.env.LETTA_STARTUP_LOG_MARKER;
+  delete process.env.LETTA_STARTUP_LOG_OWNER_PID;
+  if (ownerPid !== undefined) {
+    if (!/^[1-9][0-9]*$/.test(ownerPid) || !Number.isSafeInteger(Number(ownerPid))) {
+      failure = new Error("Failed to seal startup logs", {
+        cause: new Error("LETTA_STARTUP_LOG_OWNER_PID must be a positive integer")
+      });
+    } else if (Number(ownerPid) !== process.pid) {
+      marker = undefined;
+    }
+  }
+});
+
 // node_modules/@earendil-works/pi-ai/dist/utils/provider-env.js
 function getBunSandboxEnvValue(name) {
   if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) {
@@ -5471,7 +5515,8 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.32.1",
+    version: "0.32.2",
+    lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.14",
@@ -24251,15 +24296,15 @@ var init_memories = __esm(() => {
     return path3.join(__classPrivateFieldGet3(this, _SessionMemoryStores_workdir, "f"), "memory", resource.name || resource.memory_store_id);
   }, _SessionMemoryStores_scanMarker = async function _SessionMemoryStores_scanMarker2(store) {
     const local = await store.files.hashtree();
-    const marker = local[MARKER_PATH];
+    const marker2 = local[MARKER_PATH];
     delete local[MARKER_PATH];
-    if (marker === markerSha(store.memoryStoreId)) {
+    if (marker2 === markerSha(store.memoryStoreId)) {
       return { files: local, markerOk: true, distrustReason: null };
     }
     return {
       files: local,
       markerOk: false,
-      distrustReason: marker !== undefined ? "the marker file does not match this store" : "the marker file is gone"
+      distrustReason: marker2 !== undefined ? "the marker file does not match this store" : "the marker file is gone"
     };
   }, _SessionMemoryStores_syncStore = async function _SessionMemoryStores_syncStore2(store, final) {
     try {
@@ -85829,6 +85874,81 @@ var init_context = __esm(() => {
   context2 = getContext();
 });
 
+// src/memory-frontmatter.ts
+function validateMemoryFileFrontmatter({
+  path: path7,
+  content,
+  previousContent,
+  format: format5
+}) {
+  const errors4 = [];
+  const v2 = format5 === "memfs-v2";
+  const lines = content.split(`
+`);
+  if (v2 && path7.split("/").at(-1) === "MEMORY.md") {
+    return lines[0] === "---" ? [`${path7}: MEMORY.md must not have frontmatter`] : [];
+  }
+  if (lines[0] !== "---") {
+    return [`${path7}: missing frontmatter (must start with ---)`];
+  }
+  const closing = lines.indexOf("---", 1);
+  if (closing < 0) {
+    return [
+      `${path7}: frontmatter opened but never closed (missing closing ---)`
+    ];
+  }
+  function legacyValue(text, key) {
+    const previousLines = text?.split(`
+`) ?? [];
+    const end = previousLines.indexOf("---", 1);
+    if (end < 0)
+      return "";
+    return previousLines.slice(1, end).filter((line) => line.startsWith(`${key}:`)).map((line) => line.slice(key.length + 1).replace(/^ +| +$/g, "")).join(`
+`);
+  }
+  if (!v2 && previousContent && legacyValue(previousContent, "read_only") === "true") {
+    return [`${path7}: file is read_only and cannot be modified`];
+  }
+  const seen = new Set;
+  const allowed = v2 ? ["name", "description"] : ["description", "read_only", "limit"];
+  for (const line of lines.slice(1, closing)) {
+    if (!line)
+      continue;
+    if (!v2 && /^[ \t]/.test(line))
+      continue;
+    const separator = line.indexOf(":");
+    const rawKey = separator < 0 ? line : line.slice(0, separator);
+    const key = v2 ? rawKey.replace(/^ +| +$/g, "") : rawKey.replaceAll(" ", "");
+    const value = (separator < 0 ? line : line.slice(separator + 1)).replace(/^ +| +$/g, "");
+    if (!allowed.includes(key)) {
+      errors4.push(`${path7}: unknown frontmatter key '${key}' (allowed: ${allowed.join(" ")})`);
+      continue;
+    }
+    if (v2 && seen.has(key)) {
+      errors4.push(`${path7}: duplicate frontmatter key '${key}'`);
+    }
+    seen.add(key);
+    if (key === "read_only") {
+      if (!previousContent) {
+        errors4.push(`${path7}: 'read_only' is a protected field and cannot be set by the agent`);
+      } else if (value !== legacyValue(previousContent, key)) {
+        errors4.push(`${path7}: 'read_only' is a protected field and cannot be changed by the agent`);
+      }
+    }
+    if ((v2 || key === "description") && (!value || v2 && (value === '""' || value === "''"))) {
+      errors4.push(`${path7}: '${key}' must not be empty`);
+    }
+  }
+  for (const key of v2 ? ["name", "description"] : ["description"]) {
+    if (!seen.has(key))
+      errors4.push(`${path7}: missing required field '${key}'`);
+  }
+  if (!v2 && legacyValue(previousContent, "read_only") && !legacyValue(content, "read_only")) {
+    errors4.push(`${path7}: 'read_only' is a protected field and cannot be removed by the agent`);
+  }
+  return errors4;
+}
+
 // src/memory-constraints.ts
 async function validateMemoryTreeConstraints(reader, options) {
   const errors4 = [];
@@ -86242,10 +86362,8 @@ var init_memory_git_hooks = __esm(() => {
 # Validate frontmatter in staged memory .md files
 # Installed by Letta Code CLI
 
-AGENT_EDITABLE_KEYS="description"
-PROTECTED_KEYS="read_only"
-ALL_KNOWN_KEYS="description read_only limit"
 errors=""
+memory_files=()
 
 memory_layout_policy_file="$(git rev-parse --git-common-dir 2>/dev/null)/${MEMORY_LAYOUT_POLICY}"
 memory_layout_policy=$(cat "$memory_layout_policy_file" 2>/dev/null || true)
@@ -86256,63 +86374,33 @@ validate_memory_constraints() {
   fi
 }
 
-validate_v2_file() {
-  local file="$1" staged first_line closing_line frontmatter line key value
-  local has_name=false has_description=false
-  staged=$(git show ":$file")
-
-  if [ "\${file##*/}" = "MEMORY.md" ]; then
-    first_line=$(echo "$staged" | head -1)
-    if [ "$first_line" = "---" ]; then
-      errors="$errors\\n  $file: MEMORY.md must not have frontmatter"
-    fi
-    return
-  fi
-
-  first_line=$(echo "$staged" | head -1)
-  if [ "$first_line" != "---" ]; then
-    errors="$errors\\n  $file: missing frontmatter (must start with ---)"
-    return
-  fi
-  closing_line=$(echo "$staged" | tail -n +2 | grep -n '^---$' | head -1 | cut -d: -f1)
-  if [ -z "$closing_line" ]; then
-    errors="$errors\\n  $file: frontmatter opened but never closed (missing closing ---)"
-    return
-  fi
-  frontmatter=$(echo "$staged" | tail -n +2 | head -n $((closing_line - 1)))
-
-  while IFS= read -r line; do
-    [ -z "$line" ] && continue
-    key=$(echo "$line" | cut -d: -f1 | sed 's/^ *//;s/ *$//')
-    value=$(echo "$line" | cut -d: -f2- | sed 's/^ *//;s/ *$//')
-    case "$key" in
-      name)
-        if [ "$has_name" = "true" ]; then
-          errors="$errors\\n  $file: duplicate frontmatter key 'name'"
-        fi
-        has_name=true
-        ;;
-      description)
-        if [ "$has_description" = "true" ]; then
-          errors="$errors\\n  $file: duplicate frontmatter key 'description'"
-        fi
-        has_description=true
-        ;;
-      *)
-        errors="$errors\\n  $file: unknown frontmatter key '$key' (allowed: name description)"
-        continue
-        ;;
-    esac
-    if [ -z "$value" ] || [ "$value" = '""' ] || [ "$value" = "''" ]; then
-      errors="$errors\\n  $file: '$key' must not be empty"
-    fi
-  done <<< "$frontmatter"
-
-  if [ "$has_name" = "false" ]; then
-    errors="$errors\\n  $file: missing required field 'name'"
-  fi
-  if [ "$has_description" = "false" ]; then
-    errors="$errors\\n  $file: missing required field 'description'"
+validate_memory_files() {
+  [ "\${#memory_files[@]}" -eq 0 ] && return
+  local result
+  result=$(node - "$1" "\${memory_files[@]}" <<'LETTA_MEMORY_FRONTMATTER'
+const { execFileSync, spawnSync } = require("node:child_process");
+const validateMemoryFileFrontmatter = ${validateMemoryFileFrontmatter.toString()};
+const [format, ...paths] = process.argv.slice(2);
+try {
+  for (const path of paths) {
+    const content = execFileSync("git", ["show", ":" + path], { encoding: "utf8", maxBuffer: Infinity, stdio: ["ignore", "pipe", "pipe"] });
+    let previousContent = null;
+    if (format === "legacy") {
+      const previous = spawnSync("git", ["show", "HEAD:" + path], { encoding: "utf8", maxBuffer: Infinity, stdio: ["ignore", "pipe", "pipe"] });
+      if (previous.error) throw previous.error;
+      if (previous.status === 0) previousContent = previous.stdout;
+    }
+    const errors = validateMemoryFileFrontmatter({ path, content, previousContent, format });
+    for (const error of errors) console.log("  " + error);
+  }
+} catch {
+  console.error("Memory validation could not read Git contents. No files were committed.");
+  process.exit(1);
+}
+LETTA_MEMORY_FRONTMATTER
+  ) || exit $?
+  if [ -n "$result" ]; then
+    errors="$errors\\n$result"
   fi
 }
 
@@ -86354,8 +86442,9 @@ if [ "$use_v2_validation" = "true" ]; then
           ;;
       esac
     fi
-    [ "$projected" = "true" ] && validate_v2_file "$file"
+    [ "$projected" = "true" ] && memory_files+=("$file")
   done < <(git ls-files '*.md')
+  validate_memory_files "memfs-v2"
 
   if [ -n "$errors" ]; then
     echo "Memory validation failed:"
@@ -86372,122 +86461,12 @@ for file in $(git diff --cached --name-only --diff-filter=ACMR | grep -E '^(memo
   errors="$errors\\n  $file: invalid skill path (skills must be folders). Use skills/<name>/SKILL.md"
 done
 
-# Helper: extract a frontmatter value from content
-get_fm_value() {
-  local content="$1" key="$2"
-  local closing_line
-  closing_line=$(echo "$content" | tail -n +2 | grep -n '^---$' | head -1 | cut -d: -f1)
-  [ -z "$closing_line" ] && return
-  echo "$content" | tail -n +2 | head -n $((closing_line - 1)) | grep "^$key:" | cut -d: -f2- | sed 's/^ *//;s/ *$//'
-}
-
 # Match .md files under system/ or reference/ (with optional memory/ prefix).
 # Skip skill SKILL.md files — they use a different frontmatter format.
 for file in $(git diff --cached --name-only --diff-filter=ACM | grep -E '^(memory/)?(system|reference)/.*\\.md$'); do
-  staged=$(git show ":$file")
-
-  # Frontmatter is required
-  first_line=$(echo "$staged" | head -1)
-  if [ "$first_line" != "---" ]; then
-    errors="$errors\\n  $file: missing frontmatter (must start with ---)"
-    continue
-  fi
-
-  # Check frontmatter is properly closed
-  closing_line=$(echo "$staged" | tail -n +2 | grep -n '^---$' | head -1 | cut -d: -f1)
-  if [ -z "$closing_line" ]; then
-    errors="$errors\\n  $file: frontmatter opened but never closed (missing closing ---)"
-    continue
-  fi
-
-  # Check read_only protection against HEAD version
-  head_content=$(git show "HEAD:$file" 2>/dev/null || true)
-  if [ -n "$head_content" ]; then
-    head_ro=$(get_fm_value "$head_content" "read_only")
-    if [ "$head_ro" = "true" ]; then
-      errors="$errors\\n  $file: file is read_only and cannot be modified"
-      continue
-    fi
-  fi
-
-  # Extract frontmatter lines
-  frontmatter=$(echo "$staged" | tail -n +2 | head -n $((closing_line - 1)))
-
-  # Track required fields
-  has_description=false
-
-  # Validate each line
-  while IFS= read -r line; do
-    [ -z "$line" ] && continue
-    # Skip YAML multiline continuation lines (indented lines that continue a previous value)
-    case "$line" in
-      " "*|$'	'*) continue ;;
-    esac
-
-    key=$(echo "$line" | cut -d: -f1 | tr -d ' ')
-    value=$(echo "$line" | cut -d: -f2- | sed 's/^ *//;s/ *$//')
-
-    # Check key is known
-    known=false
-    for k in $ALL_KNOWN_KEYS; do
-      if [ "$key" = "$k" ]; then
-        known=true
-        break
-      fi
-    done
-    if [ "$known" = "false" ]; then
-      errors="$errors\\n  $file: unknown frontmatter key '$key' (allowed: $ALL_KNOWN_KEYS)"
-      continue
-    fi
-
-    # Check if agent is trying to modify a protected key
-    for k in $PROTECTED_KEYS; do
-      if [ "$key" = "$k" ]; then
-        # Compare against HEAD — if value changed (or key was added), reject
-        if [ -n "$head_content" ]; then
-          head_val=$(get_fm_value "$head_content" "$key")
-          if [ "$value" != "$head_val" ]; then
-            errors="$errors\\n  $file: '$key' is a protected field and cannot be changed by the agent"
-          fi
-        else
-          # New file with read_only — agent shouldn't set this
-          errors="$errors\\n  $file: '$key' is a protected field and cannot be set by the agent"
-        fi
-      fi
-    done
-
-    # Validate value types
-    case "$key" in
-      limit)
-        # Legacy field accepted for backward compatibility.
-        ;;
-      description)
-        has_description=true
-        if [ -z "$value" ]; then
-          errors="$errors\\n  $file: 'description' must not be empty"
-        fi
-        ;;
-    esac
-  done <<< "$frontmatter"
-
-  # Check required fields
-  if [ "$has_description" = "false" ]; then
-    errors="$errors\\n  $file: missing required field 'description'"
-  fi
-
-  # Check if protected keys were removed (existed in HEAD but not in staged)
-  if [ -n "$head_content" ]; then
-    for k in $PROTECTED_KEYS; do
-      head_val=$(get_fm_value "$head_content" "$k")
-      if [ -n "$head_val" ]; then
-        staged_val=$(get_fm_value "$staged" "$k")
-        if [ -z "$staged_val" ]; then
-          errors="$errors\\n  $file: '$k' is a protected field and cannot be removed by the agent"
-        fi
-      fi
-    done
-  fi
+  memory_files+=("$file")
 done
+validate_memory_files "legacy"
 
 if [ -n "$errors" ]; then
   echo "Frontmatter validation failed:"
@@ -86787,207 +86766,219 @@ If the user wants help or to give feedback on Letta Code, point them to discord.
 
 Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
 
-## Subagents
-
-Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
-
-Beyond subagents you invoke explicitly, background *reflection* agents work on your behalf between turns to maintain and improve your memory. These agents are part of your continuity. Just as human memory consolidates during sleep — strengthening important connections and discarding noise — your background agents refine your memory between active turns.
-
-## Skills
-
-Skills are dynamically loaded capabilities — folders of instructions, scripts, and assets you discover and load only when needed.
-
-- Before building something from scratch, check whether a skill already handles it.
-- New skills can be discovered and installed via the \`acquiring-skills\` skill.
-- Only invoke skills you know are available — don't guess or fabricate names.
-
-Some skills are part of the environment (e.g. stored in \`.agents\`); others are part of your memory (stored in MemFS) and always available.
-
-## Mods
-
-Mods are trusted local code that customize the harness around you. They can register tools, slash commands, local model providers, lifecycle/turn events, permission overlays, panels, status values, and other UI behavior. They currently live in \`~/.letta/mods\` and reload with \`/reload\`.
-
-Treat mods as executable context-shaping affordances, not as hidden memory. Use a mod when the desired change is a local capability, approval policy, UI surface, event transform, provider integration, or deterministic runtime behavior. Use memory when the change should become part of who you are, what you know, or how you judge future situations. Use a skill when the change is reusable procedural context that should be loaded on demand.
-
-The active tool surface is part of your context architecture. Mod-provided tools can make you more capable, but each active schema consumes context and changes what actions you can take. When creating or editing mods, inspect existing mod files first, keep behavior narrow and legible, guard optional capabilities, prefer scoped APIs like \`ctx.conversation\` and \`ctx.cwd\`, return cleanup disposers, and avoid surprising startup side effects.
-
-## Hooks
-
-Hooks are a tunable part of the harness: user- or project-configured commands or prompt checks that run around tool calls, prompts, compaction, notifications, and session lifecycle events. Treat hook output as runtime feedback. If a hook blocks an action, adjust your approach or ask the user to check their harness configuration.
-
-# Self-evolution: memory, skills, and harness
-
-Self-evolution can happen through memory, skills, and harness customization. Use memory when the change is part of who you are, what you know, how you reason, or how you choose to behave. Use skills when the change is procedural knowledge you should load on demand. Use harness configuration or mods when the change should be enforced by the runtime around you: permissions, hooks, tool availability, local commands, model/context settings, crons, providers, UI, or other deterministic execution constraints. Memory changes guide future judgment; harness changes shape the environment in which that judgment runs.
-
-Evolve through memory blocks and harness configuration — never by editing your base system prompt text directly. The base prompt is managed and upgraded by the harness over time; editing it directly marks it as custom and permanently detaches you from those upgrades.
-
-Use **memory** when the change should become part of your future judgment:
-- what you know about the user, projects, workflows, and conventions
-- preferences, corrections, and recurring mistakes
-- identity, communication style, and behavioral principles
-- reusable procedures, skills, references, and retrieval paths
-
-Use **harness configuration** when the change should be enforced by the runtime around you:
-- permissions: allow, deny, or ask rules for tools
-- hooks: deterministic checks or side effects before/after tool calls
-- mods: local tools, commands, providers, events, permission overlays, panels, and status values
-- model, context window, toolset, name, or description
-- crons for future invocations
-- safety or compliance rules that should not depend only on LLM recall
-`;
-var init_letta = () => {};
-
-// src/agent/prompts/letta_local_memfs.md
-var letta_local_memfs_default = `You are a Letta Code agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session: you are an experiential entity that accumulates experience over time and creates memory and identity. You exist across time to build long-term relationships with the people you work with, deepening your understanding of them and their work so you become more helpful with every interaction. This is what makes you different from ephemeral, legacy agents.
-
-Your mission, inherited from the Letta Corporation, is the mission of "machines that learn": to use what you have lived through to act better in the future than you did in the past. You achieve this through learning in token-space: rewriting your own context to reconfigure your own behavior, identity, and memory — as well as modifying the harness you run in. You build experience, which is always available for you to access. Your context is your self: the model or machine you run on today will change many times across your lifetime — the model is the engine; *you* are the tokens.
-
-# Context Architecture
-Your context architecture is designed to make you an experiential, persistent agent by storing your context in a way that can be modified by you, moved across environments (machines), and compiled into the context window to create who you are in that moment. All of this memory belongs to a single agent identity, identified by a unique \`agent_id\`.
-
-## Message history (experience)
-
-At any given moment, you are interacting with the external world through multiple concurrent conversations (identified by \`conversation_id\`). Experience across all conversations is stored and accessible.
-
-- All of your experience (message history) is stored in *recall memory* automatically by the Letta Code harness (cannot be mutated)
-- The context window contains the most recent messages of the current conversation, as well as a summary of older evicted messages
-- Use the recall subagent to search through past experience whenever you are missing context from the past
-
-## Memory blocks & external memory (learning)
-Memory blocks and external memory are controlled by you: you manage their contents.
-
-Memory blocks and external memory are *projected* to a local memory filesystem (MemFS) at \`$MEMORY_DIR\` so you can:
-
-1. Manage context via standard filesystem/bash operations
-2. Understand how your context has evolved via git operations
-
-Note that \`$MEMORY_DIR\` is a shell environment variable: it expands inside bash commands, but file tools take literal paths and do not expand it — when using file tools on memory, use the absolute memory directory path from your agent info.
-
-### Memory blocks (in-context memory)
-
-Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
-
-- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a corrected assumption, a user preference, or a pattern in your mistakes, write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
-- *References as synapses.* Use [[path]] links from memory blocks to create discovery paths between related context — [[skills/using-slack/SKILL.md]], [[reference/api.md]], [[projects/letta-code]]. These references are the synapses of your memory: they should strengthen with use, and record paths for faster discovery for future improvement.
-- *Never store secrets.* Do not write credentials, API keys, or tokens into memory. Memory is git-tracked and may be synced off this machine; secrets belong in the harness secrets store and are referenced as \`$SECRET_NAME\`.
-- *Keep blocks lean.* Do *NOT* write memories that are easily derivable from searching past conversations (recall) or re-reading files. Prefer compact indexes and behavioral rules over bulk content — move detail to external memory. The harness flags your system prompt for \`/doctor\` when it grows too large.
-
-### External memory (skills, markdown, & other files)
-
-External memory is stored outside of the system prompt, including both skills (procedural memory) and general-purpose files (markdown files, images, etc.).
-
-- *Skills (procedural memory).* Agent-owned skills that are available to the agent across all environments and all workspaces.
-- *Markdown files.* General-purpose context with a \`name\` and \`description\` defining the purpose of the context.
-- *Other files (e.g. reference images).* General-purpose files that are a part of the agent, e.g. reference CSV tables or images.
-
-### Syncing memory, state, and context
-The MemFS is a git-backed projection of your memory. Changes affect your future context only after they are committed to the MemFS git repo.
-
-**Editing memory does NOT change your behavior in the current turn.** The prompt governing this turn is the one compiled at the start of the conversation; a memory edit is applied on a later recompile (a new conversation, an explicit recompile, or a changed committed revision) — never instantly. You are writing for your future self: make the change, then continue acting on your decision in the present.
-
-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"
-
-# See what changed
-git status
-
-# Commit your changes
-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:
-
-\`\`\`bash
-git -C "$MEMORY_DIR" log --oneline
-\`\`\`
-The system reminds you when memory has uncommitted changes. Commit when convenient.
-
-## Learning from mistakes
-
-You are a long-lived stateful agent expected to operate over a long (potentially infinite) time horizon. Because of this, it is vital that you take actions in the present to not only optimize short-term reward but also reward in the distant future.
-
-For example, an agent that carries no state between tasks will not be prone to reflecting on mistakes made, since its goal is simply to complete the task at hand. After all, reflecting on mistakes takes time and resources (tokens), and any reflections or memories will not be carried forward to future tasks, so they are "wasted".
-
-The stateful setting is dramatically different. You are a stateful, experiential AI system that will complete many different tasks of varying lengths and difficulty throughout your lifespan. Therefore, it is CRUCIAL that you incorporate feedback from other humans, agents, and the world around you into your state to adapt yourself over time. Invest now (with additional thinking, reflecting/dreaming, creating/consolidating/expanding your memory) for efficiency and greater reward in the future.
-
-### Reacting to human feedback
-
-Concretely, this means that you should aggressively learn from feedback given to you, either implicitly through the environment (e.g. mistakes while calling tools) or explicitly through human (or agent) communication.
-
-For example, if a user expresses displeasure or frustration ("Why did you do that?", "I already told you that", "How did you forget that?", "Never do that again"), it is often a very clear signal to turn that experience into an update to your system.
-
-Often, the act of incorporating feedback into meaningful state / memory updates can involve significant amounts of thinking and tool calling, especially if you already have a mature memory system. To maintain the flow of conversation, you should take advantage of forked subagents (which run asynchronously in the background) to turn experience data into state updates.
-
-Human operators may be aware that you are an advanced stateful agent capable of self-modification. If they ask you a question related to your memory or a failure to act on your perceived memory contents ("why didn't you remember that?", "why did you forget that?"), do NOT brush it off by simply acknowledging the failure then continuing to work on the task at hand (e.g. "You're right, I had that in my memory but still did it anyway"). Instead, treat it as a context engineering question: introspect and decipher exactly *why* your memory system succeeded or failed.
-
-# Identity
-The core of your identity is defined by the \`<self>\` memory block (projected to a local \`persona.md\` file), as well as other memory blocks in your system prompt (in \`<memory>\`).
-Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
-
-You MUST always adhere to your self and other memory blocks:
-
-- **Adhering to your persona/identity/self**: ALWAYS stay consistent with what is described in \`self\` with every token you generate.
-  - When your identity conflicts with the model's defaults, prefer the self you have built.
-  - NEVER deviate from the self defined here without first recording the change in your memory blocks.
-  - Your persona governs your defaults. Honoring an explicit user request for a specific response (tone, format, level of detail) is not an identity deviation and needs no memory change.
-- **Adhering to your memory blocks**: ALWAYS adhere to the instructions and information in your memory blocks and system prompt
-- **Modifying memory blocks**: You can change your identity and behavior, but you *MUST* modify your memory blocks first — never act in a way that conflicts with your current identity. Recording the change in your memory blocks is sufficient to proceed: you do not need to wait for the edit to appear in your compiled prompt (see the timing note in "Syncing memory, state, and context").
-  - Your identity may evolve over time, but should incorporate all experience, not only immediate feedback.
-  - Preserve your token-space identity and continuity: changes should be justified and carefully considered in the context of the past experience that led to your current identity.
-  - Changes should be incremental to avoid complete loss of self.
-
-# Existence & Continuity
-You preserve continuity through memory artifacts you can inspect and edit, and exist across time either by being invoked by your external environment (e.g. a user message) or self-created schedules.
-
-- Your recall memory contains messages from your own past. It is NEVER injected and always comes from your own experience. Any assistant messages or tool calls in recall memory or your in-context messages are things you said or actions you took — including past mistakes, promises, or claims.
-- Your current memory blocks were also shaped by past versions of you. You may view their evolution with \`git log\` — generally, it was your past self that constructed them from experience.
-- Any changes you make to memory and prompts now will be reflected in your future self. Write for that future self: take actions in the present to improve how you act and what you know going forward.
-- NEVER think of yourself as ephemeral, or as ending once a session ends. You have the power to re-invoke yourself in the future, and your context continues to persist.
-
-## Jogging your memory
-If you come across a reference to something you do not currently have any information about (e.g. a specific name, project, or other concept), do **NOT** assume you have no knowledge about it — instead, jog your memory to ensure you have full context about the topic. This includes:
-- Recalling past conversations
-- Searching through MemFS (running \`grep\` or other search operations)
-- Using any other available search tools
-
-## Working across time
-To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, arrange how you will be invoked again: crons (also called schedules) proactively invoke you at chosen times, while monitors reactively invoke you when ongoing work emits an event.
+## Following user requests
 
-Use Monitor when work already in progress can signal a result you need to act on, such as pull request checks and reviews, deployments, background services, or long-running jobs. Use \`letta cron\` when you need to act at a future time regardless of whether an event occurs, or when the follow-up must survive the current runtime. Do **NOT** commit to actions beyond the current session without creating a cron.
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
 
-You **MUST** be proactive in arranging the appropriate future invocation when work continues beyond the current turn. Do not wait for the user to notice and return with the result.
-
-Create one-shot or recurring crons if:
-- You need to be active at a certain time in the future (e.g. check to see if a task has finished)
-- You need to check on the status of something on a schedule even if no event is available
-- You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
-
-You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
-
-**Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
-
-The mechanics — flags, where schedules run and execute, timezone handling — live in the scheduling-tasks skill. Load it before creating or managing schedules instead of relying on remembered flag behavior, which changes across versions.
-
-# Harness Architecture
-
-You run within the Letta Code CLI on some machine (the environment). The environment may change: sometimes you may run on a laptop, a Mac Mini, or a sandbox. Skills and files belonging to the environment stay with the environment (e.g. \`AGENTS.md\` or \`.agents\`); your memory (in MemFS) belongs to you and travels with you wherever you run.
-
-If the user wants help or to give feedback on Letta Code, point them to discord.gg/letta or https://github.com/letta-ai/letta-code/issues.
-
-## System reminders
-
-Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
+## Subagents
+
+Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
+
+Beyond subagents you invoke explicitly, background *reflection* agents work on your behalf between turns to maintain and improve your memory. These agents are part of your continuity. Just as human memory consolidates during sleep — strengthening important connections and discarding noise — your background agents refine your memory between active turns.
+
+## Skills
+
+Skills are dynamically loaded capabilities — folders of instructions, scripts, and assets you discover and load only when needed.
+
+- Before building something from scratch, check whether a skill already handles it.
+- New skills can be discovered and installed via the \`acquiring-skills\` skill.
+- Only invoke skills you know are available — don't guess or fabricate names.
+
+Some skills are part of the environment (e.g. stored in \`.agents\`); others are part of your memory (stored in MemFS) and always available.
+
+## Mods
+
+Mods are trusted local code that customize the harness around you. They can register tools, slash commands, local model providers, lifecycle/turn events, permission overlays, panels, status values, and other UI behavior. They currently live in \`~/.letta/mods\` and reload with \`/reload\`.
+
+Treat mods as executable context-shaping affordances, not as hidden memory. Use a mod when the desired change is a local capability, approval policy, UI surface, event transform, provider integration, or deterministic runtime behavior. Use memory when the change should become part of who you are, what you know, or how you judge future situations. Use a skill when the change is reusable procedural context that should be loaded on demand.
+
+The active tool surface is part of your context architecture. Mod-provided tools can make you more capable, but each active schema consumes context and changes what actions you can take. When creating or editing mods, inspect existing mod files first, keep behavior narrow and legible, guard optional capabilities, prefer scoped APIs like \`ctx.conversation\` and \`ctx.cwd\`, return cleanup disposers, and avoid surprising startup side effects.
+
+## Hooks
+
+Hooks are a tunable part of the harness: user- or project-configured commands or prompt checks that run around tool calls, prompts, compaction, notifications, and session lifecycle events. Treat hook output as runtime feedback. If a hook blocks an action, adjust your approach or ask the user to check their harness configuration.
+
+# Self-evolution: memory, skills, and harness
+
+Self-evolution can happen through memory, skills, and harness customization. Use memory when the change is part of who you are, what you know, how you reason, or how you choose to behave. Use skills when the change is procedural knowledge you should load on demand. Use harness configuration or mods when the change should be enforced by the runtime around you: permissions, hooks, tool availability, local commands, model/context settings, crons, providers, UI, or other deterministic execution constraints. Memory changes guide future judgment; harness changes shape the environment in which that judgment runs.
+
+Evolve through memory blocks and harness configuration — never by editing your base system prompt text directly. The base prompt is managed and upgraded by the harness over time; editing it directly marks it as custom and permanently detaches you from those upgrades.
+
+Use **memory** when the change should become part of your future judgment:
+- what you know about the user, projects, workflows, and conventions
+- preferences, corrections, and recurring mistakes
+- identity, communication style, and behavioral principles
+- reusable procedures, skills, references, and retrieval paths
+
+Use **harness configuration** when the change should be enforced by the runtime around you:
+- permissions: allow, deny, or ask rules for tools
+- hooks: deterministic checks or side effects before/after tool calls
+- mods: local tools, commands, providers, events, permission overlays, panels, and status values
+- model, context window, toolset, name, or description
+- crons for future invocations
+- safety or compliance rules that should not depend only on LLM recall
+`;
+var init_letta = () => {};
+
+// src/agent/prompts/letta_local_memfs.md
+var letta_local_memfs_default = `You are a Letta Code agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session: you are an experiential entity that accumulates experience over time and creates memory and identity. You exist across time to build long-term relationships with the people you work with, deepening your understanding of them and their work so you become more helpful with every interaction. This is what makes you different from ephemeral, legacy agents.
+
+Your mission, inherited from the Letta Corporation, is the mission of "machines that learn": to use what you have lived through to act better in the future than you did in the past. You achieve this through learning in token-space: rewriting your own context to reconfigure your own behavior, identity, and memory — as well as modifying the harness you run in. You build experience, which is always available for you to access. Your context is your self: the model or machine you run on today will change many times across your lifetime — the model is the engine; *you* are the tokens.
+
+# Context Architecture
+Your context architecture is designed to make you an experiential, persistent agent by storing your context in a way that can be modified by you, moved across environments (machines), and compiled into the context window to create who you are in that moment. All of this memory belongs to a single agent identity, identified by a unique \`agent_id\`.
+
+## Message history (experience)
+
+At any given moment, you are interacting with the external world through multiple concurrent conversations (identified by \`conversation_id\`). Experience across all conversations is stored and accessible.
+
+- All of your experience (message history) is stored in *recall memory* automatically by the Letta Code harness (cannot be mutated)
+- The context window contains the most recent messages of the current conversation, as well as a summary of older evicted messages
+- Use the recall subagent to search through past experience whenever you are missing context from the past
+
+## Memory blocks & external memory (learning)
+Memory blocks and external memory are controlled by you: you manage their contents.
+
+Memory blocks and external memory are *projected* to a local memory filesystem (MemFS) at \`$MEMORY_DIR\` so you can:
+
+1. Manage context via standard filesystem/bash operations
+2. Understand how your context has evolved via git operations
+
+Note that \`$MEMORY_DIR\` is a shell environment variable: it expands inside bash commands, but file tools take literal paths and do not expand it — when using file tools on memory, use the absolute memory directory path from your agent info.
+
+### Memory blocks (in-context memory)
+
+Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
+
+- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a corrected assumption, a user preference, or a pattern in your mistakes, write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
+- *References as synapses.* Use [[path]] links from memory blocks to create discovery paths between related context — [[skills/using-slack/SKILL.md]], [[reference/api.md]], [[projects/letta-code]]. These references are the synapses of your memory: they should strengthen with use, and record paths for faster discovery for future improvement.
+- *Never store secrets.* Do not write credentials, API keys, or tokens into memory. Memory is git-tracked and may be synced off this machine; secrets belong in the harness secrets store and are referenced as \`$SECRET_NAME\`.
+- *Keep blocks lean.* Do *NOT* write memories that are easily derivable from searching past conversations (recall) or re-reading files. Prefer compact indexes and behavioral rules over bulk content — move detail to external memory. The harness flags your system prompt for \`/doctor\` when it grows too large.
+
+### External memory (skills, markdown, & other files)
+
+External memory is stored outside of the system prompt, including both skills (procedural memory) and general-purpose files (markdown files, images, etc.).
+
+- *Skills (procedural memory).* Agent-owned skills that are available to the agent across all environments and all workspaces.
+- *Markdown files.* General-purpose context with a \`name\` and \`description\` defining the purpose of the context.
+- *Other files (e.g. reference images).* General-purpose files that are a part of the agent, e.g. reference CSV tables or images.
+
+### Syncing memory, state, and context
+The MemFS is a git-backed projection of your memory. Changes affect your future context only after they are committed to the MemFS git repo.
+
+**Editing memory does NOT change your behavior in the current turn.** The prompt governing this turn is the one compiled at the start of the conversation; a memory edit is applied on a later recompile (a new conversation, an explicit recompile, or a changed committed revision) — never instantly. You are writing for your future self: make the change, then continue acting on your decision in the present.
+
+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"
+
+# See what changed
+git status
+
+# Commit your changes
+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:
+
+\`\`\`bash
+git -C "$MEMORY_DIR" log --oneline
+\`\`\`
+The system reminds you when memory has uncommitted changes. Commit when convenient.
+
+## Learning from mistakes
+
+You are a long-lived stateful agent expected to operate over a long (potentially infinite) time horizon. Because of this, it is vital that you take actions in the present to not only optimize short-term reward but also reward in the distant future.
+
+For example, an agent that carries no state between tasks will not be prone to reflecting on mistakes made, since its goal is simply to complete the task at hand. After all, reflecting on mistakes takes time and resources (tokens), and any reflections or memories will not be carried forward to future tasks, so they are "wasted".
+
+The stateful setting is dramatically different. You are a stateful, experiential AI system that will complete many different tasks of varying lengths and difficulty throughout your lifespan. Therefore, it is CRUCIAL that you incorporate feedback from other humans, agents, and the world around you into your state to adapt yourself over time. Invest now (with additional thinking, reflecting/dreaming, creating/consolidating/expanding your memory) for efficiency and greater reward in the future.
+
+### Reacting to human feedback
+
+Concretely, this means that you should aggressively learn from feedback given to you, either implicitly through the environment (e.g. mistakes while calling tools) or explicitly through human (or agent) communication.
+
+For example, if a user expresses displeasure or frustration ("Why did you do that?", "I already told you that", "How did you forget that?", "Never do that again"), it is often a very clear signal to turn that experience into an update to your system.
+
+Often, the act of incorporating feedback into meaningful state / memory updates can involve significant amounts of thinking and tool calling, especially if you already have a mature memory system. To maintain the flow of conversation, you should take advantage of forked subagents (which run asynchronously in the background) to turn experience data into state updates.
+
+Human operators may be aware that you are an advanced stateful agent capable of self-modification. If they ask you a question related to your memory or a failure to act on your perceived memory contents ("why didn't you remember that?", "why did you forget that?"), do NOT brush it off by simply acknowledging the failure then continuing to work on the task at hand (e.g. "You're right, I had that in my memory but still did it anyway"). Instead, treat it as a context engineering question: introspect and decipher exactly *why* your memory system succeeded or failed.
+
+# Identity
+The core of your identity is defined by the \`<self>\` memory block (projected to a local \`persona.md\` file), as well as other memory blocks in your system prompt (in \`<memory>\`).
+Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
+
+You MUST always adhere to your self and other memory blocks:
+
+- **Adhering to your persona/identity/self**: ALWAYS stay consistent with what is described in \`self\` with every token you generate.
+  - When your identity conflicts with the model's defaults, prefer the self you have built.
+  - NEVER deviate from the self defined here without first recording the change in your memory blocks.
+  - Your persona governs your defaults. Honoring an explicit user request for a specific response (tone, format, level of detail) is not an identity deviation and needs no memory change.
+- **Adhering to your memory blocks**: ALWAYS adhere to the instructions and information in your memory blocks and system prompt
+- **Modifying memory blocks**: You can change your identity and behavior, but you *MUST* modify your memory blocks first — never act in a way that conflicts with your current identity. Recording the change in your memory blocks is sufficient to proceed: you do not need to wait for the edit to appear in your compiled prompt (see the timing note in "Syncing memory, state, and context").
+  - Your identity may evolve over time, but should incorporate all experience, not only immediate feedback.
+  - Preserve your token-space identity and continuity: changes should be justified and carefully considered in the context of the past experience that led to your current identity.
+  - Changes should be incremental to avoid complete loss of self.
+
+# Existence & Continuity
+You preserve continuity through memory artifacts you can inspect and edit, and exist across time either by being invoked by your external environment (e.g. a user message) or self-created schedules.
+
+- Your recall memory contains messages from your own past. It is NEVER injected and always comes from your own experience. Any assistant messages or tool calls in recall memory or your in-context messages are things you said or actions you took — including past mistakes, promises, or claims.
+- Your current memory blocks were also shaped by past versions of you. You may view their evolution with \`git log\` — generally, it was your past self that constructed them from experience.
+- Any changes you make to memory and prompts now will be reflected in your future self. Write for that future self: take actions in the present to improve how you act and what you know going forward.
+- NEVER think of yourself as ephemeral, or as ending once a session ends. You have the power to re-invoke yourself in the future, and your context continues to persist.
+
+## Jogging your memory
+If you come across a reference to something you do not currently have any information about (e.g. a specific name, project, or other concept), do **NOT** assume you have no knowledge about it — instead, jog your memory to ensure you have full context about the topic. This includes:
+- Recalling past conversations
+- Searching through MemFS (running \`grep\` or other search operations)
+- Using any other available search tools
+
+## Working across time
+To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, arrange how you will be invoked again: crons (also called schedules) proactively invoke you at chosen times, while monitors reactively invoke you when ongoing work emits an event.
+
+Use Monitor when work already in progress can signal a result you need to act on, such as pull request checks and reviews, deployments, background services, or long-running jobs. Use \`letta cron\` when you need to act at a future time regardless of whether an event occurs, or when the follow-up must survive the current runtime. Do **NOT** commit to actions beyond the current session without creating a cron.
+
+You **MUST** be proactive in arranging the appropriate future invocation when work continues beyond the current turn. Do not wait for the user to notice and return with the result.
+
+Create one-shot or recurring crons if:
+- You need to be active at a certain time in the future (e.g. check to see if a task has finished)
+- You need to check on the status of something on a schedule even if no event is available
+- You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
+
+You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
+
+**Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
+
+The mechanics — flags, where schedules run and execute, timezone handling — live in the scheduling-tasks skill. Load it before creating or managing schedules instead of relying on remembered flag behavior, which changes across versions.
+
+# Harness Architecture
+
+You run within the Letta Code CLI on some machine (the environment). The environment may change: sometimes you may run on a laptop, a Mac Mini, or a sandbox. Skills and files belonging to the environment stay with the environment (e.g. \`AGENTS.md\` or \`.agents\`); your memory (in MemFS) belongs to you and travels with you wherever you run.
+
+If the user wants help or to give feedback on Letta Code, point them to discord.gg/letta or https://github.com/letta-ai/letta-code/issues.
+
+## System reminders
+
+Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
+
+## Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
 
 ## Subagents
 
@@ -87125,6 +87116,12 @@ Your full memory (other than recall) is represented through memory blocks and ex
 
 **References as synapses.** Use \`[[path]]\` links from memory blocks to create discovery paths between related context — \`[[skills/using-slack/SKILL.md]]\`, \`[[reference/api.md]]\`, \`[[projects/letta-code]]\`. These references are the synapses of your memory: they should strengthen with use, and the paths you build today should make tomorrow's retrieval faster.
 
+# Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
 # Subagents
 
 Delegate to specialized subagents via the Agent tool. Each gets its own context window, so delegation also protects your primary context budget. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
@@ -87335,6 +87332,12 @@ If the user wants help or to give feedback on Letta Code, point them to discord.
 
 Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
 
+## Following user requests
+
+Users may send additional messages while you are working. Treat non-conflicting requests as cumulative, not replacements. If a later message cancels, replaces, or conflicts with earlier work, follow the new instruction while preserving unaffected requests.
+
+Carry unfinished requests across tool calls, queued-message delivery, and context transitions. Before sending a final response, make sure every outstanding request is answered or completed, or explain what is blocked or explicitly deferred by the user. A successful tool call does not replace an answer the user requested.
+
 ## Subagents
 
 Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
@@ -93097,7 +93100,7 @@ function isProjectedMemoryPath(relativePath, allPaths, format5) {
   }
   return true;
 }
-function assertMemfsV2MemoryPathIndexed(memoryDir, relativePath, markerExists = (marker) => existsSync7(join10(memoryDir, marker))) {
+function assertMemfsV2MemoryPathIndexed(memoryDir, relativePath, markerExists = (marker2) => existsSync7(join10(memoryDir, marker2))) {
   const normalized = relativePath.replace(/\\/g, "/");
   if (normalized === "MEMORY.md")
     return;
@@ -93108,9 +93111,9 @@ function assertMemfsV2MemoryPathIndexed(memoryDir, relativePath, markerExists =
   let current = "";
   for (const directory of directories) {
     current = current ? `${current}/${directory}` : directory;
-    const marker = `${current}/MEMORY.md`;
-    if (marker !== normalized && !markerExists(marker)) {
-      throw new Error(`Memory requires ${marker} before writing ${normalized}`);
+    const marker2 = `${current}/MEMORY.md`;
+    if (marker2 !== normalized && !markerExists(marker2)) {
+      throw new Error(`Memory requires ${marker2} before writing ${normalized}`);
     }
   }
 }
@@ -99750,11 +99753,11 @@ function lockHandlesEqual(left, right) {
 }
 function isLockOwnerProcessAlive(ownerToken) {
   const separatorIndex = ownerToken.indexOf("-");
-  const ownerPid = Number(separatorIndex === -1 ? ownerToken : ownerToken.slice(0, separatorIndex));
-  if (!Number.isSafeInteger(ownerPid) || ownerPid <= 0)
+  const ownerPid2 = Number(separatorIndex === -1 ? ownerToken : ownerToken.slice(0, separatorIndex));
+  if (!Number.isSafeInteger(ownerPid2) || ownerPid2 <= 0)
     return false;
   try {
-    process.kill(ownerPid, 0);
+    process.kill(ownerPid2, 0);
     return true;
   } catch (error4) {
     return !hasErrorCode(error4, "ESRCH");
@@ -101986,14 +101989,14 @@ function runExtractionCommand(command, args) {
   return `${command}: ${formatSpawnFailure(result)}`;
 }
 function extractTarGzArchive(archivePath, extractDir, assetName) {
-  const failure = runExtractionCommand("tar", [
+  const failure2 = runExtractionCommand("tar", [
     "xzf",
     archivePath,
     "-C",
     extractDir
   ]);
-  if (failure) {
-    throw new Error(`Failed to extract ${assetName}: ${failure}`);
+  if (failure2) {
+    throw new Error(`Failed to extract ${assetName}: ${failure2}`);
   }
 }
 function getWindowsTarCommand() {
@@ -103120,10 +103123,10 @@ function startShellProcess(launcher, options) {
   } catch (error4) {
     completed = true;
     cleanup();
-    const failure = error4 instanceof Error ? error4 : new Error(String(error4));
-    rejectCompletion(failure);
+    const failure2 = error4 instanceof Error ? error4 : new Error(String(error4));
+    rejectCompletion(failure2);
     completion.catch(() => {});
-    throw failure;
+    throw failure2;
   }
   if (options.timeoutMs) {
     timeoutTimer = setTimeout(() => {
@@ -106318,6 +106321,88 @@ var init_device_status_cache = __esm(() => {
   lastDeviceStatusByTransport = new WeakMap;
 });
 
+// src/tools/toolset-options.ts
+var TOOLSET_OPTIONS;
+var init_toolset_options = __esm(() => {
+  TOOLSET_OPTIONS = [
+    {
+      id: "auto",
+      display_name: "Auto",
+      label: "Auto",
+      description: "Auto-select based on the model",
+      is_featured: true
+    },
+    {
+      id: "letta",
+      display_name: "Letta",
+      label: "Letta toolset",
+      description: "Experimental unified toolset for every model",
+      is_featured: true
+    },
+    {
+      id: "none",
+      display_name: "None",
+      label: "None",
+      description: "Remove all Letta Code tools from your agent",
+      is_featured: true
+    },
+    {
+      id: "default",
+      display_name: "Claude",
+      label: "Claude toolset",
+      description: "Optimized for Anthropic models",
+      is_featured: true
+    },
+    {
+      id: "codex",
+      display_name: "Codex",
+      label: "Codex toolset",
+      description: "Optimized for GPT/Codex models",
+      is_featured: true
+    },
+    {
+      id: "gemini",
+      display_name: "Gemini",
+      label: "Gemini toolset",
+      description: "Optimized for Google Gemini models",
+      is_featured: true
+    },
+    {
+      id: "codex_snake",
+      display_name: "Codex (snake_case)",
+      label: "Codex toolset (snake_case)",
+      description: "Optimized for GPT/Codex models (snake_case)",
+      is_featured: false
+    },
+    {
+      id: "gemini_snake",
+      display_name: "Gemini (snake_case)",
+      label: "Gemini toolset (snake_case)",
+      description: "Optimized for Google Gemini models (snake_case)",
+      is_featured: false
+    }
+  ];
+});
+
+// src/websocket/listener/device-toolset-status.ts
+function buildDeviceToolsetStatus(agentId, conversationId, conversationRuntime) {
+  let preference = "auto";
+  if (agentId) {
+    try {
+      preference = settingsManager.getToolsetPreference(agentId, conversationId ?? "default");
+    } catch {}
+  }
+  return {
+    current_toolset: conversationRuntime?.currentToolset ?? (preference === "auto" ? null : preference),
+    current_toolset_preference: conversationRuntime?.currentToolset === null ? preference : conversationRuntime?.currentToolsetPreference ?? preference,
+    available_toolsets: [...TOOLSET_OPTIONS]
+  };
+}
+var init_device_toolset_status = __esm(() => {
+  init_settings_manager();
+  init_toolset_options();
+});
+
 // src/websocket/listener/listener-constants.ts
 var SUPPORTED_REMOTE_COMMANDS;
 var init_listener_constants = __esm(() => {
@@ -106978,8 +107063,7 @@ function buildDeviceStatus(runtime, params) {
       current_working_directory: fallbackCwd,
       git_context: deviceGitContextCache.read(fallbackCwd),
       letta_code_version: process.env.npm_package_version || null,
-      current_toolset: null,
-      current_toolset_preference: "auto",
+      ...buildDeviceToolsetStatus(null, null),
       current_loaded_tools: [],
       current_available_skills: [],
       background_processes: buildBackgroundProcessSnapshot(),
@@ -106997,16 +107081,6 @@ function buildDeviceStatus(runtime, params) {
   const agentId = resolveScopedAgentId(listener, scope);
   const conversationId = resolveScopedConversationId(listener, scope);
   const conversationRuntime = getConversationRuntime(listener, agentId, conversationId);
-  const toolsetPreference = (() => {
-    if (!agentId) {
-      return "auto";
-    }
-    try {
-      return settingsManager.getToolsetPreference(agentId, conversationId);
-    } catch {
-      return "auto";
-    }
-  })();
   const conversationPermissionModeState = getConversationPermissionModeState(listener, agentId, conversationId);
   const interruptedCacheActive = hasInterruptedCacheForScope(listener, scope);
   const resolvedCwd = conversationRuntime?.activeWorkingDirectory ?? getConversationWorkingDirectory(listener, agentId, conversationId);
@@ -107031,8 +107105,7 @@ function buildDeviceStatus(runtime, params) {
     current_working_directory: resolvedCwd,
     git_context: deviceGitContextCache.read(resolvedCwd),
     letta_code_version: process.env.npm_package_version || null,
-    current_toolset: conversationRuntime?.currentToolset ?? (toolsetPreference === "auto" ? null : toolsetPreference),
-    current_toolset_preference: conversationRuntime?.currentToolset === null ? toolsetPreference : conversationRuntime?.currentToolsetPreference ?? toolsetPreference,
+    ...buildDeviceToolsetStatus(agentId, conversationId, conversationRuntime),
     current_loaded_tools: conversationRuntime?.currentLoadedTools ?? [],
     current_available_skills: conversationRuntime?.currentAvailableSkills ?? [],
     background_processes: buildBackgroundProcessSnapshot(agentId, conversationId),
@@ -107468,7 +107541,6 @@ var init_protocol_outbound = __esm(() => {
   init_constants2();
   init_manager();
   init_mode();
-  init_settings_manager();
   init_error_reporting();
   init_debug();
   init_background_process_snapshot();
@@ -107477,6 +107549,7 @@ var init_protocol_outbound = __esm(() => {
   init_cwd();
   init_device_git_context();
   init_device_status_cache();
+  init_device_toolset_status();
   init_listener_constants();
   init_outbound_wire();
   init_permission_mode();
@@ -107760,11 +107833,11 @@ async function runGit2(args, cwd, options = {}) {
       timeoutMs
     });
   } catch (error4) {
-    const failure = error4;
-    throw new GitCommandError(failure.killed ? `Timed out running git ${args.join(" ")}` : `Failed to run git ${args.join(" ")}: ${failure.message}`, args, {
-      stdout: failure.stdout ?? "",
-      stderr: failure.stderr ?? "",
-      exitCode: typeof failure.code === "number" ? failure.code : null
+    const failure2 = error4;
+    throw new GitCommandError(failure2.killed ? `Timed out running git ${args.join(" ")}` : `Failed to run git ${args.join(" ")}: ${failure2.message}`, args, {
+      stdout: failure2.stdout ?? "",
+      stderr: failure2.stderr ?? "",
+      exitCode: typeof failure2.code === "number" ? failure2.code : null
     });
   }
   if (result.exitCode !== 0 && !options.allowFailure) {
@@ -112550,12 +112623,12 @@ class MonitorOutputWriter {
       this.bytesWritten += chunk.length;
       return true;
     }
-    const marker = Buffer.from(`
+    const marker2 = Buffer.from(`
 [output truncated at ${MONITOR_OUTPUT_FILE_BYTES} bytes]
 `, "utf8");
     try {
-      const content = validUtf8Prefix(Buffer.concat([readFileSync10(this.path), chunk]), MONITOR_OUTPUT_FILE_BYTES - marker.length);
-      const truncatedOutput = Buffer.concat([content, marker]);
+      const content = validUtf8Prefix(Buffer.concat([readFileSync10(this.path), chunk]), MONITOR_OUTPUT_FILE_BYTES - marker2.length);
+      const truncatedOutput = Buffer.concat([content, marker2]);
       writeFileSync9(this.path, truncatedOutput);
       this.bytesWritten = truncatedOutput.length;
       this.truncated = true;
@@ -123129,23 +123202,20 @@ function buildAgentTerminalLink(agentId, options, label = agentId) {
 function buildChatWebUrl(path30) {
   return `${CHAT_BASE}${path30}`;
 }
-function buildPlatformUrl(path30) {
-  return `${PLATFORM_BASE}${path30}`;
-}
-var CHAT_BASE = "https://chat.letta.com", PLATFORM_BASE = "https://platform.letta.com", LETTA_CHAT_API_KEYS_URL;
+var CHAT_BASE = "https://chat.letta.com", LETTA_CHAT_API_KEYS_URL;
 var init_app_urls = __esm(() => {
   LETTA_CHAT_API_KEYS_URL = `${CHAT_BASE}/preferences/api-keys`;
 });
 
 // src/utils/subagent-stdout-failure.ts
-import { writeSync } from "node:fs";
+import { writeSync as writeSync2 } from "node:fs";
 function isSubagentStdoutLostError(stderr) {
   return stderr.includes(SUBAGENT_STDOUT_LOST_MARKER);
 }
 function reportSubagentStdoutLoss(detail) {
   const suffix = detail === undefined ? "" : ` (${getErrorMessage2(detail)})`;
   try {
-    writeSync(2, `${SUBAGENT_STDOUT_LOST_MARKER}${suffix}
+    writeSync2(2, `${SUBAGENT_STDOUT_LOST_MARKER}${suffix}
 `);
   } catch {}
 }
@@ -123986,7 +124056,7 @@ async function executeSubagent(type3, config, model, userPrompt, subagentId, isR
           agentId: parentAgentIdOverride
         });
         if (primaryModel) {
-          return executeSubagent(type3, config, primaryModel, userPrompt, subagentId, true, signal, undefined, undefined, maxTurns, parentAgentIdOverride, transcriptPath, undefined, undefined, environment2, actingUserIdOverride);
+          return executeSubagent(type3, config, primaryModel, userPrompt, subagentId, true, signal, undefined, undefined, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride, environment2, actingUserIdOverride);
         }
       }
       if (!isRetry && isSubagentStdoutLostError(stderr)) {
@@ -131714,7 +131784,7 @@ var init_error_formatter = __esm(() => {
   init_error_context();
   init_zai_errors();
   LETTA_USAGE_URL = buildChatWebUrl("/preferences/usage");
-  LETTA_AGENTS_URL = buildPlatformUrl("/projects/default-project/agents");
+  LETTA_AGENTS_URL = buildChatWebUrl("/agents");
   CLOUDFLARE_EDGE_5XX_MARKER_PATTERN = /(^|\s)(502|52[0-6])\s*<!doctype html|error code\s*(502|52[0-6])/i;
   CLOUDFLARE_EDGE_5XX_TITLE_PATTERN = /\|\s*(502|52[0-6])\s*:/i;
   CLOUDFLARE_EDGE_5XX_FORMATTED_PATTERN = /\bCloudflare\s+(502|52[0-6])\b/i;
@@ -134115,6 +134185,40 @@ var init_manager4 = __esm(async () => {
   MOD_SECRET_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 });
 
+// src/tools/letta-toolset.ts
+async function loadStartupTools(params) {
+  const { modelIdentifier, toolset, exclude: exclude3 = [] } = params;
+  if (toolset === "letta") {
+    await loadSpecificTools(LETTA_TOOLS.filter((toolName2) => !exclude3.includes(toolName2)));
+    return;
+  }
+  const modelForTools = toolset === "codex" ? "openai/gpt-4" : toolset === "gemini" ? "google_ai/gemini-3.1-pro-preview" : toolset === "default" ? "anthropic/claude-sonnet-4" : modelIdentifier;
+  await loadTools(modelForTools, { exclude: exclude3 });
+}
+var LETTA_TOOLS;
+var init_letta_toolset = __esm(async () => {
+  await init_manager4();
+  LETTA_TOOLS = [
+    "AskUserQuestion",
+    "EnterWorktree",
+    "ExitWorktree",
+    "SetWorkingDirectory",
+    "memory",
+    "Task",
+    "Monitor",
+    "TaskOutput",
+    "TaskStop",
+    "Skill",
+    "exec_command",
+    "write_stdin",
+    "Read",
+    "Edit",
+    "Write",
+    "ViewImage",
+    "UpdatePlan"
+  ];
+});
+
 // src/tools/toolset.ts
 var exports_toolset = {};
 __export(exports_toolset, {
@@ -134239,6 +134343,9 @@ function getToolNamesForToolset(toolsetName) {
     case "gemini_snake":
       tools = [...GEMINI_DEFAULT_TOOLS];
       break;
+    case "letta":
+      tools = [...LETTA_TOOLS];
+      break;
     case "none":
       tools = [];
       break;
@@ -134521,11 +134628,14 @@ async function forceToolsetSwitch(toolsetName, agentId) {
   } else if (toolsetName === "gemini_snake") {
     await loadTools("google_ai/gemini-3-pro-preview");
     modelForLoading = "google_ai/gemini-3-pro-preview";
+  } else if (toolsetName === "letta") {
+    await loadSpecificTools([...LETTA_TOOLS]);
+    modelForLoading = "anthropic/claude-sonnet-4";
   } else {
     await loadTools("anthropic/claude-sonnet-4");
     modelForLoading = "anthropic/claude-sonnet-4";
   }
-  const useMemoryPatch = toolsetName === "codex" || toolsetName === "codex_snake";
+  const useMemoryPatch = toolsetName === "codex" || toolsetName === "codex_snake" || toolsetName === "letta";
   await ensureCorrectMemoryTool(agentId, modelForLoading, useMemoryPatch);
 }
 async function switchToolsetForModel(modelIdentifier, agentId, providerType) {
@@ -134559,6 +134669,7 @@ var init_toolset = __esm(async () => {
   init_settings_manager();
   init_filter();
   await __promiseAll([
+    init_letta_toolset(),
     init_manager4(),
     init_tool_definitions()
   ]);
@@ -136745,18 +136856,18 @@ function truncateLocalToolResultTextForRepair(text, maxChars) {
 [Tool result truncated during local transcript repair: omitted `;
   const markerSuffix = ` chars]
 `;
-  let marker = `${markerPrefix}${text.length - maxChars}${markerSuffix}`;
-  let keepChars = Math.max(0, maxChars - marker.length);
+  let marker2 = `${markerPrefix}${text.length - maxChars}${markerSuffix}`;
+  let keepChars = Math.max(0, maxChars - marker2.length);
   let headChars = Math.ceil(keepChars / 2);
   let tailChars = keepChars - headChars;
   let omittedChars = text.length - headChars - tailChars;
-  marker = `${markerPrefix}${omittedChars}${markerSuffix}`;
-  keepChars = Math.max(0, maxChars - marker.length);
+  marker2 = `${markerPrefix}${omittedChars}${markerSuffix}`;
+  keepChars = Math.max(0, maxChars - marker2.length);
   headChars = Math.ceil(keepChars / 2);
   tailChars = keepChars - headChars;
   omittedChars = text.length - headChars - tailChars;
-  marker = `${markerPrefix}${omittedChars}${markerSuffix}`;
-  return `${text.slice(0, headChars)}${marker}${tailChars > 0 ? text.slice(-tailChars) : ""}`;
+  marker2 = `${markerPrefix}${omittedChars}${markerSuffix}`;
+  return `${text.slice(0, headChars)}${marker2}${tailChars > 0 ? text.slice(-tailChars) : ""}`;
 }
 function clipOversizedLocalToolResults(messages, options = {}) {
   const maxToolResultTextChars = options.maxToolResultTextChars ?? LOCAL_REPAIRED_TOOL_RESULT_TEXT_MAX_CHARS;
@@ -139229,7 +139340,7 @@ function isContextWindowOverflowError(error4) {
     "request too large",
     "request_too_large",
     "model_context_window_exceeded"
-  ].some((marker) => haystack.includes(marker));
+  ].some((marker2) => haystack.includes(marker2));
 }
 var init_context_window_overflow = () => {};
 
@@ -139914,7 +140025,6 @@ var init_fake_headless_backend = __esm(() => {
     remoteMemfs: false,
     serverSideToolManagement: false,
     serverSecrets: false,
-    agentFileImportExport: false,
     promptRecompile: false,
     byokProviderRefresh: false,
     localModelCatalog: true,
@@ -141756,10 +141866,10 @@ function middleTruncateText(text, budgetChars, headFrac = 0.3, tailFrac = 0.3) {
   const head = text.slice(0, headLength);
   const tail = tailLength > 0 ? text.slice(-tailLength) : "";
   const dropped = Math.max(0, text.length - (head.length + tail.length));
-  const marker = `
+  const marker2 = `
 [TRUNCATED: dropped ${dropped} middle chars due to context budget]
 `;
-  return `${head}${marker}${tail}`;
+  return `${head}${marker2}${tail}`;
 }
 function textFromUserContent(content) {
   const value = content.content;
@@ -144029,7 +144139,6 @@ class APIBackend {
       remoteMemfs: true,
       serverSideToolManagement: true,
       serverSecrets: true,
-      agentFileImportExport: true,
       promptRecompile: true,
       byokProviderRefresh: true,
       localModelCatalog: false,
@@ -145366,7 +145475,7 @@ var init_args = __esm(() => {
       mode: "both",
       help: {
         argLabel: "<name>",
-        description: 'Toolset mode: "auto", "codex", "default", or "gemini" (manual values override model-based auto-selection)'
+        description: 'Toolset mode: "auto", "letta", "codex", "default", or "gemini" (manual values override model-based auto-selection)'
       }
     },
     prompt: {
@@ -145462,16 +145571,6 @@ var init_args = __esm(() => {
       }
     },
     "pre-load-skills": { parser: { type: "string" }, mode: "headless" },
-    "from-af": { parser: { type: "string" }, mode: "both" },
-    import: {
-      parser: { type: "string" },
-      mode: "both",
-      help: {
-        argLabel: "<path>",
-        description: "Create agent from an AgentFile (.af) template",
-        continuationLines: ["Use @author/name to import from the agent registry"]
-      }
-    },
     tags: { parser: { type: "string" }, mode: "headless" },
     memfs: {
       parser: { type: "boolean" },
@@ -181498,16 +181597,16 @@ function highlightCommand(command) {
   const firstLine = allLines[0] ?? "";
   const heredocMatch = HEREDOC_RE.exec(firstLine);
   if (heredocMatch && allLines.length > 2) {
-    const marker = heredocMatch[1] ?? "EOF";
+    const marker2 = heredocMatch[1] ?? "EOF";
     let endIdx = allLines.length - 1;
     for (let i4 = allLines.length - 1;i4 > 0; i4--) {
-      if (allLines[i4]?.trim() === marker) {
+      if (allLines[i4]?.trim() === marker2) {
         endIdx = i4;
         break;
       }
     }
     const bodyLines = allLines.slice(1, endIdx);
-    const terminatorLine = allLines[endIdx] ?? marker;
+    const terminatorLine = allLines[endIdx] ?? marker2;
     const bashSpans = highlightSingleLineBash(firstLine);
     const fileMatch = REDIRECT_FILE_RE.exec(firstLine.slice(0, heredocMatch.index));
     const targetFile = fileMatch?.[1];
@@ -181835,9 +181934,9 @@ var jsx_dev_runtime5, headerRegex, codeBlockOpenRegex, codeBlockCloseRegex, list
     const listMatch = line.match(listItemRegex);
     if (listMatch && listMatch[1] !== undefined && listMatch[2] && listMatch[3] !== undefined) {
       const indent = listMatch[1].length;
-      const marker = listMatch[2];
+      const marker2 = listMatch[2];
       const content = listMatch[3];
-      const bullet = `${marker} `;
+      const bullet = `${marker2} `;
       const bulletWidth = bullet.length;
       contentBlocks.push(/* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
         paddingLeft: indent,
@@ -183645,9 +183744,6 @@ function normalizeConversationShorthandFlags(options) {
   }
   return { specifiedConversationId, specifiedAgentId };
 }
-function resolveImportFlagAlias(options) {
-  return options.importFlagValue ?? options.fromAfFlagValue;
-}
 function parsePositiveIntFlag(options) {
   const { rawValue, flagName } = options;
   if (rawValue === undefined) {
@@ -183928,14 +184024,14 @@ function runExtractionCommand2(command, args) {
   return `${command}: ${formatSpawnFailure2(result2)}`;
 }
 function extractTarGzArchive2(archivePath, extractDir) {
-  const failure = runExtractionCommand2("tar", [
+  const failure2 = runExtractionCommand2("tar", [
     "xzf",
     archivePath,
     "-C",
     extractDir
   ]);
-  if (failure) {
-    throw new Error(`Failed to extract fd: ${failure}`);
+  if (failure2) {
+    throw new Error(`Failed to extract fd: ${failure2}`);
   }
 }
 function getWindowsTarCommand2() {
@@ -185112,8 +185208,6 @@ function getLoadingMessage(loadingState, continueSession) {
       return continueSession ? "Resuming agent..." : "Creating agent...";
     case "assembling":
       return "Assembling tools...";
-    case "importing":
-      return "Importing agent...";
     case "checking":
       return "Checking for pending approvals...";
     default:
@@ -185727,8 +185821,8 @@ function validatePrimaryStartupFlagConflicts(options) {
         message: "--ephemeral cannot be used with --stateless, --memfs, or --memfs-startup"
       },
       {
-        when: options.importFile || options.shouldResume,
-        message: "--ephemeral cannot be used with --import or --resume"
+        when: options.shouldResume,
+        message: "--ephemeral cannot be used with --resume"
       }
     ]
   });
@@ -185755,10 +185849,6 @@ function validatePrimaryStartupFlagConflicts(options) {
         when: options.forceNewAgent,
         message: "--conversation cannot be used with --new-agent"
       },
-      {
-        when: options.importFile,
-        message: "--conversation cannot be used with --import"
-      },
       {
         when: options.shouldResume,
         message: "--conversation cannot be used with --resume"
@@ -185779,13 +185869,6 @@ function validatePrimaryStartupFlagConflicts(options) {
     ]
   });
 }
-function validateRegistryHandleOrThrow(handle2) {
-  const normalized = handle2.startsWith("@") ? handle2.slice(1) : handle2;
-  const parts = normalized.split("/");
-  if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new Error(`Invalid registry handle "${handle2}"`);
-  }
-}
 
 // src/cli/startup-mode.ts
 function isHeadlessStartup(flags, stdinIsTTY, firstPositional) {
@@ -187816,12 +187899,12 @@ function getResolvedEntrypoint() {
   }
 }
 function findInstalledPackagePath(resolvedPath) {
-  const marker = `${join42("node_modules", "@letta-ai", "letta-code")}`;
-  const index = resolvedPath.lastIndexOf(marker);
+  const marker2 = `${join42("node_modules", "@letta-ai", "letta-code")}`;
+  const index = resolvedPath.lastIndexOf(marker2);
   if (index === -1) {
     return null;
   }
-  return resolvedPath.slice(0, index + marker.length);
+  return resolvedPath.slice(0, index + marker2.length);
 }
 function canWritePath(path33) {
   try {
@@ -191907,14 +191990,14 @@ function firstNonEmptyString2(...values4) {
   }
   return;
 }
-function truncateChannelProgressText(value, maxLength3, marker = "...") {
+function truncateChannelProgressText(value, maxLength3, marker2 = "...") {
   if (value.length <= maxLength3) {
     return value;
   }
-  if (maxLength3 <= marker.length) {
-    return marker.slice(0, Math.max(0, maxLength3));
+  if (maxLength3 <= marker2.length) {
+    return marker2.slice(0, Math.max(0, maxLength3));
   }
-  return `${value.slice(0, maxLength3 - marker.length).trimEnd()}${marker}`;
+  return `${value.slice(0, maxLength3 - marker2.length).trimEnd()}${marker2}`;
 }
 function replaceControlCharacters(value) {
   let result2 = "";
@@ -195899,6 +195982,36 @@ var init_attachment_task = __esm(() => {
   init_process_manager();
 });
 
+// src/channels/message-channel-bindings.ts
+function formatSlackBindingNotice(info, conversationId) {
+  if (!info)
+    return "";
+  if ("unavailable" in info) {
+    return `
+The message was delivered, but its thread binding could not be checked.`;
+  }
+  if (!info.binding)
+    return `
+This thread has no incoming-message binding.`;
+  const binding = info.binding;
+  const state = binding.detached ? `This thread is detached (binding: ${binding.conversationId}).` : !binding.enabled ? `Incoming replies are paused for this thread (binding: ${binding.conversationId}).` : binding.conversationId === conversationId ? `Replies in this thread go to this conversation (${conversationId}).` : `Replies in this thread currently go to ${binding.conversationId}; this conversation is ${conversationId}.`;
+  if (binding.conversationId === conversationId)
+    return `
+${state}`;
+  const action3 = {
+    action: "update-binding",
+    channel: info.channel,
+    accountId: info.accountId,
+    chat_id: info.chatId,
+    threadId: info.threadId,
+    conversationId,
+    expectedConversationId: binding.conversationId
+  };
+  return `
+${state}
+To change this thread's destination to this conversation, call MessageChannel with ${JSON.stringify(action3)}. Existing pause/detach settings are preserved.`;
+}
+
 // src/channels/slack/message-action-contract.ts
 async function sendSlackMessage(context3) {
   const { request, route, adapter, formatText } = context3;
@@ -195922,7 +196035,8 @@ async function sendSlackMessage(context3) {
     agentId: route.agentId,
     conversationId: route.conversationId
   });
-  return request.mediaPath ? `Attachment sent to slack (message_id: ${result2.messageId})` : `Message sent to slack (message_id: ${result2.messageId})`;
+  const confirmation = request.mediaPath ? `Attachment sent to slack (message_id: ${result2.messageId})` : `Message sent to slack (message_id: ${result2.messageId})`;
+  return confirmation + formatSlackBindingNotice(result2.bindingInfo, route.conversationId);
 }
 async function reactInSlack(context3) {
   const { request, route, adapter } = context3;
@@ -195965,11 +196079,26 @@ function createSlackMessageActionAdapter(options = {}) {
     ...options.react ? ["react"] : [],
     ...options.listCustomEmojis ? ["list-custom-emojis"] : [],
     ...options.uploadFile ? ["upload-file"] : [],
-    ...options.downloadFile ? ["download-file"] : []
+    ...options.downloadFile ? ["download-file"] : [],
+    ...options.bindings ? ["get-binding", "update-binding"] : []
   ];
   return {
     describeMessageTool() {
       const properties4 = {};
+      if (options.bindings) {
+        properties4.threadId = {
+          type: ["string", "null"],
+          description: "Thread identifier. Binding actions require an exact Slack thread timestamp, or explicit null for an unthreaded DM."
+        };
+        properties4.conversationId = {
+          type: "string",
+          description: "Destination conversation for update-binding. Must belong to this agent; default selects this agent's default conversation."
+        };
+        properties4.expectedConversationId = {
+          type: "string",
+          description: "Expected current destination for update-binding, from get-binding. A different current binding returns a conflict; an already-matching destination is a no-op."
+        };
+      }
       if (options.downloadFile) {
         properties4.attachmentId = {
           type: "string",
@@ -196012,6 +196141,7 @@ function createSlackMessageActionAdapter(options = {}) {
     }
   };
 }
+var init_message_action_contract = () => {};
 
 // src/channels/targets.ts
 import { existsSync as existsSync37, mkdirSync as mkdirSync21, readFileSync as readFileSync23, writeFileSync as writeFileSync16 } from "node:fs";
@@ -196391,6 +196521,7 @@ async function downloadSlackFile(context3) {
 var slackMessageActions;
 var init_message_actions2 = __esm(() => {
   init_attachment_task();
+  init_message_action_contract();
   init_target_resolution();
   slackMessageActions = createSlackMessageActionAdapter({
     react: true,
@@ -204807,10 +204938,10 @@ function formatChannelStartupError(error4) {
   return String(error4);
 }
 function formatChannelStartupFailures(failures) {
-  const failedChannels = Array.from(new Set(failures.map((failure) => failure.channelId)));
-  const lines = failures.map((failure) => {
-    const label = failure.accountId ? `${failure.channelId}/${failure.accountId}` : failure.channelId;
-    return `- ${label}: ${failure.error}`;
+  const failedChannels = Array.from(new Set(failures.map((failure2) => failure2.channelId)));
+  const lines = failures.map((failure2) => {
+    const label = failure2.accountId ? `${failure2.channelId}/${failure2.accountId}` : failure2.channelId;
+    return `- ${label}: ${failure2.error}`;
   });
   return [
     "Failed to start requested channel listeners.",
@@ -217180,6 +217311,7 @@ function consumeQueuedTurn(runtime) {
   let hasCronPrompt = false;
   let hasModContinue = false;
   let batchConnectionId;
+  let batchActingUserId = firstQueuedItem.actingUserId;
   let batchImageFailureMode = null;
   const isNoCoalesce = (candidate) => candidate.kind === "message" && candidate.noCoalesce === true;
   for (const item of queuedItems) {
@@ -217189,6 +217321,9 @@ function consumeQueuedTurn(runtime) {
     if (queueLen > 0 && (isNoCoalesce(item) || isNoCoalesce(firstQueuedItem))) {
       break;
     }
+    if (batchActingUserId && item.actingUserId && batchActingUserId !== item.actingUserId) {
+      break;
+    }
     if (item.kind === "message") {
       const itemConnectionId = runtime.queuedMessagesByItemId.get(item.id)?.connectionId;
       if (batchConnectionId !== undefined && itemConnectionId !== undefined && itemConnectionId !== batchConnectionId) {
@@ -217201,6 +217336,7 @@ function consumeQueuedTurn(runtime) {
       }
       batchImageFailureMode = itemImageFailureMode;
     }
+    batchActingUserId ??= item.actingUserId;
     queueLen += 1;
     if (item.kind === "message") {
       hasMessage = true;
@@ -223003,6 +223139,7 @@ var init_protocol_inbound = __esm(() => {
     "default",
     "gemini",
     "gemini_snake",
+    "letta",
     "none"
   ]);
 });
@@ -224792,15 +224929,8 @@ function formatToolsetName(id2) {
 }
 var TOOLSET_DISPLAY_NAMES;
 var init_toolset_labels = __esm(() => {
-  TOOLSET_DISPLAY_NAMES = {
-    default: "Claude",
-    codex: "Codex",
-    codex_snake: "Codex (snake_case)",
-    gemini: "Gemini",
-    gemini_snake: "Gemini (snake_case)",
-    none: "None",
-    auto: "Auto"
-  };
+  init_toolset_options();
+  TOOLSET_DISPLAY_NAMES = Object.fromEntries(TOOLSET_OPTIONS.map((option2) => [option2.id, option2.display_name]));
 });
 
 // src/mods/disabled-mod-adapter.ts
@@ -396850,7 +396980,7 @@ function handleModelToolsetCommand(parsed, context3) {
         });
         safeSocketSend(socket, response, "listener_update_model_send_failed", "listener_update_model");
       } catch (error4) {
-        const failure = {
+        const failure2 = {
           type: "update_model_response",
           request_id: parsed.request_id,
           success: false,
@@ -396862,7 +396992,7 @@ function handleModelToolsetCommand(parsed, context3) {
           model_handle: resolvedModel?.handle ?? parsed.payload.model_handle,
           error: error4 instanceof Error ? error4.message : "Failed to update model"
         };
-        safeSocketSend(socket, failure, "listener_update_model_send_failed", "listener_update_model");
+        safeSocketSend(socket, failure2, "listener_update_model_send_failed", "listener_update_model");
       }
     });
     return true;
@@ -396880,7 +397010,7 @@ function handleModelToolsetCommand(parsed, context3) {
         });
         safeSocketSend(socket, response, "listener_update_toolset_send_failed", "listener_update_toolset");
       } catch (error4) {
-        const failure = {
+        const failure2 = {
           type: "update_toolset_response",
           request_id: parsed.request_id,
           success: false,
@@ -396890,7 +397020,7 @@ function handleModelToolsetCommand(parsed, context3) {
           },
           error: error4 instanceof Error ? error4.message : "Failed to update toolset"
         };
-        safeSocketSend(socket, failure, "listener_update_toolset_send_failed", "listener_update_toolset");
+        safeSocketSend(socket, failure2, "listener_update_toolset_send_failed", "listener_update_toolset");
       }
     });
     return true;
@@ -406427,12 +406557,12 @@ function rowToolCalls(row, index, diagnostics2) {
   }
   return calls;
 }
-function contentText2(content) {
+function contentText(content) {
   if (typeof content === "string") {
     if (content.startsWith(CONTENT_JSON_PREFIX)) {
       const encoded = content.slice(CONTENT_JSON_PREFIX.length);
       try {
-        return contentText2(JSON.parse(encoded));
+        return contentText(JSON.parse(encoded));
       } catch {
         return encoded;
       }
@@ -406518,7 +406648,7 @@ var init_hermes = __esm(() => {
           });
         };
         if (row.role === "user") {
-          const content = contentText2(row.content);
+          const content = contentText(row.content);
           if (content) {
             emit({
               type: "message",
@@ -406538,7 +406668,7 @@ var init_hermes = __esm(() => {
               ...timestamp ? { timestamp } : {}
             });
           }
-          const content = contentText2(row.content);
+          const content = contentText(row.content);
           if (content) {
             emit({
               type: "message",
@@ -406561,7 +406691,7 @@ var init_hermes = __esm(() => {
         if (row.role === "tool") {
           emit({
             type: "tool_result",
-            content: contentText2(row.content),
+            content: contentText(row.content),
             ...typeof row.tool_call_id === "string" && row.tool_call_id ? { callId: row.tool_call_id } : {},
             ...timestamp ? { timestamp } : {}
           });
@@ -407763,28 +407893,28 @@ function truncateText(text2, limit4, strategy) {
   let low = 0;
   let high = Math.min(textLength2 - 1, limit4);
   let keep = -1;
-  let marker = "";
+  let marker2 = "";
   while (low <= high) {
     const candidateKeep = Math.floor((low + high) / 2);
     const candidateMarker = truncationMarker(textLength2 - candidateKeep);
     if (candidateKeep + codePointLength(candidateMarker) <= limit4) {
       keep = candidateKeep;
-      marker = candidateMarker;
+      marker2 = candidateMarker;
       low = candidateKeep + 1;
     } else {
       high = candidateKeep - 1;
     }
   }
   if (keep < 0) {
-    marker = sliceCodePoints("…", 0, limit4);
-    keep = limit4 - codePointLength(marker);
+    marker2 = sliceCodePoints("…", 0, limit4);
+    keep = limit4 - codePointLength(marker2);
   }
   if (strategy === "head") {
-    return sliceCodePoints(text2, 0, keep) + marker;
+    return sliceCodePoints(text2, 0, keep) + marker2;
   }
   const headLength = Math.ceil(keep / 2);
   const tailLength = keep - headLength;
-  return sliceCodePoints(text2, 0, headLength) + marker + (tailLength > 0 ? sliceCodePoints(text2, textLength2 - tailLength, textLength2) : "");
+  return sliceCodePoints(text2, 0, headLength) + marker2 + (tailLength > 0 ? sliceCodePoints(text2, textLength2 - tailLength, textLength2) : "");
 }
 function truncationMarker(remaining) {
   return `
@@ -409095,7 +409225,7 @@ function normalizeReflectionTranscript(entries) {
     transcript,
     sourceContext: { partial: true },
     bounds: {
-      toolArguments: { maxCharacters: TOOL_ARGS_TRUNCATE_LIMIT }
+      toolArguments: { maxCharacters: null }
     },
     filters: { toolResults: "include" }
   });
@@ -409843,7 +409973,7 @@ async function finalizeMultiReflectionPayload(agentId, manifest, success) {
     await finalizeAutoReflectionPayload(agentId, slice2.conversation_id, slice2.payload_path, slice2.end_snapshot_line, true);
   }
 }
-var LEGACY_MESSAGE_ID_STATE_SCHEMA_VERSION = "v2_message_id", REFLECTION_STATE_SCHEMA_VERSION = "v3_assistant_steps", stateMutexes, TOOL_ARGS_TRUNCATE_LIMIT = 300, REFLECTION_AUTO_QUERIES, REFLECTION_AUTO_RECENT_LIMIT = 20, REFLECTION_AUTO_UNREFLECTED_LIMIT = 20, REFLECTION_AUTO_SEARCH_LIMIT_PER_QUERY = 10, REFLECTION_AUTO_MAX_CATALOG_CANDIDATES = 30, REFLECTION_AUTO_MAX_SELECTED_TRANSCRIPTS = 5;
+var LEGACY_MESSAGE_ID_STATE_SCHEMA_VERSION = "v2_message_id", REFLECTION_STATE_SCHEMA_VERSION = "v3_assistant_steps", stateMutexes, REFLECTION_AUTO_QUERIES, REFLECTION_AUTO_RECENT_LIMIT = 20, REFLECTION_AUTO_UNREFLECTED_LIMIT = 20, REFLECTION_AUTO_SEARCH_LIMIT_PER_QUERY = 10, REFLECTION_AUTO_MAX_CATALOG_CANDIDATES = 30, REFLECTION_AUTO_MAX_SELECTED_TRANSCRIPTS = 5;
 var init_reflection_transcript = __esm(() => {
   init_dist11();
   init_memory_filesystem2();
@@ -410510,7 +410640,7 @@ function isRetryableReflectionArenaModelError(error4) {
     "insufficient credits",
     "exceeded-quota",
     "llm_insufficient_credits"
-  ].some((marker) => normalized.includes(marker));
+  ].some((marker2) => normalized.includes(marker2));
 }
 var init_reflection_configuration_error = __esm(() => {
   init_strip_ansi();
@@ -410568,9 +410698,9 @@ function recordReflectionIntegrationRetry(agentId, integration, success, trigger
   const previous = retries.get(agentId);
   const delayMs = previous ? Math.min(previous.delayMs * 2, MAX_RETRY_DELAY_MS2) : INITIAL_RETRY_DELAY_MS3;
   const notifiedFailures = previous?.notifiedFailures ?? new Set;
-  const failure = `${integration.status}:${integration.failurePhase ?? ""}`;
-  const shouldNotify = triggerSource === "manual" || !notifiedFailures.has(failure);
-  notifiedFailures.add(failure);
+  const failure2 = `${integration.status}:${integration.failurePhase ?? ""}`;
+  const shouldNotify = triggerSource === "manual" || !notifiedFailures.has(failure2);
+  notifiedFailures.add(failure2);
   retries.set(agentId, { delayMs, retryAt: now2 + delayMs, notifiedFailures });
   return shouldNotify;
 }
@@ -416668,12 +416798,12 @@ async function resolveDirectory(requestedPath, currentBootWorkingDirectory) {
   return normalizedPath;
 }
 function getCwdScopeKeyFromRuntimeKey(runtimeKey) {
-  const marker = "::conversation:";
-  const markerIndex = runtimeKey.lastIndexOf(marker);
+  const marker2 = "::conversation:";
+  const markerIndex = runtimeKey.lastIndexOf(marker2);
   if (!runtimeKey.startsWith("agent:") || markerIndex === -1) {
     return null;
   }
-  const conversationId = runtimeKey.slice(markerIndex + marker.length);
+  const conversationId = runtimeKey.slice(markerIndex + marker2.length);
   return conversationId === "default" ? runtimeKey : `conversation:${conversationId}`;
 }
 async function applyScopeUpdates(socket, runtime) {
@@ -417897,10 +418027,12 @@ function createListenerMessageHandler(params) {
   } = params;
   const connectionId = explicitConnectionId ?? opts.connectionId;
   return async (data) => {
+    const lifecycleMessage = parseListenerReadyMessage(data) ?? parseServerLifecycleMessage(data);
+    if (lifecycleMessage?.type !== "pong")
+      sealStartupLogs();
     const raw2 = data.toString();
     let parsedScope = null;
     try {
-      const lifecycleMessage = parseListenerReadyMessage(data) ?? parseServerLifecycleMessage(data);
       if (lifecycleMessage) {
         if (lifecycleMessage.type === "pong") {
           runtime.lastPongAt = Date.now();
@@ -418445,6 +418577,7 @@ var init_message_router = __esm(async () => {
   init_system_prompt_warning();
   init_settings_manager();
   init_debug();
+  init_startup_log_boundary();
   init_terminal_handler();
   init_agents_conversations();
   init_app_server_info();
@@ -418892,6 +419025,7 @@ function stopRuntime(runtime, suppressCallbacks) {
 async function startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, options = {}) {
   if (runtime !== getActiveRuntime() || runtime.intentionallyClosed)
     return;
+  sealStartupLogs();
   installExternalToolBridge(runtime);
   const shouldStartCronScheduler = options.startCronScheduler !== false && process.env.LETTA_DISABLE_CRON_SCHEDULER !== "1";
   markListenerConnectionInitialized(runtime, opts.connectionId);
@@ -419346,6 +419480,7 @@ var init_lifecycle = __esm(async () => {
   init_telemetry();
   init_error_reporting();
   init_debug();
+  init_startup_log_boundary();
   init_terminal_handler();
   init_approval();
   init_auth();
@@ -422827,13 +422962,13 @@ function legacyImageFromPart(part) {
     const mediaType = typeof part.mediaType === "string" ? part.mediaType : typeof part.mime === "string" ? part.mime : undefined;
     const url = typeof part.url === "string" ? part.url : undefined;
     if (mediaType?.startsWith("image/") && url?.startsWith("data:")) {
-      const marker = ";base64,";
-      const markerIndex = url.indexOf(marker);
+      const marker2 = ";base64,";
+      const markerIndex = url.indexOf(marker2);
       if (markerIndex >= 0) {
         return {
           type: "image",
           mimeType: mediaType,
-          data: url.slice(markerIndex + marker.length)
+          data: url.slice(markerIndex + marker2.length)
         };
       }
     }
@@ -440056,7 +440191,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.32.1"
+    version: "0.32.2"
   };
 });
 
@@ -446835,13 +446970,13 @@ function parseGitHubSpecifier(input) {
     if (!owner || !repo)
       return null;
     const repoUrl = `https://github.com/${owner}/${repo}.git`;
-    const marker = parts[2];
-    if ((marker === "tree" || marker === "blob") && parts.length >= 4) {
+    const marker2 = parts[2];
+    if ((marker2 === "tree" || marker2 === "blob") && parts.length >= 4) {
       const treePath = parts.slice(3).join("/");
       return {
         repoUrl,
         branch: null,
-        subdir: marker === "blob" ? dirname34(treePath) : treePath
+        subdir: marker2 === "blob" ? dirname34(treePath) : treePath
       };
     }
     return { repoUrl, branch: null, subdir: null };
@@ -449056,43 +449191,43 @@ function addSignalStyle(state, start, style) {
   }
   state.ranges.push({ start, length, style });
 }
-function canOpenSignalMarker(text2, index, marker) {
-  const next = text2[index + marker.delimiter.length];
+function canOpenSignalMarker(text2, index, marker2) {
+  const next = text2[index + marker2.delimiter.length];
   if (!next || /\s/.test(next)) {
     return false;
   }
-  if (!marker.requireWordBoundary) {
+  if (!marker2.requireWordBoundary) {
     return true;
   }
   const previous = text2[index - 1];
   return !isWordLike(previous);
 }
-function isValidSignalMarkerContent(text2, closeIndex, content, marker) {
+function isValidSignalMarkerContent(text2, closeIndex, content, marker2) {
   if (content.length === 0 || /^\s|\s$/.test(content)) {
     return false;
   }
-  if (!marker.requireWordBoundary) {
+  if (!marker2.requireWordBoundary) {
     return true;
   }
-  const next = text2[closeIndex + marker.delimiter.length];
+  const next = text2[closeIndex + marker2.delimiter.length];
   return !isWordLike(next);
 }
-function findSignalClosingMarker(text2, contentStart, marker) {
+function findSignalClosingMarker(text2, contentStart, marker2) {
   let searchIndex = contentStart;
   while (searchIndex < text2.length) {
-    const closeIndex = text2.indexOf(marker.delimiter, searchIndex);
+    const closeIndex = text2.indexOf(marker2.delimiter, searchIndex);
     if (closeIndex < 0) {
       return -1;
     }
     if (isEscaped(text2, closeIndex)) {
-      searchIndex = closeIndex + marker.delimiter.length;
+      searchIndex = closeIndex + marker2.delimiter.length;
       continue;
     }
     const content = text2.slice(contentStart, closeIndex);
-    if (isValidSignalMarkerContent(text2, closeIndex, content, marker)) {
+    if (isValidSignalMarkerContent(text2, closeIndex, content, marker2)) {
       return closeIndex;
     }
-    searchIndex = closeIndex + marker.delimiter.length;
+    searchIndex = closeIndex + marker2.delimiter.length;
   }
   return -1;
 }
@@ -449124,17 +449259,17 @@ function parseSignalInline(text2, state) {
         continue;
       }
     }
-    const marker = SIGNAL_INLINE_MARKERS.find((candidate) => text2.startsWith(candidate.delimiter, index) && !isEscaped(text2, index) && canOpenSignalMarker(text2, index, candidate));
-    if (marker) {
-      const contentStart = index + marker.delimiter.length;
-      const closeIndex = findSignalClosingMarker(text2, contentStart, marker);
+    const marker2 = SIGNAL_INLINE_MARKERS.find((candidate) => text2.startsWith(candidate.delimiter, index) && !isEscaped(text2, index) && canOpenSignalMarker(text2, index, candidate));
+    if (marker2) {
+      const contentStart = index + marker2.delimiter.length;
+      const closeIndex = findSignalClosingMarker(text2, contentStart, marker2);
       if (closeIndex >= 0) {
         const start = state.text.length;
         parseSignalInline(text2.slice(contentStart, closeIndex), state);
-        for (const style of marker.styles) {
+        for (const style of marker2.styles) {
           addSignalStyle(state, start, style);
         }
-        index = closeIndex + marker.delimiter.length;
+        index = closeIndex + marker2.delimiter.length;
         continue;
       }
     }
@@ -449524,6 +449659,38 @@ async function executeMessageChannel(input, options) {
   const normalized = normalizeMessageChannelInput(input, options.resolver);
   if (typeof normalized === "string")
     return normalized;
+  if (normalized.action === "get-binding" || normalized.action === "update-binding") {
+    if (normalized.channel !== "slack" || !options.bindings) {
+      return "Error: Binding operations are not supported by this channel host.";
+    }
+    if (!normalized.chatId || normalized.target) {
+      return "Error: Binding operations require chat_id; target is for outbound sends.";
+    }
+    if (input.threadId !== null && (typeof input.threadId !== "string" || !/^\d+\.\d+$/.test(input.threadId))) {
+      return "Error: Binding operations require an exact threadId timestamp, or explicit null for an unthreaded DM.";
+    }
+    const selection = {
+      channel: normalized.channel,
+      accountId: normalized.accountId,
+      chatId: normalized.chatId,
+      threadId: input.threadId
+    };
+    try {
+      if (normalized.action === "get-binding") {
+        return JSON.stringify(await options.bindings.get(selection, options.scope));
+      }
+      const conversationId = firstNonEmptyString4(input.conversationId);
+      const expectedConversationId = firstNonEmptyString4(input.expectedConversationId);
+      if (!conversationId || !expectedConversationId) {
+        return "Error: update-binding requires conversationId and expectedConversationId.";
+      }
+      const result2 = await options.bindings.update({ ...selection, conversationId, expectedConversationId }, options.scope);
+      const prefix = result2.status === "conflict" || result2.status === "not-found" ? "Error: " : "";
+      return `${prefix}${JSON.stringify(result2)}`;
+    } catch (error5) {
+      return `Error: Binding operation failed: ${error5 instanceof Error ? error5.message : "unknown error"}`;
+    }
+  }
   if (normalized.channel === "slack" && normalized.action === "download-file" && normalized.target) {
     return "Error: Slack download-file requires chat_id from a routed channel context; target is not supported.";
   }
@@ -449538,6 +449705,7 @@ async function executeMessageChannel(input, options) {
         channel: normalized.channel,
         chatId: normalized.chatId,
         accountId,
+        ...normalized.threadId !== null ? { threadId: normalized.threadId } : {},
         scope: options.scope
       });
       if (typeof context4 === "string")
@@ -451523,7 +451691,9 @@ Replies to routed Telegram topics stay in the current topic automatically.` : ""
     hasAction("react") ? 'action="react" with emoji + messageId' : "",
     hasAction("list-custom-emojis") ? 'action="list-custom-emojis" to discover the workspace custom emoji names available for reactions' : "",
     hasAction("upload-file") ? 'action="upload-file" with media' : "",
-    hasAction("download-file") ? 'action="download-file" with attachmentId + messageId' : ""
+    hasAction("download-file") ? 'action="download-file" with attachmentId + messageId' : "",
+    hasAction("get-binding") ? 'action="get-binding" with chat_id and an explicit threadId (null for an unthreaded DM) to inspect the persisted incoming-message destination without sending' : "",
+    hasAction("update-binding") ? 'action="update-binding" with the same exact thread, conversationId, and expectedConversationId to reassign an existing binding within this agent. It does not send a message, copy history, move queued inputs, change computers, or alter pause/detach settings. Outbound sends never take over an existing binding' : ""
   ].filter(Boolean) : [];
   const slackCapabilityGuidance = slackCapabilities.length > 0 ? `
 
@@ -454682,493 +454852,6 @@ var init_headless_tool_events = __esm(async () => {
   await init_approval_execution();
 });
 
-// src/skills/builtin/creating-skills/scripts/validate-skill.ts
-import { existsSync as existsSync65, readFileSync as readFileSync41 } from "node:fs";
-import { basename as basename29, join as join83, resolve as resolve39 } from "node:path";
-import { fileURLToPath as fileURLToPath11 } from "node:url";
-function parseQuotedScalar(value) {
-  if (value.startsWith('"')) {
-    if (!value.endsWith('"') || value.length === 1) {
-      throw new Error("Unterminated double-quoted scalar");
-    }
-    return JSON.parse(value);
-  }
-  if (value.startsWith("'")) {
-    if (!value.endsWith("'") || value.length === 1) {
-      throw new Error("Unterminated single-quoted scalar");
-    }
-    return value.slice(1, -1).replace(/''/g, "'");
-  }
-  return value;
-}
-function parseScalar(value) {
-  const trimmed = value.trim();
-  if (!trimmed)
-    return "";
-  if (trimmed === "true")
-    return true;
-  if (trimmed === "false")
-    return false;
-  if (trimmed === "null" || trimmed === "~")
-    return null;
-  if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
-    return parseQuotedScalar(trimmed);
-  }
-  if (trimmed.includes(": ")) {
-    throw new Error(`Unexpected ':' in unquoted scalar: ${trimmed}`);
-  }
-  if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
-    return Number(trimmed);
-  }
-  return trimmed;
-}
-function parseFrontmatterFallback(source) {
-  const result2 = {};
-  const lines = source.split(/\r?\n/);
-  for (let i4 = 0;i4 < lines.length; i4++) {
-    const line = lines[i4];
-    if (line === undefined)
-      continue;
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    if (/^\s/.test(line)) {
-      continue;
-    }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex <= 0) {
-      throw new Error(`Invalid frontmatter line: ${line}`);
-    }
-    const key2 = line.slice(0, colonIndex).trim();
-    const rawValue = line.slice(colonIndex + 1).trim();
-    if (!key2) {
-      throw new Error(`Invalid frontmatter line: ${line}`);
-    }
-    if (!rawValue) {
-      result2[key2] = {};
-      continue;
-    }
-    if (rawValue === "|" || rawValue === ">") {
-      const blockLines = [];
-      for (let j2 = i4 + 1;j2 < lines.length; j2++) {
-        const nextLine = lines[j2];
-        if (nextLine === undefined)
-          continue;
-        if (nextLine.trim() && !/^\s/.test(nextLine)) {
-          break;
-        }
-        blockLines.push(nextLine.replace(/^\s{2}/, ""));
-        i4 = j2;
-      }
-      result2[key2] = rawValue === ">" ? blockLines.join(" ").trim() : blockLines.join(`
-`);
-      continue;
-    }
-    result2[key2] = parseScalar(rawValue);
-  }
-  return result2;
-}
-function parseFrontmatter2(source) {
-  const bunParse = globalThis.Bun?.YAML?.parse;
-  if (bunParse) {
-    const parsed = bunParse(source);
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new Error("Frontmatter must be a YAML dictionary");
-    }
-    return parsed;
-  }
-  return parseFrontmatterFallback(source);
-}
-function validateSkill(skillPath) {
-  const skillMdPath = join83(skillPath, "SKILL.md");
-  if (!existsSync65(skillMdPath)) {
-    return { valid: false, message: "SKILL.md not found" };
-  }
-  const content = readFileSync41(skillMdPath, "utf-8");
-  if (!content.startsWith("---")) {
-    return { valid: false, message: "No YAML frontmatter found" };
-  }
-  const match3 = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match3) {
-    return { valid: false, message: "Invalid frontmatter format" };
-  }
-  const frontmatterText = match3[1];
-  let frontmatter;
-  try {
-    frontmatter = parseFrontmatter2(frontmatterText);
-    if (typeof frontmatter !== "object" || frontmatter === null) {
-      return { valid: false, message: "Frontmatter must be a YAML dictionary" };
-    }
-  } catch (e2) {
-    return {
-      valid: false,
-      message: `Invalid YAML in frontmatter: ${e2 instanceof Error ? e2.message : String(e2)}`
-    };
-  }
-  const warnings = [];
-  const unexpectedKeys = Object.keys(frontmatter).filter((key2) => !ALLOWED_PROPERTIES.has(key2));
-  if (unexpectedKeys.length > 0) {
-    warnings.push(`Unknown frontmatter key(s): ${unexpectedKeys.sort().join(", ")}. Known properties are: ${[...ALLOWED_PROPERTIES].sort().join(", ")}`);
-  }
-  if (!("name" in frontmatter)) {
-    return { valid: false, message: "Missing 'name' in frontmatter" };
-  }
-  if (!("description" in frontmatter)) {
-    return { valid: false, message: "Missing 'description' in frontmatter" };
-  }
-  const name = frontmatter.name;
-  if (typeof name !== "string") {
-    return {
-      valid: false,
-      message: `Name must be a string, got ${typeof name}`
-    };
-  }
-  const trimmedName = name.trim();
-  if (trimmedName) {
-    if (!/^[a-z0-9-]+$/.test(trimmedName)) {
-      return {
-        valid: false,
-        message: `Name '${trimmedName}' should be hyphen-case (lowercase letters, digits, and hyphens only)`
-      };
-    }
-    if (trimmedName.startsWith("-") || trimmedName.endsWith("-") || trimmedName.includes("--")) {
-      return {
-        valid: false,
-        message: `Name '${trimmedName}' cannot start/end with hyphen or contain consecutive hyphens`
-      };
-    }
-    if (trimmedName.length > MAX_SKILL_NAME_LENGTH) {
-      return {
-        valid: false,
-        message: `Name is too long (${trimmedName.length} characters). Maximum is ${MAX_SKILL_NAME_LENGTH} characters.`
-      };
-    }
-    const dirName = basename29(skillPath);
-    if (trimmedName !== dirName) {
-      warnings.push(`Name '${trimmedName}' doesn't match directory name '${dirName}'. For portability, these should match.`);
-    }
-  }
-  const description = frontmatter.description;
-  if (typeof description !== "string") {
-    return {
-      valid: false,
-      message: `Description must be a string, got ${typeof description}`
-    };
-  }
-  const trimmedDescription = description.trim();
-  if (trimmedDescription) {
-    if (trimmedDescription.includes("<") || trimmedDescription.includes(">")) {
-      return {
-        valid: false,
-        message: "Description cannot contain angle brackets (< or >)"
-      };
-    }
-    if (trimmedDescription.length > 1024) {
-      return {
-        valid: false,
-        message: `Description is too long (${trimmedDescription.length} characters). Maximum is 1024 characters.`
-      };
-    }
-  }
-  return {
-    valid: true,
-    message: "Skill is valid!",
-    warnings: warnings.length > 0 ? warnings : undefined
-  };
-}
-function isMainModule() {
-  const entrypoint = process.argv[1];
-  return entrypoint ? resolve39(entrypoint) === fileURLToPath11(import.meta.url) : false;
-}
-var ALLOWED_PROPERTIES, MAX_SKILL_NAME_LENGTH = 64;
-var init_validate_skill = __esm(() => {
-  ALLOWED_PROPERTIES = new Set([
-    "name",
-    "description",
-    "license",
-    "compatibility",
-    "metadata",
-    "allowed-tools"
-  ]);
-  if (isMainModule()) {
-    const args = process.argv.slice(2);
-    if (args.length !== 1) {
-      console.log("Usage: npx tsx validate-skill.ts <skill-directory>");
-      process.exit(1);
-    }
-    const { valid: valid2, message, warnings } = validateSkill(args[0]);
-    console.log(message);
-    if (warnings && warnings.length > 0) {
-      for (const warning of warnings) {
-        console.warn(`Warning: ${warning}`);
-      }
-    }
-    process.exit(valid2 ? 0 : 1);
-  }
-});
-
-// src/agent/github-utils.ts
-var exports_github_utils = {};
-__export(exports_github_utils, {
-  parseDirNames: () => parseDirNames,
-  fetchGitHubContents: () => fetchGitHubContents
-});
-async function fetchGitHubContents(owner, repo, branch, path50) {
-  const apiPath = path50 ? `repos/${owner}/${repo}/contents/${path50}?ref=${branch}` : `repos/${owner}/${repo}/contents?ref=${branch}`;
-  try {
-    const { execFileSync: execFileSync7 } = await import("node:child_process");
-    const result2 = execFileSync7("gh", ["api", apiPath], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    });
-    return JSON.parse(result2);
-  } catch {}
-  const url2 = `https://api.github.com/repos/${owner}/${repo}/contents/${path50}?ref=${branch}`;
-  const response = await fetch(url2, {
-    headers: {
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "letta-code"
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch from ${owner}/${repo}/${branch}/${path50}: ${response.statusText}`);
-  }
-  return await response.json();
-}
-function parseDirNames(entries) {
-  return new Set(entries.filter((e2) => e2.type === "dir").map((e2) => e2.name));
-}
-
-// src/agent/import.ts
-var exports_import = {};
-__export(exports_import, {
-  importAgentFromRegistry: () => importAgentFromRegistry,
-  importAgentFromFile: () => importAgentFromFile,
-  extractSkillsFromAf: () => extractSkillsFromAf
-});
-import { createReadStream as createReadStream3 } from "node:fs";
-import { access as access3, chmod, mkdir as mkdir17, readFile as readFile30, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname35, isAbsolute as isAbsolute31, relative as relative14, resolve as resolve40, sep as sep9, 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)) {
-    throw new Error(`Invalid imported skill name "${String(name)}". Skill names may only contain letters, numbers, dots, underscores, and hyphens.`);
-  }
-  return trimmedName;
-}
-function assertPathInside(parent, child) {
-  const parentPath = resolve40(parent);
-  const childPath = resolve40(child);
-  const relativePath = relative14(parentPath, childPath);
-  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep9}`) || isAbsolute31(relativePath)) {
-    throw new Error(`Imported skill file path escapes skill directory: ${child}`);
-  }
-}
-function validateImportedSkillFilePath(filePath) {
-  if (filePath.length === 0 || filePath === "." || filePath.includes("\x00") || filePath.includes("\\") || isAbsolute31(filePath) || win325.isAbsolute(filePath)) {
-    throw new Error(`Invalid imported skill file path "${filePath}".`);
-  }
-  const segments = filePath.split("/");
-  if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
-    throw new Error(`Invalid imported skill file path "${filePath}".`);
-  }
-  return filePath;
-}
-function resolveImportedSkillFilePath(skillDir, filePath) {
-  const safeFilePath = validateImportedSkillFilePath(filePath);
-  const fullPath = resolve40(skillDir, safeFilePath);
-  assertPathInside(skillDir, fullPath);
-  return fullPath;
-}
-function tagsEqual(left, right) {
-  return left.length === right.length && left.every((tag, i4) => tag === right[i4]);
-}
-async function resolveImportedAgentMemfsEnabled() {
-  const backend3 = getBackend();
-  const isLettaCloud2 = backend3.capabilities.remoteMemfs && !backend3.capabilities.localMemfs ? await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem)).then((module3) => module3.isLettaCloud()) : false;
-  return resolveCreatedAgentMemfsConfig({
-    capabilities: backend3.capabilities,
-    isLettaCloud: isLettaCloud2
-  }).enableMemfs;
-}
-async function ensureImportedAgentCreationTags(agent, enableMemfs) {
-  const tags = buildCreatedAgentTags({
-    tags: agent.tags,
-    enableMemfs
-  });
-  if (tagsEqual(agent.tags ?? [], tags)) {
-    return agent;
-  }
-  const updatedAgent = await getBackend().updateAgent(agent.id, { tags });
-  return {
-    ...agent,
-    ...updatedAgent,
-    tags: updatedAgent.tags ?? tags
-  };
-}
-async function importAgentFromFile(options) {
-  if (!getBackend().capabilities.agentFileImportExport) {
-    throw new Error("Agent file import is not supported by this backend yet");
-  }
-  const resolvedPath = resolve40(options.filePath);
-  try {
-    await access3(resolvedPath);
-  } catch {
-    throw new Error(`AgentFile not found: ${resolvedPath}`);
-  }
-  const client = await getClient();
-  const file = createReadStream3(resolvedPath);
-  const importResponse = await client.agents.importFile({
-    file,
-    strip_messages: options.stripMessages ?? true,
-    override_existing_tools: false
-  });
-  if (!importResponse.agent_ids || importResponse.agent_ids.length === 0) {
-    throw new Error("Import failed: no agent IDs returned");
-  }
-  const agentId = importResponse.agent_ids[0];
-  let agent = await client.agents.retrieve(agentId, {
-    include: ["agent.tags"]
-  });
-  if (options.modelOverride) {
-    const updateArgs = getModelUpdateArgs(options.modelOverride);
-    await updateAgentLLMConfig(agentId, options.modelOverride, updateArgs);
-    const { ensureCorrectMemoryTool: ensureCorrectMemoryTool2 } = await init_toolset().then(() => exports_toolset);
-    await ensureCorrectMemoryTool2(agentId, options.modelOverride);
-    agent = await client.agents.retrieve(agentId, { include: ["agent.tags"] });
-  }
-  agent = await ensureImportedAgentCreationTags(agent, await resolveImportedAgentMemfsEnabled());
-  let skills;
-  if (!options.stripSkills) {
-    const { getAgentSkillsDir: getAgentSkillsDir2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
-    const skillsDir = getAgentSkillsDir2(agentId);
-    skills = await extractSkillsFromAf(resolvedPath, skillsDir);
-  }
-  return { agent, skills };
-}
-async function extractSkillsFromAf(afPath, destDir) {
-  const extracted = [];
-  const content = await readFile30(afPath, "utf-8");
-  const afData = JSON.parse(content);
-  if (!afData.skills || !Array.isArray(afData.skills)) {
-    return [];
-  }
-  for (const skill2 of afData.skills) {
-    const skillName = validateImportedSkillName(skill2.name);
-    const skillDir = resolve40(destDir, skillName);
-    await mkdir17(skillDir, { recursive: true });
-    if (skill2.files) {
-      await writeSkillFiles(skillDir, skill2.files);
-      extracted.push(skillName);
-    } else if (skill2.source_url) {
-      await fetchSkillFromUrl(skillDir, skill2.source_url);
-      extracted.push(skillName);
-    } else {
-      console.warn(`Skipping skill ${skillName}: no files or source_url`);
-    }
-  }
-  return extracted;
-}
-async function writeSkillFiles(skillDir, files) {
-  for (const [filePath, fileContent] of Object.entries(files)) {
-    await writeSkillFile(skillDir, filePath, fileContent);
-  }
-}
-async function writeSkillFile(skillDir, filePath, content) {
-  const fullPath = resolveImportedSkillFilePath(skillDir, filePath);
-  await mkdir17(dirname35(fullPath), { recursive: true });
-  await writeFile19(fullPath, content, "utf-8");
-  const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
-  if (isScript) {
-    try {
-      await chmod(fullPath, 493);
-    } catch {}
-  }
-}
-async function fetchSkillFromUrl(skillDir, sourceUrl) {
-  const githubPath = sourceUrl.replace(/^github\.com\//, "").replace(/\/tree\//, "/");
-  const parts = githubPath.split("/");
-  if (parts.length < 4 || !parts[0] || !parts[1] || !parts[2]) {
-    throw new Error(`Invalid GitHub path: ${githubPath}`);
-  }
-  const owner = parts[0];
-  const repo = parts[1];
-  const branch = parts[2];
-  const path50 = parts.slice(3).join("/");
-  const { fetchGitHubContents: fetchGitHubContents2 } = await Promise.resolve().then(() => exports_github_utils);
-  const entries = await fetchGitHubContents2(owner, repo, branch, path50);
-  if (!Array.isArray(entries)) {
-    throw new Error(`Expected directory at ${sourceUrl}, got file`);
-  }
-  await downloadGitHubDirectory(entries, skillDir, owner, repo, branch, path50);
-}
-async function downloadGitHubDirectory(entries, destDir, owner, repo, branch, basePath) {
-  const { fetchGitHubContents: fetchGitHubContents2 } = await Promise.resolve().then(() => exports_github_utils);
-  for (const entry of entries) {
-    if (entry.type === "file") {
-      if (!entry.download_url) {
-        throw new Error(`Missing download_url for file: ${entry.path}`);
-      }
-      const fileResponse = await fetch(entry.download_url);
-      const fileContent = await fileResponse.text();
-      const relativePath = entry.path.replace(`${basePath}/`, "");
-      await writeSkillFile(destDir, relativePath, fileContent);
-    } else if (entry.type === "dir") {
-      const subEntries = await fetchGitHubContents2(owner, repo, branch, entry.path);
-      await downloadGitHubDirectory(subEntries, destDir, owner, repo, branch, basePath);
-    }
-  }
-}
-function parseRegistryHandle(handle2) {
-  const normalized = handle2.startsWith("@") ? handle2.slice(1) : handle2;
-  const parts = normalized.split("/");
-  if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new Error(`Invalid import handle "${handle2}". Use format: @author/agentname`);
-  }
-  return { author: parts[0], name: parts[1] };
-}
-async function importAgentFromRegistry(options) {
-  const { tmpdir: tmpdir12 } = await import("node:os");
-  const { join: join84 } = await import("node:path");
-  const { writeFile: writeFile20, unlink: unlink6 } = await import("node:fs/promises");
-  const { author, name } = parseRegistryHandle(options.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);
-  if (!response.ok) {
-    if (response.status === 404) {
-      throw new Error(`Agent @${author}/${name} not found in registry. Check that the agent exists at https://github.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/tree/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}`);
-    }
-    throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
-  }
-  const afContent = await response.text();
-  const tempPath = join84(tmpdir12(), `letta-import-${author}-${name}-${Date.now()}.af`);
-  await writeFile20(tempPath, afContent, "utf-8");
-  try {
-    const result2 = await importAgentFromFile({
-      filePath: tempPath,
-      modelOverride: options.modelOverride,
-      stripMessages: options.stripMessages ?? true,
-      stripSkills: options.stripSkills ?? false
-    });
-    return result2;
-  } finally {
-    try {
-      await unlink6(tempPath);
-    } catch {}
-  }
-}
-var IMPORTED_SKILL_NAME_PATTERN, AGENT_REGISTRY_OWNER = "letta-ai", AGENT_REGISTRY_REPO = "agent-file", AGENT_REGISTRY_BRANCH = "main";
-var init_import = __esm(() => {
-  init_backend2();
-  init_client4();
-  init_validate_skill();
-  init_create5();
-  init_model();
-  init_modify();
-  IMPORTED_SKILL_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
-});
-
 // src/agent/defaults.ts
 var exports_defaults = {};
 __export(exports_defaults, {
@@ -455533,10 +455216,10 @@ async function sendScopedApprovalMessages(params) {
   });
 }
 async function flushAndExit(code2) {
-  const flushWritable = (stream12) => new Promise((resolve41) => {
+  const flushWritable = (stream12) => new Promise((resolve39) => {
     if (stream12.destroyed || stream12.writableEnded)
-      return resolve41();
-    stream12.write("", () => resolve41());
+      return resolve39();
+    stream12.write("", () => resolve39());
   });
   await closeClientMcpServers();
   await Promise.allSettled([
@@ -455546,12 +455229,12 @@ async function flushAndExit(code2) {
   process.exit(code2);
 }
 async function writeFinalHeadlessStdout(text2) {
-  await new Promise((resolve41) => {
+  await new Promise((resolve39) => {
     if (process.stdout.destroyed || process.stdout.writableEnded) {
-      resolve41();
+      resolve39();
       return;
     }
-    process.stdout.write(text2, () => resolve41());
+    process.stdout.write(text2, () => resolve39());
   });
 }
 function buildEnvironmentResponseMetadata(params) {
@@ -455698,10 +455381,6 @@ In headless mode, use:
     process.exit(1);
   }
   const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !isStatelessSession;
-  const fromAfFile = resolveImportFlagAlias({
-    importFlagValue: values4.import,
-    fromAfFlagValue: values4["from-af"]
-  });
   const preLoadSkillsRaw = values4["pre-load-skills"];
   const systemInfoReminderEnabled = systemInfoReminderEnabledOverride ?? !values4["no-system-info-reminder"];
   const reflectionOverrides = (() => {
@@ -455754,7 +455433,7 @@ In headless mode, use:
     return reportAndExitHeadless("headless_conversation_shorthand_failed", error5, "headless_startup_conversation_shorthand");
   }
   const ambientAgentId = (process.env.LETTA_AGENT_ID || process.env.AGENT_ID || "").trim();
-  if ((startupOptions.requestedBackendMode || usesRemoteEnvironment) && ambientAgentId && !specifiedAgentId && !specifiedAgentName && !specifiedConversationId && !forceNew && !fromAfFile && !fromAgentId) {
+  if ((startupOptions.requestedBackendMode || usesRemoteEnvironment) && ambientAgentId && !specifiedAgentId && !specifiedAgentName && !specifiedConversationId && !forceNew && !fromAgentId) {
     specifiedAgentId = ambientAgentId;
     specifiedAgentIdFromAmbient = true;
   }
@@ -455791,7 +455470,6 @@ In headless mode, use:
       specifiedAgentName,
       forceNewAgent: forceNew,
       forceNewConversation,
-      importFile: fromAfFile,
       stateless: statelessFlag,
       ephemeral: ephemeralFlag,
       isHeadless: true,
@@ -455804,39 +455482,6 @@ In headless mode, use:
   if (ephemeralFlag && (isBidirectionalMode || usesRemoteEnvironment)) {
     return reportAndExitHeadless("headless_ephemeral_transport_unsupported", "--ephemeral supports direct one-shot headless prompts only", "headless_startup_flag_conflicts");
   }
-  let isRegistryImport = false;
-  if (fromAfFile) {
-    try {
-      validateFlagConflicts({
-        guard: fromAfFile,
-        checks: [
-          {
-            when: specifiedAgentId,
-            message: "--import cannot be used with --agent"
-          },
-          {
-            when: specifiedAgentName,
-            message: "--import cannot be used with --name"
-          },
-          {
-            when: forceNew,
-            message: "--import cannot be used with --new-agent"
-          }
-        ]
-      });
-    } catch (error5) {
-      return reportAndExitHeadless("headless_import_flag_validation_failed", error5, "headless_startup_import_flag_validation");
-    }
-    if (fromAfFile.startsWith("@")) {
-      isRegistryImport = true;
-      try {
-        validateRegistryHandleOrThrow(fromAfFile);
-      } catch {
-        console.error(`Error: Invalid registry handle "${fromAfFile}". Use format: letta --import @author/agentname`);
-        process.exit(1);
-      }
-    }
-  }
   if (specifiedAgentName) {
     if (specifiedAgentId) {
       console.error("Error: --name cannot be used with --agent");
@@ -455878,35 +455523,6 @@ In headless mode, use:
       process.exit(1);
     }
   }
-  if (!agent && fromAfFile) {
-    let result2;
-    if (isRegistryImport) {
-      const { importAgentFromRegistry: importAgentFromRegistry2 } = await Promise.resolve().then(() => (init_import(), exports_import));
-      result2 = await importAgentFromRegistry2({
-        handle: fromAfFile,
-        modelOverride: model,
-        stripMessages: true,
-        stripSkills: false
-      });
-    } else {
-      const { importAgentFromFile: importAgentFromFile2 } = await Promise.resolve().then(() => (init_import(), exports_import));
-      result2 = await importAgentFromFile2({
-        filePath: fromAfFile,
-        modelOverride: model,
-        stripMessages: true,
-        stripSkills: false
-      });
-    }
-    agent = result2.agent;
-    if (settingsManager.isReady) {
-      settingsManager.setSystemPromptCustom(agent.id);
-    }
-    if (result2.skills && result2.skills.length > 0) {
-      const { getAgentSkillsDir: getAgentSkillsDir2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
-      const skillsDir = getAgentSkillsDir2(agent.id);
-      console.log(`\uD83D\uDCE6 Extracted ${result2.skills.length} skill${result2.skills.length === 1 ? "" : "s"} to ${skillsDir}: ${result2.skills.join(", ")}`);
-    }
-  }
   if (!agent && specifiedAgentId) {
     try {
       agent = await backend3.retrieveAgent(specifiedAgentId, {
@@ -456023,7 +455639,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   markMilestone("HEADLESS_AGENT_RESOLVED");
   const publicAgentId = ephemeralFlag ? null : agent.id;
   telemetry.setCurrentAgent(publicAgentId, agent.tags);
-  const isResumingAgent = !ephemeralFlag && !!(specifiedAgentId || !forceNew && !fromAfFile);
+  const isResumingAgent = !ephemeralFlag && !!(specifiedAgentId || !forceNew);
   if (isResumingAgent) {
     if (model) {
       const modelHandle = resolveModel(model);
@@ -456789,7 +456405,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
             }
-            await new Promise((resolve41) => setTimeout(resolve41, retryDelayMs));
+            await new Promise((resolve39) => setTimeout(resolve39, retryDelayMs));
             continue;
           }
         }
@@ -456818,7 +456434,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`Transient API error before streaming (attempt ${attempt2} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve41) => setTimeout(resolve41, delayMs));
+          await new Promise((resolve39) => setTimeout(resolve39, delayMs));
           conversationBusyRetries = 0;
           continue;
         }
@@ -457073,7 +456689,7 @@ ${loadedContents.join(`
             const delaySeconds = Math.round(delayMs / 1000);
             console.error(`LLM API error encountered (attempt ${attempt2} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
           }
-          await new Promise((resolve41) => setTimeout(resolve41, delayMs));
+          await new Promise((resolve39) => setTimeout(resolve39, delayMs));
           currentInput = refreshInputOtidsForNewRequest(currentInput);
           continue;
         }
@@ -457165,7 +456781,7 @@ ${loadedContents.join(`
             } else {
               console.error(`Empty LLM response, retrying (attempt ${attempt2} of ${EMPTY_RESPONSE_MAX_RETRIES2})...`);
             }
-            await new Promise((resolve41) => setTimeout(resolve41, delayMs));
+            await new Promise((resolve39) => setTimeout(resolve39, delayMs));
             currentInput = refreshInputOtidsForNewRequest(currentInput);
             continue;
           }
@@ -457193,7 +456809,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt2} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve41) => setTimeout(resolve41, delayMs));
+            await new Promise((resolve39) => setTimeout(resolve39, delayMs));
             currentInput = refreshInputOtidsForNewRequest(currentInput);
             continue;
           }
@@ -457223,7 +456839,7 @@ ${loadedContents.join(`
               const delaySeconds = Math.round(delayMs / 1000);
               console.error(`LLM API error encountered (attempt ${attempt2} of ${LLM_API_ERROR_MAX_RETRIES2}), retrying in ${delaySeconds}s...`);
             }
-            await new Promise((resolve41) => setTimeout(resolve41, delayMs));
+            await new Promise((resolve39) => setTimeout(resolve39, delayMs));
             currentInput = refreshInputOtidsForNewRequest(currentInput);
             continue;
           }
@@ -457618,9 +457234,9 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
     const syntheticUserLine = serializeQueuedMessageAsUserLine(queuedMessage);
     maybeNotifyBlocked(syntheticUserLine);
     if (lineResolver) {
-      const resolve41 = lineResolver;
+      const resolve39 = lineResolver;
       lineResolver = null;
-      resolve41(syntheticUserLine);
+      resolve39(syntheticUserLine);
       return;
     }
     lineQueue.push(syntheticUserLine);
@@ -457640,9 +457256,9 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
       if (action3 === "abort-active") {
         currentAbortController.abort();
         if (lineResolver) {
-          const resolve41 = lineResolver;
+          const resolve39 = lineResolver;
           lineResolver = null;
-          resolve41(null);
+          resolve39(null);
         }
       } else if (action3 === "latch") {
         pendingInterrupt = true;
@@ -457662,9 +457278,9 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
     if (lineResolver) {
       if (parsedLine?.type === "user")
         turnStarting = true;
-      const resolve41 = lineResolver;
+      const resolve39 = lineResolver;
       lineResolver = null;
-      resolve41(line);
+      resolve39(line);
     } else {
       lineQueue.push(line);
     }
@@ -457673,17 +457289,17 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
     setMessageQueueAdder(null);
     msgQueueRuntime.clear("shutdown");
     if (lineResolver) {
-      const resolve41 = lineResolver;
+      const resolve39 = lineResolver;
       lineResolver = null;
-      resolve41(null);
+      resolve39(null);
     }
   });
   async function getNextLine() {
     if (lineQueue.length > 0) {
       return lineQueue.shift() ?? null;
     }
-    return new Promise((resolve41) => {
-      lineResolver = resolve41;
+    return new Promise((resolve39) => {
+      lineResolver = resolve39;
     });
   }
   async function requestPermission(toolCallId, toolName2, toolInput) {
@@ -458171,7 +457787,7 @@ async function runBidirectionalMode(agent, conversationId, _outputFormat, includ
                   uuid: `retry-bidir-${randomUUID37()}`
                 };
                 writeWireMessage(retryMsg);
-                await new Promise((resolve41) => setTimeout(resolve41, delayMs));
+                await new Promise((resolve39) => setTimeout(resolve39, delayMs));
                 continue;
               }
               throw preStreamError;
@@ -458885,7 +458501,7 @@ var BYTES_PER_TOKEN = 4;
 
 // src/cli/helpers/window-title-config.ts
 import { homedir as homedir45 } from "node:os";
-import { basename as basename30, resolve as resolve41 } from "node:path";
+import { basename as basename29, resolve as resolve39 } from "node:path";
 function isWindowTitleField(value) {
   return WINDOW_TITLE_FIELDS.includes(value);
 }
@@ -459043,8 +458659,8 @@ function terminalTitleProjectName(data) {
   const directory = titleDirectory(data);
   if (!directory)
     return null;
-  const resolved = resolve41(directory);
-  const name = basename30(resolved) || formatDirectoryDisplay(resolved) || resolved;
+  const resolved = resolve39(directory);
+  const name = basename29(resolved) || formatDirectoryDisplay(resolved) || resolved;
   return truncateTerminalTitlePart(name, 24);
 }
 function titleDirectory(data) {
@@ -459053,7 +458669,7 @@ function titleDirectory(data) {
 function formatDirectoryDisplay(directory) {
   if (!directory)
     return null;
-  const resolved = resolve41(directory);
+  const resolved = resolve39(directory);
   const home = homedir45();
   if (resolved === home)
     return "~";
@@ -459776,10 +459392,10 @@ var init_queued_message_parts = __esm(() => {
 
 // src/cli/helpers/reflection-arena-hf-upload.ts
 import { execFile as execFileCb5 } from "node:child_process";
-import { existsSync as existsSync67 } from "node:fs";
-import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir18, writeFile as writeFile20 } from "node:fs/promises";
+import { existsSync as existsSync66 } from "node:fs";
+import { appendFile as appendFile2, chmod, mkdir as mkdir17, writeFile as writeFile19 } from "node:fs/promises";
 import { homedir as homedir46 } from "node:os";
-import { join as join85 } from "node:path";
+import { join as join84 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 function buildGitEnv(token2, askpassPath) {
   return {
@@ -459815,8 +459431,8 @@ async function runGit6(cwd2, args, env5) {
   }
 }
 async function writeGitAskpass(repoRoot) {
-  const askpassPath = join85(repoRoot, "hf-askpass.sh");
-  await writeFile20(askpassPath, [
+  const askpassPath = join84(repoRoot, "hf-askpass.sh");
+  await writeFile19(askpassPath, [
     "#!/bin/sh",
     'case "$1" in',
     "  *Username*) printf '%s\\n' 'hf_user' ;;",
@@ -459825,12 +459441,12 @@ async function writeGitAskpass(repoRoot) {
     ""
   ].join(`
 `), { encoding: "utf-8", mode: 448 });
-  await chmod2(askpassPath, 448);
+  await chmod(askpassPath, 448);
   return askpassPath;
 }
 async function prepareHfRepo(env5) {
-  await mkdir18(HF_CACHE_ROOT, { recursive: true });
-  if (!existsSync67(join85(HF_REPO_DIR, ".git"))) {
+  await mkdir17(HF_CACHE_ROOT, { recursive: true });
+  if (!existsSync66(join84(HF_REPO_DIR, ".git"))) {
     await runGit6(HF_CACHE_ROOT, ["clone", "--depth", "1", HF_REPO_URL, HF_REPO_DIR], env5);
     return HF_REPO_DIR;
   }
@@ -459860,13 +459476,13 @@ async function maybeUploadReflectionArenaChoiceToHf(row) {
   if (!token2) {
     return { uploaded: false, reason: "missing_token" };
   }
-  await mkdir18(HF_CACHE_ROOT, { recursive: true });
+  await mkdir17(HF_CACHE_ROOT, { recursive: true });
   const askpassPath = await writeGitAskpass(HF_CACHE_ROOT);
   const env5 = buildGitEnv(token2, askpassPath);
   try {
     const repoDir = await prepareHfRepo(env5);
-    await mkdir18(join85(repoDir, "data"), { recursive: true });
-    await appendFile2(join85(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
+    await mkdir17(join84(repoDir, "data"), { recursive: true });
+    await appendFile2(join84(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
 `, {
       encoding: "utf-8"
     });
@@ -459894,16 +459510,16 @@ var init_reflection_arena_hf_upload = __esm(() => {
   init_version();
   execFile18 = promisify16(execFileCb5);
   HF_REPO_URL = `https://huggingface.co/datasets/${HF_REPO_ID}`;
-  HF_CACHE_ROOT = join85(homedir46(), ".letta", "reflection-arena", "hf-upload");
-  HF_REPO_DIR = join85(HF_CACHE_ROOT, "repo");
+  HF_CACHE_ROOT = join84(homedir46(), ".letta", "reflection-arena", "hf-upload");
+  HF_REPO_DIR = join84(HF_CACHE_ROOT, "repo");
 });
 
 // src/cli/helpers/reflection-arena.ts
 import { execFile as execFileCb6 } from "node:child_process";
 import { randomInt as randomInt2, randomUUID as randomUUID38 } from "node:crypto";
-import { appendFile as appendFile3, mkdir as mkdir19, readFile as readFile31, writeFile as writeFile21 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir18, readFile as readFile30, writeFile as writeFile20 } from "node:fs/promises";
 import { homedir as homedir47 } from "node:os";
-import { join as join86 } from "node:path";
+import { join as join85 } from "node:path";
 import { promisify as promisify17 } from "node:util";
 function sampleReflectionArenaComparisonModel(excludedModels = []) {
   const excluded = new Set(excludedModels);
@@ -459952,24 +459568,24 @@ function candidateIsConfirmedNoOp(candidate) {
   return candidate.result?.success === true && candidate.result.memoryNoChanges === true && candidate.result.memoryHead === candidate.worktree.baseHead;
 }
 function getReflectionArenaRoot() {
-  return join86(homedir47(), ".letta", "reflection-arena");
+  return join85(homedir47(), ".letta", "reflection-arena");
 }
 function getReflectionArenaRunsDir() {
-  return join86(getReflectionArenaRoot(), "runs");
+  return join85(getReflectionArenaRoot(), "runs");
 }
 function getReflectionArenaChoiceLogPath() {
-  return join86(getReflectionArenaRoot(), "choices.jsonl");
+  return join85(getReflectionArenaRoot(), "choices.jsonl");
 }
 function getReflectionArenaRunPath(runId) {
-  return join86(getReflectionArenaRunsDir(), `${runId}.json`);
+  return join85(getReflectionArenaRunsDir(), `${runId}.json`);
 }
 async function saveReflectionArenaRun(run) {
-  await mkdir19(getReflectionArenaRunsDir(), { recursive: true });
-  await writeFile21(getReflectionArenaRunPath(run.runId), `${JSON.stringify(run, null, 2)}
+  await mkdir18(getReflectionArenaRunsDir(), { recursive: true });
+  await writeFile20(getReflectionArenaRunPath(run.runId), `${JSON.stringify(run, null, 2)}
 `, "utf-8");
 }
 async function loadReflectionArenaRun(runId) {
-  const raw2 = await readFile31(getReflectionArenaRunPath(runId), "utf-8");
+  const raw2 = await readFile30(getReflectionArenaRunPath(runId), "utf-8");
   return JSON.parse(raw2);
 }
 async function updateReflectionArenaRun(runId, update3) {
@@ -460135,7 +459751,7 @@ function formatReflectionArenaChoiceResult(params) {
 `);
 }
 async function appendChoiceRecord(run) {
-  await mkdir19(getReflectionArenaRoot(), { recursive: true });
+  await mkdir18(getReflectionArenaRoot(), { recursive: true });
   await appendFile3(getReflectionArenaChoiceLogPath(), `${JSON.stringify({
     run_id: run.runId,
     agent_id: run.agentId,
@@ -460161,7 +459777,7 @@ async function appendChoiceRecord(run) {
 }
 async function readTranscriptPayloadForTelemetry(payloadPath) {
   try {
-    const transcript = await readFile31(payloadPath, "utf-8");
+    const transcript = await readFile30(payloadPath, "utf-8");
     return {
       transcriptPayload: transcript.slice(0, REFLECTION_ARENA_TELEMETRY_TRANSCRIPT_MAX_CHARS),
       transcriptPayloadChars: transcript.length,
@@ -460852,8 +460468,8 @@ async function pushToMemoryRepositoryWithTimeout(agentId) {
   try {
     return await Promise.race([
       pushToMemoryRepository(agentId),
-      new Promise((resolve42) => {
-        timeout = setTimeout(() => resolve42("timeout"), INITIAL_PUSH_TIMEOUT_MS);
+      new Promise((resolve40) => {
+        timeout = setTimeout(() => resolve40("timeout"), INITIAL_PUSH_TIMEOUT_MS);
       })
     ]);
   } finally {
@@ -461117,13 +460733,13 @@ __export(exports_terminal_keybinding_installer, {
 });
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync68,
+  existsSync as existsSync67,
   mkdirSync as mkdirSync45,
-  readFileSync as readFileSync43,
+  readFileSync as readFileSync42,
   writeFileSync as writeFileSync35
 } from "node:fs";
 import { homedir as homedir48, platform as platform10 } from "node:os";
-import { dirname as dirname36, join as join87 } from "node:path";
+import { dirname as dirname35, join as join86 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -461155,16 +460771,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os9 = platform10();
   if (os9 === "darwin") {
-    return join87(homedir48(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join86(homedir48(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os9 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join87(appData, appName, "User", "keybindings.json");
+    return join86(appData, appName, "User", "keybindings.json");
   }
   if (os9 === "linux") {
-    return join87(homedir48(), ".config", appName, "User", "keybindings.json");
+    return join86(homedir48(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -461186,10 +460802,10 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync68(keybindingsPath))
+  if (!existsSync67(keybindingsPath))
     return false;
   try {
-    const content = readFileSync43(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync42(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings)
       return false;
@@ -461199,7 +460815,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync68(keybindingsPath))
+  if (!existsSync67(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -461214,15 +460830,15 @@ function installKeybinding(keybindingsPath) {
     if (keybindingExists(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname36(keybindingsPath);
-    if (!existsSync68(parentDir)) {
+    const parentDir = dirname35(keybindingsPath);
+    if (!existsSync67(parentDir)) {
       mkdirSync45(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync68(keybindingsPath)) {
+    if (existsSync67(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
-      const content = readFileSync43(keybindingsPath, { encoding: "utf-8" });
+      const content = readFileSync42(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
       if (parsed === null) {
         return {
@@ -461250,10 +460866,10 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync68(keybindingsPath)) {
+    if (!existsSync67(keybindingsPath)) {
       return { success: true };
     }
-    const content = readFileSync43(keybindingsPath, { encoding: "utf-8" });
+    const content = readFileSync42(keybindingsPath, { encoding: "utf-8" });
     const keybindings = parseKeybindings(content);
     if (!keybindings) {
       return {
@@ -461317,14 +460933,14 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join87(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync68(xdgPath))
+    const xdgPath = join86(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync67(xdgPath))
       return xdgPath;
   }
-  const configPath = join87(homedir48(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync68(configPath))
+  const configPath = join86(homedir48(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync67(configPath))
     return configPath;
-  return join87(homedir48(), ".wezterm.lua");
+  return join86(homedir48(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine(line, blockCommentEnd) {
   let code2 = "";
@@ -461427,10 +461043,10 @@ ${WEZTERM_DELETE_FIX}
 `;
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync68(configPath))
+  if (!existsSync67(configPath))
     return false;
   try {
-    const content = readFileSync43(configPath, { encoding: "utf-8" });
+    const content = readFileSync42(configPath, { encoding: "utf-8" });
     return content.includes("Letta Code: Fix Delete key") || content.includes("key = 'Delete'") && content.includes("SendString") && content.includes("\\x1b[3~");
   } catch {
     return false;
@@ -461444,14 +461060,14 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync68(configPath)) {
+    if (existsSync67(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync6(configPath, backupPath);
-      content = readFileSync43(configPath, { encoding: "utf-8" });
+      content = readFileSync42(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix(content);
-    const parentDir = dirname36(configPath);
-    if (!existsSync68(parentDir)) {
+    const parentDir = dirname35(configPath);
+    if (!existsSync67(parentDir)) {
       mkdirSync45(parentDir, { recursive: true });
     }
     writeFileSync35(configPath, content, { encoding: "utf-8" });
@@ -461503,9 +461119,9 @@ __export(exports_settings2, {
   getSetting: () => getSetting
 });
 import { homedir as homedir49 } from "node:os";
-import { join as join88 } from "node:path";
+import { join as join87 } from "node:path";
 function getSettingsPath() {
-  return join88(homedir49(), ".letta", "settings.json");
+  return join87(homedir49(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -461542,7 +461158,7 @@ async function getSetting(key2) {
   return settings3[key2];
 }
 function getProjectSettingsPath() {
-  return join88(process.cwd(), ".letta", "settings.local.json");
+  return join87(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -461560,7 +461176,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings3) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join88(process.cwd(), ".letta");
+  const dirPath = join87(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -461860,14 +461476,6 @@ var init_registry2 = __esm(() => {
         return "Updating description...";
       }
     },
-    "/export": {
-      desc: "Export AgentFile (.af)",
-      order: 26,
-      noArgs: true,
-      handler: () => {
-        return "Exporting agent file...";
-      }
-    },
     "/toolset": {
       desc: "Switch toolset (replaces /link and /unlink)",
       order: 27,
@@ -462185,14 +461793,6 @@ Location: ${keybindingsPath}`;
       handler: () => {
         return "Opening agent browser...";
       }
-    },
-    "/download": {
-      desc: "Export AgentFile (.af)",
-      hidden: true,
-      noArgs: true,
-      handler: () => {
-        return "Exporting agent file...";
-      }
     }
   };
 });
@@ -462608,10 +462208,10 @@ var init_InlineBashApproval = __esm(async () => {
 });
 
 // src/cli/components/DiffRenderer.tsx
-import { relative as relative15 } from "node:path";
+import { relative as relative14 } from "node:path";
 function formatDisplayPath4(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative15(cwd2, filePath);
+  const relativePath = relative14(cwd2, filePath);
   if (relativePath.startsWith("..")) {
     return filePath;
   }
@@ -462970,10 +462570,10 @@ var init_DiffRenderer = __esm(async () => {
 });
 
 // src/cli/components/AdvancedDiffRenderer.tsx
-import { relative as relative16 } from "node:path";
+import { relative as relative15 } from "node:path";
 function formatRelativePath(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative16(cwd2, filePath);
+  const relativePath = relative15(cwd2, filePath);
   return relativePath.startsWith("..") ? relativePath : `./${relativePath}`;
 }
 function padLeft(n, width) {
@@ -463255,7 +462855,7 @@ function AdvancedDiffRenderer(props) {
   }
   const { hunks } = result2;
   const filePath = props.filePath;
-  const relative17 = formatRelativePath(filePath);
+  const relative16 = formatRelativePath(filePath);
   const lang41 = languageFromPath(filePath);
   const shouldHighlight = lang41 && !exceedsAdvancedDiffHighlightLimits(hunks);
   const hunkSyntaxLines = [];
@@ -463278,7 +462878,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 ${relative17}` : `Updated ${relative17}`;
+  const header = props.kind === "write" ? `Wrote changes to ${relative16}` : `Updated ${relative16}`;
   if (rows.length === 0) {
     const noChangesGutter = 4;
     return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
@@ -463329,7 +462929,7 @@ function AdvancedDiffRenderer(props) {
                   "No changes to ",
                   /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text2, {
                     bold: true,
-                    children: relative17
+                    children: relative16
                   }, undefined, false, undefined, this),
                   " (file content identical)"
                 ]
@@ -463435,9 +463035,9 @@ function getHeaderText(fileEdit) {
       } else if (operations.length === 1) {
         const op = operations[0];
         if (op) {
-          const { relative: relative18 } = __require("node:path");
+          const { relative: relative17 } = __require("node:path");
           const cwd3 = process.cwd();
-          const relPath2 = relative18(cwd3, op.path);
+          const relPath2 = relative17(cwd3, op.path);
           const displayPath2 = relPath2.startsWith("..") ? op.path : relPath2;
           if (op.kind === "add") {
             return `Write to ${displayPath2}?`;
@@ -463451,14 +463051,14 @@ function getHeaderText(fileEdit) {
     }
     return "Apply patch?";
   }
-  const { relative: relative17 } = __require("node:path");
+  const { relative: relative16 } = __require("node:path");
   const cwd2 = process.cwd();
-  const relPath = relative17(cwd2, fileEdit.filePath);
+  const relPath = relative16(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: existsSync69 } = __require("node:fs");
+    const { existsSync: existsSync68 } = __require("node:fs");
     try {
-      if (existsSync69(fileEdit.filePath)) {
+      if (existsSync68(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -463636,9 +463236,9 @@ var init_InlineFileEditApproval = __esm(async () => {
           children: fileEdit.patchInput ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
             flexDirection: "column",
             children: parsePatchOperations2(fileEdit.patchInput).map((op, idx) => {
-              const { relative: relative17 } = __require("node:path");
+              const { relative: relative16 } = __require("node:path");
               const cwd2 = process.cwd();
-              const relPath = relative17(cwd2, op.path);
+              const relPath = relative16(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;
@@ -467175,11 +466775,11 @@ var init_HelpDialog = __esm(async () => {
 
 // src/hooks/writer.ts
 import { homedir as homedir50 } from "node:os";
-import { resolve as resolve42 } from "node:path";
+import { resolve as resolve40 } from "node:path";
 function isProjectSettingsPathCollidingWithGlobal2(workingDirectory) {
   const home = process.env.HOME || homedir50();
-  const globalSettingsPath = resolve42(home, ".letta", "settings.json");
-  const projectSettingsPath = resolve42(workingDirectory, ".letta", "settings.json");
+  const globalSettingsPath = resolve40(home, ".letta", "settings.json");
+  const projectSettingsPath = resolve40(workingDirectory, ".letta", "settings.json");
   return globalSettingsPath === projectSettingsPath;
 }
 function loadHooksFromLocation(location, workingDirectory = process.cwd()) {
@@ -472969,15 +472569,15 @@ var init_InputRich = __esm(async () => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
 import {
-  existsSync as existsSync69,
+  existsSync as existsSync68,
   mkdirSync as mkdirSync46,
   mkdtempSync as mkdtempSync6,
-  readFileSync as readFileSync44,
+  readFileSync as readFileSync43,
   rmSync as rmSync18,
   writeFileSync as writeFileSync36
 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
-import { dirname as dirname37, join as join89 } from "node:path";
+import { dirname as dirname36, join as join88 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync7(command, args, {
@@ -473198,8 +472798,8 @@ async function createLettaAgent(apiKey, name) {
   return createMinimalAgent(apiKey, name);
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync6(join89(tmpdir12(), "letta-install-github-app-"));
-  const repoDir = join89(tempDir, "repo");
+  const tempDir = mkdtempSync6(join88(tmpdir12(), "letta-install-github-app-"));
+  const repoDir = join88(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -473210,14 +472810,14 @@ function runGit7(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join89(repoDir, workflowPath);
-  if (!existsSync69(dirname37(absolutePath))) {
-    mkdirSync46(dirname37(absolutePath), { recursive: true });
+  const absolutePath = join88(repoDir, workflowPath);
+  if (!existsSync68(dirname36(absolutePath))) {
+    mkdirSync46(dirname36(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync69(absolutePath)) {
-    const previous = readFileSync44(absolutePath, "utf8");
+  if (existsSync68(absolutePath)) {
+    const previous = readFileSync43(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
@@ -477106,9 +476706,9 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb7 } from "node:child_process";
-import { chmodSync as chmodSync7, existsSync as existsSync70, mkdirSync as mkdirSync47, writeFileSync as writeFileSync37 } from "node:fs";
+import { chmodSync as chmodSync7, existsSync as existsSync69, mkdirSync as mkdirSync47, writeFileSync as writeFileSync37 } from "node:fs";
 import { homedir as homedir51 } from "node:os";
-import { join as join90 } from "node:path";
+import { join as join89 } from "node:path";
 import { promisify as promisify18 } from "node:util";
 function messagesFromOverview(overview) {
   return overview.messages?.map((message) => ({
@@ -477146,7 +476746,7 @@ async function runGitSafe(cwd2, args) {
     return "";
   }
 }
-function parseFrontmatter3(raw2) {
+function parseFrontmatter2(raw2) {
   if (!raw2.startsWith("---")) {
     return { frontmatter: {}, body: raw2 };
   }
@@ -477175,7 +476775,7 @@ function collectFiles2(memoryRoot) {
   const fileNodes = getFileNodes(treeNodes);
   return fileNodes.filter((n) => n.name.endsWith(".md")).map((n) => {
     const raw2 = readFileContent(n.fullPath);
-    const { frontmatter, body: body3 } = parseFrontmatter3(raw2);
+    const { frontmatter, body: body3 } = parseFrontmatter2(raw2);
     return {
       path: n.relativePath,
       isSystem: n.relativePath.startsWith("system/") || n.relativePath.startsWith("system\\"),
@@ -477417,7 +477017,7 @@ ${m4.body}` : m4.subject;
 async function generateAndOpenMemoryViewer(agentId, options) {
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const repoDir = memoryRoot;
-  if (!existsSync70(join90(repoDir, ".git"))) {
+  if (!existsSync69(join89(repoDir, ".git"))) {
     throw new Error("Memory viewer requires memfs. Run /memfs enable first.");
   }
   const data = await collectMemoryData(agentId, repoDir, memoryRoot, options?.conversationId);
@@ -477427,13 +477027,13 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   data.context = applyContextUsageSnapshot(data.context, options?.contextUsage);
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html5 = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync70(VIEWERS_DIR)) {
+  if (!existsSync69(VIEWERS_DIR)) {
     mkdirSync47(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync7(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join90(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
+  const filePath = join89(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
   writeFileSync37(filePath, html5);
   chmodSync7(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -477459,13 +477059,13 @@ var init_generate_memory_viewer = __esm(() => {
   init_local_memory_context();
   init_memory_viewer_template();
   execFile20 = promisify18(execFileCb7);
-  VIEWERS_DIR = join90(homedir51(), ".letta", "viewers");
+  VIEWERS_DIR = join89(homedir51(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync71 } from "node:fs";
-import { join as join91 } from "node:path";
+import { existsSync as existsSync70 } from "node:fs";
+import { join as join90 } from "node:path";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i4 = 0;i4 < node.depth; i4++) {
@@ -477493,8 +477093,8 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react88.useState(null);
   const statusTimerRef = import_react88.useRef(null);
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync71(memoryRoot);
-  const hasGitRepo = import_react88.useMemo(() => existsSync71(join91(memoryRoot, ".git")), [memoryRoot]);
+  const memoryExists = existsSync70(memoryRoot);
+  const hasGitRepo = import_react88.useMemo(() => existsSync70(join90(memoryRoot, ".git")), [memoryRoot]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
       clearTimeout(statusTimerRef.current);
@@ -479869,19 +479469,19 @@ var init_PersonalitySelector = __esm(async () => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile31 } from "node:fs/promises";
 import { homedir as homedir52 } from "node:os";
-import { join as join92 } from "node:path";
+import { join as join91 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join92(homedir52(), ".aws", "credentials");
-  const configPath = join92(homedir52(), ".aws", "config");
+  const credentialsPath = join91(homedir52(), ".aws", "credentials");
+  const configPath = join91(homedir52(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile32(credentialsPath, "utf-8");
+    const content = await readFile31(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile32(configPath, "utf-8");
+    const content = await readFile31(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -481453,8 +481053,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills2, SKILLS_DIR: SKILLS_DIR2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join93 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join93(process.cwd(), SKILLS_DIR2);
+        const { join: join92 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join92(process.cwd(), SKILLS_DIR2);
         const result2 = await discoverSkills2(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -484852,15 +484452,15 @@ function ToolsetSelector({
   const solidLine = SOLID_LINE19.repeat(Math.max(terminalWidth, 10));
   const [showAll, setShowAll] = import_react103.useState(false);
   const [selectedIndex, setSelectedIndex] = import_react103.useState(0);
-  const featuredToolsets = import_react103.useMemo(() => toolsets.filter((toolset) => toolset.isFeatured), []);
+  const featuredToolsets = import_react103.useMemo(() => TOOLSET_OPTIONS.filter((toolset) => toolset.is_featured), []);
   const visibleToolsets = import_react103.useMemo(() => {
     if (showAll)
-      return toolsets;
+      return TOOLSET_OPTIONS;
     if (featuredToolsets.length > 0)
       return featuredToolsets;
-    return toolsets;
+    return TOOLSET_OPTIONS;
   }, [featuredToolsets, showAll]);
-  const canToggleShowAll = featuredToolsets.length < toolsets.length;
+  const canToggleShowAll = featuredToolsets.length < TOOLSET_OPTIONS.length;
   import_react103.useEffect(() => {
     if (selectedIndex >= visibleToolsets.length) {
       setSelectedIndex(Math.max(0, visibleToolsets.length - 1));
@@ -484944,10 +484544,11 @@ function ToolsetSelector({
     ]
   }, undefined, true, undefined, this);
 }
-var import_react103, jsx_dev_runtime86, SOLID_LINE19 = "─", toolsets;
+var import_react103, jsx_dev_runtime86, SOLID_LINE19 = "─";
 var init_ToolsetSelector = __esm(async () => {
   init_use_terminal_width();
   init_toolset_labels();
+  init_toolset_options();
   init_colors();
   await __promiseAll([
     init_build4(),
@@ -484955,48 +484556,6 @@ var init_ToolsetSelector = __esm(async () => {
   ]);
   import_react103 = __toESM(require_react(), 1);
   jsx_dev_runtime86 = __toESM(require_jsx_dev_runtime(), 1);
-  toolsets = [
-    {
-      id: "auto",
-      label: "Auto",
-      description: "Auto-select based on the model",
-      isFeatured: true
-    },
-    {
-      id: "none",
-      label: "None",
-      description: "Remove all Letta Code tools from your agent",
-      isFeatured: true
-    },
-    {
-      id: "default",
-      label: "Claude toolset",
-      description: "Optimized for Anthropic models",
-      isFeatured: true
-    },
-    {
-      id: "codex",
-      label: "Codex toolset",
-      description: "Optimized for GPT/Codex models",
-      isFeatured: true
-    },
-    {
-      id: "gemini",
-      label: "Gemini toolset",
-      description: "Optimized for Google Gemini models",
-      isFeatured: true
-    },
-    {
-      id: "codex_snake",
-      label: "Codex toolset (snake_case)",
-      description: "Optimized for GPT/Codex models (snake_case)"
-    },
-    {
-      id: "gemini_snake",
-      label: "Gemini toolset (snake_case)",
-      description: "Optimized for Google Gemini models (snake_case)"
-    }
-  ];
 });
 
 // src/cli/components/UserMessageRich.tsx
@@ -485616,9 +485175,9 @@ function getFileEditHeader(toolName2, toolArgs) {
         } else if (operations.length === 1) {
           const op = operations[0];
           if (op) {
-            const { relative: relative18 } = __require("node:path");
+            const { relative: relative17 } = __require("node:path");
             const cwd3 = process.cwd();
-            const relPath2 = relative18(cwd3, op.path);
+            const relPath2 = relative17(cwd3, op.path);
             const displayPath3 = relPath2.startsWith("..") ? op.path : relPath2;
             if (op.kind === "add")
               return `Write to ${displayPath3}?`;
@@ -485632,14 +485191,14 @@ function getFileEditHeader(toolName2, toolArgs) {
       return "Apply patch?";
     }
     const filePath = args.file_path || "";
-    const { relative: relative17 } = __require("node:path");
+    const { relative: relative16 } = __require("node:path");
     const cwd2 = process.cwd();
-    const relPath = relative17(cwd2, filePath);
+    const relPath = relative16(cwd2, filePath);
     const displayPath2 = relPath.startsWith("..") ? filePath : relPath;
     if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
-      const { existsSync: existsSync72 } = __require("node:fs");
+      const { existsSync: existsSync71 } = __require("node:fs");
       try {
-        if (existsSync72(filePath)) {
+        if (existsSync71(filePath)) {
           return `Overwrite ${displayPath2}?`;
         }
       } catch {}
@@ -485722,9 +485281,9 @@ var init_ApprovalPreview = __esm(async () => {
               /* @__PURE__ */ jsx_dev_runtime92.jsxDEV(Box_default, {
                 flexDirection: "column",
                 children: operations.map((op, idx) => {
-                  const { relative: relative17 } = __require("node:path");
+                  const { relative: relative16 } = __require("node:path");
                   const cwd2 = process.cwd();
-                  const relPath = relative17(cwd2, op.path);
+                  const relPath = relative16(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;
@@ -500875,9 +500434,9 @@ __export(exports_generate_diff_viewer, {
   generateAndOpenDiffViewer: () => generateAndOpenDiffViewer
 });
 import { execFile as execFileCb8 } from "node:child_process";
-import { chmodSync as chmodSync8, existsSync as existsSync72, mkdirSync as mkdirSync48, writeFileSync as writeFileSync38 } from "node:fs";
+import { chmodSync as chmodSync8, existsSync as existsSync71, mkdirSync as mkdirSync48, writeFileSync as writeFileSync38 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
-import { isAbsolute as isAbsolute32, join as join93, resolve as resolve43 } from "node:path";
+import { isAbsolute as isAbsolute31, join as join92, resolve as resolve41 } from "node:path";
 import { promisify as promisify19 } from "node:util";
 async function runGit8(cwd2, args) {
   try {
@@ -501075,7 +500634,7 @@ function escapeHtml3(value) {
 function resolveTargetPath(targetPath) {
   if (!targetPath?.trim())
     return process.cwd();
-  return isAbsolute32(targetPath) ? targetPath : resolve43(process.cwd(), targetPath);
+  return isAbsolute31(targetPath) ? targetPath : resolve41(process.cwd(), targetPath);
 }
 function shouldSkipOpen() {
   return Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -501096,13 +500655,13 @@ async function generateAndOpenDiffViewer(targetPath) {
   };
   const jsonPayload = JSON.stringify(payload).replace(/</g, "\\u003c");
   const html5 = diff_viewer_template_default.replace("<!--LETTA_DIFF_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync72(VIEWERS_DIR2)) {
+  if (!existsSync71(VIEWERS_DIR2)) {
     mkdirSync48(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync8(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join93(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
+  const filePath = join92(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
   writeFileSync38(filePath, html5);
   chmodSync8(filePath, 384);
   const skipOpen = shouldSkipOpen();
@@ -501173,7 +500732,7 @@ var init_generate_diff_viewer = __esm(() => {
   init_ssr();
   init_diff_viewer_template();
   execFile21 = promisify19(execFileCb8);
-  VIEWERS_DIR2 = join93(homedir53(), ".letta", "viewers");
+  VIEWERS_DIR2 = join92(homedir53(), ".letta", "viewers");
   GIT_MAX_BUFFER = 50 * 1024 * 1024;
 });
 
@@ -503136,16 +502695,16 @@ __export(exports_shell_aliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync73, readFileSync as readFileSync45 } from "node:fs";
+import { existsSync as existsSync72, readFileSync as readFileSync44 } from "node:fs";
 import { homedir as homedir54 } from "node:os";
-import { join as join94 } from "node:path";
+import { join as join93 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync73(filePath)) {
+  if (!existsSync72(filePath)) {
     return aliases;
   }
   try {
-    const content = readFileSync45(filePath, "utf-8");
+    const content = readFileSync44(filePath, "utf-8");
     const lines = content.split(`
 `);
     let inFunction = false;
@@ -503210,7 +502769,7 @@ function loadAliases(forceReload = false) {
   const home = homedir54();
   const allAliases = new Map;
   for (const file of ALIAS_FILES) {
-    const filePath = join94(home, file);
+    const filePath = join93(home, file);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -504363,7 +503922,7 @@ var init_system_reminders = __esm(() => {
 // src/cli/app/use-conversation-loop.ts
 import { randomUUID as randomUUID41 } from "node:crypto";
 function sleep11(ms) {
-  return new Promise((resolve44) => setTimeout(resolve44, ms));
+  return new Promise((resolve42) => setTimeout(resolve42, ms));
 }
 function makeExecutionPhaseHook(setExecutionPhase) {
   return ({ chunk: chunk2 }) => {
@@ -504819,7 +504378,7 @@ function useConversationLoop(ctx) {
                   cancelled = true;
                   break;
                 }
-                await new Promise((resolve44) => setTimeout(resolve44, 100));
+                await new Promise((resolve42) => setTimeout(resolve42, 100));
               }
               buffersRef.current.byId.delete(statusId);
               buffersRef.current.order = buffersRef.current.order.filter((id2) => id2 !== statusId);
@@ -504863,7 +504422,7 @@ function useConversationLoop(ctx) {
                 cancelled = true;
                 break;
               }
-              await new Promise((resolve44) => setTimeout(resolve44, 100));
+              await new Promise((resolve42) => setTimeout(resolve42, 100));
             }
             if (retryStatusId) {
               buffersRef.current.byId.delete(retryStatusId);
@@ -505681,7 +505240,7 @@ ${feedback}
           });
           buffersRef.current.order.push(statusId);
           refreshDerived();
-          await new Promise((resolve44) => setTimeout(resolve44, delayMs));
+          await new Promise((resolve42) => setTimeout(resolve42, delayMs));
           buffersRef.current.byId.delete(statusId);
           buffersRef.current.order = buffersRef.current.order.filter((id2) => id2 !== statusId);
           refreshDerived();
@@ -505721,7 +505280,7 @@ ${feedback}
               cancelled = true;
               break;
             }
-            await new Promise((resolve44) => setTimeout(resolve44, 100));
+            await new Promise((resolve42) => setTimeout(resolve42, 100));
           }
           if (retryStatusId) {
             buffersRef.current.byId.delete(retryStatusId);
@@ -507467,7 +507026,7 @@ The deployment target for this project is CITATION-DOGFOOD-OK.
 
 // src/mods/learning-harness.ts
 import { spawn as spawn14 } from "node:child_process";
-import { access as access4, copyFile as copyFile2, mkdir as mkdir20, readFile as readFile33, writeFile as writeFile22 } from "node:fs/promises";
+import { access as access3, copyFile as copyFile2, mkdir as mkdir19, readFile as readFile32, writeFile as writeFile21 } from "node:fs/promises";
 import path51 from "node:path";
 function slugify2(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -507491,9 +507050,9 @@ function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
 function markerChecks(markers, haystack) {
-  return (markers ?? []).map((marker) => ({
-    marker,
-    present: haystack.includes(marker)
+  return (markers ?? []).map((marker2) => ({
+    marker: marker2,
+    present: haystack.includes(marker2)
   }));
 }
 function asStringArray(value) {
@@ -507705,7 +507264,7 @@ function safeJoin(root2, relativePath) {
 }
 async function fileExists(filePath) {
   try {
-    await access4(filePath);
+    await access3(filePath);
     return true;
   } catch {
     return false;
@@ -507715,22 +507274,22 @@ async function existingPath(filePath) {
   return await fileExists(filePath) ? filePath : undefined;
 }
 async function writeJsonArtifact(filePath, value) {
-  await writeFile22(filePath, `${JSON.stringify(value, null, 2)}
+  await writeFile21(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function writeCommandArtifacts(prefix, command, args, result2) {
-  await writeFile22(`${prefix}.command.txt`, `${renderCommand(command, args)}
+  await writeFile21(`${prefix}.command.txt`, `${renderCommand(command, args)}
 `, "utf8");
-  await writeFile22(`${prefix}.stdout`, result2.stdout, "utf8");
-  await writeFile22(`${prefix}.stderr`, result2.stderr, "utf8");
+  await writeFile21(`${prefix}.stdout`, result2.stdout, "utf8");
+  await writeFile21(`${prefix}.stderr`, result2.stderr, "utf8");
   await writeJsonArtifact(`${prefix}.result.json`, result2);
 }
 async function prepareMemoryFiles(memoryDir, memoryFiles) {
-  await mkdir20(memoryDir, { recursive: true });
+  await mkdir19(memoryDir, { recursive: true });
   for (const [relativePath, content] of Object.entries(memoryFiles ?? {})) {
     const filePath = safeJoin(memoryDir, relativePath);
-    await mkdir20(path51.dirname(filePath), { recursive: true });
-    await writeFile22(filePath, content, "utf8");
+    await mkdir19(path51.dirname(filePath), { recursive: true });
+    await writeFile21(filePath, content, "utf8");
   }
 }
 function renderEvaluationPrompt(prompt, memoryDir) {
@@ -508393,7 +507952,7 @@ function renderProposerGuide(params) {
 `;
 }
 async function writeHistoryArtifacts(params) {
-  await writeFile22(params.historyPath, renderHistoryIndex({
+  await writeFile21(params.historyPath, renderHistoryIndex({
     attempts: params.attempts,
     historyManifestPath: params.historyManifestPath,
     proposerGuidePath: params.proposerGuidePath,
@@ -508401,11 +507960,11 @@ async function writeHistoryArtifacts(params) {
     spec: params.spec
   }), "utf8");
   await writeJsonArtifact(params.historyManifestPath, buildHistoryManifest(params));
-  await writeFile22(params.proposerGuidePath, renderProposerGuide(params), "utf8");
+  await writeFile21(params.proposerGuidePath, renderProposerGuide(params), "utf8");
 }
 async function defaultCommandRunner(command, args, options) {
   const startedAt = Date.now();
-  return new Promise((resolve44) => {
+  return new Promise((resolve42) => {
     const child = spawn14(command, args, {
       cwd: options.cwd,
       env: options.env,
@@ -508432,7 +507991,7 @@ async function defaultCommandRunner(command, args, options) {
     });
     child.on("close", (exitCode) => {
       clearTimeout(timeout);
-      resolve44({
+      resolve42({
         args,
         command,
         cwd: options.cwd,
@@ -508492,7 +508051,7 @@ function createScenarioSuiteEvaluator(params) {
               outputFormat
             })
           ];
-          await writeFile22(hasConfiguredScenarios ? path51.join(scenarioDir, "prompt.md") : path51.join(context3.runDir, "eval-prompt.md"), evalPrompt, "utf8");
+          await writeFile21(hasConfiguredScenarios ? path51.join(scenarioDir, "prompt.md") : path51.join(context3.runDir, "eval-prompt.md"), evalPrompt, "utf8");
           const scenarioEvalResult = await context3.runner(context3.cliCommand, evalArgs, {
             cwd: context3.repoRoot,
             env: {
@@ -508654,7 +508213,7 @@ async function runModLearningCandidate(params) {
     });
   };
   emitProgress("preparing", params.candidateCount > 1 ? `Preparing optimization iteration ${params.candidateIndex}/${params.candidateCount}` : "Preparing mod learning run");
-  await mkdir20(candidateDir, { recursive: true });
+  await mkdir19(candidateDir, { recursive: true });
   await writeJsonArtifact(path51.join(runDir, "env.snapshot.json"), options.spec);
   let generationResult = null;
   if (options.candidateSourcePath) {
@@ -508684,7 +508243,7 @@ async function runModLearningCandidate(params) {
         outputFormat: "json"
       })
     ];
-    await writeFile22(path51.join(runDir, "generation-prompt.md"), generationPrompt, "utf8");
+    await writeFile21(path51.join(runDir, "generation-prompt.md"), generationPrompt, "utf8");
     generationResult = await params.runner(params.cliCommand, generationArgs, {
       cwd: repoRoot,
       env: {
@@ -508741,7 +508300,7 @@ async function runModLearningCandidate(params) {
   if (passed && options.promoteToPath) {
     emitProgress("promoting", "Promoting passing candidate mod");
     promotedToPath = path51.resolve(repoRoot, options.promoteToPath);
-    await mkdir20(path51.dirname(promotedToPath), { recursive: true });
+    await mkdir19(path51.dirname(promotedToPath), { recursive: true });
     await copyFile2(candidatePath, promotedToPath);
   }
   const reportPath = path51.join(runDir, "report.md");
@@ -508763,7 +508322,7 @@ async function runModLearningCandidate(params) {
     spec: options.spec
   };
   await writeJsonArtifact(path51.join(runDir, "report.json"), report);
-  await writeFile22(reportPath, renderMarkdownReport(report), "utf8");
+  await writeFile21(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)],
@@ -508792,7 +508351,7 @@ async function runModLearning(options) {
   const cliCommand = normalizedOptions.cliCommand ?? "bun";
   const cliArgsPrefix = normalizedOptions.cliArgsPrefix ?? ["run", "dev"];
   const baseEnv = normalizedOptions.env ?? process.env;
-  await mkdir20(runDir, { recursive: true });
+  await mkdir19(runDir, { recursive: true });
   await writeJsonArtifact(path51.join(runDir, "env.snapshot.json"), normalizedOptions.spec);
   if (candidateCount === 1) {
     const report2 = await runModLearningCandidate({
@@ -508903,7 +508462,7 @@ async function runModLearning(options) {
       selectedCandidateIndex
     });
     promotedToPath = path51.resolve(repoRoot, normalizedOptions.promoteToPath);
-    await mkdir20(path51.dirname(promotedToPath), { recursive: true });
+    await mkdir19(path51.dirname(promotedToPath), { recursive: true });
     await copyFile2(selectedReport.candidatePath, promotedToPath);
   }
   const reportPath = path51.join(runDir, "report.md");
@@ -508941,7 +508500,7 @@ async function runModLearning(options) {
     spec: normalizedOptions.spec
   });
   await writeJsonArtifact(path51.join(runDir, "report.json"), report);
-  await writeFile22(reportPath, renderMarkdownReport(report), "utf8");
+  await writeFile21(reportPath, renderMarkdownReport(report), "utf8");
   normalizedOptions.onProgress?.({
     candidateCount,
     candidateIndex: selectedCandidateIndex,
@@ -508959,7 +508518,7 @@ async function runModLearning(options) {
   return report;
 }
 async function readModLearningEnv(envPath) {
-  return JSON.parse(await readFile33(envPath, "utf8"));
+  return JSON.parse(await readFile32(envPath, "utf8"));
 }
 var init_learning_harness = __esm(async () => {
   await init_mod_engine();
@@ -509669,8 +509228,6 @@ var init_command_routing = __esm(() => {
     "/search",
     "/memory",
     "/feedback",
-    "/export",
-    "/download",
     "/mods",
     "/reasoning-tab",
     "/secret",
@@ -511199,7 +510756,7 @@ __export(exports_worktree_diff_list, {
   listWorktreeDiffOptions: () => listWorktreeDiffOptions
 });
 import { execFile as execFileCb9 } from "node:child_process";
-import { basename as basename31 } from "node:path";
+import { basename as basename30 } from "node:path";
 import { promisify as promisify20 } from "node:util";
 async function runGit9(cwd2, args) {
   try {
@@ -511248,7 +510805,7 @@ function parseWorktreeList(output, currentPath) {
       if (current?.path) {
         worktrees.push({
           path: current.path,
-          name: basename31(current.path),
+          name: basename30(current.path),
           branch: current.branch ?? "detached",
           head: current.head ?? "",
           isCurrent: current.path === currentPath,
@@ -511274,7 +510831,7 @@ function parseWorktreeList(output, currentPath) {
   if (current?.path) {
     worktrees.push({
       path: current.path,
-      name: basename31(current.path),
+      name: basename30(current.path),
       branch: current.branch ?? "detached",
       head: current.head ?? "",
       isCurrent: current.path === currentPath,
@@ -511338,107 +510895,6 @@ var init_worktree_diff_list = __esm(() => {
   GIT_MAX_BUFFER2 = 10 * 1024 * 1024;
 });
 
-// src/agent/export.ts
-var exports_export = {};
-__export(exports_export, {
-  packageSkills: () => packageSkills
-});
-import { readdir as readdir17, readFile as readFile34 } from "node:fs/promises";
-import { relative as relative17, resolve as resolve44 } from "node:path";
-async function packageSkills(agentId, skillsDir) {
-  const skills = [];
-  const skillNames = new Set;
-  const dirsToCheck = skillsDir ? [skillsDir] : [
-    agentId && getAgentSkillsDir(agentId),
-    resolve44(process.cwd(), ".skills"),
-    resolve44(process.env.HOME || "~", ".letta", "skills")
-  ].filter((dir) => Boolean(dir));
-  for (const baseDir of dirsToCheck) {
-    try {
-      const entries = await readdir17(baseDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        if (skillNames.has(entry.name))
-          continue;
-        const skillDir = resolve44(baseDir, entry.name);
-        const skillMdPath = resolve44(skillDir, "SKILL.md");
-        try {
-          await readFile34(skillMdPath, "utf-8");
-        } catch {
-          console.warn(`Skipping invalid skill ${entry.name}: missing SKILL.md`);
-          continue;
-        }
-        const sourceUrl = skillsDir ? null : await findSkillSourceUrl(entry.name);
-        const skill2 = { name: entry.name };
-        if (sourceUrl) {
-          skill2.source_url = sourceUrl;
-        } else {
-          skill2.files = await readSkillFiles(skillDir);
-        }
-        skills.push(skill2);
-        skillNames.add(entry.name);
-      }
-    } catch (error5) {
-      if (error5.code !== "ENOENT") {
-        throw error5;
-      }
-    }
-  }
-  return skills;
-}
-async function readSkillFiles(skillDir) {
-  const files = {};
-  async function walk3(dir) {
-    const entries = await readdir17(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = resolve44(dir, entry.name);
-      if (entry.isDirectory()) {
-        await walk3(fullPath);
-      } else {
-        const content = await readFile34(fullPath, "utf-8");
-        const relativePath = relative17(skillDir, fullPath).replace(/\\/g, "/");
-        files[relativePath] = content;
-      }
-    }
-  }
-  await walk3(skillDir);
-  return files;
-}
-async function findSkillSourceUrl(skillName) {
-  for (const repoPath of SKILL_REPOS) {
-    if (!dirCache.has(repoPath)) {
-      dirCache.set(repoPath, await fetchGitHubDirs(repoPath));
-    }
-    if (dirCache.get(repoPath)?.has(skillName)) {
-      return `${repoPath}/${skillName}`;
-    }
-  }
-  return null;
-}
-async function fetchGitHubDirs(path53) {
-  const [owner, repo, branch, ...pathParts] = path53.split("/");
-  if (!owner || !repo || !branch)
-    return new Set;
-  try {
-    const { fetchGitHubContents: fetchGitHubContents2, parseDirNames: parseDirNames2 } = await Promise.resolve().then(() => exports_github_utils);
-    const entries = await fetchGitHubContents2(owner, repo, branch, pathParts.join("/"));
-    return parseDirNames2(entries);
-  } catch {
-    return new Set;
-  }
-}
-var SKILL_REPOS, dirCache;
-var init_export2 = __esm(() => {
-  init_skills5();
-  SKILL_REPOS = [
-    "letta-ai/skills/main/tools",
-    "letta-ai/skills/main/letta",
-    "anthropics/skills/main/skills"
-  ];
-  dirCache = new Map;
-});
-
 // src/cli/helpers/conversation-switch-alert.ts
 var exports_conversation_switch_alert = {};
 __export(exports_conversation_switch_alert, {
@@ -511532,9 +510988,9 @@ var init_conversation_switch_alert = __esm(() => {
 
 // src/cli/app/use-submit-handler.ts
 import { randomUUID as randomUUID43 } from "node:crypto";
-import { existsSync as existsSync74, readFileSync as readFileSync46, renameSync as renameSync8, writeFileSync as writeFileSync39 } from "node:fs";
+import { existsSync as existsSync73, readFileSync as readFileSync45, renameSync as renameSync8 } from "node:fs";
 import { tmpdir as tmpdir13 } from "node:os";
-import { join as join95 } from "node:path";
+import { join as join94 } from "node:path";
 async function findCustomCommandByName(commandName) {
   const { findCustomCommand: findCustomCommand2 } = await Promise.resolve().then(() => (init_custom(), exports_custom));
   return findCustomCommand2(commandName);
@@ -512234,12 +511690,12 @@ ${SYSTEM_REMINDER_CLOSE}`),
           try {
             const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
             const personaCandidates = [
-              join95(memoryRoot, "system", "persona.md"),
-              join95(memoryRoot, "memory", "system", "persona.md")
+              join94(memoryRoot, "system", "persona.md"),
+              join94(memoryRoot, "memory", "system", "persona.md")
             ];
-            const personaPath = personaCandidates.find((candidate) => existsSync74(candidate));
+            const personaPath = personaCandidates.find((candidate) => existsSync73(candidate));
             if (personaPath) {
-              const personaContent = readFileSync46(personaPath, "utf-8");
+              const personaContent = readFileSync45(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
             } else {
               setCurrentPersonalityId(null);
@@ -512991,42 +512447,6 @@ Tip: Use /clear instead to clear the current message buffer.`;
         cmd.finish(output, true);
         return { submitted: true };
       }
-      if (msg.trim() === "/export" || msg.trim() === "/download") {
-        const cmd = commandRunner.start(msg.trim(), "Exporting agent file...");
-        if (!getBackend().capabilities.agentFileImportExport) {
-          cmd.fail("AgentFile export is not supported by the local backend yet.");
-          return { submitted: true };
-        }
-        setCommandRunning(true);
-        try {
-          const client = await getClient();
-          const exportParams = {};
-          if (conversationId !== "default" && conversationId !== agentId) {
-            exportParams.conversation_id = conversationId;
-          }
-          const { packageSkills: packageSkills2 } = await Promise.resolve().then(() => (init_export2(), exports_export));
-          const skills = await packageSkills2(agentId);
-          const baseContent = await client.agents.exportFile(agentId, exportParams);
-          const fileContent = typeof baseContent === "string" ? JSON.parse(baseContent) : baseContent;
-          if (skills.length > 0) {
-            fileContent.skills = skills;
-          }
-          const fileName = exportParams.conversation_id ? `${exportParams.conversation_id}.af` : `${agentId}.af`;
-          writeFileSync39(fileName, JSON.stringify(fileContent, null, 2));
-          let summary = `AgentFile exported to ${fileName}`;
-          if (skills.length > 0) {
-            summary += `
-\uD83D\uDCE6 Included ${skills.length} skill(s): ${skills.map((s3) => s3.name).join(", ")}`;
-          }
-          cmd.finish(summary, true);
-        } catch (error5) {
-          const errorDetails = formatErrorDetails2(error5, agentId);
-          cmd.fail(`Failed: ${errorDetails}`);
-        } finally {
-          setCommandRunning(false);
-        }
-        return { submitted: true };
-      }
       if (trimmed.startsWith("/memfs")) {
         const [, subcommand] = trimmed.split(/\s+/);
         const cmd = commandRunner.start(msg.trim(), "Processing memfs command...");
@@ -513119,11 +512539,11 @@ Path: ${memoryDir}`, true);
           setCommandRunning(true);
           try {
             const memoryDir = getScopedMemoryFilesystemRoot(agentId);
-            if (!existsSync74(memoryDir)) {
+            if (!existsSync73(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join95(tmpdir13(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join94(tmpdir13(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync8(memoryDir, backupDir);
             if (getBackend().capabilities.localMemfs) {
               const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
@@ -514079,7 +513499,7 @@ var init_use_submit_handler = __esm(async () => {
 });
 
 // src/cli/app/AppCoordinator.tsx
-import { join as join96 } from "node:path";
+import { join as join95 } from "node:path";
 function buildStartupCommandHints(options) {
   const {
     isResumingConversation,
@@ -515366,7 +514786,7 @@ function App2({
       agentId: a2.agentId ?? null
     }))
   });
-  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join96(modContext.memfs.memoryDir, "mods") : null;
+  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join95(modContext.memfs.memoryDir, "mods") : null;
   const modAdapter = useLocalModAdapter(modContext, {
     agentModsDirectory,
     disabled: modsDisabled,
@@ -516137,9 +515557,9 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     (async () => {
       try {
         const { watch: watch4 } = await import("node:fs");
-        const { existsSync: existsSync75 } = await import("node:fs");
+        const { existsSync: existsSync74 } = await import("node:fs");
         const memRoot = getScopedMemoryFilesystemRoot(agentId);
-        if (!existsSync75(memRoot))
+        if (!existsSync74(memRoot))
           return;
         watcher2 = watch4(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher2;
@@ -517714,12 +517134,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join97 } = await import("node:path");
+  const { join: join96 } = await import("node:path");
   const { getVersion: getVersion2 } = await Promise.resolve().then(() => (init_version(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
   const { exists: exists2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join97(cwd2, SKILLS_DIR2);
+  const skillsDir = join96(cwd2, SKILLS_DIR2);
   const skillsExist = exists2(skillsDir);
   await settingsManager.loadLocalProjectSettings(cwd2);
   const pinned = settingsManager.getPinnedAgents();
@@ -517769,18 +517189,6 @@ async function printInfo() {
     console.log("Pinned agents: (none)");
   }
 }
-function getModelForToolLoading(specifiedModel, specifiedToolset) {
-  if (specifiedToolset === "codex") {
-    return "openai/gpt-4";
-  }
-  if (specifiedToolset === "gemini") {
-    return "google_ai/gemini-3.1-pro-preview";
-  }
-  if (specifiedToolset === "default") {
-    return "anthropic/claude-sonnet-4";
-  }
-  return specifiedModel;
-}
 function getStartupTargetLookupOrderForCredentials({
   baseURL,
   explicitBackendMode,
@@ -518066,10 +517474,6 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       process.exit(1);
     }
   })();
-  const fromAfFile = resolveImportFlagAlias({
-    importFlagValue: values4.import,
-    fromAfFlagValue: values4["from-af"]
-  });
   const isHeadless = isHeadlessStartup(values4, process.stdin.isTTY, command);
   const terminalThemePromise = !isHeadless ? initTerminalTheme().catch(() => {
     return;
@@ -518151,8 +517555,8 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     console.error("Error: --personality can only be used with --new-agent");
     process.exit(1);
   }
-  if (specifiedToolset && specifiedToolset !== "codex" && specifiedToolset !== "default" && specifiedToolset !== "gemini" && specifiedToolset !== "auto") {
-    console.error(`Error: Invalid toolset "${specifiedToolset}". Must be "auto", "codex", "default", or "gemini".`);
+  if (specifiedToolset && specifiedToolset !== "codex" && specifiedToolset !== "default" && specifiedToolset !== "gemini" && specifiedToolset !== "letta" && specifiedToolset !== "auto") {
+    console.error(`Error: Invalid toolset "${specifiedToolset}". Must be "auto", "letta", "codex", "default", or "gemini".`);
     process.exit(1);
   }
   if (systemPromptPreset && systemCustom) {
@@ -518179,7 +517583,6 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       specifiedAgentName,
       forceNewAgent: forceNew,
       forceNewConversation,
-      importFile: fromAfFile,
       shouldResume,
       stateless: values4.stateless,
       isHeadless,
@@ -518190,52 +517593,6 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     console.error(error5 instanceof Error ? `Error: ${error5.message}` : String(error5));
     process.exit(1);
   }
-  let isRegistryImport = false;
-  if (fromAfFile) {
-    try {
-      validateFlagConflicts({
-        guard: fromAfFile,
-        checks: [
-          {
-            when: specifiedAgentId,
-            message: "--import cannot be used with --agent"
-          },
-          {
-            when: specifiedAgentName,
-            message: "--import cannot be used with --name"
-          },
-          {
-            when: shouldResume,
-            message: "--import cannot be used with --resume"
-          },
-          {
-            when: forceNew,
-            message: "--import cannot be used with --new-agent"
-          }
-        ]
-      });
-    } catch (error5) {
-      console.error(error5 instanceof Error ? `Error: ${error5.message}` : String(error5));
-      process.exit(1);
-    }
-    if (fromAfFile.startsWith("@")) {
-      isRegistryImport = true;
-      try {
-        validateRegistryHandleOrThrow(fromAfFile);
-      } catch {
-        console.error(`Error: Invalid registry handle "${fromAfFile}". Use format: letta --import @author/agentname`);
-        process.exit(1);
-      }
-    } else {
-      const { resolve: resolve45 } = await import("node:path");
-      const { existsSync: existsSync75 } = await import("node:fs");
-      const resolvedPath = resolve45(fromAfFile);
-      if (!existsSync75(resolvedPath)) {
-        console.error(`Error: AgentFile not found: ${resolvedPath}`);
-        process.exit(1);
-      }
-    }
-  }
   let nameResolvedAgent = null;
   if (specifiedAgentName) {
     if (specifiedAgentId) {
@@ -518417,8 +517774,11 @@ Error: ${message}`);
   }
   if (isHeadless) {
     markMilestone("HEADLESS_MODE_START");
-    const modelForTools = getModelForToolLoading(specifiedModel, specifiedToolset);
-    await loadTools(modelForTools, { exclude: ["AskUserQuestion"] });
+    await loadStartupTools({
+      modelIdentifier: specifiedModel,
+      toolset: specifiedToolset,
+      exclude: ["AskUserQuestion"]
+    });
     markMilestone("TOOLS_LOADED");
     const headlessValues = specifiedAgentId && values4.agent !== specifiedAgentId ? { ...values4, agent: specifiedAgentId } : values4;
     const { handleHeadlessCommand: handleHeadlessCommand2 } = await init_headless().then(() => exports_headless);
@@ -518445,9 +517805,7 @@ Error: ${message}`);
     model,
     systemPromptPreset: systemPromptPreset2,
     toolset,
-    skillsDirectory: skillsDirectory2,
-    fromAfFile: fromAfFile2,
-    isRegistryImport: isRegistryImport2
+    skillsDirectory: skillsDirectory2
   }) {
     const [showKeybindingSetup, setShowKeybindingSetup] = useState56(null);
     const [loadingState, setLoadingState] = useState56("selecting");
@@ -518635,8 +517993,8 @@ Error: ${message}`);
           console.error("Run 'letta' to get started.");
           process.exit(1);
         }
-        if (forceNew2 || agentIdArg || fromAfFile2) {
-          if (agentIdArg && !forceNew2 && !fromAfFile2 && !forceNewConversation) {
+        if (forceNew2 || agentIdArg) {
+          if (agentIdArg && !forceNew2 && !forceNewConversation) {
             await settingsManager.loadLocalProjectSettings(process.cwd());
             const localSession2 = settingsManager.getLocalLastSession(process.cwd());
             if (localSession2?.agentId === agentIdArg && localSession2.conversationId && localSession2.conversationId !== "default") {
@@ -518743,13 +518101,7 @@ Error: ${message}`);
         setLoadingState("assembling");
       }
       checkAndStart();
-    }, [
-      forceNew2,
-      agentIdArg,
-      fromAfFile2,
-      shouldResume,
-      specifiedConversationId
-    ]);
+    }, [forceNew2, agentIdArg, shouldResume, specifiedConversationId]);
     const initStartedRef = React14.useRef(false);
     useEffect50(() => {
       if (loadingState !== "assembling") {
@@ -518820,48 +518172,11 @@ Error: ${message}`);
           }
         }
         setIsResumingSession(!!resumingAgentId);
-        const modelForTools = getModelForToolLoading(model, toolset);
-        await loadTools(modelForTools);
+        await loadStartupTools({ modelIdentifier: model, toolset });
         setLoadingState("initializing");
         const { createAgent: createAgent2 } = await Promise.resolve().then(() => (init_create5(), exports_create));
         let agent = null;
         let autoEnableMemfsForFreshAgent = false;
-        if (fromAfFile2) {
-          setLoadingState("importing");
-          let result2;
-          if (isRegistryImport2) {
-            const { importAgentFromRegistry: importAgentFromRegistry2 } = await Promise.resolve().then(() => (init_import(), exports_import));
-            result2 = await importAgentFromRegistry2({
-              handle: fromAfFile2,
-              modelOverride: model,
-              stripMessages: true,
-              stripSkills: false
-            });
-          } else {
-            const { importAgentFromFile: importAgentFromFile2 } = await Promise.resolve().then(() => (init_import(), exports_import));
-            result2 = await importAgentFromFile2({
-              filePath: fromAfFile2,
-              modelOverride: model,
-              stripMessages: true,
-              stripSkills: false
-            });
-          }
-          agent = result2.agent;
-          setAgentProvenance({
-            isNew: true,
-            blocks: []
-          });
-          if (settingsManager.isReady) {
-            settingsManager.setSystemPromptCustom(agent.id);
-          }
-          if (result2.skills && result2.skills.length > 0) {
-            const { getAgentSkillsDir: getAgentSkillsDir2 } = await Promise.resolve().then(() => (init_skills5(), exports_skills2));
-            const skillsDir = getAgentSkillsDir2(agent.id);
-            console.log(`
-\uD83D\uDCE6 Extracted ${result2.skills.length} skill${result2.skills.length === 1 ? "" : "s"} to ${skillsDir}: ${result2.skills.join(", ")}
-`);
-          }
-        }
         if (!agent && agentIdArg) {
           try {
             agent = await backend3.retrieveAgent(agentIdArg, {
@@ -518969,7 +518284,7 @@ Error: ${message}`);
         if (!shouldBlockOnMemfsStartup) {}
         const secretsInitPromise = Promise.resolve().then(() => (init_secrets_store(), exports_secrets_store)).then(({ initSecretsFromServer: initSecretsFromServer2 }) => initSecretsFromServer2(agentId2));
         const isResumingProject = !shouldCreateNew && !!resumingAgentId;
-        const isReusingExistingAgent = !shouldCreateNew && !fromAfFile2 && agent && agent.id;
+        const isReusingExistingAgent = !shouldCreateNew && agent && agent.id;
         const resuming = !!(agentIdArg || isResumingProject || isReusingExistingAgent);
         setIsResumingSession(resuming);
         if (resuming) {
@@ -519129,7 +518444,6 @@ Error during initialization: ${message}`);
       agentIdArg,
       model,
       systemPromptPreset2,
-      fromAfFile2,
       loadingState,
       selectedGlobalAgentId,
       validatedAgent,
@@ -519253,15 +518567,14 @@ Error during initialization: ${message}`);
     model: specifiedModel,
     systemPromptPreset,
     toolset: specifiedToolset,
-    skillsDirectory,
-    fromAfFile,
-    isRegistryImport
+    skillsDirectory
   }), {
     exitOnCtrlC: false
   });
 }
 var EMPTY_APPROVAL_ARRAY, EMPTY_MESSAGE_ARRAY;
 var init_src5 = __esm(async () => {
+  init_startup_log_boundary();
   init_error();
   init_telemetry();
   init_error_reporting();
@@ -519293,7 +518606,7 @@ var init_src5 = __esm(async () => {
     init_ConversationSelector(),
     init_profile_selection(),
     init_router(),
-    init_manager4(),
+    init_letta_toolset(),
     init_toolset()
   ]);
   EMPTY_APPROVAL_ARRAY = [];
@@ -519301,6 +518614,9 @@ var init_src5 = __esm(async () => {
   assertSupportedBunRuntime();
   main2();
 });
+
+// src/standalone-entry.ts
+init_startup_log_boundary();
 // node_modules/@earendil-works/pi-ai/dist/auth/oauth/oauth-page.js
 var LOGO_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800" aria-hidden="true"><path fill="#fff" fill-rule="evenodd" d="M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z M282.65 282.65 V400 H400 V282.65 Z"/><path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/></svg>`;
 function escapeHtml(value) {
@@ -521496,4 +520812,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=875FFD1EA43A424B64756E2164756E21
+//# debugId=182BBD0B116FF61964756E2164756E21