@ktpartners/dgs-platform 2.7.5 → 2.9.0

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

@@ -1,580 +1,525 @@
 /**
- * Tests for migration.cjs — v1-to-v2 migration with git mv history preservation
+ * Tests for .planning/ to root layout migration engine.
+ *
+ * Covers all MIG requirements (01-11), OPT-02 (dry-run),
+ * and OPT-03 (rollback on commit failure).
  */
 
 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');
+const { resetPaths } = require('./paths.cjs');
+const { migrateDotPlanningToRoot } = require('./migration.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 libDir = path.resolve(__dirname);
+
+// ─── Test 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('dgs-mig-test-');
+  initGitRepo(tmpDir);
+  return fs.realpathSync(tmpDir);
 }
 
-const {
-  detectV1Install,
-  validateMigrationPreconditions,
-  createBackupTag,
-  collectMigrationMoves,
-  validateMoves,
-  migrateV1ToV2,
-} = require('./migration.cjs');
+/**
+ * Creates a temp directory without git, returns realpathSync'd path.
+ */
+function makePlainDir() {
+  const tmpDir = createTempDir('dgs-mig-test-');
+  return fs.realpathSync(tmpDir);
+}
 
-// ─── detectV1Install ─────────────────────────────────────────────────────────
+/**
+ * Spawns a subprocess to call migrateDotPlanningToRoot.
+ * Used for tests where error() calls process.exit(1).
+ *
+ * @param {string} cwd - Directory to pass
+ * @param {Object} [options] - Options to pass to migrateDotPlanningToRoot
+ * @returns {{ exitCode: number, stdout: string, stderr: string }}
+ */
+function callMigrateSubprocess(cwd, options) {
+  const optsStr = options ? JSON.stringify(options) : '{}';
+  // Write script OUTSIDE the git repo to avoid dirtying the working tree
+  const scriptPath = path.join(require('os').tmpdir(), '_test_migrate_' + Date.now() + '.js');
+  const scriptContent = [
+    'const { migrateDotPlanningToRoot } = require(' + JSON.stringify(path.join(libDir, 'migration.cjs')) + ');',
+    'const result = migrateDotPlanningToRoot(' + JSON.stringify(cwd) + ', ' + optsStr + ');',
+    'process.stdout.write(JSON.stringify(result));',
+  ].join('\n');
+  fs.writeFileSync(scriptPath, scriptContent);
+  try {
+    const stdout = execSync('node ' + JSON.stringify(scriptPath), {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000,
+    });
+    return { exitCode: 0, stdout: stdout, stderr: '' };
+  } catch (err) {
+    return {
+      exitCode: err.status ?? 1,
+      stdout: (err.stdout ?? '').toString(),
+      stderr: (err.stderr ?? '').toString(),
+    };
+  }
+}
 
