@letta-ai/letta-code 0.12.1 → 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.1",
+    version: "0.12.2",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -33487,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) {
@@ -33520,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,
@@ -33610,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 {
@@ -33641,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()
@@ -33755,7 +33873,7 @@ ${errorMessage}`;
     };
   }
 }
-var cachedShellConfig = null;
+var cachedWorkingLauncher = null;
 var init_Bash2 = __esm(async () => {
   init_constants();
   init_process_manager();
@@ -34080,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",
@@ -42159,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";
@@ -42426,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";
@@ -42444,7 +42513,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors = [];
-  if (!existsSync5(skillsPath)) {
+  if (!existsSync4(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -45011,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";
@@ -45029,7 +45098,7 @@ async function getBundledSkills2() {
 }
 async function discoverSkillsFromDir2(skillsPath, source) {
   const errors = [];
-  if (!existsSync6(skillsPath)) {
+  if (!existsSync5(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -45269,7 +45338,7 @@ __export(exports_fs, {
   exists: () => exists2
 });
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   readFileSync as fsReadFileSync2,
   writeFileSync as fsWriteFileSync2,
   mkdirSync as mkdirSync2
@@ -45280,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);
@@ -45558,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) {
@@ -45641,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 {
@@ -52170,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, {
@@ -55501,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 {}
@@ -56273,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;
@@ -56324,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";
@@ -56912,7 +57064,7 @@ __export(exports_terminalKeybindingInstaller, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync10,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
   writeFileSync
@@ -56981,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" });
@@ -56994,7 +57146,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync10(keybindingsPath))
+  if (!existsSync9(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -57010,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);
@@ -57045,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" });
@@ -57113,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" });
@@ -57139,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" });
@@ -57169,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" });
@@ -57475,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,
@@ -57539,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() {
@@ -57573,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 = [];
@@ -58321,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 {}
@@ -63290,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);
@@ -63412,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",
@@ -63628,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 };
@@ -63792,7 +63992,9 @@ function Input({
                     dimColor: true,
                     children: [
                       " ",
-                      "(shift+tab to cycle)"
+                      "(shift+tab to ",
+                      ralphActive || ralphPending ? "exit" : "cycle",
+                      ")"
                     ]
                   }, undefined, true, undefined, this)
                 ]
@@ -63826,6 +64028,7 @@ var init_InputRich = __esm(async () => {
   init_oauth();
   init_constants();
   init_mode();
+  init_mode2();
   init_useTerminalWidth();
   init_colors();
   await __promiseAll([
@@ -70454,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)}`;
 }
@@ -70552,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, {});
@@ -70566,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,
@@ -70623,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;
@@ -70874,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 = {
@@ -70998,6 +71268,64 @@ 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;
@@ -71113,6 +71441,10 @@ function App2({
             waitingForQueueCancelRef.current = false;
             queueSnapshotRef.current = [];
           }
+          if (ralphMode.getState().isActive) {
+            handleRalphContinuation();
+            return;
+          }
           return;
         }
         if (stopReasonToHandle === "cancelled") {
@@ -71134,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;
         }
@@ -72029,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";
@@ -72249,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");
@@ -73035,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");
@@ -73066,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, {
@@ -73365,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(() => {
@@ -73965,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();
@@ -74497,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, {
@@ -74662,6 +75115,7 @@ var init_App2 = __esm(async () => {
   init_context();
   init_model();
   init_mode();
+  init_mode2();
   init_settings();
   init_colors();
   init_SessionStats();
@@ -74750,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
@@ -74819,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" });
@@ -74832,7 +75286,7 @@ function keybindingExists2(keybindingsPath) {
   }
 }
 function createBackup2(keybindingsPath) {
-  if (!existsSync13(keybindingsPath))
+  if (!existsSync12(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -74848,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);
@@ -74883,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" });
@@ -74951,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" });
@@ -74977,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" });
@@ -75007,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" });
@@ -76177,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",
@@ -77550,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);
     }
@@ -78037,4 +78505,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=D2E37E4C34BABD1E64756E2164756E21
+//# debugId=D15B3A68114566C264756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {