sparkecoder 0.1.83 → 0.1.85

package/dist/cli.js

@@ -1049,6 +1049,388 @@ var init_config = __esm({
   }
 });
 
+// src/tools/todo.ts
+var todo_exports = {};
+__export(todo_exports, {
+  createTodoTool: () => createTodoTool,
+  readSessionPlans: () => readSessionPlans
+});
+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";
+}
+function createTodoTool(options) {
+  return tool4({
+    description: `Manage your task list and persistent plans for the current session.
+
+## 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
+
+## Plan Actions (for complex, multi-phase work)
+- "save_plan": Create or update a named plan. When saved and no active todos exist, todos are AUTO-CREATED from the first uncompleted phase.
+- "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, auto-derived from plan phases.
+
+## Workflow for complex tasks
+1. Create a plan with phases and subtasks using checkboxes (save_plan) \u2014 todos are auto-created from Phase 1
+2. Work through the todos, marking them as you go
+3. When all todos are done, update the plan: mark the completed phase heading with [completed] and its items with [x]
+4. Call save_plan again with the updated content \u2014 todos are auto-created from the next uncompleted phase
+5. Repeat until all phases are complete, then delete_plan
+
+## Auto-todo creation rules
+- Only triggers when there are NO active (pending/in_progress) todos
+- Skips phases with [completed] in the heading
+- Skips sections named Overview, Notes, Key Decisions, etc.
+- Only top-level checklist items (- [ ]) become todos \u2014 indented sub-items are task details
+
+## 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, planName, planContent }) => {
+      try {
+        switch (action) {
+          case "add": {
+            if (!items || items.length === 0) {
+              return {
+                success: false,
+                error: "No items provided. Include at least one todo item."
+              };
+            }
+            const created = await todoQueries.createMany(options.sessionId, items);
+            return {
+              success: true,
+              action: "add",
+              itemsAdded: created.length,
+              items: created.map(formatTodoItem)
+            };
+          }
+          case "list": {
+            const todos = await todoQueries.getBySession(options.sessionId);
+            const stats = {
+              total: todos.length,
+              pending: todos.filter((t) => t.status === "pending").length,
+              inProgress: todos.filter((t) => t.status === "in_progress").length,
+              completed: todos.filter((t) => t.status === "completed").length,
+              cancelled: todos.filter((t) => t.status === "cancelled").length
+            };
+            return {
+              success: true,
+              action: "list",
+              stats,
+              items: todos.map(formatTodoItem)
+            };
+          }
+          case "mark": {
+            if (!todoId) {
+              return {
+                success: false,
+                error: 'todoId is required for "mark" action'
+              };
+            }
+            if (!status) {
+              return {
+                success: false,
+                error: 'status is required for "mark" action'
+              };
+            }
+            const updated = await todoQueries.updateStatus(todoId, status);
+            if (!updated) {
+              return {
+                success: false,
+                error: `Todo item not found: ${todoId}`
+              };
+            }
+            let planContinuation;
+            if (status === "completed") {
+              const allTodos = await todoQueries.getBySession(options.sessionId);
+              const allDone = allTodos.every(
+                (t) => t.status === "completed" || t.status === "cancelled"
+              );
+              if (allDone) {
+                const plansDir = getPlansDir(options.workingDirectory, options.sessionId);
+                if (existsSync9(plansDir)) {
+                  const planFiles = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+                  for (const f of planFiles) {
+                    try {
+                      const content = await readFile6(join4(plansDir, f), "utf-8");
+                      if (parseNextUncompletedPhase(content) !== null) {
+                        planContinuation = "All todos are done but your plan has remaining phases. Update the plan now: mark the completed phase heading with [completed] and its items with [x], then call save_plan to save \u2014 new todos will be auto-created from the next phase.";
+                        break;
+                      }
+                    } catch {
+                    }
+                  }
+                }
+              }
+            }
+            return {
+              success: true,
+              action: "mark",
+              item: formatTodoItem(updated),
+              ...planContinuation ? { planContinuation } : {}
+            };
+          }
+          case "clear": {
+            const count = await todoQueries.clearSession(options.sessionId);
+            return {
+              success: true,
+              action: "clear",
+              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");
+            const existingTodos = await todoQueries.getBySession(options.sessionId);
+            const hasActiveTodos = existingTodos.some(
+              (t) => t.status === "pending" || t.status === "in_progress"
+            );
+            let autoCreatedTodos = [];
+            if (!hasActiveTodos) {
+              const nextPhase = parseNextUncompletedPhase(planContent);
+              if (nextPhase) {
+                const created = await todoQueries.createMany(
+                  options.sessionId,
+                  nextPhase.tasks.map((task, i) => ({ content: task, order: i }))
+                );
+                autoCreatedTodos = created.map(formatTodoItem);
+              }
+            }
+            return {
+              success: true,
+              action: "save_plan",
+              planName,
+              filename,
+              path: filePath,
+              sizeChars: planContent.length,
+              ...autoCreatedTodos.length > 0 ? {
+                autoCreatedTodos,
+                autoCreatedFromPhase: "Created todos from the first uncompleted phase. Start working on them!"
+              } : {}
+            };
+          }
+          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,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+function formatTodoItem(item) {
+  return {
+    id: item.id,
+    content: item.content,
+    status: item.status,
+    order: item.order,
+    createdAt: item.createdAt.toISOString()
+  };
+}
+function parseNextUncompletedPhase(content) {
+  const lines = content.split("\n");
+  let currentPhase = null;
+  let currentTasks = [];
+  let hasUncompletedTask = false;
+  for (const line of lines) {
+    const h2Match = line.match(/^##\s+(.+)/);
+    if (h2Match) {
+      if (currentPhase && hasUncompletedTask && currentTasks.length > 0) {
+        return { phaseName: currentPhase, tasks: currentTasks };
+      }
+      const headingText = h2Match[1].trim();
+      if (/^(overview|notes|key decisions|context|summary|references)\b/i.test(headingText)) {
+        currentPhase = null;
+        currentTasks = [];
+        hasUncompletedTask = false;
+        continue;
+      }
+      if (/\[completed\]/i.test(headingText)) {
+        currentPhase = null;
+        currentTasks = [];
+        hasUncompletedTask = false;
+        continue;
+      }
+      currentPhase = headingText.replace(/\s*\[(in_progress|pending|completed)\]\s*/gi, "").replace(/^Phase\s+\d+[:\s]*/i, "").trim();
+      currentTasks = [];
+      hasUncompletedTask = false;
+      continue;
+    }
+    if (!currentPhase) continue;
+    const uncheckedMatch = line.match(/^[-*]\s+\[\s\]\s+(.+)/);
+    if (uncheckedMatch) {
+      currentTasks.push(uncheckedMatch[1].trim());
+      hasUncompletedTask = true;
+    }
+  }
+  if (currentPhase && hasUncompletedTask && currentTasks.length > 0) {
+    return { phaseName: currentPhase, tasks: currentTasks };
+  }
+  return null;
+}
+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;
+}
+var todoInputSchema;
+var init_todo = __esm({
+  "src/tools/todo.ts"() {
+    "use strict";
+    init_db();
+    todoInputSchema = z5.object({
+      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"),
+          order: z5.number().optional().describe("Optional order/priority (lower = higher priority)")
+        })
+      ).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'),
+      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')
+    });
+  }
+});
+
 // src/skills/index.ts
 var skills_exports = {};
 __export(skills_exports, {
@@ -4836,381 +5218,123 @@ Working directory: ${options.workingDirectory}`,
                 chunkIndex: i,
                 chunkCount,
                 chunkStart,
-                isChunked: true
-              });
-              if (chunkCount > 1) {
-                await new Promise((resolve12) => setTimeout(resolve12, 0));
-              }
-            }
-          }
-          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
-          const dir = dirname5(absolutePath);
-          if (!existsSync8(dir)) {
-            await mkdir3(dir, { recursive: true });
-          }
-          await writeFile3(absolutePath, content, "utf-8");
-          let diagnosticsOutput = "";
-          if (options.enableLSP !== false && isSupported(absolutePath)) {
-            await touchFile(absolutePath, true);
-            diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
-          }
-          options.onProgress?.({
-            path: absolutePath,
-            relativePath,
-            mode: "full",
-            status: "completed",
-            action,
-            totalLength: content.length
-          });
-          return {
-            success: true,
-            path: absolutePath,
-            relativePath,
-            mode: "full",
-            action,
-            bytesWritten: Buffer.byteLength(content, "utf-8"),
-            lineCount: content.split("\n").length,
-            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
-          };
-        } else if (mode === "str_replace") {
-          if (old_string === void 0 || new_string === void 0) {
-            return {
-              success: false,
-              error: 'Both old_string and new_string are required for "str_replace" mode'
-            };
-          }
-          if (!existsSync8(absolutePath)) {
-            return {
-              success: false,
-              error: `File not found: ${path}. Use "full" mode to create new files.`
-            };
-          }
-          options.onProgress?.({
-            path: absolutePath,
-            relativePath,
-            mode: "str_replace",
-            status: "started",
-            action: "edited"
-          });
-          options.onProgress?.({
-            path: absolutePath,
-            relativePath,
-            mode: "str_replace",
-            status: "content",
-            oldString: old_string,
-            newString: new_string,
-            action: "edited"
-          });
-          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
-          const currentContent = await readFile5(absolutePath, "utf-8");
-          if (!currentContent.includes(old_string)) {
-            const lines = currentContent.split("\n");
-            const preview = lines.slice(0, 20).join("\n");
-            return {
-              success: false,
-              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
-              hint: "Check for differences in indentation, line endings, or invisible characters.",
-              filePreview: lines.length > 20 ? `${preview}
-... (${lines.length - 20} more lines)` : preview
-            };
-          }
-          const occurrences = currentContent.split(old_string).length - 1;
-          if (occurrences > 1) {
-            return {
-              success: false,
-              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
-              hint: "Include surrounding lines or more specific content in old_string."
-            };
-          }
-          const newContent = currentContent.replace(old_string, new_string);
-          await writeFile3(absolutePath, newContent, "utf-8");
-          const oldLines = old_string.split("\n").length;
-          const newLines = new_string.split("\n").length;
-          let diagnosticsOutput = "";
-          if (options.enableLSP !== false && isSupported(absolutePath)) {
-            await touchFile(absolutePath, true);
-            diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
-          }
-          options.onProgress?.({
-            path: absolutePath,
-            relativePath,
-            mode: "str_replace",
-            status: "completed",
-            action: "edited"
-          });
-          return {
-            success: true,
-            path: absolutePath,
-            relativePath,
-            mode: "str_replace",
-            linesRemoved: oldLines,
-            linesAdded: newLines,
-            lineDelta: newLines - oldLines,
-            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
-          };
-        }
-        return {
-          success: false,
-          error: `Invalid mode: ${mode}`
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-    }
-  });
-}
-
-// src/tools/todo.ts
-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", "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"),
-      order: z5.number().optional().describe("Optional order/priority (lower = higher priority)")
-    })
-  ).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'),
-  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 and persistent plans for the current session.
-
-## 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
-
-## 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, planName, planContent }) => {
-      try {
-        switch (action) {
-          case "add": {
-            if (!items || items.length === 0) {
-              return {
-                success: false,
-                error: "No items provided. Include at least one todo item."
-              };
-            }
-            const created = await todoQueries.createMany(options.sessionId, items);
-            return {
-              success: true,
-              action: "add",
-              itemsAdded: created.length,
-              items: created.map(formatTodoItem)
-            };
+                isChunked: true
+              });
+              if (chunkCount > 1) {
+                await new Promise((resolve12) => setTimeout(resolve12, 0));
+              }
+            }
           }
