@ktpartners/dgs-platform 2.6.2

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

@@ -0,0 +1,582 @@
+/**
+ * Tests for migration.cjs — v1-to-v2 migration with git mv history preservation
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const { createTempDir, cleanupDir, writeFile, initGitRepo } = require('./test-helpers.cjs');
+
+// Helper to create a v1 install structure and commit it
+function createV1Install(dir, projectName) {
+  writeFile(dir, '.planning/PROJECT.md', `# Project: ${projectName}\n\nA test project.\n`);
+  writeFile(dir, '.planning/REQUIREMENTS.md', `# Requirements\n\n## Functional\n\n- REQ-01: Do something\n`);
+  writeFile(dir, '.planning/ROADMAP.md', `# Roadmap\n\n## Phase 1\n\nDo things.\n`);
+  writeFile(dir, '.planning/STATE.md', `# Project State\n\nPhase: 1\nStatus: Ready\nProgress: [░░░░░░░░░░] 0%\n`);
+  writeFile(dir, '.planning/config.json', '{"model_profile":"balanced"}');
+  writeFile(dir, '.planning/phases/01-setup/01-01-PLAN.md', '---\nphase: 01\n---\n');
+  writeFile(dir, '.planning/research/notes.md', '# Research Notes\n');
+  execSync('git add .', { cwd: dir, stdio: 'pipe' });
+  execSync('git commit -m "v1 install"', { cwd: dir, stdio: 'pipe' });
+}
+
+const {
+  detectV1Install,
+  validateMigrationPreconditions,
+  createBackupTag,
+  collectMigrationMoves,
+  validateMoves,
+  migrateV1ToV2,
+} = require('./migration.cjs');
+
+// ─── detectV1Install ─────────────────────────────────────────────────────────
+
+describe('detectV1Install', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('returns isV1 true when PROJECT.md exists but no PROJECTS.md or REPOS.md', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: My Cool App\n');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, true);
+    assert.strictEqual(result.projectName, 'My Cool App');
+    assert.strictEqual(result.slug, 'my-cool-app');
+  });
+
+  it('returns isV1 false when already v2 (PROJECTS.md exists)', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    writeFile(tmpDir, '.planning/PROJECTS.md', '# Projects\n');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, false);
+  });
+
+  it('returns isV1 false when already v2 (REPOS.md exists)', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    writeFile(tmpDir, '.planning/REPOS.md', '# Repos\n');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, false);
+  });
+
+  it('returns isV1 false when no .planning directory exists', () => {
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, false);
+  });
+
+  it('returns isV1 false when .planning exists but no PROJECT.md', () => {
+    fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true });
+    writeFile(tmpDir, '.planning/config.json', '{}');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, false);
+  });
+
+  it('extracts project name from "# Project: Name" heading', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Auth Overhaul\n\nDetails here.\n');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.projectName, 'Auth Overhaul');
+    assert.strictEqual(result.slug, 'auth-overhaul');
+  });
+
+  it('falls back to directory name if no heading found', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', 'Random content without heading\n');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, true);
+    // slug should be derived from the directory basename
+    assert.ok(result.slug);
+    assert.ok(result.slug.length > 0);
+  });
+
+  it('handles PROJECT.md with "# Project Name" (no colon) heading', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project Name\n\nSome project.\n');
+    const result = detectV1Install(tmpDir);
+    assert.strictEqual(result.isV1, true);
+    // Should parse the heading somehow
+    assert.ok(result.slug);
+  });
+});
+
+// ─── validateMigrationPreconditions ──────────────────────────────────────────
+
+describe('validateMigrationPreconditions', () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    initGitRepo(tmpDir);
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('passes when v1 install with clean working tree', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    execSync('git add .', { cwd: tmpDir, stdio: 'pipe' });
+    execSync('git commit -m "add planning"', { cwd: tmpDir, stdio: 'pipe' });
+    const result = validateMigrationPreconditions(tmpDir);
+    assert.strictEqual(result.valid, true);
+  });
+
+  it('fails when working tree has uncommitted changes', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    // Don't commit — dirty tree
+    const result = validateMigrationPreconditions(tmpDir);
+    assert.strictEqual(result.valid, false);
+    assert.ok(result.reason.toLowerCase().includes('uncommitted') || result.reason.toLowerCase().includes('dirty') || result.reason.toLowerCase().includes('clean'));
+  });
+
+  it('fails when already v2 install', () => {
+    writeFile(tmpDir, '.planning/PROJECTS.md', '# Projects\n');
+    writeFile(tmpDir, '.planning/REPOS.md', '# Repos\n');
+    execSync('git add .', { cwd: tmpDir, stdio: 'pipe' });
+    execSync('git commit -m "v2"', { cwd: tmpDir, stdio: 'pipe' });
+    const result = validateMigrationPreconditions(tmpDir);
+    assert.strictEqual(result.valid, false);
+    assert.ok(result.reason.toLowerCase().includes('v2') || result.reason.toLowerCase().includes('already'));
+  });
+
+  it('fails when no .planning/PROJECT.md exists', () => {
+    const result = validateMigrationPreconditions(tmpDir);
+    assert.strictEqual(result.valid, false);
+  });
+});
+
+// ─── createBackupTag ─────────────────────────────────────────────────────────
+
+describe('createBackupTag', () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    initGitRepo(tmpDir);
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('creates dgs-pre-v2-migration tag successfully', () => {
+    const result = createBackupTag(tmpDir);
+    assert.strictEqual(result.tagged, true);
+    // Verify tag actually exists
+    const tags = execSync('git tag', { cwd: tmpDir, encoding: 'utf-8' }).trim();
+    assert.ok(tags.includes('dgs-pre-v2-migration'));
+  });
+
+  it('returns tagged false if tag already exists', () => {
+    execSync('git tag dgs-pre-v2-migration', { cwd: tmpDir, stdio: 'pipe' });
+    const result = createBackupTag(tmpDir);
+    assert.strictEqual(result.tagged, false);
+    assert.ok(result.reason);
+  });
+
+  it('returns tagged false if not a git repo', () => {
+    const noGitDir = createTempDir();
+    try {
+      const result = createBackupTag(noGitDir);
+      assert.strictEqual(result.tagged, false);
+      assert.ok(result.reason);
+    } finally {
+      cleanupDir(noGitDir);
+    }
+  });
+});
+
+// ─── migrateV1ToV2 ──────────────────────────────────────────────────────────
+
+describe('migrateV1ToV2', () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    initGitRepo(tmpDir);
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('moves PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md into project subfolder', () => {
+    createV1Install(tmpDir, 'Test App');
+    const result = migrateV1ToV2(tmpDir, 'test-app');
+    assert.strictEqual(result.migrated, true);
+    assert.strictEqual(result.slug, 'test-app');
+
+    // Files should exist in new location
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'PROJECT.md')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'REQUIREMENTS.md')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'ROADMAP.md')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'STATE.md')));
+
+    // Files should NOT exist in old location
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'PROJECT.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'REQUIREMENTS.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'ROADMAP.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'STATE.md')));
+  });
+
+  it('moves phases/ directory into project subfolder', () => {
+    createV1Install(tmpDir, 'Test App');
+    const result = migrateV1ToV2(tmpDir, 'test-app');
+    assert.strictEqual(result.migrated, true);
+
+    // phases/ should exist in new location
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'phases', '01-setup', '01-01-PLAN.md')));
+    // phases/ should NOT exist in old location
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'phases')));
+  });
+
+  it('moves research/ directory into project subfolder', () => {
+    createV1Install(tmpDir, 'Test App');
+    const result = migrateV1ToV2(tmpDir, 'test-app');
+    assert.strictEqual(result.migrated, true);
+
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'research', 'notes.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'research')));
+  });
+
+  it('skips files/dirs that do not exist (partial v1 install)', () => {
+    // Create minimal v1 install with only PROJECT.md and STATE.md
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Minimal\n');
+    writeFile(tmpDir, '.planning/STATE.md', '# Project State\n\nPhase: 1\nStatus: Ready\nProgress: [░░░░░░░░░░] 0%\n');
+    writeFile(tmpDir, '.planning/config.json', '{}');
+    execSync('git add .', { cwd: tmpDir, stdio: 'pipe' });
+    execSync('git commit -m "partial v1"', { cwd: tmpDir, stdio: 'pipe' });
+
+    const result = migrateV1ToV2(tmpDir, 'minimal');
+    assert.strictEqual(result.migrated, true);
+    // Moved files should be in new location
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'minimal', 'PROJECT.md')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'minimal', 'STATE.md')));
+    // Skipped files should not cause errors
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'minimal', 'REQUIREMENTS.md')));
+  });
+
+  it('does NOT move config.json (product-level)', () => {
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    // config.json should remain at .planning/config.json
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'config.json')));
+    // config.json should NOT be in project subfolder
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'config.json')));
+  });
+
+  it('does NOT move codebase/ directory (product-level)', () => {
+    writeFile(tmpDir, '.planning/codebase/overview.md', '# Codebase\n');
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    // codebase/ should remain at product level
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'codebase', 'overview.md')));
+  });
+
+  it('does NOT move milestones/ directory (product-level)', () => {
+    writeFile(tmpDir, '.planning/milestones/v1.0.md', '# Milestone v1.0\n');
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    // milestones/ should remain at product level
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'milestones', 'v1.0.md')));
+  });
+
+  it('creates REPOS.md with current directory as single repo', () => {
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    const reposMdPath = path.join(tmpDir, '.planning', 'REPOS.md');
+    assert.ok(fs.existsSync(reposMdPath));
+    const content = fs.readFileSync(reposMdPath, 'utf-8');
+    assert.ok(content.startsWith('# Repos'));
+    assert.ok(content.includes('.'));  // path is '.'
+  });
+
+  it('creates PROJECTS.md from migrated project', () => {
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    const projectsMdPath = path.join(tmpDir, '.planning', 'PROJECTS.md');
+    assert.ok(fs.existsSync(projectsMdPath));
+    const content = fs.readFileSync(projectsMdPath, 'utf-8');
+    assert.ok(content.startsWith('# Projects'));
+  });
+
+  it('sets current_project in config.json', () => {
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    const configPath = path.join(tmpDir, '.planning', 'dgs.config.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    assert.strictEqual(config.current_project, 'test-app');
+  });
+
+  it('returns structured result with files_moved', () => {
+    createV1Install(tmpDir, 'Test App');
+    const result = migrateV1ToV2(tmpDir, 'test-app');
+    assert.strictEqual(result.migrated, true);
+    assert.strictEqual(result.slug, 'test-app');
+    assert.ok(Array.isArray(result.files_moved));
+    assert.ok(result.files_moved.length > 0);
+    assert.strictEqual(result.repos_created, true);
+    assert.strictEqual(result.project_created, true);
+  });
+
+  it('uses git mv to preserve history', () => {
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    // Check git log for the moved files — git should show rename detection
+    const log = execSync('git log --diff-filter=R --summary --format="" HEAD', {
+      cwd: tmpDir,
+      encoding: 'utf-8',
+    }).trim();
+    // Should have rename entries
+    assert.ok(log.includes('rename'));
+  });
+
+  it('moves todos/ directory if it exists', () => {
+    writeFile(tmpDir, '.planning/todos/pending/task1.md', '# Todo 1\n');
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'todos', 'pending', 'task1.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'todos')));
+  });
+
+  it('moves quick/ directory if it exists', () => {
+    writeFile(tmpDir, '.planning/quick/fix1.md', '# Quick Fix\n');
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'quick', 'fix1.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'quick')));
+  });
+
+  it('moves debug/ directory if it exists', () => {
+    writeFile(tmpDir, '.planning/debug/issue1.md', '# Debug Session\n');
+    createV1Install(tmpDir, 'Test App');
+    migrateV1ToV2(tmpDir, 'test-app');
+
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'debug', 'issue1.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'debug')));
+  });
+});
+
+// ─── collectMigrationMoves ──────────────────────────────────────────────────
+
+describe('collectMigrationMoves', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('returns correct move entries for a full v1 install', () => {
+    // Create a full v1 install (without git — just files on disk)
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    writeFile(tmpDir, '.planning/REQUIREMENTS.md', '# Requirements\n');
+    writeFile(tmpDir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(tmpDir, '.planning/STATE.md', '# State\n');
+    writeFile(tmpDir, '.planning/phases/01-setup/01-01-PLAN.md', '---\n---\n');
+    writeFile(tmpDir, '.planning/research/notes.md', '# Notes\n');
+
+    const { moves, targetDir } = collectMigrationMoves(tmpDir, 'test-app');
+
+    // Should have 2 directories + 4 files = 6 moves
+    assert.strictEqual(moves.length, 6);
+    assert.ok(targetDir.endsWith(path.join('.planning', 'projects', 'test-app')));
+
+    // Directories should come first
+    const dirMoves = moves.filter(m => m.isDir);
+    const fileMoves = moves.filter(m => !m.isDir);
+    assert.strictEqual(dirMoves.length, 2); // phases, research
+    assert.strictEqual(fileMoves.length, 4); // PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md
+
+    // First moves should be dirs
+    assert.strictEqual(moves[0].isDir, true);
+    assert.strictEqual(moves[1].isDir, true);
+  });
+
+  it('omits entries for non-existent items (partial v1 install)', () => {
+    // Create only PROJECT.md and STATE.md
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Partial\n');
+    writeFile(tmpDir, '.planning/STATE.md', '# State\n');
+
+    const { moves } = collectMigrationMoves(tmpDir, 'partial');
+
+    // Should have only 2 moves (the 2 files that exist)
+    assert.strictEqual(moves.length, 2);
+    assert.ok(moves.every(m => !m.isDir));
+    const sources = moves.map(m => path.basename(m.relSource));
+    assert.ok(sources.includes('PROJECT.md'));
+    assert.ok(sources.includes('STATE.md'));
+  });
+
+  it('sets isDir flag correctly for directories and files', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    writeFile(tmpDir, '.planning/phases/01-setup/01-01-PLAN.md', '---\n---\n');
+    writeFile(tmpDir, '.planning/research/notes.md', '# Notes\n');
+    writeFile(tmpDir, '.planning/todos/pending/task.md', '# Todo\n');
+
+    const { moves } = collectMigrationMoves(tmpDir, 'test');
+
+    const phasesMove = moves.find(m => m.relSource.endsWith('phases'));
+    const researchMove = moves.find(m => m.relSource.endsWith('research'));
+    const todosMove = moves.find(m => m.relSource.endsWith('todos'));
+    const projectMove = moves.find(m => m.relSource.endsWith('PROJECT.md'));
+
+    assert.strictEqual(phasesMove.isDir, true);
+    assert.strictEqual(researchMove.isDir, true);
+    assert.strictEqual(todosMove.isDir, true);
+    assert.strictEqual(projectMove.isDir, false);
+  });
+});
+
+// ─── validateMoves ──────────────────────────────────────────────────────────
+
+describe('validateMoves', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('returns valid when all sources exist and no targets exist', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    writeFile(tmpDir, '.planning/STATE.md', '# State\n');
+
+    const moves = [
+      { relSource: '.planning/PROJECT.md', relTarget: '.planning/test/PROJECT.md', isDir: false },
+      { relSource: '.planning/STATE.md', relTarget: '.planning/test/STATE.md', isDir: false },
+    ];
+
+    const result = validateMoves(tmpDir, moves);
+    assert.strictEqual(result.valid, true);
+    assert.strictEqual(result.errors.length, 0);
+  });
+
+  it('returns invalid when target already exists', () => {
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
+    // Pre-create a target that would collide
+    writeFile(tmpDir, '.planning/test/PROJECT.md', '# Already here\n');
+
+    const moves = [
+      { relSource: '.planning/PROJECT.md', relTarget: '.planning/test/PROJECT.md', isDir: false },
+    ];
+
+    const result = validateMoves(tmpDir, moves);
+    assert.strictEqual(result.valid, false);
+    assert.ok(result.errors.length > 0);
+    assert.ok(result.errors[0].includes('Target already exists'));
+  });
+});
+
+// ─── Rollback on git mv failure ─────────────────────────────────────────────
+
+describe('migrateV1ToV2 rollback', () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    initGitRepo(tmpDir);
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('returns migrated false and rolls back when git mv fails mid-migration', () => {
+    createV1Install(tmpDir, 'Test App');
+
+    // Create a file at the target path for phases/ to force git mv to fail.
+    // The phases/ dir move will fail because the target .planning/bad-slug/phases
+    // already exists as a FILE, preventing the directory move.
+    const targetPhasesPath = path.join(tmpDir, '.planning', 'projects', 'bad-slug', 'phases');
+    fs.mkdirSync(path.join(tmpDir, '.planning', 'projects', 'bad-slug'), { recursive: true });
+    fs.writeFileSync(targetPhasesPath, 'blocker file');
+    execSync('git add .', { cwd: tmpDir, stdio: 'pipe' });
+    execSync('git commit -m "add blocker"', { cwd: tmpDir, stdio: 'pipe' });
+
+    const result = migrateV1ToV2(tmpDir, 'bad-slug');
+
+    // Should report validation failure (target already exists)
+    assert.strictEqual(result.migrated, false);
+    assert.ok(result.error);
+  });
+
+  it('restores original files after rollback from git mv failure', () => {
+    createV1Install(tmpDir, 'Test App');
+
+    // Force a validation failure by creating a conflicting target
+    const targetProjectPath = path.join(tmpDir, '.planning', 'projects', 'fail-slug', 'PROJECT.md');
+    fs.mkdirSync(path.join(tmpDir, '.planning', 'projects', 'fail-slug'), { recursive: true });
+    fs.writeFileSync(targetProjectPath, 'conflict');
+    execSync('git add .', { cwd: tmpDir, stdio: 'pipe' });
+    execSync('git commit -m "add conflict"', { cwd: tmpDir, stdio: 'pipe' });
+
+    migrateV1ToV2(tmpDir, 'fail-slug');
+
+    // Original files should still exist (validation catches it before any moves)
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'PROJECT.md')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'STATE.md')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'phases', '01-setup', '01-01-PLAN.md')));
+  });
+});
+
+// ─── Scale test: 50+ files with rename detection ────────────────────────────
+
+describe('migrateV1ToV2 scale test', () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    initGitRepo(tmpDir);
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('migrates 60+ phase files and git detects renames with renameLimit=1000', () => {
+    // Create base v1 install files
+    writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Scale Test\n\nA large project.\n');
+    writeFile(tmpDir, '.planning/REQUIREMENTS.md', '# Requirements\n\n- REQ-01\n');
+    writeFile(tmpDir, '.planning/ROADMAP.md', '# Roadmap\n\n## Phase 1\n');
+    writeFile(tmpDir, '.planning/STATE.md', '# Project State\n\nPhase: 1\nStatus: Active\nProgress: [░░░░░░░░░░] 0%\n');
+    writeFile(tmpDir, '.planning/config.json', '{"model_profile":"balanced"}');
+
+    // Create 60 plan files across 10 phases (6 files each)
+    for (let phase = 1; phase <= 10; phase++) {
+      const phaseNum = String(phase).padStart(2, '0');
+      const phaseName = phaseNum + '-phase-' + phase;
+      for (let plan = 1; plan <= 6; plan++) {
+        const planNum = String(plan).padStart(2, '0');
+        const filename = phaseNum + '-' + planNum + '-PLAN.md';
+        writeFile(
+          tmpDir,
+          '.planning/phases/' + phaseName + '/' + filename,
+          '---\nphase: ' + phaseNum + '\nplan: ' + planNum + '\n---\n\n# Plan ' + phaseNum + '-' + planNum + '\n\nContent for plan ' + phase + '.' + plan + '\n'
+        );
+      }
+    }
+
+    // Commit the v1 install
+    execSync('git add .', { cwd: tmpDir, stdio: 'pipe' });
+    execSync('git commit -m "v1 install with 60 plan files"', { cwd: tmpDir, stdio: 'pipe' });
+
+    // Run migration
+    const result = migrateV1ToV2(tmpDir, 'scale-test');
+    assert.strictEqual(result.migrated, true);
+
+    // Verify all 60 plan files exist in new location
+    let foundCount = 0;
+    for (let phase = 1; phase <= 10; phase++) {
+      const phaseNum = String(phase).padStart(2, '0');
+      const phaseName = phaseNum + '-phase-' + phase;
+      for (let plan = 1; plan <= 6; plan++) {
+        const planNum = String(plan).padStart(2, '0');
+        const filename = phaseNum + '-' + planNum + '-PLAN.md';
+        const filePath = path.join(tmpDir, '.planning', 'projects', 'scale-test', 'phases', phaseName, filename);
+        if (fs.existsSync(filePath)) {
+          foundCount++;
+        }
+      }
+    }
+    assert.strictEqual(foundCount, 60, 'All 60 plan files should be in new location');
+
+    // Verify git detects renames (not delete+add)
+    // Look at the migration commit (HEAD~1 is the move commit, HEAD is the markers commit)
+    const renameLog = execSync(
+      'git log --diff-filter=R --summary --format="" HEAD~1',
+      { cwd: tmpDir, encoding: 'utf-8' }
+    ).trim();
+    assert.ok(renameLog.includes('rename'), 'Git should detect renames in the migration commit');
+
+    // Count rename entries — should be at least 50 (60 plan files + 4 markdown files + directories)
+    const renameLines = renameLog.split('\n').filter(line => line.includes('rename'));
+    assert.ok(
+      renameLines.length >= 50,
+      'Should detect at least 50 renames, got ' + renameLines.length
+    );
+  });
+});