-describe('detectV1Install', () => {
-  let tmpDir;
-  beforeEach(() => { tmpDir = createTempDir(); });
-  afterEach(() => { cleanupDir(tmpDir); });
+// ─── Suite 1: Idempotency (MIG-07) ───────────────────────────────────────────
 
-  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');
-  });
+describe('idempotency (MIG-07)', () => {
+  let dir;
 
-  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);
+  beforeEach(() => {
+    dir = makeGitDir();
   });
 
-  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);
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  it('returns isV1 false when no .planning directory exists', () => {
-    const result = detectV1Install(tmpDir);
-    assert.strictEqual(result.isV1, false);
+  it('returns migrated:false when no .planning/ directory exists', () => {
+    const result = migrateDotPlanningToRoot(dir);
+    assert.strictEqual(result.migrated, false);
+    assert.strictEqual(result.filesMoved, 0);
+    assert.strictEqual(result.identicalResolved, 0);
+    assert.strictEqual(result.commitHash, null);
+    assert.deepStrictEqual(result.actions, []);
   });
 
-  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('returns migrated:false when .planning is a file not a directory', () => {
+    fs.writeFileSync(path.join(dir, '.planning'), 'not a directory');
+    execSync('git add .planning && git commit -m "add file"', { cwd: dir, stdio: 'pipe' });
+    const result = migrateDotPlanningToRoot(dir);
+    assert.strictEqual(result.migrated, false);
+    assert.strictEqual(result.filesMoved, 0);
   });
+});
+
+// ─── Suite 2: Clean working tree (git only) ──────────────────────────────────
+
+describe('clean working tree (git only)', () => {
+  let dir;
 
-  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');
+  beforeEach(() => {
+    dir = makeGitDir();
   });
 
-  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);
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  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);
+  it('aborts when git working tree has uncommitted changes', () => {
+    // Create .planning dir and commit it
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    execSync('git add .planning && git commit -m "add planning"', { cwd: dir, stdio: 'pipe' });
+    // Create an uncommitted file to dirty the tree
+    fs.writeFileSync(path.join(dir, 'dirty.txt'), 'uncommitted');
+
+    const result = callMigrateSubprocess(dir);
+    assert.strictEqual(result.exitCode, 1, 'Should exit with code 1');
+    assert.ok(
+      result.stderr.includes('clean working tree'),
+      'stderr should mention clean working tree, got: ' + result.stderr
+    );
   });
 });
 
