sparkecoder 0.1.82 → 0.1.83

package/dist/index.js

@@ -369,27 +369,38 @@ function requiresApproval(toolName, sessionConfig) {
   return false;
 }
 function loadStoredAuthKey() {
-  const keysPath = join(getAppDataDirectory(), AUTH_KEY_FILE);
-  if (!existsSync(keysPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(keysPath, "utf-8");
-    const data = JSON.parse(content);
-    return data.authKey || null;
-  } catch {
-    return null;
+  const locations = [
+    join(process.cwd(), ".sparkecoder", AUTH_KEY_FILE),
+    join(getAppDataDirectory(), AUTH_KEY_FILE)
+  ];
+  for (const keysPath of locations) {
+    if (!existsSync(keysPath)) continue;
+    try {
+      const content = readFileSync(keysPath, "utf-8");
+      const data = JSON.parse(content);
+      if (data.authKey) return data.authKey;
+    } catch {
+    }
   }
+  return null;
 }
 function saveAuthKey(authKey3, userId) {
-  const appDir = ensureAppDataDirectory();
-  const keysPath = join(appDir, AUTH_KEY_FILE);
   const data = {
     authKey: authKey3,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     userId
   };
-  writeFileSync(keysPath, JSON.stringify(data, null, 2), { mode: 384 });
+  const json = JSON.stringify(data, null, 2);
+  const appDir = ensureAppDataDirectory();
+  writeFileSync(join(appDir, AUTH_KEY_FILE), json, { mode: 384 });
+  try {
+    const workspaceAuthDir = join(process.cwd(), ".sparkecoder");
+    if (!existsSync(workspaceAuthDir)) {
+      mkdirSync(workspaceAuthDir, { recursive: true });
+    }
+    writeFileSync(join(workspaceAuthDir, AUTH_KEY_FILE), json, { mode: 384 });
+  } catch {
+  }
 }
 async function registerWithRemoteServer(serverUrl, name) {
   const response = await fetch(`${serverUrl}/auth/register`, {
@@ -1023,9 +1034,9 @@ __export(skills_exports, {
   loadSkillContent: () => loadSkillContent,
   loadSkillsFromDirectory: () => loadSkillsFromDirectory
 });
-import { readFile as readFile6, readdir } from "fs/promises";
+import { readFile as readFile7, readdir } from "fs/promises";
 import { resolve as resolve6, basename, extname as extname4, relative as relative4 } from "path";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { minimatch } from "minimatch";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -1103,7 +1114,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     defaultLoadType = "on_demand",
     forceAlwaysApply = false
   } = options;
-  if (!existsSync9(directory)) {
+  if (!existsSync10(directory)) {
     return [];
   }
   const skills = [];
@@ -1113,7 +1124,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     let fileName;
     if (entry.isDirectory()) {
       const skillMdPath = resolve6(directory, entry.name, "SKILL.md");
-      if (existsSync9(skillMdPath)) {
+      if (existsSync10(skillMdPath)) {
         filePath = skillMdPath;
         fileName = entry.name;
       } else {
@@ -1125,7 +1136,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     } else {
       continue;
     }
-    const content = await readFile6(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       const alwaysApply = forceAlwaysApply || parsed.metadata.alwaysApply;
@@ -1204,7 +1215,7 @@ async function loadAllSkillsFromDiscovered(discovered) {
   const onDemandSkills = allSkills.filter((s) => !s.alwaysApply && s.loadType !== "always");
   const alwaysWithContent = await Promise.all(
     alwaysSkills.map(async (skill) => {
-      const content = await readFile6(skill.filePath, "utf-8");
+      const content = await readFile7(skill.filePath, "utf-8");
       const parsed = parseSkillFrontmatter(content);
       return {
         ...skill,
@@ -1241,7 +1252,7 @@ async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
   });
   const matchedWithContent = await Promise.all(
     matchedSkills.map(async (skill) => {
-      const content = await readFile6(skill.filePath, "utf-8");
+      const content = await readFile7(skill.filePath, "utf-8");
       const parsed = parseSkillFrontmatter(content);
       return {
         ...skill,
@@ -1253,10 +1264,10 @@ async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
   return matchedWithContent;
 }
 async function loadAgentsMd(agentsMdPath) {
-  if (!agentsMdPath || !existsSync9(agentsMdPath)) {
+  if (!agentsMdPath || !existsSync10(agentsMdPath)) {
     return null;
   }
-  const content = await readFile6(agentsMdPath, "utf-8");
+  const content = await readFile7(agentsMdPath, "utf-8");
   return content;
 }
 async function loadSkillContent(skillName, directories) {
@@ -1267,7 +1278,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile6(skill.filePath, "utf-8");
+  const content = await readFile7(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -1528,7 +1539,7 @@ var init_client = __esm({
 });
 
 // src/semantic/indexer.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
+import { readFileSync as readFileSync5, statSync } from "fs";
 import { relative as relative6 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 async function getIndexStatus(workingDirectory) {
@@ -1613,8 +1624,8 @@ __export(semantic_search_exports, {
 });
 import { tool as tool8 } from "ai";
 import { z as z9 } from "zod";
-import { existsSync as existsSync12, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 function createSemanticSearchTool(options) {
   return tool8({
@@ -1681,13 +1692,13 @@ Returns matching code snippets with file paths, line numbers, and relevance scor
             if (language && matchLanguage !== language.toLowerCase()) {
               continue;
             }
-            const fullPath = join5(options.workingDirectory, filePath);
-            if (!existsSync12(fullPath)) {
+            const fullPath = join6(options.workingDirectory, filePath);
+            if (!existsSync13(fullPath)) {
               continue;
             }
             let snippet = "";
             try {
-              const content = readFileSync5(fullPath, "utf-8");
+              const content = readFileSync6(fullPath, "utf-8");
               const lines = content.split("\n");
               const snippetLines = lines.slice(
                 Math.max(0, startLine - 1),
@@ -1755,7 +1766,7 @@ async function sendWebhook(url, event) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 5e3);
-    await fetch(url, {
+    const response = await fetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1765,7 +1776,12 @@ async function sendWebhook(url, event) {
       signal: controller.signal
     });
     clearTimeout(timeout);
-  } catch {
+    if (!response.ok) {
+      console.warn(`[WEBHOOK] ${event.type} to ${url} returned HTTP ${response.status}`);
+    }
+  } catch (err) {
+    const reason = err.name === "AbortError" ? "timeout (5s)" : err.message;
+    console.warn(`[WEBHOOK] ${event.type} to ${url} failed: ${reason}`);
   }
 }
 var init_webhook = __esm({
@@ -1982,8 +1998,8 @@ __export(recorder_exports, {
 });
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile10, unlink as unlink2, readdir as readdir5, rm } from "fs/promises";
-import { join as join7 } from "path";
+import { writeFile as writeFile5, mkdir as mkdir4, readFile as readFile11, unlink as unlink2, readdir as readdir5, rm } from "fs/promises";
+import { join as join8 } from "path";
 import { tmpdir } from "os";
 import { nanoid as nanoid3 } from "nanoid";
 async function checkFfmpeg() {
@@ -2040,21 +2056,21 @@ var init_recorder = __esm({
        */
       async encode() {
         if (this.frames.length === 0) return null;
-        const workDir = join7(tmpdir(), `sparkecoder-recording-${nanoid3(8)}`);
+        const workDir = join8(tmpdir(), `sparkecoder-recording-${nanoid3(8)}`);
         await mkdir4(workDir, { recursive: true });
         try {
           for (let i = 0; i < this.frames.length; i++) {
-            const framePath = join7(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
-            await writeFile4(framePath, this.frames[i].data);
+            const framePath = join8(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
+            await writeFile5(framePath, this.frames[i].data);
           }
           const duration = (this.frames[this.frames.length - 1].timestamp - this.frames[0].timestamp) / 1e3;
           const fps = duration > 0 ? Math.round(this.frames.length / duration) : 10;
           const clampedFps = Math.max(1, Math.min(fps, 30));
-          const outputPath = join7(workDir, `recording_${this.sessionId}.mp4`);
+          const outputPath = join8(workDir, `recording_${this.sessionId}.mp4`);
           const hasFfmpeg = await checkFfmpeg();
           if (hasFfmpeg) {
             await execAsync5(
-              `ffmpeg -y -framerate ${clampedFps} -i "${join7(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
+              `ffmpeg -y -framerate ${clampedFps} -i "${join8(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
               { timeout: 12e4 }
             );
           } else {
@@ -2062,11 +2078,11 @@ var init_recorder = __esm({
             await cleanup(workDir);
             return null;
           }
-          const outputBuf = await readFile10(outputPath);
+          const outputBuf = await readFile11(outputPath);
           const files = await readdir5(workDir);
           for (const f of files) {
             if (f.startsWith("frame_")) {
-              await unlink2(join7(workDir, f)).catch(() => {
+              await unlink2(join8(workDir, f)).catch(() => {
               });
             }
           }
@@ -4168,8 +4184,34 @@ Working directory: ${options.workingDirectory}`,
 init_db();
 import { tool as tool4 } from "ai";
 import { z as z5 } from "zod";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync, unlinkSync, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { join as join4 } from "path";
+function getPlansDir(workingDirectory, sessionId) {
+  return join4(workingDirectory, ".sparkecoder", "plans", sessionId);
+}
+function ensurePlansDir(workingDirectory, sessionId) {
+  const dir = getPlansDir(workingDirectory, sessionId);
+  if (!existsSync9(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  const gitignorePath = join4(workingDirectory, ".gitignore");
+  if (existsSync9(gitignorePath)) {
+    try {
+      const content = readFileSync3(gitignorePath, "utf-8");
+      if (!content.includes(".sparkecoder")) {
+        appendFileSync(gitignorePath, "\n.sparkecoder/\n");
+      }
+    } catch {
+    }
+  }
+  return dir;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "plan";
+}
 var todoInputSchema = z5.object({
-  action: z5.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
+  action: z5.enum(["add", "list", "mark", "clear", "save_plan", "list_plans", "get_plan", "delete_plan"]).describe("The action to perform"),
   items: z5.array(
     z5.object({
       content: z5.string().describe("Description of the task"),
@@ -4177,27 +4219,67 @@ var todoInputSchema = z5.object({
     })
   ).optional().describe('For "add" action: Array of todo items to add'),
   todoId: z5.string().optional().describe('For "mark" action: The ID of the todo item to update'),
-  status: z5.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe('For "mark" action: The new status for the todo item')
+  status: z5.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe('For "mark" action: The new status for the todo item'),
+  planName: z5.string().optional().describe('For plan actions: Name of the plan (e.g. "auth-system", "db-migration")'),
+  planContent: z5.string().optional().describe('For "save_plan": Full plan content as markdown with hierarchical tasks using checkboxes')
 });
 function createTodoTool(options) {
   return tool4({
-    description: `Manage your task list for the current session. Use this to:
-- Break down complex tasks into smaller steps
-- Track progress on multi-step operations
-- Organize your work systematically
+    description: `Manage your task list and persistent plans for the current session.
 
-Available actions:
+## Todo Actions (for tracking current work)
 - "add": Add one or more new todo items to the list
 - "list": View all current todo items and their status
 - "mark": Update the status of a todo item (pending, in_progress, completed, cancelled)
 - "clear": Remove all todo items from the list
 
-Best practices:
-- Add todos before starting complex tasks
-- Mark items as "in_progress" when actively working on them
-- Update status as you complete each step`,
+## Plan Actions (for complex, multi-phase work)
+- "save_plan": Create or update a named plan \u2014 a persistent markdown document with hierarchical tasks, subtasks, and notes. Plans survive context compaction and are always available.
+- "list_plans": List all plans for this session
+- "get_plan": Read a specific plan by name
+- "delete_plan": Remove a plan
+
+## Plans vs Todos
+- **Plans** are the big picture \u2014 the full spec with phases, subtasks, notes, and decisions. They persist on disk and are always injected into your context, even after old messages are summarized.
+- **Todos** are your current focus \u2014 the immediate steps you're working on right now.
+
+## Workflow for complex tasks
+1. Create a plan with phases and subtasks (save_plan)
+2. Create todos from the first uncompleted phase (add)
+3. Work through the todos, marking them as you go
+4. When all current todos are done, update the plan (mark completed sections with [x]) and save it
+5. Create new todos from the next uncompleted phase
+6. Repeat until the plan is fully complete
+
+## Plan format
+Plans should be markdown with this structure:
+\`\`\`markdown
+# Plan: [Title]
+
+## Overview
+[What we're doing and why]
+
+## Phase 1: [Name] [completed]
+- [x] Task 1
+- [x] Task 2
+
+## Phase 2: [Name] [in_progress]
+- [x] Subtask 2.1
+- [ ] Subtask 2.2
+  - [ ] Sub-subtask 2.2.1
+  - [ ] Sub-subtask 2.2.2
+- [ ] Subtask 2.3
+
+## Phase 3: [Name] [pending]
+- [ ] Task 1
+- [ ] Task 2
+
+## Notes
+- Key decisions and context to preserve
+- Important file paths discovered
+\`\`\``,
     inputSchema: todoInputSchema,
-    execute: async ({ action, items, todoId, status }) => {
+    execute: async ({ action, items, todoId, status, planName, planContent }) => {
       try {
         switch (action) {
           case "add": {
@@ -4265,6 +4347,81 @@ Best practices:
               itemsRemoved: count
             };
           }
+          // ── Plan actions ─────────────────────────────────────────
+          case "save_plan": {
+            if (!planName) {
+              return { success: false, error: 'planName is required for "save_plan"' };
+            }
+            if (!planContent) {
+              return { success: false, error: 'planContent is required for "save_plan"' };
+            }
+            const dir = ensurePlansDir(options.workingDirectory, options.sessionId);
+            const filename = `${slugify(planName)}.md`;
+            const filePath = join4(dir, filename);
+            await writeFile4(filePath, planContent, "utf-8");
+            return {
+              success: true,
+              action: "save_plan",
+              planName,
+              filename,
+              path: filePath,
+              sizeChars: planContent.length
+            };
+          }
+          case "list_plans": {
+            const dir = getPlansDir(options.workingDirectory, options.sessionId);
+            if (!existsSync9(dir)) {
+              return { success: true, action: "list_plans", plans: [], count: 0 };
+            }
+            const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+            const plans = [];
+            for (const f of files) {
+              try {
+                const content = await readFile6(join4(dir, f), "utf-8");
+                const titleMatch = content.match(/^#\s+(?:Plan:\s*)?(.+)/m);
+                plans.push({
+                  name: f.replace(/\.md$/, ""),
+                  title: titleMatch?.[1]?.trim() || f.replace(/\.md$/, ""),
+                  filename: f,
+                  sizeChars: content.length
+                });
+              } catch {
+              }
+            }
+            return { success: true, action: "list_plans", plans, count: plans.length };
+          }
+          case "get_plan": {
+            if (!planName) {
+              return { success: false, error: 'planName is required for "get_plan"' };
+            }
+            const dir = getPlansDir(options.workingDirectory, options.sessionId);
+            const filename = `${slugify(planName)}.md`;
+            const filePath = join4(dir, filename);
+            if (!existsSync9(filePath)) {
+              return { success: false, error: `Plan not found: "${planName}" (looked for ${filename})` };
+            }
+            const content = await readFile6(filePath, "utf-8");
+            return {
+              success: true,
+              action: "get_plan",
+              planName,
+              content,
+              sizeChars: content.length
+            };
+          }
+          case "delete_plan": {
+            if (!planName) {
+              return { success: false, error: 'planName is required for "delete_plan"' };
+            }
+            const dir = getPlansDir(options.workingDirectory, options.sessionId);
+            const filename = `${slugify(planName)}.md`;
+            const filePath = join4(dir, filename);
+            if (!existsSync9(filePath)) {
+              return { success: false, error: `Plan not found: "${planName}"` };
+            }
+            unlinkSync(filePath);
+            return { success: true, action: "delete_plan", planName, deleted: true };
+          }
           default:
             return {
               success: false,
@@ -4289,6 +4446,21 @@ function formatTodoItem(item) {
     createdAt: item.createdAt.toISOString()
   };
 }
+async function readSessionPlans(workingDirectory, sessionId) {
+  const dir = getPlansDir(workingDirectory, sessionId);
+  if (!existsSync9(dir)) return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  if (files.length === 0) return [];
+  const plans = [];
+  for (const f of files) {
+    try {
+      const content = await readFile6(join4(dir, f), "utf-8");
+      plans.push({ name: f.replace(/\.md$/, ""), content });
+    } catch {
+    }
+  }
+  return plans;
+}
 
 // src/tools/load-skill.ts
 init_skills();
@@ -4378,7 +4550,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
 import { tool as tool6 } from "ai";
 import { z as z7 } from "zod";
 import { resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3, extname as extname5 } from "path";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 var linterInputSchema = z7.object({
   paths: z7.array(z7.string()).optional().describe("File or directory paths to check for lint errors. If not provided, returns diagnostics for all recently touched files."),
@@ -4446,7 +4618,7 @@ Working directory: ${options.workingDirectory}`,
         const filesToCheck = [];
         for (const path of paths) {
           const absolutePath = isAbsolute3(path) ? path : resolve7(options.workingDirectory, path);
-          if (!existsSync10(absolutePath)) {
+          if (!existsSync11(absolutePath)) {
             continue;
           }
           const stats = await stat2(absolutePath);
@@ -4758,17 +4930,17 @@ import { tool as tool9 } from "ai";
 import { z as z10 } from "zod";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
-import { readFile as readFile8, stat as stat3, readdir as readdir4 } from "fs/promises";
+import { readFile as readFile9, stat as stat3, readdir as readdir4 } from "fs/promises";
 import { resolve as resolve9, relative as relative8, isAbsolute as isAbsolute5 } from "path";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 init_semantic();
 
 // src/tools/code-graph.ts
 import { tool as tool7 } from "ai";
 import { z as z8 } from "zod";
 import { resolve as resolve8, relative as relative7, isAbsolute as isAbsolute4, basename as basename3 } from "path";
-import { readFile as readFile7, readdir as readdir3 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile8, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execFileSync } from "child_process";
 var codeGraphInputSchema = z8.object({
@@ -4905,7 +5077,7 @@ async function grepForSymbol(symbol, workingDirectory) {
           const ext = entry.name.substring(entry.name.lastIndexOf("."));
           if (!SUPPORTED_EXTS.has(ext)) continue;
           remaining--;
-          const content = await readFile7(fullPath, "utf-8");
+          const content = await readFile8(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             if (defPattern.test(lines[i])) {
@@ -4954,7 +5126,7 @@ Working directory: ${options.workingDirectory}`,
         let defSymbol = null;
         if (filePath) {
           const absPath = isAbsolute4(filePath) ? filePath : resolve8(options.workingDirectory, filePath);
-          if (!existsSync11(absPath)) {
+          if (!existsSync12(absPath)) {
             return { success: false, error: `File not found: ${filePath}` };
           }
           if (!isSupported(absPath)) {
@@ -4968,7 +5140,7 @@ Working directory: ${options.workingDirectory}`,
             defLine = defSymbol.selectionRange.start.line;
             defChar = defSymbol.selectionRange.start.character;
           } else {
-            const content = await readFile7(absPath, "utf-8");
+            const content = await readFile8(absPath, "utf-8");
             const lines2 = content.split("\n");
             const defPattern = new RegExp(
               `(export|function|const|let|var|class|interface|type|enum)\\s+.*\\b${symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`
@@ -5381,7 +5553,7 @@ Keep it concise but INCLUDE THE ACTUAL DATA.`;
         execute: async ({ path, startLine, endLine }) => {
           try {
             const absolutePath = isAbsolute5(path) ? path : resolve9(workingDirectory, path);
-            if (!existsSync13(absolutePath)) {
+            if (!existsSync14(absolutePath)) {
               return {
                 success: false,
                 error: `File not found: ${path}`
@@ -5394,7 +5566,7 @@ Keep it concise but INCLUDE THE ACTUAL DATA.`;
                 error: `File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Use startLine/endLine to read portions.`
               };
             }
-            let content = await readFile8(absolutePath, "utf-8");
+            let content = await readFile9(absolutePath, "utf-8");
             if (startLine !== void 0 || endLine !== void 0) {
               const lines = content.split("\n");
               const start = (startLine ?? 1) - 1;
@@ -5425,7 +5597,7 @@ Keep it concise but INCLUDE THE ACTUAL DATA.`;
         execute: async ({ path, recursive, maxDepth }) => {
           try {
             const absolutePath = isAbsolute5(path) ? path : resolve9(workingDirectory, path);
-            if (!existsSync13(absolutePath)) {
+            if (!existsSync14(absolutePath)) {
               return {
                 success: false,
                 error: `Directory not found: ${path}`
@@ -5792,8 +5964,8 @@ function createTaskFailedTool(options) {
 // src/tools/upload-file.ts
 import { tool as tool12 } from "ai";
 import { z as z13 } from "zod";
-import { readFile as readFile9, stat as stat4 } from "fs/promises";
-import { join as join6, basename as basename4, extname as extname7 } from "path";
+import { readFile as readFile10, stat as stat4 } from "fs/promises";
+import { join as join7, basename as basename4, extname as extname7 } from "path";
 var MIME_TYPES = {
   ".txt": "text/plain",
   ".md": "text/markdown",
@@ -5835,7 +6007,7 @@ function createUploadFileTool(options) {
             error: "File upload is not available \u2014 remote server with GCS is not configured."
           };
         }
-        const fullPath = input.path.startsWith("/") ? input.path : join6(options.workingDirectory, input.path);
+        const fullPath = input.path.startsWith("/") ? input.path : join7(options.workingDirectory, input.path);
         try {
           await stat4(fullPath);
         } catch {
@@ -5853,7 +6025,7 @@ function createUploadFileTool(options) {
           contentType,
           "general"
         );
-        const fileData = await readFile9(fullPath);
+        const fileData = await readFile10(fullPath);
         const putRes = await fetch(uploadInfo.uploadUrl, {
           method: "PUT",
           headers: { "Content-Type": contentType },
@@ -5908,7 +6080,8 @@ async function createTools(options) {
       onProgress: options.onWriteFileProgress
     }),
     todo: createTodoTool({
-      sessionId: options.sessionId
+      sessionId: options.sessionId,
+      workingDirectory: options.workingDirectory
     }),
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,
@@ -6006,6 +6179,8 @@ async function buildSystemPrompt(options) {
   }
   const todos = await todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
+  const plans = await readSessionPlans(workingDirectory, sessionId);
+  const plansContext = formatPlansForContext(plans);
   const platform3 = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
   const currentDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" });
   const searchInstructions = getSearchInstructions();
@@ -6022,7 +6197,7 @@ You have access to powerful tools for:
 - **read_file**: Read file contents to understand code and context
 - **write_file**: Create new files or edit existing ones (supports targeted string replacement)
 - **linter**: Check files for type errors and lint issues (TypeScript, JavaScript, TSX, JSX)
-- **todo**: Manage your task list to track progress on complex operations
+- **todo**: Manage your task list AND persistent plans for complex multi-phase operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
 - **explore_agent**: Explore agent for semantic discovery - for exploratory questions and finding code by meaning
 - **code_graph**: Inspect a symbol's type hierarchy and usage graph via the TypeScript language server
@@ -6031,9 +6206,23 @@ You have access to powerful tools for:
 
 IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
 
-Use the TODO tool to manage your task list to track progress on complex operations. Always ask the user what they want to do specifically before doing it, and make a plan. 
-Step 1 of the plan should be researching files and understanding the components/structure of what you're working on (if you don't already have context), then after u have done that, plan out the rest of the tasks u need to do. 
-You can clear the todo and restart it, and do multiple things inside of one session.
+### Planning & Task Management
+Use the **todo tool** to manage both immediate tasks AND persistent plans:
+
+**For simple tasks (< 5 steps):** Just use regular todos (add/mark/clear).
+
+**For complex, multi-phase tasks:** Create a persistent **plan** first.
+1. Research the codebase to understand what you're working with
+2. Create a plan with save_plan \u2014 a structured markdown document with phases and subtasks
+3. Create todos from the first uncompleted phase
+4. Work through the todos
+5. When done, update the plan (mark completed phases with [x]), save it again
+6. Create new todos from the next uncompleted phase
+7. Repeat until the plan is fully complete
+
+Plans persist on disk and are always injected into your context \u2014 they survive context compaction even in very long sessions. You can have multiple plans active at once (e.g., one for frontend, one for backend).
+
+You can clear the todo list and restart it, and do multiple things inside of one session.
 
 ### bash Tool
 The bash tool runs commands in the terminal. Every command runs in its own session with logs saved to disk.
@@ -6257,6 +6446,8 @@ ${onDemandSkillsContext}
 ## Current Task List
 ${todosContext}
 
+${plansContext}
+
 ${customInstructions ? `## Custom Instructions
 ${customInstructions}` : ""}
 
@@ -6280,6 +6471,37 @@ function formatTodosForContext(todos) {
   }
   return lines.join("\n");
 }
+var MAX_PLAN_CHARS = 3e4;
+var MAX_TOTAL_PLANS_CHARS = 6e4;
+function formatPlansForContext(plans) {
+  if (plans.length === 0) return "";
+  let totalChars = 0;
+  const sections = [];
+  sections.push(`## Persistent Plans (${plans.length})`);
+  sections.push("");
+  sections.push("These plans persist across context compaction \u2014 they are always available.");
+  sections.push("When you finish your current todos, check these plans for the next uncompleted phase,");
+  sections.push("update the plan (mark completed items with [x]), then create new todos for the next phase.");
+  sections.push("");
+  for (const plan of plans) {
+    let content = plan.content;
+    if (content.length > MAX_PLAN_CHARS) {
+      content = content.slice(0, MAX_PLAN_CHARS) + `
+
+... [plan truncated \u2014 ${content.length - MAX_PLAN_CHARS} chars omitted. Use get_plan to read the full plan.]`;
+    }
+    if (totalChars + content.length > MAX_TOTAL_PLANS_CHARS) {
+      sections.push(`### \u{1F4CB} Plan: ${plan.name} [truncated \u2014 use get_plan("${plan.name}") to read]`);
+      continue;
+    }
+    sections.push(`### \u{1F4CB} Plan: ${plan.name}`);
+    sections.push("");
+    sections.push(content);
+    sections.push("");
+    totalChars += content.length;
+  }
+  return sections.join("\n");
+}
 function buildTaskPromptAddendum(outputSchema) {
   return `
 ## Task Mode
@@ -6351,7 +6573,7 @@ Before calling \`complete_task\`, you MUST verify your work completely. Do not j
 - **load_skill**: Load specialized skills/knowledge relevant to the task. Check what skills are available and use them.
 - **explore_agent**: Use for codebase exploration and understanding before making changes.
 - **code_graph**: Use to understand type hierarchies, references, and impact before refactoring.
-- **todo**: Track your progress on multi-step tasks so you don't miss steps.
+- **todo**: Track your progress on multi-step tasks so you don't miss steps. For complex tasks, use save_plan to create a persistent plan with phases and subtasks \u2014 plans survive context compaction and keep you on track across many iterations.
 - **bash**: Full shell access \u2014 run builds, tests, dev servers, open browsers, curl endpoints, anything.
 - **upload_file**: Upload files (screenshots, reports, exports) to cloud storage. Use this to include screenshots of completed work in your task result \u2014 visual proof is very helpful.
 
@@ -7104,12 +7326,14 @@ ${prompt}` });
     const config = getConfig();
     const maxIterations = options.taskConfig.maxIterations ?? 50;
     const webhookUrl = options.taskConfig.webhookUrl;
+    const parentTaskId = options.taskConfig.parentTaskId;
     const fireWebhook = (type, data) => {
       if (!webhookUrl) return;
       sendWebhook(webhookUrl, {
         type,
         taskId: this.session.id,
         sessionId: this.session.id,
+        ...parentTaskId ? { parentTaskId } : {},
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data
       });
@@ -7302,14 +7526,14 @@ ${taskAddendum}`;
       for (const step of resultSteps) {
         if (step.toolCalls) {
           for (const tc of step.toolCalls) {
-            options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.args });
-            fireWebhook("task.tool_call", { iteration, toolName: tc.toolName, toolCallId: tc.toolCallId, input: tc.args });
+            options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.input });
+            fireWebhook("task.tool_call", { iteration, toolName: tc.toolName, toolCallId: tc.toolCallId, input: tc.input });
           }
         }
         if (step.toolResults) {
           for (const tr of step.toolResults) {
-            options.onToolResult?.({ toolCallId: tr.toolCallId, toolName: tr.toolName, output: tr.result });
-            fireWebhook("task.tool_result", { iteration, toolName: tr.toolName, toolCallId: tr.toolCallId, output: tr.result });
+            options.onToolResult?.({ toolCallId: tr.toolCallId, toolName: tr.toolName, output: tr.output });
+            fireWebhook("task.tool_result", { iteration, toolName: tr.toolName, toolCallId: tr.toolCallId, output: tr.output });
           }
         }
       }
@@ -7401,14 +7625,14 @@ ${taskAddendum}`;
       const result = await recorder.encode();
       recorder.clear();
       if (!result) return [];
-      const { readFile: readFile11, unlink: unlink3 } = await import("fs/promises");
+      const { readFile: readFile12, unlink: unlink3 } = await import("fs/promises");
       const uploadInfo = await storageQueries2.getUploadUrl(
         this.session.id,
         `browser-recording-${Date.now()}.mp4`,
         "video/mp4",
         "browser-recording"
       );
-      const fileData = await readFile11(result.path);
+      const fileData = await readFile12(result.path);
       await fetch(uploadInfo.uploadUrl, {
         method: "PUT",
         headers: { "Content-Type": "video/mp4" },
@@ -7434,12 +7658,12 @@ ${taskAddendum}`;
     try {
       const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
       if (!isRemoteConfigured2()) return [];
-      const { readFile: readFile11 } = await import("fs/promises");
-      const { join: join12, basename: basename6 } = await import("path");
+      const { readFile: readFile12 } = await import("fs/promises");
+      const { join: join13, basename: basename6 } = await import("path");
       const urls = [];
       for (const filePath of filePaths) {
         try {
-          const fullPath = filePath.startsWith("/") ? filePath : join12(this.session.workingDirectory, filePath);
+          const fullPath = filePath.startsWith("/") ? filePath : join13(this.session.workingDirectory, filePath);
           const fileName = basename6(fullPath);
           const ext = fileName.split(".").pop()?.toLowerCase() || "";
           const mimeMap = {
@@ -7464,7 +7688,7 @@ ${taskAddendum}`;
             contentType,
             "task-output"
           );
-          const fileData = await readFile11(fullPath);
+          const fileData = await readFile12(fullPath);
           await fetch(uploadInfo.uploadUrl, {
             method: "PUT",
             headers: { "Content-Type": contentType },
@@ -7614,8 +7838,8 @@ import { Hono as Hono6 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve10, dirname as dirname7, join as join11 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve10, dirname as dirname7, join as join12 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -7625,9 +7849,9 @@ init_db();
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { z as z15 } from "zod";
-import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readdirSync, statSync as statSync2, unlinkSync } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync3, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
 import { readdir as readdir6 } from "fs/promises";
-import { join as join8, basename as basename5, extname as extname8, relative as relative9 } from "path";
+import { join as join9, basename as basename5, extname as extname8, relative as relative9 } from "path";
 import { nanoid as nanoid5 } from "nanoid";
 init_config();
 
@@ -8089,12 +8313,12 @@ sessions.get("/:id/diff/:filePath", async (c) => {
 });
 function getAttachmentsDir(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join8(appDataDir, "attachments", sessionId);
+  return join9(appDataDir, "attachments", sessionId);
 }
 function ensureAttachmentsDir(sessionId) {
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync14(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  if (!existsSync15(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   return dir;
 }
@@ -8105,12 +8329,12 @@ sessions.get("/:id/attachments", async (c) => {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync14(dir)) {
+  if (!existsSync15(dir)) {
     return c.json({ sessionId, attachments: [], count: 0 });
   }
-  const files = readdirSync(dir);
+  const files = readdirSync2(dir);
   const attachments = files.map((filename) => {
-    const filePath = join8(dir, filename);
+    const filePath = join9(dir, filename);
     const stats = statSync2(filePath);
     return {
       id: filename.split("_")[0],
@@ -8145,7 +8369,7 @@ sessions.post("/:id/attachments", async (c) => {
       const id = nanoid5(10);
       const ext = extname8(file.name) || "";
       const safeFilename = `${id}_${basename5(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-      const filePath = join8(dir, safeFilename);
+      const filePath = join9(dir, safeFilename);
       const arrayBuffer = await file.arrayBuffer();
       writeFileSync3(filePath, Buffer.from(arrayBuffer));
       return c.json({
@@ -8171,7 +8395,7 @@ sessions.post("/:id/attachments", async (c) => {
     const id = nanoid5(10);
     const ext = extname8(body.filename) || "";
     const safeFilename = `${id}_${basename5(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-    const filePath = join8(dir, safeFilename);
+    const filePath = join9(dir, safeFilename);
     let base64Data = body.data;
     if (base64Data.includes(",")) {
       base64Data = base64Data.split(",")[1];
@@ -8200,16 +8424,16 @@ sessions.delete("/:id/attachments/:attachmentId", async (c) => {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync14(dir)) {
+  if (!existsSync15(dir)) {
     return c.json({ error: "Attachment not found" }, 404);
   }
-  const files = readdirSync(dir);
+  const files = readdirSync2(dir);
   const file = files.find((f) => f.startsWith(attachmentId + "_"));
   if (!file) {
     return c.json({ error: "Attachment not found" }, 404);
   }
-  const filePath = join8(dir, file);
-  unlinkSync(filePath);
+  const filePath = join9(dir, file);
+  unlinkSync2(filePath);
   return c.json({ success: true, id: attachmentId });
 });
 var filesQuerySchema = z15.object({
@@ -8291,7 +8515,7 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
     const entries = await readdir6(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= limit * 2) break;
-      const fullPath = join8(currentDir, entry.name);
+      const fullPath = join9(currentDir, entry.name);
       const relativePath = relative9(baseDir, fullPath);
       if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) {
         continue;
@@ -8339,7 +8563,7 @@ sessions.get(
       return c.json({ error: "Session not found" }, 404);
     }
     const workingDirectory = session.workingDirectory;
-    if (!existsSync14(workingDirectory)) {
+    if (!existsSync15(workingDirectory)) {
       return c.json({
         sessionId,
         workingDirectory,
@@ -8450,8 +8674,8 @@ init_db();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { z as z16 } from "zod";
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
 init_config();
 
 // src/server/resumable-stream.ts
@@ -8657,12 +8881,12 @@ var rejectSchema = z16.object({
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function getAttachmentsDirectory(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join9(appDataDir, "attachments", sessionId);
+  return join10(appDataDir, "attachments", sessionId);
 }
 async function saveAttachmentToDisk(sessionId, attachment, index) {
   const attachmentsDir = getAttachmentsDirectory(sessionId);
-  if (!existsSync15(attachmentsDir)) {
-    mkdirSync5(attachmentsDir, { recursive: true });
+  if (!existsSync16(attachmentsDir)) {
+    mkdirSync6(attachmentsDir, { recursive: true });
   }
   let filename = attachment.filename;
   if (!filename) {
@@ -8680,7 +8904,7 @@ async function saveAttachmentToDisk(sessionId, attachment, index) {
     attachment.mediaType = resized.mediaType;
     attachment.data = buffer.toString("base64");
   }
-  const filePath = join9(attachmentsDir, filename);
+  const filePath = join10(attachmentsDir, filename);
   writeFileSync4(filePath, buffer);
   return filePath;
 }
@@ -9621,26 +9845,26 @@ init_config();
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { z as z17 } from "zod";
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname6, join as join10 } from "path";
+import { dirname as dirname6, join as join11 } from "path";
 var __filename = fileURLToPath3(import.meta.url);
 var __dirname = dirname6(__filename);
 var possiblePaths = [
-  join10(__dirname, "../package.json"),
+  join11(__dirname, "../package.json"),
   // From dist/server -> dist/../package.json
-  join10(__dirname, "../../package.json"),
+  join11(__dirname, "../../package.json"),
   // From dist/server (if nested differently)
-  join10(__dirname, "../../../package.json"),
+  join11(__dirname, "../../../package.json"),
   // From src/server/routes (development)
-  join10(process.cwd(), "package.json")
+  join11(process.cwd(), "package.json")
   // From current working directory
 ];
 var currentVersion = "0.0.0";
 var packageName = "sparkecoder";
 for (const packageJsonPath of possiblePaths) {
   try {
-    const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
     if (packageJson.name === "sparkecoder") {
       currentVersion = packageJson.version || "0.0.0";
       packageName = packageJson.name || "sparkecoder";
@@ -10210,6 +10434,7 @@ tasks.post(
                 type: "task.failed",
                 taskId,
                 sessionId: taskId,
+                ...taskConfig.parentTaskId ? { parentTaskId: taskConfig.parentTaskId } : {},
                 timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                 data: { status: "failed", error: errorMsg }
               });
@@ -10299,6 +10524,7 @@ tasks.post("/:id/cancel", async (c) => {
       type: "task.failed",
       taskId: id,
       sessionId: id,
+      ...task.parentTaskId ? { parentTaskId: task.parentTaskId } : {},
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       data: { status: "failed", error: "Task cancelled by user" }
     });
@@ -10397,11 +10623,11 @@ function getWebDirectory() {
   try {
     const currentDir = dirname7(fileURLToPath4(import.meta.url));
     const webDir = resolve10(currentDir, "..", "web");
-    if (existsSync16(webDir) && existsSync16(join11(webDir, "package.json"))) {
+    if (existsSync17(webDir) && existsSync17(join12(webDir, "package.json"))) {
       return webDir;
     }
     const altWebDir = resolve10(currentDir, "..", "..", "web");
-    if (existsSync16(altWebDir) && existsSync16(join11(altWebDir, "package.json"))) {
+    if (existsSync17(altWebDir) && existsSync17(join12(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -10459,23 +10685,23 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join11(webDir, ".next", "BUILD_ID");
-  return existsSync16(buildIdPath);
+  const buildIdPath = join12(webDir, ".next", "BUILD_ID");
+  return existsSync17(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join11(webDir, "src", "app");
-  const pagesDir = join11(webDir, "src", "pages");
-  const rootAppDir = join11(webDir, "app");
-  const rootPagesDir = join11(webDir, "pages");
-  return existsSync16(appDir) || existsSync16(pagesDir) || existsSync16(rootAppDir) || existsSync16(rootPagesDir);
+  const appDir = join12(webDir, "src", "app");
+  const pagesDir = join12(webDir, "src", "pages");
+  const rootAppDir = join12(webDir, "app");
+  const rootPagesDir = join12(webDir, "pages");
+  return existsSync17(appDir) || existsSync17(pagesDir) || existsSync17(rootAppDir) || existsSync17(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths2 = [
-    join11(webDir, ".next", "standalone", "server.js"),
-    join11(webDir, ".next", "standalone", "web", "server.js")
+    join12(webDir, ".next", "standalone", "server.js"),
+    join12(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths2) {
-    if (existsSync16(serverPath)) {
+    if (existsSync17(serverPath)) {
       return serverPath;
     }
   }
@@ -10515,13 +10741,13 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync16(join11(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync16(join11(webDir, "package-lock.json"));
+  const usePnpm = existsSync17(join12(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync17(join12(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const apiUrl = publicUrl || `http://127.0.0.1:${apiPort}`;
   const runtimeConfig = { apiBaseUrl: apiUrl };
-  const runtimeConfigPath = join11(webDir, "runtime-config.json");
+  const runtimeConfigPath = join12(webDir, "runtime-config.json");
   try {
     writeFileSync5(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
@@ -10714,8 +10940,8 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync16(config.resolvedWorkingDirectory)) {
-    mkdirSync6(config.resolvedWorkingDirectory, { recursive: true });
+  if (!existsSync17(config.resolvedWorkingDirectory)) {
+    mkdirSync7(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   if (!config.resolvedRemoteServer.url) {