@ktpartners/dgs-platform 2.8.0 → 3.0.4

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

@@ -37,6 +37,38 @@ function captureCommitOutput(fn) {
   return null;
 }
 
+/**
+ * Capture stdout output from functions that use process.stdout.write + process.exit.
+ * core.cjs output() writes via process.stdout.write and then calls process.exit(0),
+ * which would terminate the test process. This helper mocks both so multiple
+ * cmdCommit invocations can run in sequence and their output is inspectable.
+ *
+ * Returns { stdout: string, exitCode: number|null, json: any|null }.
+ */
+function captureStdout(fn) {
+  const chunks = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  const origExit = process.exit;
+  let exitCode = null;
+  process.stdout.write = (data) => { chunks.push(String(data)); return true; };
+  process.exit = (code) => {
+    exitCode = code == null ? 0 : code;
+    throw new Error('__EXIT__');
+  };
+  try {
+    fn();
+  } catch (e) {
+    if (e && e.message !== '__EXIT__') throw e;
+  } finally {
+    process.stdout.write = origWrite;
+    process.exit = origExit;
+  }
+  const stdout = chunks.join('');
+  let json = null;
+  try { json = JSON.parse(stdout); } catch { /* not JSON */ }
+  return { stdout, exitCode, json };
+}
+
 /**
  * Set up a temp project with git, write a file, and return the fixture.
  */
@@ -323,3 +355,307 @@ describe('cmdCommit with push=true, sync_push unset (defaults to off)', () => {
     assert.equal(result.needs_push, undefined);
   });
 });