-// ─── validateMigrationPreconditions ──────────────────────────────────────────
+// ─── Suite 3: File moves (MIG-01, MIG-04) ────────────────────────────────────
+
+describe('file moves (MIG-01, MIG-04)', () => {
+  let dir;
 
-describe('validateMigrationPreconditions', () => {
-  let tmpDir;
   beforeEach(() => {
-    tmpDir = createTempDir();
-    initGitRepo(tmpDir);
+    dir = makeGitDir();
   });
-  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);
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  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('moves all files from .planning/ to root', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, '.planning/STATE.md', '# State\n');
+    writeFile(dir, '.planning/phases/01-foo/01-01-PLAN.md', '# Plan\n');
+    execSync('git add .planning && git commit -m "add planning"', { cwd: dir, stdio: 'pipe' });
+
+    const result = migrateDotPlanningToRoot(dir);
 
-  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'));
+    assert.strictEqual(result.migrated, true);
+    assert.strictEqual(result.filesMoved, 3);
+    assert.ok(fs.existsSync(path.join(dir, 'ROADMAP.md')), 'ROADMAP.md should exist at root');
+    assert.ok(fs.existsSync(path.join(dir, 'STATE.md')), 'STATE.md should exist at root');
+    assert.ok(fs.existsSync(path.join(dir, 'phases/01-foo/01-01-PLAN.md')), 'Nested file should exist at root');
+    assert.ok(!fs.existsSync(path.join(dir, '.planning')), '.planning/ should be gone');
   });
 
-  it('fails when no .planning/PROJECT.md exists', () => {
-    const result = validateMigrationPreconditions(tmpDir);
-    assert.strictEqual(result.valid, false);
+  it('handles partial migration (only files still in .planning/)', () => {
+    // ROADMAP.md already at root, STATE.md only in .planning
+    writeFile(dir, 'ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, '.planning/STATE.md', '# State\n');
+    execSync('git add . && git commit -m "partial setup"', { cwd: dir, stdio: 'pipe' });
+
+    const result = migrateDotPlanningToRoot(dir);
+
+    assert.strictEqual(result.migrated, true);
+    assert.strictEqual(result.filesMoved, 1);
+    assert.ok(fs.existsSync(path.join(dir, 'STATE.md')), 'STATE.md should be at root');
+    assert.ok(fs.existsSync(path.join(dir, 'ROADMAP.md')), 'ROADMAP.md should still be at root');
   });
 });
 
-// ─── createBackupTag ─────────────────────────────────────────────────────────
+// ─── Suite 4: Conflict detection (MIG-02, MIG-03) ────────────────────────────
+
+describe('conflict detection (MIG-02, MIG-03)', () => {
+  let dir;
 
-describe('createBackupTag', () => {
-  let tmpDir;
   beforeEach(() => {
-    tmpDir = createTempDir();
-    initGitRepo(tmpDir);
+    dir = makeGitDir();
   });
-  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'));
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  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('aborts when files have different content in both locations', () => {
+    writeFile(dir, '.planning/ROADMAP.md', 'old content');
+    writeFile(dir, 'ROADMAP.md', 'new content');
+    execSync('git add . && git commit -m "conflict setup"', { cwd: dir, stdio: 'pipe' });
 
-  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);
-    }
+    const result = callMigrateSubprocess(dir);
+    assert.strictEqual(result.exitCode, 1, 'Should exit with code 1');
+    assert.ok(result.stderr.includes('Migration aborted'), 'stderr should mention Migration aborted');
+    assert.ok(result.stderr.includes('ROADMAP.md'), 'stderr should list conflicting file');
   });
-});
 
-// ─── migrateV1ToV2 ──────────────────────────────────────────────────────────
+  it('resolves identical-content conflicts by keeping root copy', () => {
+    const content = '# Roadmap\nSame content\n';
+    writeFile(dir, '.planning/ROADMAP.md', content);
+    writeFile(dir, 'ROADMAP.md', content);
+    execSync('git add . && git commit -m "identical setup"', { cwd: dir, stdio: 'pipe' });
 
-describe('migrateV1ToV2', () => {
-  let tmpDir;
-  beforeEach(() => {
-    tmpDir = createTempDir();
-    initGitRepo(tmpDir);
-  });
-  afterEach(() => { cleanupDir(tmpDir); });
+    const result = migrateDotPlanningToRoot(dir);
 
-  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');
+    assert.strictEqual(result.identicalResolved, 1);
+    assert.ok(!fs.existsSync(path.join(dir, '.planning')), '.planning/ should be gone');
+    const rootContent = fs.readFileSync(path.join(dir, 'ROADMAP.md'), 'utf-8');
+    assert.strictEqual(rootContent, content, 'Root copy should be unchanged');
+  });
+});
 
-    // 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')));
+// ─── Suite 5: .gitignore rewrite (MIG-05) ────────────────────────────────────
 
-    // 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')));
-  });
+describe('.gitignore rewrite (MIG-05)', () => {
+  let dir;
 
-  it('moves phases/ directory into project subfolder', () => {
-    createV1Install(tmpDir, 'Test App');
-    const result = migrateV1ToV2(tmpDir, 'test-app');
-    assert.strictEqual(result.migrated, true);
+  beforeEach(() => {
+    dir = makeGitDir();
+  });
 
-    // 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')));
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  it('moves research/ directory into project subfolder', () => {
-    createV1Install(tmpDir, 'Test App');
-    const result = migrateV1ToV2(tmpDir, 'test-app');
-    assert.strictEqual(result.migrated, true);
+  it('rewrites .gitignore entries to strip .planning/ prefix', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, '.gitignore', '.planning/config.local.json\n.planning/archive/\n!.planning/keep.txt\n');
+    execSync('git add . && git commit -m "gitignore setup"', { cwd: dir, stdio: 'pipe' });
 
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'research', 'notes.md')));
-    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'research')));
+    migrateDotPlanningToRoot(dir);
+
+    const gitignore = fs.readFileSync(path.join(dir, '.gitignore'), 'utf-8');
+    assert.ok(gitignore.includes('config.local.json'), 'Should contain config.local.json without .planning/ prefix');
+    assert.ok(gitignore.includes('archive/'), 'Should contain archive/ without .planning/ prefix');
+    assert.ok(gitignore.includes('!keep.txt'), 'Should contain !keep.txt without .planning/ prefix');
+    assert.ok(!gitignore.includes('.planning/'), 'Should not contain .planning/ prefix');
   });
+});
 
-  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' });
+// ─── Suite 6: config.local.json cleanup (MIG-06) ─────────────────────────────
 
