tarsk 0.4.22 → 0.4.24

package/dist/index.js

@@ -188,6 +188,7 @@ async function initializeSchema(db) {
         description TEXT NOT NULL,
         status TEXT NOT NULL DEFAULT 'pending',
         assignedTo TEXT NOT NULL DEFAULT 'agent',
+        passes INTEGER NOT NULL DEFAULT 0,
         createdAt TEXT NOT NULL,
         updatedAt TEXT NOT NULL,
         FOREIGN KEY (threadId) REFERENCES threads(id) ON DELETE CASCADE
@@ -638,6 +639,25 @@ async function runMigrations(db) {
       await db.execute(`ALTER TABLE projects ADD COLUMN testPrompt TEXT`);
       await db.execute(`ALTER TABLE projects ADD COLUMN reviewPrompt TEXT`);
     }
+    const todosInfo = await db.execute(`PRAGMA table_info(todos)`);
+    const hasTodoPasses = todosInfo.rows.some(
+      (col) => col.name === "passes"
+    );
+    if (!hasTodoPasses) {
+      console.log("[db] Running migration: Adding passes column to todos");
+      await db.execute(`ALTER TABLE todos ADD COLUMN passes INTEGER NOT NULL DEFAULT 0`);
+    }
+    const hasRalphMode = convInfo.rows.some(
+      (col) => col.name === "request_ralphMode"
+    );
+    if (!hasRalphMode) {
+      console.log(
+        "[db] Running migration: Adding request_ralphMode column to conversation_history"
+      );
+      await db.execute(
+        `ALTER TABLE conversation_history ADD COLUMN request_ralphMode INTEGER NOT NULL DEFAULT 0`
+      );
+    }
     const hasValidationScript = projectsInfo.rows.some(
       (col) => col.name === "validationScript"
     );
@@ -3179,11 +3199,14 @@ init_database();
 import { randomUUID } from "crypto";
 async function fetchAllTodos(db, threadId) {
   const result = await db.execute({
-    sql: `SELECT id, threadId, description, status, assignedTo, createdAt, updatedAt
+    sql: `SELECT id, threadId, description, status, assignedTo, passes, createdAt, updatedAt
 		      FROM todos WHERE threadId = ? ORDER BY createdAt ASC`,
     args: [threadId]
   });
-  return result.rows;
+  return result.rows.map((row) => ({
+    ...row,
+    passes: row.passes === 1
+  }));
 }
 async function addTodos(threadId, descriptions, assignedTo = "agent") {
   const db = await getDatabase();
@@ -3192,8 +3215,8 @@ async function addTodos(threadId, descriptions, assignedTo = "agent") {
     const id = randomUUID();
     const ts = new Date(baseTime + i).toISOString();
     await db.execute({
-      sql: `INSERT INTO todos (id, threadId, description, status, assignedTo, createdAt, updatedAt)
-			      VALUES (?, ?, ?, 'pending', ?, ?, ?)`,
+      sql: `INSERT INTO todos (id, threadId, description, status, assignedTo, passes, createdAt, updatedAt)
+			      VALUES (?, ?, ?, 'pending', ?, 0, ?, ?)`,
       args: [id, threadId, descriptions[i].trim(), assignedTo, ts, ts]
     });
   }
@@ -3206,13 +3229,71 @@ async function clearTodos(threadId) {
     args: [threadId]
   });
 }
+async function clearTodosIfAllDone(db, threadId) {
+  const result = await db.execute({
+    sql: `SELECT status FROM todos WHERE threadId = ?`,
+    args: [threadId]
+  });
+  if (result.rows.length === 0) {
+    return false;
+  }
+  const allDone = result.rows.every(
+    (row) => row.status === "done"
+  );
+  if (!allDone) {
+    return false;
+  }
+  await db.execute({
+    sql: "DELETE FROM todos WHERE threadId = ?",
+    args: [threadId]
+  });
+  return true;
+}
+
+// src/features/ralph/ralph.progress.ts
+import { readFile as readFile3, appendFile, writeFile } from "fs/promises";
+import { join as join6 } from "path";
+var PROGRESS_FILE = "progress.txt";
+async function readProgress(threadPath) {
+  try {
+    return await readFile3(join6(threadPath, PROGRESS_FILE), "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return "";
+    }
+    throw err;
+  }
+}
+async function appendProgress(threadPath, learnings) {
+  const filePath = join6(threadPath, PROGRESS_FILE);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = `
+--- ${timestamp} ---
+${learnings}
+`;
+  try {
+    await appendFile(filePath, entry, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      await writeFile(filePath, entry, "utf-8");
+    } else {
+      throw err;
+    }
+  }
+}
 
 // src/tools/todo.ts
 var todoSchema = Type12.Object({
   action: Type12.Union(
-    [Type12.Literal("add"), Type12.Literal("update"), Type12.Literal("list"), Type12.Literal("delete")],
+    [
+      Type12.Literal("add"),
+      Type12.Literal("update"),
+      Type12.Literal("list"),
+      Type12.Literal("delete"),
+      Type12.Literal("learnings")
+    ],
     {
-      description: "Operation to perform: 'add' creates new items, 'update' changes status, 'list' returns all items, 'delete' removes items."
+      description: "Operation to perform: 'add' creates new items, 'update' changes status, 'list' returns all items, 'delete' removes items, 'learnings' appends text to progress.txt for cross-iteration memory."
     }
   ),
   descriptions: Type12.Optional(
@@ -3234,15 +3315,25 @@ var todoSchema = Type12.Object({
     Type12.String({
       description: "Who items are assigned to. Defaults to 'agent'. Applied to all specified items."
     })
+  ),
+  passes: Type12.Optional(
+    Type12.Boolean({
+      description: "Whether the story's quality checks passed. Used in Ralph mode to mark stories as verified. Set to true when checks pass after implementation."
+    })
+  ),
+  learnings: Type12.Optional(
+    Type12.String({
+      description: "Text to append to progress.txt. Required for 'learnings' action. Records patterns, gotchas, and context discovered during implementation."
+    })
   )
 });
-function createTodoTool(threadId) {
+function createTodoTool(threadId, threadPath) {
   return {
     name: "todo",
     label: "todo",
     description: "Manage todo items to break down the current task into 2 more items. Use 'add' to create items when planning work, 'update' to change an item's status as you progress (pending \u2192 working \u2192 done), 'list' to see all current items, and 'delete' to remove one. Marking an item done does not end the conversation \u2014 continue working on remaining items. Call 'list' at the end so the user sees a completion checklist.",
     parameters: todoSchema,
-    execute: async (_toolCallId, { action, descriptions, ids, status, assignedTo }) => {
+    execute: async (_toolCallId, { action, descriptions, ids, status, assignedTo, passes, learnings }) => {
       const db = await getDatabase();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       switch (action) {
@@ -3294,6 +3385,10 @@ function createTodoTool(threadId) {
               updates.push("assignedTo = ?");
               args2.push(assignedTo);
             }
+            if (passes !== void 0) {
+              updates.push("passes = ?");
+              args2.push(passes ? 1 : 0);
+            }
             updates.push("updatedAt = ?");
             args2.push(now);
             args2.push(id, threadId);
@@ -3360,6 +3455,40 @@ function createTodoTool(threadId) {
             details: void 0
           };
         }
+        case "learnings": {
+          if (!learnings?.trim()) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Error: learnings text is required for 'learnings' action"
+                }
+              ],
+              details: void 0
+            };
+          }
+          if (!threadPath) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Error: threadPath is not available, cannot write progress.txt"
+                }
+              ],
+              details: void 0
+            };
+          }
+          await appendProgress(threadPath, learnings.trim());
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Learnings appended to progress.txt successfully."
+              }
+            ],
+            details: void 0
+          };
+        }
         default:
           return {
             content: [
@@ -3377,16 +3506,16 @@ function createTodoTool(threadId) {
 var todoTool = createTodoTool("");
 
 // src/features/mcp/mcp.config.ts
-import { readFile as readFile3, stat, access } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile4, stat, access } from "fs/promises";
+import { join as join7 } from "path";
 var MCP_CONFIG_PATHS = [".agents/mcp.json", "mcp.json"];
 async function loadMCPConfig(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS) {
-    const fullPath = join6(projectPath, configPath);
+    const fullPath = join7(projectPath, configPath);
     try {
       await access(fullPath);
       const fileStats = await stat(fullPath);
-      const fileContent = await readFile3(fullPath, "utf-8");
+      const fileContent = await readFile4(fullPath, "utf-8");
       const rawConfig = JSON.parse(fileContent);
       const serversData = rawConfig.servers || rawConfig.mcpServers || {};
       const config = {
@@ -3411,7 +3540,7 @@ async function loadMCPConfig(projectPath) {
 }
 async function getMCPConfigModificationTime(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS) {
-    const fullPath = join6(projectPath, configPath);
+    const fullPath = join7(projectPath, configPath);
     try {
       await access(fullPath);
       const fileStats = await stat(fullPath);
@@ -4734,7 +4863,7 @@ async function createCodingTools(cwd, options) {
     createEditTool(cwd),
     createWriteTool(cwd),
     createAskUserTool(),
-    createTodoTool(options?.threadId ?? ""),
+    createTodoTool(options?.threadId ?? "", options?.threadPath),
     createFindTool(cwd),
     createCodeSearchTool(cwd, options?.threadId ?? ""),
     createRunWebWorkerTool()
@@ -5274,10 +5403,10 @@ function createAgentTool(options) {
 }
 
 // src/core/paths.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { homedir as homedir3 } from "os";
-var APP_SUPPORT_DIR = join7(homedir3(), "Library", "Application Support", "Tarsk");
-var DATA_DIR = join7(APP_SUPPORT_DIR, "data");
+var APP_SUPPORT_DIR = join8(homedir3(), "Library", "Application Support", "Tarsk");
+var DATA_DIR = join8(APP_SUPPORT_DIR, "data");
 function getDataDir() {
   return DATA_DIR;
 }
@@ -5288,7 +5417,7 @@ import { readFileSync as readFileSync4 } from "fs";
 
 // src/project-analyzer.ts
 import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var ProjectAnalyzer = class {
   projectPath;
   constructor(projectPath = process.cwd()) {
@@ -5299,7 +5428,7 @@ var ProjectAnalyzer = class {
     return this.generateDescription(info);
   }
   getProjectInfo() {
-    const packageJsonPath = join8(this.projectPath, "package.json");
+    const packageJsonPath = join9(this.projectPath, "package.json");
     const info = { description: "" };
     if (existsSync7(packageJsonPath)) {
       const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -5341,15 +5470,15 @@ var ProjectAnalyzer = class {
     }
   }
   detectBuildTool(_scripts = {}, deps, info) {
-    if (deps.vite || existsSync7(join8(this.projectPath, "vite.config.js")) || existsSync7(join8(this.projectPath, "vite.config.ts"))) {
+    if (deps.vite || existsSync7(join9(this.projectPath, "vite.config.js")) || existsSync7(join9(this.projectPath, "vite.config.ts"))) {
       info.buildTool = "Vite";
       return;
     }
-    if (deps.webpack || existsSync7(join8(this.projectPath, "webpack.config.js"))) {
+    if (deps.webpack || existsSync7(join9(this.projectPath, "webpack.config.js"))) {
       info.buildTool = "Webpack";
       return;
     }
-    if (deps.rollup || existsSync7(join8(this.projectPath, "rollup.config.js"))) {
+    if (deps.rollup || existsSync7(join9(this.projectPath, "rollup.config.js"))) {
       info.buildTool = "Rollup";
       return;
     }
@@ -5399,40 +5528,40 @@ var ProjectAnalyzer = class {
     info.uiLibraries = [...new Set(uiLibs)].filter(Boolean);
   }
   detectProjectType(info) {
-    if (existsSync7(join8(this.projectPath, ".xcodeproj")) || existsSync7(join8(this.projectPath, ".xcworkspace")) || existsSync7(join8(this.projectPath, "project.pbxproj"))) {
+    if (existsSync7(join9(this.projectPath, ".xcodeproj")) || existsSync7(join9(this.projectPath, ".xcworkspace")) || existsSync7(join9(this.projectPath, "project.pbxproj"))) {
       info.projectType = "Xcode";
-    } else if (existsSync7(join8(this.projectPath, "build.gradle")) || existsSync7(join8(this.projectPath, "build.gradle.kts")) || existsSync7(join8(this.projectPath, "app/build.gradle")) || existsSync7(join8(this.projectPath, "settings.gradle"))) {
+    } else if (existsSync7(join9(this.projectPath, "build.gradle")) || existsSync7(join9(this.projectPath, "build.gradle.kts")) || existsSync7(join9(this.projectPath, "app/build.gradle")) || existsSync7(join9(this.projectPath, "settings.gradle"))) {
       info.projectType = "Android Studio";
-    } else if (existsSync7(join8(this.projectPath, "pubspec.yaml"))) {
+    } else if (existsSync7(join9(this.projectPath, "pubspec.yaml"))) {
       info.projectType = "Flutter";
-    } else if (existsSync7(join8(this.projectPath, "go.mod"))) {
+    } else if (existsSync7(join9(this.projectPath, "go.mod"))) {
       info.projectType = "Go";
-    } else if (existsSync7(join8(this.projectPath, "Cargo.toml"))) {
+    } else if (existsSync7(join9(this.projectPath, "Cargo.toml"))) {
       info.projectType = "Rust";
-    } else if (existsSync7(join8(this.projectPath, "requirements.txt")) || existsSync7(join8(this.projectPath, "pyproject.toml")) || existsSync7(join8(this.projectPath, "setup.py"))) {
+    } else if (existsSync7(join9(this.projectPath, "requirements.txt")) || existsSync7(join9(this.projectPath, "pyproject.toml")) || existsSync7(join9(this.projectPath, "setup.py"))) {
       info.projectType = "Python";
-    } else if (existsSync7(join8(this.projectPath, "Gemfile"))) {
+    } else if (existsSync7(join9(this.projectPath, "Gemfile"))) {
       info.projectType = "Ruby";
-    } else if (existsSync7(join8(this.projectPath, "composer.json"))) {
+    } else if (existsSync7(join9(this.projectPath, "composer.json"))) {
       info.projectType = "PHP";
-    } else if (existsSync7(join8(this.projectPath, "pom.xml")) || existsSync7(join8(this.projectPath, "build.xml"))) {
+    } else if (existsSync7(join9(this.projectPath, "pom.xml")) || existsSync7(join9(this.projectPath, "build.xml"))) {
       info.projectType = "Java";
-    } else if (existsSync7(join8(this.projectPath, ".csproj")) || existsSync7(join8(this.projectPath, "project.json"))) {
+    } else if (existsSync7(join9(this.projectPath, ".csproj")) || existsSync7(join9(this.projectPath, "project.json"))) {
       info.projectType = ".NET";
     }
   }
   detectPackageManager(info) {
-    if (existsSync7(join8(this.projectPath, "bun.lockb"))) {
+    if (existsSync7(join9(this.projectPath, "bun.lockb"))) {
       info.packageManager = "Bun";
-    } else if (existsSync7(join8(this.projectPath, "bun.lock"))) {
+    } else if (existsSync7(join9(this.projectPath, "bun.lock"))) {
       info.packageManager = "Bun";
-    } else if (existsSync7(join8(this.projectPath, "pnpm-lock.yaml"))) {
+    } else if (existsSync7(join9(this.projectPath, "pnpm-lock.yaml"))) {
       info.packageManager = "pnpm";
-    } else if (existsSync7(join8(this.projectPath, "yarn.lock"))) {
+    } else if (existsSync7(join9(this.projectPath, "yarn.lock"))) {
       info.packageManager = "Yarn";
-    } else if (existsSync7(join8(this.projectPath, "package-lock.json"))) {
+    } else if (existsSync7(join9(this.projectPath, "package-lock.json"))) {
       info.packageManager = "npm";
-    } else if (existsSync7(join8(this.projectPath, "npm-shrinkwrap.json"))) {
+    } else if (existsSync7(join9(this.projectPath, "npm-shrinkwrap.json"))) {
       info.packageManager = "npm";
     }
   }
@@ -5494,8 +5623,8 @@ function analyzeProject(projectPath) {
 }
 
 // src/features/rules/rules.manager.ts
-import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
-import { join as join9, relative as relative4 } from "path";
+import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
+import { join as join10, relative as relative4 } from "path";
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir4 } from "os";
 function parseRuleFrontmatter(markdown) {
@@ -5539,10 +5668,10 @@ function parseRuleFrontmatter(markdown) {
   return { metadata, content };
 }
 function getGlobalRulesDir() {
-  return join9(homedir4(), ".agents", "rules");
+  return join10(homedir4(), ".agents", "rules");
 }
 function getProjectRulesDir(threadPath) {
-  return join9(threadPath, ".agents", "rules");
+  return join10(threadPath, ".agents", "rules");
 }
 var RuleManager = class {
   /**
@@ -5575,13 +5704,13 @@ var RuleManager = class {
     try {
       const entries = await readdir3(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join9(dir, entry.name);
+        const fullPath = join10(dir, entry.name);
         if (entry.isDirectory()) {
           const subRules = await this.loadRulesFromDir(fullPath, threadPath, scope);
           rules.push(...subRules);
         } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
           try {
-            const fileContent = await readFile4(fullPath, "utf-8");
+            const fileContent = await readFile5(fullPath, "utf-8");
             const { metadata, content } = parseRuleFrontmatter(fileContent);
             const ruleName = entry.name.replace(/\.(md|mdc)$/, "");
             const relativePath = relative4(threadPath, fullPath);
@@ -5741,6 +5870,43 @@ Structure your response as:
 YOU MUST use the ask_user tool to ask clarifying questions if needed and to confirm implementation of the plan.
 
 Remember: You are ONLY planning. Do NOT execute any changes.`;
+var RALPH_MODE_INSTRUCTIONS = `
+
+# Ralph Mode (ACTIVE)
+
+You are currently in RALPH MODE. This is an autonomous iterative loop that implements one story per iteration with fresh context between iterations.
+
+## How Ralph Mode Works
+- You receive a list of stories (managed via the todo tool) and implement ONE story per iteration.
+- After each iteration, your context is cleared. Memory persists via git history, progress.txt, and the todo list state.
+- The loop continues automatically until all stories pass or the iteration limit is reached.
+
+## What you MUST do each iteration:
+1. Call the todo tool with action 'list' to see all current stories and their status.
+2. Pick the highest-priority story where passes is false (earliest in the list).
+3. Implement ONLY that one story. Do not work on multiple stories.
+4. After implementation, run the project's quality checks (typecheck, tests, lint). Use the project's validation script or the check commands from the developer context (e.g. bun run check:all).
+5. If checks pass:
+   - Mark the story as done with passes=true using the todo tool: action='update', ids=[storyId], status='done', passes=true
+   - Commit your changes with a clear commit message describing the story.
+   - Use the todo tool with action='learnings' to record what you learned (patterns discovered, gotchas, useful context).
+6. If checks fail: fix the issues and re-run checks. Keep iterating until they pass.
+7. After completing the story and recording learnings, output the marker: <ralph-iteration-complete/>
+
+## What you MUST NOT do:
+- Do NOT work on more than one story per iteration.
+- Do NOT skip running quality checks.
+- Do NOT use emojis.
+
+## Story sizing:
+Each story should be small enough to implement within one context window. If a story is too large, break it down before implementing.
+
+## Progress and learnings:
+Use the todo tool's 'learnings' action to record:
+- Patterns discovered (e.g. "this codebase uses X for Y")
+- Gotchas (e.g. "do not forget to update Z when changing W")
+- Useful context for future iterations
+`;
 function loadDeveloperContext(threadPath) {
   try {
     const agentsPath = resolve(threadPath, "agents.md");
@@ -5879,7 +6045,7 @@ function formatAgentsSection(agents) {
   );
   return section;
 }
-async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents, deferredTools) {
+async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents, deferredTools, ralphMode) {
   let prompt = buildDefaultPrompt(tools);
   const agentsContent = loadDeveloperContext(threadPath);
   if (agentsContent) {
@@ -5900,6 +6066,13 @@ async function loadAgentSystemPrompt(threadPath, tools, skills, planMode, agents
   if (planMode) {
     prompt += PLAN_MODE_INSTRUCTIONS;
   }
+  if (ralphMode) {
+    prompt += RALPH_MODE_INSTRUCTIONS;
+    const progressContent = await readProgress(threadPath);
+    if (progressContent.trim()) {
+      prompt += "\n\n# Prior Learnings (from progress.txt)\n\n" + progressContent;
+    }
+  }
   const skillsSection = formatSkillsSection(skills ?? []);
   if (skillsSection) {
     prompt += skillsSection;
@@ -6008,6 +6181,7 @@ var PiExecutorImpl = class {
       const { tools, deferredToolNames } = await createCodingTools(cwd, {
         skills: context.skills,
         threadId: context.threadId,
+        threadPath: cwd,
         metadataManager: this.metadataManager
       });
       const systemPrompt = await loadAgentSystemPrompt(
@@ -6016,7 +6190,8 @@ var PiExecutorImpl = class {
         context.skills,
         context.planMode,
         context.agents,
-        deferredToolNames
+        deferredToolNames,
+        context.ralphMode
       );
       console.log(
         "[ai] System prompt loaded from thread path",
@@ -6458,8 +6633,8 @@ import { Hono as Hono2 } from "hono";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/features/skills/skills.manager.ts
-import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
-import { join as join10 } from "path";
+import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
 import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir5 } from "os";
 function parseFrontmatter(markdown) {
@@ -6507,10 +6682,10 @@ function parseFrontmatter(markdown) {
   return { metadata, content };
 }
 function getGlobalSkillsDir() {
-  return join10(homedir5(), ".agents", "skills");
+  return join11(homedir5(), ".agents", "skills");
 }
 function getProjectSkillsDir(threadPath) {
-  return join10(threadPath, ".agents", "skills");
+  return join11(threadPath, ".agents", "skills");
 }
 function validateSkillName(name) {
   if (!name || name.length === 0 || name.length > 64) {
@@ -6563,14 +6738,14 @@ var SkillManager = class {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const skillDirName = entry.name;
-        const skillPath = join10(dir, skillDirName);
-        const skillFilePath = join10(skillPath, "SKILL.md");
+        const skillPath = join11(dir, skillDirName);
+        const skillFilePath = join11(skillPath, "SKILL.md");
         if (!existsSync9(skillFilePath)) {
           console.warn(`Skipping skill directory ${skillDirName}: SKILL.md not found`);
           continue;
         }
         try {
-          const fileContent = await readFile5(skillFilePath, "utf-8");
+          const fileContent = await readFile6(skillFilePath, "utf-8");
           const { metadata, content } = parseFrontmatter(fileContent);
           if (!metadata.name) {
             console.warn(`Skipping skill in ${skillDirName}: missing 'name' in frontmatter`);
@@ -6743,8 +6918,8 @@ async function activateSkills(allSkills, taskDescription, thread, options) {
 }
 
 // src/features/agents/agents.manager.ts
-import { readdir as readdir5, readFile as readFile6 } from "fs/promises";
-import { join as join11 } from "path";
+import { readdir as readdir5, readFile as readFile7 } from "fs/promises";
+import { join as join12 } from "path";
 import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir6 } from "os";
 function parseFrontmatter2(markdown) {
@@ -6802,10 +6977,10 @@ function validateDescription2(description) {
   return !!description && description.length > 0 && description.length <= 1024;
 }
 function getGlobalAgentsDir() {
-  return join11(homedir6(), ".agents", "agents");
+  return join12(homedir6(), ".agents", "agents");
 }
 function getProjectAgentsDir(threadPath) {
-  return join11(threadPath, ".agents", "agents");
+  return join12(threadPath, ".agents", "agents");
 }
 var AgentsManager = class {
   /**
@@ -6837,14 +7012,14 @@ var AgentsManager = class {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const agentDirName = entry.name;
-        const agentPath = join11(dir, agentDirName);
-        const agentFilePath = join11(agentPath, "AGENT.md");
+        const agentPath = join12(dir, agentDirName);
+        const agentFilePath = join12(agentPath, "AGENT.md");
         if (!existsSync10(agentFilePath)) {
           console.warn(`[agents] Skipping agent directory ${agentDirName}: AGENT.md not found`);
           continue;
         }
         try {
-          const fileContent = await readFile6(agentFilePath, "utf-8");
+          const fileContent = await readFile7(agentFilePath, "utf-8");
           const { metadata, content } = parseFrontmatter2(fileContent);
           if (!metadata.name) {
             console.warn(
@@ -7024,8 +7199,8 @@ function extractAssistantContent(events, fallback) {
 
 // src/features/chat/chat-post.route.ts
 init_database();
-import { readFile as readFile7, unlink } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile8, unlink } from "fs/promises";
+import { join as join13 } from "path";
 
 // src/features/project-todos/project-todos.database.ts
 init_database();
@@ -7592,7 +7767,15 @@ function runValidationScript(script, cwd) {
 async function postChatMessage(c, threadManager, agentExecutor, conversationManager, processingStateManager) {
   try {
     const body = await c.req.json();
-    const { threadId, content, model: baseModel, provider, attachments, planMode } = body;
+    const {
+      threadId,
+      content,
+      model: baseModel,
+      provider,
+      attachments,
+      planMode,
+      ralphMode
+    } = body;
     let model = baseModel;
     if (provider && typeof provider === "string") {
       const providerPrefix = provider.toLowerCase();
@@ -7716,6 +7899,7 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
       provider,
       attachments,
       planMode,
+      ralphMode,
       skills: activatedSkills,
       agents
     };
@@ -7741,7 +7925,9 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
       content,
       model,
       attachments,
-      planMode
+      planMode,
+      void 0,
+      ralphMode
     );
     const history = await conversationManager.getConversationHistoryByConversationId(
       threadId,
@@ -7854,7 +8040,9 @@ ${result.output}`;
               validationPrompt,
               model,
               void 0,
-              planMode
+              planMode,
+              void 0,
+              ralphMode
             );
             const validationCaptured = { events: [], fullContent: "" };
             yield* executeAgent(
@@ -7890,6 +8078,82 @@ ${result.output}`;
             yield maxAttemptsEvent;
           }
         }
+        if (ralphMode) {
+          const MAX_RALPH_ITERATIONS = 10;
+          let ralphIteration = 1;
+          while (ralphIteration < MAX_RALPH_ITERATIONS) {
+            if (abortController.signal.aborted) break;
+            const db2 = await getDatabase();
+            const todos = await fetchAllTodos(db2, threadId);
+            const remaining = todos.filter((t) => !t.passes);
+            if (remaining.length === 0) {
+              const completeEvent = {
+                type: "thinking",
+                content: `[Ralph] All ${todos.length} stories completed successfully.`
+              };
+              processingStateManager.pushEvent(threadId, completeEvent);
+              yield completeEvent;
+              break;
+            }
+            ralphIteration++;
+            const iterationEvent = {
+              type: "thinking",
+              content: `[Ralph] Iteration ${ralphIteration}/${MAX_RALPH_ITERATIONS} - ${remaining.length} stories remaining. Clearing context and starting next story...`
+            };
+            processingStateManager.pushEvent(threadId, iterationEvent);
+            yield iterationEvent;
+            const newConversationId = randomUUID4();
+            await threadManager.updateThread(threadId, {
+              currentConversationId: newConversationId
+            });
+            const ralphPrompt = "Continue the Ralph loop. List all stories, pick the next incomplete one (passes=false), and implement it. Follow the Ralph mode instructions.";
+            const iterMessageId = await conversationManager.startMessage(
+              threadId,
+              threadPath,
+              newConversationId,
+              ralphPrompt,
+              model,
+              void 0,
+              void 0,
+              void 0,
+              true
+            );
+            const iterCaptured = { events: [], fullContent: "" };
+            const iterContext = { ...context, attachments: void 0 };
+            yield* executeAgent(
+              ralphPrompt,
+              iterContext,
+              abortController.signal,
+              [],
+              // Empty history - fresh context
+              iterCaptured
+            );
+            const iterContent = extractAssistantContent(
+              iterCaptured.events,
+              iterCaptured.fullContent
+            );
+            await conversationManager.completeMessage(
+              iterMessageId,
+              iterContent,
+              iterCaptured.events
+            );
+            decrementBalance().catch((err) => {
+              console.error("[ChatRoute] Failed to decrement balance:", err);
+            });
+          }
+          if (ralphIteration >= MAX_RALPH_ITERATIONS) {
+            const finalTodos = await fetchAllTodos(db, threadId);
+            const remaining = finalTodos.filter((todo) => todo.status !== "done");
+            if (remaining.length > 0) {
+              const limitEvent = {
+                type: "thinking",
+                content: `[Ralph] Reached maximum iteration limit (${MAX_RALPH_ITERATIONS}). Stopping.`
+              };
+              processingStateManager.pushEvent(threadId, limitEvent);
+              yield limitEvent;
+            }
+          }
+        }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const errorEvent = {
@@ -7923,12 +8187,15 @@ ${result.output}`;
           const db = await getDatabase();
           await invalidateGitStatusCache(db, threadId);
           await clearWorkingByThreadId(db, threadId);
+          if (!ralphMode) {
+            await clearTodosIfAllDone(db, threadId);
+          }
           try {
             const todo = await getTodoByThreadId(db, threadId);
             if (todo && todo.status === "Plan") {
-              const planFilePath = join12(threadPath, `${todo.id}-plan.md`);
+              const planFilePath = join13(threadPath, `${todo.id}-plan.md`);
               try {
-                const planContent = await readFile7(planFilePath, "utf-8");
+                const planContent = await readFile8(planFilePath, "utf-8");
                 await updateTodo(db, todo.id, { description: planContent.trim() });
                 await unlink(planFilePath);
               } catch {
@@ -8094,7 +8361,7 @@ init_database();
 
 // src/features/conversations/conversations.database.ts
 import { randomUUID as randomUUID6 } from "crypto";
-async function insertMessage(db, threadId, conversationId, message, model, attachments, planMode, imageMode) {
+async function insertMessage(db, threadId, conversationId, message, model, attachments, planMode, imageMode, ralphMode) {
   try {
     const messageId = randomUUID6();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -8102,9 +8369,9 @@ async function insertMessage(db, threadId, conversationId, message, model, attac
       `
       INSERT INTO conversation_history (
         id, threadId, conversationId, timestamp, status,
-        request_message, request_model, request_attachments, request_planMode, request_imageMode
+        request_message, request_model, request_attachments, request_planMode, request_ralphMode, request_imageMode
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
       [
         messageId,
@@ -8116,6 +8383,7 @@ async function insertMessage(db, threadId, conversationId, message, model, attac
         model,
         attachments ? JSON.stringify(attachments) : null,
         planMode ? 1 : 0,
+        ralphMode ? 1 : 0,
         imageMode ? 1 : 0
       ]
     );
@@ -8289,6 +8557,7 @@ function deserializeMessage(row) {
       model: row.request_model,
       ...row.request_attachments && { attachments: JSON.parse(row.request_attachments) },
       ...row.request_planMode === 1 && { planMode: true },
+      ...row.request_ralphMode === 1 && { ralphMode: true },
       ...row.request_imageMode === 1 && { imageMode: true }
     },
     response: row.response_content != null ? {
@@ -8368,7 +8637,7 @@ var ConversationManagerImpl = class {
   /**
    * Starts a new conversation message
    */
-  async startMessage(threadId, _threadPath, conversationId, message, model, attachments, planMode, imageMode) {
+  async startMessage(threadId, _threadPath, conversationId, message, model, attachments, planMode, imageMode, ralphMode) {
     try {
       if (!this.db) {
         await this.initialize();
@@ -8381,7 +8650,8 @@ var ConversationManagerImpl = class {
         model,
         attachments,
         planMode,
-        imageMode
+        imageMode,
+        ralphMode
       );
     } catch (error) {
       console.error("Failed to start conversation message:", error);
@@ -10662,12 +10932,12 @@ async function handleCheckRunning(c, projectManager) {
 }
 
 // src/core/run-command-detector.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join14 } from "path";
 async function detectPackageManager(projectPath) {
   try {
-    const packageJsonPath = join13(projectPath, "package.json");
-    const content = await readFile8(packageJsonPath, "utf-8");
+    const packageJsonPath = join14(projectPath, "package.json");
+    const content = await readFile9(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     if (packageJson.packageManager) {
       const pm = packageJson.packageManager.split("@")[0];
@@ -10682,8 +10952,8 @@ async function detectPackageManager(projectPath) {
 }
 async function detectRunScripts(projectPath) {
   try {
-    const packageJsonPath = join13(projectPath, "package.json");
-    const content = await readFile8(packageJsonPath, "utf-8");
+    const packageJsonPath = join14(projectPath, "package.json");
+    const content = await readFile9(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     const scripts = packageJson.scripts ?? {};
     return {
@@ -10728,8 +10998,8 @@ async function suggestRunCommand(projectPath) {
 }
 
 // src/features/projects/projects-package-scripts.route.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join15 } from "path";
 import { glob } from "glob";
 function formatScriptName(scriptName) {
   return scriptName.replace(/[-:_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
@@ -10757,8 +11027,8 @@ async function findPackageScripts(projectPath) {
     const packageManager = await detectPackageManager(projectPath);
     for (const filePath of packageJsonFiles) {
       try {
-        const fullPath = join14(projectPath, filePath);
-        const content = await readFile9(fullPath, "utf-8");
+        const fullPath = join15(projectPath, filePath);
+        const content = await readFile10(fullPath, "utf-8");
         const packageJson = JSON.parse(content);
         if (packageJson.scripts) {
           for (const [scriptName] of Object.entries(packageJson.scripts)) {
@@ -10805,8 +11075,8 @@ async function handleGetPackageScripts(c, projectManager) {
 }
 
 // src/features/projects/projects-ai-files.route.ts
-import { readdir as readdir6, readFile as readFile10, writeFile, mkdir, access as access2, rm } from "fs/promises";
-import { join as join15, extname as extname3, basename } from "path";
+import { readdir as readdir6, readFile as readFile11, writeFile as writeFile2, mkdir, access as access2, rm } from "fs/promises";
+import { join as join16, extname as extname3, basename } from "path";
 import { existsSync as existsSync11 } from "fs";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".git",
@@ -10825,8 +11095,8 @@ async function buildFullTree(dirPath, relativeDirPath) {
   try {
     const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryRelPath = join15(relativeDirPath, entry.name);
-      const entryAbsPath = join15(dirPath, entry.name);
+      const entryRelPath = join16(relativeDirPath, entry.name);
+      const entryAbsPath = join16(dirPath, entry.name);
       if (entry.isDirectory()) {
         const children = await buildFullTree(entryAbsPath, entryRelPath);
         nodes.push({
@@ -10854,8 +11124,8 @@ async function buildMarkdownFilteredTree(dirPath, relativeDirPath) {
   try {
     const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryRelPath = join15(relativeDirPath, entry.name);
-      const entryAbsPath = join15(dirPath, entry.name);
+      const entryRelPath = join16(relativeDirPath, entry.name);
+      const entryAbsPath = join16(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         const children = await buildMarkdownFilteredTree(entryAbsPath, entryRelPath);
@@ -10890,8 +11160,8 @@ async function buildAIFileTree(projectPath) {
     { key: "agents", label: "Agents" }
   ];
   for (const { key, label } of agentsFolders) {
-    const relPath = join15(".agents", key);
-    const absPath = join15(projectPath, relPath);
+    const relPath = join16(".agents", key);
+    const absPath = join16(projectPath, relPath);
     const exists = existsSync11(absPath);
     if (exists) {
       const children = await buildFullTree(absPath, relPath);
@@ -10926,7 +11196,7 @@ async function buildAIFileTree(projectPath) {
       if (entry.name === ".agents" || entry.name === "AGENTS.md" || IGNORED_DIRS.has(entry.name))
         continue;
       const entryRelPath = entry.name;
-      const entryAbsPath = join15(projectPath, entry.name);
+      const entryAbsPath = join16(projectPath, entry.name);
       if (entry.isFile() && MARKDOWN_EXTS.has(extname3(entry.name))) {
         nodes.push({
           id: entryRelPath,
@@ -10953,7 +11223,7 @@ async function buildAIFileTree(projectPath) {
 }
 function validateFilePath(projectPath, filePath) {
   if (!filePath) return null;
-  const abs = join15(projectPath, filePath);
+  const abs = join16(projectPath, filePath);
   if (!abs.startsWith(projectPath + "/") && abs !== projectPath) return null;
   return abs;
 }
@@ -11040,7 +11310,7 @@ Links to important documentation, tools, or references.
     } catch {
       return c.json({ error: { code: "NOT_FOUND", message: `File not found: ${filePath}` } }, 404);
     }
-    const content = await readFile10(absPath, "utf-8");
+    const content = await readFile11(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -11079,9 +11349,9 @@ async function handleSaveAIFile(c, projectManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join15(absPath, "..");
+    const parentDir = join16(absPath, "..");
     await mkdir(parentDir, { recursive: true });
-    await writeFile(absPath, content, "utf-8");
+    await writeFile2(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -11179,10 +11449,10 @@ async function handleCreateSkill(c, projectManager) {
     if (!project) {
       return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
     }
-    const skillRelPath = join15(".agents", "skills", name);
-    const skillAbsPath = join15(project.path, skillRelPath);
-    const skillFileRelPath = join15(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join15(skillAbsPath, "SKILL.md");
+    const skillRelPath = join16(".agents", "skills", name);
+    const skillAbsPath = join16(project.path, skillRelPath);
+    const skillFileRelPath = join16(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join16(skillAbsPath, "SKILL.md");
     if (existsSync11(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
@@ -11197,7 +11467,7 @@ description: ${description}
 
 Place your skill instructions here as markdown. This will be used when Tarsk is prompted with a request related to the description of this skill.
 `;
-    await writeFile(skillFileAbsPath, skillContent, "utf-8");
+    await writeFile2(skillFileAbsPath, skillContent, "utf-8");
     return c.json({
       success: true,
       path: skillFileRelPath,
@@ -11284,7 +11554,7 @@ function createProjectRoutes(projectManager, threadManager) {
 
 // src/features/projects/projects.manager.ts
 init_utils();
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { realpathSync as realpathSync2 } from "fs";
 import { rm as rm3 } from "fs/promises";
 
@@ -11505,14 +11775,14 @@ var ProcessManager = class extends EventEmitter {
 // src/features/projects/projects.creator.ts
 init_utils();
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, join as join17, relative as relative5 } from "path";
+import { basename as basename2, join as join18, relative as relative5 } from "path";
 import { access as access3, stat as stat3, readdir as readdir8 } from "fs/promises";
 
 // src/features/scaffold/scaffold.runner.ts
 init_utils();
 import { existsSync as existsSync12 } from "fs";
-import { join as join16 } from "path";
-import { mkdir as mkdir2, readdir as readdir7, stat as stat2, rename, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { join as join17 } from "path";
+import { mkdir as mkdir2, readdir as readdir7, stat as stat2, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline";
 
 // src/scaffold-templates.json
@@ -12233,9 +12503,9 @@ function loadCatalog() {
 }
 async function writeAgentsMd(projectPath, agentsMd) {
   if (!agentsMd) return;
-  const agentsPath = join16(projectPath, "AGENTS.md");
+  const agentsPath = join17(projectPath, "AGENTS.md");
   if (existsSync12(agentsPath)) return;
-  await writeFile2(agentsPath, agentsMd, "utf-8");
+  await writeFile3(agentsPath, agentsMd, "utf-8");
 }
 function getProjectName(name) {
   return name.toLowerCase().replace(/\s/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-(\d)/g, "-a$1");
@@ -12391,7 +12661,7 @@ async function* runCommandStreaming(cwd, command) {
   }
 }
 async function* createScaffoldedProjectStreaming(options) {
-  const projectPath = join16(options.parentDir, options.threadId);
+  const projectPath = join17(options.parentDir, options.threadId);
   if (!existsSync12(options.parentDir)) {
     yield {
       type: "result",
@@ -12481,7 +12751,7 @@ async function* createScaffoldedProjectStreaming(options) {
   }
   try {
     const projectName2 = getProjectName(options.projectName);
-    const projectSubDir = join16(projectPath, projectName2);
+    const projectSubDir = join17(projectPath, projectName2);
     try {
       const subDirStat = await stat2(projectSubDir);
       if (subDirStat.isDirectory()) {
@@ -12491,8 +12761,8 @@ async function* createScaffoldedProjectStreaming(options) {
         };
         const items = await readdir7(projectSubDir);
         for (const item of items) {
-          const oldPath = join16(projectSubDir, item);
-          const newPath = join16(projectPath, item);
+          const oldPath = join17(projectSubDir, item);
+          const newPath = join17(projectPath, item);
           await rename(oldPath, newPath);
         }
         await rm2(projectSubDir, { recursive: true, force: true });
@@ -12960,7 +13230,7 @@ var ProjectCreator = class {
     return name;
   }
   generateThreadPath(_projectId, threadId) {
-    return join17(this.rootFolder, threadId);
+    return join18(this.rootFolder, threadId);
   }
   async *createProjectFromFolder() {
     await loadUtils();
@@ -13110,19 +13380,19 @@ var ProjectCreator = class {
   }
   async findAllPackageJsonFiles(rootPath, currentPath, setupScripts) {
     try {
-      await access3(join17(currentPath, "package.json"));
+      await access3(join18(currentPath, "package.json"));
       const relativePath = relative5(rootPath, currentPath);
       let installCommand = "";
       try {
-        await access3(join17(currentPath, "yarn.lock"));
+        await access3(join18(currentPath, "yarn.lock"));
         installCommand = "yarn install";
       } catch {
         try {
-          await access3(join17(currentPath, "bun.lock"));
+          await access3(join18(currentPath, "bun.lock"));
           installCommand = "bun install";
         } catch {
           try {
-            await access3(join17(currentPath, "pnpm-lock.yaml"));
+            await access3(join18(currentPath, "pnpm-lock.yaml"));
             installCommand = "pnpm install";
           } catch {
             installCommand = "npm install";
@@ -13139,7 +13409,7 @@ var ProjectCreator = class {
     try {
       const entries = await readdir8(currentPath);
       for (const entry of entries) {
-        const entryPath = join17(currentPath, entry);
+        const entryPath = join18(currentPath, entry);
         try {
           const stats = await stat3(entryPath);
           if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
@@ -13476,7 +13746,7 @@ var ProjectManagerImpl = class {
     const session = this.terminalSessionManager.getOrCreateSession(threadId, thread.path);
     let workingDir;
     if (cwd) {
-      workingDir = cwd.startsWith("/") ? cwd : join18(thread.path, cwd);
+      workingDir = cwd.startsWith("/") ? cwd : join19(thread.path, cwd);
       this.terminalSessionManager.updateWorkingDirectory(threadId, workingDir);
     } else {
       workingDir = session.currentWorkingDirectory;
@@ -13681,9 +13951,9 @@ import { Hono as Hono7 } from "hono";
 
 // src/core/env-manager.ts
 import { promises as fs } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 async function updateEnvFile(keyNames) {
-  const envPath = join19(process.cwd(), ".env");
+  const envPath = join20(process.cwd(), ".env");
   let content = "";
   try {
     content = await fs.readFile(envPath, "utf-8");
@@ -13712,7 +13982,7 @@ async function updateEnvFile(keyNames) {
   await fs.writeFile(envPath, newLines.join("\n") + "\n", "utf-8");
 }
 async function readEnvFile() {
-  const envPath = join19(process.cwd(), ".env");
+  const envPath = join20(process.cwd(), ".env");
   const envMap = {};
   try {
     const content = await fs.readFile(envPath, "utf-8");
@@ -14182,8 +14452,8 @@ function createScaffoldRoutes(projectManager) {
 }
 
 // src/features/slash-commands/slash-commands.manager.ts
-import { readdir as readdir9, readFile as readFile11, mkdir as mkdir3, writeFile as writeFile3, unlink as unlink2 } from "fs/promises";
-import { join as join20, basename as basename3, extname as extname4 } from "path";
+import { readdir as readdir9, readFile as readFile12, mkdir as mkdir3, writeFile as writeFile4, unlink as unlink2 } from "fs/promises";
+import { join as join21, basename as basename3, extname as extname4 } from "path";
 import { existsSync as existsSync13 } from "fs";
 import { homedir as homedir7 } from "os";
 function slugify(filename) {
@@ -14229,16 +14499,32 @@ function parseFrontmatter3(markdown) {
   return { metadata, content };
 }
 function getGlobalCommandsDir() {
-  return join20(homedir7(), ".agents", "commands");
+  return join21(homedir7(), ".agents", "commands");
 }
 function getProjectCommandsDir(threadPath) {
-  return join20(threadPath, ".agents", "commands");
+  return join21(threadPath, ".agents", "commands");
 }
 var SlashCommandManager = class _SlashCommandManager {
   /**
    * Built-in commands that cannot be overridden
    */
-  static BUILT_IN_COMMANDS = /* @__PURE__ */ new Set(["init"]);
+  static BUILT_IN_COMMANDS = /* @__PURE__ */ new Set(["init", "ralph"]);
+  /**
+   * Built-in command definitions injected programmatically
+   */
+  static BUILT_IN_COMMAND_DEFS = [
+    {
+      name: "ralph",
+      content: "Start the Ralph autonomous loop. Add your stories as todo items, then Ralph will implement them one by one with fresh context between iterations. Each story should be small enough to complete in one iteration.",
+      metadata: {
+        description: "Start the Ralph autonomous implementation loop",
+        mode: "ralph"
+      },
+      scope: "global",
+      filePath: "(built-in)",
+      isBuiltIn: true
+    }
+  ];
   /**
    * Load all available commands for a given thread
    * Project commands override global ones with the same name
@@ -14262,6 +14548,11 @@ var SlashCommandManager = class _SlashCommandManager {
         }
       }
     }
+    for (const builtIn of _SlashCommandManager.BUILT_IN_COMMAND_DEFS) {
+      if (!commands.has(builtIn.name)) {
+        commands.set(builtIn.name, builtIn);
+      }
+    }
     return Array.from(commands.values());
   }
   /**
@@ -14273,8 +14564,8 @@ var SlashCommandManager = class _SlashCommandManager {
       const files = await readdir9(dir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = join20(dir, file);
-        const fileContent = await readFile11(filePath, "utf-8");
+        const filePath = join21(dir, file);
+        const fileContent = await readFile12(filePath, "utf-8");
         const { metadata, content } = parseFrontmatter3(fileContent);
         const nameWithoutExt = basename3(file, extname4(file));
         const commandName = slugify(nameWithoutExt);
@@ -14308,7 +14599,7 @@ var SlashCommandManager = class _SlashCommandManager {
       await mkdir3(dir, { recursive: true });
     }
     const filename = `${name}.md`;
-    const filePath = join20(dir, filename);
+    const filePath = join21(dir, filename);
     if (existsSync13(filePath)) {
       throw new Error(`Command already exists: ${name}`);
     }
@@ -14330,7 +14621,7 @@ var SlashCommandManager = class _SlashCommandManager {
       markdown += "---\n\n";
     }
     markdown += content;
-    await writeFile3(filePath, markdown, "utf-8");
+    await writeFile4(filePath, markdown, "utf-8");
     return {
       name,
       content,
@@ -14364,7 +14655,7 @@ var SlashCommandManager = class _SlashCommandManager {
       markdown += "---\n\n";
     }
     markdown += content;
-    await writeFile3(filePath, markdown, "utf-8");
+    await writeFile4(filePath, markdown, "utf-8");
   }
   /**
    * Delete a command
@@ -14903,7 +15194,7 @@ function createRuleRoutes(router, projectManager) {
 // src/features/threads/threads.manager.ts
 init_utils();
 import { randomUUID as randomUUID8 } from "crypto";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { execSync as execSync3 } from "child_process";
 import { rm as rm4, stat as stat4, mkdir as mkdir4 } from "fs/promises";
 init_database();
@@ -15307,7 +15598,7 @@ var ThreadManagerImpl = class {
    * - 7.4 - THE CLI SHALL ensure each Thread clone is stored in a unique directory path
    */
   generateThreadPath(_projectId, threadId) {
-    return join21(this.rootFolder, threadId);
+    return join22(this.rootFolder, threadId);
   }
   /**
    * Generates a thread title if not provided
@@ -15500,9 +15791,9 @@ async function handleDeleteThread(c, threadManager) {
 }
 
 // src/core/project-inspector.ts
-import { readFile as readFile12, readdir as readdir10 } from "fs/promises";
+import { readFile as readFile13, readdir as readdir10 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
-import { join as join22, basename as basename4, relative as relative6 } from "path";
+import { join as join23, basename as basename4, relative as relative6 } from "path";
 import { glob as glob2 } from "glob";
 
 // src/features/project-scripts/project-scripts.database.ts
@@ -15546,13 +15837,13 @@ async function inspectProject(projectPath, projectId) {
   return scripts;
 }
 async function detectPackageManager2(projectPath) {
-  if (existsSync14(join22(projectPath, "bun.lockb")) || existsSync14(join22(projectPath, "bun.lock"))) {
+  if (existsSync14(join23(projectPath, "bun.lockb")) || existsSync14(join23(projectPath, "bun.lock"))) {
     return "bun";
   }
-  if (existsSync14(join22(projectPath, "pnpm-lock.yaml"))) {
+  if (existsSync14(join23(projectPath, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync14(join22(projectPath, "yarn.lock"))) {
+  if (existsSync14(join23(projectPath, "yarn.lock"))) {
     return "yarn";
   }
   try {
@@ -15571,8 +15862,8 @@ async function detectPackageManager2(projectPath) {
   return "npm";
 }
 async function detectMonoRepoType(projectPath) {
-  const hasPnpmWorkspace = existsSync14(join22(projectPath, "pnpm-workspace.yaml"));
-  if (existsSync14(join22(projectPath, "nx.json"))) {
+  const hasPnpmWorkspace = existsSync14(join23(projectPath, "pnpm-workspace.yaml"));
+  if (existsSync14(join23(projectPath, "nx.json"))) {
     return "nx";
   }
   const pkg = await readPackageJson(projectPath);
@@ -15586,10 +15877,10 @@ async function detectMonoRepoType(projectPath) {
   if (hasPnpmWorkspace) {
     return "pnpm";
   }
-  if (existsSync14(join22(projectPath, "lerna.json"))) {
+  if (existsSync14(join23(projectPath, "lerna.json"))) {
     return "lerna";
   }
-  if (existsSync14(join22(projectPath, "turbo.json"))) {
+  if (existsSync14(join23(projectPath, "turbo.json"))) {
     return "turbo";
   }
   const folderWorkspaces = await detectFolderBasedWorkspaces(projectPath);
@@ -15630,8 +15921,8 @@ async function resolvePackageJsonWorkspaces(projectPath) {
   });
   const workspaces = [];
   for (const folder of folders) {
-    const absPath = join22(projectPath, folder);
-    if (existsSync14(join22(absPath, "package.json"))) {
+    const absPath = join23(projectPath, folder);
+    if (existsSync14(join23(absPath, "package.json"))) {
       workspaces.push({
         name: basename4(folder),
         folder: absPath,
@@ -15646,12 +15937,12 @@ async function resolvePackageJsonWorkspaces(projectPath) {
   return workspaces;
 }
 async function resolvePnpmWorkspaces(projectPath) {
-  const yamlPath = join22(projectPath, "pnpm-workspace.yaml");
+  const yamlPath = join23(projectPath, "pnpm-workspace.yaml");
   if (!existsSync14(yamlPath)) {
     return [{ name: "root", folder: projectPath, relativePath: "." }];
   }
   try {
-    const yaml = await readFile12(yamlPath, "utf-8");
+    const yaml = await readFile13(yamlPath, "utf-8");
     const patterns = [];
     for (const line of yaml.split("\n")) {
       const trimmed = line.trim();
@@ -15672,8 +15963,8 @@ async function resolvePnpmWorkspaces(projectPath) {
     });
     const workspaces = [];
     for (const folder of folders) {
-      const absPath = join22(projectPath, folder);
-      if (existsSync14(join22(absPath, "package.json"))) {
+      const absPath = join23(projectPath, folder);
+      if (existsSync14(join23(absPath, "package.json"))) {
         const wsPkg = await readPackageJson(absPath);
         workspaces.push({
           name: wsPkg?.name ?? basename4(folder),
@@ -15692,12 +15983,12 @@ async function resolvePnpmWorkspaces(projectPath) {
   }
 }
 async function resolveLernaWorkspaces(projectPath) {
-  const lernaPath = join22(projectPath, "lerna.json");
+  const lernaPath = join23(projectPath, "lerna.json");
   if (!existsSync14(lernaPath)) {
     return [{ name: "root", folder: projectPath, relativePath: "." }];
   }
   try {
-    const content = await readFile12(lernaPath, "utf-8");
+    const content = await readFile13(lernaPath, "utf-8");
     const lerna = JSON.parse(content);
     const patterns = lerna.packages ?? ["packages/*"];
     const folders = await glob2(patterns, {
@@ -15706,8 +15997,8 @@ async function resolveLernaWorkspaces(projectPath) {
     });
     const workspaces = [];
     for (const folder of folders) {
-      const absPath = join22(projectPath, folder);
-      if (existsSync14(join22(absPath, "package.json"))) {
+      const absPath = join23(projectPath, folder);
+      if (existsSync14(join23(absPath, "package.json"))) {
         const wsPkg = await readPackageJson(absPath);
         workspaces.push({
           name: wsPkg?.name ?? basename4(folder),
@@ -15727,17 +16018,17 @@ async function resolveLernaWorkspaces(projectPath) {
 }
 async function resolveNxWorkspaces(projectPath) {
   const workspaces = [];
-  const workspaceJsonPath = join22(projectPath, "workspace.json");
+  const workspaceJsonPath = join23(projectPath, "workspace.json");
   if (existsSync14(workspaceJsonPath)) {
     try {
-      const content = await readFile12(workspaceJsonPath, "utf-8");
+      const content = await readFile13(workspaceJsonPath, "utf-8");
       const wsJson = JSON.parse(content);
       for (const [name, value] of Object.entries(wsJson.projects ?? {})) {
         const folder = typeof value === "string" ? value : value.root;
         if (folder) {
           workspaces.push({
             name,
-            folder: join22(projectPath, folder),
+            folder: join23(projectPath, folder),
             relativePath: folder
           });
         }
@@ -15752,13 +16043,13 @@ async function resolveNxWorkspaces(projectPath) {
   });
   for (const file of projectJsonFiles) {
     try {
-      const content = await readFile12(join22(projectPath, file), "utf-8");
+      const content = await readFile13(join23(projectPath, file), "utf-8");
       const project = JSON.parse(content);
       if (project.name) {
         const folder = file.replace(/\/project\.json$/, "");
         workspaces.push({
           name: project.name,
-          folder: join22(projectPath, folder),
+          folder: join23(projectPath, folder),
           relativePath: folder
         });
       }
@@ -15766,15 +16057,15 @@ async function resolveNxWorkspaces(projectPath) {
     }
   }
   if (workspaces.length > 0) return workspaces;
-  const appsDir = join22(projectPath, "apps");
+  const appsDir = join23(projectPath, "apps");
   if (existsSync14(appsDir)) {
     const entries = await readdir10(appsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        const folder = join22("apps", entry.name);
+        const folder = join23("apps", entry.name);
         workspaces.push({
           name: entry.name,
-          folder: join22(projectPath, folder),
+          folder: join23(projectPath, folder),
           relativePath: folder
         });
       }
@@ -15808,13 +16099,13 @@ async function detectFolderBasedWorkspaces(projectPath) {
     const results = [];
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") {
-        const pkgPath = join22(projectPath, entry.name, "package.json");
+        const pkgPath = join23(projectPath, entry.name, "package.json");
         if (existsSync14(pkgPath)) {
           try {
-            const content = await readFile12(pkgPath, "utf-8");
+            const content = await readFile13(pkgPath, "utf-8");
             const pkg = JSON.parse(content);
             if (pkg.dependencies || pkg.devDependencies || pkg.scripts) {
-              results.push({ name: entry.name, absPath: join22(projectPath, entry.name) });
+              results.push({ name: entry.name, absPath: join23(projectPath, entry.name) });
             }
           } catch {
           }
@@ -15870,7 +16161,7 @@ function pmRunCommand(packageManager, scriptName) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile12(join22(dir, "package.json"), "utf-8");
+    const content = await readFile13(join23(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -16091,8 +16382,8 @@ async function handleListThreadFiles(c, threadManager) {
 }
 
 // src/features/threads/threads-explorer.route.ts
-import { readdir as readdir11, readFile as readFile13, rename as rename2, writeFile as writeFile4, mkdir as mkdir5, rm as rm5, access as access4 } from "fs/promises";
-import { join as join23 } from "path";
+import { readdir as readdir11, readFile as readFile14, rename as rename2, writeFile as writeFile5, mkdir as mkdir5, rm as rm5, access as access4 } from "fs/promises";
+import { join as join24 } from "path";
 import { spawn as spawn2 } from "child_process";
 var Utils3 = null;
 var utilsLoaded3 = false;
@@ -16155,7 +16446,7 @@ async function handleListThreadExplorerDir(c, threadManager) {
     const entries = dirents.filter((d) => !(isRoot && d.name === ".git")).map((d) => ({
       name: d.name,
       type: d.isDirectory() ? "folder" : "file",
-      path: queryPath ? join23(queryPath, d.name) : d.name
+      path: queryPath ? join24(queryPath, d.name) : d.name
     })).sort((a, b) => {
       if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
       return a.name.localeCompare(b.name);
@@ -16301,7 +16592,7 @@ async function handleCreateExplorerFile(c, threadManager) {
       absParent = validated;
     }
     await mkdir5(absParent, { recursive: true });
-    await writeFile4(join23(absParent, name), "", "utf-8");
+    await writeFile5(join24(absParent, name), "", "utf-8");
     const relPath = dirPath ? `${dirPath}/${name}` : name;
     return c.json({ success: true, path: relPath });
   } catch (error) {
@@ -16358,7 +16649,7 @@ async function handleGetExplorerMedia(c, threadManager) {
     }
     const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
     const contentType = MEDIA_MIME_TYPES[ext] ?? "application/octet-stream";
-    const data = await readFile13(absPath);
+    const data = await readFile14(absPath);
     return new Response(data, { headers: { "Content-Type": contentType } });
   } catch (error) {
     return errorResponse(
@@ -16403,7 +16694,7 @@ async function handleCreateExplorerFolder(c, threadManager) {
       }
       absParent = validated;
     }
-    await mkdir5(join23(absParent, name), { recursive: true });
+    await mkdir5(join24(absParent, name), { recursive: true });
     const relPath = dirPath ? `${dirPath}/${name}` : name;
     return c.json({ success: true, path: relPath });
   } catch (error) {
@@ -16513,14 +16804,14 @@ async function handleOpenThread(c, threadManager) {
 }
 
 // src/features/threads/threads-conversation-folder-path.route.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 async function handleGetConversationFolderPath(c) {
   try {
     const threadId = c.req.param("id");
     if (!threadId) {
       return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
     }
-    const path6 = join24(getDataDir(), threadId);
+    const path6 = join25(getDataDir(), threadId);
     return successResponse(c, { path: path6 });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -16574,13 +16865,13 @@ async function handleFixComments(c, threadManager) {
 }
 
 // src/features/threads/threads-ai-files.route.ts
-import { readFile as readFile14, writeFile as writeFile6, mkdir as mkdir7, access as access5, rm as rm6 } from "fs/promises";
-import { join as join26 } from "path";
+import { readFile as readFile15, writeFile as writeFile7, mkdir as mkdir7, access as access5, rm as rm6 } from "fs/promises";
+import { join as join27 } from "path";
 import { existsSync as existsSync15 } from "fs";
 
 // src/features/git/git-download-folder.ts
-import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
-import { join as join25, dirname as dirname4 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
+import { join as join26, dirname as dirname4 } from "path";
 async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   const { token, ref } = options;
   const match = repoUrl.replace(/\.git$/, "").match(/github\.com\/([^/]+)\/([^/]+)/);
@@ -16616,7 +16907,7 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   await Promise.all(
     files.map(async (file) => {
       const relativePath = file.path.slice(prefix.length);
-      const localPath = join25(destPath, relativePath);
+      const localPath = join26(destPath, relativePath);
       await mkdir6(dirname4(localPath), { recursive: true });
       const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${refParam}/${file.path}`;
       const fileRes = await fetch(rawUrl, { headers });
@@ -16625,7 +16916,7 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
       }
       let content = Buffer.from(await fileRes.arrayBuffer()).toString("utf8");
       content = content.replace(/Claude/gi, "Tarsk");
-      await writeFile5(localPath, content, "utf8");
+      await writeFile6(localPath, content, "utf8");
       console.log(`  \u2713 ${relativePath}`);
     })
   );
@@ -16719,7 +17010,7 @@ Links to important documentation, tools, or references.
     } catch {
       return c.json({ error: { code: "NOT_FOUND", message: `File not found: ${filePath}` } }, 404);
     }
-    const content = await readFile14(absPath, "utf-8");
+    const content = await readFile15(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -16758,9 +17049,9 @@ async function handleSaveThreadAIFile(c, threadManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join26(absPath, "..");
+    const parentDir = join27(absPath, "..");
     await mkdir7(parentDir, { recursive: true });
-    await writeFile6(absPath, content, "utf-8");
+    await writeFile7(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -16847,10 +17138,10 @@ async function handleCreateThreadAgent(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const agentRelPath = join26(".agents", "agents", name);
-    const agentAbsPath = join26(thread.path, agentRelPath);
-    const agentFileRelPath = join26(agentRelPath, "AGENT.md");
-    const agentFileAbsPath = join26(agentAbsPath, "AGENT.md");
+    const agentRelPath = join27(".agents", "agents", name);
+    const agentAbsPath = join27(thread.path, agentRelPath);
+    const agentFileRelPath = join27(agentRelPath, "AGENT.md");
+    const agentFileAbsPath = join27(agentAbsPath, "AGENT.md");
     if (existsSync15(agentAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Agent '${name}' already exists` } },
@@ -16867,7 +17158,7 @@ description: ${description}${toolsLine}
 
 Place your agent system prompt here as markdown. This will be used as the system prompt when this agent is invoked as a subagent.
 `;
-    await writeFile6(agentFileAbsPath, agentContent, "utf-8");
+    await writeFile7(agentFileAbsPath, agentContent, "utf-8");
     return c.json({
       success: true,
       path: agentFileRelPath,
@@ -16917,10 +17208,10 @@ async function handleCreateThreadSkill(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const skillRelPath = join26(".agents", "skills", name);
-    const skillAbsPath = join26(thread.path, skillRelPath);
-    const skillFileRelPath = join26(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join26(skillAbsPath, "SKILL.md");
+    const skillRelPath = join27(".agents", "skills", name);
+    const skillAbsPath = join27(thread.path, skillRelPath);
+    const skillFileRelPath = join27(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join27(skillAbsPath, "SKILL.md");
     if (existsSync15(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
@@ -16935,7 +17226,7 @@ description: ${description}
 
 Place your skill instructions here as markdown. This will be used when Tarsk is prompted with a request related to the description of this skill.
 `;
-    await writeFile6(skillFileAbsPath, skillContent, "utf-8");
+    await writeFile7(skillFileAbsPath, skillContent, "utf-8");
     return c.json({
       success: true,
       path: skillFileRelPath,
@@ -17604,7 +17895,7 @@ import { existsSync as existsSync17 } from "fs";
 // src/features/git/git.utils.ts
 init_utils();
 import { existsSync as existsSync16, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
-import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolve3, join as join27 } from "path";
+import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolve3, join as join28 } from "path";
 import { completeSimple } from "@mariozechner/pi-ai";
 async function resolveModelAndKey(provider, modelId, metadataManager) {
   const providerConfig = await resolveProviderConfig(provider);
@@ -17861,7 +18152,7 @@ async function getUntrackedFilesDiff(gitRoot) {
   const parts = [];
   const maxFileSize = 1e5;
   for (const relPath of untrackedPaths) {
-    const fullPath = join27(gitRoot, relPath);
+    const fullPath = join28(gitRoot, relPath);
     if (!existsSync16(fullPath)) continue;
     try {
       if (statSync4(fullPath).isDirectory()) continue;
@@ -20230,8 +20521,8 @@ function createUpdateRoutes(updater) {
 
 // src/features/mcp/mcp.routes.ts
 import { Hono as Hono13 } from "hono";
-import { readFile as readFile15, writeFile as writeFile7, mkdir as mkdir9, access as access6 } from "fs/promises";
-import { join as join28, dirname as dirname6 } from "path";
+import { readFile as readFile16, writeFile as writeFile8, mkdir as mkdir9, access as access6 } from "fs/promises";
+import { join as join29, dirname as dirname6 } from "path";
 
 // src/features/mcp/mcp.popular.json
 var mcp_popular_default = [
@@ -20342,10 +20633,10 @@ var mcp_popular_default = [
 var MCP_CONFIG_PATHS2 = [".agents/mcp.json", "mcp.json"];
 async function readMCPConfig(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS2) {
-    const fullPath = join28(projectPath, configPath);
+    const fullPath = join29(projectPath, configPath);
     try {
       await access6(fullPath);
-      const content = await readFile15(fullPath, "utf-8");
+      const content = await readFile16(fullPath, "utf-8");
       const config = JSON.parse(content);
       return { config, filePath: fullPath };
     } catch {
@@ -20356,9 +20647,9 @@ async function readMCPConfig(projectPath) {
 }
 async function writeMCPConfig(projectPath, config) {
   const existing = await readMCPConfig(projectPath);
-  const targetPath = existing?.filePath ?? join28(projectPath, ".agents/mcp.json");
+  const targetPath = existing?.filePath ?? join29(projectPath, ".agents/mcp.json");
   await mkdir9(dirname6(targetPath), { recursive: true });
-  await writeFile7(targetPath, JSON.stringify(config, null, 2), "utf-8");
+  await writeFile8(targetPath, JSON.stringify(config, null, 2), "utf-8");
 }
 function createMCPRoutes() {
   const router = new Hono13();
@@ -21030,7 +21321,7 @@ async function clipboardWriteImage(c) {
 }
 
 // src/features/image/image-save.route.ts
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var Utils5 = null;
 var utilsLoaded5 = false;
 async function loadUtils5() {
@@ -21067,7 +21358,7 @@ async function saveImage(c) {
       return c.json({ error: "imageUrl or imageData is required" }, 400);
     }
     const name = filename ?? `generated-image-${Date.now()}.png`;
-    const savePath = join29(Utils5.paths.downloads, name);
+    const savePath = join30(Utils5.paths.downloads, name);
     await Bun.write(savePath, data);
     return c.json({ success: true, path: savePath });
   } catch (error) {