@letta-ai/letta-code 0.28.3 → 0.28.4

package/letta.js

@@ -4815,7 +4815,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.28.3",
+    version: "0.28.4",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -154418,6 +154418,23 @@ function resolveProviderFromModelHandle(model) {
     return;
   return PI_PROVIDER_SPECS.find((provider) => provider.handlePrefixes.some((prefix) => model.startsWith(prefix)))?.id;
 }
+function resolvePiModelIdentity(model) {
+  const provider = resolveProviderFromModelHandle(model);
+  if (!model || !provider)
+    return;
+  const modelId = stripProviderHandlePrefix(model, provider);
+  return modelId ? `${provider}/${modelId}` : undefined;
+}
+function isResolvablePiModelHandle(model) {
+  const provider = resolveProviderFromModelHandle(model);
+  if (!model || !provider)
+    return false;
+  const spec = getPiProviderSpec(provider);
+  if (!spec.piProvider)
+    return spec.createCustomModel === true;
+  const modelId = stripProviderHandlePrefix(model, provider);
+  return getModels(spec.piProvider).some((entry) => entry.id === modelId);
+}
 function resolveProviderFromProviderType(providerType) {
   if (typeof providerType !== "string")
     return;
@@ -154569,6 +154586,11 @@ var init_pi_provider_registry = __esm(() => {
       baseUrlEnv: () => process.env.GOOGLE_GENERATIVE_AI_BASE_URL,
       envConfigured: () => hasEnvValue(process.env.GOOGLE_GENERATIVE_AI_API_KEY) || getEnvApiKey("google") !== undefined
     },
+    "google-vertex": {
+      providerTypes: ["google-vertex", "google_vertex"],
+      handlePrefixes: ["google-vertex/", "google_vertex/"],
+      localProviderNames: ["google-vertex", "google_vertex"]
+    },
     "amazon-bedrock": {
       providerTypes: ["amazon-bedrock", "bedrock"],
       handlePrefixes: ["amazon-bedrock/", "bedrock/"],
@@ -155407,6 +155429,7 @@ __export(exports_available_models, {
   getModelContextWindow: () => getModelContextWindow,
   getCachedModelProviderTypes: () => getCachedModelProviderTypes,
   getCachedModelHandles: () => getCachedModelHandles,
+  getCachedAvailableModels: () => getCachedAvailableModels,
   getAvailableModelsCacheInfo: () => getAvailableModelsCacheInfo,
   getAvailableModelHandles: () => getAvailableModelHandles,
   clearAvailableModelsCache: () => clearAvailableModelsCache
@@ -155441,11 +155464,15 @@ function getCachedModelProviderTypes() {
   }
   return new Map(cache.providerTypes);
 }
+function getCachedAvailableModels() {
+  return cache?.models.map((model) => ({ ...model })) ?? null;
+}
 async function fetchFromNetwork() {
   const modelsList2 = await getBackend().listModels();
   const handles = new Set(modelsList2.map((m2) => m2.handle).filter((h2) => !!h2));
   const contextWindows = new Map;
   const providerTypes = new Map;
+  const modelsByHandle = new Map;
   for (const model of modelsList2) {
     if (model.handle && model.max_context_window) {
       contextWindows.set(model.handle, model.max_context_window);
@@ -155454,8 +155481,27 @@ async function fetchFromNetwork() {
     if (model.handle && providerType) {
       providerTypes.set(model.handle, providerType);
     }
+    if (model.handle) {
+      const label = typeof model.display_name === "string" && model.display_name || typeof model.name === "string" && model.name || typeof model.model === "string" && model.model || model.handle;
+      const availableModel = {
+        handle: model.handle,
+        label,
+        ...typeof model.max_context_window === "number" ? { maxContextWindow: model.max_context_window } : {},
+        ...typeof model.max_tokens === "number" ? { maxOutputTokens: model.max_tokens } : {},
+        ...providerType ? { providerType } : {}
+      };
+      if (!modelsByHandle.has(model.handle)) {
+        modelsByHandle.set(model.handle, availableModel);
+      }
+    }
   }
-  return { handles, contextWindows, providerTypes, fetchedAt: Date.now() };
+  return {
+    handles,
+    contextWindows,
+    providerTypes,
+    models: [...modelsByHandle.values()],
+    fetchedAt: Date.now()
+  };
 }
 async function getAvailableModelHandles(options3) {
   const forceRefresh = options3?.forceRefresh === true;
@@ -155464,6 +155510,7 @@ async function getAvailableModelHandles(options3) {
     return {
       handles: cache.handles,
       providerTypes: cache.providerTypes,
+      models: cache.models,
       source: "cache",
       fetchedAt: cache.fetchedAt
     };
@@ -155473,6 +155520,7 @@ async function getAvailableModelHandles(options3) {
     return {
       handles: entry2.handles,
       providerTypes: entry2.providerTypes,
+      models: entry2.models,
       source: "network",
       fetchedAt: entry2.fetchedAt
     };
@@ -155497,6 +155545,7 @@ async function getAvailableModelHandles(options3) {
   return {
     handles: entry.handles,
     providerTypes: entry.providerTypes,
+    models: entry.models,
     source: "network",
     fetchedAt: entry.fetchedAt
   };
@@ -392147,6 +392196,200 @@ var init_memory_filesystem2 = __esm(() => {
   MEMORY_TREE_MAX_CHILDREN_PER_DIR = DIRECTORY_LIMIT_DEFAULTS.memfsTreeMaxChildrenPerDir;
 });
 
+// src/agent/memory-git-hooks.ts
+import { chmodSync as chmodSync4, existsSync as existsSync31, mkdirSync as mkdirSync22, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join38 } from "node:path";
+function installPreCommitHook(dir) {
+  const hooksDir = join38(dir, ".git", "hooks");
+  const hookPath = join38(hooksDir, "pre-commit");
+  if (!existsSync31(hooksDir)) {
+    mkdirSync22(hooksDir, { recursive: true });
+  }
+  writeFileSync16(hookPath, PRE_COMMIT_HOOK_SCRIPT, "utf-8");
+  chmodSync4(hookPath, 493);
+  debugLog("memfs-git", "Installed pre-commit hook");
+}
+function installPostCommitHook(dir) {
+  const hooksDir = join38(dir, ".git", "hooks");
+  const hookPath = join38(hooksDir, "post-commit");
+  if (!existsSync31(hooksDir)) {
+    mkdirSync22(hooksDir, { recursive: true });
+  }
+  writeFileSync16(hookPath, POST_COMMIT_HOOK_SCRIPT, "utf-8");
+  chmodSync4(hookPath, 493);
+  debugLog("memfs-git", "Installed post-commit memory-repository hook");
+}
+var PRE_COMMIT_HOOK_SCRIPT = `#!/usr/bin/env bash
+# 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=""
+
+# Skills must always be directories: skills/<name>/SKILL.md
+# Reject legacy flat skill files (both current and legacy repo layouts).
+for file in $(git diff --cached --name-only --diff-filter=ACMR | grep -E '^(memory/)?skills/[^/]+\\.md$' || true); do
+  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
+done
+
+if [ -n "$errors" ]; then
+  echo "Frontmatter validation failed:"
+  echo -e "$errors"
+  exit 1
+fi
+`, POST_COMMIT_HOOK_SCRIPT = `#!/usr/bin/env bash
+# Letta Code: push memfs commits to the configured memory-repository remote.
+# Installed by Letta Code CLI. Do not edit by hand — regenerated on startup.
+url=$(git config --local --get letta.memoryRepository.url 2>/dev/null)
+[ -z "$url" ] && exit 0
+branch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || exit 0
+[ -z "$branch" ] && exit 0
+# Reflection and other harness worktrees commit on temporary branches; only the
+# main MemFS checkout should push to the optional memory repository remote.
+[ "$branch" != "main" ] && exit 0
+log="$(git rev-parse --git-dir)/memory-repository-push.log"
+(
+  {
+    printf '\\n--- %s %s on %s ---\\n' "$(date '+%Y-%m-%dT%H:%M:%S%z')" "$(git rev-parse --short HEAD)" "$branch"
+    git push --quiet "$url" "$branch":"$branch" 2>&1
+    echo "exit=$?"
+  } >> "$log" 2>&1
+) &
+disown 2>/dev/null || true
+exit 0
+`;
+var init_memory_git_hooks = __esm(() => {
+  init_debug();
+});
+
+// src/agent/memory-git-signing.ts
+var GIT_DISABLE_COMMIT_SIGNING_ARGS;
+var init_memory_git_signing = __esm(() => {
+  GIT_DISABLE_COMMIT_SIGNING_ARGS = [
+    "-c",
+    "commit.gpgsign=false"
+  ];
+});
+
 // src/agent/memory-git.ts
 var exports_memory_git = {};
 __export(exports_memory_git, {
@@ -392185,28 +392428,25 @@ __export(exports_memory_git, {
   buildMemfsGitProxyArgs: () => buildMemfsGitProxyArgs,
   buildGitAuthArgs: () => buildGitAuthArgs,
   assertMemoryRepoCleanForWrite: () => assertMemoryRepoCleanForWrite,
-  addGitMemoryTag: () => addGitMemoryTag,
-  PRE_COMMIT_HOOK_SCRIPT: () => PRE_COMMIT_HOOK_SCRIPT,
-  POST_COMMIT_HOOK_SCRIPT: () => POST_COMMIT_HOOK_SCRIPT
+  addGitMemoryTag: () => addGitMemoryTag
 });
 import { execFile as execFileCb } from "node:child_process";
 import {
-  chmodSync as chmodSync4,
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync22,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync23,
   readFileSync as readFileSync23,
   renameSync as renameSync2,
   rmSync as rmSync5,
-  writeFileSync as writeFileSync16
+  writeFileSync as writeFileSync17
 } from "node:fs";
 import { homedir as homedir25, platform as platform3 } from "node:os";
-import { dirname as dirname20, isAbsolute as isAbsolute20, join as join38 } from "node:path";
+import { dirname as dirname20, isAbsolute as isAbsolute20, join as join39 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 function getAgentRootDir(agentId) {
-  return join38(homedir25(), ".letta", "agents", agentId);
+  return join39(homedir25(), ".letta", "agents", agentId);
 }
 function getMemoryRepoDir(agentId) {
-  return join38(getAgentRootDir(agentId), "memory");
+  return join39(getAgentRootDir(agentId), "memory");
 }
 function getMemoryRepositoryRepoDir(agentId) {
   return getScopedMemoryFilesystemRoot(agentId);
@@ -392280,7 +392520,7 @@ function getRepositoryRemoteUrl(agentId, repositoryName, baseUrl) {
   return `${resolvedBaseUrl}/v1/git/${agentId}/repositories/${encodeURIComponent(repositoryName)}.git`;
 }
 function getRepositoryMountDir(agentId, repositoryName) {
-  return join38(dirname20(getMemoryRepoDir(agentId)), repositoryName);
+  return join39(dirname20(getMemoryRepoDir(agentId)), repositoryName);
 }
 function validateAgentRepositoryName(name) {
   const trimmed = name.trim();
@@ -392333,8 +392573,8 @@ async function prepareAttachedRepositoryForGitOps(args) {
   await ensureLocalMemfsGitConfig(args.directory, args.agentId);
 }
 async function cloneRepositoryMount(args) {
-  if (!existsSync31(args.directory)) {
-    mkdirSync22(args.directory, { recursive: true });
+  if (!existsSync32(args.directory)) {
+    mkdirSync23(args.directory, { recursive: true });
     try {
       await runGitWithRetry(args.directory, ["clone", args.remoteUrl, "."], args.token, {
         operation: `clone repository ${args.repositoryName}`,
@@ -392344,7 +392584,7 @@ async function cloneRepositoryMount(args) {
       rmSync5(args.directory, { recursive: true, force: true });
       throw err;
     }
-  } else if (!existsSync31(join38(args.directory, ".git"))) {
+  } else if (!existsSync32(join39(args.directory, ".git"))) {
     throw new Error(`repository mount path already exists and is not a git repository: ${args.directory}`);
   } else {
     await prepareAttachedRepositoryForGitOps(args);
@@ -392465,7 +392705,12 @@ function buildNonInteractiveGitEnv(env3 = process.env) {
 }
 async function runGit3(cwd, args, token, options3) {
   const authArgs = token ? buildGitAuthArgs(token) : [];
-  const allArgs = [...buildMemfsGitProxyArgs(args), ...authArgs, ...args];
+  const allArgs = [
+    ...GIT_DISABLE_COMMIT_SIGNING_ARGS,
+    ...buildMemfsGitProxyArgs(args),
+    ...authArgs,
+    ...args
+  ];
   let loggableArgs = args;
   if (args[0] === "config" && typeof args[1] === "string" && args[1].includes("credential") && args[1].includes(".helper")) {
     loggableArgs = [args[0], args[1], "<redacted>"];
@@ -392510,15 +392755,15 @@ async function runGitWithRetry(cwd, args, token, options3) {
   const operation = options3?.operation ?? args[0] ?? "git op";
   for (let attempt = 1;attempt <= attempts; attempt += 1) {
     try {
-      if (!existsSync31(cwd)) {
-        mkdirSync22(cwd, { recursive: true });
+      if (!existsSync32(cwd)) {
+        mkdirSync23(cwd, { recursive: true });
       }
       return await runGit3(cwd, args, token, {
         timeoutMs: options3?.timeoutMs
       });
     } catch (error54) {
       if (isMissingCwdGitError(error54)) {
-        mkdirSync22(cwd, { recursive: true });
+        mkdirSync23(cwd, { recursive: true });
         if (attempt < attempts) {
           continue;
         }
@@ -392544,12 +392789,12 @@ async function configureLocalCredentialHelper(dir, token) {
   }
   let helper;
   if (platform3() === "win32") {
-    const helperScriptPath = join38(dir, ".git", "letta-credential-helper.cmd");
+    const helperScriptPath = join39(dir, ".git", "letta-credential-helper.cmd");
     const batchScript = `@echo off
 echo username=letta
 echo password=${token}
 `;
-    writeFileSync16(helperScriptPath, batchScript, "utf-8");
+    writeFileSync17(helperScriptPath, batchScript, "utf-8");
     helper = formatGitCredentialHelperPath(helperScriptPath);
     debugLog("memfs-git", `Wrote Windows credential helper script`);
   } else {
@@ -392576,26 +392821,6 @@ async function clearLocalCredentialHelper(dir, rawBaseUrl, normalizedBaseUrl) {
     } catch {}
   }
 }
-function installPreCommitHook(dir) {
-  const hooksDir = join38(dir, ".git", "hooks");
-  const hookPath = join38(hooksDir, "pre-commit");
-  if (!existsSync31(hooksDir)) {
-    mkdirSync22(hooksDir, { recursive: true });
-  }
-  writeFileSync16(hookPath, PRE_COMMIT_HOOK_SCRIPT, "utf-8");
-  chmodSync4(hookPath, 493);
-  debugLog("memfs-git", "Installed pre-commit hook");
-}
-function installPostCommitHook(dir) {
-  const hooksDir = join38(dir, ".git", "hooks");
-  const hookPath = join38(hooksDir, "post-commit");
-  if (!existsSync31(hooksDir)) {
-    mkdirSync22(hooksDir, { recursive: true });
-  }
-  writeFileSync16(hookPath, POST_COMMIT_HOOK_SCRIPT, "utf-8");
-  chmodSync4(hookPath, 493);
-  debugLog("memfs-git", "Installed post-commit memory-repository hook");
-}
 async function getLocalGitConfig(dir, key) {
   try {
     const { stdout } = await runGit3(dir, ["config", "--local", "--get", key]);
@@ -392639,7 +392864,7 @@ async function fetchAgentDisplayName(agentId) {
   }
 }
 async function ensureLocalMemfsGitConfig(dir, agentId) {
-  if (!existsSync31(join38(dir, ".git"))) {
+  if (!existsSync32(join39(dir, ".git"))) {
     return;
   }
   try {
@@ -392656,20 +392881,24 @@ async function ensureLocalMemfsGitConfig(dir, agentId) {
       const displayName = await fetchAgentDisplayName(agentId) ?? "Letta Agent";
       await setLocalGitConfig(dir, "user.name", displayName);
     }
+    const currentGpgSign = await getLocalGitConfig(dir, "commit.gpgsign");
+    if (currentGpgSign === null) {
+      await setLocalGitConfig(dir, "commit.gpgsign", "false");
+    }
   } catch (err) {
     debugWarn("memfs-git", `Failed to ensure local memfs git config: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 async function getMemoryRepositoryUrl(agentId) {
   const dir = getMemoryRepositoryRepoDir(agentId);
-  if (!existsSync31(join38(dir, ".git"))) {
+  if (!existsSync32(join39(dir, ".git"))) {
     return null;
   }
   return await getLocalGitConfig(dir, MEMORY_REPOSITORY_CONFIG_KEY);
 }
 async function setMemoryRepositoryUrl(agentId, url2) {
   const dir = getMemoryRepositoryRepoDir(agentId);
-  if (!existsSync31(join38(dir, ".git"))) {
+  if (!existsSync32(join39(dir, ".git"))) {
     throw new Error(`Memory repo not initialized for ${agentId} — cannot configure memory-repository endpoint.`);
   }
   await setLocalGitConfig(dir, MEMORY_REPOSITORY_CONFIG_KEY, url2.trim());
@@ -392677,7 +392906,7 @@ async function setMemoryRepositoryUrl(agentId, url2) {
 }
 async function unsetMemoryRepositoryUrl(agentId) {
   const dir = getMemoryRepositoryRepoDir(agentId);
-  if (!existsSync31(join38(dir, ".git"))) {
+  if (!existsSync32(join39(dir, ".git"))) {
     return;
   }
   await unsetLocalGitConfig(dir, MEMORY_REPOSITORY_CONFIG_KEY);
@@ -392741,8 +392970,8 @@ async function pushToMemoryRepository(agentId) {
   }
 }
 function readMemoryRepositoryPushLog(agentId, tailLines = 20) {
-  const logPath = join38(getMemoryRepositoryRepoDir(agentId), ".git", MEMORY_REPOSITORY_PUSH_LOG);
-  if (!existsSync31(logPath)) {
+  const logPath = join39(getMemoryRepositoryRepoDir(agentId), ".git", MEMORY_REPOSITORY_PUSH_LOG);
+  if (!existsSync32(logPath)) {
     return "";
   }
   try {
@@ -392828,6 +393057,9 @@ async function prepareLocalOnlyMemoryRepoForGitOps(memoryDir, author) {
   await setLocalGitConfig(memoryDir, "letta.agentId", author.agentId);
   await setLocalGitConfig(memoryDir, "user.email", author.authorEmail);
   await setLocalGitConfig(memoryDir, "user.name", author.authorName.trim() || "Letta Agent");
+  if (await getLocalGitConfig(memoryDir, "commit.gpgsign") === null) {
+    await setLocalGitConfig(memoryDir, "commit.gpgsign", "false");
+  }
 }
 async function stageMemoryPaths(memoryDir, pathspecs) {
   if (pathspecs.length === 0) {
@@ -392909,8 +393141,8 @@ function parsePorcelainPath(line) {
   return path31.replace(/^"|"$/g, "");
 }
 function describeMarkdownEncodingIssue(memoryDir, relativePath) {
-  const filePath = join38(memoryDir, relativePath);
-  if (!existsSync31(filePath)) {
+  const filePath = join39(memoryDir, relativePath);
+  if (!existsSync32(filePath)) {
     return null;
   }
   const bytes = readFileSync23(filePath);
@@ -392944,7 +393176,7 @@ async function commitMemoryWrite(params) {
   };
 }
 function isGitRepo(agentId) {
-  return existsSync31(join38(getScopedMemoryFilesystemRoot(agentId), ".git"));
+  return existsSync32(join39(getScopedMemoryFilesystemRoot(agentId), ".git"));
 }
 async function hasMemoryHead(memoryDir) {
   try {
@@ -392968,8 +393200,8 @@ async function getMemoryHeadRevision(memoryDir) {
   }
 }
 async function initializeLocalMemoryRepo(params) {
-  mkdirSync22(params.memoryDir, { recursive: true });
-  if (!existsSync31(join38(params.memoryDir, ".git"))) {
+  mkdirSync23(params.memoryDir, { recursive: true });
+  if (!existsSync32(join39(params.memoryDir, ".git"))) {
     await runGit3(params.memoryDir, ["init"]);
     await runGit3(params.memoryDir, ["symbolic-ref", "HEAD", "refs/heads/main"]);
   }
@@ -392989,9 +393221,9 @@ async function initializeLocalMemoryRepo(params) {
     if (!relativePath || relativePath.startsWith("/") || segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) {
       continue;
     }
-    const fullPath = join38(params.memoryDir, relativePath);
-    mkdirSync22(dirname20(fullPath), { recursive: true });
-    writeFileSync16(fullPath, file3.content, "utf8");
+    const fullPath = join39(params.memoryDir, relativePath);
+    mkdirSync23(dirname20(fullPath), { recursive: true });
+    writeFileSync17(fullPath, file3.content, "utf8");
     pathspecs.push(relativePath);
   }
   if (pathspecs.length > 0) {
@@ -393081,24 +393313,24 @@ async function cloneMemoryRepo(agentId) {
   const url2 = getMemoryRemoteUrl(agentId);
   const dir = getMemoryRepoDir(agentId);
   debugLog("memfs-git", `Cloning ${url2} → ${dir}`);
-  if (!existsSync31(dir)) {
-    mkdirSync22(dir, { recursive: true });
+  if (!existsSync32(dir)) {
+    mkdirSync23(dir, { recursive: true });
     await runGitWithRetry(dir, ["clone", url2, "."], token, {
       operation: "clone memory repo",
       timeoutMs: GIT_CLONE_TIMEOUT_MS
     });
-  } else if (!existsSync31(join38(dir, ".git"))) {
+  } else if (!existsSync32(join39(dir, ".git"))) {
     const tmpDir = `${dir}-git-clone-tmp`;
     try {
-      if (existsSync31(tmpDir)) {
+      if (existsSync32(tmpDir)) {
         rmSync5(tmpDir, { recursive: true, force: true });
       }
-      mkdirSync22(tmpDir, { recursive: true });
+      mkdirSync23(tmpDir, { recursive: true });
       await runGitWithRetry(tmpDir, ["clone", url2, "."], token, {
         operation: "clone memory repo (tmp migration)",
         timeoutMs: GIT_CLONE_TIMEOUT_MS
       });
-      renameSync2(join38(tmpDir, ".git"), join38(dir, ".git"));
+      renameSync2(join39(tmpDir, ".git"), join39(dir, ".git"));
       try {
         await runGit3(dir, ["rev-parse", "--verify", "HEAD"], token);
         await runGit3(dir, ["checkout", "--", "."], token);
@@ -393108,7 +393340,7 @@ async function cloneMemoryRepo(agentId) {
       }
       debugLog("memfs-git", "Migrated existing memory directory to git repo");
     } finally {
-      if (existsSync31(tmpDir)) {
+      if (existsSync32(tmpDir)) {
         rmSync5(tmpDir, { recursive: true, force: true });
       }
     }
@@ -393227,15 +393459,15 @@ function isUnmergedStatusCode(code2) {
 async function getMemoryGitDir(memoryDir) {
   const { stdout } = await runGit3(memoryDir, ["rev-parse", "--git-dir"]);
   const gitDir = stdout.trim() || ".git";
-  return isAbsolute20(gitDir) ? gitDir : join38(memoryDir, gitDir);
+  return isAbsolute20(gitDir) ? gitDir : join39(memoryDir, gitDir);
 }
 async function getMemoryConflictSummary(memoryDir, statusOut) {
   let operation = null;
   try {
     const gitDir = await getMemoryGitDir(memoryDir);
-    if (existsSync31(join38(gitDir, "MERGE_HEAD"))) {
+    if (existsSync32(join39(gitDir, "MERGE_HEAD"))) {
       operation = "merge in progress";
-    } else if (existsSync31(join38(gitDir, "rebase-merge")) || existsSync31(join38(gitDir, "rebase-apply"))) {
+    } else if (existsSync32(join39(gitDir, "rebase-merge")) || existsSync32(join39(gitDir, "rebase-apply"))) {
       operation = "rebase in progress";
     }
   } catch {
@@ -393278,7 +393510,7 @@ async function syncPendingMemoryCommitsAfterTurn(agentId, options3 = {}) {
   const backend = getBackend2();
   const localOnly = backend.capabilities.localMemfs && !backend.capabilities.remoteMemfs;
   const memoryDir = options3.memoryDir ?? getScopedMemoryFilesystemRoot(agentId);
-  if (!existsSync31(join38(memoryDir, ".git"))) {
+  if (!existsSync32(join39(memoryDir, ".git"))) {
     return {
       status: "skipped",
       summary: "Memory repo is not initialized.",
@@ -393404,164 +393636,7 @@ async function addGitMemoryTag(agentId, prefetchedAgent) {
     debugWarn("memfs-git", `Failed to add git-memory tag: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-var execFile5, RETRYABLE_GIT_HTTP_ERROR_RE, RETRYABLE_GIT_NETWORK_ERROR_RE, MISSING_CWD_GIT_ERROR_RE, NON_FAST_FORWARD_PUSH_ERROR_RE, UNRELATED_HISTORY_PULL_ERROR_RE, NO_UPSTREAM_PULL_ERROR_RE, AGENT_DISPLAY_NAME_TIMEOUT_MS = 3000, HOSTED_BACKEND_HEADER2 = "x-letta-memfs-backend", HOSTED_BACKEND_VALUE2 = "hosted", GIT_DEFAULT_TIMEOUT_MS = 60000, GIT_CLONE_TIMEOUT_MS = 180000, PRE_COMMIT_HOOK_SCRIPT = `#!/usr/bin/env bash
-# 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=""
-
-# Skills must always be directories: skills/<name>/SKILL.md
-# Reject legacy flat skill files (both current and legacy repo layouts).
-for file in $(git diff --cached --name-only --diff-filter=ACMR | grep -E '^(memory/)?skills/[^/]+\\.md$' || true); do
-  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
-done
-
-if [ -n "$errors" ]; then
-  echo "Frontmatter validation failed:"
-  echo -e "$errors"
-  exit 1
-fi
-`, POST_COMMIT_HOOK_SCRIPT = `#!/usr/bin/env bash
-# Letta Code: push memfs commits to the configured memory-repository remote.
-# Installed by Letta Code CLI. Do not edit by hand — regenerated on startup.
-url=$(git config --local --get letta.memoryRepository.url 2>/dev/null)
-[ -z "$url" ] && exit 0
-branch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || exit 0
-[ -z "$branch" ] && exit 0
-# Reflection and other harness worktrees commit on temporary branches; only the
-# main MemFS checkout should push to the optional memory repository remote.
-[ "$branch" != "main" ] && exit 0
-log="$(git rev-parse --git-dir)/memory-repository-push.log"
-(
-  {
-    printf '\\n--- %s %s on %s ---\\n' "$(date '+%Y-%m-%dT%H:%M:%S%z')" "$(git rev-parse --short HEAD)" "$branch"
-    git push --quiet "$url" "$branch":"$branch" 2>&1
-    echo "exit=$?"
-  } >> "$log" 2>&1
-) &
-disown 2>/dev/null || true
-exit 0
-`, MEMORY_REPOSITORY_CONFIG_KEY = "letta.memoryRepository.url", MEMORY_REPOSITORY_PUSH_LOG = "memory-repository-push.log";
+var execFile5, RETRYABLE_GIT_HTTP_ERROR_RE, RETRYABLE_GIT_NETWORK_ERROR_RE, MISSING_CWD_GIT_ERROR_RE, NON_FAST_FORWARD_PUSH_ERROR_RE, UNRELATED_HISTORY_PULL_ERROR_RE, NO_UPSTREAM_PULL_ERROR_RE, AGENT_DISPLAY_NAME_TIMEOUT_MS = 3000, HOSTED_BACKEND_HEADER2 = "x-letta-memfs-backend", HOSTED_BACKEND_VALUE2 = "hosted", GIT_DEFAULT_TIMEOUT_MS = 60000, GIT_CLONE_TIMEOUT_MS = 180000, MEMORY_REPOSITORY_CONFIG_KEY = "letta.memoryRepository.url", MEMORY_REPOSITORY_PUSH_LOG = "memory-repository-push.log";
 var init_memory_git = __esm(() => {
   init_client2();
   init_memfs_git_proxy();
@@ -393569,6 +393644,8 @@ var init_memory_git = __esm(() => {
   init_debug();
   init_text_files();
   init_memory_filesystem2();
+  init_memory_git_hooks();
+  init_memory_git_signing();
   execFile5 = promisify5(execFileCb);
   RETRYABLE_GIT_HTTP_ERROR_RE = /(?:\bHTTP\s+(?:520|521|522|523|524)\b|The requested URL returned error:\s*(?:520|521|522|523|524))/i;
   RETRYABLE_GIT_NETWORK_ERROR_RE = /(remote end hung up unexpectedly|connection reset by peer|operation timed out|timed out|SIGTERM|ETIMEDOUT)/i;
@@ -393932,6 +394009,9 @@ function providerTypeFromModelSettings2(modelSettings) {
   return typeof providerType === "string" && providerType.length > 0 ? providerType : null;
 }
 function normalizeLocalModelHandle(model, modelSettings, legacyLlmConfig) {
+  if (isResolvablePiModelHandle(model) || resolveRegisteredPiProviderFromModelHandle(model)) {
+    return model;
+  }
   const providerType = providerTypeFromModelSettings2(modelSettings);
   const legacyEndpointType = legacyLlmConfig?.model_endpoint_type;
   return resolveModelHandleFromLlmConfig({
@@ -393972,6 +394052,8 @@ function localLlmConfigModelPatch(model, modelSettings) {
 }
 var init_local_model_normalization = __esm(() => {
   init_model_handles();
+  init_pi_provider_mod_registry();
+  init_pi_provider_registry();
 });
 
 // src/backend/local/local-stream-chunks.ts
@@ -394010,17 +394092,17 @@ import { randomUUID as randomUUID18 } from "node:crypto";
 import {
   appendFileSync as appendFileSync4,
   closeSync,
-  existsSync as existsSync32,
-  mkdirSync as mkdirSync23,
+  existsSync as existsSync33,
+  mkdirSync as mkdirSync24,
   openSync,
   readdirSync as readdirSync11,
   readFileSync as readFileSync24,
   readSync,
   rmSync as rmSync6,
   statSync as statSync9,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "node:fs";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 function isStringArray2(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
@@ -394311,18 +394393,18 @@ function jsonl(items3) {
 `;
 }
 function readJsonFile2(path31) {
-  if (!existsSync32(path31))
+  if (!existsSync33(path31))
     return;
   return JSON.parse(readFileSync24(path31, "utf8"));
 }
 function readJsonlFile(path31) {
-  if (!existsSync32(path31))
+  if (!existsSync33(path31))
     return [];
   return readFileSync24(path31, "utf8").split(`
 `).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 function readJsonlFileSuffix(path31, maxBytes) {
-  if (!existsSync32(path31))
+  if (!existsSync33(path31))
     return { items: [], reachedStart: true };
   const size = statSync9(path31).size;
   if (size === 0)
@@ -394354,13 +394436,13 @@ function localTranscriptMigrationCommand(storageDir) {
   return `letta local-backend migrate-transcripts --storage-dir ${quotedStorageDir}`;
 }
 function transcriptManifestPath(conversationDir) {
-  return join39(conversationDir, "manifest.json");
+  return join40(conversationDir, "manifest.json");
 }
 function transcriptMessagesPath(conversationDir) {
-  return join39(conversationDir, "messages.jsonl");
+  return join40(conversationDir, "messages.jsonl");
 }
 function hasNonEmptyJsonl(path31) {
-  if (!existsSync32(path31))
+  if (!existsSync33(path31))
     return false;
   const stats = statSync9(path31);
   if (stats.size === 0)
@@ -394496,7 +394578,7 @@ function validateLocalTranscriptManifest(conversationDir, storageDir) {
   return manifest;
 }
 function writeLocalTranscriptManifest(conversationDir, manifest = createLocalTranscriptManifest()) {
-  writeFileSync17(transcriptManifestPath(conversationDir), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync18(transcriptManifestPath(conversationDir), `${JSON.stringify(manifest, null, 2)}
 `);
 }
 function numericSuffix(value, prefix) {
@@ -394513,7 +394595,7 @@ function fileIsoTimestamp(value) {
 }
 function transcriptTimingForConversationDir(conversationDir, manifest) {
   const messagesPath = transcriptMessagesPath(conversationDir);
-  const stats = existsSync32(messagesPath) ? statSync9(messagesPath) : undefined;
+  const stats = existsSync33(messagesPath) ? statSync9(messagesPath) : undefined;
   const manifestCreatedAt = parseIsoTimestamp(manifest?.created_at) !== null ? manifest?.created_at : undefined;
   const fileCreatedAt = fileIsoTimestamp(stats?.birthtimeMs);
   const fileUpdatedAt = fileIsoTimestamp(stats?.mtimeMs);
@@ -394677,7 +394759,7 @@ class LocalStore {
         this.persistedMessageByMessageIdByConversationKey.delete(key);
         this.lastSessionEntryIdByConversationKey.delete(key);
         if (this.storageDir) {
-          rmSync6(join39(this.storageDir, "conversations", encodePathSegment(key)), {
+          rmSync6(join40(this.storageDir, "conversations", encodePathSegment(key)), {
             recursive: true,
             force: true
           });
@@ -394685,7 +394767,7 @@ class LocalStore {
       }
     }
     if (this.storageDir) {
-      rmSync6(join39(this.storageDir, "agents", `${encodePathSegment(agentId)}.json`), { force: true });
+      rmSync6(join40(this.storageDir, "agents", `${encodePathSegment(agentId)}.json`), { force: true });
     }
   }
   retrieveAgentRecord(agentId) {
@@ -395008,7 +395090,7 @@ class LocalStore {
         continue;
       this.compiledSystemPromptByConversationKey.delete(key);
       if (this.storageDir) {
-        rmSync6(join39(this.storageDir, "conversations", encodePathSegment(key), "system-prompt.json"), { force: true });
+        rmSync6(join40(this.storageDir, "conversations", encodePathSegment(key), "system-prompt.json"), { force: true });
       }
     }
   }
@@ -395778,11 +395860,11 @@ class LocalStore {
     });
   }
   conversationsDir() {
-    return this.storageDir ? join39(this.storageDir, "conversations") : undefined;
+    return this.storageDir ? join40(this.storageDir, "conversations") : undefined;
   }
   conversationDirForKey(key) {
     const conversationsDir = this.conversationsDir();
-    return conversationsDir ? join39(conversationsDir, encodePathSegment(key)) : undefined;
+    return conversationsDir ? join40(conversationsDir, encodePathSegment(key)) : undefined;
   }
   updateConversationSequences(conversation) {
     this.conversationSeq = Math.max(this.conversationSeq, numericSuffix(conversation.id, this.conversationIdPrefix));
@@ -395801,7 +395883,7 @@ class LocalStore {
     const conversation = requiresFullTimestampRepair ? normalizedInput : repairSyntheticConversationTimestamps(normalizedInput, [], timing);
     let compiledSystemPrompt;
     try {
-      compiledSystemPrompt = readJsonFile2(join39(conversationDir, "system-prompt.json"));
+      compiledSystemPrompt = readJsonFile2(join40(conversationDir, "system-prompt.json"));
     } catch {
       compiledSystemPrompt = undefined;
     }
@@ -395820,7 +395902,7 @@ class LocalStore {
   }
   loadConversationRecordFromDir(conversationDir) {
     try {
-      const conversation = readJsonFile2(join39(conversationDir, "conversation.json"));
+      const conversation = readJsonFile2(join40(conversationDir, "conversation.json"));
       if (!conversation?.id || !conversation.agent_id)
         return;
       return this.cacheConversationRecord(conversationDir, conversation);
@@ -395830,7 +395912,7 @@ class LocalStore {
   }
   conversationRecordMtimeMs(conversationDir) {
     try {
-      return statSync9(join39(conversationDir, "conversation.json")).mtimeMs;
+      return statSync9(join40(conversationDir, "conversation.json")).mtimeMs;
     } catch {
       return;
     }
@@ -395856,7 +395938,7 @@ class LocalStore {
       return existing;
     }
     try {
-      const conversation = readJsonFile2(join39(conversationDir, "conversation.json"));
+      const conversation = readJsonFile2(join40(conversationDir, "conversation.json"));
       if (!conversation?.id || !conversation.agent_id)
         return existing;
       const loadedKey = this.conversationKey(conversation.id, conversation.agent_id);
@@ -395875,7 +395957,7 @@ class LocalStore {
       return;
     this.conversationRecordsScanned = true;
     const conversationsDir = this.conversationsDir();
-    if (!conversationsDir || !existsSync32(conversationsDir))
+    if (!conversationsDir || !existsSync33(conversationsDir))
       return;
     let entries;
     try {
@@ -395884,7 +395966,7 @@ class LocalStore {
       return;
     }
     for (const entry of entries) {
-      const conversationDir = join39(conversationsDir, entry);
+      const conversationDir = join40(conversationsDir, entry);
       try {
         if (!statSync9(conversationDir).isDirectory())
           continue;
@@ -395900,14 +395982,14 @@ class LocalStore {
     }
   }
   loadFromStorage() {
-    if (!this.storageDir || !existsSync32(this.storageDir))
+    if (!this.storageDir || !existsSync33(this.storageDir))
       return;
-    const agentsDir = join39(this.storageDir, "agents");
-    if (existsSync32(agentsDir)) {
+    const agentsDir = join40(this.storageDir, "agents");
+    if (existsSync33(agentsDir)) {
       for (const file3 of readdirSync11(agentsDir)) {
         if (!file3.endsWith(".json"))
           continue;
-        const raw = readJsonFile2(join39(agentsDir, file3));
+        const raw = readJsonFile2(join40(agentsDir, file3));
         const agent2 = normalizeAgentRecord(raw, this.defaultAgentModel);
         if (agent2?.id) {
           this.agents.set(agent2.id, agent2);
@@ -395924,9 +396006,9 @@ class LocalStore {
     const agent2 = this.agents.get(agentId);
     if (!agent2)
       return;
-    const agentsDir = join39(this.storageDir, "agents");
-    mkdirSync23(agentsDir, { recursive: true });
-    writeFileSync17(join39(agentsDir, `${encodePathSegment(agentId)}.json`), `${JSON.stringify(agent2, null, 2)}
+    const agentsDir = join40(this.storageDir, "agents");
+    mkdirSync24(agentsDir, { recursive: true });
+    writeFileSync18(join40(agentsDir, `${encodePathSegment(agentId)}.json`), `${JSON.stringify(agent2, null, 2)}
 `);
   }
   projectAgent(record5) {
@@ -395943,15 +396025,15 @@ class LocalStore {
     const conversation = this.conversations.get(key);
     if (!conversation)
       return;
-    const conversationDir = join39(this.storageDir, "conversations", encodePathSegment(key));
-    mkdirSync23(conversationDir, { recursive: true });
-    writeFileSync17(join39(conversationDir, "conversation.json"), `${JSON.stringify(conversation, null, 2)}
+    const conversationDir = join40(this.storageDir, "conversations", encodePathSegment(key));
+    mkdirSync24(conversationDir, { recursive: true });
+    writeFileSync18(join40(conversationDir, "conversation.json"), `${JSON.stringify(conversation, null, 2)}
 `);
     this.recordConversationRecordMtime(key, conversationDir);
     const messagesPath = transcriptMessagesPath(conversationDir);
     let metadata = this.transcriptMetadataRecord(key, conversationDir);
     const manifestPath = transcriptManifestPath(conversationDir);
-    if (!existsSync32(manifestPath) && !hasNonEmptyJsonl(messagesPath)) {
+    if (!existsSync33(manifestPath) && !hasNonEmptyJsonl(messagesPath)) {
       const manifest = createLocalTranscriptManifest();
       writeLocalTranscriptManifest(conversationDir, manifest);
       metadata = this.setTranscriptMetadata(key, {
@@ -395970,7 +396052,7 @@ class LocalStore {
   persistConversationTranscript(key, conversation, conversationDir, messagesPath, messageFormat, options3) {
     if (options3.transcript === "skip")
       return;
-    if (options3.transcript === undefined && this.loadRepairedConversationKeys.has(key) && existsSync32(messagesPath)) {
+    if (options3.transcript === undefined && this.loadRepairedConversationKeys.has(key) && existsSync33(messagesPath)) {
       return;
     }
     const messages = this.localMessagesByConversationKey.get(key) ?? [];
@@ -396005,7 +396087,7 @@ class LocalStore {
       this.appendConversationSessionCompactionEntry(key, conversation, messagesPath, options3.compaction);
       return;
     }
-    if (options3.transcript === "rewrite" || this.loadedConversationKeys.has(key) || !existsSync32(messagesPath)) {
+    if (options3.transcript === "rewrite" || this.loadedConversationKeys.has(key) || !existsSync33(messagesPath)) {
       if (messages.length === 0)
         return;
       this.rewriteConversationSessionTranscript(key, conversation, messagesPath, messages);
@@ -396016,7 +396098,7 @@ class LocalStore {
     if (messages.length === 0)
       return;
     const entries = localTranscriptSessionEntries(conversation, messages);
-    writeFileSync17(messagesPath, jsonl(entries));
+    writeFileSync18(messagesPath, jsonl(entries));
     this.resetPersistedSessionStateFromEntries(key, entries);
   }
   appendConversationSessionMessageEntry(key, conversation, messagesPath, message) {
@@ -396066,9 +396148,9 @@ class LocalStore {
     this.lastSessionEntryIdByConversationKey.set(key, entry.id);
   }
   ensureConversationTranscriptHeader(conversation, messagesPath) {
-    if (existsSync32(messagesPath) && statSync9(messagesPath).size > 0)
+    if (existsSync33(messagesPath) && statSync9(messagesPath).size > 0)
       return;
-    writeFileSync17(messagesPath, `${JSON.stringify(createLocalTranscriptSessionHeader(conversation))}
+    writeFileSync18(messagesPath, `${JSON.stringify(createLocalTranscriptSessionHeader(conversation))}
 `);
   }
   resetPersistedSessionState(key, messageFormat, transcript) {
@@ -396125,9 +396207,9 @@ class LocalStore {
     const prompt = this.compiledSystemPromptByConversationKey.get(key);
     if (!prompt)
       return;
-    const conversationDir = join39(this.storageDir, "conversations", encodePathSegment(key));
-    mkdirSync23(conversationDir, { recursive: true });
-    writeFileSync17(join39(conversationDir, "system-prompt.json"), `${JSON.stringify(prompt, null, 2)}
+    const conversationDir = join40(this.storageDir, "conversations", encodePathSegment(key));
+    mkdirSync24(conversationDir, { recursive: true });
+    writeFileSync18(join40(conversationDir, "system-prompt.json"), `${JSON.stringify(prompt, null, 2)}
 `);
   }
   ensureConversation(conversationId, agentId) {
@@ -396156,7 +396238,7 @@ class LocalStore {
       if (this.conversations.has(key))
         continue;
       const conversationDir = this.conversationDirForKey(key);
-      if (conversationDir && existsSync32(conversationDir))
+      if (conversationDir && existsSync33(conversationDir))
         continue;
       return conversationId;
     }
@@ -398846,11 +398928,21 @@ async function listLocalModels(storageDir, options3 = {}) {
       return;
     const modelSettings = localModelSettingsForHandle(handle);
     const maxContextWindow = options4.maxContextWindow ?? (typeof modelSettings?.context_window_limit === "number" ? modelSettings.context_window_limit : undefined);
+    const maxOutputTokens = options4.maxOutputTokens ?? (typeof modelSettings?.max_tokens === "number" ? modelSettings.max_tokens : undefined);
+    const modelId = typeof provider === "string" && isPiProvider(provider) ? stripProviderHandlePrefix(handle, provider) ?? model : model;
+    const providerSpec = isPiProvider(provider) ? getPiProviderSpec(provider) : undefined;
+    const catalogModel = providerSpec?.piProvider ? getModels(providerSpec.piProvider).find((entry) => entry.id === modelId) : undefined;
+    const providerType = options4.modelEndpointType ?? localProviderTypeForModelConfig(provider);
+    const name = options4.name ?? catalogModel?.name ?? modelId;
     models3.push({
+      display_name: name,
       handle,
       ...maxContextWindow ? { max_context_window: maxContextWindow } : {},
+      ...maxOutputTokens ? { max_tokens: maxOutputTokens } : {},
       model: handle,
-      model_endpoint_type: options4.modelEndpointType ?? localProviderTypeForModelConfig(provider)
+      model_endpoint_type: providerType,
+      name,
+      provider_type: providerType
     });
   };
   for (const provider of registeredProviders2) {
@@ -398864,7 +398956,9 @@ async function listLocalModels(storageDir, options3 = {}) {
         addModel(provider.providerName, model.id, {
           handle: `${provider.providerName}/${model.id}`,
           maxContextWindow: model.contextWindow,
-          modelEndpointType: provider.providerName
+          maxOutputTokens: model.maxTokens,
+          modelEndpointType: provider.providerName,
+          name: model.name
         });
       }
     } catch {
@@ -398872,7 +398966,9 @@ async function listLocalModels(storageDir, options3 = {}) {
         addModel(provider.providerName, model.id, {
           handle: `${provider.providerName}/${model.id}`,
           maxContextWindow: model.contextWindow,
-          modelEndpointType: provider.providerName
+          maxOutputTokens: model.maxTokens,
+          modelEndpointType: provider.providerName,
+          name: model.name
         });
       }
     }
@@ -400397,7 +400493,7 @@ Keep your summary under ${SLIDING_WORD_LIMIT} words. Only output the summary.`;
 // src/backend/local/system-prompt-compilation.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync33 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { basename as basename16, dirname as dirname21, relative as relative6 } from "node:path";
 function hashString(value) {
   return createHash4("sha256").update(value).digest("hex");
@@ -400419,7 +400515,7 @@ function gitOutput(memoryDir, args) {
   });
 }
 function getCommittedMemfsRevision(memoryDir) {
-  if (!existsSync33(memoryDir))
+  if (!existsSync34(memoryDir))
     return;
   try {
     const revision = gitOutput(memoryDir, [
@@ -438685,9 +438781,9 @@ var init_paste_registry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync35, readFileSync as readFileSync26, statSync as statSync10, unlinkSync as unlinkSync5 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync26, statSync as statSync10, unlinkSync as unlinkSync5 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
-import { basename as basename18, extname as extname10, isAbsolute as isAbsolute21, join as join40, resolve as resolve29 } from "node:path";
+import { basename as basename18, extname as extname10, isAbsolute as isAbsolute21, join as join41, resolve as resolve29 } from "node:path";
 function countLines(text2) {
   return (text2.match(/\r\n|\r|\n/g) || []).length + 1;
 }
@@ -438777,7 +438873,7 @@ function translatePasteForImages(paste) {
 function getClipboardImageToTempFile() {
   if (process.platform !== "darwin")
     return null;
-  const tempPath = join40(tmpdir7(), `letta-clipboard-${Date.now()}.bin`);
+  const tempPath = join41(tmpdir7(), `letta-clipboard-${Date.now()}.bin`);
   try {
     const jxa = `
       ObjC.import('AppKit');
@@ -438800,11 +438896,11 @@ function getClipboardImageToTempFile() {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    if (!uti || !existsSync35(tempPath))
+    if (!uti || !existsSync36(tempPath))
       return null;
     return { tempPath, uti };
   } catch {
-    if (existsSync35(tempPath)) {
+    if (existsSync36(tempPath)) {
       try {
         unlinkSync5(tempPath);
       } catch {}
@@ -438837,7 +438933,7 @@ async function tryImportClipboardImageMac() {
       height: resized.height
     };
   } catch (err) {
-    if (existsSync35(tempPath)) {
+    if (existsSync36(tempPath)) {
       try {
         unlinkSync5(tempPath);
       } catch {}
@@ -439320,18 +439416,18 @@ var init_local = __esm(() => {
 });
 
 // src/cli/helpers/local-agent-listing.ts
-import { existsSync as existsSync37, readdirSync as readdirSync13, readFileSync as readFileSync27, statSync as statSync12 } from "node:fs";
-import { join as join42 } from "node:path";
+import { existsSync as existsSync38, readdirSync as readdirSync13, readFileSync as readFileSync27, statSync as statSync12 } from "node:fs";
+import { join as join43 } from "node:path";
 function listLocalAgentsFromDisk() {
   const storageDir = getLocalBackendStorageDir();
-  const agentsDir = join42(storageDir, "agents");
-  if (!existsSync37(agentsDir))
+  const agentsDir = join43(storageDir, "agents");
+  if (!existsSync38(agentsDir))
     return [];
   const files = readdirSync13(agentsDir).filter((f4) => f4.endsWith(".json"));
   const agents = [];
   for (const file3 of files) {
     try {
-      const filePath = join42(agentsDir, file3);
+      const filePath = join43(agentsDir, file3);
       const raw2 = readFileSync27(filePath, "utf8");
       const record5 = JSON.parse(raw2);
       if (isHiddenLocalAgentRecord(record5))
@@ -440049,23 +440145,23 @@ __export(exports_personality, {
   applyPersonalityToMemory: () => applyPersonalityToMemory
 });
 import { execFile as execFileCb3 } from "node:child_process";
-import { existsSync as existsSync38, mkdirSync as mkdirSync25, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname22, join as join43 } from "node:path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync26, readFileSync as readFileSync28, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname22, join as join44 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 function ensureTrailingNewline2(content) {
   return `${content.trimEnd()}
 `;
 }
 function getMemoryFileRelativePathForRepo(repoDir, primaryRelativePath, legacyRelativePath) {
-  const primaryPath = join43(repoDir, primaryRelativePath);
-  if (existsSync38(primaryPath)) {
+  const primaryPath = join44(repoDir, primaryRelativePath);
+  if (existsSync39(primaryPath)) {
     return primaryRelativePath;
   }
-  const legacyPath = join43(repoDir, legacyRelativePath);
-  if (existsSync38(legacyPath)) {
+  const legacyPath = join44(repoDir, legacyRelativePath);
+  if (existsSync39(legacyPath)) {
     return legacyRelativePath;
   }
-  if (existsSync38(join43(repoDir, "memory"))) {
+  if (existsSync39(join44(repoDir, "memory"))) {
     return legacyRelativePath;
   }
   return primaryRelativePath;
@@ -440175,15 +440271,15 @@ async function getMemoryCommitAuthor(agentId) {
 function applyPersonalityFiles(filesToUpdate) {
   const changedPaths = [];
   for (const file3 of filesToUpdate) {
-    const existingContent = existsSync38(file3.absolutePath) ? readFileSync28(file3.absolutePath, "utf-8") : null;
+    const existingContent = existsSync39(file3.absolutePath) ? readFileSync28(file3.absolutePath, "utf-8") : null;
     const nextContent = existingContent ? replaceBodyPreservingFrontmatter(existingContent, file3.content, {
       description: file3.description
     }) : buildDefaultMemoryFile(file3.templatePromptAssetName, file3.content, file3.description);
     if (existingContent !== null && normalizeComparableContent(existingContent) === normalizeComparableContent(nextContent)) {
       continue;
     }
-    mkdirSync25(dirname22(file3.absolutePath), { recursive: true });
-    writeFileSync18(file3.absolutePath, nextContent, "utf-8");
+    mkdirSync26(dirname22(file3.absolutePath), { recursive: true });
+    writeFileSync19(file3.absolutePath, nextContent, "utf-8");
     changedPaths.push(file3.relativePath);
   }
   return changedPaths;
@@ -440205,8 +440301,8 @@ async function applyPersonalityToMemory(params) {
   }
   const personaRelativePath = getPersonaRelativePathForRepo(repoDir);
   const humanRelativePath = getHumanRelativePathForRepo(repoDir);
-  const personaPath = join43(repoDir, personaRelativePath);
-  const humanPath = join43(repoDir, humanRelativePath);
+  const personaPath = join44(repoDir, personaRelativePath);
+  const humanPath = join44(repoDir, humanRelativePath);
   const filesToUpdate = [
     {
       relativePath: personaRelativePath,
@@ -440645,13 +440741,14 @@ var init_progress_builder = __esm(async () => {
 // src/agent/memory-worktree.ts
 import { execFile as execFileCb4 } from "node:child_process";
 import { randomUUID as randomUUID21 } from "node:crypto";
-import { existsSync as existsSync39 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 import { mkdir as mkdir11, realpath as realpath4 } from "node:fs/promises";
-import { dirname as dirname23, isAbsolute as isAbsolute23, join as join44, relative as relative7, resolve as resolve30 } from "node:path";
+import { dirname as dirname23, isAbsolute as isAbsolute23, join as join45, relative as relative7, resolve as resolve30 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 async function runGit4(cwd2, args) {
   try {
-    const { stdout, stderr } = await execFile8("git", args, {
+    const allArgs = [...GIT_DISABLE_COMMIT_SIGNING_ARGS, ...args];
+    const { stdout, stderr } = await execFile8("git", allArgs, {
       cwd: cwd2,
       env: {
         ...process.env,
@@ -440706,8 +440803,8 @@ async function buildReflectionMergeMessage(parentMemoryDir, branchName) {
 async function createReflectionMemoryWorktree(options3) {
   const parentMemoryDir = resolve30(options3.parentMemoryDir);
   const id2 = buildReflectionWorktreeId(options3.now);
-  const worktreeBaseDir = join44(dirname23(parentMemoryDir), "memory-worktrees");
-  const worktreeDir = join44(worktreeBaseDir, `reflection-${id2}`);
+  const worktreeBaseDir = join45(dirname23(parentMemoryDir), "memory-worktrees");
+  const worktreeDir = join45(worktreeBaseDir, `reflection-${id2}`);
   const branchName = `letta/reflection/${id2}`;
   await mkdir11(worktreeBaseDir, { recursive: true });
   const { stdout: baseHeadOut } = await runGit4(parentMemoryDir, [
@@ -440824,7 +440921,7 @@ function parseWorktreeListPorcelain(output) {
 }
 async function listPendingReflectionMemoryWorktrees(parentMemoryDir) {
   const resolvedParent = await realpath4(resolve30(parentMemoryDir));
-  const worktreeBaseDir = join44(dirname23(resolvedParent), "memory-worktrees");
+  const worktreeBaseDir = join45(dirname23(resolvedParent), "memory-worktrees");
   const worktreeList = await tryRunGit(resolvedParent, [
     "worktree",
     "list",
@@ -440915,7 +441012,7 @@ async function integratePendingReflectionMemoryWorktrees(parentMemoryDir) {
   return unresolved;
 }
 async function cleanupWorktreeAndBranch(parentMemoryDir, worktreeDir, branchName, options3 = {}) {
-  const removedWorktree = existsSync39(worktreeDir);
+  const removedWorktree = existsSync40(worktreeDir);
   if (removedWorktree) {
     await runGit4(parentMemoryDir, [
       "worktree",
@@ -441026,6 +441123,7 @@ async function finalizeReflectionMemoryWorktree(worktree, options3) {
 }
 var execFile8, GIT_TIMEOUT_MS = 30000, HARNESS_GIT_ENV;
 var init_memory_worktree = __esm(() => {
+  init_memory_git_signing();
   init_debug();
   execFile8 = promisify8(execFileCb4);
   HARNESS_GIT_ENV = {
@@ -441292,7 +441390,7 @@ import {
   stat as stat11,
   writeFile as writeFile13
 } from "node:fs/promises";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 function buildReflectionSubagentPrompt(input) {
   const lines = [];
   lines.push('Review the conversation transcript payload and update memory files. The payload path is available as the `$TRANSCRIPT_PATH` env var — read it via Bash (e.g. `wc -c "$TRANSCRIPT_PATH"`). Note: `$TRANSCRIPT_PATH` only expands in shell commands; Edit `file_path` is literal and does NOT expand env vars.', "", 'The payload may be either a JSON message array for one conversation or a `multi_transcript_reflection_payload` manifest. If it is a manifest, read each `payload_path` listed in `transcripts` and synthesize across all conversations. Entries with `mode: "replay"` were already reflected before and are included intentionally for re-review/deduplication; do not ignore them just because they are replay slices.', "When reviewing multiple transcripts, prefer durable patterns and latest evidence across sessions. Resolve contradictions by updating stale memory at the source, deduplicate repeated facts, and avoid storing one-off task state.", "", "The primary agent's memory filesystem is available through the `$MEMORY_DIR` environment variable.", "Run git add or git commit commands only from $MEMORY_DIR; the harness handles integration after your commit. If these fail, stop reflecting and report the failure. All other git commands are out of your purview.", 'When using Edit, first resolve the absolute file path from `$MEMORY_DIR` with Bash (for example: `printf "%s/system/persona.md\\n" "$MEMORY_DIR"`) and use the printed path. Do not hardcode memory paths from the prompt.', "In-context memory (in the parent agent's system prompt) is stored in the `system/` folder and are rendered in <memory> tags below. Modification to files in `system/` will edit the parent agent's system prompt.", "Additional memory files (such as skills and external memory) may also be read and modified.", "");
@@ -441338,7 +441436,7 @@ async function collectParentMemoryFiles(memoryDir) {
       return a2.name.localeCompare(b3.name);
     });
     for (const entry of sortedEntries) {
-      const entryPath = join45(currentDir, entry.name);
+      const entryPath = join46(currentDir, entry.name);
       const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         await walk(entryPath, relativePath);
@@ -441784,17 +441882,17 @@ async function writeState(paths, state) {
 }
 function buildPayloadPath(rootDir, kind) {
   const nonce = Math.random().toString(36).slice(2, 8);
-  return join45(rootDir, `payload-${kind}-${nonce}.json`);
+  return join46(rootDir, `payload-${kind}-${nonce}.json`);
 }
 function getAgentTranscriptRoot(agentId) {
-  return join45(getTranscriptRoot(), sanitizePathSegment2(agentId));
+  return join46(getTranscriptRoot(), sanitizePathSegment2(agentId));
 }
 function getReflectionTranscriptPaths(agentId, conversationId) {
-  const rootDir = join45(getTranscriptRoot(), sanitizePathSegment2(agentId), sanitizePathSegment2(conversationId));
+  const rootDir = join46(getTranscriptRoot(), sanitizePathSegment2(agentId), sanitizePathSegment2(conversationId));
   return {
     rootDir,
-    transcriptPath: join45(rootDir, "transcript.jsonl"),
-    statePath: join45(rootDir, "state.json")
+    transcriptPath: join46(rootDir, "transcript.jsonl"),
+    statePath: join46(rootDir, "state.json")
   };
 }
 async function appendTranscriptDeltaJsonl(agentId, conversationId, lines) {
@@ -441963,7 +442061,7 @@ async function getTranscriptLastUpdatedAt(paths) {
   }
 }
 async function ensureAgentPayloadRoot(agentId) {
-  const root2 = join45(getAgentTranscriptRoot(agentId), "multi-reflection-payloads");
+  const root2 = join46(getAgentTranscriptRoot(agentId), "multi-reflection-payloads");
   await mkdir12(root2, { recursive: true });
   return root2;
 }
@@ -443910,25 +444008,25 @@ var init_parse_interval = __esm(() => {
 // src/cron/cron-file.ts
 import { randomBytes } from "node:crypto";
 import {
-  existsSync as existsSync40,
-  mkdirSync as mkdirSync26,
+  existsSync as existsSync41,
+  mkdirSync as mkdirSync27,
   readFileSync as readFileSync29,
   renameSync as renameSync4,
   rmSync as rmSync8,
   statSync as statSync13,
-  writeFileSync as writeFileSync19
+  writeFileSync as writeFileSync20
 } from "node:fs";
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 function getLettaDir() {
   if (process.env.LETTA_HOME)
     return process.env.LETTA_HOME;
-  return join46(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".letta");
+  return join47(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".letta");
 }
 function getCronFilePath() {
-  return join46(getLettaDir(), CRON_FILE_NAME);
+  return join47(getLettaDir(), CRON_FILE_NAME);
 }
 function getLockDirPath() {
-  return join46(getLettaDir(), LOCK_DIR_NAME);
+  return join47(getLettaDir(), LOCK_DIR_NAME);
 }
 function emptyFile() {
   return {
@@ -443958,7 +444056,7 @@ function normalizeCronFileData(data) {
 }
 function readCronFile() {
   const path31 = getCronFilePath();
-  if (!existsSync40(path31))
+  if (!existsSync41(path31))
     return emptyFile();
   try {
     const raw2 = readFileSync29(path31, "utf-8");
@@ -443973,11 +444071,11 @@ function readCronFile() {
 function writeCronFile(data) {
   const path31 = getCronFilePath();
   const dir = getLettaDir();
-  if (!existsSync40(dir)) {
-    mkdirSync26(dir, { recursive: true });
+  if (!existsSync41(dir)) {
+    mkdirSync27(dir, { recursive: true });
   }
   const tmp = `${path31}.tmp`;
-  writeFileSync19(tmp, JSON.stringify(data, null, 2), { flush: true });
+  writeFileSync20(tmp, JSON.stringify(data, null, 2), { flush: true });
   renameSync4(tmp, path31);
 }
 function readLinuxProcessIdentity(pid) {
@@ -444035,14 +444133,14 @@ function isProcessAlive(pid, owner) {
 }
 function readLockOwner(lockDir) {
   try {
-    const raw2 = readFileSync29(join46(lockDir, LOCK_TOKEN_FILE), "utf-8");
+    const raw2 = readFileSync29(join47(lockDir, LOCK_TOKEN_FILE), "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
   }
 }
 function writeLockOwner(lockDir, owner) {
-  writeFileSync19(join46(lockDir, LOCK_TOKEN_FILE), JSON.stringify(owner));
+  writeFileSync20(join47(lockDir, LOCK_TOKEN_FILE), JSON.stringify(owner));
 }
 function isLockStale(lockDir) {
   const owner = readLockOwner(lockDir);
@@ -444069,7 +444167,7 @@ function acquireLock() {
   const token2 = randomBytes(4).toString("hex");
   while (Date.now() < deadline) {
     try {
-      mkdirSync26(lockDir, { recursive: false });
+      mkdirSync27(lockDir, { recursive: false });
       const owner = {
         pid: process.pid,
         token: token2,
@@ -444314,11 +444412,11 @@ var init_cron_file = __esm(() => {
 import {
   appendFileSync as appendFileSync5,
   chmodSync as chmodSync6,
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync27,
+  existsSync as existsSync42,
+  mkdirSync as mkdirSync28,
   readFileSync as readFileSync30,
   statSync as statSync14,
-  writeFileSync as writeFileSync20
+  writeFileSync as writeFileSync21
 } from "node:fs";
 import path31 from "node:path";
 function assertSafeCronRunLogJobId(jobId) {
@@ -444368,7 +444466,7 @@ function pruneIfNeeded(filePath, opts) {
   const lines = raw2.split(`
 `).map((line) => line.trim()).filter(Boolean);
   const kept = lines.slice(Math.max(0, lines.length - opts.keepLines));
-  writeFileSync20(filePath, `${kept.join(`
+  writeFileSync21(filePath, `${kept.join(`
 `)}
 `, { mode: 384 });
   setSecureFileMode(filePath);
@@ -444376,8 +444474,8 @@ function pruneIfNeeded(filePath, opts) {
 function appendCronRunLog(filePath, entry, opts) {
   const resolved = path31.resolve(filePath);
   const runDir = path31.dirname(resolved);
-  if (!existsSync41(runDir)) {
-    mkdirSync27(runDir, { recursive: true, mode: 448 });
+  if (!existsSync42(runDir)) {
+    mkdirSync28(runDir, { recursive: true, mode: 448 });
   }
   setSecureDirMode(runDir);
   appendFileSync5(resolved, `${JSON.stringify(entry)}
@@ -445693,9 +445791,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync42 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import { readdir as readdir9, readFile as readFile16 } from "node:fs/promises";
-import { basename as basename20, dirname as dirname24, join as join47 } from "node:path";
+import { basename as basename20, dirname as dirname24, join as join48 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -445706,7 +445804,7 @@ async function getCustomCommands() {
 function refreshCustomCommands() {
   cachedCommands = null;
 }
-async function discoverCustomCommands(projectPath = join47(process.cwd(), COMMANDS_DIR)) {
+async function discoverCustomCommands(projectPath = join48(process.cwd(), COMMANDS_DIR)) {
   const commandsById = new Map;
   const userCommands = await discoverFromDirectory(GLOBAL_COMMANDS_DIR, "user");
   for (const cmd of userCommands) {
@@ -445727,7 +445825,7 @@ async function discoverCustomCommands(projectPath = join47(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source2) {
-  if (!existsSync42(dirPath)) {
+  if (!existsSync43(dirPath)) {
     return [];
   }
   const commands = [];
@@ -445738,7 +445836,7 @@ async function findCommandFiles(currentPath, rootPath, commands, source2) {
   try {
     const entries = await readdir9(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join47(currentPath, entry.name);
+      const fullPath = join48(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findCommandFiles(fullPath, rootPath, commands, source2);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -445823,7 +445921,7 @@ async function findCustomCommand(commandName) {
 }
 var COMMANDS_DIR = ".commands", GLOBAL_COMMANDS_DIR, cachedCommands = null;
 var init_custom = __esm(() => {
-  GLOBAL_COMMANDS_DIR = join47(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
+  GLOBAL_COMMANDS_DIR = join48(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
 });
 
 // src/cli/helpers/init-command.ts
@@ -445913,7 +446011,7 @@ var init_init_command = __esm(() => {
 
 // src/cli/helpers/skill-name-frontmatter-repair.ts
 import { readdir as readdir10, readFile as readFile17, stat as stat12, writeFile as writeFile14 } from "node:fs/promises";
-import { basename as basename21, dirname as dirname25, join as join48, relative as relative8 } from "node:path";
+import { basename as basename21, dirname as dirname25, join as join49, relative as relative8 } from "node:path";
 async function pathExists(path32) {
   try {
     await stat12(path32);
@@ -445929,7 +446027,7 @@ async function findSkillMarkdownFiles(root2) {
     if (entry.name === ".git" || entry.name === "node_modules") {
       continue;
     }
-    const fullPath = join48(root2, entry.name);
+    const fullPath = join49(root2, entry.name);
     if (entry.isSymbolicLink()) {
       continue;
     }
@@ -446001,7 +446099,7 @@ async function repairMissingSkillNameFrontmatter(memoryDir) {
   if (!memoryDir) {
     return result;
   }
-  const skillsDir = join48(memoryDir, "skills");
+  const skillsDir = join49(memoryDir, "skills");
   if (!await pathExists(skillsDir)) {
     return result;
   }
@@ -449003,7 +449101,7 @@ var init_accumulator = __esm(async () => {
 });
 
 // src/utils/tui-perf.ts
-import { appendFileSync as appendFileSync6, mkdirSync as mkdirSync28 } from "node:fs";
+import { appendFileSync as appendFileSync6, mkdirSync as mkdirSync29 } from "node:fs";
 import { dirname as dirname26 } from "node:path";
 function ensureExitHook() {
   if (tuiPerfExitHookRegistered) {
@@ -449095,7 +449193,7 @@ function flushTuiPerfTelemetry() {
   try {
     const dir = dirname26(filePath);
     if (tuiPerfFileDirEnsured !== dir) {
-      mkdirSync28(dir, { recursive: true });
+      mkdirSync29(dir, { recursive: true });
       tuiPerfFileDirEnsured = dir;
     }
     appendFileSync6(filePath, `${JSON.stringify({
@@ -449126,14 +449224,14 @@ var init_tui_perf = __esm(() => {
 
 // src/cli/helpers/chunk-log.ts
 import {
-  existsSync as existsSync43,
-  mkdirSync as mkdirSync29,
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync30,
   readdirSync as readdirSync14,
   unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync21
+  writeFileSync as writeFileSync22
 } from "node:fs";
 import { homedir as homedir29 } from "node:os";
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 function truncateStr(value, maxLen) {
   if (value === null || value === undefined)
     return "";
@@ -449197,8 +449295,8 @@ class ChunkLog {
   agentDir = null;
   dirCreated = false;
   init(agentId, sessionId) {
-    this.agentDir = join49(LOG_BASE_DIR, agentId);
-    this.logPath = join49(this.agentDir, `${sessionId}.jsonl`);
+    this.agentDir = join50(LOG_BASE_DIR, agentId);
+    this.logPath = join50(this.agentDir, `${sessionId}.jsonl`);
     this.buffer = [];
     this.dirty = false;
     this.dirCreated = false;
@@ -449227,8 +449325,8 @@ class ChunkLog {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync43(this.agentDir)) {
-        mkdirSync29(this.agentDir, { recursive: true });
+      if (!existsSync44(this.agentDir)) {
+        mkdirSync30(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
     } catch (e2) {
@@ -449242,7 +449340,7 @@ class ChunkLog {
     try {
       const content = this.buffer.map((entry) => JSON.stringify(entry)).join(`
 `);
-      writeFileSync21(this.logPath, `${content}
+      writeFileSync22(this.logPath, `${content}
 `, "utf8");
     } catch (e2) {
       debugWarn("chunkLog", `Failed to write ${this.logPath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
@@ -449252,14 +449350,14 @@ class ChunkLog {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync43(this.agentDir))
+      if (!existsSync44(this.agentDir))
         return;
       const files = readdirSync14(this.agentDir).filter((f4) => f4.endsWith(".jsonl")).sort();
       if (files.length >= MAX_SESSION_FILES2) {
         const toDelete = files.slice(0, files.length - MAX_SESSION_FILES2 + 1);
         for (const file3 of toDelete) {
           try {
-            unlinkSync6(join49(this.agentDir, file3));
+            unlinkSync6(join50(this.agentDir, file3));
           } catch (e2) {
             debugWarn("chunkLog", `Failed to delete old session log ${file3}: ${e2 instanceof Error ? e2.message : String(e2)}`);
           }
@@ -449273,7 +449371,7 @@ class ChunkLog {
 var MAX_ENTRIES = 100, CONTENT_TRUNCATE_LEN = 200, MAX_SESSION_FILES2 = 5, LOG_BASE_DIR, chunkLog;
 var init_chunk_log = __esm(() => {
   init_debug();
-  LOG_BASE_DIR = join49(homedir29(), ".letta", "logs", "chunk-logs");
+  LOG_BASE_DIR = join50(homedir29(), ".letta", "logs", "chunk-logs");
   chunkLog = new ChunkLog;
 });
 
@@ -458716,7 +458814,7 @@ var init_commands2 = __esm(async () => {
 });
 
 // src/channels/custom/scaffolding.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync30, rmSync as rmSync9, writeFileSync as writeFileSync22 } from "node:fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync31, rmSync as rmSync9, writeFileSync as writeFileSync23 } from "node:fs";
 function removeUserPlugin(channelId) {
   if (FIRST_PARTY_SET.has(channelId)) {
     return;
@@ -458725,7 +458823,7 @@ function removeUserPlugin(channelId) {
     return;
   }
   const channelDir = getChannelDir(channelId);
-  if (!existsSync44(channelDir)) {
+  if (!existsSync45(channelDir)) {
     return;
   }
   try {
@@ -459527,6 +459625,55 @@ var init_toolset_labels = __esm(() => {
   };
 });
 
+// src/websocket/listener/commands/model-catalog.ts
+function buildPresetEntry(model) {
+  return {
+    id: model.id,
+    handle: model.handle,
+    label: model.label,
+    description: model.description,
+    ...typeof model.isDefault === "boolean" ? { isDefault: model.isDefault } : {},
+    ...typeof model.isFeatured === "boolean" ? { isFeatured: model.isFeatured } : {},
+    ...typeof model.free === "boolean" ? { free: model.free } : {},
+    ...model.updateArgs && typeof model.updateArgs === "object" ? { updateArgs: model.updateArgs } : {}
+  };
+}
+function buildNativeEntry(model) {
+  return {
+    id: model.handle,
+    handle: model.handle,
+    label: model.label,
+    description: ""
+  };
+}
+function modelIdentity(handle2) {
+  return resolvePiModelIdentity(handle2) ?? handle2;
+}
+function findAvailableModelForPreset(presetHandle, availableModels) {
+  return availableModels.find((model) => model.handle === presetHandle) ?? availableModels.find((model) => modelIdentity(model.handle) === modelIdentity(presetHandle));
+}
+function buildListModelsEntries(availableModels = []) {
+  const presetEntries = models2.map((model) => {
+    const entry = buildPresetEntry(model);
+    const availableModel = findAvailableModelForPreset(entry.handle, availableModels);
+    return availableModel ? { ...entry, handle: availableModel.handle } : entry;
+  });
+  const presetHandles = new Set(presetEntries.map((entry) => entry.handle));
+  const nativeHandles = new Set;
+  const nativeEntries = availableModels.flatMap((model) => {
+    if (nativeHandles.has(model.handle) || presetHandles.has(model.handle)) {
+      return [];
+    }
+    nativeHandles.add(model.handle);
+    return [buildNativeEntry(model)];
+  });
+  return [...presetEntries, ...nativeEntries];
+}
+var init_model_catalog2 = __esm(() => {
+  init_model();
+  init_pi_provider_registry();
+});
+
 // src/websocket/listener/commands/model-toolset.ts
 function inferProviderTypeFromRegistryHandle(modelHandle) {
   const provider = modelHandle.split("/")[0];
@@ -459589,22 +459736,34 @@ async function getCurrentModelStatusForRuntime(params) {
   };
 }
 function resolveModelForUpdate(payload) {
+  const availableModels = getCachedAvailableModels() ?? [];
   if (typeof payload.model_id === "string" && payload.model_id.length > 0) {
     const byId = getModelInfo(payload.model_id);
     if (byId) {
       const explicitHandle = typeof payload.model_handle === "string" && payload.model_handle.length > 0 ? payload.model_handle : null;
       const updateArgs = byId.updateArgs && typeof byId.updateArgs === "object" ? { ...byId.updateArgs } : undefined;
       const providerType = inferProviderTypeFromRegistryHandle(byId.handle);
-      if (explicitHandle && updateArgs && providerType && typeof updateArgs.provider_type !== "string") {
-        updateArgs.provider_type = providerType;
+      const availableModel = findAvailableModelForPreset(byId.handle, availableModels);
+      if ((explicitHandle || availableModel) && updateArgs && (availableModel?.providerType || providerType) && typeof updateArgs.provider_type !== "string") {
+        updateArgs.provider_type = availableModel?.providerType ?? providerType;
       }
       return {
         id: byId.id,
-        handle: explicitHandle ?? byId.handle,
+        handle: explicitHandle ?? availableModel?.handle ?? byId.handle,
         label: byId.label,
         updateArgs
       };
     }
+    const nativeModel = availableModels.find((model) => model.handle === payload.model_id);
+    if (nativeModel || payload.model_id.includes("/")) {
+      const explicitHandle = typeof payload.model_handle === "string" && payload.model_handle.length > 0 ? payload.model_handle : null;
+      return {
+        id: payload.model_id,
+        handle: explicitHandle ?? payload.model_id,
+        label: nativeModel?.label ?? payload.model_id,
+        updateArgs: undefined
+      };
+    }
   }
   if (typeof payload.model_handle === "string" && payload.model_handle.length > 0) {
     const exactByHandle = models2.find((m4) => m4.handle === payload.model_handle);
@@ -459616,10 +459775,11 @@ function resolveModelForUpdate(payload) {
         updateArgs: exactByHandle.updateArgs && typeof exactByHandle.updateArgs === "object" ? { ...exactByHandle.updateArgs } : undefined
       };
     }
+    const nativeModel = availableModels.find((model) => model.handle === payload.model_handle);
     return {
       id: payload.model_handle,
       handle: payload.model_handle,
-      label: payload.model_handle,
+      label: nativeModel?.label ?? payload.model_handle,
       updateArgs: undefined
     };
   }
@@ -459830,25 +459990,13 @@ async function applyToolsetUpdateForRuntime(params) {
     current_toolset_preference: toolsetPreference
   };
 }
-function buildListModelsEntries() {
-  return models2.map((model) => ({
-    id: model.id,
-    handle: model.handle,
-    label: model.label,
-    description: model.description,
-    ...typeof model.isDefault === "boolean" ? { isDefault: model.isDefault } : {},
-    ...typeof model.isFeatured === "boolean" ? { isFeatured: model.isFeatured } : {},
-    ...typeof model.free === "boolean" ? { free: model.free } : {},
-    ...model.updateArgs && typeof model.updateArgs === "object" ? { updateArgs: model.updateArgs } : {}
-  }));
-}
 async function buildListModelsResponse(requestId, options3 = {}) {
-  const entries = buildListModelsEntries();
   const [handlesResult, providersResult] = await Promise.allSettled([
     getAvailableModelHandles(options3.forceRefresh === true ? { forceRefresh: true } : undefined),
     listProviders2()
   ]);
   const availableHandles = handlesResult.status === "fulfilled" ? [...handlesResult.value.handles] : null;
+  const entries = buildListModelsEntries(handlesResult.status === "fulfilled" ? handlesResult.value.models : []);
   const providers = providersResult.status === "fulfilled" ? providersResult.value : [];
   const byokProviderAliases = buildByokProviderAliases(providers);
   return {
@@ -459966,6 +460114,7 @@ var init_model_toolset = __esm(async () => {
   init_byok_providers();
   init_settings_manager();
   init_toolset_labels();
+  init_model_catalog2();
   await __promiseAll([
     init_toolset(),
     init_mod_adapter2(),
@@ -462942,7 +463091,7 @@ __export(exports_memory_scanner, {
   getFileNodes: () => getFileNodes
 });
 import { readdirSync as readdirSync15, readFileSync as readFileSync31, statSync as statSync15 } from "node:fs";
-import { join as join50, relative as relative12 } from "node:path";
+import { join as join51, relative as relative12 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
   const scanDir = (dir, depth, parentIsLast) => {
@@ -462954,8 +463103,8 @@ function scanMemoryFilesystem(memoryRoot) {
     }
     const filtered = entries.filter((name) => !name.startsWith("."));
     const sorted = filtered.sort((a2, b3) => {
-      const aPath = join50(dir, a2);
-      const bPath = join50(dir, b3);
+      const aPath = join51(dir, a2);
+      const bPath = join51(dir, b3);
       let aIsDir = false;
       let bIsDir = false;
       try {
@@ -462975,7 +463124,7 @@ function scanMemoryFilesystem(memoryRoot) {
       return a2.localeCompare(b3);
     });
     sorted.forEach((name, index) => {
-      const fullPath = join50(dir, name);
+      const fullPath = join51(dir, name);
       let isDir = false;
       try {
         isDir = statSync15(fullPath).isDirectory();
@@ -463077,10 +463226,10 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     const isMemfsEnabledOnServer2 = overrides.isMemfsEnabledOnServer ?? actualIsMemfsEnabledOnServer;
     const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memory_scanner(), exports_memory_scanner));
     const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-    const { existsSync: existsSync45, statSync: statSync16 } = await import("node:fs");
-    const { join: join51, posix: posix4 } = await import("node:path");
+    const { existsSync: existsSync46, statSync: statSync16 } = await import("node:fs");
+    const { join: join52, posix: posix4 } = await import("node:path");
     const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
-    let memfsInitialized = existsSync45(join51(memoryRoot, ".git"));
+    let memfsInitialized = existsSync46(join52(memoryRoot, ".git"));
     const memfsEnabled = memfsInitialized ? true : await isMemfsEnabledOnServer2(parsed.agent_id);
     if (!memfsEnabled) {
       safeSocketSend(socket, {
@@ -463098,7 +463247,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     await ensureLocalMemfsCheckout2(parsed.agent_id, {
       pullOnExistingRepo: true
     });
-    memfsInitialized = existsSync45(join51(memoryRoot, ".git"));
+    memfsInitialized = existsSync46(join52(memoryRoot, ".git"));
     if (!memfsInitialized) {
       throw new Error("MemFS is enabled, but the local memory checkout could not be initialized.");
     }
@@ -463398,27 +463547,27 @@ function handleMemoryProtocolCommand(parsed, context4) {
           isMemfsEnabledOnServer: isMemfsEnabledOnServer2
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { readFile: readFile19 } = await import("node:fs/promises");
-        const { existsSync: existsSync45 } = await import("node:fs");
-        const { isAbsolute: isAbsolute24, join: join51, normalize: normalize5, relative: relative13, sep: sep6 } = await import("node:path");
+        const { existsSync: existsSync46 } = await import("node:fs");
+        const { isAbsolute: isAbsolute24, join: join52, normalize: normalize5, relative: relative13, sep: sep6 } = await import("node:path");
         if (isAbsolute24(parsed.path) || parsed.path.length === 0) {
           sendFailure("path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize5(join51(memoryRoot, parsed.path));
+        const absolutePath = normalize5(join52(memoryRoot, parsed.path));
         const rel = relative13(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute24(rel) || rel.split(sep6).includes("..")) {
           sendFailure("path must resolve inside the memory root");
           return;
         }
-        if (!existsSync45(join51(memoryRoot, ".git"))) {
+        if (!existsSync46(join52(memoryRoot, ".git"))) {
           const enabled = await isMemfsEnabledOnServer2(parsed.agent_id);
           if (!enabled) {
             sendFailure("memfs is not enabled for this agent");
             return;
           }
           await ensureLocalMemfsCheckout2(parsed.agent_id);
-          if (!existsSync45(join51(memoryRoot, ".git"))) {
+          if (!existsSync46(join52(memoryRoot, ".git"))) {
             sendFailure("failed to initialize local memory checkout");
             return;
           }
@@ -463464,27 +463613,27 @@ function handleMemoryProtocolCommand(parsed, context4) {
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { writeFile: writeFile15, mkdir: mkdir13 } = await import("node:fs/promises");
-        const { existsSync: existsSync45 } = await import("node:fs");
-        const { dirname: dirname27, isAbsolute: isAbsolute24, join: join51, normalize: normalize5, relative: relative13, sep: sep6 } = await import("node:path");
+        const { existsSync: existsSync46 } = await import("node:fs");
+        const { dirname: dirname27, isAbsolute: isAbsolute24, join: join52, normalize: normalize5, relative: relative13, sep: sep6 } = await import("node:path");
         if (isAbsolute24(parsed.path) || parsed.path.length === 0) {
           sendFailure("write_memory_file: path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize5(join51(memoryRoot, parsed.path));
+        const absolutePath = normalize5(join52(memoryRoot, parsed.path));
         const rel = relative13(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute24(rel) || rel.split(sep6).includes("..")) {
           sendFailure("write_memory_file: path must resolve inside the memory root");
           return;
         }
-        if (!existsSync45(join51(memoryRoot, ".git"))) {
+        if (!existsSync46(join52(memoryRoot, ".git"))) {
           const enabled = await isMemfsEnabledOnServer2(parsed.agent_id);
           if (!enabled) {
             sendFailure("write_memory_file: memfs is not enabled for this agent");
             return;
           }
           await ensureLocalMemfsCheckout2(parsed.agent_id);
-          if (!existsSync45(join51(memoryRoot, ".git"))) {
+          if (!existsSync46(join52(memoryRoot, ".git"))) {
             sendFailure("write_memory_file: failed to initialize local memory checkout");
             return;
           }
@@ -463562,34 +463711,34 @@ function handleMemoryProtocolCommand(parsed, context4) {
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { unlink: unlink5 } = await import("node:fs/promises");
-        const { existsSync: existsSync45 } = await import("node:fs");
-        const { isAbsolute: isAbsolute24, join: join51, normalize: normalize5, relative: relative13, sep: sep6 } = await import("node:path");
+        const { existsSync: existsSync46 } = await import("node:fs");
+        const { isAbsolute: isAbsolute24, join: join52, normalize: normalize5, relative: relative13, sep: sep6 } = await import("node:path");
         if (isAbsolute24(parsed.path) || parsed.path.length === 0) {
           sendFailure("delete_memory_file: path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
-        const absolutePath = normalize5(join51(memoryRoot, parsed.path));
+        const absolutePath = normalize5(join52(memoryRoot, parsed.path));
         const rel = relative13(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute24(rel) || rel.split(sep6).includes("..")) {
           sendFailure("delete_memory_file: path must resolve inside the memory root");
           return;
         }
-        if (!existsSync45(join51(memoryRoot, ".git"))) {
+        if (!existsSync46(join52(memoryRoot, ".git"))) {
           const enabled = await isMemfsEnabledOnServer2(parsed.agent_id);
           if (!enabled) {
             sendFailure("delete_memory_file: memfs is not enabled for this agent");
             return;
           }
           await ensureLocalMemfsCheckout2(parsed.agent_id);
-          if (!existsSync45(join51(memoryRoot, ".git"))) {
+          if (!existsSync46(join52(memoryRoot, ".git"))) {
             sendFailure("delete_memory_file: failed to initialize local memory checkout");
             return;
           }
         }
         const pathspec = rel.split(sep6).join("/");
         const removeIfPresent = async () => {
-          if (!existsSync45(absolutePath))
+          if (!existsSync46(absolutePath))
             return false;
           await unlink5(absolutePath);
           return true;
@@ -463995,19 +464144,19 @@ function emitSkillsUpdated(socket, safeSocketSend) {
 }
 async function handleSkillCommand(parsed, socket, safeSocketSend) {
   const {
-    existsSync: existsSync45,
+    existsSync: existsSync46,
     lstatSync: lstatSync3,
-    mkdirSync: mkdirSync31,
+    mkdirSync: mkdirSync32,
     rmdirSync,
     symlinkSync: symlinkSync2,
     unlinkSync: unlinkSync7
   } = await import("node:fs");
-  const { basename: basename25, join: join51 } = await import("node:path");
-  const lettaHome = process.env.LETTA_HOME || join51(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
-  const globalSkillsDir = join51(lettaHome, "skills");
+  const { basename: basename25, join: join52 } = await import("node:path");
+  const lettaHome = process.env.LETTA_HOME || join52(process.env.HOME || process.env.USERPROFILE || "~", ".letta");
+  const globalSkillsDir = join52(lettaHome, "skills");
   if (parsed.type === "skill_enable") {
     try {
-      if (!existsSync45(parsed.skill_path)) {
+      if (!existsSync46(parsed.skill_path)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
           request_id: parsed.request_id,
@@ -464016,8 +464165,8 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         }, "listener_skill_send_failed", "listener_skill_command");
         return true;
       }
-      const skillMdPath = join51(parsed.skill_path, "SKILL.md");
-      if (!existsSync45(skillMdPath)) {
+      const skillMdPath = join52(parsed.skill_path, "SKILL.md");
+      if (!existsSync46(skillMdPath)) {
         safeSocketSend(socket, {
           type: "skill_enable_response",
           request_id: parsed.request_id,
@@ -464027,9 +464176,9 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
         return true;
       }
       const linkName = basename25(parsed.skill_path);
-      const linkPath = join51(globalSkillsDir, linkName);
-      mkdirSync31(globalSkillsDir, { recursive: true });
-      if (existsSync45(linkPath)) {
+      const linkPath = join52(globalSkillsDir, linkName);
+      mkdirSync32(globalSkillsDir, { recursive: true });
+      if (existsSync46(linkPath)) {
         const stat14 = lstatSync3(linkPath);
         if (stat14.isSymbolicLink()) {
           if (process.platform === "win32") {
@@ -464070,8 +464219,8 @@ async function handleSkillCommand(parsed, socket, safeSocketSend) {
   }
   if (parsed.type === "skill_disable") {
     try {
-      const linkPath = join51(globalSkillsDir, parsed.name);
-      if (!existsSync45(linkPath)) {
+      const linkPath = join52(globalSkillsDir, parsed.name);
+      if (!existsSync46(linkPath)) {
         safeSocketSend(socket, {
           type: "skill_disable_response",
           request_id: parsed.request_id,
@@ -469062,6 +469211,7 @@ function createLegacyTestRuntime() {
 }
 var __listenClientTestUtils;
 var init_client7 = __esm(async () => {
+  init_model_catalog2();
   init_cwd();
   init_runtime6();
   await __promiseAll([
@@ -469210,10 +469360,10 @@ var init_listen_client = __esm(async () => {
 });
 
 // src/backend/local/transcript-search.ts
-import { existsSync as existsSync48, readdirSync as readdirSync18, readFileSync as readFileSync33, statSync as statSync17 } from "node:fs";
-import { join as join56 } from "node:path";
+import { existsSync as existsSync49, readdirSync as readdirSync18, readFileSync as readFileSync33, statSync as statSync17 } from "node:fs";
+import { join as join57 } from "node:path";
 function readJsonFile3(path37) {
-  if (!existsSync48(path37))
+  if (!existsSync49(path37))
     return;
   try {
     return JSON.parse(readFileSync33(path37, "utf8"));
@@ -469222,7 +469372,7 @@ function readJsonFile3(path37) {
   }
 }
 function readJsonlFile2(path37) {
-  if (!existsSync48(path37))
+  if (!existsSync49(path37))
     return [];
   try {
     return readFileSync33(path37, "utf8").split(`
@@ -469432,11 +469582,11 @@ function collectConversationMessages(input) {
     return [];
   if (input.conversationId && conversation.id !== input.conversationId)
     return [];
-  const messagesPath = join56(conversationDir, "messages.jsonl");
+  const messagesPath = join57(conversationDir, "messages.jsonl");
   const rows = readJsonlFile2(messagesPath);
   if (rows.length === 0)
     return [];
-  const manifest2 = readJsonFile3(join56(conversationDir, "manifest.json"));
+  const manifest2 = readJsonFile3(join57(conversationDir, "manifest.json"));
   const format5 = transcriptFormat(manifest2, rows);
   if (!format5)
     return [];
@@ -469457,11 +469607,11 @@ function collectConversationMessages(input) {
   });
 }
 function conversationDirectories(storageDir) {
-  const conversationsDir = join56(storageDir, "conversations");
-  if (!existsSync48(conversationsDir))
+  const conversationsDir = join57(storageDir, "conversations");
+  if (!existsSync49(conversationsDir))
     return [];
   try {
-    return readdirSync18(conversationsDir).map((entry) => join56(conversationsDir, entry)).filter((entryPath) => statSync17(entryPath).isDirectory());
+    return readdirSync18(conversationsDir).map((entry) => join57(conversationsDir, entry)).filter((entryPath) => statSync17(entryPath).isDirectory());
   } catch {
     return [];
   }
@@ -469485,7 +469635,7 @@ function searchLocalTranscriptMessages(storageDir, body3) {
   const endDate = typeof body3.end_date === "string" ? body3.end_date : undefined;
   const includeHidden = body3.include_hidden === true;
   const records = conversationDirectories(storageDir).flatMap((conversationDir) => {
-    const conversation = conversationSearchRecord(readJsonFile3(join56(conversationDir, "conversation.json")));
+    const conversation = conversationSearchRecord(readJsonFile3(join57(conversationDir, "conversation.json")));
     if (!conversation)
       return [];
     if (conversation.hidden && !includeHidden)
@@ -471357,14 +471507,14 @@ __export(exports_debug2, {
 });
 import {
   appendFileSync as appendFileSync8,
-  existsSync as existsSync52,
-  mkdirSync as mkdirSync36,
+  existsSync as existsSync53,
+  mkdirSync as mkdirSync37,
   readdirSync as readdirSync20,
   readFileSync as readFileSync37,
   unlinkSync as unlinkSync8
 } from "node:fs";
 import { homedir as homedir33 } from "node:os";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 import { format as format5 } from "node:util";
 function isDebugEnabled2() {
   const lettaDebug = process.env.LETTA_DEBUG;
@@ -471395,8 +471545,8 @@ class DebugLogFile2 {
     const telem = process.env.LETTA_CODE_TELEM;
     if (telem === "0" || telem === "false")
       return;
-    this.agentDir = join60(DEBUG_LOG_DIR2, agentId);
-    this.logPath = join60(this.agentDir, `${sessionId}.log`);
+    this.agentDir = join61(DEBUG_LOG_DIR2, agentId);
+    this.logPath = join61(this.agentDir, `${sessionId}.log`);
     this.dirCreated = false;
     this.pruneOldSessions();
   }
@@ -471412,7 +471562,7 @@ class DebugLogFile2 {
     if (!this.logPath)
       return;
     try {
-      if (!existsSync52(this.logPath))
+      if (!existsSync53(this.logPath))
         return;
       const content = readFileSync37(this.logPath, "utf8");
       const lines = content.trimEnd().split(`
@@ -471427,8 +471577,8 @@ class DebugLogFile2 {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync52(this.agentDir)) {
-        mkdirSync36(this.agentDir, { recursive: true });
+      if (!existsSync53(this.agentDir)) {
+        mkdirSync37(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
     } catch {}
@@ -471437,14 +471587,14 @@ class DebugLogFile2 {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync52(this.agentDir))
+      if (!existsSync53(this.agentDir))
         return;
       const files = readdirSync20(this.agentDir).filter((f4) => f4.endsWith(".log")).sort();
       if (files.length >= MAX_SESSION_FILES3) {
         const toDelete = files.slice(0, files.length - MAX_SESSION_FILES3 + 1);
         for (const file3 of toDelete) {
           try {
-            unlinkSync8(join60(this.agentDir, file3));
+            unlinkSync8(join61(this.agentDir, file3));
           } catch {}
         }
       }
@@ -471469,7 +471619,7 @@ function debugWarn2(prefix, message, ...args) {
 }
 var DEBUG_LOG_DIR2, MAX_SESSION_FILES3 = 5, DEFAULT_TAIL_LINES2 = 50, debugLogFile2;
 var init_debug2 = __esm(() => {
-  DEBUG_LOG_DIR2 = join60(homedir33(), ".letta", "logs", "debug");
+  DEBUG_LOG_DIR2 = join61(homedir33(), ".letta", "logs", "debug");
   debugLogFile2 = new DebugLogFile2;
 });
 
@@ -471503,16 +471653,16 @@ __export(exports_skills3, {
   PROJECT_SKILLS_DIR: () => PROJECT_SKILLS_DIR2,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
-import { existsSync as existsSync53 } from "node:fs";
+import { existsSync as existsSync54 } from "node:fs";
 import { readdir as readdir15, readFile as readFile22, realpath as realpath6, stat as stat15 } from "node:fs/promises";
-import { dirname as dirname31, join as join61 } from "node:path";
+import { dirname as dirname31, join as join62 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
   const thisDir = dirname31(fileURLToPath8(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join61(thisDir, "../skills/builtin");
+    return join62(thisDir, "../skills/builtin");
   }
-  return join61(thisDir, "skills");
+  return join62(thisDir, "skills");
 }
 function compareSkills2(a2, b3) {
   return a2.id.localeCompare(b3.id) || a2.source.localeCompare(b3.source) || a2.path.localeCompare(b3.path);
@@ -471559,7 +471709,7 @@ function isSkillAvailableForAgent2(skill2, agentId) {
   return true;
 }
 function getAgentSkillsDir2(agentId) {
-  return join61(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
+  return join62(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory/skills");
 }
 async function getBundledSkills2() {
   const bundledPath = getBundledSkillsPath2();
@@ -471568,7 +471718,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source2) {
   const errors7 = [];
-  if (!existsSync53(skillsPath)) {
+  if (!existsSync54(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -471582,7 +471732,7 @@ async function discoverSkillsFromDir2(skillsPath, source2) {
   }
   return { skills, errors: errors7 };
 }
-async function discoverSkills2(projectSkillsPath = join61(process.cwd(), SKILLS_DIR2), agentId, options3) {
+async function discoverSkills2(projectSkillsPath = join62(process.cwd(), SKILLS_DIR2), agentId, options3) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options3?.sources ?? ALL_SKILL_SOURCES);
@@ -471637,7 +471787,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors7, source2,
   try {
     const entries = await readdir15(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join61(currentPath, entry.name);
+      const fullPath = join62(currentPath, entry.name);
       try {
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
@@ -471728,8 +471878,8 @@ var LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS2, PROJECT_SKILLS_DIR2, SKILLS_DIR2 = ".s
 var init_skills4 = __esm(() => {
   init_skill_sources();
   LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS2 = new Set(["image-generation"]);
-  PROJECT_SKILLS_DIR2 = join61(".agents", "skills");
-  GLOBAL_SKILLS_DIR2 = join61(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  PROJECT_SKILLS_DIR2 = join62(".agents", "skills");
+  GLOBAL_SKILLS_DIR2 = join62(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/utils/fs.ts
@@ -471743,10 +471893,10 @@ __export(exports_fs, {
   exists: () => exists2
 });
 import {
-  existsSync as existsSync54,
+  existsSync as existsSync55,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
-  mkdirSync as mkdirSync37
+  mkdirSync as mkdirSync38
 } from "node:fs";
 import { dirname as dirname32 } from "node:path";
 async function readFile23(path39) {
@@ -471754,16 +471904,16 @@ async function readFile23(path39) {
 }
 async function writeFile17(path39, content) {
   const dir = dirname32(path39);
-  if (!existsSync54(dir)) {
-    mkdirSync37(dir, { recursive: true });
+  if (!existsSync55(dir)) {
+    mkdirSync38(dir, { recursive: true });
   }
   fsWriteFileSync2(path39, content, { encoding: "utf-8", flush: true });
 }
 function exists2(path39) {
-  return existsSync54(path39);
+  return existsSync55(path39);
 }
 async function mkdir15(path39, options3) {
-  mkdirSync37(path39, options3);
+  mkdirSync38(path39, options3);
 }
 async function readJsonFile4(path39) {
   const text2 = await readFile23(path39);
@@ -471973,7 +472123,7 @@ import {
 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants4, realpathSync as realpathSync6 } from "node:fs";
 import { readdir as readdir16, rm as rm6 } from "node:fs/promises";
-import { dirname as dirname33, join as join62 } from "node:path";
+import { dirname as dirname33, join as join63 } from "node:path";
 import { promisify as promisify15 } from "node:util";
 function debugLog4(...args) {
   if (DEBUG2) {
@@ -472048,7 +472198,7 @@ function getResolvedEntrypoint2() {
   }
 }
 function findInstalledPackagePath2(resolvedPath) {
-  const marker = `${join62("node_modules", "@letta-ai", "letta-code")}`;
+  const marker = `${join63("node_modules", "@letta-ai", "letta-code")}`;
   const index = resolvedPath.lastIndexOf(marker);
   if (index === -1) {
     return null;
@@ -472197,12 +472347,12 @@ async function getNpmGlobalPath2() {
   }
 }
 async function cleanupOrphanedDirs2(globalPath) {
-  const lettaAiDir = join62(globalPath, "lib/node_modules/@letta-ai");
+  const lettaAiDir = join63(globalPath, "lib/node_modules/@letta-ai");
   try {
     const entries = await readdir16(lettaAiDir);
     for (const entry of entries) {
       if (entry.startsWith(".letta-code-")) {
-        const orphanPath = join62(lettaAiDir, entry);
+        const orphanPath = join63(lettaAiDir, entry);
         debugLog4("Cleaning orphaned temp directory:", orphanPath);
         await rm6(orphanPath, { recursive: true, force: true });
       }
@@ -472732,18 +472882,18 @@ var exports_bootstrap_tools = {};
 __export(exports_bootstrap_tools, {
   bootstrapBaseToolsIfNeeded: () => bootstrapBaseToolsIfNeeded
 });
-import { existsSync as existsSync56, mkdirSync as mkdirSync39, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync57, mkdirSync as mkdirSync40, writeFileSync as writeFileSync29 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 async function bootstrapBaseToolsIfNeeded() {
-  if (existsSync56(MARKER_PATH))
+  if (existsSync57(MARKER_PATH))
     return;
   debugLog("bootstrap", "No marker found, bootstrapping base tools...");
   try {
     const success2 = await addBaseToolsToServer();
     if (success2) {
-      mkdirSync39(join64(homedir35(), ".letta"), { recursive: true });
-      writeFileSync28(MARKER_PATH, new Date().toISOString(), "utf-8");
+      mkdirSync40(join65(homedir35(), ".letta"), { recursive: true });
+      writeFileSync29(MARKER_PATH, new Date().toISOString(), "utf-8");
     }
   } catch (err) {
     debugWarn("bootstrap", `Failed to bootstrap base tools: ${err instanceof Error ? err.message : String(err)}`);
@@ -472753,7 +472903,7 @@ var MARKER_PATH;
 var init_bootstrap_tools = __esm(() => {
   init_debug();
   init_create6();
-  MARKER_PATH = join64(homedir35(), ".letta", ".bootstrapped");
+  MARKER_PATH = join65(homedir35(), ".letta", ".bootstrapped");
 });
 
 // src/tools/filter.ts
@@ -473205,7 +473355,7 @@ function validateRegistryHandleOrThrow2(handle2) {
 }
 
 // src/headless-mod-adapter.ts
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 function isHeadlessMemfsEnabled(agentId) {
   try {
     return settingsManager.isMemfsEnabled(agentId);
@@ -473276,7 +473426,7 @@ function createHeadlessModContext(options3) {
   };
 }
 function createHeadlessModAdapter(options3) {
-  const agentModsDirectory = isHeadlessMemfsEnabled(options3.agent.id) ? join65(getScopedMemoryFilesystemRoot(options3.agent.id), "mods") : undefined;
+  const agentModsDirectory = isHeadlessMemfsEnabled(options3.agent.id) ? join66(getScopedMemoryFilesystemRoot(options3.agent.id), "mods") : undefined;
   return createModAdapter({
     ...agentModsDirectory ? { agentModsDirectory } : {},
     ...options3.cacheDirectory ? { cacheDirectory: options3.cacheDirectory } : {},
@@ -473407,8 +473557,8 @@ var init_headless_tool_events = __esm(async () => {
 });
 
 // src/skills/builtin/creating-skills/scripts/validate-skill.ts
-import { existsSync as existsSync57, readFileSync as readFileSync38 } from "node:fs";
-import { basename as basename27, join as join66, resolve as resolve35 } from "node:path";
+import { existsSync as existsSync58, readFileSync as readFileSync38 } from "node:fs";
+import { basename as basename27, join as join67, resolve as resolve35 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function parseQuotedScalar(value) {
   if (value.startsWith('"')) {
@@ -473505,8 +473655,8 @@ function parseFrontmatter2(source2) {
   return parseFrontmatterFallback(source2);
 }
 function validateSkill(skillPath) {
-  const skillMdPath = join66(skillPath, "SKILL.md");
-  if (!existsSync57(skillMdPath)) {
+  const skillMdPath = join67(skillPath, "SKILL.md");
+  if (!existsSync58(skillMdPath)) {
     return { valid: false, message: "SKILL.md not found" };
   }
   const content = readFileSync38(skillMdPath, "utf-8");
@@ -473854,7 +474004,7 @@ function parseRegistryHandle(handle2) {
 }
 async function importAgentFromRegistry(options3) {
   const { tmpdir: tmpdir10 } = await import("node:os");
-  const { join: join67 } = await import("node:path");
+  const { join: join68 } = await import("node:path");
   const { writeFile: writeFile19, unlink: unlink5 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options3.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
@@ -473866,7 +474016,7 @@ async function importAgentFromRegistry(options3) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join67(tmpdir10(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join68(tmpdir10(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile19(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
@@ -478681,10 +478831,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 existsSync59 } from "node:fs";
+import { existsSync as existsSync60 } from "node:fs";
 import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir17, writeFile as writeFile19 } from "node:fs/promises";
 import { homedir as homedir38 } from "node:os";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 function buildGitEnv(token2, askpassPath) {
   return {
@@ -478720,7 +478870,7 @@ async function runGit6(cwd2, args, env5) {
   }
 }
 async function writeGitAskpass(repoRoot) {
-  const askpassPath = join68(repoRoot, "hf-askpass.sh");
+  const askpassPath = join69(repoRoot, "hf-askpass.sh");
   await writeFile19(askpassPath, [
     "#!/bin/sh",
     'case "$1" in',
@@ -478735,7 +478885,7 @@ async function writeGitAskpass(repoRoot) {
 }
 async function prepareHfRepo(env5) {
   await mkdir17(HF_CACHE_ROOT, { recursive: true });
-  if (!existsSync59(join68(HF_REPO_DIR, ".git"))) {
+  if (!existsSync60(join69(HF_REPO_DIR, ".git"))) {
     await runGit6(HF_CACHE_ROOT, ["clone", "--depth", "1", HF_REPO_URL, HF_REPO_DIR], env5);
     return HF_REPO_DIR;
   }
@@ -478770,8 +478920,8 @@ async function maybeUploadReflectionArenaChoiceToHf(row) {
   const env5 = buildGitEnv(token2, askpassPath);
   try {
     const repoDir = await prepareHfRepo(env5);
-    await mkdir17(join68(repoDir, "data"), { recursive: true });
-    await appendFile2(join68(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
+    await mkdir17(join69(repoDir, "data"), { recursive: true });
+    await appendFile2(join69(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
 `, {
       encoding: "utf-8"
     });
@@ -478799,8 +478949,8 @@ 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 = join68(homedir38(), ".letta", "reflection-arena", "hf-upload");
-  HF_REPO_DIR = join68(HF_CACHE_ROOT, "repo");
+  HF_CACHE_ROOT = join69(homedir38(), ".letta", "reflection-arena", "hf-upload");
+  HF_REPO_DIR = join69(HF_CACHE_ROOT, "repo");
 });
 
 // src/cli/helpers/reflection-arena.ts
@@ -478808,7 +478958,7 @@ import { execFile as execFileCb6 } from "node:child_process";
 import { randomInt, randomUUID as randomUUID30 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir18, readFile as readFile25, writeFile as writeFile20 } from "node:fs/promises";
 import { homedir as homedir39 } from "node:os";
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 import { promisify as promisify17 } from "node:util";
 function sampleReflectionArenaComparisonModel(excludedModels = []) {
   const excluded = new Set(excludedModels);
@@ -478838,16 +478988,16 @@ async function getGitHead(cwd2) {
   }
 }
 function getReflectionArenaRoot() {
-  return join69(homedir39(), ".letta", "reflection-arena");
+  return join70(homedir39(), ".letta", "reflection-arena");
 }
 function getReflectionArenaRunsDir() {
-  return join69(getReflectionArenaRoot(), "runs");
+  return join70(getReflectionArenaRoot(), "runs");
 }
 function getReflectionArenaChoiceLogPath() {
-  return join69(getReflectionArenaRoot(), "choices.jsonl");
+  return join70(getReflectionArenaRoot(), "choices.jsonl");
 }
 function getReflectionArenaRunPath(runId) {
-  return join69(getReflectionArenaRunsDir(), `${runId}.json`);
+  return join70(getReflectionArenaRunsDir(), `${runId}.json`);
 }
 async function saveReflectionArenaRun(run) {
   await mkdir18(getReflectionArenaRunsDir(), { recursive: true });
@@ -479944,13 +480094,13 @@ __export(exports_terminal_keybinding_installer, {
 });
 import {
   copyFileSync as copyFileSync5,
-  existsSync as existsSync60,
-  mkdirSync as mkdirSync41,
+  existsSync as existsSync61,
+  mkdirSync as mkdirSync42,
   readFileSync as readFileSync40,
-  writeFileSync as writeFileSync30
+  writeFileSync as writeFileSync31
 } from "node:fs";
 import { homedir as homedir40, platform as platform9 } from "node:os";
-import { dirname as dirname35, join as join70 } from "node:path";
+import { dirname as dirname35, join as join71 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -479982,16 +480132,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os9 = platform9();
   if (os9 === "darwin") {
-    return join70(homedir40(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join71(homedir40(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os9 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join70(appData, appName, "User", "keybindings.json");
+    return join71(appData, appName, "User", "keybindings.json");
   }
   if (os9 === "linux") {
-    return join70(homedir40(), ".config", appName, "User", "keybindings.json");
+    return join71(homedir40(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -480013,7 +480163,7 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync60(keybindingsPath))
+  if (!existsSync61(keybindingsPath))
     return false;
   try {
     const content = readFileSync40(keybindingsPath, { encoding: "utf-8" });
@@ -480026,7 +480176,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync60(keybindingsPath))
+  if (!existsSync61(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -480042,12 +480192,12 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname35(keybindingsPath);
-    if (!existsSync60(parentDir)) {
-      mkdirSync41(parentDir, { recursive: true });
+    if (!existsSync61(parentDir)) {
+      mkdirSync42(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync60(keybindingsPath)) {
+    if (existsSync61(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
       const content = readFileSync40(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
@@ -480062,7 +480212,7 @@ function installKeybinding(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync30(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync31(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -480077,7 +480227,7 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync60(keybindingsPath)) {
+    if (!existsSync61(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync40(keybindingsPath, { encoding: "utf-8" });
@@ -480091,7 +480241,7 @@ function removeKeybinding(keybindingsPath) {
     const filtered = keybindings.filter((kb) => !(kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus")));
     const newContent = `${JSON.stringify(filtered, null, 2)}
 `;
-    writeFileSync30(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync31(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error54) {
     const message = error54 instanceof Error ? error54.message : String(error54);
@@ -480144,14 +480294,14 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join70(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync60(xdgPath))
+    const xdgPath = join71(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync61(xdgPath))
       return xdgPath;
   }
-  const configPath = join70(homedir40(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync60(configPath))
+  const configPath = join71(homedir40(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync61(configPath))
     return configPath;
-  return join70(homedir40(), ".wezterm.lua");
+  return join71(homedir40(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine(line, blockCommentEnd) {
   let code2 = "";
@@ -480254,7 +480404,7 @@ ${WEZTERM_DELETE_FIX}
 `;
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync60(configPath))
+  if (!existsSync61(configPath))
     return false;
   try {
     const content = readFileSync40(configPath, { encoding: "utf-8" });
@@ -480271,17 +480421,17 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync60(configPath)) {
+    if (existsSync61(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync5(configPath, backupPath);
       content = readFileSync40(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix(content);
     const parentDir = dirname35(configPath);
-    if (!existsSync60(parentDir)) {
-      mkdirSync41(parentDir, { recursive: true });
+    if (!existsSync61(parentDir)) {
+      mkdirSync42(parentDir, { recursive: true });
     }
-    writeFileSync30(configPath, content, { encoding: "utf-8" });
+    writeFileSync31(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -480330,9 +480480,9 @@ __export(exports_settings2, {
   getSetting: () => getSetting
 });
 import { homedir as homedir41 } from "node:os";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 function getSettingsPath() {
-  return join71(homedir41(), ".letta", "settings.json");
+  return join72(homedir41(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -480369,7 +480519,7 @@ async function getSetting(key2) {
   return settings3[key2];
 }
 function getProjectSettingsPath() {
-  return join71(process.cwd(), ".letta", "settings.local.json");
+  return join72(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -480387,7 +480537,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings3) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join71(process.cwd(), ".letta");
+  const dirPath = join72(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -482274,9 +482424,9 @@ function getHeaderText(fileEdit) {
   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: existsSync61 } = __require("node:fs");
+    const { existsSync: existsSync62 } = __require("node:fs");
     try {
-      if (existsSync61(fileEdit.filePath)) {
+      if (existsSync62(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -489784,15 +489934,15 @@ import { spawn as spawn12, spawnSync as spawnSync4 } from "node:child_process";
 import {
   chmodSync as chmodSync7,
   createWriteStream as createWriteStream4,
-  existsSync as existsSync61,
-  mkdirSync as mkdirSync42,
+  existsSync as existsSync62,
+  mkdirSync as mkdirSync43,
   readdirSync as readdirSync22,
   renameSync as renameSync6,
   rmSync as rmSync14,
   statSync as statSync20
 } from "node:fs";
 import { arch as arch4, homedir as homedir43, platform as platform10 } from "node:os";
-import { basename as basename29, join as join72 } from "node:path";
+import { basename as basename29, join as join73 } from "node:path";
 function toDisplayPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -490034,7 +490184,7 @@ class FileAutocompleteProvider {
   }
   expandHomePath(path42) {
     if (path42.startsWith("~/")) {
-      const expandedPath = join72(homedir43(), path42.slice(2));
+      const expandedPath = join73(homedir43(), path42.slice(2));
       return path42.endsWith("/") && !expandedPath.endsWith("/") ? `${expandedPath}/` : expandedPath;
     } else if (path42 === "~") {
       return homedir43();
@@ -490055,7 +490205,7 @@ class FileAutocompleteProvider {
     } else if (displayBase.startsWith("/")) {
       baseDir = displayBase;
     } else {
-      baseDir = join72(this.basePath, displayBase);
+      baseDir = join73(this.basePath, displayBase);
     }
     try {
       if (!statSync20(baseDir).isDirectory()) {
@@ -490134,9 +490284,9 @@ class FileAutocompleteProvider {
 var PATH_DELIMITERS2, FD_TOOLS_DIR2, FD_BINARY_NAME2, FD_LOCAL_PATH2;
 var init_file_autocomplete = __esm(() => {
   PATH_DELIMITERS2 = new Set([" ", "\t", '"', "'", "="]);
-  FD_TOOLS_DIR2 = join72(homedir43(), ".letta", "bin");
+  FD_TOOLS_DIR2 = join73(homedir43(), ".letta", "bin");
   FD_BINARY_NAME2 = platform10() === "win32" ? "fd.exe" : "fd";
-  FD_LOCAL_PATH2 = join72(FD_TOOLS_DIR2, FD_BINARY_NAME2);
+  FD_LOCAL_PATH2 = join73(FD_TOOLS_DIR2, FD_BINARY_NAME2);
 });
 
 // src/cli/hooks/use-autocomplete-navigation.ts
@@ -492955,15 +493105,15 @@ var init_agents7 = __esm(() => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
 import {
-  existsSync as existsSync62,
-  mkdirSync as mkdirSync43,
+  existsSync as existsSync63,
+  mkdirSync as mkdirSync44,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync41,
   rmSync as rmSync15,
-  writeFileSync as writeFileSync31
+  writeFileSync as writeFileSync32
 } from "node:fs";
 import { tmpdir as tmpdir10 } from "node:os";
-import { dirname as dirname36, join as join73 } from "node:path";
+import { dirname as dirname36, join as join74 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync8(command, args, {
@@ -493184,8 +493334,8 @@ async function createLettaAgent(apiKey, name) {
   return createMinimalAgent(apiKey, name);
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync5(join73(tmpdir10(), "letta-install-github-app-"));
-  const repoDir = join73(tempDir, "repo");
+  const tempDir = mkdtempSync5(join74(tmpdir10(), "letta-install-github-app-"));
+  const repoDir = join74(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -493196,19 +493346,19 @@ function runGit7(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join73(repoDir, workflowPath);
-  if (!existsSync62(dirname36(absolutePath))) {
-    mkdirSync43(dirname36(absolutePath), { recursive: true });
+  const absolutePath = join74(repoDir, workflowPath);
+  if (!existsSync63(dirname36(absolutePath))) {
+    mkdirSync44(dirname36(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync62(absolutePath)) {
+  if (existsSync63(absolutePath)) {
     const previous = readFileSync41(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
   }
-  writeFileSync31(absolutePath, next, "utf8");
+  writeFileSync32(absolutePath, next, "utf8");
   return true;
 }
 function getDefaultBaseBranch(repoDir) {
@@ -497625,9 +497775,9 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb7 } from "node:child_process";
-import { chmodSync as chmodSync8, existsSync as existsSync63, mkdirSync as mkdirSync44, writeFileSync as writeFileSync32 } from "node:fs";
+import { chmodSync as chmodSync8, existsSync as existsSync64, mkdirSync as mkdirSync45, writeFileSync as writeFileSync33 } from "node:fs";
 import { homedir as homedir44 } from "node:os";
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 import { promisify as promisify18 } from "node:util";
 function messagesFromOverview(overview) {
   return overview.messages?.map((message) => ({
@@ -497936,7 +498086,7 @@ ${m4.body}` : m4.subject;
 async function generateAndOpenMemoryViewer(agentId, options3) {
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const repoDir = memoryRoot;
-  if (!existsSync63(join74(repoDir, ".git"))) {
+  if (!existsSync64(join75(repoDir, ".git"))) {
     throw new Error("Memory viewer requires memfs. Run /memfs enable first.");
   }
   const data = await collectMemoryData(agentId, repoDir, memoryRoot, options3?.conversationId);
@@ -497946,14 +498096,14 @@ async function generateAndOpenMemoryViewer(agentId, options3) {
   data.context = applyContextUsageSnapshot(data.context, options3?.contextUsage);
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html5 = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync63(VIEWERS_DIR)) {
-    mkdirSync44(VIEWERS_DIR, { recursive: true, mode: 448 });
+  if (!existsSync64(VIEWERS_DIR)) {
+    mkdirSync45(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync8(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join74(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
-  writeFileSync32(filePath, html5);
+  const filePath = join75(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
+  writeFileSync33(filePath, html5);
   chmodSync8(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
   if (!skipOpen) {
@@ -497977,13 +498127,13 @@ var init_generate_memory_viewer = __esm(() => {
   init_local_memory_context();
   init_memory_viewer_template();
   execFile20 = promisify18(execFileCb7);
-  VIEWERS_DIR = join74(homedir44(), ".letta", "viewers");
+  VIEWERS_DIR = join75(homedir44(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync64 } from "node:fs";
-import { join as join75 } from "node:path";
+import { existsSync as existsSync65 } from "node:fs";
+import { join as join76 } from "node:path";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i4 = 0;i4 < node.depth; i4++) {
@@ -498011,8 +498161,8 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react90.useState(null);
   const statusTimerRef = import_react90.useRef(null);
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync64(memoryRoot);
-  const hasGitRepo = import_react90.useMemo(() => existsSync64(join75(memoryRoot, ".git")), [memoryRoot]);
+  const memoryExists = existsSync65(memoryRoot);
+  const hasGitRepo = import_react90.useMemo(() => existsSync65(join76(memoryRoot, ".git")), [memoryRoot]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
       clearTimeout(statusTimerRef.current);
@@ -500478,10 +500628,10 @@ var init_PersonalitySelector = __esm(async () => {
 // src/utils/aws-credentials.ts
 import { readFile as readFile26 } from "node:fs/promises";
 import { homedir as homedir45 } from "node:os";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join76(homedir45(), ".aws", "credentials");
-  const configPath = join76(homedir45(), ".aws", "config");
+  const credentialsPath = join77(homedir45(), ".aws", "credentials");
+  const configPath = join77(homedir45(), ".aws", "config");
   const profiles = new Map;
   try {
     const content = await readFile26(credentialsPath, "utf-8");
@@ -502057,8 +502207,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join77 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join77(process.cwd(), SKILLS_DIR3);
+        const { join: join78 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join78(process.cwd(), SKILLS_DIR3);
         const result = await discoverSkills3(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -505984,9 +506134,9 @@ function getFileEditHeader(toolName, toolArgs) {
     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: existsSync65 } = __require("node:fs");
+      const { existsSync: existsSync66 } = __require("node:fs");
       try {
-        if (existsSync65(filePath)) {
+        if (existsSync66(filePath)) {
           return `Overwrite ${displayPath2}?`;
         }
       } catch {}
@@ -521326,9 +521476,9 @@ __export(exports_generate_diff_viewer, {
   generateAndOpenDiffViewer: () => generateAndOpenDiffViewer
 });
 import { execFile as execFileCb8 } from "node:child_process";
-import { chmodSync as chmodSync9, existsSync as existsSync65, mkdirSync as mkdirSync45, writeFileSync as writeFileSync33 } from "node:fs";
+import { chmodSync as chmodSync9, existsSync as existsSync66, mkdirSync as mkdirSync46, writeFileSync as writeFileSync34 } from "node:fs";
 import { homedir as homedir46 } from "node:os";
-import { isAbsolute as isAbsolute26, join as join77, resolve as resolve39 } from "node:path";
+import { isAbsolute as isAbsolute26, join as join78, resolve as resolve39 } from "node:path";
 import { promisify as promisify19 } from "node:util";
 async function runGit8(cwd2, args) {
   try {
@@ -521547,14 +521697,14 @@ 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 (!existsSync65(VIEWERS_DIR2)) {
-    mkdirSync45(VIEWERS_DIR2, { recursive: true, mode: 448 });
+  if (!existsSync66(VIEWERS_DIR2)) {
+    mkdirSync46(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync9(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join77(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
-  writeFileSync33(filePath, html5);
+  const filePath = join78(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
+  writeFileSync34(filePath, html5);
   chmodSync9(filePath, 384);
   const skipOpen = shouldSkipOpen();
   if (!skipOpen) {
@@ -521624,7 +521774,7 @@ var init_generate_diff_viewer = __esm(() => {
   init_ssr();
   init_diff_viewer_template();
   execFile21 = promisify19(execFileCb8);
-  VIEWERS_DIR2 = join77(homedir46(), ".letta", "viewers");
+  VIEWERS_DIR2 = join78(homedir46(), ".letta", "viewers");
   GIT_MAX_BUFFER = 50 * 1024 * 1024;
 });
 
@@ -523589,12 +523739,12 @@ __export(exports_shell_aliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync66, readFileSync as readFileSync42 } from "node:fs";
+import { existsSync as existsSync67, readFileSync as readFileSync42 } from "node:fs";
 import { homedir as homedir47 } from "node:os";
-import { join as join78 } from "node:path";
+import { join as join79 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync66(filePath)) {
+  if (!existsSync67(filePath)) {
     return aliases;
   }
   try {
@@ -523663,7 +523813,7 @@ function loadAliases(forceReload = false) {
   const home = homedir47();
   const allAliases = new Map;
   for (const file3 of ALIAS_FILES) {
-    const filePath = join78(home, file3);
+    const filePath = join79(home, file3);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -531935,9 +532085,9 @@ var init_conversation_switch_alert = __esm(() => {
 
 // src/cli/app/use-submit-handler.ts
 import { randomUUID as randomUUID35 } from "node:crypto";
-import { existsSync as existsSync67, readFileSync as readFileSync43, renameSync as renameSync7, writeFileSync as writeFileSync34 } from "node:fs";
+import { existsSync as existsSync68, readFileSync as readFileSync43, renameSync as renameSync7, writeFileSync as writeFileSync35 } from "node:fs";
 import { tmpdir as tmpdir11 } from "node:os";
-import { join as join79 } from "node:path";
+import { join as join80 } from "node:path";
 async function findCustomCommandByName(commandName) {
   const { findCustomCommand: findCustomCommand2 } = await Promise.resolve().then(() => (init_custom(), exports_custom));
   return findCustomCommand2(commandName);
@@ -532633,10 +532783,10 @@ ${SYSTEM_REMINDER_CLOSE}`),
           try {
             const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
             const personaCandidates = [
-              join79(memoryRoot, "system", "persona.md"),
-              join79(memoryRoot, "memory", "system", "persona.md")
+              join80(memoryRoot, "system", "persona.md"),
+              join80(memoryRoot, "memory", "system", "persona.md")
             ];
-            const personaPath = personaCandidates.find((candidate) => existsSync67(candidate));
+            const personaPath = personaCandidates.find((candidate) => existsSync68(candidate));
             if (personaPath) {
               const personaContent = readFileSync43(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
@@ -533410,7 +533560,7 @@ Tip: Use /clear instead to clear the current message buffer.`;
             fileContent.skills = skills;
           }
           const fileName = exportParams.conversation_id ? `${exportParams.conversation_id}.af` : `${agentId}.af`;
-          writeFileSync34(fileName, JSON.stringify(fileContent, null, 2));
+          writeFileSync35(fileName, JSON.stringify(fileContent, null, 2));
           let summary = `AgentFile exported to ${fileName}`;
           if (skills.length > 0) {
             summary += `
@@ -533517,11 +533667,11 @@ Path: ${memoryDir}`, true);
           setCommandRunning(true);
           try {
             const memoryDir = getScopedMemoryFilesystemRoot(agentId);
-            if (!existsSync67(memoryDir)) {
+            if (!existsSync68(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join79(tmpdir11(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join80(tmpdir11(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync7(memoryDir, backupDir);
             if (getBackend().capabilities.localMemfs) {
               const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
@@ -534485,7 +534635,7 @@ var init_use_submit_handler = __esm(async () => {
 });
 
 // src/cli/app/AppCoordinator.tsx
-import { join as join80 } from "node:path";
+import { join as join81 } from "node:path";
 function buildStartupCommandHints(options3) {
   const {
     isResumingConversation,
@@ -535791,7 +535941,7 @@ function App2({
       agentId: a2.agentId ?? null
     }))
   });
-  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join80(modContext.memfs.memoryDir, "mods") : null;
+  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join81(modContext.memfs.memoryDir, "mods") : null;
   const modAdapter = useLocalModAdapter(modContext, {
     agentModsDirectory,
     disabled: modsDisabled
@@ -536564,9 +536714,9 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     (async () => {
       try {
         const { watch: watch3 } = await import("node:fs");
-        const { existsSync: existsSync68 } = await import("node:fs");
+        const { existsSync: existsSync69 } = await import("node:fs");
         const memRoot = getScopedMemoryFilesystemRoot(agentId);
-        if (!existsSync68(memRoot))
+        if (!existsSync69(memRoot))
           return;
         watcher2 = watch3(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher2;
@@ -537891,13 +538041,13 @@ __export(exports_terminal_keybinding_installer2, {
 });
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync68,
-  mkdirSync as mkdirSync46,
+  existsSync as existsSync69,
+  mkdirSync as mkdirSync47,
   readFileSync as readFileSync44,
-  writeFileSync as writeFileSync35
+  writeFileSync as writeFileSync36
 } from "node:fs";
 import { homedir as homedir49, platform as platform11 } from "node:os";
-import { dirname as dirname37, join as join81 } from "node:path";
+import { dirname as dirname37, join as join82 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -537929,16 +538079,16 @@ function getKeybindingsPath2(terminal) {
   }[terminal];
   const os10 = platform11();
   if (os10 === "darwin") {
-    return join81(homedir49(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join82(homedir49(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os10 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join81(appData, appName, "User", "keybindings.json");
+    return join82(appData, appName, "User", "keybindings.json");
   }
   if (os10 === "linux") {
-    return join81(homedir49(), ".config", appName, "User", "keybindings.json");
+    return join82(homedir49(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -537960,7 +538110,7 @@ function parseKeybindings2(content) {
   }
 }
 function keybindingExists2(keybindingsPath) {
-  if (!existsSync68(keybindingsPath))
+  if (!existsSync69(keybindingsPath))
     return false;
   try {
     const content = readFileSync44(keybindingsPath, { encoding: "utf-8" });
@@ -537973,7 +538123,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync68(keybindingsPath))
+  if (!existsSync69(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -537989,12 +538139,12 @@ function installKeybinding2(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname37(keybindingsPath);
-    if (!existsSync68(parentDir)) {
-      mkdirSync46(parentDir, { recursive: true });
+    if (!existsSync69(parentDir)) {
+      mkdirSync47(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync68(keybindingsPath)) {
+    if (existsSync69(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
       const content = readFileSync44(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
@@ -538009,7 +538159,7 @@ function installKeybinding2(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING2);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync35(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync36(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -538024,7 +538174,7 @@ function installKeybinding2(keybindingsPath) {
 }
 function removeKeybinding2(keybindingsPath) {
   try {
-    if (!existsSync68(keybindingsPath)) {
+    if (!existsSync69(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync44(keybindingsPath, { encoding: "utf-8" });
@@ -538038,7 +538188,7 @@ function removeKeybinding2(keybindingsPath) {
     const filtered = keybindings.filter((kb) => !(kb.key?.toLowerCase() === "shift+enter" && kb.command === "workbench.action.terminal.sendSequence" && kb.when?.includes("terminalFocus")));
     const newContent = `${JSON.stringify(filtered, null, 2)}
 `;
-    writeFileSync35(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync36(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error54) {
     const message = error54 instanceof Error ? error54.message : String(error54);
@@ -538091,14 +538241,14 @@ function getWezTermConfigPath2() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join81(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync68(xdgPath))
+    const xdgPath = join82(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync69(xdgPath))
       return xdgPath;
   }
-  const configPath = join81(homedir49(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync68(configPath))
+  const configPath = join82(homedir49(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync69(configPath))
     return configPath;
-  return join81(homedir49(), ".wezterm.lua");
+  return join82(homedir49(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine2(line, blockCommentEnd) {
   let code2 = "";
@@ -538201,7 +538351,7 @@ ${WEZTERM_DELETE_FIX2}
 `;
 }
 function wezTermDeleteFixExists2(configPath) {
-  if (!existsSync68(configPath))
+  if (!existsSync69(configPath))
     return false;
   try {
     const content = readFileSync44(configPath, { encoding: "utf-8" });
@@ -538218,17 +538368,17 @@ function installWezTermDeleteFix2() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync68(configPath)) {
+    if (existsSync69(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync6(configPath, backupPath);
       content = readFileSync44(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix2(content);
     const parentDir = dirname37(configPath);
-    if (!existsSync68(parentDir)) {
-      mkdirSync46(parentDir, { recursive: true });
+    if (!existsSync69(parentDir)) {
+      mkdirSync47(parentDir, { recursive: true });
     }
-    writeFileSync35(configPath, content, { encoding: "utf-8" });
+    writeFileSync36(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -538277,9 +538427,9 @@ __export(exports_settings3, {
   getSetting: () => getSetting2
 });
 import { homedir as homedir50 } from "node:os";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 function getSettingsPath2() {
-  return join82(homedir50(), ".letta", "settings.json");
+  return join83(homedir50(), ".letta", "settings.json");
 }
 async function loadSettings2() {
   const settingsPath = getSettingsPath2();
@@ -538316,7 +538466,7 @@ async function getSetting2(key2) {
   return settings3[key2];
 }
 function getProjectSettingsPath2() {
-  return join82(process.cwd(), ".letta", "settings.local.json");
+  return join83(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings2() {
   const settingsPath = getProjectSettingsPath2();
@@ -538334,7 +538484,7 @@ async function loadProjectSettings2() {
 }
 async function saveProjectSettings2(settings3) {
   const settingsPath = getProjectSettingsPath2();
-  const dirPath = join82(process.cwd(), ".letta");
+  const dirPath = join83(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -539007,7 +539157,7 @@ function parseRegistryHandle2(handle2) {
 }
 async function importAgentFromRegistry2(options3) {
   const { tmpdir: tmpdir12 } = await import("node:os");
-  const { join: join83 } = await import("node:path");
+  const { join: join84 } = await import("node:path");
   const { writeFile: writeFile23, unlink: unlink5 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle2(options3.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER2}/${AGENT_REGISTRY_REPO2}/refs/heads/${AGENT_REGISTRY_BRANCH2}/agents/@${author}/${name}/${name}.af`;
@@ -539019,7 +539169,7 @@ async function importAgentFromRegistry2(options3) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join83(tmpdir12(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join84(tmpdir12(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile23(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile2({
@@ -539073,14 +539223,14 @@ __export(exports_memory_filesystem2, {
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR2,
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR2
 });
-import { existsSync as existsSync69, mkdirSync as mkdirSync47 } from "node:fs";
+import { existsSync as existsSync70, mkdirSync as mkdirSync48 } from "node:fs";
 import { homedir as homedir51 } from "node:os";
-import { join as join83, resolve as resolve42 } from "node:path";
+import { join as join84, resolve as resolve42 } from "node:path";
 function getMemoryFilesystemRoot2(agentId, homeDir = homedir51()) {
-  return join83(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
+  return join84(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
 }
 function getMemorySystemDir2(agentId, homeDir = homedir51()) {
-  return join83(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
+  return join84(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
 }
 function getScopedMemoryFilesystemRoot2(agentId, options3 = {}) {
   const env6 = options3.env ?? process.env;
@@ -539116,11 +539266,11 @@ function resolveScopedMemoryDir2(options3 = {}) {
 function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir51()) {
   const root2 = getMemoryFilesystemRoot2(agentId, homeDir);
   const systemDir = getMemorySystemDir2(agentId, homeDir);
-  if (!existsSync69(root2)) {
-    mkdirSync47(root2, { recursive: true });
+  if (!existsSync70(root2)) {
+    mkdirSync48(root2, { recursive: true });
   }
-  if (!existsSync69(systemDir)) {
-    mkdirSync47(systemDir, { recursive: true });
+  if (!existsSync70(systemDir)) {
+    mkdirSync48(systemDir, { recursive: true });
   }
 }
 function stampMemfsTagOnCreateBody2(body3, gitMemoryEnabledTag) {
@@ -539425,8 +539575,8 @@ __export(exports_secrets_store2, {
   __testOverrideSecretsBackend: () => __testOverrideSecretsBackend2,
   __testOverrideLocalSecretStorage: () => __testOverrideLocalSecretStorage2
 });
-import { existsSync as existsSync70, mkdirSync as mkdirSync48, readFileSync as readFileSync45, writeFileSync as writeFileSync36 } from "node:fs";
-import { dirname as dirname39, join as join84 } from "node:path";
+import { existsSync as existsSync71, mkdirSync as mkdirSync49, readFileSync as readFileSync45, writeFileSync as writeFileSync37 } from "node:fs";
+import { dirname as dirname39, join as join85 } from "node:path";
 function __testOverrideSecretsBackend2(backend4) {
   testBackendOverride2 = backend4;
 }
@@ -539437,11 +539587,11 @@ function getSecretsBackend2() {
   return testBackendOverride2 ?? getBackend();
 }
 function getFileBackedLocalSecretsPath2() {
-  return join84(getLocalBackendStorageDir(), FILE_BACKED_LOCAL_SECRETS_PATH2);
+  return join85(getLocalBackendStorageDir(), FILE_BACKED_LOCAL_SECRETS_PATH2);
 }
 function readFileBackedLocalSecrets2() {
   const filePath = getFileBackedLocalSecretsPath2();
-  if (!existsSync70(filePath))
+  if (!existsSync71(filePath))
     return {};
   try {
     const parsed = JSON.parse(readFileSync45(filePath, "utf8"));
@@ -539454,8 +539604,8 @@ function readFileBackedLocalSecrets2() {
 }
 function writeFileBackedLocalSecrets2(secrets2) {
   const filePath = getFileBackedLocalSecretsPath2();
-  mkdirSync48(dirname39(filePath), { mode: 448, recursive: true });
-  writeFileSync36(filePath, `${JSON.stringify({ secrets: secrets2 }, null, 2)}
+  mkdirSync49(dirname39(filePath), { mode: 448, recursive: true });
+  writeFileSync37(filePath, `${JSON.stringify({ secrets: secrets2 }, null, 2)}
 `, {
     encoding: "utf8",
     flush: true,
@@ -539750,7 +539900,7 @@ var init_secrets_store2 = __esm(() => {
   init_backend2();
   init_paths();
   init_secrets();
-  FILE_BACKED_LOCAL_SECRETS_PATH2 = join84("secrets", "local-agent-secrets.json");
+  FILE_BACKED_LOCAL_SECRETS_PATH2 = join85("secrets", "local-agent-secrets.json");
   SECRETS_CACHE_KEY2 = Symbol.for("@letta/secretsCache");
   LOCAL_SECRET_NAME_PATTERN2 = /^[A-Z_][A-Z0-9_]*$/;
 });
@@ -542949,21 +543099,21 @@ import { spawn as spawn9, spawnSync as spawnSync3 } from "node:child_process";
 import {
   chmodSync as chmodSync5,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync36,
-  mkdirSync as mkdirSync24,
+  existsSync as existsSync37,
+  mkdirSync as mkdirSync25,
   readdirSync as readdirSync12,
   renameSync as renameSync3,
   rmSync as rmSync7,
   statSync as statSync11
 } from "node:fs";
 import { arch as arch2, homedir as homedir27, platform as platform5 } from "node:os";
-import { basename as basename19, join as join41 } from "node:path";
+import { basename as basename19, join as join42 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline6 } from "node:stream/promises";
 var PATH_DELIMITERS = new Set([" ", "\t", '"', "'", "="]);
-var FD_TOOLS_DIR = join41(homedir27(), ".letta", "bin");
+var FD_TOOLS_DIR = join42(homedir27(), ".letta", "bin");
 var FD_BINARY_NAME = platform5() === "win32" ? "fd.exe" : "fd";
-var FD_LOCAL_PATH = join41(FD_TOOLS_DIR, FD_BINARY_NAME);
+var FD_LOCAL_PATH = join42(FD_TOOLS_DIR, FD_BINARY_NAME);
 var FD_DOWNLOAD_REPO = "sharkdp/fd";
 var FD_DOWNLOAD_TIMEOUT_MS = 120000;
 var FD_NETWORK_TIMEOUT_MS = 1e4;
@@ -543050,8 +543200,8 @@ function extractTarGzArchive2(archivePath, extractDir) {
 function getWindowsTarCommand2() {
   const systemRoot = process.env.SystemRoot ?? process.env.WINDIR;
   if (systemRoot) {
-    const systemTar = join41(systemRoot, "System32", "tar.exe");
-    if (existsSync36(systemTar)) {
+    const systemTar = join42(systemRoot, "System32", "tar.exe");
+    if (existsSync37(systemTar)) {
       return systemTar;
     }
   }
@@ -543113,7 +543263,7 @@ function findBinaryRecursively2(rootDir, binaryName2) {
     if (!currentDir)
       continue;
     for (const entry of readdirSync12(currentDir, { withFileTypes: true })) {
-      const fullPath = join41(currentDir, entry.name);
+      const fullPath = join42(currentDir, entry.name);
       if (entry.isFile() && entry.name === binaryName2) {
         return fullPath;
       }
@@ -543133,10 +543283,10 @@ async function downloadFd() {
   if (!assetName) {
     throw new Error(`Unsupported platform: ${platform5()}/${arch2()}`);
   }
-  mkdirSync24(FD_TOOLS_DIR, { recursive: true });
-  const archivePath = join41(FD_TOOLS_DIR, assetName);
-  const extractDir = join41(FD_TOOLS_DIR, `extract_tmp_fd_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
-  mkdirSync24(extractDir, { recursive: true });
+  mkdirSync25(FD_TOOLS_DIR, { recursive: true });
+  const archivePath = join42(FD_TOOLS_DIR, assetName);
+  const extractDir = join42(FD_TOOLS_DIR, `extract_tmp_fd_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync25(extractDir, { recursive: true });
   try {
     await downloadFile3(`https://github.com/${FD_DOWNLOAD_REPO}/releases/download/v${version2}/${assetName}`, archivePath);
     if (assetName.endsWith(".tar.gz")) {
@@ -543164,7 +543314,7 @@ function resolveFdPath() {
   if (cachedFdPath !== undefined) {
     return cachedFdPath;
   }
-  if (existsSync36(FD_LOCAL_PATH)) {
+  if (existsSync37(FD_LOCAL_PATH)) {
     cachedFdPath = FD_LOCAL_PATH;
     return cachedFdPath;
   }
@@ -546204,7 +546354,7 @@ import { createHash as createHash6 } from "node:crypto";
 
 // src/cli/subcommands/dream-sources/openhands.ts
 import { readdir as readdir12, readFile as readFile19, stat as stat14 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 var RESULT_TEXT_TRUNCATE_LIMIT = 4000;
 function joinTextContent(content) {
   if (!Array.isArray(content))
@@ -546319,7 +546469,7 @@ function eventSequence(fileName) {
 async function readOpenHandsEventDir(dir) {
   let eventsDir = dir;
   try {
-    const nested = join51(dir, "events");
+    const nested = join52(dir, "events");
     if ((await stat14(nested)).isDirectory()) {
       eventsDir = nested;
     }
@@ -546330,7 +546480,7 @@ async function readOpenHandsEventDir(dir) {
   }
   const events = [];
   for (const name of fileNames) {
-    const raw2 = await readFile19(join51(eventsDir, name), "utf-8");
+    const raw2 = await readFile19(join52(eventsDir, name), "utf-8");
     const event2 = safeJsonParseOr(raw2, null);
     if (event2 && typeof event2 === "object") {
       events.push(event2);
@@ -546408,7 +546558,7 @@ init_memory_filesystem2();
 init_memory_git();
 import { execFileSync as execFileSync7 } from "node:child_process";
 import { mkdir as mkdir13, readFile as readFile21, rm as rm5, writeFile as writeFile15 } from "node:fs/promises";
-import { basename as basename25, dirname as dirname27, join as join52 } from "node:path";
+import { basename as basename25, dirname as dirname27, join as join53 } from "node:path";
 function resolveDreamTarget(spec) {
   const fileName = basename25(spec);
   if (!fileName) {
@@ -546509,7 +546659,7 @@ async function syncTargetIntoMemory(agentId, target2, content) {
   if (committed !== null && stripFrontmatter(committed) === stripFrontmatter(content)) {
     return { synced: false };
   }
-  const absPath = join52(memoryDir, relPath);
+  const absPath = join53(memoryDir, relPath);
   await mkdir13(dirname27(absPath), { recursive: true });
   await writeFile15(absPath, addManagedFrontmatter(content, target2.kind), "utf-8");
   try {
@@ -547072,14 +547222,14 @@ init_telemetry();
 // src/websocket/listen-log.ts
 import {
   appendFileSync as appendFileSync7,
-  existsSync as existsSync45,
-  mkdirSync as mkdirSync31,
+  existsSync as existsSync46,
+  mkdirSync as mkdirSync32,
   readdirSync as readdirSync16,
   unlinkSync as unlinkSync7
 } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { join as join53 } from "node:path";
-var REMOTE_LOG_DIR = join53(homedir31(), ".letta", "logs", "remote");
+import { join as join54 } from "node:path";
+var REMOTE_LOG_DIR = join54(homedir31(), ".letta", "logs", "remote");
 var MAX_LOG_FILES = 10;
 function formatTimestamp2() {
   const now = new Date;
@@ -547091,14 +547241,14 @@ function formatTimestamp2() {
 }
 function pruneOldLogs() {
   try {
-    if (!existsSync45(REMOTE_LOG_DIR))
+    if (!existsSync46(REMOTE_LOG_DIR))
       return;
     const files = readdirSync16(REMOTE_LOG_DIR).filter((f4) => f4.endsWith(".log")).sort();
     if (files.length >= MAX_LOG_FILES) {
       const toDelete = files.slice(0, files.length - MAX_LOG_FILES + 1);
       for (const file3 of toDelete) {
         try {
-          unlinkSync7(join53(REMOTE_LOG_DIR, file3));
+          unlinkSync7(join54(REMOTE_LOG_DIR, file3));
         } catch {}
       }
     }
@@ -547111,7 +547261,7 @@ class RemoteSessionLog {
   constructor() {
     const now = new Date;
     const stamp = now.toISOString().replace(/[:.]/g, "-");
-    this.path = join53(REMOTE_LOG_DIR, `${stamp}.log`);
+    this.path = join54(REMOTE_LOG_DIR, `${stamp}.log`);
   }
   init() {
     this.ensureDir();
@@ -547138,8 +547288,8 @@ class RemoteSessionLog {
     if (this.dirCreated)
       return;
     try {
-      if (!existsSync45(REMOTE_LOG_DIR)) {
-        mkdirSync31(REMOTE_LOG_DIR, { recursive: true });
+      if (!existsSync46(REMOTE_LOG_DIR)) {
+        mkdirSync32(REMOTE_LOG_DIR, { recursive: true });
       }
       this.dirCreated = true;
     } catch {}
@@ -547734,15 +547884,15 @@ init_local_store();
 import { randomUUID as randomUUID24 } from "node:crypto";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync46,
-  mkdirSync as mkdirSync32,
+  existsSync as existsSync47,
+  mkdirSync as mkdirSync33,
   readdirSync as readdirSync17,
   readFileSync as readFileSync32,
-  writeFileSync as writeFileSync23
+  writeFileSync as writeFileSync24
 } from "node:fs";
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 function readJsonl(path37) {
-  if (!existsSync46(path37))
+  if (!existsSync47(path37))
     return [];
   return readFileSync32(path37, "utf8").split(`
 `).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
@@ -547754,7 +547904,7 @@ function isPiLocalMessage(value) {
   return isRecord(value) && typeof value.id === "string" && (value.role === "user" || value.role === "assistant" || value.role === "toolResult") && Object.hasOwn(value, "content");
 }
 function writeJsonl(path37, items3) {
-  writeFileSync23(path37, `${items3.map((item) => JSON.stringify(item)).join(`
+  writeFileSync24(path37, `${items3.map((item) => JSON.stringify(item)).join(`
 `)}
 `);
 }
@@ -548023,20 +548173,20 @@ function convertMessages4(messages, mode, nextId2) {
 }
 function migrateLocalBackendTranscripts(input) {
   const storageDir = input.storageDir;
-  const conversationsDir = join54(storageDir, "conversations");
+  const conversationsDir = join55(storageDir, "conversations");
   const result = {
     storageDir,
     converted: [],
     skipped: [],
     dryRun: input.dryRun === true
   };
-  if (!existsSync46(conversationsDir))
+  if (!existsSync47(conversationsDir))
     return result;
   for (const name of readdirSync17(conversationsDir)) {
-    const conversationDir = join54(conversationsDir, name);
-    const messagesPath = join54(conversationDir, "messages.jsonl");
-    const manifestPath = join54(conversationDir, "manifest.json");
-    const hasManifest = existsSync46(manifestPath);
+    const conversationDir = join55(conversationsDir, name);
+    const messagesPath = join55(conversationDir, "messages.jsonl");
+    const manifestPath = join55(conversationDir, "manifest.json");
+    const hasManifest = existsSync47(manifestPath);
     const existingManifest = hasManifest ? (() => {
       try {
         return JSON.parse(readFileSync32(manifestPath, "utf8"));
@@ -548054,8 +548204,8 @@ function migrateLocalBackendTranscripts(input) {
     if (legacyMessages.length === 0) {
       result.skipped.push({ conversationDir, reason: "empty" });
       if (!input.dryRun) {
-        mkdirSync32(conversationDir, { recursive: true });
-        writeFileSync23(manifestPath, `${JSON.stringify(manifest({}), null, 2)}
+        mkdirSync33(conversationDir, { recursive: true });
+        writeFileSync24(manifestPath, `${JSON.stringify(manifest({}), null, 2)}
 `);
       }
       continue;
@@ -548078,9 +548228,9 @@ function migrateLocalBackendTranscripts(input) {
     const backupPath = `${messagesPath}.pre-pi-backup-${timestampSuffix()}`;
     if (!input.dryRun) {
       copyFileSync2(messagesPath, backupPath);
-      const conversationPath = join54(conversationDir, "conversation.json");
+      const conversationPath = join55(conversationDir, "conversation.json");
       let conversation;
-      if (existsSync46(conversationPath)) {
+      if (existsSync47(conversationPath)) {
         try {
           conversation = JSON.parse(readFileSync32(conversationPath, "utf8"));
         } catch {
@@ -548108,12 +548258,12 @@ function migrateLocalBackendTranscripts(input) {
               }
             }
             conversation.in_context_message_ids = remapped;
-            writeFileSync23(conversationPath, `${JSON.stringify(conversation, null, 2)}
+            writeFileSync24(conversationPath, `${JSON.stringify(conversation, null, 2)}
 `);
           }
         } catch {}
       }
-      writeFileSync23(manifestPath, `${JSON.stringify(manifest({
+      writeFileSync24(manifestPath, `${JSON.stringify(manifest({
         backupPath,
         migratedFrom: repairVersioned ? hasLegacyUiRows ? "versioned-pi-transcript-with-legacy-ui-message-rows" : "versioned-pi-ai-message-jsonl" : undefined
       }), null, 2)}
@@ -548190,9 +548340,9 @@ async function runLocalBackendSubcommand(argv) {
 init_memory_filesystem2();
 init_memory_git();
 init_paths();
-import { cpSync, existsSync as existsSync47, mkdirSync as mkdirSync33, rmSync as rmSync10, statSync as statSync16 } from "node:fs";
+import { cpSync, existsSync as existsSync48, mkdirSync as mkdirSync34, rmSync as rmSync10, statSync as statSync16 } from "node:fs";
 import { readdir as readdir13 } from "node:fs/promises";
-import { dirname as dirname28, join as join55 } from "node:path";
+import { dirname as dirname28, join as join56 } from "node:path";
 import { parseArgs as parseArgs11 } from "node:util";
 
 // src/cli/subcommands/memory-tokens.ts
@@ -548344,7 +548494,7 @@ function formatBackupTimestamp(date6 = new Date) {
 }
 async function listBackups(agentId) {
   const agentRoot = getAgentRoot(agentId);
-  if (!existsSync47(agentRoot)) {
+  if (!existsSync48(agentRoot)) {
     return [];
   }
   const entries = await readdir13(agentRoot, { withFileTypes: true });
@@ -548354,7 +548504,7 @@ async function listBackups(agentId) {
       continue;
     if (!entry.name.startsWith("memory-backup-"))
       continue;
-    const path37 = join55(agentRoot, entry.name);
+    const path37 = join56(agentRoot, entry.name);
     let createdAt = null;
     try {
       const stat15 = statSync16(path37);
@@ -548371,7 +548521,7 @@ function resolveBackupPath(agentId, from) {
   if (from.startsWith("/") || /^[A-Za-z]:[/\\]/.test(from)) {
     return from;
   }
-  return join55(getAgentRoot(agentId), from);
+  return join56(getAgentRoot(agentId), from);
 }
 async function runMemorySubcommand(argv) {
   let parsed;
@@ -548447,14 +548597,14 @@ async function runMemorySubcommand(argv) {
     }
     if (action3 === "backup") {
       const root2 = getMemoryRoot(agentId);
-      if (!existsSync47(root2)) {
+      if (!existsSync48(root2)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
       const agentRoot = getAgentRoot(agentId);
       const backupName = `memory-backup-${formatBackupTimestamp()}`;
-      const backupPath = join55(agentRoot, backupName);
-      if (existsSync47(backupPath)) {
+      const backupPath = join56(agentRoot, backupName);
+      if (existsSync48(backupPath)) {
         console.error(`Backup already exists at ${backupPath}`);
         return 1;
       }
@@ -548478,7 +548628,7 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       const backupPath = resolveBackupPath(agentId, from);
-      if (!existsSync47(backupPath)) {
+      if (!existsSync48(backupPath)) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
@@ -548500,11 +548650,11 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       const root2 = getMemoryRoot(agentId);
-      if (!existsSync47(root2)) {
+      if (!existsSync48(root2)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
-      if (existsSync47(out)) {
+      if (existsSync48(out)) {
         const stat15 = statSync16(out);
         if (stat15.isDirectory()) {
           const contents = await readdir13(out);
@@ -548517,7 +548667,7 @@ async function runMemorySubcommand(argv) {
           return 1;
         }
       } else {
-        mkdirSync33(out, { recursive: true });
+        mkdirSync34(out, { recursive: true });
       }
       cpSync(root2, out, { recursive: true });
       console.log(JSON.stringify({ exportedFrom: root2, exportedTo: out, agentId }, null, 2));
@@ -548911,7 +549061,7 @@ async function runMessagesSubcommand(argv, deps = {}) {
 // src/cli/subcommands/mods.ts
 init_memory_filesystem2();
 await init_mod_engine();
-import { dirname as dirname29, join as join57 } from "node:path";
+import { dirname as dirname29, join as join58 } from "node:path";
 import { parseArgs as parseArgs13 } from "node:util";
 
 // src/mods/package-installer.ts
@@ -548923,15 +549073,15 @@ import {
 } from "node:child_process";
 import {
   copyFileSync as copyFileSync3,
-  existsSync as existsSync49,
+  existsSync as existsSync50,
   lstatSync as lstatSync3,
-  mkdirSync as mkdirSync34,
+  mkdirSync as mkdirSync35,
   mkdtempSync as mkdtempSync3,
   readdirSync as readdirSync19,
   readFileSync as readFileSync34,
   renameSync as renameSync5,
   rmSync as rmSync11,
-  writeFileSync as writeFileSync24
+  writeFileSync as writeFileSync25
 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
 import path37 from "node:path";
@@ -549071,7 +549221,7 @@ function validatePackageSource(packageDirectory) {
   };
 }
 function copyPackageDirectory(sourceRoot, targetRoot) {
-  mkdirSync34(targetRoot, { recursive: true });
+  mkdirSync35(targetRoot, { recursive: true });
   for (const entry of readdirSync19(sourceRoot, { withFileTypes: true })) {
     if (SKIPPED_PACKAGE_COPY_NAMES.has(entry.name))
       continue;
@@ -549086,7 +549236,7 @@ function copyPackageDirectory(sourceRoot, targetRoot) {
       continue;
     }
     if (stats.isFile()) {
-      mkdirSync34(path37.dirname(targetPath), { recursive: true });
+      mkdirSync35(path37.dirname(targetPath), { recursive: true });
       copyFileSync3(sourcePath, targetPath);
       continue;
     }
@@ -549126,7 +549276,7 @@ function copyDependencyDirectoryFiltered(params) {
       continue;
     }
     if (stats.isFile()) {
-      mkdirSync34(path37.dirname(targetPath), { recursive: true });
+      mkdirSync35(path37.dirname(targetPath), { recursive: true });
       copyFileSync3(sourcePath, targetPath);
       copied = true;
       continue;
@@ -549136,7 +549286,7 @@ function copyDependencyDirectoryFiltered(params) {
   return copied;
 }
 function copyDependencyNodeModules(params) {
-  if (!existsSync49(params.sourceNodeModulesDirectory))
+  if (!existsSync50(params.sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     installedPackageName: params.installedPackageName,
@@ -549146,7 +549296,7 @@ function copyDependencyNodeModules(params) {
 }
 function copyPackageInternalNodeModules(params) {
   const sourceNodeModulesDirectory = path37.join(params.packageDirectory, "node_modules");
-  if (!existsSync49(sourceNodeModulesDirectory))
+  if (!existsSync50(sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     sourceRoot: sourceNodeModulesDirectory,
@@ -549158,8 +549308,8 @@ function restoreRegistry(registryPath, previousContents) {
     rmSync11(registryPath, { force: true });
     return;
   }
-  mkdirSync34(path37.dirname(registryPath), { recursive: true });
-  writeFileSync24(registryPath, previousContents);
+  mkdirSync35(path37.dirname(registryPath), { recursive: true });
+  writeFileSync25(registryPath, previousContents);
 }
 function removeIfExists(targetPath) {
   if (!targetPath)
@@ -549168,12 +549318,12 @@ function removeIfExists(targetPath) {
 }
 function restoreDestination(params) {
   rmSync11(params.destinationRoot, { force: true, recursive: true });
-  if (params.backupRoot && existsSync49(params.backupRoot)) {
+  if (params.backupRoot && existsSync50(params.backupRoot)) {
     renameSync5(params.backupRoot, params.destinationRoot);
   }
 }
 function restoreDestinationIfNeeded(params) {
-  if (!params.backupRoot || !existsSync49(params.backupRoot)) {
+  if (!params.backupRoot || !existsSync50(params.backupRoot)) {
     rmSync11(params.destinationRoot, { force: true, recursive: true });
     return;
   }
@@ -549182,7 +549332,7 @@ function restoreDestinationIfNeeded(params) {
 function makeSiblingTempDirectory(destinationRoot, label) {
   const parent = path37.dirname(destinationRoot);
   const baseName = path37.basename(destinationRoot).replace(/[^a-zA-Z0-9._-]/g, "-");
-  mkdirSync34(parent, { recursive: true });
+  mkdirSync35(parent, { recursive: true });
   return mkdtempSync3(path37.join(parent, `.${baseName}.${label}-`));
 }
 function installPreparedManagedModPackage(params) {
@@ -549214,7 +549364,7 @@ function installPreparedManagedModPackage(params) {
         targetPackageRoot: stagingRoot
       });
     }
-    if (existsSync49(destinationRoot)) {
+    if (existsSync50(destinationRoot)) {
       backupRoot = makeSiblingTempDirectory(destinationRoot, "backup");
       rmSync11(backupRoot, { force: true, recursive: true });
       renameSync5(destinationRoot, backupRoot);
@@ -549280,7 +549430,7 @@ function getNpmInstallArgs(installSpec) {
   ];
 }
 function writeNpmInstallManifest(tempRoot) {
-  writeFileSync24(path37.join(tempRoot, "package.json"), `${JSON.stringify({
+  writeFileSync25(path37.join(tempRoot, "package.json"), `${JSON.stringify({
     private: true,
     name: "letta-managed-mod-install"
   }, null, 2)}
@@ -549497,7 +549647,7 @@ function hasRuntimeDependencies(packageJson) {
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path37.join(packageDirectory, "package.json");
-  if (!existsSync49(packageJsonPath))
+  if (!existsSync50(packageJsonPath))
     return null;
   return readPackageJson(packageJsonPath);
 }
@@ -549511,7 +549661,7 @@ function isRegularModFile(filePath) {
 }
 function inferCompatibilityModEntries(packageDirectory) {
   const modsDirectory = path37.join(packageDirectory, "mods");
-  if (existsSync49(modsDirectory)) {
+  if (existsSync50(modsDirectory)) {
     const stats = lstatSync3(modsDirectory);
     if (stats.isSymbolicLink()) {
       throw new Error(`Package mods directory must not be a symlink: mods`);
@@ -549552,7 +549702,7 @@ function getPackageVersionForGitPackage(params) {
 }
 function writeCompatibilityPackageManifest(params) {
   const packageJsonPath = path37.join(params.packageDirectory, "package.json");
-  writeFileSync24(packageJsonPath, `${JSON.stringify({
+  writeFileSync25(packageJsonPath, `${JSON.stringify({
     ...params.packageJson ?? {},
     name: params.packageName,
     version: params.version,
@@ -549783,11 +549933,11 @@ init_package_manifest();
 init_package_registry();
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync50,
+  existsSync as existsSync51,
   lstatSync as lstatSync4,
-  mkdirSync as mkdirSync35,
+  mkdirSync as mkdirSync36,
   rmSync as rmSync12,
-  writeFileSync as writeFileSync25
+  writeFileSync as writeFileSync26
 } from "node:fs";
 import path38 from "node:path";
 var DEFAULT_PACKAGE_VERSION = "0.1.0";
@@ -549879,7 +550029,7 @@ function scaffoldLocalModPackage(options3) {
   const sourceFile = readSourceFile(options3.sourceFile);
   const packageName = assertValidPackageName(options3.packageName);
   const outputDirectory = path38.resolve(options3.outputDirectory ?? defaultOutputDirectory(sourceFile, packageName));
-  if (existsSync50(outputDirectory)) {
+  if (existsSync51(outputDirectory)) {
     throw new Error(`Output directory already exists: ${outputDirectory}`);
   }
   const modFileName = path38.basename(sourceFile);
@@ -549891,12 +550041,12 @@ function scaffoldLocalModPackage(options3) {
   const modGuidePath = path38.join(outputDirectory, "MOD.md");
   const installCommand = `letta install ${outputDirectory}`;
   try {
-    mkdirSync35(targetModsDirectory, { recursive: true });
+    mkdirSync36(targetModsDirectory, { recursive: true });
     copyFileSync4(sourceFile, targetModPath);
-    writeFileSync25(packageJsonPath, `${JSON.stringify(createPackageJson(packageName, manifestEntry), null, 2)}
+    writeFileSync26(packageJsonPath, `${JSON.stringify(createPackageJson(packageName, manifestEntry), null, 2)}
 `);
-    writeFileSync25(readmePath, createReadme(packageName));
-    writeFileSync25(modGuidePath, createModGuide(packageName, manifestEntry));
+    writeFileSync26(readmePath, createReadme(packageName));
+    writeFileSync26(modGuidePath, createModGuide(packageName, manifestEntry));
   } catch (error54) {
     rmSync12(outputDirectory, { force: true, recursive: true });
     throw error54;
@@ -549964,7 +550114,7 @@ function getExplicitAgentId(values2) {
   return typeof explicitAgent === "string" && explicitAgent.trim() ? explicitAgent.trim() : null;
 }
 function getAgentModsDirectory(agentId) {
-  return join57(getScopedMemoryFilesystemRoot(agentId), "mods");
+  return join58(getScopedMemoryFilesystemRoot(agentId), "mods");
 }
 function directFilesForSource(source2) {
   return source2.files.filter((file3) => dirname29(file3) === source2.root);
@@ -550293,16 +550443,16 @@ async function runSetupSubcommand(argv) {
 // src/cli/subcommands/skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync51,
+  existsSync as existsSync52,
   mkdtempSync as mkdtempSync4,
   readFileSync as readFileSync35,
   rmSync as rmSync13,
   statSync as statSync18,
-  writeFileSync as writeFileSync26
+  writeFileSync as writeFileSync27
 } from "node:fs";
 import { mkdir as mkdir14, readdir as readdir14 } from "node:fs/promises";
 import { tmpdir as tmpdir9 } from "node:os";
-import { basename as basename26, dirname as dirname30, join as join58, normalize as normalize5, resolve as resolve32, sep as sep6 } from "node:path";
+import { basename as basename26, dirname as dirname30, join as join59, normalize as normalize5, resolve as resolve32, sep as sep6 } from "node:path";
 import { parseArgs as parseArgs14, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
 init_paths2();
 var HERMES_REPO_URL = "https://github.com/NousResearch/hermes-agent.git";
@@ -550607,14 +550757,14 @@ async function resolveBranchAndSubdir(location) {
 }
 async function cloneSkillSource(location) {
   const resolvedLocation = await resolveBranchAndSubdir(location);
-  const tmpDir = mkdtempSync4(join58(tmpdir9(), "letta-skill-install-"));
+  const tmpDir = mkdtempSync4(join59(tmpdir9(), "letta-skill-install-"));
   const args = ["clone", "--depth", "1"];
   if (resolvedLocation.branch) {
     args.push("--branch", resolvedLocation.branch);
   }
   args.push(resolvedLocation.repoUrl, tmpDir);
   await execFile16("git", args, { timeout: 120000 });
-  const sourceDir = resolvedLocation.subdir ? join58(tmpDir, resolvedLocation.subdir) : tmpDir;
+  const sourceDir = resolvedLocation.subdir ? join59(tmpDir, resolvedLocation.subdir) : tmpDir;
   return { tmpDir, sourceDir };
 }
 function assertDirectSkillFileSize(receivedBytes, maxBytes) {
@@ -550669,11 +550819,11 @@ async function downloadDirectSkillFileSource(location, options3 = {}) {
     throw new Error(`Direct skill file download failed for ${location.url}: ${response.status}`);
   }
   const skillText = await readResponseTextWithLimit(response, MAX_DIRECT_SKILL_FILE_BYTES);
-  const tmpDir = mkdtempSync4(join58(tmpdir9(), "letta-direct-skill-"));
+  const tmpDir = mkdtempSync4(join59(tmpdir9(), "letta-direct-skill-"));
   try {
-    const sourceDir = join58(tmpDir, "skill");
+    const sourceDir = join59(tmpDir, "skill");
     await mkdir14(sourceDir, { recursive: true });
-    writeFileSync26(join58(sourceDir, "SKILL.md"), skillText, "utf8");
+    writeFileSync27(join59(sourceDir, "SKILL.md"), skillText, "utf8");
     return { tmpDir, sourceDir };
   } catch (error54) {
     rmSync13(tmpDir, { recursive: true, force: true });
@@ -550714,9 +550864,9 @@ function assertSafeZipMember(name) {
 }
 async function downloadClawHubSkillSource(location) {
   const version2 = await resolveClawHubVersion(location);
-  const tmpDir = mkdtempSync4(join58(tmpdir9(), "letta-clawhub-skill-"));
-  const zipPath = join58(tmpDir, "skill.zip");
-  const sourceDir = join58(tmpDir, "skill");
+  const tmpDir = mkdtempSync4(join59(tmpdir9(), "letta-clawhub-skill-"));
+  const zipPath = join59(tmpDir, "skill.zip");
+  const sourceDir = join59(tmpDir, "skill");
   await mkdir14(sourceDir, { recursive: true });
   const url2 = new URL(`${CLAWHUB_API_BASE_URL}/download`);
   url2.searchParams.set("slug", location.slug);
@@ -550725,7 +550875,7 @@ async function downloadClawHubSkillSource(location) {
   if (!response.ok) {
     throw new Error(`ClawHub download failed for ${location.slug}@${version2}: ${response.status}`);
   }
-  writeFileSync26(zipPath, Buffer.from(await response.arrayBuffer()));
+  writeFileSync27(zipPath, Buffer.from(await response.arrayBuffer()));
   const { stdout } = await execFile16("unzip", ["-Z1", zipPath], {
     timeout: 30000
   });
@@ -550755,7 +550905,7 @@ function sanitizeSkillName(name) {
   return trimmed;
 }
 function getSkillName(sourceDir) {
-  const skillMd = readFileSync35(join58(sourceDir, "SKILL.md"), "utf8");
+  const skillMd = readFileSync35(join59(sourceDir, "SKILL.md"), "utf8");
   const { frontmatter } = parseFrontmatter(skillMd);
   const frontmatterName = frontmatter.name;
   const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename26(sourceDir);
@@ -550764,18 +550914,18 @@ function getSkillName(sourceDir) {
 async function installSkillDirectory(params) {
   const sourceDir = resolve32(params.sourceDir);
   const memoryDir = resolve32(params.memoryDir);
-  const skillMdPath = join58(sourceDir, "SKILL.md");
-  if (!existsSync51(skillMdPath)) {
+  const skillMdPath = join59(sourceDir, "SKILL.md");
+  if (!existsSync52(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
   if (!statSync18(sourceDir).isDirectory()) {
     throw new Error(`Skill source is not a directory: ${sourceDir}`);
   }
   const name = getSkillName(sourceDir);
-  const skillsDir = join58(memoryDir, "skills");
-  const targetPath = join58(skillsDir, name);
+  const skillsDir = join59(memoryDir, "skills");
+  const targetPath = join59(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (existsSync51(targetPath)) {
+  if (existsSync52(targetPath)) {
     if (!params.force) {
       throw new Error(`Skill "${name}" already exists at ${targetPath}. Re-run with --force to replace it.`);
     }
@@ -550790,17 +550940,17 @@ async function installSkillDirectory(params) {
 }
 async function listSkillDirectories(params) {
   const memoryDir = resolve32(params.memoryDir);
-  const skillsDir = join58(memoryDir, "skills");
-  if (!existsSync51(skillsDir))
+  const skillsDir = join59(memoryDir, "skills");
+  if (!existsSync52(skillsDir))
     return [];
   const entries = await readdir14(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const skillDir = join58(skillsDir, entry.name);
-    const skillMdPath = join58(skillDir, "SKILL.md");
-    if (!existsSync51(skillMdPath))
+    const skillDir = join59(skillsDir, entry.name);
+    const skillMdPath = join59(skillDir, "SKILL.md");
+    if (!existsSync52(skillMdPath))
       continue;
     let name = entry.name;
     let description;
@@ -550820,11 +550970,11 @@ async function listSkillDirectories(params) {
 }
 async function deleteSkillDirectory(params) {
   const memoryDir = resolve32(params.memoryDir);
-  const skillsDir = join58(memoryDir, "skills");
+  const skillsDir = join59(memoryDir, "skills");
   const name = sanitizeSkillName(params.name);
-  const targetPath = join58(skillsDir, name);
+  const targetPath = join59(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (!existsSync51(targetPath)) {
+  if (!existsSync52(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
   }
   if (!statSync18(targetPath).isDirectory()) {
@@ -550873,7 +551023,7 @@ async function installSkill(specifier, agentId, force) {
     tmpDir = downloaded.tmpDir;
     const sourceDir = resolve32(downloaded.sourceDir);
     assertInside(tmpDir, sourceDir);
-    if (!existsSync51(sourceDir)) {
+    if (!existsSync52(sourceDir)) {
       const missingPath = source2.type === "git" ? source2.location.subdir ?? "." : source2.type === "direct-file" ? source2.location.url : source2.location.slug;
       throw new Error(`Skill path not found: ${missingPath}`);
     }
@@ -551327,7 +551477,7 @@ init_secrets();
 import { randomUUID as randomUUID25 } from "node:crypto";
 import { readFileSync as readFileSync36 } from "node:fs";
 import { homedir as homedir32 } from "node:os";
-import { join as join59, resolve as resolve33 } from "node:path";
+import { join as join60, resolve as resolve33 } from "node:path";
 var OBSOLETE_SETTINGS_KEYS2 = [
   "reflectionBehavior",
   "enableSleeptime",
@@ -551770,7 +551920,7 @@ class SettingsManager2 {
       return;
     const settingsPath = this.getSettingsPath();
     const home = process.env.HOME || homedir32();
-    const dirPath = join59(home, ".letta");
+    const dirPath = join60(home, ".letta");
     try {
       if (!exists(dirPath)) {
         await mkdir(dirPath, { recursive: true });
@@ -551811,7 +551961,7 @@ class SettingsManager2 {
     if (!settings3)
       return;
     const settingsPath = this.getProjectSettingsPath(workingDirectory);
-    const dirPath = join59(workingDirectory, ".letta");
+    const dirPath = join60(workingDirectory, ".letta");
     try {
       let existingSettings = {};
       if (exists(settingsPath)) {
@@ -551833,16 +551983,16 @@ class SettingsManager2 {
   }
   getSettingsPath() {
     const home = process.env.HOME || homedir32();
-    return join59(home, ".letta", "settings.json");
+    return join60(home, ".letta", "settings.json");
   }
   getProjectSettingsPath(workingDirectory) {
-    return join59(workingDirectory, ".letta", "settings.json");
+    return join60(workingDirectory, ".letta", "settings.json");
   }
   isProjectSettingsPathCollidingWithGlobal(workingDirectory) {
     return resolve33(this.getProjectSettingsPath(workingDirectory)) === resolve33(this.getSettingsPath());
   }
   getLocalProjectSettingsPath(workingDirectory) {
-    return join59(workingDirectory, ".letta", "settings.local.json");
+    return join60(workingDirectory, ".letta", "settings.local.json");
   }
   async loadLocalProjectSettings(workingDirectory = process.cwd()) {
     const cached3 = this.localProjectSettings.get(workingDirectory);
@@ -551903,7 +552053,7 @@ class SettingsManager2 {
     if (!settings3)
       return;
     const settingsPath = this.getLocalProjectSettingsPath(workingDirectory);
-    const dirPath = join59(workingDirectory, ".letta");
+    const dirPath = join60(workingDirectory, ".letta");
     try {
       if (!exists(dirPath)) {
         await mkdir(dirPath, { recursive: true });
@@ -552257,7 +552407,7 @@ class SettingsManager2 {
     });
   }
   hasLocalLettaDir(workingDirectory = process.cwd()) {
-    const dirPath = join59(workingDirectory, ".letta");
+    const dirPath = join60(workingDirectory, ".letta");
     return exists(dirPath);
   }
   storeOAuthState(state, codeVerifier, redirectUri, provider) {
@@ -553032,12 +553182,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join85 } = await import("path");
+  const { join: join86 } = await import("path");
   const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_version2(), exports_version2));
   const { SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills4(), exports_skills3));
   const { exists: exists3 } = await Promise.resolve().then(() => (init_fs2(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join85(cwd2, SKILLS_DIR3);
+  const skillsDir = join86(cwd2, SKILLS_DIR3);
   const skillsExist = exists3(skillsDir);
   await settingsManager2.loadLocalProjectSettings(cwd2);
   const pinned = settingsManager2.getPinnedAgents();
@@ -553611,9 +553761,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     } else {
       const { resolve: resolve43 } = await import("path");
-      const { existsSync: existsSync71 } = await import("fs");
+      const { existsSync: existsSync72 } = await import("fs");
       const resolvedPath = resolve43(fromAfFile);
-      if (!existsSync71(resolvedPath)) {
+      if (!existsSync72(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
       }
@@ -554643,4 +554793,4 @@ Error during initialization: ${message}`);
 }
 main2();
 
-//# debugId=6B7881A097F42D3C64756E2164756E21
+//# debugId=EA7311931B35FB9664756E2164756E21