@cephalization/math 0.3.1 → 0.4.0

package/README.md

@@ -14,6 +14,13 @@ The primary responsibility of this harness is to **reduce context bloat** by dig
 
 The harness consists of a simple for-loop, executing a new coding agent with a mandate from `PROMPT.md` to complete a *single* task from `TASKS.md`, while reading and recording any insight gained during the work into `LEARNINGS.md`.
 
+### Directory Structure
+
+| Path | Description |
+| ---- | ----------- |
+| `.math/todo/` | Active sprint files (PROMPT.md, TASKS.md, LEARNINGS.md) |
+| `.math/backups/<summary>/` | Archived sprints from `math iterate`, named with AI-generated descriptions |
+
 ## Requirements
 
 **[Bun](https://bun.sh) is required** to run this tool. Node.js is not supported.
@@ -70,7 +77,7 @@ bun link
 math init
 ```
 
-Creates a `todo/` directory with template files and offers to run **planning mode** to help you break down your goal into tasks.
+Creates a `.math/todo/` directory with template files and offers to run **planning mode** to help you break down your goal into tasks.
 
 Options:
 
@@ -130,12 +137,14 @@ Shows task progress with a visual progress bar and next task info.
 math iterate
 ```
 
-Backs up `todo/` to `todo-{M}-{D}-{Y}/` and resets for a new goal:
+Backs up `.math/todo/` to `.math/backups/<summary>/` and resets for a new goal:
 
 - TASKS.md and LEARNINGS.md are reset to templates
 - PROMPT.md is preserved (keeping your accumulated "signs")
 - Offers to run planning mode for your new goal
 
+The `<summary>` is a short description of the completed sprint (e.g., `add-user-auth`, `fix-api-bugs`).
+
 Options:
 
 - `--no-plan` - Skip the planning prompt

package/index.ts

@@ -31,12 +31,12 @@ ${colors.bold}USAGE${colors.reset}
   math <command> [options]
 
 ${colors.bold}COMMANDS${colors.reset}
-  ${colors.cyan}init${colors.reset}      Create todo/ directory with template files
+  ${colors.cyan}init${colors.reset}      Create .math/todo/ directory with template files
   ${colors.cyan}plan${colors.reset}      Run planning mode to flesh out tasks
   ${colors.cyan}run${colors.reset}       Start the agent loop until all tasks complete
   ${colors.cyan}status${colors.reset}    Show current task counts
-  ${colors.cyan}iterate${colors.reset}   Backup todo/ and reset for a new sprint
-  ${colors.cyan}prune${colors.reset}     Delete backup artifacts (todo-M-D-Y directories)
+  ${colors.cyan}iterate${colors.reset}   Backup .math/todo/ and reset for a new sprint
+  ${colors.cyan}prune${colors.reset}     Delete backup artifacts from .math/backups/
   ${colors.cyan}help${colors.reset}      Show this help message
 
 ${colors.bold}OPTIONS${colors.reset}
@@ -55,7 +55,7 @@ ${colors.bold}EXAMPLES${colors.reset}
   ${colors.dim}# Initialize without planning${colors.reset}
   math init --no-plan
 
-  ${colors.dim}# Run planning mode on existing todo/${colors.reset}
+  ${colors.dim}# Run planning mode on existing .math/todo/${colors.reset}
   math plan
 
   ${colors.dim}# Quick planning without clarifying questions${colors.reset}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cephalization/math",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "author": "Tony Powell <powell.anthonyd@proton.me>",
   "access": "public",
   "repository": {

package/src/commands/init.test.ts

@@ -0,0 +1,79 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { existsSync } from "node:fs";
+import { rm, readFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { init } from "./init";
+import { getTodoDir } from "../paths";
+
+const TEST_DIR = join(import.meta.dir, ".test-init");
+
+// Store original cwd to restore after tests
+let originalCwd: string;
+
+beforeEach(async () => {
+  originalCwd = process.cwd();
+
+  // Clean up and create fresh test directory
+  if (existsSync(TEST_DIR)) {
+    await rm(TEST_DIR, { recursive: true });
+  }
+  await mkdir(TEST_DIR, { recursive: true });
+
+  // Change to test directory so getTodoDir() resolves to test location
+  process.chdir(TEST_DIR);
+});
+
+afterEach(async () => {
+  // Restore original working directory
+  process.chdir(originalCwd);
+
+  // Clean up test directory
+  if (existsSync(TEST_DIR)) {
+    await rm(TEST_DIR, { recursive: true });
+  }
+});
+
+describe("init command", () => {
+  test("creates .math/todo directory structure", async () => {
+    // Run init with skipPlan to avoid interactive prompt
+    await init({ skipPlan: true });
+
+    const todoDir = getTodoDir();
+
+    // Verify directory was created
+    expect(existsSync(todoDir)).toBe(true);
+
+    // Verify template files were created
+    expect(existsSync(join(todoDir, "PROMPT.md"))).toBe(true);
+    expect(existsSync(join(todoDir, "TASKS.md"))).toBe(true);
+    expect(existsSync(join(todoDir, "LEARNINGS.md"))).toBe(true);
+  });
+
+  test("uses getTodoDir for path resolution", () => {
+    // Verify getTodoDir returns the expected .math/todo path relative to cwd
+    const todoDir = getTodoDir();
+    expect(todoDir).toContain(".math");
+    expect(todoDir).toContain("todo");
+    expect(todoDir.endsWith(".math/todo")).toBe(true);
+    // Should resolve relative to our test directory
+    expect(todoDir.startsWith(TEST_DIR)).toBe(true);
+  });
+
+  test("does not overwrite if directory already exists", async () => {
+    // First init
+    await init({ skipPlan: true });
+
+    const todoDir = getTodoDir();
+    const originalContent = await readFile(join(todoDir, "TASKS.md"), "utf-8");
+
+    // Modify a file
+    await Bun.write(join(todoDir, "TASKS.md"), "modified content");
+
+    // Second init should not overwrite
+    await init({ skipPlan: true });
+
+    // Verify content was not overwritten
+    const newContent = await readFile(join(todoDir, "TASKS.md"), "utf-8");
+    expect(newContent).toBe("modified content");
+  });
+});

package/src/commands/init.ts

@@ -7,6 +7,7 @@ import {
   LEARNINGS_TEMPLATE,
 } from "../templates";
 import { runPlanningMode, askToRunPlanning } from "../plan";
+import { getTodoDir } from "../paths";
 
 const colors = {
   reset: "\x1b[0m",
@@ -18,16 +19,16 @@ const colors = {
 export async function init(
   options: { skipPlan?: boolean; model?: string } = {}
 ) {
-  const todoDir = join(process.cwd(), "todo");
+  const todoDir = getTodoDir();
 
   if (existsSync(todoDir)) {
     console.log(
-      `${colors.yellow}todo/ directory already exists${colors.reset}`
+      `${colors.yellow}.math/todo/ directory already exists${colors.reset}`
     );
     return;
   }
 
-  // Create todo directory
+  // Create .math/todo directory (recursive creates .math too)
   await mkdir(todoDir, { recursive: true });
 
   // Write template files
@@ -35,7 +36,7 @@ export async function init(
   await Bun.write(join(todoDir, "TASKS.md"), TASKS_TEMPLATE);
   await Bun.write(join(todoDir, "LEARNINGS.md"), LEARNINGS_TEMPLATE);
 
-  console.log(`${colors.green}✓${colors.reset} Created todo/ directory with:`);
+  console.log(`${colors.green}✓${colors.reset} Created .math/todo/ directory with:`);
   console.log(
     `  ${colors.cyan}PROMPT.md${colors.reset}    - System prompt with guardrails`
   );
@@ -54,10 +55,10 @@ export async function init(
   console.log();
   console.log(`Next steps:`);
   console.log(
-    `  1. Edit ${colors.cyan}todo/TASKS.md${colors.reset} to add your tasks`
+    `  1. Edit ${colors.cyan}.math/todo/TASKS.md${colors.reset} to add your tasks`
   );
   console.log(
-    `  2. Customize ${colors.cyan}todo/PROMPT.md${colors.reset} for your project`
+    `  2. Customize ${colors.cyan}.math/todo/PROMPT.md${colors.reset} for your project`
   );
   console.log(
     `  3. Run ${colors.cyan}math run${colors.reset} to start the agent loop`

package/src/commands/iterate.ts

@@ -1,7 +1,11 @@
 import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { TASKS_TEMPLATE, LEARNINGS_TEMPLATE } from "../templates";
 import { runPlanningMode, askToRunPlanning } from "../plan";
+import { getTodoDir, getBackupsDir } from "../paths";
+import { migrateIfNeeded } from "../migration";
+import { generatePlanSummary } from "../summary";
 
 const colors = {
   reset: "\x1b[0m",
@@ -14,20 +18,31 @@ const colors = {
 export async function iterate(
   options: { skipPlan?: boolean; model?: string } = {}
 ) {
-  const todoDir = join(process.cwd(), "todo");
+  // Check for migration first
+  const migrated = await migrateIfNeeded();
+  if (!migrated) {
+    throw new Error("Migration required but was declined.");
+  }
+
+  const todoDir = getTodoDir();
 
   if (!existsSync(todoDir)) {
-    throw new Error("todo/ directory not found. Run 'math init' first.");
+    throw new Error(".math/todo/ directory not found. Run 'math init' first.");
+  }
+
+  // Read current TASKS.md to generate summary for backup directory name
+  const tasksPath = join(todoDir, "TASKS.md");
+  let summary = "plan";
+  if (existsSync(tasksPath)) {
+    const tasksContent = await Bun.file(tasksPath).text();
+    summary = generatePlanSummary(tasksContent);
   }
 
-  // Generate backup directory name: todo-{M}-{D}-{Y}
-  const now = new Date();
-  const month = now.getMonth() + 1;
-  const day = now.getDate();
-  const year = now.getFullYear();
-  const backupDir = join(process.cwd(), `todo-${month}-${day}-${year}`);
+  // Generate backup directory in .math/backups/<summary>/
+  const backupsDir = getBackupsDir();
+  const backupDir = join(backupsDir, summary);
 
-  // Handle existing backup for same day
+  // Handle existing backup with same summary
   let finalBackupDir = backupDir;
   let counter = 1;
   while (existsSync(finalBackupDir)) {
@@ -37,11 +52,15 @@ export async function iterate(
 
   console.log(`${colors.bold}Iterating to new sprint${colors.reset}\n`);
 
+  // Ensure .math/backups/ directory exists
+  if (!existsSync(backupsDir)) {
+    await mkdir(backupsDir, { recursive: true });
+  }
+
   // Step 1: Backup current todo directory
+  const backupName = finalBackupDir.split("/").pop();
   console.log(
-    `${colors.cyan}1.${colors.reset} Backing up todo/ to ${finalBackupDir
-      .split("/")
-      .pop()}/`
+    `${colors.cyan}1.${colors.reset} Backing up .math/todo/ to .math/backups/${backupName}/`
   );
   await Bun.$`cp -r ${todoDir} ${finalBackupDir}`;
   console.log(`   ${colors.green}✓${colors.reset} Backup complete\n`);
@@ -67,9 +86,7 @@ export async function iterate(
 
   console.log(`${colors.green}Done!${colors.reset} Ready for new sprint.`);
   console.log(
-    `${colors.yellow}Previous sprint preserved at:${
-      colors.reset
-    } ${finalBackupDir.split("/").pop()}/`
+    `${colors.yellow}Previous sprint preserved at:${colors.reset} .math/backups/${backupName}/`
   );
 
   // Ask to run planning mode unless --no-plan flag
@@ -84,7 +101,7 @@ export async function iterate(
   console.log();
   console.log(`${colors.bold}Next steps:${colors.reset}`);
   console.log(
-    `  1. Edit ${colors.cyan}todo/TASKS.md${colors.reset} to add new tasks`
+    `  1. Edit ${colors.cyan}.math/todo/TASKS.md${colors.reset} to add new tasks`
   );
   console.log(
     `  2. Run ${colors.cyan}math run${colors.reset} to start the agent loop`

package/src/commands/plan.ts

@@ -1,12 +1,16 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { runPlanningMode } from "../plan";
+import { getTodoDir } from "../paths";
+import { migrateIfNeeded } from "../migration";
 
 export async function plan(options: { model?: string; quick?: boolean } = {}) {
-  const todoDir = join(process.cwd(), "todo");
+  // Check for migration from legacy todo/ to .math/todo/
+  await migrateIfNeeded();
+
+  const todoDir = getTodoDir();
 
   if (!existsSync(todoDir)) {
-    throw new Error("todo/ directory not found. Run 'math init' first.");
+    throw new Error(".math/todo/ directory not found. Run 'math init' first.");
   }
 
   await runPlanningMode({

package/src/commands/status.ts

@@ -1,4 +1,5 @@
 import { readTasks, countTasks, findNextTask } from "../tasks";
+import { getTodoDir } from "../paths";
 
 const colors = {
   reset: "\x1b[0m",
@@ -12,7 +13,7 @@ const colors = {
 };
 
 export async function status() {
-  const { tasks } = await readTasks();
+  const { tasks } = await readTasks(getTodoDir());
   const counts = countTasks(tasks);
 
   console.log(`${colors.bold}Task Status${colors.reset}\n`);

package/src/loop.test.ts

@@ -17,8 +17,8 @@ describe("runLoop dry-run mode", () => {
     originalCwd = process.cwd();
     process.chdir(testDir);
 
-    // Create the todo directory with required files
-    const todoDir = join(testDir, "todo");
+    // Create the .math/todo directory with required files (new structure)
+    const todoDir = join(testDir, ".math", "todo");
     await mkdir(todoDir, { recursive: true });
 
     // Create PROMPT.md
@@ -51,7 +51,7 @@ describe("runLoop dry-run mode", () => {
   test("dry-run mode uses custom mock agent", async () => {
     // Use a pending task so the agent gets invoked
     await writeFile(
-      join(testDir, "todo", "TASKS.md"),
+      join(testDir, ".math", "todo", "TASKS.md"),
       `# Tasks
 
 ### test-task
@@ -113,7 +113,7 @@ describe("runLoop dry-run mode", () => {
   test("dry-run mode with pending tasks runs iteration", async () => {
     // Update TASKS.md to have a pending task
     await writeFile(
-      join(testDir, "todo", "TASKS.md"),
+      join(testDir, ".math", "todo", "TASKS.md"),
       `# Tasks
 
 ### test-task
@@ -178,7 +178,7 @@ describe("runLoop dry-run mode", () => {
   test("agent option with pending task invokes agent", async () => {
     // Update TASKS.md to have a pending task
     await writeFile(
-      join(testDir, "todo", "TASKS.md"),
+      join(testDir, ".math", "todo", "TASKS.md"),
       `# Tasks
 
 ### test-task
@@ -227,8 +227,8 @@ describe("runLoop stream-capture with buffer", () => {
     originalCwd = process.cwd();
     process.chdir(testDir);
 
-    // Create the todo directory with required files
-    const todoDir = join(testDir, "todo");
+    // Create the .math/todo directory with required files (new structure)
+    const todoDir = join(testDir, ".math", "todo");
     await mkdir(todoDir, { recursive: true });
 
     // Create PROMPT.md
@@ -318,7 +318,7 @@ describe("runLoop stream-capture with buffer", () => {
   test("agent output is captured to buffer", async () => {
     // Use a pending task so the agent gets invoked
     await writeFile(
-      join(testDir, "todo", "TASKS.md"),
+      join(testDir, ".math", "todo", "TASKS.md"),
       `# Tasks
 
 ### test-task
@@ -396,7 +396,7 @@ describe("runLoop stream-capture with buffer", () => {
 
   test("buffer subscribers receive agent output in real-time", async () => {
     await writeFile(
-      join(testDir, "todo", "TASKS.md"),
+      join(testDir, ".math", "todo", "TASKS.md"),
       `# Tasks
 
 ### test-task
@@ -479,8 +479,8 @@ describe("runLoop UI server integration", () => {
     originalCwd = process.cwd();
     process.chdir(testDir);
 
-    // Create the todo directory with required files
-    const todoDir = join(testDir, "todo");
+    // Create the .math/todo directory with required files (new structure)
+    const todoDir = join(testDir, ".math", "todo");
     await mkdir(todoDir, { recursive: true });
 
     // Create PROMPT.md

package/src/loop.ts

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readTasks, countTasks, updateTaskStatus, writeTasks } from "./tasks";
 import { DEFAULT_MODEL } from "./constants";
@@ -6,6 +5,8 @@ import { OpenCodeAgent, MockAgent, createLogEntry } from "./agent";
 import type { Agent, LogCategory } from "./agent";
 import { createOutputBuffer, type OutputBuffer } from "./ui/buffer";
 import { startServer, DEFAULT_PORT } from "./ui/server";
+import { getTodoDir } from "./paths";
+import { migrateIfNeeded } from "./migration";
 
 const colors = {
   reset: "\x1b[0m",
@@ -149,9 +150,15 @@ export async function runLoop(options: LoopOptions = {}): Promise<void> {
     log(`Web UI available at http://localhost:${DEFAULT_PORT}`);
   }
 
-  const todoDir = join(process.cwd(), "todo");
-  const promptPath = join(todoDir, "PROMPT.md");
-  const tasksPath = join(todoDir, "TASKS.md");
+  // Check for legacy todo/ directory and migrate if needed
+  const migrated = await migrateIfNeeded();
+  if (!migrated) {
+    throw new Error("Migration declined. Please migrate to continue.");
+  }
+
+  const todoDir = getTodoDir();
+  const promptPath = `${todoDir}/PROMPT.md`;
+  const tasksPath = `${todoDir}/TASKS.md`;
 
   // Check required files exist
   if (!existsSync(promptPath)) {
@@ -262,7 +269,7 @@ export async function runLoop(options: LoopOptions = {}): Promise<void> {
     try {
       const prompt =
         "Read the attached PROMPT.md and TASKS.md files. Follow the instructions in PROMPT.md to complete the next pending task.";
-      const files = ["todo/PROMPT.md", "todo/TASKS.md"];
+      const files = [".math/todo/PROMPT.md", ".math/todo/TASKS.md"];
 
       const result = await agent.run({
         model,

package/src/migration.test.ts

@@ -0,0 +1,165 @@
+import { test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { hasLegacyTodoDir, hasNewTodoDir, migrateIfNeeded } from "./migration";
+
+// Use a temp directory for testing
+const TEST_DIR = join(import.meta.dir, ".test-migration");
+
+beforeEach(async () => {
+  // Clean up and create fresh test directory
+  if (existsSync(TEST_DIR)) {
+    await rm(TEST_DIR, { recursive: true });
+  }
+  await mkdir(TEST_DIR, { recursive: true });
+
+  // Change to test directory
+  process.chdir(TEST_DIR);
+});
+
+afterEach(async () => {
+  // Go back to original directory and clean up
+  process.chdir(import.meta.dir);
+  if (existsSync(TEST_DIR)) {
+    await rm(TEST_DIR, { recursive: true });
+  }
+});
+
+test("hasLegacyTodoDir returns false when no todo/ exists", () => {
+  expect(hasLegacyTodoDir()).toBe(false);
+});
+
+test("hasLegacyTodoDir returns false when todo/ exists but is empty", async () => {
+  await mkdir(join(TEST_DIR, "todo"));
+  expect(hasLegacyTodoDir()).toBe(false);
+});
+
+test("hasLegacyTodoDir returns true when todo/ has TASKS.md", async () => {
+  await mkdir(join(TEST_DIR, "todo"));
+  await writeFile(join(TEST_DIR, "todo", "TASKS.md"), "# Tasks");
+  expect(hasLegacyTodoDir()).toBe(true);
+});
+
+test("hasLegacyTodoDir returns true when todo/ has PROMPT.md", async () => {
+  await mkdir(join(TEST_DIR, "todo"));
+  await writeFile(join(TEST_DIR, "todo", "PROMPT.md"), "# Prompt");
+  expect(hasLegacyTodoDir()).toBe(true);
+});
+
+test("hasLegacyTodoDir returns true when todo/ has LEARNINGS.md", async () => {
+  await mkdir(join(TEST_DIR, "todo"));
+  await writeFile(join(TEST_DIR, "todo", "LEARNINGS.md"), "# Learnings");
+  expect(hasLegacyTodoDir()).toBe(true);
+});
+
+test("hasNewTodoDir returns false when .math/todo/ does not exist", () => {
+  expect(hasNewTodoDir()).toBe(false);
+});
+
+test("hasNewTodoDir returns true when .math/todo/ exists", async () => {
+  await mkdir(join(TEST_DIR, ".math", "todo"), { recursive: true });
+  expect(hasNewTodoDir()).toBe(true);
+});
+
+test("migrateIfNeeded returns true when already migrated", async () => {
+  // Create new structure
+  await mkdir(join(TEST_DIR, ".math", "todo"), { recursive: true });
+
+  const result = await migrateIfNeeded();
+  expect(result).toBe(true);
+});
+
+test("migrateIfNeeded returns true when no legacy directory exists", async () => {
+  const result = await migrateIfNeeded();
+  expect(result).toBe(true);
+});
+
+// Tests for migration prompt and file moving require mocking readline
+// We test the migration behavior by directly calling the internal functions
+// Since promptForMigration is not exported, we test migrateIfNeeded end-to-end
+
+test("migrateIfNeeded moves files when user confirms (simulated)", async () => {
+  // Create legacy structure with files
+  const legacyDir = join(TEST_DIR, "todo");
+  await mkdir(legacyDir);
+  await writeFile(join(legacyDir, "TASKS.md"), "# Tasks\ncontent");
+  await writeFile(join(legacyDir, "PROMPT.md"), "# Prompt\ncontent");
+  await writeFile(join(legacyDir, "LEARNINGS.md"), "# Learnings\ncontent");
+
+  // Verify legacy exists
+  expect(hasLegacyTodoDir()).toBe(true);
+  expect(hasNewTodoDir()).toBe(false);
+
+  // Since we can't easily mock readline in bun tests, we verify
+  // the pre-conditions and post-conditions that file moving would achieve
+  // by manually performing what performMigration does
+  const { rename } = await import("node:fs/promises");
+  const mathDir = join(TEST_DIR, ".math");
+  const newTodoDir = join(TEST_DIR, ".math", "todo");
+
+  await mkdir(mathDir, { recursive: true });
+  await rename(legacyDir, newTodoDir);
+
+  // Verify migration completed
+  expect(hasLegacyTodoDir()).toBe(false);
+  expect(hasNewTodoDir()).toBe(true);
+  expect(existsSync(join(newTodoDir, "TASKS.md"))).toBe(true);
+  expect(existsSync(join(newTodoDir, "PROMPT.md"))).toBe(true);
+  expect(existsSync(join(newTodoDir, "LEARNINGS.md"))).toBe(true);
+});
+
+test("legacy directory with multiple files is correctly detected", async () => {
+  const legacyDir = join(TEST_DIR, "todo");
+  await mkdir(legacyDir);
+  await writeFile(join(legacyDir, "TASKS.md"), "# Tasks");
+  await writeFile(join(legacyDir, "PROMPT.md"), "# Prompt");
+  await writeFile(join(legacyDir, "LEARNINGS.md"), "# Learnings");
+
+  expect(hasLegacyTodoDir()).toBe(true);
+});
+
+test("legacy directory with unrelated files is not detected", async () => {
+  const legacyDir = join(TEST_DIR, "todo");
+  await mkdir(legacyDir);
+  await writeFile(join(legacyDir, "random.txt"), "random content");
+
+  expect(hasLegacyTodoDir()).toBe(false);
+});
+
+test("new todo directory detection is independent of file contents", async () => {
+  // .math/todo just needs to exist, no files required
+  await mkdir(join(TEST_DIR, ".math", "todo"), { recursive: true });
+  expect(hasNewTodoDir()).toBe(true);
+
+  // Even empty, it should be detected
+  expect(existsSync(join(TEST_DIR, ".math", "todo", "TASKS.md"))).toBe(false);
+});
+
+test("migration preserves file contents", async () => {
+  const legacyDir = join(TEST_DIR, "todo");
+  await mkdir(legacyDir);
+
+  const tasksContent = "# Tasks\n\n## Phase 1\n\n### task-1\n- content: Test task";
+  const promptContent = "# Prompt\n\nCustom prompt content here";
+  const learningsContent = "# Learnings\n\n## task-0\n- Learned something";
+
+  await writeFile(join(legacyDir, "TASKS.md"), tasksContent);
+  await writeFile(join(legacyDir, "PROMPT.md"), promptContent);
+  await writeFile(join(legacyDir, "LEARNINGS.md"), learningsContent);
+
+  // Perform migration manually (simulating user confirmation)
+  const { rename, readFile } = await import("node:fs/promises");
+  const newTodoDir = join(TEST_DIR, ".math", "todo");
+  await mkdir(join(TEST_DIR, ".math"), { recursive: true });
+  await rename(legacyDir, newTodoDir);
+
+  // Verify file contents are preserved
+  const migratedTasks = await readFile(join(newTodoDir, "TASKS.md"), "utf-8");
+  const migratedPrompt = await readFile(join(newTodoDir, "PROMPT.md"), "utf-8");
+  const migratedLearnings = await readFile(join(newTodoDir, "LEARNINGS.md"), "utf-8");
+
+  expect(migratedTasks).toBe(tasksContent);
+  expect(migratedPrompt).toBe(promptContent);
+  expect(migratedLearnings).toBe(learningsContent);
+});