-    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')));
-  });
+describe('config.local.json cleanup (MIG-06)', () => {
+  let dir;
 
-  it('does NOT move config.json (product-level)', () => {
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  beforeEach(() => {
+    dir = makeGitDir();
+  });
 
-    // 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')));
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  it('does NOT move codebase/ directory (product-level)', () => {
-    writeFile(tmpDir, '.planning/codebase/overview.md', '# Codebase\n');
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  it('removes planningRoot key from config.local.json', () => {
+    writeFile(dir, '.planning/config.local.json', JSON.stringify({ planningRoot: '.', other: 'keep' }));
+    execSync('git add . && git commit -m "config setup"', { cwd: dir, stdio: 'pipe' });
+
+    migrateDotPlanningToRoot(dir);
 
-    // codebase/ should remain at product level
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'codebase', 'overview.md')));
+    const configPath = path.join(dir, 'config.local.json');
+    assert.ok(fs.existsSync(configPath), 'config.local.json should exist at root');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    assert.ok(!('planningRoot' in config), 'planningRoot key should be removed');
+    assert.strictEqual(config.other, 'keep', 'Other keys should be preserved');
   });
+});
 
-  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');
+// ─── Suite 7: dgs.config.json rename (MIG-10) ────────────────────────────────
 
-    // milestones/ should remain at product level
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'milestones', 'v1.0.md')));
-  });
+describe('dgs.config.json rename (MIG-10)', () => {
+  let dir;
 
-  it('creates REPOS.md with current directory as single repo', () => {
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  beforeEach(() => {
+    dir = makeGitDir();
+  });
 
-    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 '.'
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  it('creates PROJECTS.md from migrated project', () => {
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  it('renames dgs.config.json to config.json during migration', () => {
+    writeFile(dir, '.planning/dgs.config.json', JSON.stringify({ model_profile: 'balanced' }));
+    execSync('git add . && git commit -m "dgs config setup"', { cwd: dir, stdio: 'pipe' });
 
-    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'));
+    const result = migrateDotPlanningToRoot(dir);
+
+    assert.ok(fs.existsSync(path.join(dir, 'config.json')), 'config.json should exist at root');
+    assert.ok(!fs.existsSync(path.join(dir, 'dgs.config.json')), 'dgs.config.json should not exist');
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.strictEqual(config.model_profile, 'balanced', 'Content should be preserved');
+    assert.strictEqual(result.migrated, true);
   });
+});
 
-  it('sets current_project in config.local.json', () => {
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+// ─── Suite 8: Atomic commit (MIG-11) ─────────────────────────────────────────
 
-    const localConfigPath = path.join(tmpDir, '.planning', 'config.local.json');
-    assert.ok(fs.existsSync(localConfigPath), 'config.local.json should exist');
-    const config = JSON.parse(fs.readFileSync(localConfigPath, 'utf-8'));
-    assert.strictEqual(config.current_project, 'test-app');
+describe('atomic commit (MIG-11)', () => {
+  let dir;
+
+  beforeEach(() => {
+    dir = makeGitDir();
   });
 
-  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);
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  it('uses git mv to preserve history', () => {
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  it('creates a single commit with migration message', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    execSync('git add .planning && git commit -m "add planning"', { cwd: dir, stdio: 'pipe' });
 
-    // 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'));
+    const result = migrateDotPlanningToRoot(dir);
+
+    assert.ok(result.commitHash, 'commitHash should be non-empty');
+    assert.strictEqual(typeof result.commitHash, 'string');
+    const log = execSync('git log --oneline -1', { cwd: dir, encoding: 'utf-8' });
+    assert.ok(log.includes('chore: migrate .planning/ to root layout'), 'Commit message should match');
   });
+});
 
-  it('preserves todos/ at product level (not moved to project)', () => {
-    writeFile(tmpDir, '.planning/todos/pending/task1.md', '# Todo 1\n');
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+// ─── Suite 9: Non-git fallback (MIG-09) ──────────────────────────────────────
 
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'todos', 'pending', 'task1.md')));
-    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'todos')));
-  });
+describe('non-git fallback (MIG-09)', () => {
+  let dir;
 
-  it('moves quick/ directory if it exists', () => {
-    writeFile(tmpDir, '.planning/quick/fix1.md', '# Quick Fix\n');
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  beforeEach(() => {
+    dir = makePlainDir();
+  });
 
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'quick', 'fix1.md')));
-    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'quick')));
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
 