-          case "list": {
-            const todos = await todoQueries.getBySession(options.sessionId);
-            const stats = {
-              total: todos.length,
-              pending: todos.filter((t) => t.status === "pending").length,
-              inProgress: todos.filter((t) => t.status === "in_progress").length,
-              completed: todos.filter((t) => t.status === "completed").length,
-              cancelled: todos.filter((t) => t.status === "cancelled").length
-            };
-            return {
-              success: true,
-              action: "list",
-              stats,
-              items: todos.map(formatTodoItem)
-            };
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const dir = dirname5(absolutePath);
+          if (!existsSync8(dir)) {
+            await mkdir3(dir, { recursive: true });
           }
-          case "mark": {
-            if (!todoId) {
-              return {
-                success: false,
-                error: 'todoId is required for "mark" action'
-              };
-            }
-            if (!status) {
-              return {
-                success: false,
-                error: 'status is required for "mark" action'
-              };
-            }
-            const updated = await todoQueries.updateStatus(todoId, status);
-            if (!updated) {
-              return {
-                success: false,
-                error: `Todo item not found: ${todoId}`
-              };
-            }
-            return {
-              success: true,
-              action: "mark",
-              item: formatTodoItem(updated)
-            };
+          await writeFile3(absolutePath, content, "utf-8");
+          let diagnosticsOutput = "";
+          if (options.enableLSP !== false && isSupported(absolutePath)) {
+            await touchFile(absolutePath, true);
+            diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
           }
-          case "clear": {
-            const count = await todoQueries.clearSession(options.sessionId);
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "full",
+            status: "completed",
+            action,
+            totalLength: content.length
+          });
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath,
+            mode: "full",
+            action,
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            lineCount: content.split("\n").length,
+            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
+          };
+        } else if (mode === "str_replace") {
+          if (old_string === void 0 || new_string === void 0) {
             return {
-              success: true,
-              action: "clear",
-              itemsRemoved: count
+              success: false,
+              error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          // ── 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");
+          if (!existsSync8(absolutePath)) {
             return {
-              success: true,
-              action: "save_plan",
-              planName,
-              filename,
-              path: filePath,
-              sizeChars: planContent.length
+              success: false,
+              error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
-          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");
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            status: "started",
+            action: "edited"
+          });
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            status: "content",
+            oldString: old_string,
+            newString: new_string,
+            action: "edited"
+          });
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const currentContent = await readFile5(absolutePath, "utf-8");
+          if (!currentContent.includes(old_string)) {
+            const lines = currentContent.split("\n");
+            const preview = lines.slice(0, 20).join("\n");
             return {
-              success: true,
-              action: "get_plan",
-              planName,
-              content,
-              sizeChars: content.length
+              success: false,
+              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
+              hint: "Check for differences in indentation, line endings, or invisible characters.",
+              filePreview: lines.length > 20 ? `${preview}
+... (${lines.length - 20} more lines)` : preview
             };
           }
-          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:
+          const occurrences = currentContent.split(old_string).length - 1;
+          if (occurrences > 1) {
             return {
               success: false,
-              error: `Unknown action: ${action}`
+              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
+              hint: "Include surrounding lines or more specific content in old_string."
             };
+          }
+          const newContent = currentContent.replace(old_string, new_string);
+          await writeFile3(absolutePath, newContent, "utf-8");
+          const oldLines = old_string.split("\n").length;
+          const newLines = new_string.split("\n").length;
+          let diagnosticsOutput = "";
+          if (options.enableLSP !== false && isSupported(absolutePath)) {
+            await touchFile(absolutePath, true);
+            diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
+          }
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            status: "completed",
+            action: "edited"
+          });
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            linesRemoved: oldLines,
+            linesAdded: newLines,
+            lineDelta: newLines - oldLines,
+            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
+          };
         }
