@letta-ai/letta-code 0.32.1 → 0.32.3

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.3",
+    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,6 +86766,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.
@@ -86989,6 +86974,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.
@@ -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}`);
     }
   }
 }
@@ -98013,7 +98016,7 @@ Note: \`fork\` cannot be combined with \`agent_id\` or \`conversation_id\`.
 
 ## Running on Another Computer
 
-Pass \`computer\` to run the subagent's turn on another connected computer instead of this machine. Works with any subagent type. The call fails fast if the named device is offline, ambiguous, or too old to support routing.
+Pass \`computer\` to run the subagent's turn on another connected computer instead of this machine. Prefer a stable device ID or computer name; these select the freshest online listener for that device. Ephemeral connection IDs are still supported to pin a specific listener. Works with any subagent type. The call fails fast if the named device is offline, the name matches multiple online devices, or the listener is too old to support routing.
 
 \`computer: "cloud"\` provisions a Cloud sandbox for the subagent's conversation and runs the turn there. Sandboxes are per-conversation: this is a separate machine from wherever you are running now, even if you are already in a Cloud sandbox.
 
@@ -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;
@@ -122404,7 +122477,8 @@ var init_skills5 = __esm(() => {
   init_skill_sources();
   LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS = new Set([
     "image-generation",
-    "managing-shared-memory"
+    "managing-shared-memory",
+    "working-across-computers"
   ]);
   PROJECT_SKILLS_DIR = join26(".agents", "skills");
   GLOBAL_SKILLS_DIR = join26(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
@@ -123129,23 +123203,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 +124057,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)) {
@@ -126262,7 +126333,7 @@ var init_Task2 = __esm(() => {
       },
       computer: {
         type: "string",
-        description: `Run the subagent on another connected computer instead of this machine. Pass a computer name/connection ID, or "cloud" to provision a Cloud sandbox for the subagent's conversation. Fails fast if the device is offline or does not support routing. Omit this field to run on the current machine (the default) — only set it when the task specifically needs to run elsewhere.`
+        description: `Run the subagent on another connected computer instead of this machine. Prefer a stable device ID or computer name; ephemeral connection IDs are also supported to pin a specific listener. Pass "cloud" to provision a Cloud sandbox for the subagent's conversation. Fails fast if the device is offline or does not support routing. Omit this field to run on the current machine (the default) — only set it when the task specifically needs to run elsewhere.`
       }
     },
     required: ["description", "prompt", "subagent_type"],