+
+// ─── --repo-cwd flag tests ────────────────────────────────────────────────────
+
+describe('cmdCommit with --repo-cwd flag', () => {
+  let planningFixture;
+  let worktreeFixture;
+  let commands;
+
+  beforeEach(() => {
+    // Planning-root fixture: holds config, sync_push=off so pushAll won't be
+    // invoked when push=false.
+    planningFixture = setupGitFixture('off');
+    // "Worktree" fixture: a second independent git repo where commits should
+    // actually land when --repo-cwd is passed.
+    worktreeFixture = setupGitFixture('off');
+    // Clear require cache so we load a fresh commands module that picks up
+    // any test-time mutations (e.g., mocked sync.pushAll).
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    planningFixture.cleanup();
+    worktreeFixture.cleanup();
+  });
+
+  it('runs git add/commit/rev-parse in repoCwd, not cwd', () => {
+    // Write file in the worktree, NOT in the planning root
+    const fileName = 'worktree-file.txt';
+    fs.writeFileSync(
+      path.join(worktreeFixture.cwd, fileName),
+      'worktree content'
+    );
+
+    // Record each repo's HEAD before the commit
+    const planningHeadBefore = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    const worktreeHeadBefore = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+
+    // Call cmdCommit with cwd=planning, repoCwd=worktree.
+    // raw=false so output() writes JSON (with rawValue undefined path).
+    const capture = captureStdout(() => {
+      commands.cmdCommit(
+        planningFixture.cwd,          // cwd
+        'test: commit in worktree',   // message
+        [fileName],                   // files (relative to repoCwd)
+        false,                        // raw (false => JSON output)
+        false,                        // amend
+        false,                        // push
+        worktreeFixture.cwd           // repoCwd
+      );
+    });
+
+    // Parse result
+    const result = capture.json;
+    assert.ok(result, 'Expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, true, 'Expected committed=true');
+    assert.ok(result.hash, 'Expected a commit hash');
+
+    // HEAD must have advanced in the worktree
+    const worktreeHeadAfter = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.notEqual(worktreeHeadAfter, worktreeHeadBefore,
+      'worktree HEAD must have advanced');
+    assert.ok(worktreeHeadAfter.startsWith(result.hash),
+      `worktree HEAD (${worktreeHeadAfter}) should start with returned hash (${result.hash})`);
+
+    // Planning-root HEAD must be unchanged
+    const planningHeadAfter = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.equal(planningHeadAfter, planningHeadBefore,
+      'planning-root HEAD must NOT have moved');
+  });
+
+  it('loads config from cwd, not repoCwd (push uses planning-root config)', () => {
+    // Planning fixture has sync_push=auto
+    planningFixture.cleanup();
+    planningFixture = setupGitFixture('auto');
+
+    // Write file in worktree
+    const fileName = 'pushable.txt';
+    fs.writeFileSync(
+      path.join(worktreeFixture.cwd, fileName),
+      'pushable content'
+    );
+
+    // Mock pushAll and capture what cwd it's called with
+    let pushAllCwd = null;
+    const restore = mockPushAll((cwd) => {
+      pushAllCwd = cwd;
+      return { ok: true, results: [], summary: '' };
+    });
+
+    try {
+      const capture = captureStdout(() => {
+        commands.cmdCommit(
+          planningFixture.cwd,
+          'test: push uses planning cwd',
+          [fileName],
+          false,                      // raw=false => JSON output
+          false,
+          true,                       // push=true
+          worktreeFixture.cwd         // repoCwd
+        );
+      });
+      const result = capture.json;
+      assert.ok(result, 'Expected JSON result. stdout: ' + capture.stdout);
+      assert.equal(result.committed, true);
+      assert.equal(pushAllCwd, planningFixture.cwd,
+        'pushAll must be called with planning-root cwd, not worktree repoCwd');
+    } finally {
+      restore();
+    }
+  });
+
+  it('behaves identically to pre-change when repoCwd is undefined', () => {
+    // Write file in planning root (as existing tests do)
+    writeAndStageFile(planningFixture.cwd, 'no-repo-cwd.txt', 'regression');
+    const headBefore = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+
+    // Call cmdCommit with NO repoCwd (existing 6-arg signature)
+    const capture = captureStdout(() => {
+      commands.cmdCommit(
+        planningFixture.cwd,
+        'test: no repo-cwd regression',
+        [],
+        false,                        // raw=false => JSON output
+        false,
+        false
+        // no 7th arg
+      );
+    });
+    const result = capture.json;
+    assert.ok(result, 'Expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+
+    // Commit must land in planningFixture.cwd (not elsewhere)
+    const headAfter = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.notEqual(headAfter, headBefore,
+      'planning-root HEAD must have advanced when no repoCwd is passed');
+    assert.ok(headAfter.startsWith(result.hash),
+      'planning-root HEAD should match returned hash');
+  });
+
+  it('dgs-tools commit CLI parses --repo-cwd flag and targets that directory', () => {
+    // Write file in the worktree (a separate git repo)
+    const fileName = 'cli-repo-cwd.txt';
+    fs.writeFileSync(
+      path.join(worktreeFixture.cwd, fileName),
+      'cli content'
+    );
+
+    const worktreeHeadBefore = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+
+    // Invoke dgs-tools.cjs commit with --repo-cwd from planningFixture.cwd
+    const dgsTools = path.resolve(__dirname, '..', 'dgs-tools.cjs');
+    const cliOut = execSync(
+      `node "${dgsTools}" commit "cli test repo-cwd" --raw --repo-cwd "${worktreeFixture.cwd}" --files "${fileName}"`,
+      { cwd: planningFixture.cwd, encoding: 'utf-8' }
+    );
+    // --raw with a hash rawValue outputs the hash only (not JSON)
+    const hash = cliOut.trim();
+    assert.ok(hash.length > 0, 'Expected some hash/output. stdout: ' + cliOut);
+
+    // Verify the commit landed in the worktree repo
+    const worktreeHeadAfter = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.notEqual(worktreeHeadAfter, worktreeHeadBefore,
+      'worktree HEAD must advance when --repo-cwd targets it');
+    assert.ok(worktreeHeadAfter.startsWith(hash),
+      `worktree HEAD (${worktreeHeadAfter}) should start with CLI hash (${hash})`);
+  });
+});
+
+// ─── TODO_STATUSES constant ─────────────────────────────────────────────────
+
+describe('TODO_STATUSES constant', () => {
+  it('exports correct values', () => {
+    const { TODO_STATUSES } = require('./commands.cjs');
+    assert.deepStrictEqual(TODO_STATUSES, ['pending', 'done']);
+  });
+});
+
+// ─── setTodoStatus ──────────────────────────────────────────────────────────
+
+describe('setTodoStatus', () => {
+  it('throws on invalid status', () => {
+    const { setTodoStatus } = require('./commands.cjs');
+    assert.throws(() => {
+      setTodoStatus('/nonexistent', 'test.md', 'invalid-status');
+    }, (err) => {
+      assert.ok(err.message.includes('Invalid status'));
+      assert.ok(err.message.includes('pending'));
+      assert.ok(err.message.includes('done'));
+      return true;
+    });
+  });
+});
+
+// ─── cmdListTodos flat-first scanning ─────────────────────────────────────
+
+describe('cmdListTodos flat-first scanning', () => {
+  const { cmdListTodos } = require('./commands.cjs');
+
+  /**
+   * Capture JSON output from cmdListTodos.
+   */
+  function captureTodosOutput(fn) {
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => logs.push(args.join(' '));
+    try {
+      fn();
+    } finally {
+      console.log = origLog;
+    }
+    return logs.length ? JSON.parse(logs[0]) : null;
+  }
+
+  it('lists todos from flat todos/ directory', () => {
+    const fixture = createTempProject({ withGit: true });
+    try {
+      const todosDir = path.join(fixture.planningDir, 'todos');
+      fs.mkdirSync(todosDir, { recursive: true });
+      fs.writeFileSync(path.join(todosDir, 'test-todo.md'), '---\nstatus: pending\ntitle: Test Todo\ncreated: 2026-04-06\narea: general\n---\n\nTodo body.\n');
+      const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+      assert.equal(result.count, 1);
+      assert.equal(result.todos[0].status, 'pending');
+      assert.ok(!result.todos[0].path.includes('pending/'), 'Flat path should NOT contain pending/');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('excludes done todos from flat directory', () => {
+    const fixture = createTempProject({ withGit: true });
+    try {
+      const todosDir = path.join(fixture.planningDir, 'todos');
+      fs.mkdirSync(todosDir, { recursive: true });
+      fs.writeFileSync(path.join(todosDir, 'done-todo.md'), '---\nstatus: done\ntitle: Done Todo\ncreated: 2026-04-06\narea: general\n---\n\nDone.\n');
+      const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+      assert.equal(result.count, 0, 'Done todos should be excluded');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('falls back to legacy todos/pending/ with warning', () => {
+    const fixture = createTempProject({ withTodos: true, withGit: true });
+    try {
+      const pendingDir = path.join(fixture.planningDir, 'todos', 'pending');
+      fs.mkdirSync(pendingDir, { recursive: true });
+      fs.writeFileSync(path.join(pendingDir, 'legacy-todo.md'), '---\ntitle: Legacy Todo\ncreated: 2026-04-06\narea: general\n---\n\nLegacy.\n');
+      const origWrite = process.stderr.write;
+      let stderrOutput = '';
+      process.stderr.write = (msg) => { stderrOutput += msg; };
+      try {
+        const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+        assert.equal(result.count, 1);
+        assert.ok(stderrOutput.includes('[DGS] Warning:'), 'Should emit legacy warning');
+        assert.ok(result.todos[0].path.includes('pending/'), 'Legacy path should contain pending/');
+      } finally {
+        process.stderr.write = origWrite;
+      }
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('deduplicates when same file in flat and legacy', () => {
+    const fixture = createTempProject({ withGit: true });
+    try {
+      const todosDir = path.join(fixture.planningDir, 'todos');
+      const pendingDir = path.join(todosDir, 'pending');
+      fs.mkdirSync(pendingDir, { recursive: true });
+      const todoContent = '---\nstatus: pending\ntitle: Dedup Test\ncreated: 2026-04-06\narea: general\n---\n\nBody.\n';
+      fs.writeFileSync(path.join(todosDir, 'dedup-test.md'), todoContent);
+      fs.writeFileSync(path.join(pendingDir, 'dedup-test.md'), todoContent);
+      // Suppress stderr
+      const origWrite = process.stderr.write;
+      process.stderr.write = () => {};
+      try {
+        const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+        assert.equal(result.count, 1, 'No duplicates');
+      } finally {
+        process.stderr.write = origWrite;
+      }
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});

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

@@ -26,6 +26,7 @@ const LOCAL_KEYS = new Set([
   'planningRoot',
   'v2_hint_shown',
   'sync_hint_shown',
+  'execution',
 ]);
 
 const VALID_CONFIG_KEYS = new Set([
@@ -34,7 +35,7 @@ const VALID_CONFIG_KEYS = new Set([
   'workflow.research', 'workflow.plan_check', 'workflow.verifier',
   'workflow.nyquist_validation', 'workflow.ui_phase', 'workflow.ui_safety_gate',
   'workflow._auto_chain_active', 'workflow.discipline', 'workflow.codereview',
-  'git.base_branch', 'git.branching_strategy', 'git.phase_branch_template', 'git.milestone_branch_template',
+  'git.base_branch',
   'git.sync', 'git.sync_push', 'git.sync_pull',
   'planning.commit_docs', 'planning.search_gitignored',
 ]);
@@ -161,9 +162,6 @@ function cmdConfigEnsureSection(cwd, raw) {
     model_profile: 'balanced',
     commit_docs: true,
     search_gitignored: false,
-    branching_strategy: 'none',
-    phase_branch_template: 'dgs/{project}/phase-{phase}-{slug}',
-    milestone_branch_template: 'dgs/{project}/{milestone}-{slug}',
     base_branch: 'main',
     workflow: {
       research: true,
@@ -173,8 +171,8 @@ function cmdConfigEnsureSection(cwd, raw) {
       discipline: true,
     },
     git: {
-      sync_push: 'prompt',
-      sync_pull: 'prompt',
+      sync_push: 'auto',
+      sync_pull: 'auto',
     },
     parallelization: true,
     brave_search: hasBraveSearch,
@@ -265,6 +263,40 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
   }
 }
 
+/**
+ * CLI: Set a key in config.local.json (no VALID_CONFIG_KEYS gate).
+ * Used by workflows to write local-only fields like execution.active_context.
+ */
+function cmdConfigLocalSet(cwd, keyPath, value, raw) {
+  if (!keyPath) {
+    error('Usage: config-local-set <key.path> <value>');
+  }
+
+  let parsedValue = value;
+  if (value === 'true') parsedValue = true;
+  else if (value === 'false') parsedValue = false;
+  else if (value === 'null') parsedValue = null;
+  else if (!isNaN(value) && value !== '') parsedValue = Number(value);
+
+  const localPath = getLocalConfigPath(cwd);
+  let config = _readJsonSafe(localPath);
+
+  const keys = keyPath.split('.');
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === undefined || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = parsedValue;
+
+  _writeJson(localPath, config);
+  const result = { updated: true, key: keyPath, value: parsedValue, file: 'config.local.json' };
+  output(result, raw, `${keyPath}=${parsedValue}`);
+}
+
 function cmdConfigGet(cwd, keyPath, raw) {
   if (!keyPath) {
     error('Usage: config-get <key.path>');
@@ -520,6 +552,7 @@ module.exports = {
   getReviewKeysPath,
   cmdConfigEnsureSection,
   cmdConfigSet,
+  cmdConfigLocalSet,
   cmdConfigGet,
   writeConfigField,
   loadReviewConfig,

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

@@ -911,6 +911,125 @@ function cmdContextLoadTier(cwd, tierName, args, raw) {
   output(result, raw, result.files.map(f => f.path).join('\n'));
 }
 
+// ─── Code Context Resolution ──────────────────────────────────────────────
+
+// Lazy requires to avoid circular dependencies (repos.cjs requires core.cjs)
+function _getRepos() { return require('./repos.cjs'); }
+const { getLocalConfigPath } = require('./config.cjs');
+
+/**
+ * Resolve the active code context for a repo.
+ *
+ * Returns the directory where code operations should target:
+ * - Main checkout when no active context
+ * - Milestone worktree when milestone context active
+ * - Quick worktree when quick context active
+ *
+ * Handles stale contexts (missing directories) by clearing
+ * active_context and falling back to main with a warning.
+ *
+ * @param {string} cwd - Working directory (for config resolution)
+ * @param {string} repoName - Name of the repo (as in REPOS.md)
+ * @returns {{ type: string, directory: string, slug?: string, mode?: string }}
+ */
+function resolveCodeContext(cwd, repoName) {
+  const localPath = getLocalConfigPath(cwd);
+  let local;
+  try {
+    local = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+  } catch {
+    local = {};
+  }
+
+  const activeContext = local && local.execution && local.execution.active_context;
+  if (!activeContext) {
+    // No active context -- resolve to main checkout
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Look up the current project
+  const project = local.current_project;
+  if (!project) {
+    // No project set -- fall back to main
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Look up worktree entry
+  const worktreeEntry = local.projects
+    && local.projects[project]
+    && local.projects[project].worktrees
+    && local.projects[project].worktrees[activeContext];
+
+  if (!worktreeEntry) {
+    // Stale context -- entry missing from config
+    process.stderr.write(
+      'Warning: Active context \'' + activeContext + '\' not found in worktree state. Falling back to main.\n'
+    );
+    _clearActiveContext(localPath, local);
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Look up repo directory in worktree entry
+  const worktreeDir = worktreeEntry.repos && worktreeEntry.repos[repoName];
+  if (!worktreeDir) {
+    // Repo not in this worktree -- fall back to main
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Validate directory exists on disk
+  if (!fs.existsSync(worktreeDir)) {
+    // Stale context -- directory missing
+    process.stderr.write(
+      'Warning: Active context \'' + activeContext + '\' is stale -- worktree directory no longer exists at ' + worktreeDir + '. Falling back to main.\n'
+    );
+    _clearActiveContext(localPath, local);
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  return {
+    type: worktreeEntry.type || 'milestone',
+    directory: worktreeDir,
+    slug: activeContext,
+    mode: worktreeEntry.mode || null,
+  };
+}
+
+/**
+ * Resolve main checkout path for a repo.
+ * @private
+ */
+function _resolveMainCheckout(cwd, repoName) {
+  try {
+    const parsed = _getRepos().parseReposMd(cwd);
+    if (parsed && parsed.repos) {
+      const repo = parsed.repos.find(function(r) { return r.name === repoName; });
+      if (repo && repo.path) {
+        const root = getPlanningRoot(cwd);
+        const absPath = path.resolve(root, repo.path);
+        return { type: 'main', directory: absPath };
+      }
+    }
+  } catch {
+    // REPOS.md not found or parse error
+  }
+  // Fallback: return cwd
+  return { type: 'main', directory: cwd };
+}
+
+/**
+ * Clear active_context in config.local.json.
+ * @private
+ */
+function _clearActiveContext(localPath, localData) {
+  try {
+    if (!localData.execution) localData.execution = {};
+    localData.execution.active_context = null;
+    fs.writeFileSync(localPath, JSON.stringify(localData, null, 2) + '\n', 'utf-8');
+  } catch {
+    // Best effort -- don't crash on write failure
+  }
+}
+
 // ─── Exports ────────────────────────────────────────────────────────────────
 
 module.exports = {
@@ -918,6 +1037,7 @@ module.exports = {
   cmdContextLoadTier,
   truncateApprovedSpec,
   resetTierCache,
+  resolveCodeContext,
   // Internal exports for testing
   parseTierDefinitions,
   parseSimpleYaml,

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

@@ -71,9 +71,6 @@ function loadConfig(cwd) {
     model_profile: 'balanced',
     commit_docs: true,
     search_gitignored: false,
-    branching_strategy: 'none',
-    phase_branch_template: 'dgs/{project}/phase-{phase}-{slug}',
-    milestone_branch_template: 'dgs/{project}/{milestone}-{slug}',
     base_branch: 'main',
     sync_push: 'off',
     sync_pull: 'off',
@@ -144,9 +141,6 @@ function loadConfig(cwd) {
       model_profile: get('model_profile') ?? defaults.model_profile,
       commit_docs: get('commit_docs', { section: 'planning', field: 'commit_docs' }) ?? defaults.commit_docs,
       search_gitignored: get('search_gitignored', { section: 'planning', field: 'search_gitignored' }) ?? defaults.search_gitignored,
-      branching_strategy: get('branching_strategy', { section: 'git', field: 'branching_strategy' }) ?? defaults.branching_strategy,
-      phase_branch_template: get('phase_branch_template', { section: 'git', field: 'phase_branch_template' }) ?? defaults.phase_branch_template,
-      milestone_branch_template: get('milestone_branch_template', { section: 'git', field: 'milestone_branch_template' }) ?? defaults.milestone_branch_template,
       base_branch: get('base_branch', { section: 'git', field: 'base_branch' }) ?? defaults.base_branch,
       sync_push: get('sync_push', { section: 'git', field: 'sync_push' }) ?? defaults.sync_push,
       sync_pull: get('sync_pull', { section: 'git', field: 'sync_pull' }) ?? defaults.sync_pull,
@@ -472,7 +466,14 @@ function generateSlugInternal(text) {
 
 function getMilestoneInfo(cwd) {
   try {
-    const roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    // Try project-scoped ROADMAP first, then planning root
+    let roadmap;
+    try {
+      const projectRoot = getProjectRoot(cwd);
+      roadmap = fs.readFileSync(path.join(cwd, projectRoot, 'ROADMAP.md'), 'utf-8');
+    } catch {
+      roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    }
 
     // First: check for list-format roadmaps using 🚧 (in-progress) marker
     // e.g. "- 🚧 **v2.1 Belgium** — Phases 24-28 (in progress)"
@@ -484,10 +485,20 @@ function getMilestoneInfo(cwd) {
       };
     }
 
-    // Second: heading-format roadmaps — strip shipped milestones in <details> blocks
+    // Second: bullet-list format with "(in progress)" marker
+    // e.g. "- v19.0 Git Worktrees -- Phases 124-129 (in progress)"
+    const bulletMatch = roadmap.match(/^- v(\d+\.\d+)\s+(.+?)\s+--\s+Phases\s+\S+\s+\(in progress\)/m);
+    if (bulletMatch) {
+      return {
+        version: 'v' + bulletMatch[1],
+        name: bulletMatch[2].trim(),
+      };
+    }
+
+    // Third: heading-format roadmaps — strip shipped milestones in <details> blocks
     const cleaned = roadmap.replace(/<details>[\s\S]*?<\/details>/gi, '');
-    // Extract version and name from the same ## heading for consistency
-    const headingMatch = cleaned.match(/## .*v(\d+\.\d+)[:\s]+([^\n(]+)/);
+    // e.g. "### v19.0 Git Worktrees (In Progress)"
+    const headingMatch = cleaned.match(/#{2,3}\s+v(\d+\.\d+)[:\s]+([^\n(]+)/);
     if (headingMatch) {
       return {
         version: 'v' + headingMatch[1],
@@ -513,7 +524,13 @@ function getMilestoneInfo(cwd) {
 function getMilestonePhaseFilter(cwd) {
   const milestonePhaseNums = new Set();
   try {
-    const roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    let roadmap;
+    try {
+      const projectRoot = getProjectRoot(cwd);
+      roadmap = fs.readFileSync(path.join(cwd, projectRoot, 'ROADMAP.md'), 'utf-8');
+    } catch {
+      roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    }
     const phasePattern = /#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:/gi;
     let m;
     while ((m = phasePattern.exec(roadmap)) !== null) {