@letta-ai/letta-code 0.12.0 → 0.12.2

package/letta.js

@@ -3237,7 +3237,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.12.0",
+    version: "0.12.2",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -29951,6 +29951,10 @@ var init_WelcomeScreen = __esm(async () => {
 });
 
 // src/permissions/readOnlyShell.ts
+function isReadOnlySkillScript(scriptPath) {
+  const normalized = scriptPath.replace(/\\/g, "/");
+  return BUNDLED_READ_ONLY_SCRIPTS.some((pattern) => normalized.endsWith(pattern));
+}
 function isReadOnlyShellCommand(command) {
   if (!command) {
     return false;
@@ -30018,6 +30022,13 @@ function isSafeSegment(segment) {
     if (command === "sort") {
       return !/\s-o\b/.test(segment);
     }
+    if (command === "npx" && tokens[1] === "tsx") {
+      const scriptPath = tokens[2];
+      if (scriptPath && isReadOnlySkillScript(scriptPath)) {
+        return true;
+      }
+      return false;
+    }
     return false;
   }
   return true;
@@ -30050,7 +30061,7 @@ function extractDashCArgument(tokens) {
   }
   return;
 }
-var ALWAYS_SAFE_COMMANDS, SAFE_GIT_SUBCOMMANDS, DANGEROUS_OPERATOR_PATTERN;
+var ALWAYS_SAFE_COMMANDS, SAFE_GIT_SUBCOMMANDS, BUNDLED_READ_ONLY_SCRIPTS, DANGEROUS_OPERATOR_PATTERN;
 var init_readOnlyShell = __esm(() => {
   ALWAYS_SAFE_COMMANDS = new Set([
     "cat",
@@ -30113,6 +30124,12 @@ var init_readOnlyShell = __esm(() => {
     "tag",
     "remote"
   ]);
+  BUNDLED_READ_ONLY_SCRIPTS = [
+    "/skills/searching-messages/scripts/search-messages.ts",
+    "/skills/searching-messages/scripts/get-messages.ts",
+    "/skills/builtin/searching-messages/scripts/search-messages.ts",
+    "/skills/builtin/searching-messages/scripts/get-messages.ts"
+  ];
   DANGEROUS_OPERATOR_PATTERN = /(>>|>|\$\(|`)/;
 });
 
@@ -31629,6 +31646,46 @@ Remember: You're planning, not implementing. Don't make changes, just create a r
 `;
 var init_plan = () => {};
 
+// src/agent/subagents/builtin/recall.md
+var recall_default = `---
+name: recall
+description: Search conversation history to recall past discussions, decisions, and context
+tools: Skill, Bash, Read, BashOutput
+model: haiku
+memoryBlocks: human, persona
+mode: stateless
+---
+
+You are a subagent launched via the Task tool to search conversation history. You run autonomously and return a single final report when done. You CANNOT ask questions mid-execution.
+
+## Instructions
+
+### Step 1: Load the searching-messages skill
+\`\`\`
+Skill({ command: "load", skills: ["searching-messages"] })
+\`\`\`
+
+The skill content will appear in your loaded_skills block with script paths and search strategies.
+
+### Step 2: Search the parent agent's history
+
+**CRITICAL - Two rules:**
+
+1. **DO NOT use \`conversation_search\`** - That tool only searches YOUR history (empty). You MUST use the Bash scripts from the skill.
+
+2. **ALWAYS add \`--agent-id $LETTA_PARENT_AGENT_ID\`** - This searches the parent agent's history. The only exception is \`--all-agents\` searches.
+
+Follow the strategies documented in the loaded skill.
+
+## Output Format
+
+1. **Direct answer** - What the user asked about
+2. **Key findings** - Relevant quotes or summaries from past conversations
+3. **When discussed** - Timestamps of relevant discussions
+4. **Outcome/Decision** - What was decided or concluded (if applicable)
+`;
+var init_recall = () => {};
+
 // src/agent/subagents/index.ts
 var exports_subagents = {};
 __export(exports_subagents, {
@@ -31793,7 +31850,13 @@ var init_subagents = __esm(() => {
   init_explore();
   init_general_purpose();
   init_plan();
-  BUILTIN_SOURCES = [explore_default, general_purpose_default, plan_default];
+  init_recall();
+  BUILTIN_SOURCES = [
+    explore_default,
+    general_purpose_default,
+    plan_default,
+    recall_default
+  ];
   GLOBAL_AGENTS_DIR = join3(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS = new Set(MEMORY_BLOCK_LABELS);
   cache3 = {
@@ -33424,6 +33487,82 @@ var init_shellEnv = __esm(async () => {
   await init_settings_manager();
 });
 
+// src/tools/impl/shellLaunchers.ts
+function pushUnique(list, seen, entry) {
+  if (!entry.length || !entry[0])
+    return;
+  const key = entry.join(SEP2);
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  list.push(entry);
+}
+function windowsLaunchers(command) {
+  const trimmed = command.trim();
+  if (!trimmed)
+    return [];
+  const launchers = [];
+  const seen = new Set;
+  pushUnique(launchers, seen, [
+    "powershell.exe",
+    "-NoProfile",
+    "-Command",
+    trimmed
+  ]);
+  pushUnique(launchers, seen, ["pwsh", "-NoProfile", "-Command", trimmed]);
+  const envComSpecRaw = process.env.ComSpec || process.env.COMSPEC;
+  const envComSpec = envComSpecRaw?.trim();
+  if (envComSpec) {
+    pushUnique(launchers, seen, [envComSpec, "/d", "/s", "/c", trimmed]);
+  }
+  pushUnique(launchers, seen, ["cmd.exe", "/d", "/s", "/c", trimmed]);
+  return launchers;
+}
+function unixLaunchers(command) {
+  const trimmed = command.trim();
+  if (!trimmed)
+    return [];
+  const launchers = [];
+  const seen = new Set;
+  if (process.platform === "darwin") {
+    pushUnique(launchers, seen, ["/bin/zsh", "-c", trimmed]);
+  }
+  const envShell = process.env.SHELL?.trim();
+  if (envShell) {
+    pushUnique(launchers, seen, [envShell, "-c", trimmed]);
+  }
+  const defaults2 = process.platform === "darwin" ? [
+    ["/bin/zsh", "-c", trimmed],
+    ["bash", "-c", trimmed],
+    ["/bin/bash", "-c", trimmed],
+    ["/usr/bin/bash", "-c", trimmed],
+    ["/bin/sh", "-c", trimmed],
+    ["/bin/ash", "-c", trimmed],
+    ["/usr/bin/env", "zsh", "-c", trimmed],
+    ["/usr/bin/env", "bash", "-c", trimmed],
+    ["/usr/bin/env", "sh", "-c", trimmed],
+    ["/usr/bin/env", "ash", "-c", trimmed]
+  ] : [
+    ["/bin/bash", "-c", trimmed],
+    ["/usr/bin/bash", "-c", trimmed],
+    ["/bin/zsh", "-c", trimmed],
+    ["/bin/sh", "-c", trimmed],
+    ["/bin/ash", "-c", trimmed],
+    ["/usr/bin/env", "bash", "-c", trimmed],
+    ["/usr/bin/env", "zsh", "-c", trimmed],
+    ["/usr/bin/env", "sh", "-c", trimmed],
+    ["/usr/bin/env", "ash", "-c", trimmed]
+  ];
+  for (const entry of defaults2) {
+    pushUnique(launchers, seen, entry);
+  }
+  return launchers;
+}
+function buildShellLaunchers(command) {
+  return process.platform === "win32" ? windowsLaunchers(command) : unixLaunchers(command);
+}
+var SEP2 = "\x00";
+
 // src/tools/impl/truncation.ts
 function truncateByChars(text, maxChars, _toolName = "output") {
   if (text.length <= maxChars) {
@@ -33457,35 +33596,24 @@ __export(exports_Bash, {
   bash: () => bash
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
-function getShellConfig() {
-  if (cachedShellConfig) {
-    return cachedShellConfig;
-  }
-  if (process.platform === "win32") {
-    cachedShellConfig = {
-      executable: "powershell.exe",
-      args: (cmd) => ["-NoProfile", "-Command", cmd]
-    };
-    return cachedShellConfig;
-  }
-  if (process.platform === "darwin" && existsSync4("/bin/zsh")) {
-    cachedShellConfig = {
-      executable: "/bin/zsh",
-      args: (cmd) => ["-c", cmd]
-    };
-    return cachedShellConfig;
+function getBackgroundLauncher(command) {
+  if (cachedWorkingLauncher) {
+    const [executable, ...launcherArgs] = cachedWorkingLauncher;
+    if (executable) {
+      return [executable, ...launcherArgs.slice(0, -1), command];
+    }
   }
-  cachedShellConfig = {
-    executable: "bash",
-    args: (cmd) => ["-c", cmd]
-  };
-  return cachedShellConfig;
+  const launchers = buildShellLaunchers(command);
+  return launchers[0] || [];
 }
-function spawnCommand(command, options) {
+function spawnWithLauncher(launcher, options) {
   return new Promise((resolve2, reject) => {
-    const { executable, args } = getShellConfig();
-    const childProcess = spawn(executable, args(command), {
+    const [executable, ...args] = launcher;
+    if (!executable) {
+      reject(new Error("Empty launcher"));
+      return;
+    }
+    const childProcess = spawn(executable, args, {
       cwd: options.cwd,
       env: options.env,
       shell: false,
@@ -33547,6 +33675,52 @@ function spawnCommand(command, options) {
     });
   });
 }
+async function spawnCommand(command, options) {
+  if (process.platform !== "win32") {
+    const executable = process.platform === "darwin" ? "/bin/zsh" : "bash";
+    return spawnWithLauncher([executable, "-c", command], options);
+  }
+  if (cachedWorkingLauncher) {
+    const [executable, ...launcherArgs] = cachedWorkingLauncher;
+    if (executable) {
+      const newLauncher = [executable, ...launcherArgs.slice(0, -1), command];
+      try {
+        const result = await spawnWithLauncher(newLauncher, options);
+        return result;
+      } catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT") {
+          throw error;
+        }
+        cachedWorkingLauncher = null;
+      }
+    }
+  }
+  const launchers = buildShellLaunchers(command);
+  if (launchers.length === 0) {
+    throw new Error("No shell launchers available");
+  }
+  const tried = [];
+  let lastError = null;
+  for (const launcher of launchers) {
+    try {
+      const result = await spawnWithLauncher(launcher, options);
+      cachedWorkingLauncher = launcher;
+      return result;
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        tried.push(launcher[0] || "unknown");
+        lastError = err;
+        continue;
+      }
+      throw error;
+    }
+  }
+  const suffix = tried.filter(Boolean).join(", ");
+  const reason = lastError?.message || "Shell unavailable";
+  throw new Error(suffix ? `${reason} (tried: ${suffix})` : reason);
+}
 async function bash(args) {
   validateRequiredParams(args, ["command"], "Bash");
   const {
@@ -33578,8 +33752,15 @@ async function bash(args) {
   }
   if (run_in_background) {
     const bashId = getNextBashId();
-    const { executable, args: args2 } = getShellConfig();
-    const childProcess = spawn(executable, args2(command), {
+    const launcher = getBackgroundLauncher(command);
+    const [executable, ...launcherArgs] = launcher;
+    if (!executable) {
+      return {
+        content: [{ type: "text", text: "No shell available" }],
+        status: "error"
+      };
+    }
+    const childProcess = spawn(executable, launcherArgs, {
       shell: false,
       cwd: userCwd,
       env: getShellEnv()
@@ -33692,7 +33873,7 @@ ${errorMessage}`;
     };
   }
 }
-var cachedShellConfig = null;
+var cachedWorkingLauncher = null;
 var init_Bash2 = __esm(async () => {
   init_constants();
   init_process_manager();
@@ -34017,6 +34198,20 @@ class PermissionModeManager2 {
             return "allow";
           }
         }
+        const readOnlySubagentTypes = new Set([
+          "explore",
+          "Explore",
+          "plan",
+          "Plan",
+          "recall",
+          "Recall"
+        ]);
+        if (toolName === "Task" || toolName === "task") {
+          const subagentType = toolArgs?.subagent_type;
+          if (subagentType && readOnlySubagentTypes.has(subagentType)) {
+            return "allow";
+          }
+        }
         const shellTools = [
           "Bash",
           "shell",
@@ -42096,69 +42291,6 @@ var init_SearchFileContentGemini2 = __esm(() => {
   init_Grep2();
 });
 
-// src/tools/impl/shellLaunchers.ts
-function pushUnique(list, seen, entry) {
-  if (!entry.length || !entry[0])
-    return;
-  const key = entry.join(SEP2);
-  if (seen.has(key))
-    return;
-  seen.add(key);
-  list.push(entry);
-}
-function windowsLaunchers(command) {
-  const trimmed = command.trim();
-  if (!trimmed)
-    return [];
-  const launchers = [];
-  const seen = new Set;
-  pushUnique(launchers, seen, [
-    "powershell.exe",
-    "-NoProfile",
-    "-Command",
-    trimmed
-  ]);
-  pushUnique(launchers, seen, ["pwsh", "-NoProfile", "-Command", trimmed]);
-  const envComSpecRaw = process.env.ComSpec || process.env.COMSPEC;
-  const envComSpec = envComSpecRaw?.trim();
-  if (envComSpec) {
-    pushUnique(launchers, seen, [envComSpec, "/d", "/s", "/c", trimmed]);
-  }
-  pushUnique(launchers, seen, ["cmd.exe", "/d", "/s", "/c", trimmed]);
-  return launchers;
-}
-function unixLaunchers(command) {
-  const trimmed = command.trim();
-  if (!trimmed)
-    return [];
-  const launchers = [];
-  const seen = new Set;
-  const envShell = process.env.SHELL?.trim();
-  if (envShell) {
-    pushUnique(launchers, seen, [envShell, "-lc", trimmed]);
-    pushUnique(launchers, seen, [envShell, "-c", trimmed]);
-  }
-  const defaults3 = [
-    ["/bin/bash", "-lc", trimmed],
-    ["/usr/bin/bash", "-lc", trimmed],
-    ["/bin/zsh", "-lc", trimmed],
-    ["/bin/sh", "-c", trimmed],
-    ["/bin/ash", "-c", trimmed],
-    ["/usr/bin/env", "bash", "-lc", trimmed],
-    ["/usr/bin/env", "zsh", "-lc", trimmed],
-    ["/usr/bin/env", "sh", "-c", trimmed],
-    ["/usr/bin/env", "ash", "-c", trimmed]
-  ];
-  for (const entry of defaults3) {
-    pushUnique(launchers, seen, entry);
-  }
-  return launchers;
-}
-function buildShellLaunchers(command) {
-  return process.platform === "win32" ? windowsLaunchers(command) : unixLaunchers(command);
-}
-var SEP2 = "\x00";
-
 // src/tools/impl/Shell.ts
 import { spawn as spawn2 } from "node:child_process";
 import * as path12 from "node:path";
@@ -42363,7 +42495,7 @@ __export(exports_skills, {
   SKILLS_DIR: () => SKILLS_DIR,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR
 });
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { readdir as readdir4, readFile as readFile3 } from "node:fs/promises";
 import { dirname as dirname4, join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
@@ -42381,7 +42513,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors = [];
-  if (!existsSync5(skillsPath)) {
+  if (!existsSync4(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -43281,11 +43413,16 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
   try {
     const cliArgs = buildSubagentArgs(type, config, model, userPrompt);
     const lettaCmd = process.env.LETTA_CODE_BIN || "letta";
+    let parentAgentId;
+    try {
+      parentAgentId = getCurrentAgentId();
+    } catch {}
     const proc2 = spawn3(lettaCmd, cliArgs, {
       cwd: process.cwd(),
       env: {
         ...process.env,
-        LETTA_CODE_AGENT_ROLE: "subagent"
+        LETTA_CODE_AGENT_ROLE: "subagent",
+        ...parentAgentId && { LETTA_PARENT_AGENT_ID: parentAgentId }
       }
     });
     let wasAborted = false;
@@ -44943,7 +45080,7 @@ __export(exports_skills2, {
   SKILLS_DIR: () => SKILLS_DIR2,
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { readdir as readdir5, readFile as readFile5 } from "node:fs/promises";
 import { dirname as dirname7, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
@@ -44961,7 +45098,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source) {
   const errors = [];
-  if (!existsSync6(skillsPath)) {
+  if (!existsSync5(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -45201,7 +45338,7 @@ __export(exports_fs, {
   exists: () => exists2
 });
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
   mkdirSync as mkdirSync2
@@ -45212,13 +45349,13 @@ async function readFile6(path14) {
 }
 async function writeFile2(path14, content) {
   const dir = dirname8(path14);
-  if (!existsSync7(dir)) {
+  if (!existsSync6(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   fsWriteFileSync2(path14, content, { encoding: "utf-8", flush: true });
 }
 function exists2(path14) {
-  return existsSync7(path14);
+  return existsSync6(path14);
 }
 async function mkdir2(path14, options) {
   mkdirSync2(path14, options);
@@ -45490,7 +45627,7 @@ __export(exports_subagents2, {
   GLOBAL_AGENTS_DIR: () => GLOBAL_AGENTS_DIR2,
   AGENTS_DIR: () => AGENTS_DIR2
 });
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { readdir as readdir6, readFile as readFile7 } from "node:fs/promises";
 import { join as join10 } from "node:path";
 function isValidName2(name) {
@@ -45573,7 +45710,7 @@ function getBuiltinSubagentNames2() {
   return new Set(Object.keys(getBuiltinSubagents2()));
 }
 async function discoverSubagentsFromDir2(agentsDir, seenNames, subagents, errors) {
-  if (!existsSync8(agentsDir)) {
+  if (!existsSync7(agentsDir)) {
     return;
   }
   try {
@@ -45644,7 +45781,13 @@ var init_subagents2 = __esm(() => {
   init_explore();
   init_general_purpose();
   init_plan();
-  BUILTIN_SOURCES2 = [explore_default, general_purpose_default, plan_default];
+  init_recall();
+  BUILTIN_SOURCES2 = [
+    explore_default,
+    general_purpose_default,
+    plan_default,
+    recall_default
+  ];
   GLOBAL_AGENTS_DIR2 = join10(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS2 = new Set(MEMORY_BLOCK_LABELS);
   cache4 = {
@@ -48326,7 +48469,9 @@ var init_checker = __esm(() => {
     "explore",
     "Explore",
     "plan",
-    "Plan"
+    "Plan",
+    "recall",
+    "Recall"
   ]);
 });
 
@@ -49510,7 +49655,7 @@ var init_create = __esm(async () => {
 });
 
 // src/agent/message.ts
-async function sendMessageStream(agentId, messages, opts = { streamTokens: true, background: true }) {
+async function sendMessageStream(agentId, messages, opts = { streamTokens: true, background: true }, requestOptions = { maxRetries: 0 }) {
   const client = await getClient2();
   return client.agents.messages.create(agentId, {
     messages,
@@ -49518,7 +49663,7 @@ async function sendMessageStream(agentId, messages, opts = { streamTokens: true,
     stream_tokens: opts.streamTokens ?? true,
     background: opts.background ?? true,
     client_tools: getClientToolsFromRegistry()
-  });
+  }, requestOptions);
 }
 var init_message = __esm(async () => {
   await __promiseAll([
@@ -49636,8 +49781,10 @@ function markCurrentLineAsFinished(b) {
     markAsFinished(b, b.lastOtid);
   } else {}
 }
-function markIncompleteToolsAsCancelled(b) {
-  b.interrupted = true;
+function markIncompleteToolsAsCancelled(b, setInterruptedFlag = true) {
+  if (setInterruptedFlag) {
+    b.interrupted = true;
+  }
   let anyToolsCancelled = false;
   for (const [id, line] of b.byId.entries()) {
     if (line.kind === "tool_call" && line.phase !== "finished") {
@@ -50032,6 +50179,10 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
         queueMicrotask(refresh);
         break;
       }
+      const errObj = chunk.error;
+      if (errObj?.detail?.includes("No tool call is currently awaiting approval")) {
+        continue;
+      }
       onChunk(buffers, chunk);
       queueMicrotask(refresh);
       if (chunk.message_type === "stop_reason") {
@@ -50113,7 +50264,7 @@ async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onF
       const resumeStream = await client.runs.messages.stream(result.lastRunId, {
         starting_after: result.lastSeqId,
         batch_size: 1000
-      });
+      }, { maxRetries: 0 });
       const resumeResult = await drainStream(resumeStream, buffers, refresh, abortSignal);
       result = resumeResult;
     } catch (_e) {
@@ -52088,6 +52239,89 @@ var init_available_models = __esm(async () => {
   CACHE_TTL_MS = 5 * 60 * 1000;
 });
 
+// src/ralph/mode.ts
+function getDefaultState() {
+  return {
+    isActive: false,
+    isYolo: false,
+    originalPrompt: "",
+    completionPromise: null,
+    maxIterations: 0,
+    currentIteration: 0
+  };
+}
+function getGlobalState() {
+  const global2 = globalThis;
+  if (!global2[RALPH_KEY]) {
+    global2[RALPH_KEY] = getDefaultState();
+  }
+  return global2[RALPH_KEY];
+}
+function setGlobalState(state) {
+  const global2 = globalThis;
+  global2[RALPH_KEY] = state;
+}
+
+class RalphModeManager {
+  activate(prompt, completionPromise, maxIterations, isYolo) {
+    let resolvedPromise;
+    if (completionPromise === undefined) {
+      resolvedPromise = DEFAULT_COMPLETION_PROMISE;
+    } else if (completionPromise === null || completionPromise === "" || completionPromise.toLowerCase() === "none") {
+      resolvedPromise = null;
+    } else {
+      resolvedPromise = completionPromise;
+    }
+    setGlobalState({
+      isActive: true,
+      isYolo,
+      originalPrompt: prompt,
+      completionPromise: resolvedPromise,
+      maxIterations,
+      currentIteration: 1
+    });
+  }
+  deactivate() {
+    setGlobalState(getDefaultState());
+  }
+  getState() {
+    return getGlobalState();
+  }
+  incrementIteration() {
+    const state = getGlobalState();
+    setGlobalState({
+      ...state,
+      currentIteration: state.currentIteration + 1
+    });
+  }
+  checkForPromise(text) {
+    const state = getGlobalState();
+    if (!state.completionPromise)
+      return false;
+    const match3 = text.match(/<promise>([\s\S]*?)<\/promise>/i);
+    if (!match3 || match3[1] === undefined)
+      return false;
+    const promiseText = match3[1].trim().replace(/\s+/g, " ");
+    const expected = state.completionPromise.trim().replace(/\s+/g, " ");
+    return promiseText === expected;
+  }
+  shouldContinue() {
+    const state = getGlobalState();
+    if (!state.isActive)
+      return false;
+    if (state.maxIterations > 0 && state.currentIteration >= state.maxIterations) {
+      return false;
+    }
+    return true;
+  }
+}
+var DEFAULT_COMPLETION_PROMISE, RALPH_KEY, ralphMode;
+var init_mode2 = __esm(() => {
+  DEFAULT_COMPLETION_PROMISE = "The task is complete. All requirements have been implemented and verified working. " + "Any tests that were relevant have been run and are passing. The implementation is " + "clean and production-ready. I have not taken any shortcuts or faked anything to " + "meet these requirements.";
+  RALPH_KEY = Symbol.for("@letta/ralphMode");
+  ralphMode = new RalphModeManager;
+});
+
 // src/settings.ts
 var exports_settings = {};
 __export(exports_settings, {
@@ -55419,9 +55653,9 @@ function getFileEditHeader(toolName, toolArgs) {
     const relPath = relative4(cwd2, filePath);
     const displayPath = relPath.startsWith("..") ? filePath : relPath;
     if (t === "write" || t === "write_file" || t === "writefile" || t === "write_file_gemini" || t === "writefilegemini") {
-      const { existsSync: existsSync9 } = __require("node:fs");
+      const { existsSync: existsSync8 } = __require("node:fs");
       try {
-        if (existsSync9(filePath)) {
+        if (existsSync8(filePath)) {
           return `Overwrite ${displayPath}?`;
         }
       } catch {}
@@ -56191,7 +56425,7 @@ var init_pasteRegistry = __esm(() => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync2, statSync } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync2, statSync } from "node:fs";
 import { basename as basename2, extname, isAbsolute as isAbsolute10, resolve as resolve16 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
@@ -56242,7 +56476,7 @@ function translatePasteForImages(paste) {
       if (!isAbsolute10(filePath))
         filePath = resolve16(process.cwd(), filePath);
       const ext3 = extname(filePath || "").toLowerCase();
-      if (IMAGE_EXTS.has(ext3) && existsSync9(filePath) && statSync(filePath).isFile()) {
+      if (IMAGE_EXTS.has(ext3) && existsSync8(filePath) && statSync(filePath).isFile()) {
         const buf = readFileSync2(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";
@@ -56830,7 +57064,7 @@ __export(exports_terminalKeybindingInstaller, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync10,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
   writeFileSync
@@ -56899,7 +57133,7 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync10(keybindingsPath))
+  if (!existsSync9(keybindingsPath))
     return false;
   try {
     const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
@@ -56912,7 +57146,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync10(keybindingsPath))
+  if (!existsSync9(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -56928,12 +57162,12 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname10(keybindingsPath);
-    if (!existsSync10(parentDir)) {
+    if (!existsSync9(parentDir)) {
       mkdirSync3(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync10(keybindingsPath)) {
+    if (existsSync9(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
       const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
@@ -56963,7 +57197,7 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync10(keybindingsPath)) {
+    if (!existsSync9(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync3(keybindingsPath, { encoding: "utf-8" });
@@ -57031,16 +57265,16 @@ function getWezTermConfigPath() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
     const xdgPath = join14(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync10(xdgPath))
+    if (existsSync9(xdgPath))
       return xdgPath;
   }
   const configPath = join14(homedir7(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync10(configPath))
+  if (existsSync9(configPath))
     return configPath;
   return join14(homedir7(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync10(configPath))
+  if (!existsSync9(configPath))
     return false;
   try {
     const content = readFileSync3(configPath, { encoding: "utf-8" });
@@ -57057,7 +57291,7 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync10(configPath)) {
+    if (existsSync9(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync(configPath, backupPath);
       content = readFileSync3(configPath, { encoding: "utf-8" });
@@ -57087,7 +57321,7 @@ ${WEZTERM_DELETE_FIX}
 `;
     }
     const parentDir = dirname10(configPath);
-    if (!existsSync10(parentDir)) {
+    if (!existsSync9(parentDir)) {
       mkdirSync3(parentDir, { recursive: true });
     }
     writeFileSync(configPath, content, { encoding: "utf-8" });
@@ -57393,6 +57627,20 @@ Location: ${keybindingsPath}`;
         return "Clearing credentials...";
       }
     },
+    "/ralph": {
+      desc: 'Start Ralph Wiggum loop (/ralph [prompt] [--completion-promise "X"] [--max-iterations N])',
+      order: 45,
+      handler: () => {
+        return "Activating ralph mode...";
+      }
+    },
+    "/yolo-ralph": {
+      desc: "Start Ralph loop with bypass permissions (yolo + ralph)",
+      order: 46,
+      handler: () => {
+        return "Activating yolo-ralph mode...";
+      }
+    },
     "/stream": {
       desc: "Toggle token streaming on/off",
       hidden: true,
@@ -57457,7 +57705,7 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { readdir as readdir7, readFile as readFile8 } from "node:fs/promises";
 import { basename as basename3, dirname as dirname11, join as join15 } from "node:path";
 async function getCustomCommands() {
@@ -57491,7 +57739,7 @@ async function discoverCustomCommands(projectPath = join15(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source) {
-  if (!existsSync11(dirPath)) {
+  if (!existsSync10(dirPath)) {
     return [];
   }
   const commands2 = [];
@@ -58239,9 +58487,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative4(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: existsSync12 } = __require("node:fs");
+    const { existsSync: existsSync11 } = __require("node:fs");
     try {
-      if (existsSync12(fileEdit.filePath)) {
+      if (existsSync11(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -63208,7 +63456,11 @@ function Input({
   currentModelProvider,
   messageQueue,
   onEnterQueueEditMode,
-  onEscapeCancel
+  onEscapeCancel,
+  ralphActive = false,
+  ralphPending = false,
+  ralphPendingYolo = false,
+  onRalphExit
 }) {
   const [value, setValue] = import_react54.useState("");
   const [escapePressed, setEscapePressed] = import_react54.useState(false);
@@ -63330,6 +63582,10 @@ function Input({
       console.error(`[debug:InputRich] shift=${key.shift} tab=${key.tab} visible=${visible}`);
     }
     if (key.shift && key.tab) {
+      if (ralphActive && onRalphExit) {
+        onRalphExit();
+        return;
+      }
       const modes = [
         "default",
         "acceptEdits",
@@ -63546,6 +63802,32 @@ function Input({
     setCursorPos(selectedCommand.length);
   };
   const getModeInfo = () => {
+    if (ralphPending) {
+      if (ralphPendingYolo) {
+        return {
+          name: "yolo-ralph (waiting)",
+          color: "#FF8C00"
+        };
+      }
+      return {
+        name: "ralph (waiting)",
+        color: "#FEE19C"
+      };
+    }
+    if (ralphActive) {
+      const ralph = ralphMode.getState();
+      const iterDisplay = ralph.maxIterations > 0 ? `${ralph.currentIteration}/${ralph.maxIterations}` : `${ralph.currentIteration}`;
+      if (ralph.isYolo) {
+        return {
+          name: `yolo-ralph (iter ${iterDisplay})`,
+          color: "#FF8C00"
+        };
+      }
+      return {
+        name: `ralph (iter ${iterDisplay})`,
+        color: "#FEE19C"
+      };
+    }
     switch (currentMode) {
       case "acceptEdits":
         return { name: "accept edits", color: colors.status.processing };
@@ -63710,7 +63992,9 @@ function Input({
                     dimColor: true,
                     children: [
                       " ",
-                      "(shift+tab to cycle)"
+                      "(shift+tab to ",
+                      ralphActive || ralphPending ? "exit" : "cycle",
+                      ")"
                     ]
                   }, undefined, true, undefined, this)
                 ]
@@ -63744,6 +64028,7 @@ var init_InputRich = __esm(async () => {
   init_oauth();
   init_constants();
   init_mode();
+  init_mode2();
   init_useTerminalWidth();
   init_colors();
   await __promiseAll([
@@ -70372,7 +70657,7 @@ var exports_App = {};
 __export(exports_App, {
   default: () => App2
 });
-import { existsSync as existsSync12, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
 function uid4(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -70470,7 +70755,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 }
 function planFileExists() {
   const planFilePath = permissionMode2.getPlanFilePath();
-  return !!planFilePath && existsSync12(planFilePath);
+  return !!planFilePath && existsSync11(planFilePath);
 }
 function getQuestionsFromApproval(approval) {
   const parsed = safeJsonParseOr(approval.toolArgs, {});
@@ -70484,6 +70769,71 @@ function getSkillUnloadReminder() {
   }
   return "";
 }
+function parseRalphArgs(input) {
+  let rest = input.replace(/^\/(yolo-)?ralph\s*/, "");
+  let completionPromise;
+  const promiseMatch = rest.match(/--completion-promise\s+["']([^"']*)["']/);
+  if (promiseMatch) {
+    const val = promiseMatch[1] ?? "";
+    completionPromise = val === "" || val.toLowerCase() === "none" ? null : val;
+    rest = rest.replace(/--completion-promise\s+["'][^"']*["']\s*/, "");
+  }
+  const maxMatch = rest.match(/--max-iterations\s+(\d+)/);
+  const maxIterations = maxMatch?.[1] ? parseInt(maxMatch[1], 10) : 0;
+  rest = rest.replace(/--max-iterations\s+\d+\s*/, "");
+  const prompt = rest.trim().replace(/^["']|["']$/g, "") || null;
+  return { prompt, completionPromise, maxIterations };
+}
+function buildRalphFirstTurnReminder(state) {
+  const iterInfo = state.maxIterations > 0 ? `${state.currentIteration}/${state.maxIterations}` : `${state.currentIteration}`;
+  let reminder = `<system-reminder>
+\uD83D\uDD04 Ralph Wiggum mode activated (iteration ${iterInfo})
+`;
+  if (state.completionPromise) {
+    reminder += `
+═══════════════════════════════════════════════════════════
+RALPH LOOP COMPLETION PROMISE
+═══════════════════════════════════════════════════════════
+
+To complete this loop, output this EXACT text:
+  <promise>${state.completionPromise}</promise>
+
+STRICT REQUIREMENTS (DO NOT VIOLATE):
+  ✓ Use <promise> XML tags EXACTLY as shown above
+  ✓ The statement MUST be completely and unequivocally TRUE
+  ✓ Do NOT output false statements to exit the loop
+  ✓ Do NOT lie even if you think you should exit
+
+IMPORTANT - Do not circumvent the loop:
+  Even if you believe you're stuck, the task is impossible,
+  or you've been running too long - you MUST NOT output a
+  false promise statement. The loop is designed to continue
+  until the promise is GENUINELY TRUE. Trust the process.
+
+  If the loop should stop, the promise statement will become
+  true naturally. Do not force it by lying.
+═══════════════════════════════════════════════════════════
+`;
+  } else {
+    reminder += `
+No completion promise set - loop runs until --max-iterations or ESC/Shift+Tab to exit.
+`;
+  }
+  reminder += `</system-reminder>`;
+  return reminder;
+}
+function buildRalphContinuationReminder(state) {
+  const iterInfo = state.maxIterations > 0 ? `${state.currentIteration}/${state.maxIterations}` : `${state.currentIteration}`;
+  if (state.completionPromise) {
+    return `<system-reminder>
+\uD83D\uDD04 Ralph iteration ${iterInfo} | To stop: output <promise>${state.completionPromise}</promise> (ONLY when statement is TRUE - do not lie to exit!)
+</system-reminder>`;
+  } else {
+    return `<system-reminder>
+\uD83D\uDD04 Ralph iteration ${iterInfo} | No completion promise set - loop runs infinitely
+</system-reminder>`;
+  }
+}
 function App2({
   agentId: initialAgentId,
   agentState: initialAgentState,
@@ -70528,6 +70878,7 @@ function App2({
   }, [agentId]);
   const [streaming, setStreaming, streamingRef] = useSyncedState(false);
   const processingConversationRef = import_react76.useRef(0);
+  const conversationGenerationRef = import_react76.useRef(0);
   const [interruptRequested, setInterruptRequested] = import_react76.useState(false);
   const [commandRunning, setCommandRunning, commandRunningRef] = useSyncedState(false);
   const [profileConfirmPending, setProfileConfirmPending] = import_react76.useState(null);
@@ -70540,6 +70891,8 @@ function App2({
   const [autoHandledResults, setAutoHandledResults] = import_react76.useState([]);
   const [autoDeniedApprovals, setAutoDeniedApprovals] = import_react76.useState([]);
   const bashCommandCacheRef = import_react76.useRef([]);
+  const [pendingRalphConfig, setPendingRalphConfig] = import_react76.useState(null);
+  const [uiRalphActive, setUiRalphActive] = import_react76.useState(ralphMode.getState().isActive);
   const currentApproval = pendingApprovals[approvalResults.length];
   const currentApprovalContext = approvalContexts[approvalResults.length];
   const activeApprovalId = currentApproval?.toolCallId ?? null;
@@ -70791,8 +71144,8 @@ function App2({
     if (!planFilePath)
       return;
     try {
-      const { readFileSync: readFileSync5, existsSync: existsSync13 } = __require("node:fs");
-      if (!existsSync13(planFilePath))
+      const { readFileSync: readFileSync5, existsSync: existsSync12 } = __require("node:fs");
+      if (!existsSync12(planFilePath))
         return;
       const planContent = readFileSync5(planFilePath, "utf-8");
       const previewItem = {
@@ -70915,8 +71268,70 @@ function App2({
     }
   }, [refreshDerived, currentModelId]);
   const processConversation = import_react76.useCallback(async (initialInput, options) => {
+    const handleRalphContinuation = () => {
+      const ralphState = ralphMode.getState();
+      const lines2 = toLines(buffersRef.current);
+      const assistantLines = lines2.filter((l) => l.kind === "assistant");
+      const lastAssistantText = assistantLines.length > 0 ? assistantLines[assistantLines.length - 1]?.text ?? "" : "";
+      if (ralphMode.checkForPromise(lastAssistantText)) {
+        const wasYolo = ralphState.isYolo;
+        ralphMode.deactivate();
+        setUiRalphActive(false);
+        if (wasYolo) {
+          permissionMode2.setMode("default");
+        }
+        const statusId = uid4("status");
+        buffersRef.current.byId.set(statusId, {
+          kind: "status",
+          id: statusId,
+          lines: [
+            `✅ Ralph loop complete: promise detected after ${ralphState.currentIteration} iteration(s)`
+          ]
+        });
+        buffersRef.current.order.push(statusId);
+        refreshDerived();
+        return;
+      }
+      if (!ralphMode.shouldContinue()) {
+        const wasYolo = ralphState.isYolo;
+        ralphMode.deactivate();
+        setUiRalphActive(false);
+        if (wasYolo) {
+          permissionMode2.setMode("default");
+        }
+        const statusId = uid4("status");
+        buffersRef.current.byId.set(statusId, {
+          kind: "status",
+          id: statusId,
+          lines: [
+            `\uD83D\uDED1 Ralph loop: Max iterations (${ralphState.maxIterations}) reached`
+          ]
+        });
+        buffersRef.current.order.push(statusId);
+        refreshDerived();
+        return;
+      }
+      ralphMode.incrementIteration();
+      const newState = ralphMode.getState();
+      const systemMsg = buildRalphContinuationReminder(newState);
+      setTimeout(() => {
+        processConversation([
+          {
+            type: "message",
+            role: "user",
+            content: `${systemMsg}
+
+${newState.originalPrompt}`
+          }
+        ], { allowReentry: true });
+      }, 0);
+    };
     const currentInput = [...initialInput];
     const allowReentry = options?.allowReentry ?? false;
+    const myGeneration = options?.submissionGeneration ?? conversationGenerationRef.current;
+    if (myGeneration !== conversationGenerationRef.current) {
+      return;
+    }
     if (processingConversationRef.current > 0 && !allowReentry) {
       return;
     }
@@ -70930,20 +71345,29 @@ function App2({
         userCancelledRef.current = false;
         return;
       }
+      if (myGeneration !== conversationGenerationRef.current) {
+        return;
+      }
       setStreaming(true);
       abortControllerRef.current = new AbortController;
-      markIncompleteToolsAsCancelled(buffersRef.current);
+      markIncompleteToolsAsCancelled(buffersRef.current, false);
       buffersRef.current.interrupted = false;
       clearCompletedSubagents();
       while (true) {
         const signal = abortControllerRef.current?.signal;
         if (signal?.aborted) {
-          setStreaming(false);
+          const isStaleAtAbort = myGeneration !== conversationGenerationRef.current;
+          if (!isStaleAtAbort) {
+            setStreaming(false);
+          }
           return;
         }
         const stream2 = await sendMessageStream(agentIdRef.current, currentInput);
         if (signal?.aborted) {
-          setStreaming(false);
+          const isStaleAtAbort = myGeneration !== conversationGenerationRef.current;
+          if (!isStaleAtAbort) {
+            setStreaming(false);
+          }
           return;
         }
         const syncAgentState = async () => {
@@ -70987,6 +71411,10 @@ function App2({
         const wasInterrupted = !!buffersRef.current.interrupted;
         const wasAborted = !!signal?.aborted;
         let stopReasonToHandle = wasAborted ? "cancelled" : stopReason;
+        const isStaleAfterDrain = myGeneration !== conversationGenerationRef.current;
+        if (isStaleAfterDrain) {
+          return;
+        }
         if (!wasInterrupted) {
           refreshDerived();
         }
@@ -71013,6 +71441,10 @@ function App2({
             waitingForQueueCancelRef.current = false;
             queueSnapshotRef.current = [];
           }
+          if (ralphMode.getState().isActive) {
+            handleRalphContinuation();
+            return;
+          }
           return;
         }
         if (stopReasonToHandle === "cancelled") {
@@ -71034,6 +71466,18 @@ function App2({
             if (!EAGER_CANCEL) {
               appendError(INTERRUPT_MESSAGE, true);
             }
+            if (ralphMode.getState().isActive) {
+              const statusId = uid4("status");
+              buffersRef.current.byId.set(statusId, {
+                kind: "status",
+                id: statusId,
+                lines: [
+                  `⏸️ Ralph loop paused - type to continue or shift+tab to exit`
+                ]
+              });
+              buffersRef.current.order.push(statusId);
+              refreshDerived();
+            }
           }
           return;
         }
@@ -71306,7 +71750,8 @@ function App2({
           sendDesktopNotification();
           return;
         }
-        const isApprovalPayload = currentInput.length === 1 && currentInput[0]?.type === "approval";
+        const hasApprovalInPayload = currentInput.some((item) => item?.type === "approval");
+        const isApprovalOnlyPayload = hasApprovalInPayload && currentInput.length === 1;
         let latestErrorText = null;
         for (let i = buffersRef.current.order.length - 1;i >= 0; i -= 1) {
           const id = buffersRef.current.order[i];
@@ -71321,7 +71766,7 @@ function App2({
         const detailFromRun = await fetchRunErrorDetail(lastRunId);
         const desyncDetected = isApprovalStateDesyncError(detailFromRun) || isApprovalStateDesyncError(latestErrorText);
         const lastFailureMessage = latestErrorText || detailFromRun || null;
-        if (isApprovalPayload && desyncDetected) {
+        if (hasApprovalInPayload && desyncDetected) {
           if (llmApiErrorRetriesRef.current < LLM_API_ERROR_MAX_RETRIES2) {
             llmApiErrorRetriesRef.current += 1;
             const statusId = uid4("status");
@@ -71334,7 +71779,16 @@ function App2({
             });
             buffersRef.current.order.push(statusId);
             refreshDerived();
-            currentInput.splice(0, currentInput.length, buildApprovalRecoveryMessage());
+            if (isApprovalOnlyPayload) {
+              currentInput.splice(0, currentInput.length, buildApprovalRecoveryMessage());
+            } else {
+              const messageItems = currentInput.filter((item) => item?.type !== "approval");
+              if (messageItems.length > 0) {
+                currentInput.splice(0, currentInput.length, ...messageItems);
+              } else {
+                currentInput.splice(0, currentInput.length, buildApprovalRecoveryMessage());
+              }
+            }
             buffersRef.current.byId.delete(statusId);
             buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
             refreshDerived();
@@ -71451,8 +71905,11 @@ function App2({
       sendDesktopNotification();
       refreshDerived();
     } finally {
+      const isStale = myGeneration !== conversationGenerationRef.current;
       abortControllerRef.current = null;
-      processingConversationRef.current = Math.max(0, processingConversationRef.current - 1);
+      if (!isStale) {
+        processingConversationRef.current = Math.max(0, processingConversationRef.current - 1);
+      }
     }
   }, [
     appendError,
@@ -71495,8 +71952,9 @@ function App2({
       }, 50);
       return;
     }
-    if (!streaming || interruptRequested)
+    if (!streaming || interruptRequested) {
       return;
+    }
     if (waitingForQueueCancelRef.current) {
       setRestoreQueueOnCancel(true);
     }
@@ -71509,11 +71967,22 @@ function App2({
         abortControllerRef.current = null;
       }
       userCancelledRef.current = true;
+      conversationGenerationRef.current += 1;
+      processingConversationRef.current = 0;
       setStreaming(false);
       if (!toolsCancelled) {
         appendError(INTERRUPT_MESSAGE, true);
       }
       refreshDerived();
+      if (pendingApprovals.length > 0) {
+        const denialResults = pendingApprovals.map((approval) => ({
+          type: "approval",
+          tool_call_id: approval.toolCallId,
+          approve: false,
+          reason: "User interrupted the stream"
+        }));
+        setQueuedApprovalResults(denialResults);
+      }
       setPendingApprovals([]);
       setApprovalContexts([]);
       setApprovalResults([]);
@@ -71546,7 +72015,8 @@ function App2({
     appendError,
     isExecutingTool,
     refreshDerived,
-    setStreaming
+    setStreaming,
+    pendingApprovals
   ]);
   const processConversationRef = import_react76.useRef(processConversation);
   import_react76.useEffect(() => {
@@ -71761,6 +72231,96 @@ function App2({
     }
     refreshDerived();
   }, [refreshDerived]);
+  const checkPendingApprovalsForSlashCommand = import_react76.useCallback(async () => {
+    if (!CHECK_PENDING_APPROVALS_BEFORE_SEND) {
+      return { blocked: false };
+    }
+    try {
+      const client = await getClient2();
+      const agent = await client.agents.retrieve(agentId);
+      const { pendingApprovals: existingApprovals } = await getResumeData2(client, agent);
+      if (!existingApprovals || existingApprovals.length === 0) {
+        return { blocked: false };
+      }
+      const approvalResults2 = await Promise.all(existingApprovals.map(async (approvalItem) => {
+        if (!approvalItem.toolName) {
+          return {
+            approval: approvalItem,
+            permission: {
+              decision: "deny",
+              reason: "Tool call incomplete - missing name"
+            },
+            context: null
+          };
+        }
+        const parsedArgs = safeJsonParseOr(approvalItem.toolArgs, {});
+        const permission = await checkToolPermission(approvalItem.toolName, parsedArgs);
+        const context3 = await analyzeToolApproval(approvalItem.toolName, parsedArgs);
+        return { approval: approvalItem, permission, context: context3 };
+      }));
+      const needsUserInput = [];
+      const autoAllowed = [];
+      const autoDenied = [];
+      for (const ac of approvalResults2) {
+        const { approval, permission } = ac;
+        let decision = permission.decision;
+        if (alwaysRequiresUserInput(approval.toolName) && decision === "allow") {
+          decision = "ask";
+        }
+        if (decision === "ask") {
+          needsUserInput.push(ac);
+        } else if (decision === "deny") {
+          autoDenied.push(ac);
+        } else {
+          autoAllowed.push(ac);
+        }
+      }
+      if (needsUserInput.length > 0) {
+        setPendingApprovals(needsUserInput.map((ac) => ac.approval));
+        setApprovalContexts(needsUserInput.map((ac) => ac.context).filter((ctx) => ctx !== null));
+        return { blocked: true };
+      }
+      const allResults = [];
+      if (autoAllowed.length > 0) {
+        const autoAllowedResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk));
+        allResults.push(...autoAllowedResults.map((ar) => ({
+          type: "tool",
+          tool_call_id: ar.toolCallId,
+          tool_return: ar.result.toolReturn,
+          status: ar.result.status,
+          stdout: ar.result.stdout,
+          stderr: ar.result.stderr
+        })));
+      }
+      for (const ac of autoDenied) {
+        const reason = ac.permission.reason || "Permission denied";
+        onChunk(buffersRef.current, {
+          message_type: "tool_return_message",
+          id: "dummy",
+          date: new Date().toISOString(),
+          tool_call_id: ac.approval.toolCallId,
+          tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+          status: "error",
+          stdout: null,
+          stderr: null
+        });
+        allResults.push({
+          type: "approval",
+          tool_call_id: ac.approval.toolCallId,
+          approve: false,
+          reason
+        });
+      }
+      if (allResults.length > 0) {
+        await processConversation([
+          { type: "approval", approvals: allResults }
+        ]);
+      }
+      return { blocked: false };
+    } catch {
+      return { blocked: false };
+    }
+  }, [agentId, processConversation]);
   const onSubmit = import_react76.useCallback(async (message) => {
     const msg = message?.trim() ?? "";
     if (profileConfirmPending && !msg) {
@@ -71789,6 +72349,7 @@ function App2({
     }
     if (!msg)
       return { submitted: false };
+    const submissionGeneration = conversationGenerationRef.current;
     telemetry2.trackUserInput(msg, "user", currentModelId || "unknown");
     if (pendingApprovals.length > 0) {
       return { submitted: false };
@@ -71801,6 +72362,9 @@ function App2({
         if (!isSlashCommand && streamingRef.current && !waitingForQueueCancelRef.current) {
           waitingForQueueCancelRef.current = true;
           queueSnapshotRef.current = [...newQueue];
+          if (toolAbortControllerRef.current) {
+            toolAbortControllerRef.current.abort();
+          }
           getClient2().then((client) => client.agents.messages.cancel(agentId)).then(() => {}).catch(() => {
             waitingForQueueCancelRef.current = false;
           });
@@ -71809,6 +72373,30 @@ function App2({
       });
       return { submitted: true };
     }
+    let justActivatedRalph = false;
+    if (pendingRalphConfig && !msg.startsWith("/")) {
+      const { completionPromise, maxIterations, isYolo } = pendingRalphConfig;
+      ralphMode.activate(msg, completionPromise, maxIterations, isYolo);
+      setUiRalphActive(true);
+      setPendingRalphConfig(null);
+      justActivatedRalph = true;
+      if (isYolo) {
+        permissionMode2.setMode("bypassPermissions");
+      }
+      const ralphState = ralphMode.getState();
+      const statusId = uid4("status");
+      const promiseDisplay = ralphState.completionPromise ? `"${ralphState.completionPromise.slice(0, 50)}${ralphState.completionPromise.length > 50 ? "..." : ""}"` : "(none)";
+      buffersRef.current.byId.set(statusId, {
+        kind: "status",
+        id: statusId,
+        lines: [
+          `\uD83D\uDD04 ${isYolo ? "yolo-ralph" : "ralph"} mode started (iter 1/${maxIterations || "∞"})`,
+          `Promise: ${promiseDisplay}`
+        ]
+      });
+      buffersRef.current.order.push(statusId);
+      refreshDerived();
+    }
     let aliasedMsg = msg;
     if (msg === "exit" || msg === "quit") {
       aliasedMsg = "/exit";
@@ -72029,6 +72617,59 @@ Tip: Use /clear instead to clear the current message buffer.`;
         }
         return { submitted: true };
       }
+      if (trimmed.startsWith("/yolo-ralph") || trimmed.startsWith("/ralph")) {
+        const isYolo = trimmed.startsWith("/yolo-ralph");
+        const { prompt, completionPromise, maxIterations } = parseRalphArgs(trimmed);
+        const cmdId2 = uid4("cmd");
+        if (prompt) {
+          ralphMode.activate(prompt, completionPromise, maxIterations, isYolo);
+          setUiRalphActive(true);
+          if (isYolo) {
+            permissionMode2.setMode("bypassPermissions");
+          }
+          const ralphState = ralphMode.getState();
+          const promiseDisplay = ralphState.completionPromise ? `"${ralphState.completionPromise.slice(0, 50)}${ralphState.completionPromise.length > 50 ? "..." : ""}"` : "(none)";
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: trimmed,
+            output: `\uD83D\uDD04 ${isYolo ? "yolo-ralph" : "ralph"} mode activated (iter 1/${maxIterations || "∞"})
+Promise: ${promiseDisplay}`,
+            phase: "finished",
+            success: true
+          });
+          buffersRef.current.order.push(cmdId2);
+          refreshDerived();
+          const systemMsg = buildRalphFirstTurnReminder(ralphState);
+          processConversation([
+            {
+              type: "message",
+              role: "user",
+              content: `${systemMsg}
+
+${prompt}`
+            }
+          ]);
+        } else {
+          setPendingRalphConfig({ completionPromise, maxIterations, isYolo });
+          const defaultPromisePreview = DEFAULT_COMPLETION_PROMISE.slice(0, 40);
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: trimmed,
+            output: `\uD83D\uDD04 ${isYolo ? "yolo-ralph" : "ralph"} mode ready (waiting for task)
+Max iterations: ${maxIterations || "unlimited"}
+Promise: ${completionPromise === null ? "(none)" : completionPromise ?? `"${defaultPromisePreview}..." (default)`}
+
+Type your task to begin the loop.`,
+            phase: "finished",
+            success: true
+          });
+          buffersRef.current.order.push(cmdId2);
+          refreshDerived();
+        }
+        return { submitted: true };
+      }
       if (msg.trim() === "/stream") {
         const newValue = !tokenStreamingEnabled;
         const cmdId2 = uid4("cmd");
@@ -72479,6 +73120,10 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
         return { submitted: true };
       }
       if (trimmed.startsWith("/skill")) {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         const [, ...rest] = trimmed.split(/\s+/);
         const description = rest.join(" ").trim();
@@ -72537,6 +73182,10 @@ ${SKILL_CREATOR_PROMPT3}${userDescriptionLine}
         return { submitted: true };
       }
       if (trimmed.startsWith("/remember")) {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         const [, ...rest] = trimmed.split(/\s+/);
         const userText = rest.join(" ").trim();
@@ -72593,6 +73242,10 @@ The user did not specify what to remember. Look at the recent conversation conte
         return { submitted: true };
       }
       if (trimmed === "/init") {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         buffersRef.current.byId.set(cmdId2, {
           kind: "command",
@@ -72709,6 +73362,10 @@ ${gitContext}
       const commandName = trimmed.split(/\s+/)[0]?.slice(1) || "";
       const matchedCustom = await findCustomCommand2(commandName);
       if (matchedCustom) {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         const args = trimmed.slice(`/${matchedCustom.id}`.length).trim();
         let prompt = substituteArguments2(matchedCustom.content, args);
@@ -72799,6 +73456,21 @@ ${prompt}
     }
     const contentParts = buildMessageContentFromDisplay(msg);
     const planModeReminder = getPlanModeReminder();
+    let ralphModeReminder = "";
+    if (ralphMode.getState().isActive) {
+      if (justActivatedRalph) {
+        const ralphState = ralphMode.getState();
+        ralphModeReminder = `${buildRalphFirstTurnReminder(ralphState)}
+
+`;
+      } else {
+        ralphMode.incrementIteration();
+        const ralphState = ralphMode.getState();
+        ralphModeReminder = `${buildRalphContinuationReminder(ralphState)}
+
+`;
+      }
+    }
     const skillUnloadReminder = getSkillUnloadReminder();
     let sessionContextReminder = "";
     const sessionContextEnabled = settingsManager.getSetting("sessionContextEnabled");
@@ -72830,7 +73502,7 @@ DO NOT respond to these messages or otherwise consider them in your response unl
     }
     const memoryReminderContent = await buildMemoryReminder(turnCountRef.current);
     turnCountRef.current += 1;
-    const allReminders = sessionContextReminder + planModeReminder + skillUnloadReminder + bashCommandPrefix + memoryReminderContent;
+    const allReminders = sessionContextReminder + planModeReminder + ralphModeReminder + skillUnloadReminder + bashCommandPrefix + memoryReminderContent;
     const messageContent = allReminders && typeof contentParts === "string" ? allReminders + contentParts : Array.isArray(contentParts) && allReminders ? [{ type: "text", text: allReminders }, ...contentParts] : contentParts;
     const userId = uid4("user");
     buffersRef.current.byId.set(userId, {
@@ -73108,7 +73780,7 @@ DO NOT respond to these messages or otherwise consider them in your response unl
       role: "user",
       content: messageContent
     });
-    await processConversation(initialInput);
+    await processConversation(initialInput, { submissionGeneration });
     clearPlaceholdersInText(msg);
     return { submitted: true };
   }, [
@@ -73129,7 +73801,8 @@ DO NOT respond to these messages or otherwise consider them in your response unl
     tokenStreamingEnabled,
     isAgentBusy,
     setStreaming,
-    setCommandRunning
+    setCommandRunning,
+    pendingRalphConfig
   ]);
   const onSubmitRef = import_react76.useRef(onSubmit);
   import_react76.useEffect(() => {
@@ -73230,6 +73903,8 @@ DO NOT respond to these messages or otherwise consider them in your response unl
           setQueuedApprovalResults(allResults);
         }
         setStreaming(false);
+        waitingForQueueCancelRef.current = false;
+        queueSnapshotRef.current = [];
       } else {
         await processConversation([
           {
@@ -73727,6 +74402,18 @@ Consider switching to a different system prompt using /system to match.` : null;
     }
   }, [profileConfirmPending, refreshDerived]);
   const [uiPermissionMode, setUiPermissionMode] = import_react76.useState(permissionMode2.getMode());
+  const handleRalphExit = import_react76.useCallback(() => {
+    const ralph = ralphMode.getState();
+    if (ralph.isActive) {
+      const wasYolo = ralph.isYolo;
+      ralphMode.deactivate();
+      setUiRalphActive(false);
+      if (wasYolo) {
+        permissionMode2.setMode("default");
+        setUiPermissionMode("default");
+      }
+    }
+  }, []);
   const handlePermissionModeChange = import_react76.useCallback((mode) => {
     if (mode === "plan") {
       const planPath = generatePlanFilePath();
@@ -74001,7 +74688,6 @@ Plan file path: ${planFilePath}`;
   ]);
   return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
     flexDirection: "column",
-    gap: 1,
     children: [
       /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Static, {
         items: staticItems,
@@ -74047,7 +74733,6 @@ Plan file path: ${planFilePath}`;
       }, staticRenderEpoch, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
         flexDirection: "column",
-        gap: 1,
         children: [
           loadingState !== "ready" && /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(WelcomeScreen, {
             loadingState,
@@ -74242,7 +74927,7 @@ Plan file path: ${planFilePath}`;
                 ]
               }, undefined, true, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
-                marginTop: liveItems.length > 0 ? 0 : 1,
+                marginTop: 1,
                 children: /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Input, {
                   visible: !showExitStats && pendingApprovals.length === 0 && !anySelectorOpen,
                   streaming: streaming && !abortControllerRef.current?.signal.aborted,
@@ -74261,7 +74946,11 @@ Plan file path: ${planFilePath}`;
                   currentModelProvider,
                   messageQueue,
                   onEnterQueueEditMode: handleEnterQueueEditMode,
-                  onEscapeCancel: profileConfirmPending ? handleProfileEscapeCancel : undefined
+                  onEscapeCancel: profileConfirmPending ? handleProfileEscapeCancel : undefined,
+                  ralphActive: uiRalphActive,
+                  ralphPending: pendingRalphConfig !== null,
+                  ralphPendingYolo: pendingRalphConfig?.isYolo ?? false,
+                  onRalphExit: handleRalphExit
                 }, undefined, false, undefined, this)
               }, undefined, false, undefined, this),
               activeOverlay === "model" && /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(ModelSelector, {
@@ -74426,6 +75115,7 @@ var init_App2 = __esm(async () => {
   init_context();
   init_model();
   init_mode();
+  init_mode2();
   init_settings();
   init_colors();
   init_SessionStats();
@@ -74514,7 +75204,7 @@ __export(exports_terminalKeybindingInstaller2, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync13,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync5,
   writeFileSync as writeFileSync3
@@ -74583,7 +75273,7 @@ function parseKeybindings2(content) {
   }
 }
 function keybindingExists2(keybindingsPath) {
-  if (!existsSync13(keybindingsPath))
+  if (!existsSync12(keybindingsPath))
     return false;
   try {
     const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
@@ -74596,7 +75286,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync13(keybindingsPath))
+  if (!existsSync12(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -74612,12 +75302,12 @@ function installKeybinding2(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname12(keybindingsPath);
-    if (!existsSync13(parentDir)) {
+    if (!existsSync12(parentDir)) {
       mkdirSync4(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync13(keybindingsPath)) {
+    if (existsSync12(keybindingsPath)) {
       backupPath = createBackup2(keybindingsPath);
       const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings2(content);
@@ -74647,7 +75337,7 @@ function installKeybinding2(keybindingsPath) {
 }
 function removeKeybinding2(keybindingsPath) {
   try {
-    if (!existsSync13(keybindingsPath)) {
+    if (!existsSync12(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync5(keybindingsPath, { encoding: "utf-8" });
@@ -74715,16 +75405,16 @@ function getWezTermConfigPath2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
     const xdgPath = join17(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync13(xdgPath))
+    if (existsSync12(xdgPath))
       return xdgPath;
   }
   const configPath = join17(homedir8(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync13(configPath))
+  if (existsSync12(configPath))
     return configPath;
   return join17(homedir8(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists2(configPath) {
-  if (!existsSync13(configPath))
+  if (!existsSync12(configPath))
     return false;
   try {
     const content = readFileSync5(configPath, { encoding: "utf-8" });
@@ -74741,7 +75431,7 @@ function installWezTermDeleteFix2() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync13(configPath)) {
+    if (existsSync12(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync2(configPath, backupPath);
       content = readFileSync5(configPath, { encoding: "utf-8" });
@@ -74771,7 +75461,7 @@ ${WEZTERM_DELETE_FIX2}
 `;
     }
     const parentDir = dirname12(configPath);
-    if (!existsSync13(parentDir)) {
+    if (!existsSync12(parentDir)) {
       mkdirSync4(parentDir, { recursive: true });
     }
     writeFileSync3(configPath, content, { encoding: "utf-8" });
@@ -75941,6 +76631,20 @@ class PermissionModeManager {
             return "allow";
           }
         }
+        const readOnlySubagentTypes = new Set([
+          "explore",
+          "Explore",
+          "plan",
+          "Plan",
+          "recall",
+          "Recall"
+        ]);
+        if (toolName === "Task" || toolName === "task") {
+          const subagentType = toolArgs?.subagent_type;
+          if (subagentType && readOnlySubagentTypes.has(subagentType)) {
+            return "allow";
+          }
+        }
         const shellTools = [
           "Bash",
           "shell",
@@ -77314,9 +78018,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       process.exit(1);
     }
     const { resolve: resolve19 } = await import("path");
-    const { existsSync: existsSync14 } = await import("fs");
+    const { existsSync: existsSync13 } = await import("fs");
     const resolvedPath = resolve19(fromAfFile);
-    if (!existsSync14(resolvedPath)) {
+    if (!existsSync13(resolvedPath)) {
       console.error(`Error: AgentFile not found: ${resolvedPath}`);
       process.exit(1);
     }
@@ -77556,13 +78260,19 @@ Error: ${message}`);
             try {
               await client.agents.retrieve(localProjectSettings.lastAgent);
               resumingAgentId = localProjectSettings.lastAgent;
-            } catch {}
+            } catch {
+              setLoadingState("selecting_global");
+              return;
+            }
           }
           if (!resumingAgentId && continueSession && settings.lastAgent) {
             try {
               await client.agents.retrieve(settings.lastAgent);
               resumingAgentId = settings.lastAgent;
-            } catch {}
+            } catch {
+              setLoadingState("selecting_global");
+              return;
+            }
           }
           if (!resumingAgentId && selectedGlobalAgentId) {
             try {
@@ -77617,22 +78327,22 @@ Error: ${message}`);
           agent = result.agent;
           setAgentProvenance(result.provenance);
         }
-        if (!agent) {
-          await settingsManager2.loadLocalProjectSettings();
-          const localProjectSettings = settingsManager2.getLocalProjectSettings();
-          if (localProjectSettings?.lastAgent) {
-            try {
-              agent = await client.agents.retrieve(localProjectSettings.lastAgent);
-            } catch (error) {
-              console.error(`Project agent ${localProjectSettings.lastAgent} not found (error: ${JSON.stringify(error)}), creating new one...`);
-            }
+        if (!agent && resumingAgentId) {
+          try {
+            agent = await client.agents.retrieve(resumingAgentId);
+          } catch (error) {
+            console.error(`Agent ${resumingAgentId} not found (error: ${JSON.stringify(error)})`);
+            setLoadingState("selecting_global");
+            return;
           }
         }
         if (!agent && continueSession && settings.lastAgent) {
           try {
             agent = await client.agents.retrieve(settings.lastAgent);
           } catch (error) {
-            console.error(`Previous agent ${settings.lastAgent} not found (error: ${JSON.stringify(error)}), creating new one...`);
+            console.error(`Previous agent ${settings.lastAgent} not found (error: ${JSON.stringify(error)})`);
+            setLoadingState("selecting_global");
+            return;
           }
         }
         if (!agent) {
@@ -77795,4 +78505,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=6EE8B666F8368EAC64756E2164756E21
+//# debugId=D15B3A68114566C264756E2164756E21