@letta-ai/letta-code 0.19.8 → 0.19.9

package/letta.js

@@ -3255,7 +3255,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.19.8",
+    version: "0.19.9",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -4247,6 +4247,11 @@ class SettingsManager {
     }
     return this.getGlobalLastAgentId();
   }
+  persistSession(agentId, conversationId, workingDirectory = process.cwd()) {
+    const session = { agentId, conversationId };
+    this.setLocalLastSession(session, workingDirectory);
+    this.setGlobalLastSession(session);
+  }
   getGlobalPinnedAgents() {
     const settings = this.getSettings();
     const serverKey = getCurrentServerKey(settings);
@@ -4609,6 +4614,7 @@ var init_settings_manager = __esm(async () => {
     enableSleeptime: false,
     conversationSwitchAlertEnabled: false,
     sessionContextEnabled: true,
+    autoSwapOnQuotaLimit: true,
     memoryReminderInterval: 25,
     reflectionTrigger: "step-count",
     reflectionStepCount: 25,
@@ -40351,6 +40357,31 @@ var init_fileIndex = __esm(() => {
   cachedEntryPaths2 = new Set;
 });
 
+// src/cli/helpers/messageQueueBridge.ts
+function setMessageQueueAdder(fn) {
+  queueAdder = fn;
+  if (queueAdder && pendingMessages.length > 0) {
+    for (const message of pendingMessages) {
+      queueAdder(message);
+    }
+    pendingMessages.length = 0;
+  }
+}
+function addToMessageQueue(message) {
+  if (queueAdder) {
+    queueAdder(message);
+    return;
+  }
+  if (pendingMessages.length >= MAX_PENDING_MESSAGES) {
+    pendingMessages.shift();
+  }
+  pendingMessages.push(message);
+}
+var queueAdder = null, pendingMessages, MAX_PENDING_MESSAGES = 10;
+var init_messageQueueBridge = __esm(() => {
+  pendingMessages = [];
+});
+
 // src/cli/helpers/planName.ts
 import { homedir as homedir8 } from "node:os";
 import { join as join9 } from "node:path";
@@ -40469,6 +40500,186 @@ var init_planName = __esm(() => {
   ];
 });
 
+// src/cli/helpers/subagentState.ts
+function updateSnapshot() {
+  cachedSnapshot = {
+    agents: Array.from(store.agents.values()),
+    expanded: store.expanded
+  };
+}
+function notifyListeners() {
+  updateSnapshot();
+  for (const listener of store.listeners) {
+    listener();
+  }
+}
+function generateSubagentId() {
+  return `subagent-${Date.now()}-${++subagentCounter}`;
+}
+function getSubagentByToolCallId(toolCallId) {
+  for (const agent of store.agents.values()) {
+    if (agent.toolCallId === toolCallId) {
+      return agent;
+    }
+  }
+  return;
+}
+function registerSubagent(id, type, description, toolCallId, isBackground, silent) {
+  const displayType = type.charAt(0).toUpperCase() + type.slice(1);
+  const agent = {
+    id,
+    type: displayType,
+    description,
+    status: "pending",
+    agentURL: null,
+    toolCalls: [],
+    maxToolCallsSeen: 0,
+    totalTokens: 0,
+    durationMs: 0,
+    startTime: Date.now(),
+    toolCallId,
+    isBackground,
+    silent
+  };
+  store.agents.set(id, agent);
+  notifyListeners();
+}
+function updateSubagent(id, updates) {
+  const agent = store.agents.get(id);
+  if (!agent)
+    return;
+  if (updates.agentURL && agent.status === "pending") {
+    updates.status = "running";
+  }
+  const nextToolCalls = updates.toolCalls ?? agent.toolCalls;
+  const nextMax = Math.max(agent.maxToolCallsSeen, nextToolCalls.length, updates.maxToolCallsSeen ?? 0);
+  const keys = Object.keys(updates);
+  const isNoop = keys.every((k) => agent[k] === updates[k]) && nextMax === agent.maxToolCallsSeen;
+  if (isNoop)
+    return;
+  const updatedAgent = { ...agent, ...updates, maxToolCallsSeen: nextMax };
+  store.agents.set(id, updatedAgent);
+  notifyListeners();
+}
+function addToolCall(subagentId, toolCallId, toolName, toolArgs) {
+  const agent = store.agents.get(subagentId);
+  if (!agent)
+    return;
+  if (agent.toolCalls.some((tc) => tc.id === toolCallId))
+    return;
+  const updatedAgent = {
+    ...agent,
+    toolCalls: [
+      ...agent.toolCalls,
+      { id: toolCallId, name: toolName, args: toolArgs }
+    ],
+    maxToolCallsSeen: Math.max(agent.maxToolCallsSeen, agent.toolCalls.length + 1)
+  };
+  store.agents.set(subagentId, updatedAgent);
+  notifyListeners();
+}
+function completeSubagent(id, result) {
+  const agent = store.agents.get(id);
+  if (!agent)
+    return;
+  const updatedAgent = {
+    ...agent,
+    status: result.success ? "completed" : "error",
+    error: result.error,
+    durationMs: Date.now() - agent.startTime,
+    totalTokens: result.totalTokens ?? agent.totalTokens,
+    maxToolCallsSeen: Math.max(agent.maxToolCallsSeen, agent.toolCalls.length)
+  };
+  store.agents.set(id, updatedAgent);
+  notifyListeners();
+}
+function getSubagentToolCount(agent) {
+  return Math.max(agent.toolCalls.length, agent.maxToolCallsSeen);
+}
+function toggleExpanded() {
+  store.expanded = !store.expanded;
+  notifyListeners();
+}
+function getSubagents() {
+  return Array.from(store.agents.values());
+}
+function getActiveBackgroundAgents() {
+  return Array.from(store.agents.values()).filter((a) => a.silent === true && (a.status === "pending" || a.status === "running"));
+}
+function clearCompletedSubagents() {
+  for (const [id, agent] of store.agents.entries()) {
+    if (agent.status === "completed" || agent.status === "error") {
+      store.agents.delete(id);
+    }
+  }
+  notifyListeners();
+}
+function clearSubagentsByIds(ids) {
+  for (const id of ids) {
+    store.agents.delete(id);
+  }
+  notifyListeners();
+}
+function hasActiveSubagents() {
+  for (const agent of store.agents.values()) {
+    if (agent.status === "pending" || agent.status === "running") {
+      return true;
+    }
+  }
+  return false;
+}
+function interruptActiveSubagents(errorMessage) {
+  let anyInterrupted = false;
+  for (const [id, agent] of store.agents.entries()) {
+    if (agent.status === "pending" || agent.status === "running") {
+      const updatedAgent = {
+        ...agent,
+        status: "error",
+        error: errorMessage,
+        durationMs: Date.now() - agent.startTime
+      };
+      store.agents.set(id, updatedAgent);
+      anyInterrupted = true;
+    }
+  }
+  if (anyInterrupted) {
+    notifyListeners();
+  }
+}
+function subscribe2(listener) {
+  store.listeners.add(listener);
+  return () => {
+    store.listeners.delete(listener);
+  };
+}
+function getSnapshot2() {
+  return cachedSnapshot;
+}
+function subscribeToStreamEvents(listener) {
+  streamEventListeners.add(listener);
+  return () => {
+    streamEventListeners.delete(listener);
+  };
+}
+function emitStreamEvent(subagentId, event) {
+  for (const listener of streamEventListeners) {
+    listener(subagentId, event);
+  }
+}
+var store, cachedSnapshot, subagentCounter = 0, streamEventListeners;
+var init_subagentState = __esm(() => {
+  store = {
+    agents: new Map,
+    expanded: false,
+    listeners: new Set
+  };
+  cachedSnapshot = {
+    agents: [],
+    expanded: false
+  };
+  streamEventListeners = new Set;
+});
+
 // src/queue/queueRuntime.ts
 function isCoalescable(kind) {
   return kind === "message" || kind === "task_notification";
@@ -40738,6 +40949,7 @@ async function executeSingleDecision(decision, onChunk, options) {
         signal: options?.abortSignal,
         toolCallId: decision.approval.toolCallId,
         toolContextId: options?.toolContextId,
+        parentScope: options?.parentScope,
         onOutput: options?.onStreamingOutput ? (chunk, stream) => options.onStreamingOutput?.(decision.approval.toolCallId, chunk, stream === "stderr") : undefined
       });
       if (onChunk) {
@@ -43157,6 +43369,141 @@ var init_telemetry = __esm(async () => {
   telemetry = new TelemetryManager;
 });
 
+// src/utils/secretsStore.ts
+var exports_secretsStore = {};
+__export(exports_secretsStore, {
+  setSecretOnServer: () => setSecretOnServer,
+  loadSecrets: () => loadSecrets,
+  listSecretNames: () => listSecretNames,
+  initSecretsFromServer: () => initSecretsFromServer,
+  deleteSecretOnServer: () => deleteSecretOnServer,
+  clearSecretsCache: () => clearSecretsCache
+});
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join11 } from "node:path";
+function getAgentId3() {
+  const agentId = storedAgentId || process.env.AGENT_ID || process.env.LETTA_AGENT_ID;
+  if (!agentId) {
+    throw new Error("No agent ID available — call initSecretsFromServer first");
+  }
+  return agentId;
+}
+async function initSecretsFromServer(agentId, memoryDir) {
+  storedAgentId = agentId;
+  if (memoryDir)
+    storedMemoryDir = memoryDir;
+  const client = await getClient2();
+  const agent = await client.agents.retrieve(agentId, {
+    include: ["agent.secrets"]
+  });
+  const secrets2 = {};
+  if (agent.secrets && Array.isArray(agent.secrets)) {
+    for (const env3 of agent.secrets) {
+      if (env3.key && env3.value) {
+        secrets2[env3.key] = env3.value;
+      }
+    }
+  }
+  cachedSecrets = secrets2;
+  syncSecretsToMemoryBlock();
+}
+function loadSecrets() {
+  return cachedSecrets ?? {};
+}
+function listSecretNames() {
+  return Object.keys(loadSecrets()).sort();
+}
+async function setSecretOnServer(key, value) {
+  const client = await getClient2();
+  const agentId = getAgentId3();
+  const secrets2 = { ...loadSecrets() };
+  secrets2[key] = value;
+  await client.agents.update(agentId, { secrets: secrets2 });
+  cachedSecrets = secrets2;
+  syncSecretsToMemoryBlock();
+}
+async function deleteSecretOnServer(key) {
+  const secrets2 = { ...loadSecrets() };
+  if (!(key in secrets2)) {
+    return false;
+  }
+  delete secrets2[key];
+  const client = await getClient2();
+  const agentId = getAgentId3();
+  await client.agents.update(agentId, { secrets: secrets2 });
+  cachedSecrets = secrets2;
+  syncSecretsToMemoryBlock();
+  return true;
+}
+function syncSecretsToMemoryBlock() {
+  const memoryDir = storedMemoryDir || process.env.MEMORY_DIR;
+  if (!memoryDir)
+    return;
+  const names = listSecretNames();
+  const secretsFilePath = join11(memoryDir, "system", "secrets.md");
+  const description = names.length > 0 ? "Available secrets for shell command substitution" : "No secrets configured";
+  const body = names.length > 0 ? `Use \`$SECRET_NAME\` syntax in shell commands to reference these secrets:
+
+${names.map((n) => `- \`$${n}\``).join(`
+`)}` : "";
+  const rendered = `---
+description: ${description}
+---
+
+## Available Secrets
+
+${body}
+`;
+  const systemDir = dirname3(secretsFilePath);
+  if (!existsSync10(systemDir)) {
+    mkdirSync8(systemDir, { recursive: true });
+  }
+  writeFileSync5(secretsFilePath, rendered, "utf8");
+}
+function clearSecretsCache() {
+  cachedSecrets = null;
+}
+var cachedSecrets = null, storedAgentId = null, storedMemoryDir = null;
+var init_secretsStore = __esm(async () => {
+  await init_client2();
+});
+
+// src/tools/secret-substitution.ts
+function substituteSecretsInString(input) {
+  const secrets2 = loadSecrets();
+  return input.replace(SECRET_PATTERN, (match, name) => {
+    const value = secrets2[name];
+    return value !== undefined ? value : match;
+  });
+}
+function substituteSecretsInArgs(args) {
+  const result = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value === "string") {
+      result[key] = substituteSecretsInString(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function scrubSecretsFromString(input) {
+  const secrets2 = loadSecrets();
+  let result = input;
+  const entries = Object.entries(secrets2).sort(([, a], [, b]) => b.length - a.length);
+  for (const [name, value] of entries) {
+    if (value.length > 0) {
+      result = result.replaceAll(value, `$${name}`);
+    }
+  }
+  return result;
+}
+var SECRET_PATTERN;
+var init_secret_substitution = __esm(async () => {
+  await init_secretsStore();
+  SECRET_PATTERN = /\$([A-Z_][A-Z0-9_]*)/g;
+});
+
 // src/tools/descriptions/ApplyPatch.md
 var ApplyPatch_default = `Use the \`apply_patch\` tool to edit files.
 Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
@@ -44859,20 +45206,20 @@ __export(exports_memoryGit, {
 import { execFile as execFileCb } from "node:child_process";
 import {
   chmodSync,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync8,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync9,
   renameSync,
   rmSync,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 function getAgentRootDir(agentId) {
-  return join11(homedir12(), ".letta", "agents", agentId);
+  return join12(homedir12(), ".letta", "agents", agentId);
 }
 function getMemoryRepoDir(agentId) {
-  return join11(getAgentRootDir(agentId), "memory");
+  return join12(getAgentRootDir(agentId), "memory");
 }
 function normalizeCredentialBaseUrl(serverUrl) {
   const trimmed = serverUrl.trim().replace(/\/+$/, "");
@@ -44924,39 +45271,39 @@ async function configureLocalCredentialHelper(dir, token) {
   debugLog("memfs-git", `Configured local credential helper for ${normalizedBaseUrl}${rawBaseUrl !== normalizedBaseUrl ? ` (and raw ${rawBaseUrl})` : ""}`);
 }
 function installPreCommitHook(dir) {
-  const hooksDir = join11(dir, ".git", "hooks");
-  const hookPath = join11(hooksDir, "pre-commit");
-  if (!existsSync10(hooksDir)) {
-    mkdirSync8(hooksDir, { recursive: true });
+  const hooksDir = join12(dir, ".git", "hooks");
+  const hookPath = join12(hooksDir, "pre-commit");
+  if (!existsSync11(hooksDir)) {
+    mkdirSync9(hooksDir, { recursive: true });
   }
-  writeFileSync5(hookPath, PRE_COMMIT_HOOK_SCRIPT, "utf-8");
+  writeFileSync6(hookPath, PRE_COMMIT_HOOK_SCRIPT, "utf-8");
   chmodSync(hookPath, 493);
   debugLog("memfs-git", "Installed pre-commit hook");
 }
 function isGitRepo(agentId) {
-  return existsSync10(join11(getMemoryRepoDir(agentId), ".git"));
+  return existsSync11(join12(getMemoryRepoDir(agentId), ".git"));
 }
 async function cloneMemoryRepo(agentId) {
   const token = await getAuthToken();
   const url = getGitRemoteUrl(agentId);
   const dir = getMemoryRepoDir(agentId);
   debugLog("memfs-git", `Cloning ${url} → ${dir}`);
-  if (!existsSync10(dir)) {
-    mkdirSync8(dir, { recursive: true });
+  if (!existsSync11(dir)) {
+    mkdirSync9(dir, { recursive: true });
     await runGit(dir, ["clone", url, "."], token);
-  } else if (!existsSync10(join11(dir, ".git"))) {
+  } else if (!existsSync11(join12(dir, ".git"))) {
     const tmpDir = `${dir}-git-clone-tmp`;
     try {
-      if (existsSync10(tmpDir)) {
+      if (existsSync11(tmpDir)) {
         rmSync(tmpDir, { recursive: true, force: true });
       }
-      mkdirSync8(tmpDir, { recursive: true });
+      mkdirSync9(tmpDir, { recursive: true });
       await runGit(tmpDir, ["clone", url, "."], token);
-      renameSync(join11(tmpDir, ".git"), join11(dir, ".git"));
+      renameSync(join12(tmpDir, ".git"), join12(dir, ".git"));
       await runGit(dir, ["checkout", "--", "."], token);
       debugLog("memfs-git", "Migrated existing memory directory to git repo");
     } finally {
-      if (existsSync10(tmpDir)) {
+      if (existsSync11(tmpDir)) {
         rmSync(tmpDir, { recursive: true, force: true });
       }
     }
@@ -45699,23 +46046,23 @@ __export(exports_memoryFilesystem, {
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR,
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync9 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function getMemoryFilesystemRoot(agentId, homeDir = homedir13()) {
-  return join12(homeDir, MEMORY_FS_ROOT, MEMORY_FS_AGENTS_DIR, agentId, MEMORY_FS_MEMORY_DIR);
+  return join13(homeDir, MEMORY_FS_ROOT, MEMORY_FS_AGENTS_DIR, agentId, MEMORY_FS_MEMORY_DIR);
 }
 function getMemorySystemDir(agentId, homeDir = homedir13()) {
-  return join12(getMemoryFilesystemRoot(agentId, homeDir), MEMORY_SYSTEM_DIR);
+  return join13(getMemoryFilesystemRoot(agentId, homeDir), MEMORY_SYSTEM_DIR);
 }
 function ensureMemoryFilesystemDirs(agentId, homeDir = homedir13()) {
   const root = getMemoryFilesystemRoot(agentId, homeDir);
   const systemDir = getMemorySystemDir(agentId, homeDir);
-  if (!existsSync11(root)) {
-    mkdirSync9(root, { recursive: true });
+  if (!existsSync12(root)) {
+    mkdirSync10(root, { recursive: true });
   }
-  if (!existsSync11(systemDir)) {
-    mkdirSync9(systemDir, { recursive: true });
+  if (!existsSync12(systemDir)) {
+    mkdirSync10(systemDir, { recursive: true });
   }
 }
 function labelFromRelativePath(relativePath) {
@@ -45883,6 +46230,10 @@ async function applyMemfsFlags(agentId, memfsFlag, noMemfsFlag, options) {
       const result = await pullMemory2(agentId);
       pullSummary = result.summary;
     }
+    const { initSecretsFromServer: initSecretsFromServer2 } = await init_secretsStore().then(() => exports_secretsStore);
+    try {
+      await initSecretsFromServer2(agentId, getMemoryFilesystemRoot(agentId));
+    } catch {}
   }
   const action = memfsFlag || shouldAutoEnableFromTag ? "enabled" : noMemfsFlag ? "disabled" : "unchanged";
   return {
@@ -45922,7 +46273,7 @@ __export(exports_shellEnv, {
   getShellEnv: () => getShellEnv,
   ensureLettaShimDir: () => ensureLettaShimDir
 });
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir } from "node:os";
 import * as path5 from "node:path";
@@ -45995,19 +46346,19 @@ function ensureLettaShimDir(invocation) {
   if (!invocation.command)
     return null;
   const shimDir = path5.join(tmpdir(), "letta-code-shell-shim");
-  mkdirSync10(shimDir, { recursive: true });
+  mkdirSync11(shimDir, { recursive: true });
   if (process.platform === "win32") {
     const cmdPath = path5.join(shimDir, "letta.cmd");
     const quotedCommand = `"${invocation.command.replaceAll('"', '""')}"`;
     const quotedArgs = invocation.args.map((arg) => `"${arg.replaceAll('"', '""')}"`).join(" ");
-    writeFileSync6(cmdPath, `@echo off\r
+    writeFileSync7(cmdPath, `@echo off\r
 ${quotedCommand} ${quotedArgs} %*\r
 `);
     return shimDir;
   }
   const shimPath = path5.join(shimDir, "letta");
   const commandWithArgs = [invocation.command, ...invocation.args].map(shellEscape).join(" ");
-  writeFileSync6(shimPath, `#!/bin/sh
+  writeFileSync7(shimPath, `#!/bin/sh
 exec ${commandWithArgs} "$@"
 `, {
     mode: 493
@@ -47548,7 +47899,7 @@ var init_LS2 = __esm(() => {
 
 // src/tools/impl/LS.ts
 import { readdir as readdir2, stat } from "node:fs/promises";
-import { join as join16, resolve as resolve11 } from "node:path";
+import { join as join17, resolve as resolve11 } from "node:path";
 async function ls(args) {
   validateRequiredParams(args, ["path"], "LS");
   validateParamTypes(args, LS_default2, "LS");
@@ -47558,7 +47909,7 @@ async function ls(args) {
     const items = await readdir2(dirPath);
     const filteredItems = items.filter((item) => !ignore.some((pattern) => import_picomatch2.default.isMatch(item, pattern)));
     const fileInfos = await Promise.all(filteredItems.map(async (item) => {
-      const fullPath = join16(dirPath, item);
+      const fullPath = join17(dirPath, item);
       try {
         const stats = await stat(fullPath);
         return {
@@ -47910,7 +48261,7 @@ var init_runtime = () => {};
 
 // src/tools/impl/Memory.ts
 import { execFile as execFileCb2 } from "node:child_process";
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import {
   mkdir as mkdir2,
   readFile as readFile3,
@@ -47921,7 +48272,7 @@ import {
   writeFile as writeFile2
 } from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute8, relative as relative5, resolve as resolve12 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute8, relative as relative5, resolve as resolve12 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 async function getAgentIdentity() {
   const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
@@ -47963,14 +48314,14 @@ async function memory(args) {
     const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
     const filePath = resolveMemoryFilePath(memoryDir, label);
     const relPath = toRepoRelative(memoryDir, filePath);
-    if (existsSync13(filePath)) {
+    if (existsSync14(filePath)) {
       throw new Error(`memory create: block already exists at ${pathArg}`);
     }
     const body = args.file_text ?? "";
     const rendered = renderMemoryFile({
       description
     }, body);
-    await mkdir2(dirname5(filePath), { recursive: true });
+    await mkdir2(dirname6(filePath), { recursive: true });
     await writeFile2(filePath, rendered, "utf8");
     affectedPaths = [relPath];
   } else if (command === "str_replace") {
@@ -48015,7 +48366,7 @@ async function memory(args) {
     const pathArg = requireString(args.path, "path", "delete");
     const label = normalizeMemoryLabel(memoryDir, pathArg, "path");
     const targetPath = resolveMemoryPath(memoryDir, label);
-    if (existsSync13(targetPath) && (await stat2(targetPath)).isDirectory()) {
+    if (existsSync14(targetPath) && (await stat2(targetPath)).isDirectory()) {
       const relPath = toRepoRelative(memoryDir, targetPath);
       await rm(targetPath, { recursive: true, force: false });
       affectedPaths = [relPath];
@@ -48035,11 +48386,11 @@ async function memory(args) {
     const newFilePath = resolveMemoryFilePath(memoryDir, newLabel);
     const oldRelPath = toRepoRelative(memoryDir, oldFilePath);
     const newRelPath = toRepoRelative(memoryDir, newFilePath);
-    if (existsSync13(newFilePath)) {
+    if (existsSync14(newFilePath)) {
       throw new Error(`memory rename: destination already exists at ${newPathArg}`);
     }
     await loadEditableMemoryFile(oldFilePath, oldPathArg);
-    await mkdir2(dirname5(newFilePath), { recursive: true });
+    await mkdir2(dirname6(newFilePath), { recursive: true });
     await rename(oldFilePath, newFilePath);
     affectedPaths = [oldRelPath, newRelPath];
   } else if (command === "update_description") {
@@ -48092,10 +48443,10 @@ function resolveMemoryDir() {
   throw new Error("memory: unable to resolve memory directory. Ensure MEMORY_DIR (or AGENT_ID) is available.");
 }
 function ensureMemoryRepo(memoryDir) {
-  if (!existsSync13(memoryDir)) {
+  if (!existsSync14(memoryDir)) {
     throw new Error(`memory: memory directory does not exist: ${memoryDir}`);
   }
-  if (!existsSync13(resolve12(memoryDir, ".git"))) {
+  if (!existsSync14(resolve12(memoryDir, ".git"))) {
     throw new Error(`memory: ${memoryDir} is not a git repository. This tool requires a git-backed memory filesystem.`);
   }
 }
@@ -48325,7 +48676,7 @@ var init_Memory2 = __esm(async () => {
 
 // src/tools/impl/MemoryApplyPatch.ts
 import { execFile as execFileCb3 } from "node:child_process";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import {
   access,
   mkdir as mkdir3,
@@ -48336,7 +48687,7 @@ import {
   writeFile as writeFile3
 } from "node:fs/promises";
 import { homedir as homedir16 } from "node:os";
-import { dirname as dirname6, isAbsolute as isAbsolute9, relative as relative6, resolve as resolve13 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute9, relative as relative6, resolve as resolve13 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 async function getAgentIdentity2() {
   const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
@@ -48449,7 +48800,7 @@ async function memory_apply_patch(args) {
     }
   }
   for (const [absPath, content] of pendingWrites.entries()) {
-    await mkdir3(dirname6(absPath), { recursive: true });
+    await mkdir3(dirname7(absPath), { recursive: true });
     await writeFile3(absPath, content, "utf8");
   }
   for (const absPath of pendingDeletes) {
@@ -48628,10 +48979,10 @@ function resolveMemoryDir2() {
   throw new Error("memory_apply_patch: unable to resolve memory directory. Ensure MEMORY_DIR (or AGENT_ID) is available.");
 }
 function ensureMemoryRepo2(memoryDir) {
-  if (!existsSync14(memoryDir)) {
+  if (!existsSync15(memoryDir)) {
     throw new Error(`memory_apply_patch: memory directory does not exist: ${memoryDir}`);
   }
-  if (!existsSync14(resolve13(memoryDir, ".git"))) {
+  if (!existsSync15(resolve13(memoryDir, ".git"))) {
     throw new Error(`memory_apply_patch: ${memoryDir} is not a git repository. This tool requires a git-backed memory filesystem.`);
   }
 }
@@ -48984,12 +49335,12 @@ __export(exports_imageResize_magick, {
   MAX_IMAGE_BYTES: () => MAX_IMAGE_BYTES
 });
 import { execSync } from "node:child_process";
-import { readFileSync as readFileSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync8 } from "node:fs";
+import { readFileSync as readFileSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 async function getImageDimensions(buffer) {
-  const tempInput = join17(tmpdir2(), `image-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync8(tempInput, buffer);
+  const tempInput = join18(tmpdir2(), `image-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  writeFileSync9(tempInput, buffer);
   try {
     const output = execSync(`magick identify -format "%w %h %m" "${tempInput}"`, {
       encoding: "utf-8"
@@ -49011,12 +49362,12 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
   if (buffer.length <= MAX_IMAGE_BYTES) {
     return null;
   }
-  const tempInput = join17(tmpdir2(), `compress-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync8(tempInput, buffer);
+  const tempInput = join18(tmpdir2(), `compress-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  writeFileSync9(tempInput, buffer);
   try {
     const qualities = [85, 70, 55, 40];
     for (const quality of qualities) {
-      const tempOutput = join17(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
+      const tempOutput = join18(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
       try {
         execSync(`magick "${tempInput}" -quality ${quality} "${tempOutput}"`, {
           stdio: "ignore"
@@ -49042,7 +49393,7 @@ async function compressToFitByteLimit(buffer, currentWidth, currentHeight) {
     for (const scale of scales) {
       const scaledWidth = Math.floor(currentWidth * scale);
       const scaledHeight = Math.floor(currentHeight * scale);
-      const tempOutput = join17(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
+      const tempOutput = join18(tmpdir2(), `compress-output-${Date.now()}-${Math.random().toString(36).slice(2)}.jpg`);
       try {
         execSync(`magick "${tempInput}" -resize ${scaledWidth}x${scaledHeight} -quality 70 "${tempOutput}"`, {
           stdio: "ignore"
@@ -49086,11 +49437,11 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
       resized: false
     };
   }
-  const tempInput = join17(tmpdir2(), `resize-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-  writeFileSync8(tempInput, buffer);
+  const tempInput = join18(tmpdir2(), `resize-input-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  writeFileSync9(tempInput, buffer);
   try {
     if (needsResize) {
-      const tempOutput2 = join17(tmpdir2(), `resize-output-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      const tempOutput2 = join18(tmpdir2(), `resize-output-${Date.now()}-${Math.random().toString(36).slice(2)}`);
       let outputBuffer2;
       let outputMediaType;
       if (format2 === "jpeg" || format2 === "jpg") {
@@ -49121,7 +49472,7 @@ async function resizeImageIfNeeded(buffer, inputMediaType) {
         resized: true
       };
     }
-    const tempOutput = join17(tmpdir2(), `convert-output-${Date.now()}-${Math.random().toString(36).slice(2)}.png`);
+    const tempOutput = join18(tmpdir2(), `convert-output-${Date.now()}-${Math.random().toString(36).slice(2)}.png`);
     execSync(`magick "${tempInput}" "${tempOutput}"`, {
       stdio: "ignore"
     });
@@ -61282,8 +61633,8 @@ var init_ignore = __esm(() => {
 // node_modules/glob/dist/esm/processor.js
 class HasWalkedCache {
   store;
-  constructor(store = new Map) {
-    this.store = store;
+  constructor(store2 = new Map) {
+    this.store = store2;
   }
   copy() {
     return new HasWalkedCache(new Map(this.store));
@@ -62184,7 +62535,7 @@ var init_ReplaceGemini2 = __esm(() => {
 });
 
 // src/tools/impl/Shell.ts
-import { existsSync as existsSync15, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync16, statSync as statSync4 } from "node:fs";
 import * as path16 from "node:path";
 async function runProcess(context3) {
   const { stdout, stderr, exitCode } = await spawnWithLauncher(context3.command, {
@@ -62272,7 +62623,7 @@ function arraysEqual(a, b) {
 }
 function isUsableDirectory(candidate) {
   try {
-    return existsSync15(candidate) && statSync4(candidate).isDirectory();
+    return existsSync16(candidate) && statSync4(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -62423,22 +62774,22 @@ __export(exports_skills, {
   SKILLS_DIR: () => SKILLS_DIR,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR
 });
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { readdir as readdir4, readFile as readFile5, realpath as realpath2, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname7, join as join18 } from "node:path";
+import { dirname as dirname8, join as join19 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function getBundledSkillsPath() {
-  const thisDir = dirname7(fileURLToPath7(import.meta.url));
+  const thisDir = dirname8(fileURLToPath7(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join18(thisDir, "../skills/builtin");
+    return join19(thisDir, "../skills/builtin");
   }
-  return join18(thisDir, "skills");
+  return join19(thisDir, "skills");
 }
 function compareSkills(a, b) {
   return a.id.localeCompare(b.id) || a.source.localeCompare(b.source) || a.path.localeCompare(b.path);
 }
 function getAgentSkillsDir(agentId) {
-  return join18(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
+  return join19(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills() {
   const bundledPath = getBundledSkillsPath();
@@ -62447,7 +62798,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors = [];
-  if (!existsSync16(skillsPath)) {
+  if (!existsSync17(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -62461,7 +62812,7 @@ async function discoverSkillsFromDir(skillsPath, source) {
   }
   return { skills, errors };
 }
-async function discoverSkills(projectSkillsPath = join18(process.cwd(), SKILLS_DIR), agentId, options) {
+async function discoverSkills(projectSkillsPath = join19(process.cwd(), SKILLS_DIR), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
@@ -62516,7 +62867,7 @@ async function findSkillFiles(currentPath, rootPath, skills, errors, source, vis
   try {
     const entries = await readdir4(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join18(currentPath, entry.name);
+      const fullPath = join19(currentPath, entry.name);
       try {
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
@@ -62605,7 +62956,7 @@ ${lines.join(`
 var SKILLS_DIR = ".skills", GLOBAL_SKILLS_DIR;
 var init_skills = __esm(() => {
   init_skillSources();
-  GLOBAL_SKILLS_DIR = join18(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  GLOBAL_SKILLS_DIR = join19(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/tools/impl/skillContentRegistry.ts
@@ -62630,10 +62981,10 @@ var init_skillContentRegistry = __esm(() => {
 // src/tools/impl/Skill.ts
 import { readdirSync as readdirSync7 } from "node:fs";
 import { readFile as readFile6 } from "node:fs/promises";
-import { dirname as dirname8, join as join19 } from "node:path";
+import { dirname as dirname9, join as join20 } from "node:path";
 function hasAdditionalFiles(skillMdPath) {
   try {
-    const skillDir = dirname8(skillMdPath);
+    const skillDir = dirname9(skillMdPath);
     const entries = readdirSync7(skillDir);
     return entries.some((e) => e.toUpperCase() !== "SKILL.MD");
   } catch {
@@ -62641,19 +62992,19 @@ function hasAdditionalFiles(skillMdPath) {
   }
 }
 async function readSkillContent(skillId, skillsDir, agentId) {
-  const projectSkillPath = join19(skillsDir, skillId, "SKILL.md");
+  const projectSkillPath = join20(skillsDir, skillId, "SKILL.md");
   try {
     const content = await readFile6(projectSkillPath, "utf-8");
     return { content, path: projectSkillPath };
   } catch {}
   if (agentId) {
-    const agentSkillPath = join19(getAgentSkillsDir(agentId), skillId, "SKILL.md");
+    const agentSkillPath = join20(getAgentSkillsDir(agentId), skillId, "SKILL.md");
     try {
       const content = await readFile6(agentSkillPath, "utf-8");
       return { content, path: agentSkillPath };
     } catch {}
   }
-  const globalSkillPath = join19(GLOBAL_SKILLS_DIR, skillId, "SKILL.md");
+  const globalSkillPath = join20(GLOBAL_SKILLS_DIR, skillId, "SKILL.md");
   try {
     const content = await readFile6(globalSkillPath, "utf-8");
     return { content, path: globalSkillPath };
@@ -62667,8 +63018,8 @@ async function readSkillContent(skillId, skillsDir, agentId) {
     } catch {}
   }
   try {
-    const bundledSkillsDir = join19(process.cwd(), "skills", "skills");
-    const bundledSkillPath = join19(bundledSkillsDir, skillId, "SKILL.md");
+    const bundledSkillsDir = join20(process.cwd(), "skills", "skills");
+    const bundledSkillPath = join20(bundledSkillsDir, skillId, "SKILL.md");
     const content = await readFile6(bundledSkillPath, "utf-8");
     return { content, path: bundledSkillPath };
   } catch {
@@ -62680,7 +63031,7 @@ async function getResolvedSkillsDir() {
   if (skillsDir) {
     return skillsDir;
   }
-  return join19(process.cwd(), SKILLS_DIR);
+  return join20(process.cwd(), SKILLS_DIR);
 }
 async function skill(args) {
   validateRequiredParams(args, ["skill"], "Skill");
@@ -62692,7 +63043,7 @@ async function skill(args) {
     const agentId = getCurrentAgentId();
     const skillsDir = await getResolvedSkillsDir();
     const { content: skillContent, path: skillPath } = await readSkillContent(skillName, skillsDir, agentId);
-    const skillDir = dirname8(skillPath);
+    const skillDir = dirname9(skillPath);
     const hasExtras = hasAdditionalFiles(skillPath);
     const processedContent = hasExtras ? skillContent.replace(/<SKILL_DIR>/g, skillDir) : skillContent;
     const dirHeader = hasExtras ? `# Skill Directory: ${skillDir}
@@ -62718,174 +63069,6 @@ var init_Skill2 = __esm(() => {
   init_skillContentRegistry();
 });
 
-// src/cli/helpers/subagentState.ts
-function updateSnapshot() {
-  cachedSnapshot = {
-    agents: Array.from(store.agents.values()),
-    expanded: store.expanded
-  };
-}
-function notifyListeners() {
-  updateSnapshot();
-  for (const listener of store.listeners) {
-    listener();
-  }
-}
-function generateSubagentId() {
-  return `subagent-${Date.now()}-${++subagentCounter}`;
-}
-function getSubagentByToolCallId(toolCallId) {
-  for (const agent of store.agents.values()) {
-    if (agent.toolCallId === toolCallId) {
-      return agent;
-    }
-  }
-  return;
-}
-function registerSubagent(id, type, description, toolCallId, isBackground, silent) {
-  const displayType = type.charAt(0).toUpperCase() + type.slice(1);
-  const agent = {
-    id,
-    type: displayType,
-    description,
-    status: "pending",
-    agentURL: null,
-    toolCalls: [],
-    maxToolCallsSeen: 0,
-    totalTokens: 0,
-    durationMs: 0,
-    startTime: Date.now(),
-    toolCallId,
-    isBackground,
-    silent
-  };
-  store.agents.set(id, agent);
-  notifyListeners();
-}
-function updateSubagent(id, updates) {
-  const agent = store.agents.get(id);
-  if (!agent)
-    return;
-  if (updates.agentURL && agent.status === "pending") {
-    updates.status = "running";
-  }
-  const nextToolCalls = updates.toolCalls ?? agent.toolCalls;
-  const nextMax = Math.max(agent.maxToolCallsSeen, nextToolCalls.length, updates.maxToolCallsSeen ?? 0);
-  const keys = Object.keys(updates);
-  const isNoop = keys.every((k) => agent[k] === updates[k]) && nextMax === agent.maxToolCallsSeen;
-  if (isNoop)
-    return;
-  const updatedAgent = { ...agent, ...updates, maxToolCallsSeen: nextMax };
-  store.agents.set(id, updatedAgent);
-  notifyListeners();
-}
-function addToolCall(subagentId, toolCallId, toolName, toolArgs) {
-  const agent = store.agents.get(subagentId);
-  if (!agent)
-    return;
-  if (agent.toolCalls.some((tc) => tc.id === toolCallId))
-    return;
-  const updatedAgent = {
-    ...agent,
-    toolCalls: [
-      ...agent.toolCalls,
-      { id: toolCallId, name: toolName, args: toolArgs }
-    ],
-    maxToolCallsSeen: Math.max(agent.maxToolCallsSeen, agent.toolCalls.length + 1)
-  };
-  store.agents.set(subagentId, updatedAgent);
-  notifyListeners();
-}
-function completeSubagent(id, result) {
-  const agent = store.agents.get(id);
-  if (!agent)
-    return;
-  const updatedAgent = {
-    ...agent,
-    status: result.success ? "completed" : "error",
-    error: result.error,
-    durationMs: Date.now() - agent.startTime,
-    totalTokens: result.totalTokens ?? agent.totalTokens,
-    maxToolCallsSeen: Math.max(agent.maxToolCallsSeen, agent.toolCalls.length)
-  };
-  store.agents.set(id, updatedAgent);
-  notifyListeners();
-}
-function getSubagentToolCount(agent) {
-  return Math.max(agent.toolCalls.length, agent.maxToolCallsSeen);
-}
-function toggleExpanded() {
-  store.expanded = !store.expanded;
-  notifyListeners();
-}
-function getSubagents() {
-  return Array.from(store.agents.values());
-}
-function getActiveBackgroundAgents() {
-  return Array.from(store.agents.values()).filter((a) => a.silent === true && (a.status === "pending" || a.status === "running"));
-}
-function clearCompletedSubagents() {
-  for (const [id, agent] of store.agents.entries()) {
-    if (agent.status === "completed" || agent.status === "error") {
-      store.agents.delete(id);
-    }
-  }
-  notifyListeners();
-}
-function clearSubagentsByIds(ids) {
-  for (const id of ids) {
-    store.agents.delete(id);
-  }
-  notifyListeners();
-}
-function hasActiveSubagents() {
-  for (const agent of store.agents.values()) {
-    if (agent.status === "pending" || agent.status === "running") {
-      return true;
-    }
-  }
-  return false;
-}
-function interruptActiveSubagents(errorMessage) {
-  let anyInterrupted = false;
-  for (const [id, agent] of store.agents.entries()) {
-    if (agent.status === "pending" || agent.status === "running") {
-      const updatedAgent = {
-        ...agent,
-        status: "error",
-        error: errorMessage,
-        durationMs: Date.now() - agent.startTime
-      };
-      store.agents.set(id, updatedAgent);
-      anyInterrupted = true;
-    }
-  }
-  if (anyInterrupted) {
-    notifyListeners();
-  }
-}
-function subscribe2(listener) {
-  store.listeners.add(listener);
-  return () => {
-    store.listeners.delete(listener);
-  };
-}
-function getSnapshot2() {
-  return cachedSnapshot;
-}
-var store, cachedSnapshot, subagentCounter = 0;
-var init_subagentState = __esm(() => {
-  store = {
-    agents: new Map,
-    expanded: false,
-    listeners: new Set
-  };
-  cachedSnapshot = {
-    agents: [],
-    expanded: false
-  };
-});
-
 // src/permissions/canonical.ts
 function canonicalToolName(toolName) {
   if (SHELL_TOOL_NAMES.has(toolName))
@@ -63279,6 +63462,8 @@ function processStreamEvent(line, state, subagentId) {
       case "message":
         if (event.message_type === "approval_request_message") {
           handleApprovalRequestEvent(event, state);
+        } else {
+          emitStreamEvent(subagentId, event);
         }
         break;
       case "auto_approval":
@@ -63632,31 +63817,6 @@ var init_manager2 = __esm(async () => {
   };
 });
 
-// src/cli/helpers/messageQueueBridge.ts
-function setMessageQueueAdder(fn) {
-  queueAdder = fn;
-  if (queueAdder && pendingMessages.length > 0) {
-    for (const message of pendingMessages) {
-      queueAdder(message);
-    }
-    pendingMessages.length = 0;
-  }
-}
-function addToMessageQueue(message) {
-  if (queueAdder) {
-    queueAdder(message);
-    return;
-  }
-  if (pendingMessages.length >= MAX_PENDING_MESSAGES) {
-    pendingMessages.shift();
-  }
-  pendingMessages.push(message);
-}
-var queueAdder = null, pendingMessages, MAX_PENDING_MESSAGES = 10;
-var init_messageQueueBridge = __esm(() => {
-  pendingMessages = [];
-});
-
 // src/cli/helpers/taskNotifications.ts
 function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -63737,11 +63897,13 @@ __export(exports_Task, {
   task: () => task,
   spawnBackgroundSubagentTask: () => spawnBackgroundSubagentTask
 });
-function buildTaskResultHeader(subagentType, result) {
+function buildTaskResultHeader(subagentType, subagentId, result, status) {
   return [
     `subagent_type=${subagentType}`,
-    result.agentId ? `agent_id=${result.agentId}` : undefined,
-    result.conversationId ? `conversation_id=${result.conversationId}` : undefined
+    `subagent_id=${subagentId}`,
+    status ? `subagent_status=${status}` : undefined,
+    result?.agentId ? `agent_id=${result.agentId}` : undefined,
+    result?.conversationId ? `conversation_id=${result.conversationId}` : undefined
   ].filter(Boolean).join(" ");
 }
 function writeTaskTranscriptStart(outputFile, description, subagentType) {
@@ -63760,7 +63922,9 @@ ${result.report}
 `);
     return;
   }
-  appendToOutputFile(outputFile, `[error] ${result.error || "Subagent execution failed"}
+  appendToOutputFile(outputFile, `${header ? `${header}
+
+` : ""}[error] ${result.error || "Subagent execution failed"}
 
 [Task failed]
 `);
@@ -63800,6 +63964,7 @@ function spawnBackgroundSubagentTask(args) {
     existingAgentId,
     existingConversationId,
     maxTurns,
+    parentScope,
     silentCompletion,
     onComplete,
     deps
@@ -63834,7 +63999,7 @@ function spawnBackgroundSubagentTask(args) {
     if (result.error) {
       bgTask.error = result.error;
     }
-    const header = buildTaskResultHeader(subagentType, result);
+    const header = buildTaskResultHeader(subagentType, subagentId, result, result.success ? "success" : "error");
     writeTaskTranscriptResult(outputFile, result, header);
     if (result.success) {
       bgTask.output.push(result.report || "");
@@ -63857,7 +64022,9 @@ function spawnBackgroundSubagentTask(args) {
       const durationMs = Math.max(0, Date.now() - bgTask.startTime.getTime());
       const fullResult = result.success ? `${header}
 
-${result.report || ""}` : result.error || "Subagent execution failed";
+${result.report || ""}` : `${header}
+
+Error: ${result.error || "Subagent execution failed"}`;
       const userCwd = process.env.USER_CWD || process.cwd();
       const { content: truncatedResult } = truncateByChars(fullResult, LIMITS.TASK_OUTPUT_CHARS, "Task", { workingDirectory: userCwd, toolName: "Task" });
       const notificationXml = formatTaskNotificationFn({
@@ -63874,7 +64041,9 @@ ${result.report || ""}` : result.error || "Subagent execution failed";
       });
       addToMessageQueueFn({
         kind: "task_notification",
-        text: notificationXml
+        text: notificationXml,
+        agentId: parentScope?.agentId,
+        conversationId: parentScope?.conversationId
       });
     }
     runSubagentStopHooksFn(subagentType, subagentId, result.success, result.error, result.agentId, result.conversationId).catch(() => {});
@@ -63896,11 +64065,17 @@ ${result.report || ""}` : result.error || "Subagent execution failed";
       const subagentSnapshot = getSubagentSnapshotFn();
       const subagentEntry = subagentSnapshot.agents.find((agent) => agent.id === subagentId);
       const durationMs = Math.max(0, Date.now() - bgTask.startTime.getTime());
+      const header = buildTaskResultHeader(subagentType, subagentId, {
+        agentId: existingAgentId ?? "",
+        conversationId: existingConversationId
+      }, "error");
       const notificationXml = formatTaskNotificationFn({
         taskId,
         status: "failed",
         summary: `Agent "${description}" failed`,
-        result: errorMessage,
+        result: `${header}
+
+Error: ${errorMessage}`,
         outputFile,
         usage: {
           toolUses: subagentEntry === undefined ? undefined : getSubagentToolCount(subagentEntry),
@@ -63909,7 +64084,9 @@ ${result.report || ""}` : result.error || "Subagent execution failed";
       });
       addToMessageQueueFn({
         kind: "task_notification",
-        text: notificationXml
+        text: notificationXml,
+        agentId: parentScope?.agentId,
+        conversationId: parentScope?.conversationId
       });
     }
     runSubagentStopHooksFn(subagentType, subagentId, false, errorMessage, existingAgentId, existingConversationId).catch(() => {});
@@ -63960,7 +64137,8 @@ async function task(args) {
       toolCallId,
       existingAgentId: args.agent_id,
       existingConversationId: args.conversation_id,
-      maxTurns: args.max_turns
+      maxTurns: args.max_turns,
+      parentScope: args.parentScope
     });
     await waitForBackgroundSubagentLink(subagentId2, null, signal);
     const linkedAgent = getSnapshot2().agents.find((a) => a.id === subagentId2);
@@ -63991,11 +64169,14 @@ You will be notified automatically when this task completes — a <task-notifica
         ...result,
         error: errorMessage
       };
-      writeTaskTranscriptResult(outputFile, failedResult, "");
-      return `Error: ${errorMessage}
+      const header2 = buildTaskResultHeader(subagent_type, subagentId, failedResult, "error");
+      writeTaskTranscriptResult(outputFile, failedResult, header2);
+      return `${header2}
+
+Error: ${errorMessage}
 Output file: ${outputFile}`;
     }
-    const header = buildTaskResultHeader(subagent_type, result);
+    const header = buildTaskResultHeader(subagent_type, subagentId, result, "success");
     const fullOutput = `${header}
 
 ${result.report}`;
@@ -64006,13 +64187,21 @@ ${result.report}`;
 Output file: ${outputFile}`;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    const header = buildTaskResultHeader(subagent_type, subagentId, {
+      agentId: args.agent_id ?? "",
+      conversationId: args.conversation_id
+    }, "error");
     completeSubagent(subagentId, { success: false, error: errorMessage });
     runSubagentStopHooks(subagent_type, subagentId, false, errorMessage, args.agent_id, args.conversation_id).catch(() => {});
-    appendToOutputFile(outputFile, `[error] ${errorMessage}
+    appendToOutputFile(outputFile, `${header}
+
+[error] ${errorMessage}
 
 [Task failed]
 `);
-    return `Error: ${errorMessage}
+    return `${header}
+
+Error: ${errorMessage}
 Output file: ${outputFile}`;
   }
 }
@@ -67675,13 +67864,13 @@ __export(exports_loader, {
   getUserSettingsPaths: () => getUserSettingsPaths
 });
 import { homedir as homedir17 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function getUserSettingsPaths(options = {}) {
   const homeDir = options.homeDir || homedir17();
-  const xdgConfigHome = options.xdgConfigHome || process.env.XDG_CONFIG_HOME || join20(homeDir, ".config");
+  const xdgConfigHome = options.xdgConfigHome || process.env.XDG_CONFIG_HOME || join21(homeDir, ".config");
   return {
-    canonical: join20(homeDir, ".letta", "settings.json"),
-    legacy: join20(xdgConfigHome, "letta", "settings.json")
+    canonical: join21(homeDir, ".letta", "settings.json"),
+    legacy: join21(xdgConfigHome, "letta", "settings.json")
   };
 }
 async function loadPermissions(workingDirectory = process.cwd()) {
@@ -67695,8 +67884,8 @@ async function loadPermissions(workingDirectory = process.cwd()) {
   const sources = [
     legacyUserSettingsPath,
     userSettingsPath,
-    join20(workingDirectory, ".letta", "settings.json"),
-    join20(workingDirectory, ".letta", "settings.local.json")
+    join21(workingDirectory, ".letta", "settings.json"),
+    join21(workingDirectory, ".letta", "settings.local.json")
   ];
   for (const settingsPath of sources) {
     try {
@@ -67744,10 +67933,10 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
       settingsPath = getUserSettingsPaths().canonical;
       break;
     case "project":
-      settingsPath = join20(workingDirectory, ".letta", "settings.json");
+      settingsPath = join21(workingDirectory, ".letta", "settings.json");
       break;
     case "local":
-      settingsPath = join20(workingDirectory, ".letta", "settings.local.json");
+      settingsPath = join21(workingDirectory, ".letta", "settings.local.json");
       break;
   }
   let settings = {};
@@ -67773,7 +67962,7 @@ async function savePermissionRule(rule, ruleType, scope, workingDirectory = proc
   }
 }
 async function ensureLocalSettingsIgnored(workingDirectory) {
-  const gitignorePath = join20(workingDirectory, ".gitignore");
+  const gitignorePath = join21(workingDirectory, ".gitignore");
   const pattern = ".letta/settings.local.json";
   try {
     let content = "";
@@ -67800,7 +67989,7 @@ __export(exports_analyzer, {
   analyzeApprovalContext: () => analyzeApprovalContext
 });
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname10, relative as relative8, resolve as resolve22, win32 as win322 } from "node:path";
+import { dirname as dirname11, relative as relative8, resolve as resolve22, win32 as win322 } from "node:path";
 function normalizeOsPath(path20) {
   return path20.replace(/\\/g, "/");
 }
@@ -67826,7 +68015,7 @@ function isPathWithinDirectory(path20, directory) {
   return !relativePath.startsWith("../") && relativePath !== ".." && !relativePath.startsWith("/") && !/^[a-zA-Z]:\//.test(relativePath);
 }
 function dirnameForContext(path20) {
-  return isWindowsPath(path20) ? win322.dirname(path20) : dirname10(path20);
+  return isWindowsPath(path20) ? win322.dirname(path20) : dirname11(path20);
 }
 function formatAbsoluteRulePath(path20) {
   const normalized = normalizeOsPath(path20).replace(/\/+$/, "");
@@ -67887,7 +68076,7 @@ function analyzeReadApproval(filePath, workingDir) {
     };
   }
   const relativePath = normalizeOsPath(relativePathForContext(workingDir, absolutePath));
-  const relativeDir = dirname10(relativePath);
+  const relativeDir = dirname11(relativePath);
   const pattern = relativeDir === "." || relativeDir === "" ? "**" : `${relativeDir}/**`;
   return {
     recommendedRule: `Read(${pattern})`,
@@ -68972,6 +69161,7 @@ async function executeTool(name, args, options) {
       if (options?.onOutput) {
         enhancedArgs = { ...enhancedArgs, onOutput: options.onOutput };
       }
+      enhancedArgs = substituteSecretsInArgs(enhancedArgs);
     }
     if (internalName === "Task") {
       if (options?.toolCallId) {
@@ -68980,6 +69170,9 @@ async function executeTool(name, args, options) {
       if (options?.signal) {
         enhancedArgs = { ...enhancedArgs, signal: options.signal };
       }
+      if (options?.parentScope) {
+        enhancedArgs = { ...enhancedArgs, parentScope: options.parentScope };
+      }
     }
     if (internalName === "Skill" && options?.toolCallId) {
       enhancedArgs = { ...enhancedArgs, toolCallId: options.toolCallId };
@@ -69007,7 +69200,24 @@ async function executeTool(name, args, options) {
     const stdout = isStringArray(stdoutValue) ? stdoutValue : undefined;
     const stderr = isStringArray(stderrValue) ? stderrValue : undefined;
     const toolStatus = recordResult?.status === "error" ? "error" : "success";
-    const flattenedResponse = flattenToolResponse(result);
+    let flattenedResponse = flattenToolResponse(result);
+    if (STREAMING_SHELL_TOOLS.has(internalName)) {
+      if (typeof flattenedResponse === "string") {
+        flattenedResponse = scrubSecretsFromString(flattenedResponse);
+      } else if (Array.isArray(flattenedResponse)) {
+        flattenedResponse = flattenedResponse.map((block) => block.type === "text" ? { ...block, text: scrubSecretsFromString(block.text) } : block);
+      }
+      if (stdout) {
+        for (let i = 0;i < stdout.length; i++) {
+          stdout[i] = scrubSecretsFromString(stdout[i]);
+        }
+      }
+      if (stderr) {
+        for (let i = 0;i < stderr.length; i++) {
+          stderr[i] = scrubSecretsFromString(stderr[i]);
+        }
+      }
+    }
     const responseSize = typeof flattenedResponse === "string" ? flattenedResponse.length : JSON.stringify(flattenedResponse).length;
     telemetry.trackToolUsage(internalName, toolStatus === "success", duration, responseSize, toolStatus === "error" ? "tool_error" : undefined, stderr ? stderr.join(`
 `) : undefined);
@@ -69133,6 +69343,7 @@ var init_manager3 = __esm(async () => {
     init_hooks(),
     init_openai_codex_provider(),
     init_telemetry(),
+    init_secret_substitution(),
     init_toolDefinitions()
   ]);
   FILE_MODIFYING_TOOLS = new Set([
@@ -69528,7 +69739,7 @@ var init_constants2 = __esm(() => {
 });
 
 // src/websocket/listener/remote-settings.ts
-import { existsSync as existsSync17, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync8 } from "node:fs";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir19 } from "node:os";
 import path20 from "node:path";
@@ -69542,7 +69753,7 @@ function loadRemoteSettings() {
   let loaded = {};
   try {
     const settingsPath = getRemoteSettingsPath();
-    if (existsSync17(settingsPath)) {
+    if (existsSync18(settingsPath)) {
       const raw = readFileSync8(settingsPath, "utf-8");
       const parsed = JSON.parse(raw);
       loaded = parsed;
@@ -69551,7 +69762,7 @@ function loadRemoteSettings() {
   if (loaded.cwdMap) {
     const validCwdMap = {};
     for (const [key, value] of Object.entries(loaded.cwdMap)) {
-      if (typeof value === "string" && existsSync17(value)) {
+      if (typeof value === "string" && existsSync18(value)) {
         validCwdMap[key] = value;
       }
     }
@@ -69578,13 +69789,13 @@ function saveRemoteSettings(updates) {
 function loadLegacyCwdCache() {
   try {
     const legacyPath = path20.join(homedir19(), ".letta", "cwd-cache.json");
-    if (!existsSync17(legacyPath))
+    if (!existsSync18(legacyPath))
       return {};
     const raw = readFileSync8(legacyPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = {};
     for (const [key, value] of Object.entries(parsed)) {
-      if (typeof value === "string" && existsSync17(value)) {
+      if (typeof value === "string" && existsSync18(value)) {
         result[key] = value;
       }
     }
@@ -69991,6 +70202,38 @@ function emitStateSync(socket, runtime, scope) {
   emitDeviceStatusUpdate(socket, runtime, scope);
   emitLoopStatusUpdate(socket, runtime, scope);
   emitQueueUpdate(socket, runtime, scope);
+  emitSubagentStateUpdate(socket, runtime, scope);
+}
+function buildSubagentSnapshot() {
+  return getSubagents().filter((a) => !a.silent && (a.status === "pending" || a.status === "running")).map((a) => ({
+    subagent_id: a.id,
+    subagent_type: a.type,
+    description: a.description,
+    status: a.status,
+    agent_url: a.agentURL,
+    model: a.model,
+    is_background: a.isBackground,
+    silent: a.silent,
+    tool_call_id: a.toolCallId,
+    start_time: a.startTime,
+    tool_calls: a.toolCalls,
+    total_tokens: a.totalTokens,
+    duration_ms: a.durationMs,
+    error: a.error
+  }));
+}
+function emitSubagentStateUpdate(socket, runtime, scope) {
+  const message = {
+    type: "update_subagent_state",
+    subagents: buildSubagentSnapshot()
+  };
+  emitProtocolV2Message(socket, runtime, message, scope);
+}
+function emitSubagentStateIfOpen(runtime, scope) {
+  const listener = getListenerRuntime(runtime);
+  if (listener?.socket?.readyState === WebSocket2.OPEN) {
+    emitSubagentStateUpdate(listener.socket, runtime, scope);
+  }
 }
 function scheduleQueueEmit(runtime, scope) {
   runtime.pendingQueueEmitScope = scope;
@@ -70060,15 +70303,17 @@ function emitInterruptedStatusDelta(socket, runtime, params) {
     conversationId: params.conversationId ?? undefined
   });
 }
-function emitStreamDelta(socket, runtime, delta, scope) {
+function emitStreamDelta(socket, runtime, delta, scope, subagentId) {
   const message = {
     type: "stream_delta",
-    delta
+    delta,
+    ...subagentId ? { subagent_id: subagentId } : {}
   };
   emitProtocolV2Message(socket, runtime, message, scope);
 }
 var init_protocol_outbound = __esm(async () => {
   init_memoryFilesystem();
+  init_subagentState();
   init_mode();
   init_constants2();
   init_cwd();
@@ -71029,7 +71274,22 @@ function buildQueuedTurnMessage(runtime, batch) {
     for (const item of batch.items) {
       runtime.queuedMessagesByItemId.delete(item.id);
     }
-    return null;
+    const mergedContent2 = mergeDequeuedBatchContent(batch.items);
+    if (mergedContent2 === null) {
+      return null;
+    }
+    const scopeItem = batch.items[0];
+    return {
+      type: "message",
+      agentId: scopeItem?.agentId ?? runtime.agentId ?? undefined,
+      conversationId: scopeItem?.conversationId ?? runtime.conversationId,
+      messages: [
+        {
+          role: "user",
+          content: mergedContent2
+        }
+      ]
+    };
   }
   const template = runtime.queuedMessagesByItemId.get(primaryItem.id);
   for (const item of batch.items) {
@@ -71069,6 +71329,7 @@ function consumeQueuedTurn(runtime) {
   }
   let queueLen = 0;
   let hasMessage = false;
+  let hasTaskNotification = false;
   for (const item of queuedItems) {
     if (!isCoalescable(item.kind) || !hasSameQueueScope(firstQueuedItem, item)) {
       break;
@@ -71077,8 +71338,11 @@ function consumeQueuedTurn(runtime) {
     if (item.kind === "message") {
       hasMessage = true;
     }
+    if (item.kind === "task_notification") {
+      hasTaskNotification = true;
+    }
   }
-  if (!hasMessage || queueLen === 0) {
+  if (!hasMessage && !hasTaskNotification || queueLen === 0) {
     return null;
   }
   const dequeuedBatch = runtime.queueRuntime.consumeItems(queueLen);
@@ -71965,6 +72229,9 @@ function isCloudflareEdge52xDetail(detail) {
     return false;
   return isCloudflareEdge52xHtmlError2(detail);
 }
+function isQuotaLimitErrorDetail(detail) {
+  return hasNonRetryableQuotaDetail(detail);
+}
 function hasNonRetryableQuotaDetail(detail) {
   if (typeof detail !== "string")
     return false;
@@ -73421,7 +73688,7 @@ var init_accumulator = __esm(async () => {
 });
 
 // src/agent/clientSkills.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function toClientSkill(skill2) {
   return {
     name: skill2.id,
@@ -73430,37 +73697,64 @@ function toClientSkill(skill2) {
   };
 }
 function resolveSkillDiscoveryContext(options) {
-  const skillsDirectory = options.skillsDirectory ?? getSkillsDirectory() ?? join21(process.cwd(), SKILLS_DIR);
+  const legacySkillsDirectory = options.skillsDirectory ?? getSkillsDirectory() ?? join22(process.cwd(), SKILLS_DIR);
   const skillSources = options.skillSources ?? getSkillSources();
-  return { skillsDirectory, skillSources };
+  return { legacySkillsDirectory, skillSources };
+}
+function getPrimaryProjectSkillsDirectory() {
+  return join22(process.cwd(), ".agents", "skills");
 }
 async function buildClientSkillsPayload(options = {}) {
-  const { skillsDirectory, skillSources } = resolveSkillDiscoveryContext(options);
+  const { legacySkillsDirectory, skillSources } = resolveSkillDiscoveryContext(options);
   const discoverSkillsFn = options.discoverSkillsFn ?? discoverSkills;
-  try {
-    const discovery = await discoverSkillsFn(skillsDirectory, options.agentId, {
-      sources: skillSources
+  const skillsById = new Map;
+  const errors = [];
+  const primaryProjectSkillsDirectory = getPrimaryProjectSkillsDirectory();
+  const nonProjectSources = skillSources.filter((source) => source !== "project");
+  const discoveryRuns = [];
+  if (nonProjectSources.length > 0) {
+    discoveryRuns.push({
+      path: primaryProjectSkillsDirectory,
+      sources: nonProjectSources
     });
-    const sortedSkills = [...discovery.skills].sort(compareSkills);
-    return {
-      clientSkills: sortedSkills.map(toClientSkill),
-      skillPathById: Object.fromEntries(sortedSkills.filter((skill2) => typeof skill2.path === "string" && skill2.path.length > 0).map((skill2) => [skill2.id, skill2.path])),
-      errors: discovery.errors
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : `Unknown error: ${String(error)}`;
-    options.logger?.(`Failed to build client_skills payload: ${message}`);
-    return {
-      clientSkills: [],
-      skillPathById: {},
-      errors: [
-        {
-          path: skillsDirectory,
-          message
-        }
-      ]
-    };
   }
+  const includeProjectSource = skillSources.includes("project");
+  if (includeProjectSource && legacySkillsDirectory !== primaryProjectSkillsDirectory) {
+    discoveryRuns.push({
+      path: legacySkillsDirectory,
+      sources: ["project"]
+    });
+  }
+  if (includeProjectSource) {
+    discoveryRuns.push({
+      path: primaryProjectSkillsDirectory,
+      sources: ["project"]
+    });
+  }
+  for (const run of discoveryRuns) {
+    try {
+      const discovery = await discoverSkillsFn(run.path, options.agentId, {
+        sources: run.sources
+      });
+      errors.push(...discovery.errors);
+      for (const skill2 of discovery.skills) {
+        skillsById.set(skill2.id, skill2);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : `Unknown error: ${String(error)}`;
+      errors.push({ path: run.path, message });
+    }
+  }
+  const sortedSkills = [...skillsById.values()].sort(compareSkills);
+  if (errors.length > 0) {
+    const summarizedErrors = errors.map((error) => `${error.path}: ${error.message}`);
+    options.logger?.(`Failed to build some client_skills entries: ${summarizedErrors.join("; ")}`);
+  }
+  return {
+    clientSkills: sortedSkills.map(toClientSkill),
+    skillPathById: Object.fromEntries(sortedSkills.filter((skill2) => typeof skill2.path === "string" && skill2.path.length > 0).map((skill2) => [skill2.id, skill2.path])),
+    errors
+  };
 }
 var init_clientSkills = __esm(() => {
   init_context();
@@ -73491,6 +73785,7 @@ function buildConversationMessagesCreateRequestBody(conversationId, messages, op
     client_skills: clientSkills,
     client_tools: clientTools,
     include_compaction_messages: true,
+    ...opts.overrideModel ? { override_model: opts.overrideModel } : {},
     ...isDefaultConversation ? { agent_id: opts.agentId } : {}
   };
 }
@@ -73535,7 +73830,8 @@ async function sendMessageStream(conversationId, messages, opts = { streamTokens
     }
     return `message:parts:${content.length}`;
   }).join(",");
-  debugLog("send-message-stream", "request_start conversation_id=%s agent_id=%s messages=%s stream_tokens=%s background=%s max_retries=%s", resolvedConversationId, opts.agentId ?? "none", messageSummary || "(empty)", opts.streamTokens ?? true, opts.background ?? true, requestOptions.maxRetries ?? "default");
+  const firstOtid = messages[0]?.otid;
+  debugLog("send-message-stream", "request_start conversation_id=%s agent_id=%s messages=%s otid=%s stream_tokens=%s background=%s max_retries=%s", resolvedConversationId, opts.agentId ?? "none", messageSummary || "(empty)", firstOtid ?? "none", opts.streamTokens ?? true, opts.background ?? true, requestOptions.maxRetries ?? "default");
   let stream2;
   try {
     stream2 = await client.conversations.messages.create(resolvedConversationId, requestBody, {
@@ -73546,10 +73842,10 @@ async function sendMessageStream(conversationId, messages, opts = { streamTokens
       }
     });
   } catch (error) {
-    debugWarn("send-message-stream", "request_error conversation_id=%s status=%s error=%s", resolvedConversationId, error?.status ?? "none", error instanceof Error ? error.message : String(error));
+    debugWarn("send-message-stream", "request_error conversation_id=%s otid=%s status=%s error=%s", resolvedConversationId, firstOtid ?? "none", error?.status ?? "none", error instanceof Error ? error.message : String(error));
     throw error;
   }
-  debugLog("send-message-stream", "request_ok conversation_id=%s", resolvedConversationId);
+  debugLog("send-message-stream", "request_ok conversation_id=%s otid=%s", resolvedConversationId, firstOtid ?? "none");
   if (requestStartTime !== undefined) {
     streamRequestStartTimes.set(stream2, requestStartTime);
   }
@@ -73558,7 +73854,8 @@ async function sendMessageStream(conversationId, messages, opts = { streamTokens
     conversationId,
     resolvedConversationId,
     agentId: opts.agentId ?? null,
-    requestStartedAtMs
+    requestStartedAtMs,
+    otid: firstOtid
   });
   return stream2;
 }
@@ -73580,14 +73877,14 @@ var init_message = __esm(async () => {
 
 // src/cli/helpers/chunkLog.ts
 import {
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync13,
   readdirSync as readdirSync8,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function truncateStr(value, maxLen) {
   if (value === null || value === undefined)
     return "";
@@ -73651,8 +73948,8 @@ class ChunkLog {
   agentDir = null;
   dirCreated = false;
   init(agentId, sessionId) {
-    this.agentDir = join22(LOG_BASE_DIR, agentId);
-    this.logPath = join22(this.agentDir, `${sessionId}.jsonl`);
+    this.agentDir = join23(LOG_BASE_DIR, agentId);
+    this.logPath = join23(this.agentDir, `${sessionId}.jsonl`);
     this.buffer = [];
     this.dirty = false;
     this.dirCreated = false;
@@ -73681,8 +73978,8 @@ class ChunkLog {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync18(this.agentDir)) {
-        mkdirSync12(this.agentDir, { recursive: true });
+      if (!existsSync19(this.agentDir)) {
+        mkdirSync13(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
     } catch (e) {
@@ -73696,7 +73993,7 @@ class ChunkLog {
     try {
       const content = this.buffer.map((entry) => JSON.stringify(entry)).join(`
 `);
-      writeFileSync9(this.logPath, `${content}
+      writeFileSync10(this.logPath, `${content}
 `, "utf8");
     } catch (e) {
       debugWarn("chunkLog", `Failed to write ${this.logPath}: ${e instanceof Error ? e.message : String(e)}`);
@@ -73706,14 +74003,14 @@ class ChunkLog {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync18(this.agentDir))
+      if (!existsSync19(this.agentDir))
         return;
       const files = readdirSync8(this.agentDir).filter((f) => f.endsWith(".jsonl")).sort();
       if (files.length >= MAX_SESSION_FILES2) {
         const toDelete = files.slice(0, files.length - MAX_SESSION_FILES2 + 1);
         for (const file of toDelete) {
           try {
-            unlinkSync5(join22(this.agentDir, file));
+            unlinkSync5(join23(this.agentDir, file));
           } catch (e) {
             debugWarn("chunkLog", `Failed to delete old session log ${file}: ${e instanceof Error ? e.message : String(e)}`);
           }
@@ -73727,7 +74024,7 @@ class ChunkLog {
 var MAX_ENTRIES = 100, CONTENT_TRUNCATE_LEN = 200, MAX_SESSION_FILES2 = 5, LOG_BASE_DIR, chunkLog;
 var init_chunkLog = __esm(() => {
   init_debug();
-  LOG_BASE_DIR = join22(homedir20(), ".letta", "logs", "chunk-logs");
+  LOG_BASE_DIR = join23(homedir20(), ".letta", "logs", "chunk-logs");
   chunkLog = new ChunkLog;
 });
 
@@ -73890,7 +74187,7 @@ async function discoverFallbackRunIdForResume(client, ctx) {
   }
   return null;
 }
-async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessage, onChunkProcessed, contextTracker, seenSeqIdThreshold, isResumeStream) {
+async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessage, onChunkProcessed, contextTracker, seenSeqIdThreshold, isResumeStream, skipCancelToolsOnError) {
   const startTime = performance.now();
   const requestStartTime = getStreamRequestStartTime(stream2) ?? startTime;
   let hasLoggedTTFT = false;
@@ -73996,7 +74293,11 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
     }
     fallbackError = errorMessageWithDiagnostic;
     stopReason = streamProcessor.stopReason || "error";
-    markIncompleteToolsAsCancelled(buffers, true, "stream_error", true);
+    if (skipCancelToolsOnError) {
+      buffers.interrupted = true;
+    } else {
+      markIncompleteToolsAsCancelled(buffers, true, "stream_error", true);
+    }
     queueMicrotask(refresh);
   } finally {
     try {
@@ -74021,13 +74322,15 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
   if (stopReason === "cancelled") {
     markIncompleteToolsAsCancelled(buffers, true, "user_interrupt");
   }
-  markCurrentLineAsFinished(buffers);
+  if (stopReason !== "error") {
+    markCurrentLineAsFinished(buffers);
+  }
   queueMicrotask(refresh);
   const allPending = Array.from(streamProcessor.pendingApprovals.values());
   const approvals = allPending.map((a) => ({
     toolCallId: a.toolCallId,
     toolName: a.toolName || "",
-    toolArgs: a.toolArgs || "{}"
+    toolArgs: a.toolArgs || ""
   }));
   const approval = approvals[0] || null;
   streamProcessor.pendingApprovals.clear();
@@ -74048,6 +74351,7 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
 async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onFirstMessage, onChunkProcessed, contextTracker, seenSeqIdThreshold) {
   const overallStartTime = performance.now();
   const streamRequestContext = getStreamRequestContext(stream2);
+  const streamOtid = streamRequestContext?.otid ?? null;
   let _client;
   const lazyClient = async () => {
     if (!_client) {
@@ -74055,54 +74359,84 @@ async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onF
     }
     return _client;
   };
-  let result = await drainStream(stream2, buffers, refresh, abortSignal, onFirstMessage, onChunkProcessed, contextTracker, seenSeqIdThreshold);
+  let result = await drainStream(stream2, buffers, refresh, abortSignal, onFirstMessage, onChunkProcessed, contextTracker, seenSeqIdThreshold, false, true);
   let runIdToResume = result.lastRunId ?? null;
   let runIdSource = result.lastRunId ? "stream_chunk" : null;
   if (result.stopReason === "error" && !runIdToResume && streamRequestContext && abortSignal && !abortSignal.aborted) {
-    try {
-      debugLog("stream", "Mid-stream resume: attempting run discovery (conv=%s, agent=%s)", streamRequestContext.conversationId, streamRequestContext.agentId);
-      const client = await lazyClient();
-      runIdToResume = await discoverFallbackRunIdWithTimeout(client, streamRequestContext);
-      debugLog("stream", "Mid-stream resume: run discovery result: %s", runIdToResume ?? "none");
-      if (runIdToResume) {
-        result.lastRunId = runIdToResume;
-        runIdSource = "discovery";
+    if (streamOtid) {
+      runIdSource = "otid";
+      debugLog("stream", "Mid-stream resume: will use OTID-based conversations stream (otid=%s)", streamOtid);
+    } else {
+      try {
+        debugLog("stream", "Mid-stream resume: attempting run discovery (conv=%s, agent=%s)", streamRequestContext.conversationId, streamRequestContext.agentId);
+        const client = await lazyClient();
+        runIdToResume = await discoverFallbackRunIdWithTimeout(client, streamRequestContext);
+        debugLog("stream", "Mid-stream resume: run discovery result: %s", runIdToResume ?? "none");
+        if (runIdToResume) {
+          result.lastRunId = runIdToResume;
+          runIdSource = "discovery";
+        }
+      } catch (lookupError) {
+        const lookupErrorMsg = lookupError instanceof Error ? lookupError.message : String(lookupError);
+        telemetry.trackError("stream_resume_lookup_failed", lookupErrorMsg, "stream_resume");
+        debugWarn("drainStreamWithResume", "Fallback run_id lookup failed:", lookupError);
       }
-    } catch (lookupError) {
-      const lookupErrorMsg = lookupError instanceof Error ? lookupError.message : String(lookupError);
-      telemetry.trackError("stream_resume_lookup_failed", lookupErrorMsg, "stream_resume");
-      debugWarn("drainStreamWithResume", "Fallback run_id lookup failed:", lookupError);
     }
   }
-  if (result.stopReason === "error" && runIdToResume && abortSignal && !abortSignal.aborted) {
+  const isApprovalPendingConflict = result.fallbackError?.includes("waiting for approval on a tool call") ?? false;
+  const canResume = result.stopReason === "error" && !isApprovalPendingConflict && (runIdToResume || runIdSource === "otid") && abortSignal && !abortSignal.aborted;
+  if (canResume) {
     const originalFallbackError = result.fallbackError;
     const originalApprovals = result.approvals;
     const originalApproval = result.approval;
     telemetry.trackError("stream_resume_attempt", originalFallbackError || "Stream error (no client-side detail)", "stream_resume", {
       runId: result.lastRunId ?? undefined
     });
-    debugLog("stream", "Mid-stream resume: fetching run stream (source=%s, runId=%s, lastSeqId=%s)", runIdSource ?? "unknown", runIdToResume, result.lastSeqId ?? 0);
-    debugLog("stream", "Mid-stream resume: attempting resume (runId=%s, lastSeqId=%s)", runIdToResume, result.lastSeqId ?? 0);
+    debugWarn("stream", "[MID-STREAM RESUME] Attempting (runId=%s, lastSeqId=%s, source=%s, otid=%s)", runIdToResume ?? "none", result.lastSeqId ?? 0, runIdSource ?? "unknown", streamOtid ?? "none");
     try {
       const client = await lazyClient();
       buffers.commitGeneration = (buffers.commitGeneration || 0) + 1;
       buffers.interrupted = false;
-      const resumeStream = await client.runs.messages.stream(runIdToResume, {
+      const resumeStream = runIdSource === "otid" && streamOtid && streamRequestContext ? await client.conversations.messages.stream(streamRequestContext.resolvedConversationId, {
+        agent_id: streamRequestContext.conversationId === "default" ? streamRequestContext.agentId ?? undefined : undefined,
+        otid: streamOtid,
+        starting_after: result.lastSeqId ?? 0,
+        batch_size: 1000
+      }) : await client.runs.messages.stream(runIdToResume, {
         starting_after: result.lastSeqId ?? 0,
         batch_size: 1000
       });
       const resumeResult = await drainStream(resumeStream, buffers, refresh, abortSignal, undefined, onChunkProcessed, contextTracker, seenSeqIdThreshold, true);
-      debugLog("stream", "Mid-stream resume succeeded (runId=%s, stopReason=%s)", runIdToResume, resumeResult.stopReason);
+      if (resumeResult.stopReason !== "error") {
+        debugWarn("stream", "[MID-STREAM RESUME] ✅ Success (runId=%s, stopReason=%s)", runIdToResume, resumeResult.stopReason);
+      } else {
+        debugWarn("stream", "[MID-STREAM RESUME] ⚠️ Resumed but terminal error persisted (runId=%s)", runIdToResume);
+      }
       result = resumeResult;
-      if (result.stopReason === "requires_approval" && (result.approvals?.length ?? 0) === 0 && (originalApprovals?.length ?? 0) > 0) {
-        result.approvals = originalApprovals;
-        result.approval = originalApproval;
+      if (result.stopReason === "requires_approval" && (originalApprovals?.length ?? 0) > 0) {
+        if ((result.approvals?.length ?? 0) === 0) {
+          result.approvals = originalApprovals;
+          result.approval = originalApproval;
+        } else {
+          result.approvals = (result.approvals ?? []).map((resumeApproval) => {
+            const orig = originalApprovals?.find((a) => a.toolCallId === resumeApproval.toolCallId);
+            if (!orig)
+              return resumeApproval;
+            return {
+              ...resumeApproval,
+              toolName: resumeApproval.toolName || orig.toolName,
+              toolArgs: (orig.toolArgs || "") + (resumeApproval.toolArgs || "")
+            };
+          });
+          result.approval = result.approvals[0] ?? null;
+        }
       }
     } catch (resumeError) {
+      markIncompleteToolsAsCancelled(buffers, false, "stream_error", true);
       markCurrentLineAsFinished(buffers);
       result.fallbackError = originalFallbackError;
       const resumeErrorMsg = resumeError instanceof Error ? resumeError.message : String(resumeError);
-      debugLog("stream", "Mid-stream resume failed (runId=%s): %s", runIdToResume, resumeErrorMsg);
+      debugWarn("stream", "[MID-STREAM RESUME] ❌ Failed (runId=%s): %s", runIdToResume, resumeErrorMsg);
       telemetry.trackError("stream_resume_failed", resumeErrorMsg, "stream_resume", {
         runId: result.lastRunId ?? undefined
       });
@@ -74110,13 +74444,14 @@ async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onF
   }
   if (result.stopReason === "error") {
     const skipReasons = [];
-    if (!result.lastRunId)
+    if (!result.lastRunId && runIdSource !== "otid")
       skipReasons.push("no_run_id");
     if (!abortSignal)
       skipReasons.push("no_abort_signal");
     if (abortSignal?.aborted)
       skipReasons.push("user_aborted");
     if (skipReasons.length > 0) {
+      markIncompleteToolsAsCancelled(buffers, false, "stream_error", true);
       markCurrentLineAsFinished(buffers);
       debugLog("stream", "Mid-stream resume skipped: %s", skipReasons.join(", "));
       telemetry.trackError("stream_resume_skipped", `${result.fallbackError || "Stream error (no client-side detail)"} [skip: ${skipReasons.join(", ")}]`, "stream_resume", {
@@ -74124,6 +74459,10 @@ async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onF
       });
     }
   }
+  if (result.stopReason === "requires_approval" && (result.approvals?.length ?? 0) > 0 && buffers.interrupted) {
+    buffers.interrupted = false;
+    markCurrentLineAsFinished(buffers);
+  }
   result.apiDurationMs = performance.now() - overallStartTime;
   return result;
 }
@@ -75802,7 +76141,11 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
   try {
     const approvalResults = await executeApprovalBatch(decisions, undefined, {
       abortSignal: recoveryAbortController.signal,
-      workingDirectory: getConversationWorkingDirectory(runtime.listener, recovered.agentId, recovered.conversationId)
+      workingDirectory: getConversationWorkingDirectory(runtime.listener, recovered.agentId, recovered.conversationId),
+      parentScope: recovered.agentId && recovered.conversationId ? {
+        agentId: recovered.agentId,
+        conversationId: recovered.conversationId
+      } : undefined
     });
     emitToolExecutionFinishedEvents(socket, runtime, {
       approvals: approvalResults,
@@ -76142,7 +76485,11 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
     try {
       const approvalResults = await executeApprovalBatch(decisions, undefined, {
         abortSignal,
-        workingDirectory: recoveryWorkingDirectory
+        workingDirectory: recoveryWorkingDirectory,
+        parentScope: runtime.agentId && runtime.conversationId ? {
+          agentId: runtime.agentId,
+          conversationId: runtime.conversationId
+        } : undefined
       });
       emitToolExecutionFinishedEvents(socket, runtime, {
         approvals: approvalResults,
@@ -76198,7 +76545,6 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
   let conversationBusyRetries = 0;
   let preStreamRecoveryAttempts = 0;
   const MAX_CONVERSATION_BUSY_RETRIES = 3;
-  const requestStartedAtMs = Date.now();
   while (true) {
     if (abortSignal?.aborted) {
       throw new Error("Cancelled by user");
@@ -76283,21 +76629,16 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
         });
         try {
           const client = await getClient2();
-          const discoveredRunId = await discoverFallbackRunIdWithTimeout(client, {
-            conversationId,
-            resolvedConversationId: conversationId,
-            agentId: runtime.agentId ?? null,
-            requestStartedAtMs
-          });
-          if (discoveredRunId) {
-            if (abortSignal?.aborted) {
-              throw new Error("Cancelled by user");
-            }
-            return await client.runs.messages.stream(discoveredRunId, {
-              starting_after: 0,
-              batch_size: 1000
-            });
+          const messageOtid = messages.map((item) => item.otid).find((value) => typeof value === "string");
+          if (abortSignal?.aborted) {
+            throw new Error("Cancelled by user");
           }
+          return await client.conversations.messages.stream(conversationId, {
+            agent_id: conversationId === "default" ? runtime.agentId ?? undefined : undefined,
+            otid: messageOtid ?? undefined,
+            starting_after: 0,
+            batch_size: 1000
+          });
         } catch (resumeError) {
           if (abortSignal?.aborted) {
             throw new Error("Cancelled by user");
@@ -76337,7 +76678,6 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
   let conversationBusyRetries = 0;
   let preStreamRecoveryAttempts = 0;
   const MAX_CONVERSATION_BUSY_RETRIES = 3;
-  const requestStartedAtMs = Date.now();
   while (true) {
     if (abortSignal?.aborted) {
       throw new Error("Cancelled by user");
@@ -76412,21 +76752,16 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
         });
         try {
           const client = await getClient2();
-          const discoveredRunId = await discoverFallbackRunIdWithTimeout(client, {
-            conversationId,
-            resolvedConversationId: conversationId,
-            agentId: runtime.agentId ?? null,
-            requestStartedAtMs
-          });
-          if (discoveredRunId) {
-            if (abortSignal?.aborted) {
-              throw new Error("Cancelled by user");
-            }
-            return await client.runs.messages.stream(discoveredRunId, {
-              starting_after: 0,
-              batch_size: 1000
-            });
+          const messageOtid = messages.map((item) => item.otid).find((value) => typeof value === "string");
+          if (abortSignal?.aborted) {
+            throw new Error("Cancelled by user");
           }
+          return await client.conversations.messages.stream(conversationId, {
+            agent_id: conversationId === "default" ? runtime.agentId ?? undefined : undefined,
+            otid: messageOtid ?? undefined,
+            starting_after: 0,
+            batch_size: 1000
+          });
         } catch (resumeError) {
           if (abortSignal?.aborted) {
             throw new Error("Cancelled by user");
@@ -76466,7 +76801,6 @@ var init_send = __esm(async () => {
     init_client2(),
     init_message(),
     init_approvalClassification(),
-    init_stream(),
     init_approval(),
     init_interrupts(),
     init_protocol_outbound(),
@@ -77414,7 +77748,8 @@ async function handleApprovalStop(params) {
   const executionResults = await executeApprovalBatch(decisions, undefined, {
     toolContextId: turnToolContextId ?? undefined,
     abortSignal: abortController.signal,
-    workingDirectory: turnWorkingDirectory
+    workingDirectory: turnWorkingDirectory,
+    parentScope: agentId && conversationId ? { agentId, conversationId } : undefined
   });
   const persistedExecutionResults = normalizeExecutionResultsForInterruptParity(runtime, executionResults, lastExecutingToolCallIds);
   validateApprovalResultIds(decisions.map((decision) => ({
@@ -78039,7 +78374,7 @@ __export(exports_memoryScanner, {
   getFileNodes: () => getFileNodes
 });
 import { readdirSync as readdirSync9, readFileSync as readFileSync9, statSync as statSync5 } from "node:fs";
-import { join as join23, relative as relative11 } from "node:path";
+import { join as join24, relative as relative11 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
   const scanDir = (dir, depth, parentIsLast) => {
@@ -78051,8 +78386,8 @@ function scanMemoryFilesystem(memoryRoot) {
     }
     const filtered = entries.filter((name) => !name.startsWith("."));
     const sorted = filtered.sort((a, b) => {
-      const aPath = join23(dir, a);
-      const bPath = join23(dir, b);
+      const aPath = join24(dir, a);
+      const bPath = join24(dir, b);
       let aIsDir = false;
       let bIsDir = false;
       try {
@@ -78072,7 +78407,7 @@ function scanMemoryFilesystem(memoryRoot) {
       return a.localeCompare(b);
     });
     sorted.forEach((name, index) => {
-      const fullPath = join23(dir, name);
+      const fullPath = join24(dir, name);
       let isDir = false;
       try {
         isDir = statSync5(fullPath).isDirectory();
@@ -78186,6 +78521,14 @@ function ensureConversationQueueRuntime(listener, runtime) {
 function getOrCreateScopedRuntime(listener, agentId, conversationId) {
   return ensureConversationQueueRuntime(listener, getOrCreateConversationRuntime(listener, agentId, conversationId));
 }
+function findFallbackRuntime(listener) {
+  for (const cr of listener.conversationRuntimes.values()) {
+    if (cr.queueRuntime) {
+      return cr;
+    }
+  }
+  return null;
+}
 function resolveRuntimeForApprovalRequest(listener, requestId) {
   if (!requestId) {
     return null;
@@ -78319,6 +78662,7 @@ function createRuntime() {
   };
 }
 function stopRuntime(runtime, suppressCallbacks) {
+  setMessageQueueAdder(null);
   runtime.intentionallyClosed = true;
   clearRuntimeTimers(runtime);
   for (const conversationRuntime of runtime.conversationRuntimes.values()) {
@@ -78418,6 +78762,30 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         emitLoopStatusUpdate(socket, conversationRuntime, scope);
       }
     }
+    runtime._unsubscribeSubagentState?.();
+    runtime._unsubscribeSubagentState = subscribe2(() => {
+      emitSubagentStateIfOpen(runtime);
+    });
+    runtime._unsubscribeSubagentStreamEvents?.();
+    runtime._unsubscribeSubagentStreamEvents = subscribeToStreamEvents((subagentId, event) => {
+      if (socket.readyState !== WebSocket4.OPEN)
+        return;
+      emitStreamDelta(socket, runtime, event, undefined, subagentId);
+    });
+    setMessageQueueAdder((queuedMessage) => {
+      const targetRuntime = queuedMessage.agentId && queuedMessage.conversationId ? getOrCreateScopedRuntime(runtime, queuedMessage.agentId, queuedMessage.conversationId) : findFallbackRuntime(runtime);
+      if (!targetRuntime?.queueRuntime) {
+        return;
+      }
+      targetRuntime.queueRuntime.enqueue({
+        kind: "task_notification",
+        source: "task_notification",
+        text: queuedMessage.text,
+        agentId: queuedMessage.agentId ?? targetRuntime.agentId ?? undefined,
+        conversationId: queuedMessage.conversationId ?? targetRuntime.conversationId
+      });
+      scheduleQueuePump(targetRuntime, socket, opts, processQueuedTurn);
+    });
     runtime.heartbeatInterval = setInterval(() => {
       if (socket.readyState === WebSocket4.OPEN) {
         socket.send(JSON.stringify({ type: "ping" }));
@@ -78622,8 +78990,15 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     if (isSearchFilesCommand(parsed)) {
       (async () => {
         await ensureFileIndex2();
+        let searchDir = ".";
+        if (parsed.cwd) {
+          const rel = path22.relative(process.cwd(), parsed.cwd);
+          if (rel && !rel.startsWith("..")) {
+            searchDir = rel;
+          }
+        }
         const files = searchFileIndex({
-          searchDir: ".",
+          searchDir,
           pattern: parsed.query,
           deep: true,
           maxResults: parsed.max_results ?? 5
@@ -78721,10 +79096,10 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           const { getMemoryFilesystemRoot: getMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
           const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memoryScanner(), exports_memoryScanner));
           const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-          const { existsSync: existsSync19 } = await import("node:fs");
-          const { join: join24 } = await import("node:path");
+          const { existsSync: existsSync20 } = await import("node:fs");
+          const { join: join25 } = await import("node:path");
           const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
-          const memfsInitialized = existsSync19(join24(memoryRoot, ".git"));
+          const memfsInitialized = existsSync20(join25(memoryRoot, ".git"));
           if (!memfsInitialized) {
             socket.send(JSON.stringify({
               type: "list_memory_response",
@@ -78844,6 +79219,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       code,
       reason: reason.toString()
     });
+    setMessageQueueAdder(null);
     for (const conversationRuntime of runtime.conversationRuntimes.values()) {
       conversationRuntime.queuedMessagesByItemId.clear();
       if (conversationRuntime.queueRuntime) {
@@ -78855,6 +79231,10 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     }
     clearRuntimeTimers(runtime);
     killAllTerminals();
+    runtime._unsubscribeSubagentState?.();
+    runtime._unsubscribeSubagentState = undefined;
+    runtime._unsubscribeSubagentStreamEvents?.();
+    runtime._unsubscribeSubagentStreamEvents = undefined;
     runtime.socket = null;
     for (const conversationRuntime of runtime.conversationRuntimes.values()) {
       rejectPendingApprovalResolvers(conversationRuntime, "WebSocket disconnected");
@@ -79052,7 +79432,9 @@ function createLegacyTestRuntime() {
 var __listenClientTestUtils;
 var init_client4 = __esm(async () => {
   init_fileIndex();
+  init_messageQueueBridge();
   init_planName();
+  init_subagentState();
   init_constants();
   init_queueRuntime();
   init_debug();
@@ -79165,22 +79547,22 @@ __export(exports_skills2, {
   SKILLS_DIR: () => SKILLS_DIR2,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { readdir as readdir6, readFile as readFile7, realpath as realpath4, stat as stat6 } from "node:fs/promises";
-import { dirname as dirname11, join as join28 } from "node:path";
+import { dirname as dirname12, join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
-  const thisDir = dirname11(fileURLToPath8(import.meta.url));
+  const thisDir = dirname12(fileURLToPath8(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join28(thisDir, "../skills/builtin");
+    return join29(thisDir, "../skills/builtin");
   }
-  return join28(thisDir, "skills");
+  return join29(thisDir, "skills");
 }
 function compareSkills2(a, b) {
   return a.id.localeCompare(b.id) || a.source.localeCompare(b.source) || a.path.localeCompare(b.path);
 }
 function getAgentSkillsDir2(agentId) {
-  return join28(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
+  return join29(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "skills");
 }
 async function getBundledSkills2() {
   const bundledPath = getBundledSkillsPath2();
@@ -79189,7 +79571,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source) {
   const errors = [];
-  if (!existsSync21(skillsPath)) {
+  if (!existsSync22(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -79203,7 +79585,7 @@ async function discoverSkillsFromDir2(skillsPath, source) {
   }
   return { skills, errors };
 }
-async function discoverSkills2(projectSkillsPath = join28(process.cwd(), SKILLS_DIR2), agentId, options) {
+async function discoverSkills2(projectSkillsPath = join29(process.cwd(), SKILLS_DIR2), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
@@ -79258,7 +79640,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
   try {
     const entries = await readdir6(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join28(currentPath, entry.name);
+      const fullPath = join29(currentPath, entry.name);
       try {
         let isDirectory = entry.isDirectory();
         let isFile = entry.isFile();
@@ -79347,7 +79729,7 @@ ${lines.join(`
 var SKILLS_DIR2 = ".skills", GLOBAL_SKILLS_DIR2;
 var init_skills2 = __esm(() => {
   init_skillSources();
-  GLOBAL_SKILLS_DIR2 = join28(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
+  GLOBAL_SKILLS_DIR2 = join29(process.env.HOME || process.env.USERPROFILE || "~", ".letta/skills");
 });
 
 // src/utils/fs.ts
@@ -79361,27 +79743,27 @@ __export(exports_fs, {
   exists: () => exists2
 });
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
-  mkdirSync as mkdirSync15
+  mkdirSync as mkdirSync16
 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 async function readFile8(path23) {
   return fsReadFileSync2(path23, { encoding: "utf-8" });
 }
 async function writeFile5(path23, content) {
-  const dir = dirname12(path23);
-  if (!existsSync22(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  const dir = dirname13(path23);
+  if (!existsSync23(dir)) {
+    mkdirSync16(dir, { recursive: true });
   }
   fsWriteFileSync2(path23, content, { encoding: "utf-8", flush: true });
 }
 function exists2(path23) {
-  return existsSync22(path23);
+  return existsSync23(path23);
 }
 async function mkdir5(path23, options) {
-  mkdirSync15(path23, options);
+  mkdirSync16(path23, options);
 }
 async function readJsonFile(path23) {
   const text = await readFile8(path23);
@@ -79701,7 +80083,7 @@ __export(exports_auto_update, {
 import { execFile as execFile11 } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readdir as readdir7, rm as rm3 } from "node:fs/promises";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import { promisify as promisify11 } from "node:util";
 function debugLog3(...args) {
   if (DEBUG) {
@@ -79861,12 +80243,12 @@ async function getNpmGlobalPath() {
   }
 }
 async function cleanupOrphanedDirs(globalPath) {
-  const lettaAiDir = join29(globalPath, "lib/node_modules/@letta-ai");
+  const lettaAiDir = join30(globalPath, "lib/node_modules/@letta-ai");
   try {
     const entries = await readdir7(lettaAiDir);
     for (const entry of entries) {
       if (entry.startsWith(".letta-code-")) {
-        const orphanPath = join29(lettaAiDir, entry);
+        const orphanPath = join30(lettaAiDir, entry);
         debugLog3("Cleaning orphaned temp directory:", orphanPath);
         await rm3(orphanPath, { recursive: true, force: true });
       }
@@ -81380,7 +81762,7 @@ __export(exports_import, {
 });
 import { createReadStream } from "node:fs";
 import { chmod, mkdir as mkdir6, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname13, resolve as resolve26 } from "node:path";
+import { dirname as dirname14, resolve as resolve26 } from "node:path";
 async function importAgentFromFile(options) {
   const client = await getClient2();
   const resolvedPath = resolve26(options.filePath);
@@ -81439,7 +81821,7 @@ async function writeSkillFiles(skillDir, files) {
 }
 async function writeSkillFile(skillDir, filePath, content) {
   const fullPath = resolve26(skillDir, filePath);
-  await mkdir6(dirname13(fullPath), { recursive: true });
+  await mkdir6(dirname14(fullPath), { recursive: true });
   await writeFile6(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
@@ -81492,7 +81874,7 @@ function parseRegistryHandle(handle) {
 }
 async function importAgentFromRegistry(options) {
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const { join: join31 } = await import("node:path");
+  const { join: join32 } = await import("node:path");
   const { writeFile: writeFile7, unlink: unlink3 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
@@ -81504,7 +81886,7 @@ async function importAgentFromRegistry(options) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join31(tmpdir3(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join32(tmpdir3(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile7(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
@@ -82279,11 +82661,7 @@ In headless mode, use:
   setConversationId2(conversationId);
   if (!isSubagent) {
     await settingsManager.loadLocalProjectSettings();
-    settingsManager.setLocalLastSession({ agentId: agent.id, conversationId }, process.cwd());
-    settingsManager.setGlobalLastSession({
-      agentId: agent.id,
-      conversationId
-    });
+    settingsManager.persistSession(agent.id, conversationId);
   }
   setAgentContext2(agent.id, skillsDirectory, resolvedSkillSources);
   const outputFormat = values["output-format"] || "text";
@@ -82580,27 +82958,39 @@ ${loadedContents.join(`
           continue;
         }
         if (preStreamAction === "retry_conversation_busy") {
-          conversationBusyRetries += 1;
-          const retryDelayMs = getRetryDelayMs({
-            category: "conversation_busy",
-            attempt: conversationBusyRetries
-          });
-          if (outputFormat === "stream-json") {
-            const retryMsg = {
-              type: "retry",
-              reason: "error",
-              attempt: conversationBusyRetries,
-              max_attempts: CONVERSATION_BUSY_MAX_RETRIES,
-              delay_ms: retryDelayMs,
-              session_id: sessionId,
-              uuid: `retry-conversation-busy-${randomUUID8()}`
-            };
-            console.log(JSON.stringify(retryMsg));
-          } else {
-            console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
+          const messageOtid = currentInput.map((item) => item.otid).find((v) => typeof v === "string");
+          try {
+            const client2 = await getClient2();
+            stream2 = await client2.conversations.messages.stream(conversationId, {
+              agent_id: conversationId === "default" ? agent?.id ?? undefined : undefined,
+              otid: messageOtid ?? undefined,
+              starting_after: 0,
+              batch_size: 1000
+            });
+            conversationBusyRetries = 0;
+          } catch {
+            conversationBusyRetries += 1;
+            const retryDelayMs = getRetryDelayMs({
+              category: "conversation_busy",
+              attempt: conversationBusyRetries
+            });
+            if (outputFormat === "stream-json") {
+              const retryMsg = {
+                type: "retry",
+                reason: "error",
+                attempt: conversationBusyRetries,
+                max_attempts: CONVERSATION_BUSY_MAX_RETRIES,
+                delay_ms: retryDelayMs,
+                session_id: sessionId,
+                uuid: `retry-conversation-busy-${randomUUID8()}`
+              };
+              console.log(JSON.stringify(retryMsg));
+            } else {
+              console.error(`Conversation is busy, waiting ${Math.round(retryDelayMs / 1000)}s and retrying...`);
+            }
+            await new Promise((resolve27) => setTimeout(resolve27, retryDelayMs));
+            continue;
           }
-          await new Promise((resolve27) => setTimeout(resolve27, retryDelayMs));
-          continue;
         }
         if (preStreamAction === "retry_transient") {
           const attempt = llmApiErrorRetries + 1;
@@ -84464,9 +84854,9 @@ __export(exports_settings, {
   getSetting: () => getSetting
 });
 import { homedir as homedir27 } from "node:os";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function getSettingsPath() {
-  return join32(homedir27(), ".letta", "settings.json");
+  return join33(homedir27(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -84503,7 +84893,7 @@ async function getSetting(key) {
   return settings[key];
 }
 function getProjectSettingsPath() {
-  return join32(process.cwd(), ".letta", "settings.local.json");
+  return join33(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -84521,7 +84911,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join32(process.cwd(), ".letta");
+  const dirPath = join33(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -101168,9 +101558,9 @@ function getFileEditHeader(toolName, toolArgs) {
     const relPath = relative15(cwd2, filePath);
     const displayPath = relPath.startsWith("..") ? filePath : relPath;
     if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-      const { existsSync: existsSync25 } = __require("node:fs");
+      const { existsSync: existsSync26 } = __require("node:fs");
       try {
-        if (existsSync25(filePath)) {
+        if (existsSync26(filePath)) {
           return `Overwrite ${displayPath}?`;
         }
       } catch {}
@@ -101879,9 +102269,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative15(cwd2, fileEdit.filePath);
   const displayPath = relPath.startsWith("..") ? fileEdit.filePath : relPath;
   if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-    const { existsSync: existsSync25 } = __require("node:fs");
+    const { existsSync: existsSync26 } = __require("node:fs");
     try {
-      if (existsSync25(fileEdit.filePath)) {
+      if (existsSync26(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -103519,9 +103909,9 @@ html.dark .agent-name { color: var(--text-dim); }
 var init_plan_viewer_template = () => {};
 
 // src/web/generate-plan-viewer.ts
-import { chmodSync as chmodSync2, existsSync as existsSync25, mkdirSync as mkdirSync18, writeFileSync as writeFileSync12 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync26, mkdirSync as mkdirSync19, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir28 } from "node:os";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
   const data = {
     agent: { name: options?.agentName ?? "" },
@@ -103531,14 +103921,14 @@ async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
   };
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html = plan_viewer_template_default.replace("<!--LETTA_PLAN_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync25(VIEWERS_DIR)) {
-    mkdirSync18(VIEWERS_DIR, { recursive: true, mode: 448 });
+  if (!existsSync26(VIEWERS_DIR)) {
+    mkdirSync19(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync2(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join33(VIEWERS_DIR, "plan.html");
-  writeFileSync12(filePath, html);
+  const filePath = join34(VIEWERS_DIR, "plan.html");
+  writeFileSync13(filePath, html);
   chmodSync2(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
   if (!skipOpen) {
@@ -103554,7 +103944,7 @@ async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
 var VIEWERS_DIR;
 var init_generate_plan_viewer = __esm(() => {
   init_plan_viewer_template();
-  VIEWERS_DIR = join33(homedir28(), ".letta", "viewers");
+  VIEWERS_DIR = join34(homedir28(), ".letta", "viewers");
 });
 
 // src/cli/components/StaticPlanApproval.tsx
@@ -105599,9 +105989,9 @@ var init_pasteRegistry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync12, statSync as statSync8, unlinkSync as unlinkSync8 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync12, statSync as statSync8, unlinkSync as unlinkSync8 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename4, extname as extname5, isAbsolute as isAbsolute18, join as join34, resolve as resolve27 } from "node:path";
+import { basename as basename4, extname as extname5, isAbsolute as isAbsolute18, join as join35, resolve as resolve27 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
 }
@@ -105651,7 +106041,7 @@ function translatePasteForImages(paste) {
       if (!isAbsolute18(filePath))
         filePath = resolve27(process.cwd(), filePath);
       const ext3 = extname5(filePath || "").toLowerCase();
-      if (IMAGE_EXTS.has(ext3) && existsSync26(filePath) && statSync8(filePath).isFile()) {
+      if (IMAGE_EXTS.has(ext3) && existsSync27(filePath) && statSync8(filePath).isFile()) {
         const buf = readFileSync12(filePath);
         const b64 = buf.toString("base64");
         const mt = ext3 === ".png" ? "image/png" : ext3 === ".jpg" || ext3 === ".jpeg" ? "image/jpeg" : ext3 === ".gif" ? "image/gif" : ext3 === ".webp" ? "image/webp" : ext3 === ".bmp" ? "image/bmp" : ext3 === ".svg" ? "image/svg+xml" : ext3 === ".tif" || ext3 === ".tiff" ? "image/tiff" : ext3 === ".heic" ? "image/heic" : ext3 === ".heif" ? "image/heif" : ext3 === ".avif" ? "image/avif" : "application/octet-stream";
@@ -105669,7 +106059,7 @@ function translatePasteForImages(paste) {
 function getClipboardImageToTempFile() {
   if (process.platform !== "darwin")
     return null;
-  const tempPath = join34(tmpdir3(), `letta-clipboard-${Date.now()}.bin`);
+  const tempPath = join35(tmpdir3(), `letta-clipboard-${Date.now()}.bin`);
   try {
     const jxa = `
       ObjC.import('AppKit');
@@ -105692,11 +106082,11 @@ function getClipboardImageToTempFile() {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    if (!uti || !existsSync26(tempPath))
+    if (!uti || !existsSync27(tempPath))
       return null;
     return { tempPath, uti };
   } catch {
-    if (existsSync26(tempPath)) {
+    if (existsSync27(tempPath)) {
       try {
         unlinkSync8(tempPath);
       } catch {}
@@ -105729,7 +106119,7 @@ async function tryImportClipboardImageMac() {
       height: resized.height
     };
   } catch (err) {
-    if (existsSync26(tempPath)) {
+    if (existsSync27(tempPath)) {
       try {
         unlinkSync8(tempPath);
       } catch {}
@@ -106028,6 +106418,15 @@ function PasteAwareTextInput({
       setNudgeCursorOffset(nextCaret);
       caretOffsetRef.current = nextCaret;
     };
+    const moveCursorToStart = () => {
+      setNudgeCursorOffset(0);
+      caretOffsetRef.current = 0;
+    };
+    const moveCursorToEnd = () => {
+      const endPos = displayValueRef.current.length;
+      setNudgeCursorOffset(endPos);
+      caretOffsetRef.current = endPos;
+    };
     const handleRawInput = (payload) => {
       if (!focusRef.current)
         return;
@@ -106052,6 +106451,14 @@ function PasteAwareTextInput({
         insertNewlineAtCursor();
         return;
       }
+      if (sequence === "\x1B[H" || sequence === "\x1B[1~" || sequence === "\x1BOH") {
+        moveCursorToStart();
+        return;
+      }
+      if (sequence === "\x1B[F" || sequence === "\x1B[4~" || sequence === "\x1BOF") {
+        moveCursorToEnd();
+        return;
+      }
       if (sequence === "\x1B[3~" || /^\x1b\[3;\d+~$/.test(sequence)) {
         globalThis.__lettaForwardDeleteTimestamp = Date.now();
         forwardDeleteAtCursor(caretOffsetRef.current);
@@ -106288,6 +106695,102 @@ var init_FeedbackDialog = __esm(async () => {
   jsx_dev_runtime39 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
+// src/cli/commands/secret.ts
+async function handleSecretCommand(args) {
+  const [subcommand, key, value] = args;
+  switch (subcommand) {
+    case "set": {
+      if (!key) {
+        return { output: "Usage: /secret set KEY value" };
+      }
+      if (!value) {
+        return {
+          output: `Usage: /secret set KEY value
+Provide a value for the secret.`
+        };
+      }
+      const normalizedKey = key.toUpperCase();
+      if (!/^[A-Z_][A-Z0-9_]*$/.test(normalizedKey)) {
+        return {
+          output: `Invalid secret name '${key}'. Use uppercase letters, numbers, and underscores only. Must start with a letter or underscore.`
+        };
+      }
+      try {
+        await setSecretOnServer(normalizedKey, value);
+        return { output: `Secret '$${normalizedKey}' set.` };
+      } catch (error) {
+        return {
+          output: `Failed to set secret: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+    case "list": {
+      const names = listSecretNames();
+      if (names.length === 0) {
+        return {
+          output: `No secrets stored.
+Use /secret set KEY value to add a secret.`
+        };
+      }
+      const lines = names.map((n) => `  $${n}`);
+      return {
+        output: `Available secrets (${names.length}):
+${lines.join(`
+`)}
+
+Use $SECRET_NAME in shell commands to reference them.`
+      };
+    }
+    case "unset":
+    case "delete":
+    case "remove":
+    case "rm": {
+      if (!key) {
+        return { output: "Usage: /secret unset KEY" };
+      }
+      const normalizedKey = key.toUpperCase();
+      try {
+        const deleted = await deleteSecretOnServer(normalizedKey);
+        if (deleted) {
+          return { output: `Secret '$${normalizedKey}' unset.` };
+        }
+        return {
+          output: `Secret '$${normalizedKey}' not found.
+Use /secret list to see available secrets.`
+        };
+      } catch (error) {
+        return {
+          output: `Failed to unset secret: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+    case undefined:
+    case "":
+    case "help": {
+      return {
+        output: `Secret management commands:
+
+  /secret set KEY value   Set a secret (KEY is normalized to uppercase)
+  /secret list            List available secret names
+  /secret unset KEY       Unset a secret
+
+Secrets are stored on the Letta server and available to the agent via /memory/system/secrets.md.
+The key must be all caps and can include underscores and numbers, but must start with a letter or underscore.
+Your agent can use $SECRET_NAME in shell commands and the value will be substituted at runtime, without the secret value being leaked into agent context.`
+      };
+    }
+    default: {
+      return {
+        output: `Unknown subcommand '${subcommand}'.
+Use /secret help for usage.`
+      };
+    }
+  }
+}
+var init_secret = __esm(async () => {
+  await init_secretsStore();
+});
+
 // src/cli/utils/terminalKeybindingInstaller.ts
 var exports_terminalKeybindingInstaller = {};
 __export(exports_terminalKeybindingInstaller, {
@@ -106306,13 +106809,13 @@ __export(exports_terminalKeybindingInstaller, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync19,
+  existsSync as existsSync28,
+  mkdirSync as mkdirSync20,
   readFileSync as readFileSync13,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "node:fs";
 import { homedir as homedir29, platform as platform5 } from "node:os";
-import { dirname as dirname14, join as join35 } from "node:path";
+import { dirname as dirname15, join as join36 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -106344,16 +106847,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os7 = platform5();
   if (os7 === "darwin") {
-    return join35(homedir29(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join36(homedir29(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os7 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join35(appData, appName, "User", "keybindings.json");
+    return join36(appData, appName, "User", "keybindings.json");
   }
   if (os7 === "linux") {
-    return join35(homedir29(), ".config", appName, "User", "keybindings.json");
+    return join36(homedir29(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -106375,7 +106878,7 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync27(keybindingsPath))
+  if (!existsSync28(keybindingsPath))
     return false;
   try {
     const content = readFileSync13(keybindingsPath, { encoding: "utf-8" });
@@ -106388,7 +106891,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync27(keybindingsPath))
+  if (!existsSync28(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -106403,13 +106906,13 @@ function installKeybinding(keybindingsPath) {
     if (keybindingExists(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname14(keybindingsPath);
-    if (!existsSync27(parentDir)) {
-      mkdirSync19(parentDir, { recursive: true });
+    const parentDir = dirname15(keybindingsPath);
+    if (!existsSync28(parentDir)) {
+      mkdirSync20(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync27(keybindingsPath)) {
+    if (existsSync28(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
       const content = readFileSync13(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
@@ -106424,7 +106927,7 @@ function installKeybinding(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync13(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync14(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -106439,7 +106942,7 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync27(keybindingsPath)) {
+    if (!existsSync28(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync13(keybindingsPath, { encoding: "utf-8" });
@@ -106453,7 +106956,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)}
 `;
-    writeFileSync13(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync14(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -106506,17 +107009,17 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join35(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync27(xdgPath))
+    const xdgPath = join36(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync28(xdgPath))
       return xdgPath;
   }
-  const configPath = join35(homedir29(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync27(configPath))
+  const configPath = join36(homedir29(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync28(configPath))
     return configPath;
-  return join35(homedir29(), ".wezterm.lua");
+  return join36(homedir29(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync27(configPath))
+  if (!existsSync28(configPath))
     return false;
   try {
     const content = readFileSync13(configPath, { encoding: "utf-8" });
@@ -106533,7 +107036,7 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync27(configPath)) {
+    if (existsSync28(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync(configPath, backupPath);
       content = readFileSync13(configPath, { encoding: "utf-8" });
@@ -106562,11 +107065,11 @@ return config`);
 ${WEZTERM_DELETE_FIX}
 `;
     }
-    const parentDir = dirname14(configPath);
-    if (!existsSync27(parentDir)) {
-      mkdirSync19(parentDir, { recursive: true });
+    const parentDir = dirname15(configPath);
+    if (!existsSync28(parentDir)) {
+      mkdirSync20(parentDir, { recursive: true });
     }
-    writeFileSync13(configPath, content, { encoding: "utf-8" });
+    writeFileSync14(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -106639,7 +107142,8 @@ async function executeCommand(input) {
   }
 }
 var commands;
-var init_registry = __esm(() => {
+var init_registry = __esm(async () => {
+  await init_secret();
   commands = {
     "/agents": {
       desc: "Browse agents (pinned, Letta Code, all)",
@@ -106774,6 +107278,14 @@ var init_registry = __esm(() => {
         return "Starting new conversation...";
       }
     },
+    "/fork": {
+      desc: "Fork the current conversation",
+      order: 20.5,
+      noArgs: true,
+      handler: () => {
+        return "Forking conversation...";
+      }
+    },
     "/pin": {
       desc: "Pin current agent globally, or use -l for local only",
       order: 22,
@@ -106849,6 +107361,15 @@ var init_registry = __esm(() => {
         return "Opening MCP server manager...";
       }
     },
+    "/secret": {
+      desc: "Manage secrets for shell commands",
+      order: 33,
+      args: "<set|list|unset> [key] [value]",
+      handler: async (args) => {
+        const result = await handleSecretCommand(args);
+        return result.output;
+      }
+    },
     "/usage": {
       desc: "Show session usage statistics and balance",
       order: 33,
@@ -107110,9 +107631,9 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 import { readdir as readdir8, readFile as readFile10 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname15, join as join36 } from "node:path";
+import { basename as basename5, dirname as dirname16, join as join37 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
     return cachedCommands;
@@ -107123,7 +107644,7 @@ async function getCustomCommands() {
 function refreshCustomCommands() {
   cachedCommands = null;
 }
-async function discoverCustomCommands(projectPath = join36(process.cwd(), COMMANDS_DIR)) {
+async function discoverCustomCommands(projectPath = join37(process.cwd(), COMMANDS_DIR)) {
   const commandsById = new Map;
   const userCommands = await discoverFromDirectory(GLOBAL_COMMANDS_DIR, "user");
   for (const cmd of userCommands) {
@@ -107144,7 +107665,7 @@ async function discoverCustomCommands(projectPath = join36(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source2) {
-  if (!existsSync28(dirPath)) {
+  if (!existsSync29(dirPath)) {
     return [];
   }
   const commands2 = [];
@@ -107155,7 +107676,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source2) {
   try {
     const entries = await readdir8(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join36(currentPath, entry.name);
+      const fullPath = join37(currentPath, entry.name);
       if (entry.isDirectory()) {
         await findCommandFiles(fullPath, rootPath, commands2, source2);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -107173,7 +107694,7 @@ async function parseCommandFile(filePath, rootPath, source2) {
   const content = await readFile10(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const id = basename5(filePath, ".md");
-  const relativePath = dirname15(filePath).slice(rootPath.length);
+  const relativePath = dirname16(filePath).slice(rootPath.length);
   const namespace = relativePath.replace(/^[/\\]/, "") || undefined;
   let description = getStringField(frontmatter, "description");
   if (!description) {
@@ -107240,7 +107761,7 @@ async function findCustomCommand(commandName) {
 }
 var COMMANDS_DIR = ".commands", GLOBAL_COMMANDS_DIR, cachedCommands = null;
 var init_custom = __esm(() => {
-  GLOBAL_COMMANDS_DIR = join36(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
+  GLOBAL_COMMANDS_DIR = join37(process.env.HOME || process.env.USERPROFILE || "~", ".letta/commands");
 });
 
 // src/cli/components/HelpDialog.tsx
@@ -107509,10 +108030,10 @@ function HelpDialog({ onClose }) {
 var import_react63, jsx_dev_runtime40, PAGE_SIZE = 10, HELP_TABS;
 var init_HelpDialog = __esm(async () => {
   init_version();
-  init_registry();
   init_colors();
   await __promiseAll([
     init_build2(),
+    init_registry(),
     init_Text2()
   ]);
   import_react63 = __toESM(require_react(), 1);
@@ -110160,7 +110681,7 @@ var init_AgentInfoBar = __esm(async () => {
 
 // src/cli/helpers/fileSearch.ts
 import { readdirSync as readdirSync12, statSync as statSync9 } from "node:fs";
-import { join as join37, relative as relative15, resolve as resolve29 } from "node:path";
+import { join as join38, relative as relative15, resolve as resolve29 } from "node:path";
 function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [], depth = 0, maxDepth = 10, lowerPattern = pattern.toLowerCase()) {
   if (results.length >= maxResults || depth >= maxDepth) {
     return results;
@@ -110169,7 +110690,7 @@ function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [],
     const entries = readdirSync12(dir);
     for (const entry of entries) {
       try {
-        const fullPath = join37(dir, entry);
+        const fullPath = join38(dir, entry);
         const relativePath = relative15(process.cwd(), fullPath);
         if (shouldHardExcludeEntry(entry)) {
           continue;
@@ -110247,7 +110768,7 @@ async function searchFiles(query, deep = false) {
         const matchingEntries = entries.filter((entry) => !shouldHardExcludeEntry(entry) && (searchPattern.length === 0 || entry.toLowerCase().includes(lowerPattern)));
         for (const entry of matchingEntries.slice(0, 50)) {
           try {
-            const fullPath = join37(searchDir, entry);
+            const fullPath = join38(searchDir, entry);
             const stats = statSync9(fullPath);
             const relativePath = relative15(process.cwd(), fullPath);
             results.push({
@@ -110749,10 +111270,10 @@ function SlashCommandAutocomplete({
 }
 var import_react69, jsx_dev_runtime46, VISIBLE_COMMANDS = 7, CMD_COL_WIDTH = 14, _allCommands;
 var init_SlashCommandAutocomplete = __esm(async () => {
-  init_registry();
   init_useTerminalWidth();
   await __promiseAll([
     init_settings_manager(),
+    init_registry(),
     init_useAutocompleteNavigation(),
     init_Autocomplete(),
     init_Text2()
@@ -111148,6 +111669,7 @@ function Input({
   agentName,
   currentModel,
   currentModelProvider,
+  hasTemporaryModelOverride = false,
   currentReasoningEffort,
   messageQueue,
   onEnterQueueEditMode,
@@ -111749,6 +112271,7 @@ function Input({
               currentReasoningEffort,
               isOpenAICodexProvider: currentModelProvider === OPENAI_CODEX_PROVIDER_NAME,
               isByokProvider: currentModelProvider?.startsWith("lc-") || currentModelProvider === OPENAI_CODEX_PROVIDER_NAME,
+              hasTemporaryModelOverride,
               hideFooter,
               rightColumnWidth: footerRightColumnWidth,
               statusLineText,
@@ -111793,6 +112316,7 @@ function Input({
     currentModel,
     currentReasoningEffort,
     currentModelProvider,
+    hasTemporaryModelOverride,
     hideFooter,
     footerRightColumnWidth,
     reserveInputSpace,
@@ -111888,6 +112412,7 @@ var init_InputRich = __esm(async () => {
     currentReasoningEffort,
     isOpenAICodexProvider,
     isByokProvider,
+    hasTemporaryModelOverride,
     hideFooter,
     rightColumnWidth,
     statusLineText,
@@ -111936,11 +112461,12 @@ var init_InputRich = __esm(async () => {
     const displayAgentName = truncateEnd(agentName || "Unnamed", maxAgentChars);
     const reasoningTag = getReasoningEffortTag(currentReasoningEffort);
     const byokExtraChars = isByokProvider ? 2 : 0;
-    const baseReservedChars = displayAgentName.length + byokExtraChars + 4;
+    const tempOverrideExtraChars = hasTemporaryModelOverride ? 2 : 0;
+    const baseReservedChars = displayAgentName.length + byokExtraChars + tempOverrideExtraChars + 4;
     const modelWithReasoning = (currentModel ?? "unknown") + (reasoningTag ? ` (${reasoningTag})` : "");
     const maxModelChars = Math.max(8, rightColumnWidth - baseReservedChars);
     const displayModel = truncateEnd(modelWithReasoning, maxModelChars);
-    const rightTextLength = displayAgentName.length + displayModel.length + byokExtraChars + 3;
+    const rightTextLength = displayAgentName.length + displayModel.length + byokExtraChars + tempOverrideExtraChars + 3;
     const rightPrefixSpaces = Math.max(0, rightColumnWidth - rightTextLength);
     const bgIndicatorWidth = backgroundAgents.length > 0 ? 3 + bgAgentParts.reduce((acc, p, i) => acc + (i > 0 ? 3 : 0) + p.typeLabel.length + 1 + p.elapsed.length + 2, 0) + 3 : 0;
     const effectiveRightWidth = backgroundAgents.length > 0 ? Math.max(rightColumnWidth, bgIndicatorWidth + rightTextLength) : rightColumnWidth;
@@ -111953,9 +112479,19 @@ var init_InputRich = __esm(async () => {
         parts.push(source_default.dim(" "));
         parts.push(isOpenAICodexProvider ? source_default.hex("#74AA9C")("▲") : source_default.yellow("▲"));
       }
+      if (hasTemporaryModelOverride) {
+        parts.push(source_default.dim(" "));
+        parts.push(source_default.yellow("▲"));
+      }
       parts.push(source_default.dim("]"));
       return parts.join("");
-    }, [displayAgentName, displayModel, isByokProvider, isOpenAICodexProvider]);
+    }, [
+      displayAgentName,
+      displayModel,
+      isByokProvider,
+      isOpenAICodexProvider,
+      hasTemporaryModelOverride
+    ]);
     const rightLabel = import_react73.useMemo(() => " ".repeat(rightPrefixSpaces) + rightLabelCore, [rightPrefixSpaces, rightLabelCore]);
     return /* @__PURE__ */ jsx_dev_runtime50.jsxDEV(Box_default, {
       flexDirection: "row",
@@ -112299,15 +112835,15 @@ var init_InputRich = __esm(async () => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import {
-  existsSync as existsSync29,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync21,
   mkdtempSync,
   readFileSync as readFileSync14,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname16, join as join38 } from "node:path";
+import { dirname as dirname17, join as join39 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync4(command, args, {
@@ -112541,8 +113077,8 @@ async function createLettaAgent(apiKey, name) {
   return { id: data.id, name: data.name };
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync(join38(tmpdir4(), "letta-install-github-app-"));
-  const repoDir = join38(tempDir, "repo");
+  const tempDir = mkdtempSync(join39(tmpdir4(), "letta-install-github-app-"));
+  const repoDir = join39(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -112553,19 +113089,19 @@ function runGit5(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join38(repoDir, workflowPath);
-  if (!existsSync29(dirname16(absolutePath))) {
-    mkdirSync20(dirname16(absolutePath), { recursive: true });
+  const absolutePath = join39(repoDir, workflowPath);
+  if (!existsSync30(dirname17(absolutePath))) {
+    mkdirSync21(dirname17(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync29(absolutePath)) {
+  if (existsSync30(absolutePath)) {
     const previous = readFileSync14(absolutePath, "utf8");
     if (previous === next) {
       return false;
     }
   }
-  writeFileSync14(absolutePath, next, "utf8");
+  writeFileSync15(absolutePath, next, "utf8");
   return true;
 }
 function getDefaultBaseBranch(repoDir) {
@@ -116460,9 +116996,9 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb4 } from "node:child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync30, mkdirSync as mkdirSync21, writeFileSync as writeFileSync15 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync31, mkdirSync as mkdirSync22, writeFileSync as writeFileSync16 } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 import { promisify as promisify12 } from "node:util";
 async function runGitSafe(cwd2, args) {
   try {
@@ -116745,14 +117281,14 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   }
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync30(VIEWERS_DIR2)) {
-    mkdirSync21(VIEWERS_DIR2, { recursive: true, mode: 448 });
+  if (!existsSync31(VIEWERS_DIR2)) {
+    mkdirSync22(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync3(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join39(VIEWERS_DIR2, `memory-${encodeURIComponent(agentId)}.html`);
-  writeFileSync15(filePath, html);
+  const filePath = join40(VIEWERS_DIR2, `memory-${encodeURIComponent(agentId)}.html`);
+  writeFileSync16(filePath, html);
   chmodSync3(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
   if (!skipOpen) {
@@ -116775,12 +117311,12 @@ var init_generate_memory_viewer = __esm(async () => {
     init_memoryGit()
   ]);
   execFile12 = promisify12(execFileCb4);
-  VIEWERS_DIR2 = join39(homedir31(), ".letta", "viewers");
+  VIEWERS_DIR2 = join40(homedir31(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i = 0;i < node.depth; i++) {
@@ -116806,7 +117342,7 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react77.useState(null);
   const statusTimerRef = import_react77.useRef(null);
   const memoryRoot = getMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync31(memoryRoot);
+  const memoryExists = existsSync32(memoryRoot);
   const hasGitRepo = import_react77.useMemo(() => isGitRepo(agentId), [agentId]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
@@ -117599,6 +118135,9 @@ function truncateText4(text, maxWidth) {
     return text;
   return `${text.slice(0, maxWidth - 3)}...`;
 }
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, (match3) => `\\${match3}`);
+}
 function getMessageText(msg) {
   if ("content" in msg) {
     const content = msg.content;
@@ -117629,6 +118168,34 @@ function getMessageText(msg) {
   }
   return `[${msg.message_type || "unknown"}]`;
 }
+function HighlightedText({ text, query }) {
+  if (!query.trim())
+    return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+      children: text
+    }, undefined, false, undefined, this);
+  const highlightTerms = [
+    ...new Set(query.trim().split(/\s+/).filter(Boolean))
+  ].sort((a, b) => b.length - a.length);
+  if (highlightTerms.length === 0)
+    return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+      children: text
+    }, undefined, false, undefined, this);
+  const parts = text.split(new RegExp(`(${highlightTerms.map(escapeRegExp).join("|")})`, "gi"));
+  let offset = 0;
+  return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+    children: parts.map((part) => {
+      const key = `${offset}-${part}`;
+      offset += part.length;
+      return highlightTerms.some((term) => part.toLowerCase() === term.toLowerCase()) ? /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+        bold: true,
+        color: colors.selector.itemHighlighted,
+        children: part
+      }, key, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+        children: part
+      }, key, false, undefined, this);
+    })
+  }, undefined, false, undefined, this);
+}
 function MessageSearch({
   onClose,
   initialQuery,
@@ -117856,24 +118423,23 @@ function MessageSearch({
         const isAssistant = msgType === "assistant_message" || msgType === "reasoning_message";
         const typeLabel = isAssistant ? "Agent message" : "User message";
         const timestamp = formatLocalTime(msgData.created_at || msgData.date);
-        return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(jsx_dev_runtime56.Fragment, {
+        return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
+          flexDirection: "column",
+          paddingX: 1,
           children: [
             /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
               paddingLeft: 2,
-              children: /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
-                children: [
-                  '"',
-                  fullText,
-                  '"'
-                ]
-              }, undefined, true, undefined, this)
-            }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
-              height: 1
+              paddingY: 1,
+              marginBottom: 1,
+              children: /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(HighlightedText, {
+                text: fullText,
+                query: activeQuery
+              }, undefined, false, undefined, this)
             }, undefined, false, undefined, this),
             /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
               flexDirection: "column",
               paddingLeft: 2,
+              gap: 0,
               children: [
                 /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
                   dimColor: true,
@@ -117883,18 +118449,30 @@ function MessageSearch({
                     timestamp
                   ]
                 }, undefined, true, undefined, this),
-                /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
-                  dimColor: true,
+                /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
+                  flexDirection: "row",
                   children: [
-                    "Agent ID: ",
-                    msgData.agent_id || "unknown"
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      dimColor: true,
+                      children: "Agent ID: "
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      dimColor: true,
+                      children: msgData.agent_id || "unknown"
+                    }, undefined, false, undefined, this)
                   ]
                 }, undefined, true, undefined, this),
-                msgData.conversation_id && /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
-                  dimColor: true,
+                msgData.conversation_id && /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
+                  flexDirection: "row",
                   children: [
-                    "Conv ID: ",
-                    msgData.conversation_id
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      dimColor: true,
+                      children: "Conversation ID: "
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      dimColor: true,
+                      children: msgData.conversation_id
+                    }, undefined, false, undefined, this)
                   ]
                 }, undefined, true, undefined, this)
               ]
@@ -117906,7 +118484,21 @@ function MessageSearch({
               paddingLeft: 2,
               children: /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
                 dimColor: true,
-                children: onOpenConversation ? "Enter to open conversation · Esc cancel" : "Esc cancel"
+                children: onOpenConversation ? /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(jsx_dev_runtime56.Fragment, {
+                  children: [
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      children: "Enter to open conversation"
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      children: " · "
+                    }, undefined, false, undefined, this),
+                    /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                      children: "Esc cancel"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
+                  children: "Esc cancel"
+                }, undefined, false, undefined, this)
               }, undefined, false, undefined, this)
             }, undefined, false, undefined, this)
           ]
@@ -118072,9 +118664,11 @@ function MessageSearch({
                   }, undefined, true, undefined, this),
                   /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Text2, {
                     bold: isSelected,
-                    italic: true,
                     color: isSelected ? colors.selector.itemHighlighted : undefined,
-                    children: displayText
+                    children: /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(HighlightedText, {
+                      text: displayText,
+                      query: activeQuery
+                    }, undefined, false, undefined, this)
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
@@ -119326,10 +119920,10 @@ var init_PendingApprovalStub = __esm(async () => {
 // src/utils/aws-credentials.ts
 import { readFile as readFile11 } from "node:fs/promises";
 import { homedir as homedir32 } from "node:os";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join40(homedir32(), ".aws", "credentials");
-  const configPath = join40(homedir32(), ".aws", "config");
+  const credentialsPath = join41(homedir32(), ".aws", "credentials");
+  const configPath = join41(homedir32(), ".aws", "config");
   const profiles = new Map;
   try {
     const content = await readFile11(credentialsPath, "utf-8");
@@ -120437,8 +121031,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills3, SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join41 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join41(process.cwd(), SKILLS_DIR3);
+        const { join: join42 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join42(process.cwd(), SKILLS_DIR3);
         const result = await discoverSkills3(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -124346,8 +124940,8 @@ var init_contextChart = __esm(() => {
 
 // src/cli/helpers/initCommand.ts
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync32, readdirSync as readdirSync13, readFileSync as readFileSync15 } from "node:fs";
-import { join as join41 } from "node:path";
+import { existsSync as existsSync33, readdirSync as readdirSync13, readFileSync as readFileSync15 } from "node:fs";
+import { join as join42 } from "node:path";
 function hasActiveInitSubagent() {
   const snapshot = getSnapshot2();
   return snapshot.agents.some((agent) => agent.type.toLowerCase() === "init" && (agent.status === "pending" || agent.status === "running"));
@@ -124382,7 +124976,7 @@ ${git.recentCommits || "No commits yet"}
 }
 function gatherExistingMemory(agentId) {
   const systemDir = getMemorySystemDir(agentId);
-  if (!existsSync32(systemDir))
+  if (!existsSync33(systemDir))
     return { paths: [], contents: "" };
   const paths = [];
   const sections = [];
@@ -124391,10 +124985,10 @@ function gatherExistingMemory(agentId) {
       for (const entry of readdirSync13(dir, { withFileTypes: true })) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
-          walk(join41(dir, entry.name), rel);
+          walk(join42(dir, entry.name), rel);
         } else if (entry.name.endsWith(".md")) {
           try {
-            const content = readFileSync15(join41(dir, entry.name), "utf-8");
+            const content = readFileSync15(join42(dir, entry.name), "utf-8");
             paths.push(rel);
             sections.push(`── ${rel}
 ${content.slice(0, 2000)}`);
@@ -124447,7 +125041,7 @@ function gatherDirListing() {
       if (entry.isDirectory()) {
         lines.push(`${prefix}${entry.name}/`);
         try {
-          const dirPath = join41(cwd2, entry.name);
+          const dirPath = join42(cwd2, entry.name);
           const childEntries = readdirSync13(dirPath, {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith("."));
@@ -124723,7 +125317,7 @@ import {
   writeFile as writeFile7
 } from "node:fs/promises";
 import { homedir as homedir33, tmpdir as tmpdir5 } from "node:os";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 function buildReflectionSubagentPrompt(input) {
   const lines = [];
   if (input.cwd) {
@@ -124756,7 +125350,7 @@ async function collectParentMemoryFiles(memoryDir) {
       return a.name.localeCompare(b.name);
     });
     for (const entry of sortedEntries) {
-      const entryPath = join42(currentDir, entry.name);
+      const entryPath = join43(currentDir, entry.name);
       const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         await walk(entryPath, relativePath);
@@ -124916,7 +125510,7 @@ function getTranscriptRoot() {
   if (envRoot) {
     return envRoot;
   }
-  return join42(homedir33(), ".letta", DEFAULT_TRANSCRIPT_DIR);
+  return join43(homedir33(), ".letta", DEFAULT_TRANSCRIPT_DIR);
 }
 function defaultState() {
   return { auto_cursor_line: 0 };
@@ -125028,14 +125622,14 @@ async function readTranscriptLines(paths) {
 }
 function buildPayloadPath(kind) {
   const nonce = Math.random().toString(36).slice(2, 8);
-  return join42(tmpdir5(), `letta-${kind}-${nonce}.txt`);
+  return join43(tmpdir5(), `letta-${kind}-${nonce}.txt`);
 }
 function getReflectionTranscriptPaths(agentId, conversationId) {
-  const rootDir = join42(getTranscriptRoot(), sanitizePathSegment(agentId), sanitizePathSegment(conversationId));
+  const rootDir = join43(getTranscriptRoot(), sanitizePathSegment(agentId), sanitizePathSegment(conversationId));
   return {
     rootDir,
-    transcriptPath: join42(rootDir, "transcript.jsonl"),
-    statePath: join42(rootDir, "state.json")
+    transcriptPath: join43(rootDir, "transcript.jsonl"),
+    statePath: join43(rootDir, "state.json")
   };
 }
 async function appendTranscriptDeltaJsonl(agentId, conversationId, lines) {
@@ -125865,12 +126459,12 @@ __export(exports_shellAliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync33, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync16 } from "node:fs";
 import { homedir as homedir34 } from "node:os";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync33(filePath)) {
+  if (!existsSync34(filePath)) {
     return aliases;
   }
   try {
@@ -125939,7 +126533,7 @@ function loadAliases(forceReload = false) {
   const home = homedir34();
   const allAliases = new Map;
   for (const file of ALIAS_FILES) {
-    const filePath = join43(home, file);
+    const filePath = join44(home, file);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -126699,7 +127293,10 @@ __export(exports_conversationSwitchAlert, {
 });
 function buildConversationSwitchAlert(ctx) {
   const parts = [];
-  if (ctx.origin === "new" || ctx.origin === "clear") {
+  if (ctx.origin === "fork") {
+    parts.push("Forked conversation. This is a copy of the previous conversation with a freshly compiled system message.");
+    parts.push(`Conversation: ${ctx.conversationId}`);
+  } else if (ctx.origin === "new" || ctx.origin === "clear") {
     parts.push("New conversation started. This is a fresh conversation thread with no prior messages.");
     parts.push(`Conversation: ${ctx.conversationId}`);
   } else if (ctx.origin === "search") {
@@ -126786,9 +127383,9 @@ __export(exports_App, {
   default: () => App2
 });
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { existsSync as existsSync34, readFileSync as readFileSync17, renameSync as renameSync2, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync35, readFileSync as readFileSync17, renameSync as renameSync2, writeFileSync as writeFileSync17 } from "node:fs";
 import { homedir as homedir35, tmpdir as tmpdir6 } from "node:os";
-import { join as join44, relative as relative17 } from "node:path";
+import { join as join45, relative as relative17 } from "node:path";
 function deriveReasoningEffort(modelSettings, llmConfig) {
   if (modelSettings && "provider_type" in modelSettings) {
     if (modelSettings.provider_type === "openai" && "reasoning" in modelSettings && modelSettings.reasoning) {
@@ -126951,23 +127548,27 @@ async function isRetriableError(stopReason, lastRunId) {
   }
   return false;
 }
-function saveLastAgentBeforeExit() {
+function saveLastSessionBeforeExit(conversationId) {
   try {
     const currentAgentId = getCurrentAgentId();
-    settingsManager.updateLocalProjectSettings({ lastAgent: currentAgentId });
-    settingsManager.updateSettings({ lastAgent: currentAgentId });
+    if (conversationId && conversationId !== "default") {
+      settingsManager.persistSession(currentAgentId, conversationId);
+    } else {
+      settingsManager.updateLocalProjectSettings({ lastAgent: currentAgentId });
+      settingsManager.updateSettings({ lastAgent: currentAgentId });
+    }
   } catch {}
 }
 function planFileExists(fallbackPlanFilePath) {
   const planFilePath = permissionMode.getPlanFilePath() ?? fallbackPlanFilePath;
-  return !!planFilePath && existsSync34(planFilePath);
+  return !!planFilePath && existsSync35(planFilePath);
 }
 function _readPlanFile(fallbackPlanFilePath) {
   const planFilePath = permissionMode.getPlanFilePath() ?? fallbackPlanFilePath;
   if (!planFilePath) {
     return "No plan file path set.";
   }
-  if (!existsSync34(planFilePath)) {
+  if (!existsSync35(planFilePath)) {
     return `Plan file not found at ${planFilePath}`;
   }
   try {
@@ -127334,11 +127935,26 @@ function App2({
     agentStateRef.current = agentState;
   }, [agentState]);
   const [currentModelId, setCurrentModelId] = import_react101.useState(null);
+  const [tempModelOverride, _setTempModelOverride] = import_react101.useState(null);
+  const [tempModelOverrideContext, setTempModelOverrideContext] = import_react101.useState({ agentId, conversationId });
+  const tempModelOverrideRef = import_react101.useRef(null);
+  const setTempModelOverride = import_react101.useCallback((next) => {
+    tempModelOverrideRef.current = next;
+    _setTempModelOverride(next);
+  }, []);
+  if (tempModelOverrideContext.agentId !== agentId || tempModelOverrideContext.conversationId !== conversationId) {
+    setTempModelOverrideContext({ agentId, conversationId });
+    if (tempModelOverride !== null) {
+      setTempModelOverride(null);
+    } else if (tempModelOverrideRef.current !== null) {
+      tempModelOverrideRef.current = null;
+    }
+  }
   const [currentModelHandle, setCurrentModelHandle] = import_react101.useState(null);
   const agentName = agentState?.name ?? null;
   const [agentDescription, setAgentDescription] = import_react101.useState(null);
   const [agentLastRunAt, setAgentLastRunAt] = import_react101.useState(null);
-  const currentModelLabel = currentModelHandle || agentState?.model || (llmConfig?.model_endpoint_type && llmConfig?.model ? `${llmConfig.model_endpoint_type}/${llmConfig.model}` : llmConfig?.model ?? null) || null;
+  const currentModelLabel = tempModelOverride || currentModelHandle || agentState?.model || (llmConfig?.model_endpoint_type && llmConfig?.model ? `${llmConfig.model_endpoint_type}/${llmConfig.model}` : llmConfig?.model ?? null) || null;
   const effectiveModelSettings = hasConversationModelOverride ? conversationOverrideModelSettings : agentState?.model_settings;
   const derivedReasoningEffort = deriveReasoningEffort(effectiveModelSettings, llmConfig);
   const currentModelDisplay = import_react101.useMemo(() => {
@@ -127355,6 +127971,7 @@ function App2({
   }, [currentModelLabel, derivedReasoningEffort, llmConfig]);
   const currentModelProvider = llmConfig?.provider_name ?? null;
   const currentReasoningEffort = currentModelLabel?.startsWith("letta/auto") ? null : derivedReasoningEffort ?? inferReasoningEffortFromModelPreset(currentModelId, currentModelLabel);
+  const hasTemporaryModelOverride = tempModelOverride !== null;
   const [billingTier, setBillingTier] = import_react101.useState(null);
   import_react101.useEffect(() => {
     setErrorContext({
@@ -127504,6 +128121,7 @@ function App2({
   const abortControllerRef = import_react101.useRef(null);
   const userCancelledRef = import_react101.useRef(false);
   const llmApiErrorRetriesRef = import_react101.useRef(0);
+  const quotaAutoSwapAttemptedRef = import_react101.useRef(false);
   const emptyResponseRetriesRef = import_react101.useRef(0);
   const conversationBusyRetriesRef = import_react101.useRef(0);
   const [queueDisplay, setQueueDisplay] = import_react101.useState([]);
@@ -128112,10 +128730,16 @@ function App2({
   }, [commitEligibleLines]);
   refreshDerivedRef.current = refreshDerived;
   const recordCommandReminder = import_react101.useCallback((event) => {
-    const input = event.input.trim();
+    let input = event.input.trim();
     if (!input.startsWith("/")) {
       return;
     }
+    if (/^\/secret\s+set\s+/i.test(input)) {
+      const parts = input.split(/\s+/);
+      if (parts.length >= 4) {
+        input = `${parts[0]} ${parts[1]} ${parts[2]} ***`;
+      }
+    }
     enqueueCommandIoReminder(sharedReminderStateRef.current, {
       input,
       output: event.output,
@@ -128263,8 +128887,8 @@ function App2({
     if (!planFilePath)
       return;
     try {
-      const { readFileSync: readFileSync18, existsSync: existsSync35 } = __require("node:fs");
-      if (!existsSync35(planFilePath))
+      const { readFileSync: readFileSync18, existsSync: existsSync36 } = __require("node:fs");
+      if (!existsSync36(planFilePath))
         return;
       const planContent = readFileSync18(planFilePath, "utf-8");
       const previewItem = {
@@ -128674,9 +129298,9 @@ Memory may be stale. Try running: git -C ~/.letta/agents/${agentId}/memory pull`
     (async () => {
       try {
         const { watch } = await import("node:fs");
-        const { existsSync: existsSync35 } = await import("node:fs");
+        const { existsSync: existsSync36 } = await import("node:fs");
         const memRoot = getMemoryFilesystemRoot(agentId);
-        if (!existsSync35(memRoot))
+        if (!existsSync36(memRoot))
           return;
         watcher = watch(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher;
@@ -128834,6 +129458,7 @@ ${newState.originalPrompt}`,
       llmApiErrorRetriesRef.current = 0;
       emptyResponseRetriesRef.current = 0;
       conversationBusyRetriesRef.current = 0;
+      quotaAutoSwapAttemptedRef.current = false;
     }
     let currentRunId;
     let preserveTranscriptStartForApproval = false;
@@ -128883,7 +129508,6 @@ ${newState.originalPrompt}`,
       if (shouldClearCompletedSubagentsOnTurnStart(allowReentry, hasActiveSubagents())) {
         clearCompletedSubagents();
       }
-      const requestStartedAtMs = Date.now();
       let highestSeqIdSeen = null;
       while (true) {
         const signal = abortControllerRef.current?.signal;
@@ -128911,8 +129535,12 @@ ${newState.originalPrompt}`,
         }
         let stream2 = null;
         let turnToolContextId = null;
+        let preStreamResumeResult = null;
         try {
-          const nextStream = await sendMessageStream(conversationIdRef.current, currentInput, { agentId: agentIdRef.current });
+          const nextStream = await sendMessageStream(conversationIdRef.current, currentInput, {
+            agentId: agentIdRef.current,
+            overrideModel: tempModelOverrideRef.current ?? undefined
+          });
           stream2 = nextStream;
           turnToolContextId = getStreamToolContextId(nextStream);
         } catch (preStreamError) {
@@ -128950,30 +129578,64 @@ ${newState.originalPrompt}`,
               httpStatus: preStreamError instanceof APIError2 ? preStreamError.status : undefined,
               modelId: currentModelId || undefined
             });
-            const statusId = uid5("status");
-            buffersRef.current.byId.set(statusId, {
-              kind: "status",
-              id: statusId,
-              lines: ["Conversation is busy, waiting and retrying…"]
-            });
-            buffersRef.current.order.push(statusId);
-            refreshDerived();
-            let cancelled = false;
-            const startTime = Date.now();
-            while (Date.now() - startTime < retryDelayMs) {
-              if (abortControllerRef.current?.signal.aborted || userCancelledRef.current) {
-                cancelled = true;
-                break;
+            try {
+              const client = await getClient2();
+              const messageOtid = currentInput.map((item) => item.otid).find((v) => typeof v === "string");
+              debugLog("stream", "Conversation busy: resuming via stream endpoint (otid=%s)", messageOtid ?? "none");
+              if (signal?.aborted || userCancelledRef.current) {
+                const isStaleAtAbort = myGeneration !== conversationGenerationRef.current;
+                if (!isStaleAtAbort) {
+                  setStreaming(false);
+                }
+                return;
               }
-              await new Promise((resolve31) => setTimeout(resolve31, 100));
-            }
-            buffersRef.current.byId.delete(statusId);
-            buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
-            refreshDerived();
-            if (!cancelled) {
+              const conversationId2 = conversationIdRef.current ?? "default";
+              const resumeStream = await client.conversations.messages.stream(conversationId2, {
+                agent_id: conversationId2 === "default" ? agentIdRef.current ?? undefined : undefined,
+                otid: messageOtid ?? undefined,
+                starting_after: 0,
+                batch_size: 1000
+              });
               buffersRef.current.interrupted = false;
-              restorePinnedPermissionMode();
-              continue;
+              buffersRef.current.commitGeneration = (buffersRef.current.commitGeneration || 0) + 1;
+              preStreamResumeResult = await drainStream(resumeStream, buffersRef.current, refreshDerivedThrottled, signal, undefined, undefined, contextTrackerRef.current, highestSeqIdSeen);
+              debugLog("stream", "Pre-stream resume succeeded (stopReason=%s)", preStreamResumeResult.stopReason);
+            } catch (resumeError) {
+              if (signal?.aborted || userCancelledRef.current) {
+                const isStaleAtAbort = myGeneration !== conversationGenerationRef.current;
+                if (!isStaleAtAbort) {
+                  setStreaming(false);
+                }
+                return;
+              }
+              debugLog("stream", "Pre-stream resume failed, falling back to wait/retry: %s", resumeError instanceof Error ? resumeError.message : String(resumeError));
+            }
+            if (!preStreamResumeResult) {
+              const statusId = uid5("status");
+              buffersRef.current.byId.set(statusId, {
+                kind: "status",
+                id: statusId,
+                lines: ["Conversation is busy, waiting and retrying…"]
+              });
+              buffersRef.current.order.push(statusId);
+              refreshDerived();
+              let cancelled = false;
+              const startTime = Date.now();
+              while (Date.now() - startTime < retryDelayMs) {
+                if (abortControllerRef.current?.signal.aborted || userCancelledRef.current) {
+                  cancelled = true;
+                  break;
+                }
+                await new Promise((resolve31) => setTimeout(resolve31, 100));
+              }
+              buffersRef.current.byId.delete(statusId);
+              buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
+              refreshDerived();
+              if (!cancelled) {
+                buffersRef.current.interrupted = false;
+                restorePinnedPermissionMode();
+                continue;
+              }
             }
           }
           if (preStreamAction === "retry_transient") {
@@ -129118,10 +129780,12 @@ ${newState.originalPrompt}`,
         if (hasUserMessage) {
           contextTrackerRef.current.currentTurnId++;
         }
-        if (!stream2) {
-          throw new Error("Expected stream to be set before drain");
-        }
-        const drainResult = drainStreamWithResume(stream2, buffersRef.current, refreshDerivedThrottled, signal, handleFirstMessage, undefined, contextTrackerRef.current, highestSeqIdSeen);
+        const drainResult = preStreamResumeResult ? preStreamResumeResult : (() => {
+          if (!stream2) {
+            throw new Error("Expected stream when pre-stream resume did not succeed");
+          }
+          return drainStreamWithResume(stream2, buffersRef.current, refreshDerivedThrottled, signal, handleFirstMessage, undefined, contextTrackerRef.current, highestSeqIdSeen);
+        })();
         const {
           stopReason,
           approval,
@@ -129703,6 +130367,37 @@ ${feedback}
           buffersRef.current.interrupted = false;
           continue;
         }
+        const autoSwapOnQuotaLimitEnabled = settingsManager.getSetting("autoSwapOnQuotaLimit") !== false;
+        const isQuotaLimit = isQuotaLimitErrorDetail(detailFromRun ?? fallbackError);
+        const alreadyOnTempAuto = tempModelOverrideRef.current === TEMP_QUOTA_OVERRIDE_MODEL;
+        const canAttemptQuotaAutoSwap = autoSwapOnQuotaLimitEnabled && isQuotaLimit && !alreadyOnTempAuto && !quotaAutoSwapAttemptedRef.current;
+        if (canAttemptQuotaAutoSwap) {
+          quotaAutoSwapAttemptedRef.current = true;
+          setTempModelOverride(TEMP_QUOTA_OVERRIDE_MODEL);
+          const statusId = uid5("status");
+          buffersRef.current.byId.set(statusId, {
+            kind: "status",
+            id: statusId,
+            lines: [
+              "Quota limit reached; temporarily switching to Auto and continuing..."
+            ]
+          });
+          buffersRef.current.order.push(statusId);
+          refreshDerived();
+          currentInput = [
+            ...currentInput,
+            {
+              type: "message",
+              role: "user",
+              content: "Keep going."
+            }
+          ];
+          buffersRef.current.byId.delete(statusId);
+          buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
+          refreshDerived();
+          buffersRef.current.interrupted = false;
+          continue;
+        }
         if (isEmptyResponseRetryable(stopReasonToHandle === "llm_api_error" ? "llm_error" : undefined, detailFromRun, emptyResponseRetriesRef.current, EMPTY_RESPONSE_MAX_RETRIES3)) {
           emptyResponseRetriesRef.current += 1;
           const attempt = emptyResponseRetriesRef.current;
@@ -129780,6 +130475,7 @@ ${feedback}
           }
           if (!cancelled) {
             refreshCurrentInputOtids();
+            highestSeqIdSeen = null;
             buffersRef.current.interrupted = false;
             continue;
           }
@@ -129939,7 +130635,7 @@ ${feedback}
     setUiPermissionMode
   ]);
   const handleExit = import_react101.useCallback(async () => {
-    saveLastAgentBeforeExit();
+    saveLastSessionBeforeExit(conversationIdRef.current);
     await runEndHooks();
     const stats = sessionStatsRef.current.getSnapshot();
     telemetry.trackSessionEnd(stats, "exit_command");
@@ -130199,11 +130895,7 @@ ${feedback}
       const agent = await client.agents.retrieve(targetAgentId);
       const targetConversationId = opts?.conversationId ?? "default";
       await updateProjectSettings({ lastAgent: targetAgentId });
-      settingsManager.setLocalLastSession({ agentId: targetAgentId, conversationId: targetConversationId }, process.cwd());
-      settingsManager.setGlobalLastSession({
-        agentId: targetAgentId,
-        conversationId: targetConversationId
-      });
+      settingsManager.persistSession(targetAgentId, targetConversationId);
       buffersRef.current.byId.clear();
       buffersRef.current.order = [];
       buffersRef.current.tokenCount = 0;
@@ -130291,11 +130983,7 @@ ${feedback}
       }
       await updateProjectSettings({ lastAgent: agent.id });
       const targetConversationId = "default";
-      settingsManager.setLocalLastSession({ agentId: agent.id, conversationId: targetConversationId }, process.cwd());
-      settingsManager.setGlobalLastSession({
-        agentId: agent.id,
-        conversationId: targetConversationId
-      });
+      settingsManager.persistSession(agent.id, targetConversationId);
       const agentUrl = buildChatUrl(agent.id);
       const memfsTip = settingsManager.isMemfsEnabled(agent.id) ? "Memory will be auto-initialized on your first message." : "Tip: use /init to initialize your agent's memory system!";
       const successOutput = [
@@ -130641,14 +131329,14 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
       setDequeueEpoch((e) => e + 1);
     }
     const isSlashCommand = userTextForInput.startsWith("/");
-    if (isAgentBusy() && isSlashCommand) {
+    const shouldBypassQueue = isSlashCommand && (isInteractiveCommand(userTextForInput) || isNonStateCommand(userTextForInput));
+    if (isAgentBusy() && isSlashCommand && !shouldBypassQueue) {
       const attemptedCommand = userTextForInput.split(/\s+/)[0] || "/";
       const disabledMessage = `'${attemptedCommand}' is disabled while the agent is running.`;
       const cmd = commandRunner.start(userTextForInput, disabledMessage);
       cmd.fail(disabledMessage);
       return { submitted: true };
     }
-    const shouldBypassQueue = isInteractiveCommand(userTextForInput) || isNonStateCommand(userTextForInput);
     if (isAgentBusy() && !shouldBypassQueue) {
       tuiQueueRef.current?.enqueue({
         kind: "message",
@@ -131144,7 +131832,7 @@ ${SYSTEM_REMINDER_CLOSE}` : "";
           }
           await settingsManager3.logout();
           cmd.finish("✓ Logged out successfully. Run 'letta' to re-authenticate.", true);
-          saveLastAgentBeforeExit();
+          saveLastSessionBeforeExit(conversationIdRef.current);
           const stats = sessionStatsRef.current.getSnapshot();
           telemetry.trackSessionEnd(stats, "logout");
           try {
@@ -131278,21 +131966,60 @@ Type your task to begin the loop.`, true);
             conversationId: conversation.id,
             isDefault: false
           };
-          settingsManager.setLocalLastSession({ agentId, conversationId: conversation.id }, process.cwd());
+          settingsManager.persistSession(agentId, conversation.id);
+          resetContextHistory(contextTrackerRef.current);
+          resetBootstrapReminderState();
+          sessionHooksRanRef.current = false;
+          runSessionStartHooks(true, agentId, agentName ?? undefined, conversation.id).then((result2) => {
+            if (result2.feedback.length > 0) {
+              sessionStartFeedbackRef.current = result2.feedback;
+            }
+          }).catch(() => {});
+          sessionHooksRanRef.current = true;
+          cmd.finish("Started new conversation (use /resume to change convos)", true);
+        } catch (error) {
+          const errorDetails = formatErrorDetails2(error, agentId);
+          cmd.fail(`Failed: ${errorDetails}`);
+        } finally {
+          setCommandRunning(false);
+        }
+        return { submitted: true };
+      }
+      if (msg.trim() === "/fork") {
+        if (conversationIdRef.current === "default") {
+          const cmd2 = commandRunner.start(msg.trim(), "Forking conversation...");
+          cmd2.fail("Cannot fork the default conversation — use /new instead");
+          return { submitted: true };
+        }
+        const cmd = commandRunner.start(msg.trim(), "Forking conversation...");
+        resetPendingReasoningCycle();
+        setCommandRunning(true);
+        await runEndHooks();
+        try {
+          const client = await getClient2();
+          const forked = await client.post(`/v1/conversations/${conversationIdRef.current}/fork`);
+          await maybeCarryOverActiveConversationModel(forked.id);
+          setConversationId3(forked.id);
+          pendingConversationSwitchRef.current = {
+            origin: "fork",
+            conversationId: forked.id,
+            isDefault: false
+          };
+          settingsManager.setLocalLastSession({ agentId, conversationId: forked.id }, process.cwd());
           settingsManager.setGlobalLastSession({
             agentId,
-            conversationId: conversation.id
+            conversationId: forked.id
           });
           resetContextHistory(contextTrackerRef.current);
           resetBootstrapReminderState();
           sessionHooksRanRef.current = false;
-          runSessionStartHooks(true, agentId, agentName ?? undefined, conversation.id).then((result2) => {
+          runSessionStartHooks(true, agentId, agentName ?? undefined, forked.id).then((result2) => {
             if (result2.feedback.length > 0) {
               sessionStartFeedbackRef.current = result2.feedback;
             }
           }).catch(() => {});
           sessionHooksRanRef.current = true;
-          cmd.finish("Started new conversation (use /resume to change convos)", true);
+          cmd.finish("Forked conversation (use /resume to switch back)", true);
         } catch (error) {
           const errorDetails = formatErrorDetails2(error, agentId);
           cmd.fail(`Failed: ${errorDetails}`);
@@ -131324,11 +132051,7 @@ Type your task to begin the loop.`, true);
             conversationId: conversation.id,
             isDefault: false
           };
-          settingsManager.setLocalLastSession({ agentId, conversationId: conversation.id }, process.cwd());
-          settingsManager.setGlobalLastSession({
-            agentId,
-            conversationId: conversation.id
-          });
+          settingsManager.persistSession(agentId, conversation.id);
           resetContextHistory(contextTrackerRef.current);
           resetBootstrapReminderState();
           sessionHooksRanRef.current = false;
@@ -131591,11 +132314,7 @@ Type your task to begin the loop.`, true);
                 messageCount: resumeData.messageHistory.length,
                 messageHistory: resumeData.messageHistory
               };
-              settingsManager.setLocalLastSession({ agentId, conversationId: targetConvId }, process.cwd());
-              settingsManager.setGlobalLastSession({
-                agentId,
-                conversationId: targetConvId
-              });
+              settingsManager.persistSession(agentId, targetConvId);
               const currentAgentName = agentState.name || "Unnamed Agent";
               const successLines = resumeData.messageHistory.length > 0 ? [
                 `Resumed conversation with "${currentAgentName}"`,
@@ -131904,7 +132623,7 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
             fileContent = await client.agents.exportFile(agentId, exportParams);
           }
           const fileName = exportParams.conversation_id ? `${exportParams.conversation_id}.af` : `${agentId}.af`;
-          writeFileSync16(fileName, JSON.stringify(fileContent, null, 2));
+          writeFileSync17(fileName, JSON.stringify(fileContent, null, 2));
           let summary = `AgentFile exported to ${fileName}`;
           if (skills.length > 0) {
             summary += `
@@ -131994,11 +132713,11 @@ Path: ${result2.memoryDir}`, true, msg);
           setCommandRunning(true);
           try {
             const memoryDir = getMemoryFilesystemRoot(agentId);
-            if (!existsSync34(memoryDir)) {
+            if (!existsSync35(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join44(tmpdir6(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join45(tmpdir6(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync2(memoryDir, backupDir);
             ensureMemoryFilesystemDirs(agentId);
             updateMemorySyncCommand(cmdId, `Memory filesystem reset.
@@ -132026,8 +132745,8 @@ Run \`/memfs sync\` to repopulate from API.`, true, msg);
             await removeGitMemoryTag2(agentId);
             let backupInfo = "";
             const memoryDir = getMemoryFilesystemRoot(agentId);
-            if (existsSync34(memoryDir)) {
-              const backupDir = join44(tmpdir6(), `letta-memfs-disable-${agentId}-${Date.now()}`);
+            if (existsSync35(memoryDir)) {
+              const backupDir = join45(tmpdir6(), `letta-memfs-disable-${agentId}-${Date.now()}`);
               renameSync2(memoryDir, backupDir);
               backupInfo = `
 Local files backed up to ${backupDir}`;
@@ -132295,7 +133014,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
         }
         return { submitted: true };
       }
-      const { commands: commands2, executeCommand: executeCommand2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
+      const { commands: commands2, executeCommand: executeCommand2 } = await init_registry().then(() => exports_registry);
       const registryCommandName = trimmed.split(/\s+/)[0] ?? "";
       const isRegistryCommand = Boolean(commands2[registryCommandName]);
       const registryCmd = isRegistryCommand ? commandRunner.start(msg, `Running ${registryCommandName}...`) : null;
@@ -132884,7 +133603,8 @@ ${SYSTEM_REMINDER_CLOSE}
       if (isQueuedValid) {
         initialInput.push({
           type: "approval",
-          approvals: queuedApprovalResults
+          approvals: queuedApprovalResults,
+          otid: randomUUID9()
         });
       } else {
         debugWarn("queue", "Dropping stale queued approval results for mismatched conversation or generation");
@@ -133103,7 +133823,11 @@ ${SYSTEM_REMINDER_CLOSE}
         const queuedNotifications = queuedItemsToAppend ? getQueuedNotificationSummaries(queuedItemsToAppend) : [];
         const hadNotifications = appendTaskNotificationEvents(queuedNotifications);
         const input = [
-          { type: "approval", approvals: allResults }
+          {
+            type: "approval",
+            approvals: allResults,
+            otid: randomUUID9()
+          }
         ];
         if (queuedItemsToAppend && queuedItemsToAppend.length > 0) {
           const queuedUserText = buildQueuedUserText(queuedItemsToAppend);
@@ -133492,6 +134216,7 @@ ${SYSTEM_REMINDER_CLOSE}
           } : {}
         });
         setCurrentModelId(modelId);
+        setTempModelOverride(null);
         resetContextHistory(contextTrackerRef.current);
         setCurrentModelHandle(modelHandle);
         const persistedToolsetPreference = settingsManager.getToolsetPreference(agentId);
@@ -133554,7 +134279,8 @@ ${guidance}`);
     maybeRecordToolsetChangeReminder,
     resetPendingReasoningCycle,
     withCommandLock,
-    setHasConversationModelOverride
+    setHasConversationModelOverride,
+    setTempModelOverride
   ]);
   const handleSystemPromptSelect = import_react101.useCallback(async (promptId, commandId) => {
     const overlayCommand = commandId ? commandRunner.getHandle(commandId, "/system") : consumeOverlayCommand("system");
@@ -133811,11 +134537,7 @@ ${guidance}`);
                   messageCount: resumeData.messageHistory.length,
                   messageHistory: resumeData.messageHistory
                 };
-                settingsManager.setLocalLastSession({ agentId, conversationId: action.conversationId }, process.cwd());
-                settingsManager.setGlobalLastSession({
-                  agentId,
-                  conversationId: action.conversationId
-                });
+                settingsManager.persistSession(agentId, action.conversationId);
                 resetContextHistory(contextTrackerRef.current);
                 resetBootstrapReminderState();
                 cmd.finish(`Switched to conversation (${resumeData.messageHistory.length} messages)`, true);
@@ -134249,7 +134971,7 @@ ${guidance}`);
         }
         if (mode === "bypassPermissions") {
           const planFilePath = activePlanPath ?? fallbackPlanPath;
-          const plansDir = join44(homedir35(), ".letta", "plans");
+          const plansDir = join45(homedir35(), ".letta", "plans");
           handlePlanKeepPlanning(`You must write your plan to a plan file before exiting plan mode.
 ` + (planFilePath ? `Plan file path: ${planFilePath}
 ` : "") + `Use a write tool to create your plan in ${plansDir}, then use ExitPlanMode to present the plan to the user.`);
@@ -134284,7 +135006,7 @@ ${guidance}`);
       if (!hasUsablePlan) {
         lastAutoHandledExitPlanToolCallIdRef.current = approval.toolCallId;
         const planFilePath = activePlanPath ?? fallbackPlanPath;
-        const plansDir = join44(homedir35(), ".letta", "plans");
+        const plansDir = join45(homedir35(), ".letta", "plans");
         handlePlanKeepPlanning(`You must write your plan to a plan file before exiting plan mode.
 ` + (planFilePath ? `Plan file path: ${planFilePath}
 ` : "") + `Use a write tool to create your plan in ${plansDir}, then use ExitPlanMode to present the plan to the user.`);
@@ -134883,6 +135605,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                   agentName,
                   currentModel: currentModelDisplay,
                   currentModelProvider,
+                  hasTemporaryModelOverride,
                   currentReasoningEffort,
                   messageQueue: queueDisplay,
                   onEnterQueueEditMode: handleEnterQueueEditMode,
@@ -135092,11 +135815,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                       if (selectorContext?.summary) {
                         hasSetConversationSummaryRef.current = true;
                       }
-                      settingsManager.setLocalLastSession({ agentId, conversationId: convId }, process.cwd());
-                      settingsManager.setGlobalLastSession({
-                        agentId,
-                        conversationId: convId
-                      });
+                      settingsManager.persistSession(agentId, convId);
                       const currentAgentName = agentState.name || "Unnamed Agent";
                       const successLines = resumeData.messageHistory.length > 0 ? [
                         `Resumed conversation with "${currentAgentName}"`,
@@ -135206,11 +135925,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                     });
                     await maybeCarryOverActiveConversationModel(conversation.id);
                     setConversationId3(conversation.id);
-                    settingsManager.setLocalLastSession({ agentId, conversationId: conversation.id }, process.cwd());
-                    settingsManager.setGlobalLastSession({
-                      agentId,
-                      conversationId: conversation.id
-                    });
+                    settingsManager.persistSession(agentId, conversation.id);
                     const currentAgentName = agentState?.name || "Unnamed Agent";
                     const shortConvId = conversation.id.slice(0, 20);
                     const successLines = [
@@ -135303,11 +136018,7 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                         searchQuery: searchContext?.query,
                         searchMessage: searchContext?.message
                       };
-                      settingsManager.setLocalLastSession({ agentId, conversationId: actualTargetConv }, process.cwd());
-                      settingsManager.setGlobalLastSession({
-                        agentId,
-                        conversationId: actualTargetConv
-                      });
+                      settingsManager.persistSession(agentId, actualTargetConv);
                       const currentAgentName = agentState.name || "Unnamed Agent";
                       const successOutput = [
                         `Switched to conversation with "${currentAgentName}"`,
@@ -135488,7 +136199,7 @@ Open /mcp to attach or detach tools for this server.`, true);
     ]
   }, resumeKey, true, undefined, this);
 }
-var import_react101, jsx_dev_runtime78, CLEAR_SCREEN_AND_HOME = "\x1B[2J\x1B[H", MIN_RESIZE_DELTA = 2, RESIZE_SETTLE_MS = 250, MIN_CLEAR_INTERVAL_MS = 750, STABLE_WIDTH_SETTLE_MS = 180, TOOL_CALL_COMMIT_DEFER_MS = 50, ANIMATION_RESUME_HYSTERESIS_ROWS = 2, EAGER_CANCEL = true, LLM_API_ERROR_MAX_RETRIES3 = 3, EMPTY_RESPONSE_MAX_RETRIES3 = 2, CONVERSATION_BUSY_MAX_RETRIES2 = 3, INTERRUPT_MESSAGE = "Interrupted – tell the agent what to do differently. Something went wrong? Use /feedback to report issues.", ERROR_FEEDBACK_HINT = "Something went wrong? Use /feedback to report issues.", OPUS_BEDROCK_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to Bedrock Opus 4.5", PROVIDER_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to another provider", INTERACTIVE_SLASH_COMMANDS, NON_STATE_COMMANDS, APPROVAL_OPTIONS_HEIGHT = 8, APPROVAL_PREVIEW_BUFFER = 4, MIN_WRAP_WIDTH = 10, TEXT_WRAP_GUTTER = 6, DIFF_WRAP_GUTTER = 12, SHELL_PREVIEW_MAX_LINES = 3, AUTO_REFLECTION_DESCRIPTION = "Reflect on recent conversations";
+var import_react101, jsx_dev_runtime78, CLEAR_SCREEN_AND_HOME = "\x1B[2J\x1B[H", MIN_RESIZE_DELTA = 2, RESIZE_SETTLE_MS = 250, MIN_CLEAR_INTERVAL_MS = 750, STABLE_WIDTH_SETTLE_MS = 180, TOOL_CALL_COMMIT_DEFER_MS = 50, ANIMATION_RESUME_HYSTERESIS_ROWS = 2, EAGER_CANCEL = true, LLM_API_ERROR_MAX_RETRIES3 = 3, EMPTY_RESPONSE_MAX_RETRIES3 = 2, TEMP_QUOTA_OVERRIDE_MODEL = "letta/auto", CONVERSATION_BUSY_MAX_RETRIES2 = 3, INTERRUPT_MESSAGE = "Interrupted – tell the agent what to do differently. Something went wrong? Use /feedback to report issues.", ERROR_FEEDBACK_HINT = "Something went wrong? Use /feedback to report issues.", OPUS_BEDROCK_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to Bedrock Opus 4.5", PROVIDER_FALLBACK_HINT = "Downstream provider issues? Use /model to switch to another provider", INTERACTIVE_SLASH_COMMANDS, NON_STATE_COMMANDS, APPROVAL_OPTIONS_HEIGHT = 8, APPROVAL_PREVIEW_BUFFER = 4, MIN_WRAP_WIDTH = 10, TEXT_WRAP_GUTTER = 6, DIFF_WRAP_GUTTER = 12, SHELL_PREVIEW_MAX_LINES = 3, AUTO_REFLECTION_DESCRIPTION = "Reflect on recent conversations";
 var init_App2 = __esm(async () => {
   init_error();
   init_check_approval();
@@ -135636,7 +136347,8 @@ var init_App2 = __esm(async () => {
     "/export",
     "/download",
     "/statusline",
-    "/reasoning-tab"
+    "/reasoning-tab",
+    "/secret"
   ]);
 });
 
@@ -135658,13 +136370,13 @@ __export(exports_terminalKeybindingInstaller2, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync35,
-  mkdirSync as mkdirSync22,
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync23,
   readFileSync as readFileSync18,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "node:fs";
 import { homedir as homedir36, platform as platform6 } from "node:os";
-import { dirname as dirname17, join as join45 } from "node:path";
+import { dirname as dirname18, join as join46 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -135696,16 +136408,16 @@ function getKeybindingsPath2(terminal) {
   }[terminal];
   const os8 = platform6();
   if (os8 === "darwin") {
-    return join45(homedir36(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join46(homedir36(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os8 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join45(appData, appName, "User", "keybindings.json");
+    return join46(appData, appName, "User", "keybindings.json");
   }
   if (os8 === "linux") {
-    return join45(homedir36(), ".config", appName, "User", "keybindings.json");
+    return join46(homedir36(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -135727,7 +136439,7 @@ function parseKeybindings2(content) {
   }
 }
 function keybindingExists2(keybindingsPath) {
-  if (!existsSync35(keybindingsPath))
+  if (!existsSync36(keybindingsPath))
     return false;
   try {
     const content = readFileSync18(keybindingsPath, { encoding: "utf-8" });
@@ -135740,7 +136452,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync35(keybindingsPath))
+  if (!existsSync36(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -135755,13 +136467,13 @@ function installKeybinding2(keybindingsPath) {
     if (keybindingExists2(keybindingsPath)) {
       return { success: true, alreadyExists: true };
     }
-    const parentDir = dirname17(keybindingsPath);
-    if (!existsSync35(parentDir)) {
-      mkdirSync22(parentDir, { recursive: true });
+    const parentDir = dirname18(keybindingsPath);
+    if (!existsSync36(parentDir)) {
+      mkdirSync23(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync35(keybindingsPath)) {
+    if (existsSync36(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
       const content = readFileSync18(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
@@ -135776,7 +136488,7 @@ function installKeybinding2(keybindingsPath) {
     keybindings.push(SHIFT_ENTER_KEYBINDING2);
     const newContent = `${JSON.stringify(keybindings, null, 2)}
 `;
-    writeFileSync17(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync18(keybindingsPath, newContent, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -135791,7 +136503,7 @@ function installKeybinding2(keybindingsPath) {
 }
 function removeKeybinding2(keybindingsPath) {
   try {
-    if (!existsSync35(keybindingsPath)) {
+    if (!existsSync36(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync18(keybindingsPath, { encoding: "utf-8" });
@@ -135805,7 +136517,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)}
 `;
-    writeFileSync17(keybindingsPath, newContent, { encoding: "utf-8" });
+    writeFileSync18(keybindingsPath, newContent, { encoding: "utf-8" });
     return { success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -135858,17 +136570,17 @@ function getWezTermConfigPath2() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join45(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync35(xdgPath))
+    const xdgPath = join46(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync36(xdgPath))
       return xdgPath;
   }
-  const configPath = join45(homedir36(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync35(configPath))
+  const configPath = join46(homedir36(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync36(configPath))
     return configPath;
-  return join45(homedir36(), ".wezterm.lua");
+  return join46(homedir36(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists2(configPath) {
-  if (!existsSync35(configPath))
+  if (!existsSync36(configPath))
     return false;
   try {
     const content = readFileSync18(configPath, { encoding: "utf-8" });
@@ -135885,7 +136597,7 @@ function installWezTermDeleteFix2() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync35(configPath)) {
+    if (existsSync36(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync2(configPath, backupPath);
       content = readFileSync18(configPath, { encoding: "utf-8" });
@@ -135914,11 +136626,11 @@ return config`);
 ${WEZTERM_DELETE_FIX2}
 `;
     }
-    const parentDir = dirname17(configPath);
-    if (!existsSync35(parentDir)) {
-      mkdirSync22(parentDir, { recursive: true });
+    const parentDir = dirname18(configPath);
+    if (!existsSync36(parentDir)) {
+      mkdirSync23(parentDir, { recursive: true });
     }
-    writeFileSync17(configPath, content, { encoding: "utf-8" });
+    writeFileSync18(configPath, content, { encoding: "utf-8" });
     return {
       success: true,
       backupPath: backupPath ?? undefined
@@ -135964,9 +136676,9 @@ __export(exports_settings2, {
   getSetting: () => getSetting2
 });
 import { homedir as homedir37 } from "node:os";
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 function getSettingsPath2() {
-  return join46(homedir37(), ".letta", "settings.json");
+  return join47(homedir37(), ".letta", "settings.json");
 }
 async function loadSettings2() {
   const settingsPath = getSettingsPath2();
@@ -136003,7 +136715,7 @@ async function getSetting2(key) {
   return settings[key];
 }
 function getProjectSettingsPath2() {
-  return join46(process.cwd(), ".letta", "settings.local.json");
+  return join47(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings2() {
   const settingsPath = getProjectSettingsPath2();
@@ -136021,7 +136733,7 @@ async function loadProjectSettings2() {
 }
 async function saveProjectSettings2(settings) {
   const settingsPath = getProjectSettingsPath2();
-  const dirPath = join46(process.cwd(), ".letta");
+  const dirPath = join47(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -136484,7 +137196,7 @@ __export(exports_import2, {
 });
 import { createReadStream as createReadStream2 } from "node:fs";
 import { chmod as chmod2, mkdir as mkdir8, readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname18, resolve as resolve31 } from "node:path";
+import { dirname as dirname19, resolve as resolve31 } from "node:path";
 async function importAgentFromFile2(options) {
   const client = await getClient2();
   const resolvedPath = resolve31(options.filePath);
@@ -136543,7 +137255,7 @@ async function writeSkillFiles2(skillDir, files) {
 }
 async function writeSkillFile2(skillDir, filePath, content) {
   const fullPath = resolve31(skillDir, filePath);
-  await mkdir8(dirname18(fullPath), { recursive: true });
+  await mkdir8(dirname19(fullPath), { recursive: true });
   await writeFile8(fullPath, content, "utf-8");
   const isScript = filePath.startsWith("scripts/") || content.trimStart().startsWith("#!");
   if (isScript) {
@@ -136596,7 +137308,7 @@ function parseRegistryHandle2(handle) {
 }
 async function importAgentFromRegistry2(options) {
   const { tmpdir: tmpdir7 } = await import("node:os");
-  const { join: join47 } = await import("node:path");
+  const { join: join48 } = await import("node:path");
   const { writeFile: writeFile9, unlink: unlink3 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle2(options.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER2}/${AGENT_REGISTRY_REPO2}/refs/heads/${AGENT_REGISTRY_BRANCH2}/agents/@${author}/${name}/${name}.af`;
@@ -136608,7 +137320,7 @@ async function importAgentFromRegistry2(options) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join47(tmpdir7(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join48(tmpdir7(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile9(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile2({
@@ -136652,23 +137364,23 @@ __export(exports_memoryFilesystem2, {
   MEMORY_FS_MEMORY_DIR: () => MEMORY_FS_MEMORY_DIR2,
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR2
 });
-import { existsSync as existsSync36, mkdirSync as mkdirSync23 } from "node:fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync24 } from "node:fs";
 import { homedir as homedir38 } from "node:os";
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 function getMemoryFilesystemRoot2(agentId, homeDir = homedir38()) {
-  return join47(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
+  return join48(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
 }
 function getMemorySystemDir2(agentId, homeDir = homedir38()) {
-  return join47(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
+  return join48(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
 }
 function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir38()) {
   const root = getMemoryFilesystemRoot2(agentId, homeDir);
   const systemDir = getMemorySystemDir2(agentId, homeDir);
-  if (!existsSync36(root)) {
-    mkdirSync23(root, { recursive: true });
+  if (!existsSync37(root)) {
+    mkdirSync24(root, { recursive: true });
   }
-  if (!existsSync36(systemDir)) {
-    mkdirSync23(systemDir, { recursive: true });
+  if (!existsSync37(systemDir)) {
+    mkdirSync24(systemDir, { recursive: true });
   }
 }
 function labelFromRelativePath2(relativePath) {
@@ -136836,6 +137548,10 @@ async function applyMemfsFlags2(agentId, memfsFlag, noMemfsFlag, options) {
       const result = await pullMemory2(agentId);
       pullSummary = result.summary;
     }
+    const { initSecretsFromServer: initSecretsFromServer2 } = await init_secretsStore().then(() => exports_secretsStore);
+    try {
+      await initSecretsFromServer2(agentId, getMemoryFilesystemRoot2(agentId));
+    } catch {}
   }
   const action = memfsFlag || shouldAutoEnableFromTag ? "enabled" : noMemfsFlag ? "disabled" : "unchanged";
   return {
@@ -140845,10 +141561,10 @@ async function runListenSubcommand(argv) {
 
 // src/cli/subcommands/memfs.ts
 await init_memoryGit();
-import { cpSync, existsSync as existsSync19, mkdirSync as mkdirSync13, rmSync as rmSync2, statSync as statSync6 } from "node:fs";
+import { cpSync, existsSync as existsSync20, mkdirSync as mkdirSync14, rmSync as rmSync2, statSync as statSync6 } from "node:fs";
 import { readdir as readdir5 } from "node:fs/promises";
 import { homedir as homedir21 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 import { parseArgs as parseArgs6 } from "node:util";
 function printUsage3() {
   console.log(`
@@ -140873,7 +141589,7 @@ Examples:
   letta memfs export --agent agent-123 --out /tmp/letta-memfs-agent-123
 `.trim());
 }
-function getAgentId3(agentFromArgs, agentIdFromArgs) {
+function getAgentId4(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
 var MEMFS_OPTIONS = {
@@ -140893,10 +141609,10 @@ function parseMemfsArgs(argv) {
   });
 }
 function getMemoryRoot(agentId) {
-  return join24(homedir21(), ".letta", "agents", agentId, "memory");
+  return join25(homedir21(), ".letta", "agents", agentId, "memory");
 }
 function getAgentRoot(agentId) {
-  return join24(homedir21(), ".letta", "agents", agentId);
+  return join25(homedir21(), ".letta", "agents", agentId);
 }
 function formatBackupTimestamp(date = new Date) {
   const pad = (value) => String(value).padStart(2, "0");
@@ -140910,7 +141626,7 @@ function formatBackupTimestamp(date = new Date) {
 }
 async function listBackups(agentId) {
   const agentRoot = getAgentRoot(agentId);
-  if (!existsSync19(agentRoot)) {
+  if (!existsSync20(agentRoot)) {
     return [];
   }
   const entries = await readdir5(agentRoot, { withFileTypes: true });
@@ -140920,7 +141636,7 @@ async function listBackups(agentId) {
       continue;
     if (!entry.name.startsWith("memory-backup-"))
       continue;
-    const path23 = join24(agentRoot, entry.name);
+    const path23 = join25(agentRoot, entry.name);
     let createdAt = null;
     try {
       const stat6 = statSync6(path23);
@@ -140937,7 +141653,7 @@ function resolveBackupPath(agentId, from) {
   if (from.startsWith("/") || /^[A-Za-z]:[/\\]/.test(from)) {
     return from;
   }
-  return join24(getAgentRoot(agentId), from);
+  return join25(getAgentRoot(agentId), from);
 }
 async function runMemfsSubcommand(argv) {
   let parsed;
@@ -140954,7 +141670,7 @@ async function runMemfsSubcommand(argv) {
     printUsage3();
     return 0;
   }
-  const agentId = getAgentId3(parsed.values.agent, parsed.values["agent-id"]);
+  const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
   if (!agentId) {
     console.error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
     return 1;
@@ -140997,14 +141713,14 @@ async function runMemfsSubcommand(argv) {
     }
     if (action === "backup") {
       const root = getMemoryRoot(agentId);
-      if (!existsSync19(root)) {
+      if (!existsSync20(root)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
       const agentRoot = getAgentRoot(agentId);
       const backupName = `memory-backup-${formatBackupTimestamp()}`;
-      const backupPath = join24(agentRoot, backupName);
-      if (existsSync19(backupPath)) {
+      const backupPath = join25(agentRoot, backupName);
+      if (existsSync20(backupPath)) {
         console.error(`Backup already exists at ${backupPath}`);
         return 1;
       }
@@ -141028,7 +141744,7 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       const backupPath = resolveBackupPath(agentId, from);
-      if (!existsSync19(backupPath)) {
+      if (!existsSync20(backupPath)) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
@@ -141050,11 +141766,11 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       const root = getMemoryRoot(agentId);
-      if (!existsSync19(root)) {
+      if (!existsSync20(root)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
-      if (existsSync19(out)) {
+      if (existsSync20(out)) {
         const stat6 = statSync6(out);
         if (stat6.isDirectory()) {
           const contents = await readdir5(out);
@@ -141067,7 +141783,7 @@ async function runMemfsSubcommand(argv) {
           return 1;
         }
       } else {
-        mkdirSync13(out, { recursive: true });
+        mkdirSync14(out, { recursive: true });
       }
       cpSync(root, out, { recursive: true });
       console.log(JSON.stringify({ exportedFrom: root, exportedTo: out, agentId }, null, 2));
@@ -141137,7 +141853,7 @@ function parseOrder(value) {
   }
   return;
 }
-function getAgentId4(agentFromArgs, agentIdFromArgs) {
+function getAgentId5(agentFromArgs, agentIdFromArgs) {
   return agentFromArgs || agentIdFromArgs || process.env.LETTA_AGENT_ID || "";
 }
 var MESSAGES_OPTIONS = {
@@ -141186,7 +141902,7 @@ async function runMessagesSubcommand(argv) {
         return 1;
       }
       const allAgents = parsed.values["all-agents"] ?? false;
-      const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
       if (!allAgents && !agentId) {
         console.error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
         return 1;
@@ -141203,7 +141919,7 @@ async function runMessagesSubcommand(argv) {
       return 0;
     }
     if (action === "list") {
-      const agentId = getAgentId4(parsed.values.agent, parsed.values["agent-id"]);
+      const agentId = getAgentId5(parsed.values.agent, parsed.values["agent-id"]);
       if (!agentId) {
         console.error("Missing agent id. Set LETTA_AGENT_ID or pass --agent/--agent-id.");
         return 1;
@@ -141281,7 +141997,7 @@ async function runSubcommand(argv) {
 init_readOnlyShell();
 init_shell_command_normalization();
 import { homedir as homedir22 } from "node:os";
-import { isAbsolute as isAbsolute16, join as join25, relative as relative12, resolve as resolve23 } from "node:path";
+import { isAbsolute as isAbsolute16, join as join26, relative as relative12, resolve as resolve23 } from "node:path";
 var MODE_KEY2 = Symbol.for("@letta/permissionMode");
 var PLAN_FILE_KEY2 = Symbol.for("@letta/planFilePath");
 var MODE_BEFORE_PLAN_KEY2 = Symbol.for("@letta/permissionModeBeforePlan");
@@ -141510,7 +142226,7 @@ class PermissionModeManager2 {
           return "allow";
         }
         if (writeTools.includes(toolName)) {
-          const plansDir = join25(homedir22(), ".letta", "plans");
+          const plansDir = join26(homedir22(), ".letta", "plans");
           const targetPath = toolArgs?.file_path || toolArgs?.path;
           let candidatePaths = [];
           if ((toolName === "ApplyPatch" || toolName === "apply_patch" || toolName === "memory_apply_patch") && toolArgs?.input) {
@@ -141561,7 +142277,7 @@ class PermissionModeManager2 {
           }
           const planWritePath = extractPlanFileWritePathFromShellCommand2(command);
           if (planWritePath) {
-            const plansDir = join25(homedir22(), ".letta", "plans");
+            const plansDir = join26(homedir22(), ".letta", "plans");
             const resolvedPath = resolvePlanTargetPath2(planWritePath, workingDirectory);
             if (resolvedPath && isPathInPlansDir2(resolvedPath, plansDir)) {
               return "allow";
@@ -141590,7 +142306,7 @@ init_fs();
 await init_secrets();
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { homedir as homedir23 } from "node:os";
-import { join as join26, resolve as resolve24 } from "node:path";
+import { join as join27, resolve as resolve24 } from "node:path";
 var DEFAULT_SETTINGS3 = {
   lastAgent: null,
   tokenStreaming: false,
@@ -141599,6 +142315,7 @@ var DEFAULT_SETTINGS3 = {
   enableSleeptime: false,
   conversationSwitchAlertEnabled: false,
   sessionContextEnabled: true,
+  autoSwapOnQuotaLimit: true,
   memoryReminderInterval: 25,
   reflectionTrigger: "step-count",
   reflectionStepCount: 25,
@@ -141958,7 +142675,7 @@ class SettingsManager2 {
       return;
     const settingsPath = this.getSettingsPath();
     const home = process.env.HOME || homedir23();
-    const dirPath = join26(home, ".letta");
+    const dirPath = join27(home, ".letta");
     try {
       if (!exists(dirPath)) {
         await mkdir(dirPath, { recursive: true });
@@ -141997,7 +142714,7 @@ class SettingsManager2 {
     if (!settings)
       return;
     const settingsPath = this.getProjectSettingsPath(workingDirectory);
-    const dirPath = join26(workingDirectory, ".letta");
+    const dirPath = join27(workingDirectory, ".letta");
     try {
       let existingSettings = {};
       if (exists(settingsPath)) {
@@ -142019,16 +142736,16 @@ class SettingsManager2 {
   }
   getSettingsPath() {
     const home = process.env.HOME || homedir23();
-    return join26(home, ".letta", "settings.json");
+    return join27(home, ".letta", "settings.json");
   }
   getProjectSettingsPath(workingDirectory) {
-    return join26(workingDirectory, ".letta", "settings.json");
+    return join27(workingDirectory, ".letta", "settings.json");
   }
   isProjectSettingsPathCollidingWithGlobal(workingDirectory) {
     return resolve24(this.getProjectSettingsPath(workingDirectory)) === resolve24(this.getSettingsPath());
   }
   getLocalProjectSettingsPath(workingDirectory) {
-    return join26(workingDirectory, ".letta", "settings.local.json");
+    return join27(workingDirectory, ".letta", "settings.local.json");
   }
   async loadLocalProjectSettings(workingDirectory = process.cwd()) {
     const cached = this.localProjectSettings.get(workingDirectory);
@@ -142089,7 +142806,7 @@ class SettingsManager2 {
     if (!settings)
       return;
     const settingsPath = this.getLocalProjectSettingsPath(workingDirectory);
-    const dirPath = join26(workingDirectory, ".letta");
+    const dirPath = join27(workingDirectory, ".letta");
     try {
       if (!exists(dirPath)) {
         await mkdir(dirPath, { recursive: true });
@@ -142199,6 +142916,11 @@ class SettingsManager2 {
     }
     return this.getGlobalLastAgentId();
   }
+  persistSession(agentId, conversationId, workingDirectory = process.cwd()) {
+    const session = { agentId, conversationId };
+    this.setLocalLastSession(session, workingDirectory);
+    this.setGlobalLastSession(session);
+  }
   getGlobalPinnedAgents() {
     const settings = this.getSettings();
     const serverKey = getCurrentServerKey2(settings);
@@ -142438,7 +143160,7 @@ class SettingsManager2 {
     this.upsertAgentSettings(agentId, { systemPromptPreset: "" });
   }
   hasLocalLettaDir(workingDirectory = process.cwd()) {
-    const dirPath = join26(workingDirectory, ".letta");
+    const dirPath = join27(workingDirectory, ".letta");
     return exists(dirPath);
   }
   storeOAuthState(state, codeVerifier, redirectUri, provider) {
@@ -142827,6 +143549,7 @@ await __promiseAll([
   init_hooks(),
   init_openai_codex_provider(),
   init_telemetry(),
+  init_secret_substitution(),
   init_toolDefinitions()
 ]);
 var FILE_MODIFYING_TOOLS2 = new Set([
@@ -143113,14 +143836,14 @@ async function clearPersistedClientToolRules2(agentId) {
 // src/utils/debug.ts
 import {
   appendFileSync as appendFileSync3,
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync14,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync15,
   readdirSync as readdirSync10,
   readFileSync as readFileSync10,
   unlinkSync as unlinkSync6
 } from "node:fs";
 import { homedir as homedir24 } from "node:os";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { format as format2 } from "node:util";
 function isDebugEnabled2() {
   const lettaDebug = process.env.LETTA_DEBUG;
@@ -143142,7 +143865,7 @@ function printDebugLine2(line, level = "log") {
   const colored = level === "warn" ? `\x1B[38;5;167m${line.trimEnd()}\x1B[0m` : `\x1B[38;5;179m${line.trimEnd()}\x1B[0m`;
   console.error(colored);
 }
-var DEBUG_LOG_DIR2 = join27(homedir24(), ".letta", "logs", "debug");
+var DEBUG_LOG_DIR2 = join28(homedir24(), ".letta", "logs", "debug");
 var MAX_SESSION_FILES3 = 5;
 var DEFAULT_TAIL_LINES2 = 50;
 
@@ -143154,8 +143877,8 @@ class DebugLogFile2 {
     const telem = process.env.LETTA_CODE_TELEM;
     if (telem === "0" || telem === "false")
       return;
-    this.agentDir = join27(DEBUG_LOG_DIR2, agentId);
-    this.logPath = join27(this.agentDir, `${sessionId}.log`);
+    this.agentDir = join28(DEBUG_LOG_DIR2, agentId);
+    this.logPath = join28(this.agentDir, `${sessionId}.log`);
     this.dirCreated = false;
     this.pruneOldSessions();
   }
@@ -143171,7 +143894,7 @@ class DebugLogFile2 {
     if (!this.logPath)
       return;
     try {
-      if (!existsSync20(this.logPath))
+      if (!existsSync21(this.logPath))
         return;
       const content = readFileSync10(this.logPath, "utf8");
       const lines = content.trimEnd().split(`
@@ -143186,8 +143909,8 @@ class DebugLogFile2 {
     if (this.dirCreated || !this.agentDir)
       return;
     try {
-      if (!existsSync20(this.agentDir)) {
-        mkdirSync14(this.agentDir, { recursive: true });
+      if (!existsSync21(this.agentDir)) {
+        mkdirSync15(this.agentDir, { recursive: true });
       }
       this.dirCreated = true;
     } catch {}
@@ -143196,14 +143919,14 @@ class DebugLogFile2 {
     if (!this.agentDir)
       return;
     try {
-      if (!existsSync20(this.agentDir))
+      if (!existsSync21(this.agentDir))
         return;
       const files = readdirSync10(this.agentDir).filter((f) => f.endsWith(".log")).sort();
       if (files.length >= MAX_SESSION_FILES3) {
         const toDelete = files.slice(0, files.length - MAX_SESSION_FILES3 + 1);
         for (const file of toDelete) {
           try {
-            unlinkSync6(join27(this.agentDir, file));
+            unlinkSync6(join28(this.agentDir, file));
           } catch {}
         }
       }
@@ -143334,12 +144057,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join48 } = await import("path");
+  const { join: join49 } = await import("path");
   const { getVersion: getVersion3 } = await Promise.resolve().then(() => (init_version2(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR3 } = await Promise.resolve().then(() => (init_skills2(), exports_skills2));
   const { exists: exists3 } = await Promise.resolve().then(() => (init_fs2(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join48(cwd2, SKILLS_DIR3);
+  const skillsDir = join49(cwd2, SKILLS_DIR3);
   const skillsExist = exists3(skillsDir);
   await settingsManager2.loadLocalProjectSettings(cwd2);
   const localPinned = settingsManager2.getLocalPinnedAgents(cwd2);
@@ -143724,9 +144447,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     } else {
       const { resolve: resolve32 } = await import("path");
-      const { existsSync: existsSync37 } = await import("fs");
+      const { existsSync: existsSync38 } = await import("fs");
       const resolvedPath = resolve32(fromAfFile);
-      if (!existsSync37(resolvedPath)) {
+      if (!existsSync38(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
       }
@@ -144050,6 +144773,13 @@ Error: ${message}`);
           process.exit(1);
         }
         if (forceNew2 || agentIdArg || fromAfFile2) {
+          if (agentIdArg && !forceNew2 && !fromAfFile2 && !forceNewConversation) {
+            await settingsManager2.loadLocalProjectSettings(process.cwd());
+            const localSession2 = settingsManager2.getLocalLastSession(process.cwd());
+            if (localSession2?.agentId === agentIdArg && localSession2.conversationId && localSession2.conversationId !== "default") {
+              setSelectedConversationId(localSession2.conversationId);
+            }
+          }
           setLoadingState("assembling");
           return;
         }
@@ -144442,11 +145172,7 @@ Error: ${message}`);
           }
         }
         if (!isSubagent) {
-          settingsManager2.setLocalLastSession({ agentId: agent.id, conversationId: conversationIdToUse }, process.cwd());
-          settingsManager2.setGlobalLastSession({
-            agentId: agent.id,
-            conversationId: conversationIdToUse
-          });
+          settingsManager2.persistSession(agent.id, conversationIdToUse);
         }
         setAgentId(agent.id);
         setAgentState(agent);
@@ -144590,4 +145316,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=7A6844DE3E1D139864756E2164756E21
+//# debugId=773D326804039A9D64756E2164756E21