+        return {
+          success: false,
+          error: `Invalid mode: ${mode}`
+        };
       } catch (error) {
         return {
           success: false,
@@ -5220,30 +5344,9 @@ Plans should be markdown with this structure:
     }
   });
 }
-function formatTodoItem(item) {
-  return {
-    id: item.id,
-    content: item.content,
-    status: item.status,
-    order: item.order,
-    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/index.ts
+init_todo();
 
 // src/tools/load-skill.ts
 init_skills();
@@ -6844,6 +6947,7 @@ function createUploadFileTool(options) {
 // src/tools/index.ts
 init_semantic();
 init_remote();
+init_todo();
 init_semantic_search();
 async function createTools(options) {
   const tools = {
@@ -6915,6 +7019,7 @@ init_db();
 // src/agent/prompts.ts
 init_skills();
 init_db();
+init_todo();
 import os from "os";
 function getSearchInstructions() {
   const platform3 = process.platform;
@@ -6963,7 +7068,11 @@ 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 allTodosDone = todos.length > 0 && todos.every(
+    (t) => t.status === "completed" || t.status === "cancelled"
+  );
+  const hasNoTodos = todos.length === 0;
+  const plansContext = formatPlansForContext(plans, allTodosDone || hasNoTodos);
   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();
@@ -6996,16 +7105,19 @@ Use the **todo tool** to manage both immediate tasks AND persistent plans:
 
 **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.
+2. Create a plan with save_plan \u2014 a structured markdown document with phases and subtasks using checkboxes (- [ ] for uncompleted, - [x] for completed)
+3. Todos are **auto-created** from the first uncompleted phase when you save the plan (if no active todos exist)
+4. Work through the todos, marking them as you go
+5. When all todos are done, update the plan: change completed phase heading to include [completed], mark all its items with [x], then call save_plan again \u2014 new todos will be auto-created from the next uncompleted phase
+6. Repeat until all phases are complete, then delete the plan
+
+**Key details:**
+- 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 work, one for backend)
+- When you save a plan and there are no active todos, the system automatically creates todos from the first uncompleted phase (phases with [completed] in the heading are skipped)
+- Only top-level checklist items (- [ ]) become todos \u2014 indented sub-items are part of the task detail
+- Sections named Overview, Notes, Key Decisions, etc. are not treated as phases
+- 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.
@@ -7256,7 +7368,7 @@ function formatTodosForContext(todos) {
 }
 var MAX_PLAN_CHARS = 3e4;
 var MAX_TOTAL_PLANS_CHARS = 6e4;
-function formatPlansForContext(plans) {
+function formatPlansForContext(plans, shouldContinue) {
   if (plans.length === 0) return "";
   let totalChars = 0;
   const sections = [];
@@ -7265,6 +7377,13 @@ function formatPlansForContext(plans) {
   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.");
+  if (shouldContinue) {
+    sections.push("");
+    sections.push("**>>> ACTION NEEDED: Your current todos are all done but the plan has remaining phases. To continue:**");
+    sections.push("**1. Update the plan content: change the completed phase heading to include [completed] and mark its items with [x]**");
+    sections.push("**2. Call save_plan with the updated content \u2014 new todos will be auto-created from the next uncompleted phase**");
+    sections.push("**3. Continue working on the new todos <<<**");
+  }
   sections.push("");
   for (const plan of plans) {
     let content = plan.content;
@@ -8982,6 +9101,24 @@ sessions.get("/:id/todos", async (c) => {
     } : null
   });
 });
+sessions.get("/:id/plans", async (c) => {
+  const id = c.req.param("id");
+  const session = await sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const { readSessionPlans: readSessionPlans2 } = await Promise.resolve().then(() => (init_todo(), todo_exports));
+  const plans = await readSessionPlans2(session.workingDirectory, id);
+  return c.json({
+    sessionId: id,
+    plans: plans.map((p) => ({
+      name: p.name,
+      content: p.content,
+      sizeChars: p.content.length
+    })),
+    count: plans.length
+  });
+});
 sessions.get("/:id/checkpoints", async (c) => {
   const id = c.req.param("id");
   const session = await sessionQueries.getById(id);