@ktpartners/dgs-platform 2.8.0 → 3.0.4

package/deliver-great-systems/bin/lib/execution.cjs

@@ -9,11 +9,15 @@
 const fs = require('fs');
 const path = require('path');
 const { execGit, safeReadFile, loadConfig, output, error } = require('./core.cjs');
-const { getPlanningRoot } = require('./paths.cjs');
+const { getPlanningRoot, PROJECTS_DIR } = require('./paths.cjs');
 const { parseReposMd } = require('./repos.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { scanProjectReposTags } = require('./projects.cjs');
 
+// Lazy require to avoid circular dependency (context.cjs does not require execution.cjs,
+// but keeping it lazy is a safety practice for future refactoring).
+function _getResolveCodeContext() { return require('./context.cjs').resolveCodeContext; }
+
 // ─── Repo Path Resolution ───────────────────────────────────────────────────
 
 /**
@@ -24,7 +28,26 @@ const { scanProjectReposTags } = require('./projects.cjs');
  * @param {Array} repos - Parsed repos array (optional, loads from REPOS.md if not provided)
  * @returns {{ absPath: string, repo: Object } | null}
  */
-function resolveRepoPath(cwd, repoName, repos) {
+function resolveRepoPath(cwd, repoName, repos, useActiveContext) {
+  // If active context requested, resolve to worktree directory
+  if (useActiveContext) {
+    try {
+      const ctx = _getResolveCodeContext()(cwd, repoName);
+      if (ctx && ctx.type !== 'main') {
+        // Resolve the repo object for metadata (still need repo.name etc.)
+        if (!repos) {
+          const parsed = parseReposMd(cwd);
+          if (parsed) repos = parsed.repos;
+        }
+        const repo = repos ? repos.find(r => r.name === repoName) : null;
+        return { absPath: ctx.directory, repo: repo || { name: repoName, path: ctx.directory } };
+      }
+    } catch {
+      // Fall through to standard resolution
+    }
+  }
+
+  // Standard resolution via REPOS.md
   if (!repos) {
     const parsed = parseReposMd(cwd);
     if (!parsed) return null;
@@ -48,8 +71,8 @@ function resolveRepoPath(cwd, repoName, repos) {
  * @param {Array} repos - Parsed repos array (optional, loads from REPOS.md if not provided)
  * @returns {{ absFilePath: string, repoAbsPath: string, repo: Object } | null}
  */
-function resolveRepoRelativePath(cwd, repoName, relativePath, repos) {
-  const resolved = resolveRepoPath(cwd, repoName, repos);
+function resolveRepoRelativePath(cwd, repoName, relativePath, repos, useActiveContext) {
+  const resolved = resolveRepoPath(cwd, repoName, repos, useActiveContext);
   if (!resolved) return null;
   const absFilePath = path.join(resolved.absPath, relativePath);
   return { absFilePath, repoAbsPath: resolved.absPath, repo: resolved.repo };
@@ -65,14 +88,14 @@ function resolveRepoRelativePath(cwd, repoName, relativePath, repos) {
  * @param {string} [phaseDir] - Optional phase directory to check for partial SUMMARY.md
  * @returns {{ passed: boolean, dirty_repos: Array, partial_execution: Object|null, missing_repos: string[] }}
  */
-function preflightCheck(cwd, repoNames, phaseDir) {
+function preflightCheck(cwd, repoNames, phaseDir, useActiveContext) {
   const parsed = parseReposMd(cwd);
   const repos = parsed ? parsed.repos : [];
   const dirty_repos = [];
   const missing_repos = [];
 
   for (const name of repoNames) {
-    const resolved = resolveRepoPath(cwd, name, repos);
+    const resolved = resolveRepoPath(cwd, name, repos, useActiveContext);
     if (!resolved) {
       missing_repos.push(name);
       continue;
@@ -316,13 +339,13 @@ function buildPlanningCommitBody(repoResults) {
  * @param {string[]} repoNames - Repo names to check
  * @returns {Array<{repoName: string, repoPath: string, files: string[]}>}
  */
-function detectRepoChanges(cwd, repoNames) {
+function detectRepoChanges(cwd, repoNames, useActiveContext) {
   const parsed = parseReposMd(cwd);
   const repos = parsed ? parsed.repos : [];
   const changes = [];
 
   for (const name of repoNames) {
-    const resolved = resolveRepoPath(cwd, name, repos);
+    const resolved = resolveRepoPath(cwd, name, repos, useActiveContext);
     if (!resolved) continue;
     if (!fs.existsSync(resolved.absPath)) continue;
 
@@ -347,7 +370,7 @@ function detectRepoChanges(cwd, repoNames) {
     if (files.length > 0) {
       changes.push({
         repoName: name,
-        repoPath: resolved.repo.path,
+        repoPath: useActiveContext ? resolved.absPath : resolved.repo.path,
         files,
       });
     }
@@ -360,7 +383,6 @@ function detectRepoChanges(cwd, repoNames) {
 
 /**
  * Create branches in each repo for multi-repo execution.
- * Respects branching_strategy config — if 'none', skips branch creation.
  * Reuses existing branch if it already exists.
  * Detects branch prefix collisions and warns about potential ambiguity.
  *
@@ -375,15 +397,12 @@ function detectRepoChanges(cwd, repoNames) {
  * @param {string} cwd - Product root
  * @param {string[]} repoNames - Repo names
  * @param {string} branchName - Branch name (e.g., dgs/project/phase-slug)
- * @param {{ branching_strategy?: string }} config - Config object
+ * @param {object} [config] - Config object (legacy parameter, kept for backward compatibility)
  * @param {string|null} [baseBranch=null] - Base branch to checkout before creating new branch.
  *   When null/undefined, creates branch from wherever HEAD is (backwards-compatible behavior).
  * @returns {{ created: boolean, reason?: string, error?: string, repo?: string, branches?: Array<{repo: string, branch: string, action: string}>, warnings?: Array }}
  */
 function createRepoBranches(cwd, repoNames, branchName, config, baseBranch) {
-  if (config && config.branching_strategy === 'none') {
-    return { created: false, reason: 'branching_disabled' };
-  }
 
   const parsed = parseReposMd(cwd);
   const repos = parsed ? parsed.repos : [];
@@ -521,7 +540,7 @@ function updateRepoStatus(cwd, projectSlug, repoResults) {
   let statePath;
   const planRoot = getPlanningRoot(cwd);
   if (projectSlug) {
-    statePath = path.join(planRoot, projectSlug, 'STATE.md');
+    statePath = path.join(planRoot, PROJECTS_DIR, projectSlug, 'STATE.md');
   }
   if (!statePath || !fs.existsSync(statePath)) {
     statePath = path.join(planRoot, 'STATE.md');
@@ -622,8 +641,21 @@ function cmdCommitMultiRepo(cwd, options, raw) {
 
   const warnings = [];
 
+  // Determine whether to resolve repos against active worktree
+  let useActiveContext = false;
+  try {
+    const { getLocalConfigPath } = require('./config.cjs');
+    const localPath = getLocalConfigPath(cwd);
+    if (fs.existsSync(localPath)) {
+      const localCfg = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+      if (localCfg.execution && localCfg.execution.active_context) {
+        useActiveContext = true;
+      }
+    }
+  } catch { /* fall back to standard resolution */ }
+
   // Run preflight
-  const preflight = preflightCheck(cwd, repoNames, options.phaseDir || null);
+  const preflight = preflightCheck(cwd, repoNames, options.phaseDir || null, useActiveContext);
 
   // Missing repos is a hard error — block execution
   if (preflight.missing_repos && preflight.missing_repos.length > 0) {
@@ -649,7 +681,7 @@ function cmdCommitMultiRepo(cwd, options, raw) {
   }
 
   // Detect changes
-  const changes = detectRepoChanges(cwd, repoNames);
+  const changes = detectRepoChanges(cwd, repoNames, useActiveContext);
   if (changes.length === 0) {
     output({ success: true, message: 'No changes detected', commits: [], warnings }, raw);
     return;

package/deliver-great-systems/bin/lib/flat-migration.test.cjs

@@ -0,0 +1,396 @@
+/**
+ * Tests for migrateFlatStatus — flat status directory migration
+ *
+ * Phase 134 (v20.0): Migrates ideas/todos/jobs from state subdirectories
+ * to flat directories with frontmatter status fields.
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const { createTempDir, cleanupDir, writeFile, initGitRepo } = require('./test-helpers.cjs');
+const { migrateFlatStatus } = require('./migration.cjs');
+const { extractFrontmatter } = require('./frontmatter.cjs');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Creates a temp directory with git init, returns realpathSync'd path
+ * (macOS /var -> /private/var symlink fix from Phase 118).
+ */
+function makeGitDir() {
+  const tmpDir = createTempDir('flat-mig-test-');
+  initGitRepo(tmpDir);
+  return fs.realpathSync(tmpDir);
+}
+
+/**
+ * Creates a temp directory without git, returns realpathSync'd path.
+ */
+function makePlainDir() {
+  const tmpDir = createTempDir('flat-mig-test-');
+  return fs.realpathSync(tmpDir);
+}
+
+function gitCommitAll(dir, msg) {
+  const { execSync } = require('child_process');
+  execSync('git add -A', { cwd: dir, stdio: 'pipe' });
+  execSync(`git commit -m "${msg}" --allow-empty`, { cwd: dir, stdio: 'pipe' });
+}
+
+function readFile(dir, relPath) {
+  return fs.readFileSync(path.join(dir, relPath), 'utf-8');
+}
+
+function fileExists(dir, relPath) {
+  return fs.existsSync(path.join(dir, relPath));
+}
+
+/**
+ * Create a minimal idea file with frontmatter
+ */
+function makeIdea(id, title, opts = {}) {
+  const fm = [
+    '---',
+    `id: ${id}`,
+    `title: "${title}"`,
+  ];
+  if (opts.status) fm.push(`status: ${opts.status}`);
+  if (opts.consolidated_into) fm.push(`consolidated_into: "${opts.consolidated_into}"`);
+  if (opts.consolidated_from) {
+    fm.push('consolidated_from:');
+    for (const src of opts.consolidated_from) {
+      fm.push(`  - "${src}"`);
+    }
+  }
+  fm.push(`created: "2026-01-01T00:00:00Z"`);
+  fm.push(`updated: "2026-01-01T00:00:00Z"`);
+  fm.push('---');
+  fm.push('');
+  fm.push(`# ${title}`);
+  fm.push('');
+  fm.push(opts.body || 'Some idea content.');
+  if (opts.researchLog) {
+    fm.push('');
+    fm.push('## Research Log');
+    fm.push('');
+    fm.push(opts.researchLog);
+  }
+  return fm.join('\n') + '\n';
+}
+
+/**
+ * Create a minimal todo file (no frontmatter — tests that frontmatter gets added)
+ */
+function makeTodo(title) {
+  return `# ${title}\n\nSome todo content.\n`;
+}
+
+/**
+ * Create a minimal job file with bold-key Status header
+ */
+function makeJob(title, status) {
+  return `---\ntitle: "${title}"\n---\n\n# ${title}\n\n**Status:** ${status}\n\nJob details.\n`;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('migrateFlatStatus', () => {
+  let tmpDir;
+
+  afterEach(() => {
+    if (tmpDir) cleanupDir(tmpDir);
+  });
+
+  describe('idempotency', () => {
+    it('returns early when flat_status_migration_done is true', () => {
+      tmpDir = makePlainDir();
+      writeFile(tmpDir, 'config.local.json', JSON.stringify({ flat_status_migration_done: true }));
+      const result = migrateFlatStatus(tmpDir);
+      assert.equal(result.migrated, false);
+      assert.equal(result.actions.length, 0);
+    });
+
+    it('sets flag and returns when no legacy files exist', () => {
+      tmpDir = makePlainDir();
+      writeFile(tmpDir, 'ideas/001-test.md', makeIdea(1, 'Test', { status: 'pending' }));
+      const result = migrateFlatStatus(tmpDir);
+      assert.equal(result.migrated, false);
+      assert.equal(result.actions.length, 0);
+      const config = JSON.parse(readFile(tmpDir, 'config.local.json'));
+      assert.equal(config.flat_status_migration_done, true);
+    });
+  });
+
+  describe('dry-run mode', () => {
+    it('returns actions without modifying files', () => {
+      tmpDir = makePlainDir();
+      writeFile(tmpDir, 'ideas/pending/001-test.md', makeIdea(1, 'Test'));
+
+      const result = migrateFlatStatus(tmpDir);
+
+      assert.equal(result.dryRun, true);
+      assert.equal(result.migrated, false);
+      assert.ok(result.actions.length > 0, 'should have actions');
+      assert.equal(result.filesMoved, 1);
+      // File should NOT have been moved
+      assert.ok(fileExists(tmpDir, 'ideas/pending/001-test.md'), 'original file should still exist');
+      assert.ok(!fileExists(tmpDir, 'ideas/001-test.md'), 'destination should not exist');
+    });
+
+    it('reports correct counts for multi-subsystem migration', () => {
+      tmpDir = makePlainDir();
+      writeFile(tmpDir, 'ideas/pending/001-idea.md', makeIdea(1, 'Idea'));
+      writeFile(tmpDir, 'ideas/done/002-done-idea.md', makeIdea(2, 'Done Idea'));
+      writeFile(tmpDir, 'todos/pending/todo-1.md', makeTodo('Todo 1'));
+      writeFile(tmpDir, 'jobs/completed/job-v1.md', makeJob('Job v1', 'completed'));
+
+      const result = migrateFlatStatus(tmpDir);
+
+      assert.equal(result.dryRun, true);
+      assert.equal(result.filesMoved, 4);
+      assert.equal(result.statusFieldsAdded, 4);
+    });
+  });
+
+  describe('apply mode', () => {
+    it('moves idea files and adds status frontmatter', () => {
+      tmpDir = makeGitDir();
+      writeFile(tmpDir, 'ideas/pending/001-test.md', makeIdea(1, 'Test'));
+      writeFile(tmpDir, 'ideas/done/002-shipped.md', makeIdea(2, 'Shipped'));
+      gitCommitAll(tmpDir, 'add ideas');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+      assert.equal(result.dryRun, false);
+      assert.ok(result.commitHash, 'should have commit hash');
+
+      // Files moved to flat directory
+      assert.ok(fileExists(tmpDir, 'ideas/001-test.md'), 'idea should be in flat dir');
+      assert.ok(fileExists(tmpDir, 'ideas/002-shipped.md'), 'done idea should be in flat dir');
+      assert.ok(!fileExists(tmpDir, 'ideas/pending/001-test.md'), 'original should be gone');
+      assert.ok(!fileExists(tmpDir, 'ideas/done/002-shipped.md'), 'original should be gone');
+
+      // Status frontmatter added
+      const pendingContent = readFile(tmpDir, 'ideas/001-test.md');
+      const pendingFm = extractFrontmatter(pendingContent);
+      assert.equal(pendingFm.status, 'pending');
+
+      const doneContent = readFile(tmpDir, 'ideas/002-shipped.md');
+      const doneFm = extractFrontmatter(doneContent);
+      assert.equal(doneFm.status, 'done');
+    });
+
+    it('maps todo states correctly (completed -> done, resolved -> done)', () => {
+      tmpDir = makeGitDir();
+      writeFile(tmpDir, 'todos/pending/todo-1.md', makeTodo('Pending Todo'));
+      writeFile(tmpDir, 'todos/completed/todo-2.md', makeTodo('Completed Todo'));
+      writeFile(tmpDir, 'todos/done/todo-3.md', makeTodo('Done Todo'));
+      writeFile(tmpDir, 'todos/resolved/todo-4.md', makeTodo('Resolved Todo'));
+      gitCommitAll(tmpDir, 'add todos');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+
+      // All files in flat dir
+      assert.ok(fileExists(tmpDir, 'todos/todo-1.md'));
+      assert.ok(fileExists(tmpDir, 'todos/todo-2.md'));
+      assert.ok(fileExists(tmpDir, 'todos/todo-3.md'));
+      assert.ok(fileExists(tmpDir, 'todos/todo-4.md'));
+
+      // Status mappings correct
+      const todo1 = extractFrontmatter(readFile(tmpDir, 'todos/todo-1.md'));
+      assert.equal(todo1.status, 'pending');
+      const todo2 = extractFrontmatter(readFile(tmpDir, 'todos/todo-2.md'));
+      assert.equal(todo2.status, 'done');
+      const todo3 = extractFrontmatter(readFile(tmpDir, 'todos/todo-3.md'));
+      assert.equal(todo3.status, 'done');
+      const todo4 = extractFrontmatter(readFile(tmpDir, 'todos/todo-4.md'));
+      assert.equal(todo4.status, 'done');
+    });
+
+    it('flattens research docs and updates path references in ideas', () => {
+      tmpDir = makeGitDir();
+      const ideaWithResearch = makeIdea(5, 'Research Idea', {
+        researchLog: '**Document:** docs/ideas/pending/research-idea-research.md\n**Date:** 2026-01-01'
+      });
+      writeFile(tmpDir, 'ideas/pending/005-research-idea.md', ideaWithResearch);
+      writeFile(tmpDir, 'docs/ideas/pending/research-idea-research.md', '# Research\n\nFindings here.\n');
+      gitCommitAll(tmpDir, 'add research');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+
+      // Research doc flattened
+      assert.ok(fileExists(tmpDir, 'docs/ideas/research-idea-research.md'), 'research doc in flat dir');
+      assert.ok(!fileExists(tmpDir, 'docs/ideas/pending/research-idea-research.md'), 'research doc removed from state dir');
+
+      // Path reference updated in idea
+      const ideaContent = readFile(tmpDir, 'ideas/005-research-idea.md');
+      assert.ok(ideaContent.includes('docs/ideas/research-idea-research.md'), 'path should be flat');
+      assert.ok(!ideaContent.includes('docs/ideas/pending/research-idea-research.md'), 'state path should be gone');
+    });
+
+    it('normalizes consolidated_into and consolidated_from paths', () => {
+      tmpDir = makeGitDir();
+      const consolidatedIdea = makeIdea(3, 'Old Idea', {
+        consolidated_into: 'ideas/pending/010-merged.md'
+      });
+      const mergedIdea = makeIdea(10, 'Merged', {
+        consolidated_from: ['ideas/pending/003-old-idea.md', 'ideas/done/004-another.md']
+      });
+      writeFile(tmpDir, 'ideas/consolidated/003-old-idea.md', consolidatedIdea);
+      writeFile(tmpDir, 'ideas/pending/010-merged.md', mergedIdea);
+      gitCommitAll(tmpDir, 'add consolidated');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+      assert.ok(result.pathsNormalized > 0, 'should have normalized paths');
+
+      // Check consolidated_into normalized
+      const oldContent = readFile(tmpDir, 'ideas/003-old-idea.md');
+      assert.ok(!oldContent.includes('ideas/pending/'), 'should not have state dir in path');
+      assert.ok(oldContent.includes('ideas/010-merged.md'), 'should have flat path');
+
+      // Check consolidated_from normalized
+      const mergedContent = readFile(tmpDir, 'ideas/010-merged.md');
+      assert.ok(!mergedContent.includes('ideas/pending/003'), 'should not have state dir');
+      assert.ok(!mergedContent.includes('ideas/done/004'), 'should not have state dir');
+    });
+
+    it('validates file count (no data loss)', () => {
+      tmpDir = makeGitDir();
+      writeFile(tmpDir, 'ideas/pending/001-a.md', makeIdea(1, 'A'));
+      writeFile(tmpDir, 'ideas/done/002-b.md', makeIdea(2, 'B'));
+      writeFile(tmpDir, 'ideas/rejected/003-c.md', makeIdea(3, 'C'));
+      gitCommitAll(tmpDir, 'add ideas');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+      assert.equal(result.filesMoved, 3);
+
+      // Count files in flat dir (should be 3 ideas)
+      const flatFiles = fs.readdirSync(path.join(tmpDir, 'ideas')).filter(f => f.endsWith('.md'));
+      assert.equal(flatFiles.length, 3, 'all 3 ideas should be in flat dir');
+    });
+
+    it('handles jobs with dual-write status (frontmatter + bold-key header)', () => {
+      tmpDir = makeGitDir();
+      writeFile(tmpDir, 'jobs/completed/milestone-v5.md', makeJob('v5 Build', 'completed'));
+      writeFile(tmpDir, 'jobs/in-progress/milestone-v6.md', makeJob('v6 Build', 'in-progress'));
+      gitCommitAll(tmpDir, 'add jobs');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+
+      // Check frontmatter status
+      const v5Content = readFile(tmpDir, 'jobs/milestone-v5.md');
+      const v5Fm = extractFrontmatter(v5Content);
+      assert.equal(v5Fm.status, 'completed');
+
+      // Check bold-key header still present
+      assert.ok(v5Content.includes('**Status:** completed'), 'bold-key header should be updated');
+
+      const v6Content = readFile(tmpDir, 'jobs/milestone-v6.md');
+      const v6Fm = extractFrontmatter(v6Content);
+      assert.equal(v6Fm.status, 'in-progress');
+      assert.ok(v6Content.includes('**Status:** in-progress'), 'bold-key header should be updated');
+    });
+  });
+
+  describe('realistic project fixtures', () => {
+    it('handles fc-like project (done ideas, research docs, pending todos, completed jobs)', () => {
+      tmpDir = makeGitDir();
+
+      // fc-like: 7 done ideas, 5 pending ideas, 11 pending todos, 1 resolved todo, 10 completed jobs, 1 research doc
+      for (let i = 1; i <= 7; i++) {
+        writeFile(tmpDir, `ideas/done/00${i}-done-idea-${i}.md`, makeIdea(i, `Done Idea ${i}`));
+      }
+      for (let i = 8; i <= 12; i++) {
+        writeFile(tmpDir, `ideas/pending/0${i}-pending-idea-${i}.md`, makeIdea(i, `Pending Idea ${i}`));
+      }
+
+      for (let i = 1; i <= 11; i++) {
+        writeFile(tmpDir, `todos/pending/todo-${i}.md`, makeTodo(`Todo ${i}`));
+      }
+      writeFile(tmpDir, 'todos/resolved/todo-resolved.md', makeTodo('Resolved Todo'));
+
+      for (let i = 1; i <= 10; i++) {
+        writeFile(tmpDir, `jobs/completed/milestone-v${i}.md`, makeJob(`v${i} Build`, 'completed'));
+      }
+
+      writeFile(tmpDir, 'docs/ideas/pending/research-doc.md', '# Research\n\nContent.\n');
+
+      gitCommitAll(tmpDir, 'init');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+      // 7 done + 5 pending ideas + 12 todos + 10 jobs + 1 research = 35
+      assert.equal(result.filesMoved, 35);
+
+      // Spot check: done idea has status field
+      const doneIdea = readFile(tmpDir, 'ideas/001-done-idea-1.md');
+      assert.ok(doneIdea.includes('status: done'), 'done idea should have status: done');
+
+      // Resolved todo mapped to done
+      const resolvedTodo = readFile(tmpDir, 'todos/todo-resolved.md');
+      const resolvedFm = extractFrontmatter(resolvedTodo);
+      assert.equal(resolvedFm.status, 'done');
+
+      // Research doc flattened
+      assert.ok(fileExists(tmpDir, 'docs/ideas/research-doc.md'));
+      assert.ok(!fileExists(tmpDir, 'docs/ideas/pending/research-doc.md'));
+    });
+
+    it('handles gsd-like project (mixed todo states, in-progress job)', () => {
+      tmpDir = makeGitDir();
+
+      // gsd-like: 4 done ideas, 5 pending ideas, mixed todos, 1 in-progress job
+      for (let i = 1; i <= 4; i++) {
+        writeFile(tmpDir, `ideas/done/00${i}-done-${i}.md`, makeIdea(i, `Done ${i}`));
+      }
+      for (let i = 5; i <= 9; i++) {
+        writeFile(tmpDir, `ideas/pending/00${i}-pending-${i}.md`, makeIdea(i, `Pending ${i}`));
+      }
+
+      for (let i = 1; i <= 17; i++) {
+        writeFile(tmpDir, `todos/pending/todo-p${i}.md`, makeTodo(`Pending ${i}`));
+      }
+      for (let i = 1; i <= 4; i++) {
+        writeFile(tmpDir, `todos/completed/todo-c${i}.md`, makeTodo(`Completed ${i}`));
+      }
+      for (let i = 1; i <= 9; i++) {
+        writeFile(tmpDir, `todos/done/todo-d${i}.md`, makeTodo(`Done ${i}`));
+      }
+
+      writeFile(tmpDir, 'jobs/in-progress/milestone-v20.md', makeJob('v20 Build', 'in-progress'));
+      writeFile(tmpDir, 'jobs/completed/milestone-v19.md', makeJob('v19 Build', 'completed'));
+
+      gitCommitAll(tmpDir, 'init');
+
+      const result = migrateFlatStatus(tmpDir, { apply: true });
+
+      assert.equal(result.migrated, true);
+      // 4 done + 5 pending ideas + 17 pending + 4 completed + 9 done todos + 2 jobs = 41
+      assert.equal(result.filesMoved, 41);
+
+      // All todos in flat dir with correct status
+      const completedTodo = readFile(tmpDir, 'todos/todo-c1.md');
+      const completedFm = extractFrontmatter(completedTodo);
+      assert.equal(completedFm.status, 'done', 'completed -> done');
+
+      const doneTodo = readFile(tmpDir, 'todos/todo-d1.md');
+      const doneFm = extractFrontmatter(doneTodo);
+      assert.equal(doneFm.status, 'done', 'done -> done');
+    });
+  });
+});