-  it('moves debug/ directory if it exists', () => {
-    writeFile(tmpDir, '.planning/debug/issue1.md', '# Debug Session\n');
-    createV1Install(tmpDir, 'Test App');
-    migrateV1ToV2(tmpDir, 'test-app');
+  it('moves files using fs.rename when not in a git repo', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, '.planning/STATE.md', '# State\n');
 
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'debug', 'issue1.md')));
-    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'debug')));
+    const result = migrateDotPlanningToRoot(dir);
+
+    assert.strictEqual(result.migrated, true);
+    assert.strictEqual(result.commitHash, null, 'commitHash should be null for non-git');
+    assert.ok(fs.existsSync(path.join(dir, 'ROADMAP.md')), 'ROADMAP.md should exist at root');
+    assert.ok(fs.existsSync(path.join(dir, 'STATE.md')), 'STATE.md should exist at root');
+    assert.ok(!fs.existsSync(path.join(dir, '.planning')), '.planning/ should be gone');
   });
 });
 
-// ─── collectMigrationMoves ──────────────────────────────────────────────────
+// ─── Suite 10: Dry-run (OPT-02) ──────────────────────────────────────────────
 
-describe('collectMigrationMoves', () => {
-  let tmpDir;
-  beforeEach(() => { tmpDir = createTempDir(); });
-  afterEach(() => { cleanupDir(tmpDir); });
+describe('dry-run (OPT-02)', () => {
+  let dir;
 
-  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');
+  beforeEach(() => {
+    dir = makeGitDir();
+  });
 
-    const { moves, targetDir } = collectMigrationMoves(tmpDir, 'test-app');
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
+  });
 
-    // Should have 2 directories + 4 files = 6 moves
-    assert.strictEqual(moves.length, 6);
-    assert.ok(targetDir.endsWith(path.join('.planning', 'projects', 'test-app')));
+  it('dry-run returns actions without modifying files', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    execSync('git add .planning && git commit -m "add planning"', { cwd: dir, stdio: 'pipe' });
 
-    // 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
+    const result = migrateDotPlanningToRoot(dir, { dryRun: true });
 
-    // First moves should be dirs
-    assert.strictEqual(moves[0].isDir, true);
-    assert.strictEqual(moves[1].isDir, true);
+    assert.strictEqual(result.dryRun, true);
+    assert.strictEqual(result.migrated, false, 'migrated should be false in dry-run');
+    assert.ok(result.actions.length > 0, 'Should have actions');
+    assert.strictEqual(result.filesMoved, 1, 'filesMoved should count planned moves');
+    assert.strictEqual(result.commitHash, null, 'No commit in dry-run');
+    // Files should NOT have moved
+    assert.ok(fs.existsSync(path.join(dir, '.planning/ROADMAP.md')), '.planning/ROADMAP.md should still exist');
+    assert.ok(!fs.existsSync(path.join(dir, 'ROADMAP.md')), 'ROADMAP.md should not exist at root yet');
   });
+});
 
-  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');
+// ─── CLI Helper ──────────────────────────────────────────────────────────────
 
-    const { moves } = collectMigrationMoves(tmpDir, 'partial');
+const { spawnSync } = require('child_process');
 