@@ -131714,7 +131785,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 +134186,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 +134344,9 @@ function getToolNamesForToolset(toolsetName) {
     case "gemini_snake":
       tools = [...GEMINI_DEFAULT_TOOLS];
       break;
+    case "letta":
+      tools = [...LETTA_TOOLS];
+      break;
     case "none":
       tools = [];
       break;
@@ -134521,11 +134629,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 +134670,7 @@ var init_toolset = __esm(async () => {
   init_settings_manager();
   init_filter();
   await __promiseAll([
+    init_letta_toolset(),
     init_manager4(),
     init_tool_definitions()
   ]);
@@ -136745,18 +136857,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 +139341,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 +140026,6 @@ var init_fake_headless_backend = __esm(() => {
     remoteMemfs: false,
     serverSideToolManagement: false,
     serverSecrets: false,
-    agentFileImportExport: false,
     promptRecompile: false,
     byokProviderRefresh: false,
     localModelCatalog: true,
@@ -141756,10 +141867,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 +144140,6 @@ class APIBackend {
       remoteMemfs: true,
       serverSideToolManagement: true,
       serverSecrets: true,
-      agentFileImportExport: true,
       promptRecompile: true,
       byokProviderRefresh: true,
       localModelCatalog: false,
@@ -145366,7 +145476,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 +145572,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 +181598,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 +181935,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 +183745,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 +184025,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 +185209,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 +185822,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 +185850,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 +185870,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 +187900,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 +191991,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 = "";
@@ -192313,7 +192397,8 @@ function resolveSlackConcreteActivity(event) {
   if (event.kind !== "tool" || !isNonEmptyString5(event.toolName) || event.toolName.toLowerCase() === "messagechannel") {
     return null;
   }
-  for (const description of [event.toolTitle, event.toolDetails]) {
+  const descriptions = event.toolBatchTitle !== undefined ? [event.toolBatchTitle] : [event.toolTitle, event.toolDetails];
+  for (const description of descriptions) {
     if (!isNonEmptyString5(description)) {
       continue;
     }
@@ -195184,6 +195269,12 @@ ${loadingText}`;
     signatureByConversation.set(stateKey, signature);
     const previous = writePromiseByConversation.get(stateKey) ?? Promise.resolve();
     const operation = previous.then(async () => {
+      if (footerText && !stateByConversation.get(stateKey)?.isThinkingActive) {
+        if (signatureByConversation.get(stateKey) === signature) {
+          signatureByConversation.delete(stateKey);
+        }
+        return false;
+      }
       try {
         await setStatus.call(slackClient.assistant?.threads, {
           channel_id: source.chatId,
@@ -195191,6 +195282,16 @@ ${loadingText}`;
           status: footerText,
           ...footerText ? { loading_messages: [loadingText] } : {}
         });
+        const state = stateByConversation.get(stateKey);
+        if (footerText && state && !state.isThinkingActive) {
+          await setStatus.call(slackClient.assistant?.threads, {
+            channel_id: source.chatId,
+            thread_ts: threadTs,
+            status: ""
+          });
+          clearedStaleReplyKeys.add(replyKey);
+          return true;
+        }
         if (footerText)
           clearedStaleReplyKeys.delete(replyKey);
         else
@@ -195289,7 +195390,40 @@ ${loadingText}`;
     await writeStatus(source, "", "", { force: true });
     signatureByConversation.delete(key2);
   }
+  async function refresh(source) {
+    const key2 = getConversationKey(source);
+    const state = key2 ? stateByConversation.get(key2) : undefined;
+    if (!key2 || !state?.isThinkingActive)
+      return false;
+    await writeStatus(source, state.typingFooterText, state.thinkingText, {
+      force: true
+    });
+    if (stateByConversation.get(key2) === state && state.isThinkingActive) {
+      scheduleKeepalive(key2);
+    }
+    return true;
+  }
+  async function handleLifecycle(event) {
+    if (event.type === "queued") {
+      if (await refresh(event.source))
+        return;
+      if (event.source.showStartupStatus) {
+        await activate(event.source, SLACK_ASSISTANT_STARTUP_STATUS, SLACK_ASSISTANT_STARTUP_STATUS);
+      }
+      return;
+    }
+    for (const source of getUniqueSources(event.sources)) {
+      if (event.type === "processing") {
+        await clearStale(source);
+      } else if (event.stopReason !== "requires_approval") {
+        const remaining = event.remainingSources?.some((other) => other.accountId === source.accountId && getConversationKey(other) === getConversationKey(source) && getLifecycleReplyKey(other) === getLifecycleReplyKey(source));
+        if (!remaining)
+          await deactivate(source);
+      }
+    }
+  }
   return {
+    handleLifecycle,
     getUniqueSources,
     getLifecycleErrorReplyKey,
     activate,
@@ -195329,7 +195463,9 @@ ${loadingText}`;
   };
 }
 var SLACK_ASSISTANT_STATUS_KEEPALIVE_MS = 90000;
-var init_status_controller = () => {};
+var init_status_controller = __esm(() => {
+  init_progress();
+});
 
 // src/channels/slack/thread-context.ts
 function shouldHydrateCurrentSlackMessageAttachments(msg) {
@@ -195612,19 +195748,19 @@ function createSlackAdapter(config) {
     if (!running)
       return;
     if (event.type === "queued") {
-      if (isSlackFlatChannelThreadOpener(event.source) && isNonEmptyString4(event.source.messageId) && !agentThreadTracker.has(event.source.chatId, event.source.messageId)) {
-        await status.activate(event.source, SLACK_ASSISTANT_STARTUP_STATUS, SLACK_ASSISTANT_STARTUP_STATUS);
-      }
+      const showStartupStatus = event.source.showStartupStatus || isSlackFlatChannelThreadOpener(event.source) && isNonEmptyString4(event.source.messageId) && !agentThreadTracker.has(event.source.chatId, event.source.messageId);
+      await status.handleLifecycle({
+        ...event,
+        source: { ...event.source, showStartupStatus }
+      });
       return;
     }
     const sources = status.getUniqueSources(event.sources);
-    if (event.type === "processing") {
-      await Promise.all(sources.map(status.clearStale));
+    await status.handleLifecycle(event);
+    if (event.type === "processing")
       return;
-    }
     if (event.stopReason === "requires_approval")
       return;
-    await Promise.all(sources.map(status.deactivate));
     if (!shouldPostSlackTerminalError(event.stopReason))
       return;
     const errorText = event.error?.trim() ?? "";
@@ -195899,6 +196035,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 +196088,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 +196132,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 +196194,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 +196574,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 +204991,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.",
@@ -217168,7 +217352,7 @@ function shouldProcessInboundMessageDirectly(runtime, parsed) {
   });
   return getListenerBlockedReason(runtime.turnLifecycle.snapshot(), activeScope ? getPendingControlRequestCount(runtime.listener, activeScope) : 0) === null;
 }
-function consumeQueuedTurn(runtime) {
+function consumeQueuedTurn(runtime, continuation) {
   const queuedItems = runtime.queueRuntime.peekReady();
   const firstQueuedItem = queuedItems[0];
   if (!firstQueuedItem || !isCoalescable(firstQueuedItem.kind)) {
@@ -217180,15 +217364,22 @@ 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) {
+    if (continuation && item.actingUserId !== continuation.actingUserId) {
+      break;
+    }
     if (!isCoalescable(item.kind) || !hasSameQueueScope(firstQueuedItem, item)) {
       break;
     }
     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 +217392,7 @@ function consumeQueuedTurn(runtime) {
       }
       batchImageFailureMode = itemImageFailureMode;
     }
+    batchActingUserId ??= item.actingUserId;
     queueLen += 1;
     if (item.kind === "message") {
       hasMessage = true;
@@ -218066,12 +218258,12 @@ async function resolveDesktopEnvironmentConnectionId(list = listEnvironments) {
   }
   return { connectionId: environment2.connectionId, environment: environment2 };
 }
-async function resolveEnvironmentConnectionId(selector) {
+async function resolveEnvironmentConnectionId(selector, list = listEnvironments) {
   const trimmed = selector.trim();
   if (!trimmed) {
     throw new Error("Computer selector must not be empty");
   }
-  const response = await listEnvironments({ limit: 100 });
+  const response = await list({ limit: 100 });
   const matches3 = response.connections.filter((environment3) => {
     return environment3.connectionId === trimmed || environment3.id === trimmed || environment3.deviceId === trimmed || environment3.connectionName === trimmed;
   });
@@ -218082,9 +218274,10 @@ async function resolveEnvironmentConnectionId(selector) {
   if (onlineMatches.length === 0) {
     throw new Error(`Computer "${trimmed}" is offline. Matched: ${matches3.map(describeEnvironment).join(", ")}`);
   }
-  if (onlineMatches.length > 1) {
+  if (new Set(onlineMatches.map((environment3) => environment3.deviceId)).size > 1) {
     throw new Error(`Computer "${trimmed}" is ambiguous. Matched: ${onlineMatches.map(describeEnvironment).join(", ")}`);
   }
+  onlineMatches.sort((a2, b3) => Math.max(b3.lastHeartbeat ?? 0, b3.lastSeenAt) - Math.max(a2.lastHeartbeat ?? 0, a2.lastSeenAt));
   const environment2 = onlineMatches[0];
   if (!environment2) {
     throw new Error(`Computer "${trimmed}" is offline`);
@@ -219014,7 +219207,9 @@ List options:
 Notes:
   - Output is JSON only.
   - Uses CLI auth; override with LETTA_API_KEY/LETTA_BASE_URL if needed.
-  - Use letta computers current to get this computer's connectionId.
+  - Use letta computers current to get this computer's stable deviceId.
+  - Prefer deviceId or connectionName for --computer and Agent(computer=...).
+    connectionId is ephemeral; use it only to pin a specific listener.
   - Use --computer cloud to route through the target agent's cloud sandbox.
   - Use --computer <name|device-id|connection-id> with headless messaging
     to route a message through a specific registered computer.
@@ -223003,6 +223198,7 @@ var init_protocol_inbound = __esm(() => {
     "default",
     "gemini",
     "gemini_snake",
+    "letta",
     "none"
   ]);
 });
@@ -224792,15 +224988,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 +397039,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 +397051,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 +397069,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 +397079,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;
@@ -405223,13 +405412,14 @@ async function handleApprovalStop(params) {
     }
   ]);
   let continuationBatchId = dequeuedBatchId;
-  let continuationActingUserId;
-  const consumedQueuedTurn = consumeQueuedTurn(runtime);
+  const sendOptions = buildSendOptions() ?? {};
+  const consumedQueuedTurn = consumeQueuedTurn(runtime, {
+    actingUserId: sendOptions.actingUserId
+  });
   if (consumedQueuedTurn) {
     const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
     turnCorrelation?.appendDequeuedBatch(dequeuedBatch.batchId);
     continuationBatchId = dequeuedBatch.batchId;
-    continuationActingUserId = queuedTurn.actingUserId;
     nextTurnInput = appendQueuedTurnToInput(nextTurnInput, queuedTurn);
     emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
   }
@@ -405244,11 +405434,9 @@ async function handleApprovalStop(params) {
   });
   let sendResult;
   try {
-    const sendOptions = buildSendOptions() ?? {};
     const imageFailureModesByMessageOtid = mergeImageFailureModesByMessageOtid(sendOptions.imageFailureModesByMessageOtid, nextTurnInput.imageFailureModesByMessageOtid);
     sendResult = await sendApprovalContinuation(conversationId, nextInputWithSkillContent, {
       ...sendOptions,
-      ...continuationActingUserId ? { actingUserId: continuationActingUserId } : {},
       ...imageFailureModesByMessageOtid ? { imageFailureModesByMessageOtid } : {},
       ...continuationWasFullyAutoHandled ? { allowResponseStateReuse: true } : {}
     }, socket, runtime, turnLease);
@@ -406427,12 +406615,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 +406706,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 +406726,7 @@ var init_hermes = __esm(() => {
               ...timestamp ? { timestamp } : {}
             });
           }
-          const content = contentText2(row.content);
+          const content = contentText(row.content);
           if (content) {
             emit({
               type: "message",
@@ -406561,7 +406749,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 +407951,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 +409283,7 @@ function normalizeReflectionTranscript(entries) {
     transcript,
     sourceContext: { partial: true },
     bounds: {
-      toolArguments: { maxCharacters: TOOL_ARGS_TRUNCATE_LIMIT }
+      toolArguments: { maxCharacters: null }
     },
     filters: { toolResults: "include" }
   });
@@ -409843,7 +410031,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 +410698,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 +410756,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 +416856,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 +418085,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 +418635,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 +419083,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 +419538,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 +423020,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 +440249,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.32.1"
+    version: "0.32.3"
   };
 });
 
@@ -443945,7 +444138,7 @@ async function request(path50, init, deps) {
 async function ensureConversationSandbox(agentId, conversationId, deps = defaultDeps) {
   const response = await request(`/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, {
     method: "POST",
-    body: JSON.stringify({ conversationId })
+    body: JSON.stringify(conversationId === "default" ? {} : { conversationId })
   }, deps);
   return await response.json();
 }
@@ -443983,8 +444176,17 @@ Usage:
   letta sandbox upload <local-path>
   letta sandbox download <sandbox-path> [--to <local-path>]
 
+Target another conversation (upload or download):
+  letta sandbox upload <local-path> --conversation <conv-id>
+  letta sandbox upload <local-path> --agent <agent-id>
+
 Notes:
-  - Requires an active conversation for a Letta Cloud agent.
+  - Without target flags, uses the active Letta Cloud conversation.
+  - --conversation resolves the owning agent; --agent, if given, must match.
+  - --agent alone selects that agent's main/default sandbox.
+  - --conversation default is also supported and requires explicit --agent.
+  - Target flags override shell/session context without changing it.
+  - Run upload on the computer containing the local file, including a remote subagent.
   - Uploads are stored under /root/downloads in the conversation sandbox.
   - Downloads are limited to files under /root/downloads.
   - Output is JSON only.
@@ -444021,6 +444223,35 @@ function resolveSandboxSession(env5, fallback) {
   }
   return session2;
 }
+async function resolveSandboxTarget(target2, getCurrentSession, retrieveConversation) {
+  if (target2.agent === undefined && target2.conversation === undefined) {
+    return getCurrentSession();
+  }
+  const agentId = target2.agent?.trim();
+  const conversationId = target2.conversation === undefined && agentId ? "default" : target2.conversation?.trim();
+  if (target2.agent !== undefined && !agentId) {
+    throw new Error("--agent must not be empty");
+  }
+  if (!conversationId || conversationId === "new") {
+    throw new Error("Specify --conversation <conv-id> or --conversation default");
+  }
+  if (agentId && isLocalAgentId(agentId)) {
+    throw new Error("Sandbox file transfer requires a Letta Cloud agent");
+  }
+  if (conversationId === "default") {
+    if (!agentId)
+      throw new Error("--conversation default requires --agent");
+    return { agentId, conversationId };
+  }
+  const conversation = await retrieveConversation(conversationId);
+  if (!conversation.agent_id || isLocalAgentId(conversation.agent_id)) {
+    throw new Error("The target conversation must belong to a Letta Cloud agent");
+  }
+  if (agentId && agentId !== conversation.agent_id) {
+    throw new Error(`Conversation ${conversationId} does not belong to ${agentId}`);
+  }
+  return { agentId: conversation.agent_id, conversationId };
+}
 async function initializeSandboxSettings() {
   await settingsManager.initialize();
   await settingsManager.loadLocalProjectSettings();
@@ -444049,24 +444280,37 @@ async function runSandboxSubcommand(argv, deps = {}) {
     if (!await (deps.isCloud ?? isLettaCloud)()) {
       throw new Error("Sandbox file transfer is only available on Letta Cloud");
     }
-    const session2 = resolveSandboxSession(process.env, (deps.getLastSession ?? (() => settingsManager.getEffectiveLastSession()))());
-    const ensureSandbox = deps.ensureSandbox ?? ensureConversationSandbox;
+    const session2 = await resolveSandboxTarget(parsed.values, () => resolveSandboxSession(process.env, (deps.getLastSession ?? (() => settingsManager.getEffectiveLastSession()))()), deps.retrieveConversation ?? (async (id2) => (await getClient()).conversations.retrieve(id2)));
+    const explicitTarget = parsed.values.conversation !== undefined || parsed.values.agent !== undefined;
+    const ensureSandbox = async () => {
+      const sandbox2 = await (deps.ensureSandbox ?? ensureConversationSandbox)(session2.agentId, session2.conversationId);
+      if (explicitTarget && (sandbox2.conversationId ?? "default") !== session2.conversationId) {
+        throw new Error("The server returned a sandbox for a different conversation; no files transferred");
+      }
+      return sandbox2;
+    };
+    const targetOutput = explicitTarget ? session2 : {};
     if (action3 === "upload") {
       const localPath2 = resolve37(path50);
       const fileStat = await (deps.statLocalPath ?? stat17)(localPath2);
       if (!fileStat.isFile())
         throw new Error(`${localPath2} is not a file`);
       const data2 = await (deps.readLocalFile ?? readFile25)(localPath2);
-      const sandbox2 = await ensureSandbox(session2.agentId, session2.conversationId);
+      const sandbox2 = await ensureSandbox();
       const result2 = await (deps.uploadFile ?? uploadFileToSandbox)(sandbox2.sandboxId, { blob: new Blob([data2]), name: basename26(localPath2) });
-      console.log(JSON.stringify(result2, null, 2));
+      console.log(JSON.stringify({ ...result2, ...targetOutput }, null, 2));
       return 0;
     }
-    const sandbox = await ensureSandbox(session2.agentId, session2.conversationId);
+    const sandbox = await ensureSandbox();
     const data = await (deps.downloadFile ?? downloadFileFromSandbox)(sandbox.sandboxId, path50);
     const localPath = resolve37(parsed.values.to ?? basename26(path50));
     await (deps.writeLocalFile ?? writeFile17)(localPath, data);
-    console.log(JSON.stringify({ path: localPath, sandboxPath: path50, size: data.byteLength }, null, 2));
+    console.log(JSON.stringify({
+      path: localPath,
+      sandboxPath: path50,
+      size: data.byteLength,
+      ...targetOutput
+    }, null, 2));
     return 0;
   } catch (error5) {
     console.error(`Error: ${error5 instanceof Error ? error5.message : error5}`);
@@ -444076,11 +444320,14 @@ async function runSandboxSubcommand(argv, deps = {}) {
 var SANDBOX_OPTIONS;
 var init_sandbox2 = __esm(() => {
   init_memory_filesystem2();
+  init_client4();
   init_sandbox_files();
   init_settings_manager();
   SANDBOX_OPTIONS = {
     help: { type: "boolean", short: "h" },
-    to: { type: "string" }
+    to: { type: "string" },
+    conversation: { type: "string" },
+    agent: { type: "string" }
   };
 });
 
@@ -446835,13 +447082,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 +449303,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 +449371,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 +449771,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 +449817,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")
@@ -450299,6 +450579,36 @@ var init_channel_rich_draft_streamer = __esm(() => {
   ]);
 });
 
+// src/channels/gateway-sources.ts
+function sourceRouteKey(source) {
+  return [
+    source.channel,
+    source.accountId ?? "",
+    source.chatId,
+    source.threadId ?? ""
+  ].join(":");
+}
+function sourceLifecycleKey(source) {
+  return [
+    sourceRouteKey(source),
+    source.messageId ?? "",
+    source.agentId,
+    source.conversationId
+  ].join(":");
+}
+function uniqueSourcesBy(sources, getKey) {
+  const byKey = new Map;
+  for (const source of sources)
+    byKey.set(getKey(source), source);
+  return [...byKey.values()];
+}
+function uniqueRoutedSources(sources) {
+  return uniqueSourcesBy(sources, sourceRouteKey);
+}
+function uniqueLifecycleSources(sources) {
+  return uniqueSourcesBy(sources, sourceLifecycleKey);
+}
+
 // src/channels/progress-builder.ts
 function getMessageType(delta2) {
   return firstNonEmptyString2(delta2.message_type, delta2.messageType) ?? null;
@@ -450351,6 +450661,34 @@ function toolNameForMessage(summary) {
 function createChannelTurnProgressBuilder(options = {}) {
   const argumentsByToolCallId = new Map;
   const namesByToolCallId = new Map;
+  const batchesByStep = new Map;
+  const batchesByToolCallId = new Map;
+  function addToolBatchTitles(delta2, updates) {
+    const record5 = asRecord4(delta2);
+    if (!record5)
+      return updates;
+    const messageType = getMessageType(record5);
+    const isToolRequest = messageType === "tool_call_message" || messageType === "approval_request_message";
+    const stepKey = isToolRequest ? firstNonEmptyString2(record5.step_id, record5.id) : undefined;
+    let requestBatch = stepKey ? batchesByStep.get(stepKey) : undefined;
+    if (stepKey && !requestBatch) {
+      requestBatch = { title: null };
+      batchesByStep.set(stepKey, requestBatch);
+    }
+    return updates.map((update3) => {
+      if (update3.kind !== "tool")
+        return update3;
+      const batch = (update3.toolCallId ? batchesByToolCallId.get(update3.toolCallId) : undefined) ?? requestBatch;
+      if (!batch)
+        return update3;
+      if (update3.toolCallId)
+        batchesByToolCallId.set(update3.toolCallId, batch);
+      if (batch.title === null && update3.state === "started") {
+        batch.title = firstNonEmptyString2(update3.toolTitle, update3.toolDetails) ?? null;
+      }
+      return { ...update3, toolBatchTitle: batch.title };
+    });
+  }
   function extractToolCallSummary(value) {
     const record5 = asRecord4(value);
     if (!record5) {
@@ -450667,7 +451005,9 @@ function createChannelTurnProgressBuilder(options = {}) {
         return [];
     }
   }
-  return { buildUpdates };
+  return {
+    buildUpdates: (delta2) => addToolBatchTitles(delta2, buildUpdates(delta2))
+  };
 }
 var init_progress_builder = __esm(() => {
   init_progress_formatting();
@@ -450680,34 +451020,6 @@ function runtimeKey(runtime) {
 function hasAgentRuntime(value) {
   return !!value.runtime?.agent_id;
 }
-function sourceRouteKey(source) {
-  return [
-    source.channel,
-    source.accountId ?? "",
-    source.chatId,
-    source.threadId ?? ""
-  ].join(":");
-}
-function sourceLifecycleKey(source) {
-  return [
-    sourceRouteKey(source),
-    source.messageId ?? "",
-    source.agentId,
-    source.conversationId
-  ].join(":");
-}
-function uniqueSourcesBy(sources, getKey) {
-  const byKey = new Map;
-  for (const source of sources)
-    byKey.set(getKey(source), source);
-  return [...byKey.values()];
-}
-function uniqueRoutedSources(sources) {
-  return uniqueSourcesBy(sources, sourceRouteKey);
-}
-function uniqueLifecycleSources(sources) {
-  return uniqueSourcesBy(sources, sourceLifecycleKey);
-}
 function channelTagsForSources(sources) {
   return [...new Set(sources.map((source) => `channel:${source.channel}`))];
 }
@@ -450766,6 +451078,7 @@ class ChannelGateway {
       state.acceptedClientMessageIds.add(delivery.clientMessageId);
       return true;
     }
+    const workAtSubmit = state.active || state.pendingSourcesByClientMessageId.size > 0;
     state.pendingSourcesByClientMessageId.set(delivery.clientMessageId, {
       sources: uniqueLifecycleSources(delivery.sources),
       disposition: "submitting"
@@ -450794,6 +451107,8 @@ class ChannelGateway {
       });
       if (!response.accepted) {
         state.pendingSourcesByClientMessageId.delete(delivery.clientMessageId);
+        if (workAtSubmit && !state.active)
+          this.finishRejectedDelivery(state, delivery);
         return false;
       }
       this.rememberAcceptedClientMessageId(state, delivery.clientMessageId);
@@ -450813,9 +451128,28 @@ class ChannelGateway {
       return true;
     } catch (error5) {
       state.pendingSourcesByClientMessageId.delete(delivery.clientMessageId);
+      if (workAtSubmit && !state.active)
+        this.finishRejectedDelivery(state, delivery);
       throw error5;
     }
   }
+  remainingSources(state) {
+    return uniqueLifecycleSources([
+      ...state.active?.lifecycleSources ?? [],
+      ...Array.from(state.pendingSourcesByClientMessageId.values()).flatMap((pending) => pending.sources)
+    ]);
+  }
+  finishRejectedDelivery(state, delivery) {
+    const remainingSources = this.remainingSources(state);
+    this.enqueueHook(state, () => this.hooks.onLifecycle({
+      type: "finished",
+      batchId: `channel-${delivery.clientMessageId}`,
+      sources: delivery.sources,
+      stopReason: "cancelled",
+      outcome: "cancelled",
+      remainingSources
+    }));
+  }
   adoptQueuedDelivery(delivery) {
     const state = this.getState(delivery.runtime);
     const sources = uniqueLifecycleSources(delivery.sources);
@@ -451198,12 +451532,14 @@ class ChannelGateway {
       this.activateSources(state, firstDequeued.clientMessageId, dequeued.flatMap((entry) => entry.sources));
     }
     for (const entry of cancelled) {
+      const remainingSources = this.remainingSources(state);
       this.enqueueHook(state, () => this.hooks.onLifecycle({
         type: "finished",
         batchId: `channel-${entry.clientMessageId}`,
         sources: entry.sources,
         outcome: "cancelled",
-        stopReason: "cancelled"
+        stopReason: "cancelled",
+        ...remainingSources.length ? { remainingSources } : {}
       }));
     }
   }
@@ -451280,12 +451616,14 @@ class ChannelGateway {
       return;
     state.active = null;
     active.richDraft?.dispose();
+    const remainingSources = lifecycleOutcome(terminal.stopReason) === "completed" ? this.remainingSources(state) : [];
     this.enqueueHook(state, () => this.hooks.onLifecycle({
       type: "finished",
       batchId: active.batchId,
       sources: active.lifecycleSources,
       outcome: lifecycleOutcome(terminal.stopReason),
       stopReason: terminal.stopReason,
+      ...remainingSources.length ? { remainingSources } : {},
       ...terminal.runId ?? active.runId ? { runId: terminal.runId ?? active.runId } : {},
       ...terminal.error ? { error: terminal.error } : {}
     }));
@@ -451523,7 +451861,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 +455022,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 +455386,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 +455399,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 +455551,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 +455603,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 +455640,6 @@ In headless mode, use:
       specifiedAgentName,
       forceNewAgent: forceNew,
       forceNewConversation,
-      importFile: fromAfFile,
       stateless: statelessFlag,
       ephemeral: ephemeralFlag,
       isHeadless: true,
@@ -455804,39 +455652,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 +455693,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 +455809,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 +456575,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 +456604,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 +456859,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 +456951,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 +456979,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 +457009,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 +457404,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 +457426,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 +457448,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 +457459,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 +457957,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 +458671,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 +458829,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 +458839,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 +459562,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 +459601,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 +459611,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 +459646,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 +459680,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 +459738,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 +459921,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 +459947,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 +460638,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 +460903,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 +460941,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 +460972,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 +460985,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync68(keybindingsPath))
+  if (!existsSync67(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -461214,15 +461000,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 +461036,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 +461103,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 +461213,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 +461230,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 +461289,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 +461328,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 +461346,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 +461646,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 +461963,6 @@ Location: ${keybindingsPath}`;
       handler: () => {
         return "Opening agent browser...";
       }
-    },
-    "/download": {
-      desc: "Export AgentFile (.af)",
-      hidden: true,
-      noArgs: true,
-      handler: () => {
-        return "Exporting agent file...";
-      }
     }
   };
 });
@@ -462608,10 +462378,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 +462740,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 +463025,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 +463048,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 +463099,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 +463205,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 +463221,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 +463406,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 +466945,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 +472739,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 +472968,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 +472980,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 +476876,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 +476916,7 @@ async function runGitSafe(cwd2, args) {
     return "";
   }
 }
-function parseFrontmatter3(raw2) {
+function parseFrontmatter2(raw2) {
   if (!raw2.startsWith("---")) {
     return { frontmatter: {}, body: raw2 };
   }
@@ -477175,7 +476945,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 +477187,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 +477197,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 +477229,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 +477263,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 +479639,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 +481223,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 +484622,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 +484714,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 +484726,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 +485345,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 +485361,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 +485451,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 +500604,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 +500804,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 +500825,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 +500902,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 +502865,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 +502939,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 +504092,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 +504548,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 +504592,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 +505410,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 +505450,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 +507196,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 +507220,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 +507434,7 @@ function safeJoin(root2, relativePath) {
 }
 async function fileExists(filePath) {
   try {
-    await access4(filePath);
+    await access3(filePath);
     return true;
   } catch {
     return false;
@@ -507715,22 +507444,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 +508122,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 +508130,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 +508161,7 @@ async function defaultCommandRunner(command, args, options) {
     });
     child.on("close", (exitCode) => {
       clearTimeout(timeout);
-      resolve44({
+      resolve42({
         args,
         command,
         cwd: options.cwd,
@@ -508492,7 +508221,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 +508383,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 +508413,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 +508470,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 +508492,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 +508521,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 +508632,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 +508670,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 +508688,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 +509398,6 @@ var init_command_routing = __esm(() => {
     "/search",
     "/memory",
     "/feedback",
-    "/export",
-    "/download",
     "/mods",
     "/reasoning-tab",
     "/secret",
@@ -511199,7 +510926,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 +510975,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 +511001,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 +511065,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 +511158,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 +511860,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 +512617,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 +512709,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 +513669,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 +514956,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 +515727,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 +517304,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 +517359,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 +517644,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 +517725,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 +517753,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 +517763,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 +517944,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 +517975,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 +518163,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 +518271,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 +518342,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 +518454,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 +518614,6 @@ Error during initialization: ${message}`);
       agentIdArg,
       model,
       systemPromptPreset2,
-      fromAfFile2,
       loadingState,
       selectedGlobalAgentId,
       validatedAgent,
@@ -519253,15 +518737,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 +518776,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 +518784,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 +520982,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=875FFD1EA43A424B64756E2164756E21
+//# debugId=95B2BCB7592A39B564756E2164756E21