@ktpartners/dgs-platform 2.8.0 → 3.0.4

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

@@ -12,6 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execGit, safeReadFile, error } = require('./core.cjs');
+const { extractFrontmatter, spliceFrontmatter } = require('./frontmatter.cjs');
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -286,6 +287,413 @@ function migrateDotPlanningToRoot(cwd, options) {
   };
 }
 
+// ─── Flat Status Migration ────────────���──────────────────────────────────────
+
+/**
+ * Migrates ideas, todos, jobs from state subdirectories to flat directories
+ * with frontmatter status fields. Also flattens research docs in docs/ideas/.
+ *
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @param {Object} [options] - Migration options
+ * @param {boolean} [options.apply=false] - If true, execute migration; otherwise dry-run
+ * @returns {{
+ *   migrated: boolean,
+ *   dryRun: boolean,
+ *   actions: Array<{type: string, subsystem?: string, from: string, to: string, state?: string, mappedStatus?: string, filename?: string}>,
+ *   filesMoved: number,
+ *   statusFieldsAdded: number,
+ *   pathsNormalized: number,
+ *   commitHash: string|null,
+ * }}
+ */
+function migrateFlatStatus(cwd, options) {
+  const opts = options || {};
+  const apply = opts.apply || false;
+
+  // Step 1 — Resolve paths and check idempotency
+  const resolved = path.resolve(cwd || process.cwd());
+  const localPath = path.join(resolved, 'config.local.json');
+  let localConfig = {};
+  try {
+    if (fs.existsSync(localPath)) {
+      localConfig = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+  if (localConfig.flat_status_migration_done) {
+    return { migrated: false, dryRun: !apply, actions: [], filesMoved: 0, statusFieldsAdded: 0, pathsNormalized: 0, commitHash: null };
+  }
+
+  // Step 2 — Define subsystem configs
+  const SUBSYSTEMS = [
+    {
+      name: 'ideas',
+      dir: 'ideas',
+      states: ['pending', 'done', 'rejected', 'consolidated'],
+      statusMap: { pending: 'pending', done: 'done', rejected: 'rejected', consolidated: 'consolidated' },
+    },
+    {
+      name: 'todos',
+      dir: 'todos',
+      states: ['pending', 'completed', 'done', 'resolved'],
+      statusMap: { pending: 'pending', completed: 'done', done: 'done', resolved: 'done' },
+    },
+    {
+      name: 'jobs',
+      dir: 'jobs',
+      states: ['pending', 'in-progress', 'completed', 'failed'],
+      statusMap: { pending: 'pending', 'in-progress': 'in-progress', completed: 'completed', failed: 'failed' },
+    },
+  ];
+
+  const researchStates = ['pending', 'done', 'rejected', 'consolidated'];
+
+  // Step 3 — Detect legacy layout
+  let hasLegacyFiles = false;
+  for (const sub of SUBSYSTEMS) {
+    for (const state of sub.states) {
+      const stateDir = path.join(resolved, sub.dir, state);
+      if (fs.existsSync(stateDir) && fs.statSync(stateDir).isDirectory()) {
+        const files = fs.readdirSync(stateDir).filter(f => f.endsWith('.md'));
+        if (files.length > 0) { hasLegacyFiles = true; break; }
+      }
+    }
+    if (hasLegacyFiles) break;
+  }
+  // Also check research docs
+  if (!hasLegacyFiles) {
+    for (const state of researchStates) {
+      const resDir = path.join(resolved, 'docs', 'ideas', state);
+      if (fs.existsSync(resDir) && fs.statSync(resDir).isDirectory()) {
+        const files = fs.readdirSync(resDir).filter(f => f.endsWith('.md'));
+        if (files.length > 0) { hasLegacyFiles = true; break; }
+      }
+    }
+  }
+  if (!hasLegacyFiles) {
+    localConfig.flat_status_migration_done = true;
+    fs.writeFileSync(localPath, JSON.stringify(localConfig, null, 2) + '\n');
+    return { migrated: false, dryRun: !apply, actions: [], filesMoved: 0, statusFieldsAdded: 0, pathsNormalized: 0, commitHash: null };
+  }
+
+  // Step 4 — Clean working tree check (apply mode only)
+  const inGit = isGitRepo(resolved);
+  if (apply && inGit && !isCleanWorkingTree(resolved)) {
+    error('Flat status migration requires a clean working tree. Commit or stash your changes first.');
+  }
+
+  // Step 5 — Count all .md files before migration (for validation)
+  let beforeTotal = 0;
+  for (const sub of SUBSYSTEMS) {
+    const flatDir = path.join(resolved, sub.dir);
+    if (fs.existsSync(flatDir)) {
+      beforeTotal += fs.readdirSync(flatDir).filter(f => f.endsWith('.md') && !fs.statSync(path.join(flatDir, f)).isDirectory()).length;
+    }
+    for (const state of sub.states) {
+      const stateDir = path.join(resolved, sub.dir, state);
+      if (fs.existsSync(stateDir) && fs.statSync(stateDir).isDirectory()) {
+        beforeTotal += fs.readdirSync(stateDir).filter(f => f.endsWith('.md')).length;
+      }
+    }
+  }
+  const researchBaseDir = path.join(resolved, 'docs', 'ideas');
+  if (fs.existsSync(researchBaseDir)) {
+    beforeTotal += fs.readdirSync(researchBaseDir).filter(f => f.endsWith('.md') && !fs.statSync(path.join(researchBaseDir, f)).isDirectory()).length;
+  }
+  for (const state of researchStates) {
+    const resDir = path.join(resolved, 'docs', 'ideas', state);
+    if (fs.existsSync(resDir) && fs.statSync(resDir).isDirectory()) {
+      beforeTotal += fs.readdirSync(resDir).filter(f => f.endsWith('.md')).length;
+    }
+  }
+
+  // Step 6 — Collect actions for each subsystem
+  const actions = [];
+  for (const sub of SUBSYSTEMS) {
+    for (const state of sub.states) {
+      const stateDir = path.join(resolved, sub.dir, state);
+      if (!fs.existsSync(stateDir) || !fs.statSync(stateDir).isDirectory()) continue;
+      const files = fs.readdirSync(stateDir).filter(f => f.endsWith('.md'));
+      for (const filename of files) {
+        const from = path.join(sub.dir, state, filename);
+        const to = path.join(sub.dir, filename);
+        const destAbs = path.join(resolved, to);
+        if (fs.existsSync(destAbs)) continue; // already flat, skip
+        actions.push({ type: 'move', subsystem: sub.name, from, to, state, mappedStatus: sub.statusMap[state], filename });
+      }
+    }
+  }
+  // Research docs
+  for (const state of researchStates) {
+    const resDir = path.join(resolved, 'docs', 'ideas', state);
+    if (!fs.existsSync(resDir) || !fs.statSync(resDir).isDirectory()) continue;
+    const files = fs.readdirSync(resDir).filter(f => f.endsWith('.md'));
+    for (const filename of files) {
+      const from = path.join('docs', 'ideas', state, filename);
+      const to = path.join('docs', 'ideas', filename);
+      const destAbs = path.join(resolved, to);
+      if (fs.existsSync(destAbs)) continue; // already flat, skip
+      actions.push({ type: 'move-research', from, to, state, filename });
+    }
+  }
+
+  // Step 7 — Filename collision check
+  const destPaths = new Set();
+  for (const action of actions) {
+    if (destPaths.has(action.to)) {
+      error('Flat status migration aborted: filename collision at ' + action.to + '. Two files from different state directories have the same name.');
+    }
+    destPaths.add(action.to);
+  }
+
+  // Step 8 — Dry-run return
+  if (!apply) {
+    return {
+      migrated: false,
+      dryRun: true,
+      actions,
+      filesMoved: actions.filter(a => a.type === 'move' || a.type === 'move-research').length,
+      statusFieldsAdded: actions.filter(a => a.type === 'move').length,
+      pathsNormalized: 0,
+      commitHash: null,
+    };
+  }
+
+  // Step 9 — Execute migration (apply mode)
+  let pathsNormalized = 0;
+
+  for (const action of actions) {
+    const srcAbs = path.join(resolved, action.from);
+    const destAbs = path.join(resolved, action.to);
+
+    if (action.type === 'move') {
+      // 1. Git mv to preserve history
+      fs.mkdirSync(path.dirname(destAbs), { recursive: true });
+      if (inGit) {
+        execGit(resolved, ['mv', action.from, action.to]);
+      } else {
+        fs.renameSync(srcAbs, destAbs);
+      }
+
+      // 2. Add/update status in frontmatter
+      let content = fs.readFileSync(destAbs, 'utf-8');
+      const fm = extractFrontmatter(content);
+      if (fm && typeof fm === 'object' && Object.keys(fm).length > 0) {
+        fm.status = action.mappedStatus;
+        content = spliceFrontmatter(content, fm);
+      } else {
+        // No frontmatter — prepend
+        content = '---\nstatus: ' + action.mappedStatus + '\n---\n' + content;
+      }
+
+      // 3. For jobs: update bold-key Status header
+      if (action.subsystem === 'jobs') {
+        content = content.replace(/\*\*Status:\*\*\s*\S+/, '**Status:** ' + action.mappedStatus);
+      }
+
+      // 4. Normalize consolidated_into and consolidated_from paths in ideas
+      if (action.subsystem === 'ideas') {
+        const before = content;
+        content = content.replace(/ideas\/(pending|done|rejected|consolidated)\//g, 'ideas/');
+        if (content !== before) pathsNormalized++;
+      }
+
+      // 5. Normalize research doc path references in ideas
+      if (action.subsystem === 'ideas') {
+        content = content.replace(/docs\/ideas\/(pending|done|rejected|consolidated)\//g, 'docs/ideas/');
+      }
+
+      fs.writeFileSync(destAbs, content);
+    } else if (action.type === 'move-research') {
+      // Research docs: just move, no frontmatter changes
+      fs.mkdirSync(path.dirname(destAbs), { recursive: true });
+      if (inGit) {
+        execGit(resolved, ['mv', action.from, action.to]);
+      } else {
+        fs.renameSync(srcAbs, destAbs);
+      }
+    }
+  }
+
+  // Step 10 — Normalize paths in idea files already in flat dir
+  const ideasDir = path.join(resolved, 'ideas');
+  if (fs.existsSync(ideasDir)) {
+    const flatIdeas = fs.readdirSync(ideasDir).filter(f => f.endsWith('.md'));
+    for (const f of flatIdeas) {
+      const fPath = path.join(ideasDir, f);
+      if (!fs.statSync(fPath).isFile()) continue;
+      let content = fs.readFileSync(fPath, 'utf-8');
+      const before = content;
+      content = content.replace(/ideas\/(pending|done|rejected|consolidated)\//g, 'ideas/');
+      content = content.replace(/docs\/ideas\/(pending|done|rejected|consolidated)\//g, 'docs/ideas/');
+      if (content !== before) {
+        fs.writeFileSync(fPath, content);
+        pathsNormalized++;
+      }
+    }
+  }
+
+  // Step 11 — Remove empty state subdirectories
+  for (const sub of SUBSYSTEMS) {
+    for (const state of sub.states) {
+      const stateDir = path.join(resolved, sub.dir, state);
+      if (fs.existsSync(stateDir)) {
+        try {
+          const remaining = fs.readdirSync(stateDir);
+          if (remaining.length === 0) {
+            fs.rmdirSync(stateDir);
+          }
+        } catch { /* ignore — directory may have non-.md files */ }
+      }
+    }
+  }
+  for (const state of researchStates) {
+    const resDir = path.join(resolved, 'docs', 'ideas', state);
+    if (fs.existsSync(resDir)) {
+      try {
+        const remaining = fs.readdirSync(resDir);
+        if (remaining.length === 0) {
+          fs.rmdirSync(resDir);
+        }
+      } catch { /* ignore */ }
+    }
+  }
+
+  // Step 12 — File count validation (post-move)
+  let afterTotal = 0;
+  for (const sub of SUBSYSTEMS) {
+    const flatDir = path.join(resolved, sub.dir);
+    if (fs.existsSync(flatDir)) {
+      afterTotal += fs.readdirSync(flatDir).filter(f => f.endsWith('.md') && !fs.statSync(path.join(flatDir, f)).isDirectory()).length;
+    }
+    for (const state of sub.states) {
+      const stateDir = path.join(resolved, sub.dir, state);
+      if (fs.existsSync(stateDir) && fs.statSync(stateDir).isDirectory()) {
+        afterTotal += fs.readdirSync(stateDir).filter(f => f.endsWith('.md')).length;
+      }
+    }
+  }
+  if (fs.existsSync(researchBaseDir)) {
+    afterTotal += fs.readdirSync(researchBaseDir).filter(f => f.endsWith('.md') && !fs.statSync(path.join(researchBaseDir, f)).isDirectory()).length;
+  }
+  for (const state of researchStates) {
+    const resDir = path.join(resolved, 'docs', 'ideas', state);
+    if (fs.existsSync(resDir) && fs.statSync(resDir).isDirectory()) {
+      afterTotal += fs.readdirSync(resDir).filter(f => f.endsWith('.md')).length;
+    }
+  }
+  if (beforeTotal !== afterTotal) {
+    // Rollback
+    if (inGit) {
+      execGit(resolved, ['checkout', 'HEAD', '--', '.']);
+    }
+    error('Flat status migration aborted: file count mismatch. Before: ' + beforeTotal + ', After: ' + afterTotal + '. Changes rolled back.');
+  }
+
+  // Step 13 — Atomic git commit
+  let commitHash = null;
+  if (inGit) {
+    execGit(resolved, ['add', '-A']);
+    const commitResult = execGit(resolved, ['commit', '-m', 'chore: migrate to flat status directories']);
+    if (commitResult.exitCode !== 0) {
+      execGit(resolved, ['checkout', 'HEAD', '--', '.']);
+      error('Flat status migration commit failed. Changes rolled back. Error: ' + commitResult.stderr);
+    }
+    const hashResult = execGit(resolved, ['rev-parse', '--short', 'HEAD']);
+    commitHash = hashResult.stdout;
+  }
+
+  // Step 14 — Set migration flag
+  localConfig.flat_status_migration_done = true;
+  fs.writeFileSync(localPath, JSON.stringify(localConfig, null, 2) + '\n');
+  if (inGit) {
+    execGit(resolved, ['add', localPath]);
+    execGit(resolved, ['commit', '--amend', '--no-edit']);
+    const hashResult = execGit(resolved, ['rev-parse', '--short', 'HEAD']);
+    commitHash = hashResult.stdout;
+  }
+
+  // Step 15 — Return result
+  return {
+    migrated: true,
+    dryRun: false,
+    actions,
+    filesMoved: actions.filter(a => a.type === 'move' || a.type === 'move-research').length,
+    statusFieldsAdded: actions.filter(a => a.type === 'move').length,
+    pathsNormalized,
+    commitHash,
+  };
+}
+
+// ─── Branching Config Migration ────────��─────────────────────────────────────
+
+/**
+ * Remove legacy branching config keys. Runs lazily — called once per CLI invocation.
+ * No-op if already migrated or no legacy keys present.
+ *
+ * Removes: branching_strategy, phase_branch_template, milestone_branch_template,
+ * git.worktree_setup_command. Sets branching_migration_done flag in config.local.json
+ * so the check only runs once.
+ *
+ * @param {string} cwd - Planning root directory
+ */
+function migrateBranchingConfig(cwd) {
+  const resolved = path.resolve(cwd || process.cwd());
+  const localPath = path.join(resolved, 'config.local.json');
+  const sharedPath = path.join(resolved, 'config.json');
+
+  // 1. Check migration_done flag in config.local.json
+  let localConfig = {};
+  try {
+    if (fs.existsSync(localPath)) {
+      localConfig = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+
+  if (localConfig.branching_migration_done) return; // already migrated
+
+  // 2. Read config.json
+  let config = {};
+  try {
+    if (fs.existsSync(sharedPath)) {
+      config = JSON.parse(fs.readFileSync(sharedPath, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+
+  // 3. Check for legacy keys
+  const hasStrategy = 'branching_strategy' in config;
+  const hasPhaseTemplate = 'phase_branch_template' in config;
+  const hasMilestoneTemplate = 'milestone_branch_template' in config;
+  const hasWorktreeSetup = config.git && 'worktree_setup_command' in config.git;
+
+  if (!hasStrategy && !hasPhaseTemplate && !hasMilestoneTemplate && !hasWorktreeSetup) {
+    // No legacy keys — set flag and return silently
+    localConfig.branching_migration_done = true;
+    fs.writeFileSync(localPath, JSON.stringify(localConfig, null, 2) + '\n');
+    return;
+  }
+
+  // 4. Remove legacy keys
+  delete config.branching_strategy;
+  delete config.phase_branch_template;
+  delete config.milestone_branch_template;
+  if (config.git && 'worktree_setup_command' in config.git) {
+    delete config.git.worktree_setup_command;
+    if (Object.keys(config.git).length === 0) {
+      delete config.git;
+    }
+  }
+
+  // Write updated config.json
+  fs.writeFileSync(sharedPath, JSON.stringify(config, null, 2) + '\n');
+
+  // 5. Info message
+  process.stderr.write('[DGS] Migrated: removed branching_strategy config (worktrees are now the only model)\n');
+
+  // 6. Set migration flag
+  localConfig.branching_migration_done = true;
+  fs.writeFileSync(localPath, JSON.stringify(localConfig, null, 2) + '\n');
+}
+
 // ─── V1 Rejection ────────────────────────────────────────────────────────────
 
 /**
@@ -324,4 +732,4 @@ function rejectV1Install(cwd) {
 
 // ─── Exports ──────────────────────────────────────────────────────────────────
 
-module.exports = { migrateDotPlanningToRoot, rejectV1Install };
+module.exports = { migrateDotPlanningToRoot, rejectV1Install, migrateBranchingConfig, migrateFlatStatus };

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

@@ -13,7 +13,7 @@ const { execSync } = require('child_process');
 
 const { createTempDir, cleanupDir, writeFile, initGitRepo } = require('./test-helpers.cjs');
 const { resetPaths } = require('./paths.cjs');
-const { migrateDotPlanningToRoot } = require('./migration.cjs');
+const { migrateDotPlanningToRoot, migrateBranchingConfig } = require('./migration.cjs');
 
 const libDir = path.resolve(__dirname);
 
@@ -523,3 +523,160 @@ describe('CLI: auto-trigger migration', () => {
       'stderr should NOT contain migration message, got: ' + result.stderr);
   });
 });
+
+// ─── Suite 13: Branching config migration ─────────────────────────────────────
+
+describe('migrateBranchingConfig', () => {
+  let dir;
+
+  beforeEach(() => {
+    dir = createTempDir('dgs-branchmig-test-');
+    dir = fs.realpathSync(dir);
+  });
+
+  afterEach(() => {
+    cleanupDir(dir);
+  });
+
+  it('clean config — no branching keys — migration is no-op', () => {
+    writeFile(dir, 'config.json', JSON.stringify({
+      model_profile: 'balanced',
+      base_branch: 'main',
+    }, null, 2));
+
+    migrateBranchingConfig(dir);
+
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.strictEqual(config.model_profile, 'balanced', 'config.json should be unchanged');
+    assert.strictEqual(config.base_branch, 'main', 'base_branch should be preserved');
+
+    const local = JSON.parse(fs.readFileSync(path.join(dir, 'config.local.json'), 'utf-8'));
+    assert.strictEqual(local.branching_migration_done, true, 'migration_done flag should be set');
+  });
+
+  it('config with branching_strategy none — keys removed, message shown', () => {
+    writeFile(dir, 'config.json', JSON.stringify({
+      model_profile: 'balanced',
+      branching_strategy: 'none',
+      phase_branch_template: 'dgs/{project}/phase-{phase}-{slug}',
+      base_branch: 'main',
+    }, null, 2));
+
+    // Capture stderr
+    const origWrite = process.stderr.write;
+    let stderrOutput = '';
+    process.stderr.write = (chunk) => { stderrOutput += chunk; return true; };
+
+    try {
+      migrateBranchingConfig(dir);
+    } finally {
+      process.stderr.write = origWrite;
+    }
+
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.ok(!('branching_strategy' in config), 'branching_strategy should be removed');
+    assert.ok(!('phase_branch_template' in config), 'phase_branch_template should be removed');
+    assert.strictEqual(config.model_profile, 'balanced', 'Other keys preserved');
+    assert.strictEqual(config.base_branch, 'main', 'base_branch preserved');
+
+    const local = JSON.parse(fs.readFileSync(path.join(dir, 'config.local.json'), 'utf-8'));
+    assert.strictEqual(local.branching_migration_done, true, 'migration_done flag should be set');
+
+    assert.ok(stderrOutput.includes('Migrated'), 'Should show migration info message');
+  });
+
+  it('config with branching_strategy milestone — all keys removed', () => {
+    writeFile(dir, 'config.json', JSON.stringify({
+      model_profile: 'balanced',
+      branching_strategy: 'milestone',
+      phase_branch_template: 'dgs/{project}/phase-{phase}-{slug}',
+      milestone_branch_template: 'dgs/{project}/{milestone}-{slug}',
+      base_branch: 'main',
+    }, null, 2));
+
+    // Suppress stderr
+    const origWrite = process.stderr.write;
+    process.stderr.write = () => true;
+
+    try {
+      migrateBranchingConfig(dir);
+    } finally {
+      process.stderr.write = origWrite;
+    }
+
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.ok(!('branching_strategy' in config), 'branching_strategy should be removed');
+    assert.ok(!('phase_branch_template' in config), 'phase_branch_template should be removed');
+    assert.ok(!('milestone_branch_template' in config), 'milestone_branch_template should be removed');
+    assert.strictEqual(config.model_profile, 'balanced', 'Other keys preserved');
+    assert.strictEqual(config.base_branch, 'main', 'base_branch preserved');
+
+    const local = JSON.parse(fs.readFileSync(path.join(dir, 'config.local.json'), 'utf-8'));
+    assert.strictEqual(local.branching_migration_done, true, 'migration_done flag should be set');
+  });
+
+  it('config with git.worktree_setup_command — key removed, empty git object removed', () => {
+    writeFile(dir, 'config.json', JSON.stringify({
+      model_profile: 'balanced',
+      git: { worktree_setup_command: 'npm install' },
+    }, null, 2));
+
+    // Suppress stderr
+    const origWrite = process.stderr.write;
+    process.stderr.write = () => true;
+
+    try {
+      migrateBranchingConfig(dir);
+    } finally {
+      process.stderr.write = origWrite;
+    }
+
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.ok(!('git' in config), 'git key should be removed when empty');
+    assert.strictEqual(config.model_profile, 'balanced', 'Other keys preserved');
+
+    const local = JSON.parse(fs.readFileSync(path.join(dir, 'config.local.json'), 'utf-8'));
+    assert.strictEqual(local.branching_migration_done, true, 'migration_done flag should be set');
+  });
+
+  it('already migrated — immediate no-op', () => {
+    writeFile(dir, 'config.json', JSON.stringify({
+      branching_strategy: 'none',
+      model_profile: 'balanced',
+    }, null, 2));
+    writeFile(dir, 'config.local.json', JSON.stringify({
+      branching_migration_done: true,
+    }, null, 2));
+
+    migrateBranchingConfig(dir);
+
+    // config.json should NOT be modified (branching_strategy still there)
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.strictEqual(config.branching_strategy, 'none', 'branching_strategy should still be present (migration skipped)');
+  });
+
+  it('git object preserved when other keys exist besides worktree_setup_command', () => {
+    writeFile(dir, 'config.json', JSON.stringify({
+      model_profile: 'balanced',
+      git: {
+        worktree_setup_command: 'npm install',
+        sync_push: 'auto',
+      },
+    }, null, 2));
+
+    // Suppress stderr
+    const origWrite = process.stderr.write;
+    process.stderr.write = () => true;
+
+    try {
+      migrateBranchingConfig(dir);
+    } finally {
+      process.stderr.write = origWrite;
+    }
+
+    const config = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'));
+    assert.ok(!('worktree_setup_command' in config.git), 'worktree_setup_command should be removed');
+    assert.strictEqual(config.git.sync_push, 'auto', 'Other git keys preserved');
+    assert.ok('git' in config, 'git object should still exist');
+  });
+});