-    // 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'));
-  });
+/**
+ * Spawns dgs-tools.cjs in a subprocess with given args.
+ * Uses spawnSync to capture both stdout and stderr on success.
+ *
+ * @param {string} cwd - Working directory for the subprocess
+ * @param {string} args - CLI arguments string
+ * @returns {{ exitCode: number, stdout: string, stderr: string }}
+ */
+function callDgsTools(cwd, args) {
+  const dgsToolsPath = path.resolve(__dirname, '..', 'dgs-tools.cjs');
+  const result = spawnSync('node', [dgsToolsPath, ...args.split(' ')], {
+    cwd,
+    encoding: 'utf-8',
+    timeout: 10000,
+  });
+  return {
+    exitCode: result.status ?? 1,
+    stdout: (result.stdout ?? '').toString(),
+    stderr: (result.stderr ?? '').toString(),
+  };
+}
 
-  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');
+// ─── Suite 11: CLI: migrate command (MIG-08, OPT-02) ─────────────────────────
 
-    const { moves } = collectMigrationMoves(tmpDir, 'test');
+describe('CLI: migrate command (MIG-08, OPT-02)', () => {
+  let dir;
 
-    const phasesMove = moves.find(m => m.relSource.endsWith('phases'));
-    const researchMove = moves.find(m => m.relSource.endsWith('research'));
-    const projectMove = moves.find(m => m.relSource.endsWith('PROJECT.md'));
+  beforeEach(() => {
+    dir = makeGitDir();
+  });
 
-    assert.strictEqual(phasesMove.isDir, true);
-    assert.strictEqual(researchMove.isDir, true);
-    assert.strictEqual(projectMove.isDir, false);
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
   });
-});
 
-// ─── validateMoves ──────────────────────────────────────────────────────────
+  it('migrate --layout root migrates .planning/ directory', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, 'PROJECTS.md', '# Projects\n');
+    writeFile(dir, 'REPOS.md', '# Repos\n');
+    execSync('git add . && git commit -m "setup"', { cwd: dir, stdio: 'pipe' });
 
-describe('validateMoves', () => {
-  let tmpDir;
-  beforeEach(() => { tmpDir = createTempDir(); });
-  afterEach(() => { cleanupDir(tmpDir); });
+    const result = callDgsTools(dir, 'migrate --layout root');
 
-  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');
+    assert.strictEqual(result.exitCode, 0, 'Should exit with code 0, stderr: ' + result.stderr);
+    assert.ok(fs.existsSync(path.join(dir, 'ROADMAP.md')), 'ROADMAP.md should exist at root');
+    assert.ok(!fs.existsSync(path.join(dir, '.planning')), '.planning/ should be gone');
+  });
 
-    const moves = [
-      { relSource: '.planning/PROJECT.md', relTarget: '.planning/test/PROJECT.md', isDir: false },
-      { relSource: '.planning/STATE.md', relTarget: '.planning/test/STATE.md', isDir: false },
-    ];
+  it('migrate --layout root --dry-run shows actions without moving files', () => {
+    writeFile(dir, '.planning/STATE.md', '# State\n');
+    writeFile(dir, 'PROJECTS.md', '# Projects\n');
+    writeFile(dir, 'REPOS.md', '# Repos\n');
+    execSync('git add . && git commit -m "setup"', { cwd: dir, stdio: 'pipe' });
 
-    const result = validateMoves(tmpDir, moves);
-    assert.strictEqual(result.valid, true);
-    assert.strictEqual(result.errors.length, 0);
+    const result = callDgsTools(dir, 'migrate --layout root --dry-run');
+
+    assert.strictEqual(result.exitCode, 0, 'Should exit with code 0, stderr: ' + result.stderr);
+    assert.ok(fs.existsSync(path.join(dir, '.planning/STATE.md')), '.planning/STATE.md should still exist');
+    assert.ok(result.stderr.includes('Dry run') || result.stderr.includes('would be made'),
+      'stderr should mention dry run, got: ' + result.stderr);
   });
 
-  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');
+  it('migrate --layout root --raw returns JSON', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, 'PROJECTS.md', '# Projects\n');
+    writeFile(dir, 'REPOS.md', '# Repos\n');
+    execSync('git add . && git commit -m "setup"', { cwd: dir, stdio: 'pipe' });
 
-    const moves = [
-      { relSource: '.planning/PROJECT.md', relTarget: '.planning/test/PROJECT.md', isDir: false },
-    ];
+    const result = callDgsTools(dir, 'migrate --layout root --raw');
 
-    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'));
+    assert.strictEqual(result.exitCode, 0, 'Should exit with code 0, stderr: ' + result.stderr);
+    const parsed = JSON.parse(result.stdout);
+    assert.strictEqual(parsed.migrated, true, 'JSON should indicate migrated:true');
+    assert.ok(typeof parsed.filesMoved === 'number', 'filesMoved should be a number');
+    assert.ok(typeof parsed.commitHash === 'string', 'commitHash should be a string');
   });
-});
 
-// ─── Rollback on git mv failure ─────────────────────────────────────────────
+  it('migrate without --layout root shows usage error', () => {
+    const result = callDgsTools(dir, 'migrate');
 
-describe('migrateV1ToV2 rollback', () => {
-  let tmpDir;
-  beforeEach(() => {
-    tmpDir = createTempDir();
-    initGitRepo(tmpDir);
+    assert.strictEqual(result.exitCode, 1, 'Should exit with code 1');
+    assert.ok(result.stderr.includes('Usage'), 'stderr should mention Usage, got: ' + result.stderr);
   });
-  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' });
+// ─── Suite 12: CLI: auto-trigger migration ────────────────────────────────────
 
-    const result = migrateV1ToV2(tmpDir, 'bad-slug');
+describe('CLI: auto-trigger migration', () => {
+  let dir;
 
-    // Should report validation failure (target already exists)
-    assert.strictEqual(result.migrated, false);
-    assert.ok(result.error);
+  beforeEach(() => {
+    dir = makeGitDir();
   });
 
-  it('restores original files after rollback from git mv failure', () => {
-    createV1Install(tmpDir, 'Test App');
+  afterEach(() => {
+    resetPaths();
+    cleanupDir(dir);
+  });
 
-    // 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' });
+  it('auto-triggers migration and prints banner on normal command', () => {
+    writeFile(dir, '.planning/ROADMAP.md', '# Roadmap\n');
+    writeFile(dir, 'PROJECTS.md', '# Projects\n');
+    writeFile(dir, 'REPOS.md', '# Repos\n');
+    writeFile(dir, 'config.json', '{}');
+    execSync('git add . && git commit -m "setup"', { cwd: dir, stdio: 'pipe' });
 
-    migrateV1ToV2(tmpDir, 'fail-slug');
+    const result = callDgsTools(dir, 'current-timestamp');
 
-    // 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')));
+    assert.strictEqual(result.exitCode, 0, 'Should exit with code 0, stderr: ' + result.stderr);
+    assert.ok(result.stderr.includes('DGS migrated .planning/ to root layout'),
+      'stderr should contain migration banner, got: ' + result.stderr);
+    assert.ok(fs.existsSync(path.join(dir, 'ROADMAP.md')), 'ROADMAP.md should exist at root');
+    assert.ok(!fs.existsSync(path.join(dir, '.planning')), '.planning/ should be gone');
   });
-});
 
-// ─── Scale test: 50+ files with rename detection ────────────────────────────
+  it('auto-trigger is silent when no .planning/ directory', () => {
+    writeFile(dir, 'PROJECTS.md', '# Projects\n');
+    writeFile(dir, 'REPOS.md', '# Repos\n');
+    writeFile(dir, 'config.json', '{}');
+    execSync('git add . && git commit -m "setup"', { cwd: dir, stdio: 'pipe' });
 
-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);
+    const result = callDgsTools(dir, 'current-timestamp');
 
-    // 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
-    );
+    assert.strictEqual(result.exitCode, 0, 'Should exit with code 0, stderr: ' + result.stderr);
+    assert.ok(!result.stderr.includes('migrated'),
+      'stderr should NOT contain migration message, got: ' + result.stderr);
   });
 });