@ktpartners/dgs-platform 3.5.1 → 3.5.3

package/CHANGELOG.md

@@ -8,6 +8,19 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [3.5.3] - 2026-06-28
+
+### Fixed
+- **Flat-first jobs tests (quick-260628-r5i)** — aligned the root `tests/jobs.test.cjs` with the flat-first `listJobs` behavior introduced in 3.5.2 (which had updated `bin/lib/jobs.test.cjs` but left the root copy stale, leaving the suite 61/2 on that file). The grouped-jobs test now writes flat `jobs/milestone-*.md` files grouped by frontmatter status, and the directory test asserts the legacy `jobs/pending|in-progress|completed/` subdirs are NOT auto-created. Suite back to green.
+
+## [3.5.2] - 2026-06-28
+
+### Fixed
+- **Flat-store readers flat-first (quick-260628-otc)** — `search.cjs scanIdeas`, `jobs.cjs listJobs`, and `ideas.cjs cmdIdeasFindRelated` now read the migrated flat frontmatter-status layout (`ideas/*.md`, `jobs/milestone-*.md`) first, so `/dgs:search`, `/dgs:list-jobs`, `/dgs:diff-report`, and `/dgs:find-related-ideas` no longer silently return nothing on flat installs. `listJobs` is now read-only (stops recreating abandoned `jobs/{pending,in-progress,completed}` subdirs) and `cmdIdeasUpdate` returns the file's real flat path. Legacy status-subdirs remain an existence-gated fallback.
+- **Versioned phases-dir scanners (quick-260628-p59)** — `verify.cjs` (consistency + health W010), `overlap.cjs`, `projects.cjs`, and `package-scan-report.cjs` now descend `phases/<version>/NN-slug/` (via `core.phasesDir` / `isValidMilestoneVersion`) instead of treating the `vN.N` version dir as a phase dir, so consistency validation, `/dgs:overlap-check`, repos-touched listings, and package-scan active-phase reports work under per-milestone numbering. Flat layout still supported.
+- **Versioned phases-dir workflow globs (quick-260628-pn3)** — 9 phases-dir globs/heuristics across 7 workflows (`complete-milestone`, `audit-milestone`, `plan-phase`, `discuss-phase`, `pause-work`, `resume-project`, `cleanup`) are now dual-layout (flat + `phases/<version>/`), so milestone-completion accomplishment extraction, SUMMARY cross-checks, prior-phase continuity, pause/resume detection, and cleanup no longer come up empty on versioned milestones. Also drops a GNU-only `grep -oP`.
+- **Roadmap milestone parsers recognize all formats (quick-260628-pxx)** — `detectActiveMilestone`, `getMilestoneInfo`, `parseProjectMilestone`, `cmdPhaseAdd` range-bump, and `cmdRoadmapAnalyze` now recognize the ad-hoc `## Active Milestone: vX.Y`, single-milestone bold-line `**Milestone:** vX.Y`, and per-milestone-namespaced `Phases vX.Y/N-M` formats (additively, milestone-name-preserving), gated against multi-milestone over-match. Fixes blank dashboard milestone, `create-milestone` "No active milestone found", and stale `add-phase` ranges on the newer roadmap formats.
+
 ## [3.5.1] - 2026-06-28
 
 ### Added

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

@@ -534,6 +534,27 @@ function getMilestoneInfo(cwd) {
         name: headingMatch[2].trim(),
       };
     }
+    // Ad-hoc container format: "## Active Milestone: v25.1 add-prs" — version
+    // and real NAME live on the heading. Runs after the heading branch so a
+    // legacy "### vX.Y Name" heading still wins; the literal "Active Milestone:"
+    // prefix is specific enough to run un-gated.
+    const adhoc = cleaned.match(/^##\s+Active Milestone:\s*v(\d+\.\d+)\s+(.+?)\s*$/im);
+    if (adhoc) {
+      return { version: 'v' + adhoc[1], name: adhoc[2].trim() };
+    }
+
+    // Bold-line single-milestone format: "**Milestone:** v30.1 — Name".
+    // GATED single-milestone (mirror analyzeMilestonePhases): only when at most
+    // one version-bearing heading exists, so a stray bold line never hijacks a
+    // multi-milestone heading roadmap.
+    const versionHeadings = cleaned.match(/^#{2,4}\s+.*v\d+\.\d+/gim) || [];
+    if (versionHeadings.length <= 1) {
+      const bold = cleaned.match(/^\*\*Milestone:\*\*\s*v(\d+\.\d+)\s*(?:[—-]\s*)?(.*)$/im);
+      if (bold) {
+        return { version: 'v' + bold[1], name: bold[2].trim() || 'milestone' };
+      }
+    }
+
     // Fallback: try bare version match
     const versionMatch = cleaned.match(/v(\d+\.\d+)/);
     return {

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

@@ -28,6 +28,7 @@ const {
   resolveModelInternal,
   MODEL_PROFILES,
   findPhaseInternal,
+  getMilestoneInfo,
 } = require('./core.cjs');
 
 // ─── Root layout (no v2 markers) Tests ───────────────────────────────────────
@@ -1157,3 +1158,68 @@ describe('MODEL_PROFILES dgs-idea-researcher tiering', () => {
   });
 
 });
+
+// ─── getMilestoneInfo format coverage ───────────────────────────────────────
+describe('getMilestoneInfo all-format coverage', () => {
+  let fixture;
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+  });
+
+  const ADHOC_ROADMAP = `# Roadmap
+
+## Active Milestone: v25.1 add-prs
+
+**Goal:** add-prs
+**Status:** In progress (ad-hoc container — phases added on demand via /dgs:add-phase)
+
+Phases:
+
+---
+`;
+
+  const BOLD_LINE_ROADMAP = `# Roadmap: Tenant data-quality metrics in Admin UI (v30.1)
+
+**Milestone:** v30.1 — Tenant data-quality metrics in Admin UI
+
+## Overview
+
+Single-milestone roadmap. Version is only in the title and the bold line.
+`;
+
+  // Multi-milestone heading roadmap WITH a stray bold line: the heading branch
+  // must win, the gated bold-line branch must stay inert.
+  const MULTI_MILESTONE_WITH_STRAY_BOLD = `# Roadmap
+
+**Milestone:** v9.9 — stray bold line
+
+## v1.0 Foundation
+Some shipped work.
+
+## v2.0 Next
+Current work here.
+`;
+
+  it('returns the real name for an ad-hoc roadmap (not generic milestone)', () => {
+    fixture = createFixture({ 'ROADMAP.md': ADHOC_ROADMAP });
+    assert.deepEqual(getMilestoneInfo(fixture.cwd), { version: 'v25.1', name: 'add-prs' });
+  });
+
+  it('returns the real name for a bold-line single-milestone roadmap', () => {
+    fixture = createFixture({ 'ROADMAP.md': BOLD_LINE_ROADMAP });
+    assert.deepEqual(getMilestoneInfo(fixture.cwd), {
+      version: 'v30.1',
+      name: 'Tenant data-quality metrics in Admin UI',
+    });
+  });
+
+  it('resolves a multi-milestone heading roadmap via the heading branch (bold line does not hijack)', () => {
+    fixture = createFixture({ 'ROADMAP.md': MULTI_MILESTONE_WITH_STRAY_BOLD });
+    const info = getMilestoneInfo(fixture.cwd);
+    // Heading branch wins → version is the first heading's (v1.0), NOT the stray
+    // bold line's v9.9. The key assertion is that the bold line did not hijack.
+    assert.notEqual(info.version, 'v9.9');
+    assert.equal(info.version, 'v1.0');
+  });
+});

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

@@ -475,11 +475,12 @@ function cmdIdeasUpdate(cwd, idOrFilename, field, value, raw, author) {
     }
   }
 
-  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
   const result = {
     id: fm.id,
     filename: newFilename,
-    path: path.join(planRootRel, 'ideas', idea.state, newFilename),
+    // Derive the returned path from the file's REAL location so it is correct
+    // for both flat (dirname is ideas/) and legacy (dirname is ideas/<state>/).
+    path: path.relative(cwd, path.join(path.dirname(idea.path), newFilename)),
     field,
     old_value: oldValue,
     new_value: value,
@@ -1294,23 +1295,50 @@ function cmdIdeasFindRelated(cwd, options, raw) {
 
   const anchorTags = anchor.frontmatter.tags || [];
 
-  // 2. Load all other pending ideas
-  const pendingDir = path.join(getPlanningRoot(cwd), 'ideas', 'pending');
-  let pendingFiles;
+  // 2. Load all other pending ideas — flat-first (mirror cmdIdeasList's flat
+  //    scan), with legacy ideas/pending/ as an existence-gated dedup fallback.
+  const candidateContents = [];
+  const seenIds = new Set();
+
+  const flatDir = path.join(getPlanningRoot(cwd), 'ideas');
   try {
-    pendingFiles = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md'));
+    const flatFiles = fs.readdirSync(flatDir).filter(f => f.endsWith('.md') && !fs.statSync(path.join(flatDir, f)).isDirectory());
+    for (const file of flatFiles) {
+      const content = safeReadFile(path.join(flatDir, file));
+      if (!content) continue;
+      const parsed = parseIdeaFrontmatter(content);
+      if ((parsed.frontmatter.status || 'pending') !== 'pending') continue;
+      candidateContents.push(content);
+      seenIds.add(parsed.frontmatter.id);
+    }
   } catch {
-    pendingFiles = [];
+    // Flat directory may not exist — continue to legacy scan
+  }
+
+  // Legacy fallback: ideas/pending/ (existence-gated, deduped by id)
+  const pendingDir = path.join(getPlanningRoot(cwd), 'ideas', 'pending');
+  if (fs.existsSync(pendingDir)) {
+    let pendingFiles;
+    try {
+      pendingFiles = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md'));
+    } catch {
+      pendingFiles = [];
+    }
+    for (const file of pendingFiles) {
+      const content = safeReadFile(path.join(pendingDir, file));
+      if (!content) continue;
+      const parsed = parseIdeaFrontmatter(content);
+      if (seenIds.has(parsed.frontmatter.id)) continue;
+      candidateContents.push(content);
+      seenIds.add(parsed.frontmatter.id);
+    }
   }
 
   // 3. Score each candidate for tag overlap
   const matchLevelOrder = { HIGH: 0, MEDIUM: 1, LOW: 2, NONE: 3 };
   const candidates = [];
 
-  for (const file of pendingFiles) {
-    const content = safeReadFile(path.join(pendingDir, file));
-    if (!content) continue;
-
+  for (const content of candidateContents) {
     const parsed = parseIdeaFrontmatter(content);
     const candidateId = parsed.frontmatter.id;
 

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

@@ -10,7 +10,7 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { createTempDir, cleanupDir, createTempProject, initGitRepo } = require('./test-helpers.cjs');
 const { resetPaths } = require('./paths.cjs');
-const { findIdeaFile, parseIdeaFrontmatter, ensureIdeasDirs, cmdIdeasCreate, cmdIdeasList, loadManifest, IDEA_STATES, IDEA_STATUSES, setIdeaStatus, buildIdeaContent, cmdIdeasConsolidate, cmdIdeasFindRelated, cmdIdeasUndoConsolidation } = require('./ideas.cjs');
+const { findIdeaFile, parseIdeaFrontmatter, ensureIdeasDirs, cmdIdeasCreate, cmdIdeasList, cmdIdeasUpdate, loadManifest, IDEA_STATES, IDEA_STATUSES, setIdeaStatus, buildIdeaContent, cmdIdeasConsolidate, cmdIdeasFindRelated, cmdIdeasUndoConsolidation } = require('./ideas.cjs');
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -949,8 +949,9 @@ describe('cmdIdeasFindRelated', () => {
     const filename = `${paddedId}-${slug}.md`;
     const now = new Date().toISOString();
     const tagsStr = tags.length > 0 ? `[${tags.map(t => `"${t}"`).join(', ')}]` : '[]';
-    const content = `---\nid: ${id}\ntitle: "${title}"\ntags: ${tagsStr}\ncreated: ${now}\nupdated: ${now}\n---\n\n${body || title + ' body.'}\n`;
-    const dir2 = path.join(dir, 'ideas', 'pending');
+    const content = `---\nid: ${id}\ntitle: "${title}"\nstatus: pending\ntags: ${tagsStr}\ncreated: ${now}\nupdated: ${now}\n---\n\n${body || title + ' body.'}\n`;
+    // Flat layout: ideas/<paddedId>-<slug>.md (status in frontmatter)
+    const dir2 = path.join(dir, 'ideas');
     fs.mkdirSync(dir2, { recursive: true });
     fs.writeFileSync(path.join(dir2, filename), content, 'utf-8');
     // Update manifest so allocateId returns next ID correctly
@@ -1168,6 +1169,34 @@ describe('cmdIdeasFindRelated', () => {
         `match_level should be HIGH, MEDIUM, or LOW, got: ${r.match_level}`);
     }
   });
+
+  it('finds flat-layout pending candidates', () => {
+    // createPendingIdea now seeds FLAT ideas/*.md with status: pending.
+    createPendingIdea(tmpDir, 1, 'Anchor idea', ['api', 'reliability']);
+    createPendingIdea(tmpDir, 2, 'Flat candidate', ['api', 'reliability']);
+    const output = captureOutput(() => {
+      cmdIdeasFindRelated(tmpDir, { id: '1', threshold: 'low' }, true);
+    });
+    const result = JSON.parse(output);
+    assert.ok(result.results.length >= 1, 'should find at least one flat candidate');
+    assert.strictEqual(result.results[0].id, 2);
+    assert.strictEqual(result.counts.total, 1);
+  });
+
+  it('ideas update returns the real flat path (no state subdir segment)', () => {
+    // Seed a FLAT pending idea, then rename via title update.
+    createPendingIdea(tmpDir, 1, 'Original title', ['api']);
+    const output = captureOutput(() => {
+      cmdIdeasUpdate(tmpDir, '1', 'title', 'Renamed title', true);
+    });
+    const result = JSON.parse(output);
+    // Path must point to the flat location ideas/<file>, never ideas/pending/<file>.
+    assert.ok(!result.path.includes(`${path.sep}pending${path.sep}`),
+      `path should not contain a pending/ segment, got: ${result.path}`);
+    assert.match(result.path, /^ideas[\\/]001-renamed-title\.md$/);
+    assert.ok(fs.existsSync(path.join(tmpDir, result.path)),
+      `renamed file should exist at ${result.path}`);
+  });
 });
 
 // ─── cmdIdeasUndoConsolidation ────────────────────────────────────────────────

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

@@ -1472,6 +1472,29 @@ function parseProjectMilestone(roadmapPath) {
     return { milestone_version: 'v' + headingMatch[1], milestone_name: headingMatch[2].trim() };
   }
 
+  // Ad-hoc container: "## Active Milestone: v25.1 add-prs" (mirror getMilestoneInfo)
+  const adhoc = cleaned.match(/^##\s+Active Milestone:\s*v(\d+\.\d+)\s+(.+?)\s*$/im);
+  if (adhoc) {
+    return { milestone_version: 'v' + adhoc[1], milestone_name: adhoc[2].trim() };
+  }
+
+  // Bold-line single-milestone: "**Milestone:** v30.1 — Name", GATED to <=1
+  // version-bearing heading so a stray bold line never hijacks a multi-milestone
+  // roadmap (mirror getMilestoneInfo / analyzeMilestonePhases).
+  const versionHeadings = cleaned.match(/^#{2,4}\s+.*v\d+\.\d+/gim) || [];
+  if (versionHeadings.length <= 1) {
+    const bold = cleaned.match(/^\*\*Milestone:\*\*\s*v(\d+\.\d+)\s*(?:[—-]\s*)?(.*)$/im);
+    if (bold) {
+      return { milestone_version: 'v' + bold[1], milestone_name: bold[2].trim() || 'milestone' };
+    }
+  }
+
+  // Bare-version fallback (mirror getMilestoneInfo): any vX.Y rather than {null,null}.
+  const versionMatch = cleaned.match(/v(\d+\.\d+)/);
+  if (versionMatch) {
+    return { milestone_version: versionMatch[0], milestone_name: 'milestone' };
+  }
+
   return { milestone_version: null, milestone_name: null };
 }
 

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

@@ -2255,3 +2255,81 @@ describe('init execute-phase coerces ambiguous archive number to not-found (LOOK
     }
   });
 });
+
+// ─── progress-all milestone parsing (parseProjectMilestone) ─────────────────
+describe('init progress-all: parseProjectMilestone format coverage', () => {
+  let fixture;
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+  });
+
+  // Build a v2 fixture whose single active project's ROADMAP.md carries the
+  // supplied content, so progress-all → parseProjectMilestone exercises it.
+  function v2FixtureWithRoadmap(roadmapContent) {
+    return createFixture({
+      'config.json': JSON.stringify({ current_project: 'test-project' }),
+      'PROJECTS.md': '# Projects\n\n| Project | Status |\n|---------|--------|\n| test-project | Active |\n',
+      'REPOS.md': '# Repos\n\n| Name | Path |\n|------|------|\n',
+      'projects/test-project/STATE.md': '# State',
+      'projects/test-project/ROADMAP.md': roadmapContent,
+      'projects/test-project/REQUIREMENTS.md': '# Requirements',
+      'projects/test-project/PROJECT.md': '# Project',
+    });
+  }
+
+  const ADHOC_ROADMAP = `# Roadmap
+
+## Active Milestone: v25.1 add-prs
+
+**Goal:** add-prs
+**Status:** In progress (ad-hoc container — phases added on demand via /dgs:add-phase)
+
+Phases:
+
+---
+`;
+
+  const BOLD_LINE_ROADMAP = `# Roadmap: Tenant data-quality metrics in Admin UI (v30.1)
+
+**Milestone:** v30.1 — Tenant data-quality metrics in Admin UI
+
+## Overview
+
+Single-milestone roadmap.
+`;
+
+  // Only a bare vX.Y appears anywhere — exercises the new bare-version fallback.
+  const BARE_VERSION_ROADMAP = `# Roadmap
+
+Some prose mentioning v42.7 without any heading or bold milestone line.
+`;
+
+  function projectEntry(result) {
+    return (result.projects || []).find(p => p.name === 'test-project');
+  }
+
+  it('populates milestone_version + milestone_name for an ad-hoc project roadmap', () => {
+    fixture = v2FixtureWithRoadmap(ADHOC_ROADMAP);
+    const p = projectEntry(runInit(fixture.cwd, 'progress-all --raw'));
+    assert.ok(p, 'expected the active project in progress-all output');
+    assert.equal(p.milestone_version, 'v25.1');
+    assert.equal(p.milestone_name, 'add-prs');
+  });
+
+  it('populates milestone_version + milestone_name for a bold-line project roadmap', () => {
+    fixture = v2FixtureWithRoadmap(BOLD_LINE_ROADMAP);
+    const p = projectEntry(runInit(fixture.cwd, 'progress-all --raw'));
+    assert.ok(p, 'expected the active project in progress-all output');
+    assert.equal(p.milestone_version, 'v30.1');
+    assert.equal(p.milestone_name, 'Tenant data-quality metrics in Admin UI');
+  });
+
+  it('bare-version fallback returns the version (no longer null) when only vX.Y appears', () => {
+    fixture = v2FixtureWithRoadmap(BARE_VERSION_ROADMAP);
+    const p = projectEntry(runInit(fixture.cwd, 'progress-all --raw'));
+    assert.ok(p, 'expected the active project in progress-all output');
+    assert.equal(p.milestone_version, 'v42.7');
+    assert.notEqual(p.milestone_version, null);
+  });
+});

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

@@ -1298,6 +1298,12 @@ function detectActiveMilestone(content) {
   // Fallback: milestone list item with (in progress)
   const listMatch = content.match(/-\s+.*?(v\d+\.\d+).*?\((?:in\s+progress)\)/i);
   if (listMatch) return listMatch[1];
+  // Ad-hoc container format: version on the heading, in-progress on a separate
+  // **Status:** line (NO parenthetical on the heading). Runs after the legacy
+  // In-Progress heading/list signals so a real multi-milestone In-Progress
+  // heading still wins on multi-milestone roadmaps.
+  const adhocMatch = content.match(/^##\s+Active Milestone:\s*(v\d+\.\d+)/im);
+  if (adhocMatch) return adhocMatch[1];
   // Final fallback: newer single-milestone format with a `**Milestone:** vX.Y`
   // bold line. Runs LAST so legacy In-Progress heading/list signals win when
   // present on multi-milestone roadmaps.
@@ -1333,7 +1339,14 @@ function cmdJobsCreateMilestone(cwd, version, check, raw) {
       throw new Error('No active milestone found in ROADMAP.md');
     }
   } else {
-    // Validate the version exists in ROADMAP
+    // Validate the version exists in ROADMAP.
+    // Confirmed against every real generator: each emits whitespace immediately
+    // after the FIRST occurrence of the version — a space in the ad-hoc /
+    // bullet headings (`v25.1 add-prs`, `Active Milestone: v25.1 add-prs`) and a
+    // newline after the bold line (`**Milestone:** v25.1\n`). The namespaced
+    // `Phases v25.1/1-9` form has a non-whitespace `/` delimiter, but it is
+    // never the FIRST occurrence (the bold bullet `v25.1 add-prs` precedes it),
+    // so `\s+` always matches the first occurrence. No change needed here.
     const escapedV = resolvedVersion.replace(/\./g, '\\.');
     const versionPattern = new RegExp(escapedV + '\\s+', 'i');
     if (!versionPattern.test(roadmapContent)) {
@@ -1452,47 +1465,86 @@ function cmdJobsMilestonePreview(cwd, version, check, raw) {
 function listJobs(cwd) {
   const jobsDir = path.join(getPlanningRoot(cwd), 'jobs');
   const groups = { in_progress: [], pending: [], completed: [] };
-  const dirMap = { 'in-progress': 'in_progress', 'pending': 'pending', 'completed': 'completed' };
+  const statusToGroup = { 'in-progress': 'in_progress', 'pending': 'pending', 'completed': 'completed' };
 
-  for (const [dirName, groupKey] of Object.entries(dirMap)) {
-    const dirPath = path.join(jobsDir, dirName);
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
+  // Shared flat-job predicate (identical to findJobFile/healthCheck — reused,
+  // not reinvented). Excludes summary files (job-*-SUMMARY.md).
+  const isJobFile = f => f.startsWith('milestone-') && f.endsWith('.md');
+  const seenVersions = new Set();
+
+  // Stage entries with their mtime so each group sorts most-recent-first.
+  const staged = { in_progress: [], pending: [], completed: [] };
+
+  function stageEntry(groupKey, fullPath, parsed) {
+    let mtime = 0;
+    try { mtime = fs.statSync(fullPath).mtimeMs; } catch {}
+    staged[groupKey].push({
+      mtime,
+      entry: {
+        version: parsed.version,
+        status: parsed.status,
+        check: parsed.check,
+        created_by: parsed.created_by,
+        progress: `${parsed.completedCount}/${parsed.stepCount}`,
+        file: fullPath,
+      },
+    });
+  }
+
+  // Flat-first scan: jobs/milestone-*.md grouped by parsed frontmatter status.
+  let flatFiles = [];
+  try {
+    flatFiles = fs.readdirSync(jobsDir).filter(isJobFile);
+  } catch {
+    flatFiles = [];
+  }
+  for (const file of flatFiles) {
+    const fullPath = path.join(jobsDir, file);
+    try {
+      const parsed = parseJobFile(fullPath);
+      const groupKey = statusToGroup[parsed.status];
+      if (!groupKey) continue; // guard unknown/missing status
+      stageEntry(groupKey, fullPath, parsed);
+      if (parsed.version) seenVersions.add(parsed.version);
+    } catch {
+      // Skip unparseable files
     }
+  }
+
+  // Legacy subdir fallback — existence-gated, NEVER created (read-only).
+  const legacyDirs = ['in-progress', 'pending', 'completed'];
+  for (const dirName of legacyDirs) {
+    const dirPath = path.join(jobsDir, dirName);
+    if (!fs.existsSync(dirPath)) continue;
 
     let files;
     try {
-      files = fs.readdirSync(dirPath).filter(f => f.startsWith('milestone-') && f.endsWith('.md'));
+      files = fs.readdirSync(dirPath).filter(isJobFile);
     } catch {
       continue;
     }
-
-    // Sort by modification time, most recent first
-    const fileStats = files.map(f => {
-      const fullPath = path.join(dirPath, f);
-      let mtime = 0;
-      try { mtime = fs.statSync(fullPath).mtimeMs; } catch {}
-      return { file: f, fullPath, mtime };
-    });
-    fileStats.sort((a, b) => b.mtime - a.mtime);
-
-    for (const { file, fullPath } of fileStats) {
+    for (const file of files) {
+      const fullPath = path.join(dirPath, file);
       try {
         const parsed = parseJobFile(fullPath);
-        groups[groupKey].push({
-          version: parsed.version,
-          status: parsed.status,
-          check: parsed.check,
-          created_by: parsed.created_by,
-          progress: `${parsed.completedCount}/${parsed.stepCount}`,
-          file: fullPath,
-        });
+        if (parsed.version && seenVersions.has(parsed.version)) continue;
+        // Group by parsed status, falling back to the dir name if status missing.
+        const groupKey = statusToGroup[parsed.status] || statusToGroup[dirName];
+        if (!groupKey) continue;
+        stageEntry(groupKey, fullPath, parsed);
+        if (parsed.version) seenVersions.add(parsed.version);
       } catch {
         // Skip unparseable files
       }
     }
   }
 
+  // Sort each group most-recent-first and unwrap to entry objects.
+  for (const key of Object.keys(groups)) {
+    staged[key].sort((a, b) => b.mtime - a.mtime);
+    groups[key] = staged[key].map(s => s.entry);
+  }
+
   return groups;
 }
 

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

@@ -1479,6 +1479,100 @@ Plans:
     });
   });
 
+  // ─── Ad-hoc container format ────────────────────────────────────────────
+  describe('ad-hoc container format', () => {
+    let fixture;
+
+    afterEach(() => {
+      if (fixture) fixture.cleanup();
+    });
+
+    // Bare seedAdhocRoadmapSection output: version on the heading, in-progress
+    // on a SEPARATE **Status:** line, NO parenthetical on the heading, and NO
+    // phase headings. Used only for the pure detectActiveMilestone assertions.
+    const ADHOC_ROADMAP = `# Roadmap
+
+## Active Milestone: v25.1 add-prs
+
+**Goal:** add-prs
+**Status:** In progress (ad-hoc container — phases added on demand via /dgs:add-phase)
+
+Phases:
+
+---
+`;
+
+    // Ad-hoc container that has accrued a phase (heading + matching PLAN dir),
+    // so analyzeMilestonePhases (called by cmdJobsMilestonePreview) resolves
+    // rather than throwing "Milestone vX.Y not found".
+    const ADHOC_ROADMAP_WITH_PHASE = `# Roadmap
+
+## Active Milestone: v25.1 add-prs
+
+**Goal:** add-prs
+**Status:** In progress (ad-hoc container — phases added on demand via /dgs:add-phase)
+
+Phases:
+
+### Phase 1: First ad-hoc phase
+**Goal**: Do the first thing
+Plans:
+- [ ] 01-01-PLAN.md
+
+---
+`;
+
+    // Local copies of the multi-milestone / bold-line fixtures (the originals
+    // are scoped to the sibling describe block) for the over-match guard and
+    // bold-line regression assertions.
+    const MULTI_MILESTONE_WITH_BOLD = `# Roadmap (v9.9)
+
+**Milestone:** v9.9 — stray bold line
+
+## v1.0 Foundation (SHIPPED)
+### Phase 1: Base
+### Phase 2: More base
+
+## v2.0 Next (In Progress)
+### Phase 3: New
+### Phase 4: Newer
+`;
+
+    const BOLD_LINE_ROADMAP = `# Roadmap: Tenant data-quality metrics in Admin UI (v30.1)
+
+**Milestone:** v30.1 — Tenant data-quality metrics in Admin UI
+
+## Overview
+
+Single-milestone roadmap. Version is only in the title and the bold line.
+
+### Phase 1: Metrics schema
+### Phase 2: Admin UI surface
+`;
+
+    it('detectActiveMilestone resolves v25.1 from the ad-hoc heading', () => {
+      assert.equal(detectActiveMilestone(ADHOC_ROADMAP), 'v25.1');
+    });
+
+    it('detectActiveMilestone prefers the In-Progress heading over an ad-hoc branch (no hijack)', () => {
+      assert.equal(detectActiveMilestone(MULTI_MILESTONE_WITH_BOLD), 'v2.0');
+    });
+
+    it('detectActiveMilestone leaves the bold-line branch unchanged', () => {
+      assert.equal(detectActiveMilestone(BOLD_LINE_ROADMAP), 'v30.1');
+    });
+
+    it('cmdJobsMilestonePreview auto-detects v25.1 from an ad-hoc roadmap', () => {
+      fixture = createFixture({
+        'ROADMAP.md': ADHOC_ROADMAP_WITH_PHASE,
+        'phases/01-first-ad-hoc-phase/01-01-PLAN.md': '',
+      });
+
+      const result = cmdJobsMilestonePreview(fixture.cwd, null, true, false);
+      assert.equal(result.version, 'v25.1');
+    });
+  });
+
   // ─── findJobFile Tests ──────────────────────────────────────────────────
 
   describe('findJobFile', () => {
@@ -2086,10 +2180,11 @@ Plans:
       assert.deepEqual(result.completed, []);
     });
 
-    it('returns jobs grouped by status with correct fields', () => {
+    it('groups FLAT jobs by frontmatter status with correct fields', () => {
+      // Flat layout: jobs/milestone-*.md grouped by parsed status header.
       fixture = createFixture({
-        'jobs/in-progress/milestone-v6.0.md': WELL_FORMED_JOB,
-        'jobs/completed/milestone-v5.0.md': ALL_COMPLETED_JOB,
+        'jobs/milestone-v6.0.md': WELL_FORMED_JOB,
+        'jobs/milestone-v5.0.md': ALL_COMPLETED_JOB,
       });
       const result = listJobs(fixture.cwd);
 
@@ -2111,6 +2206,40 @@ Plans:
       assert.equal(comp.progress, '2/2');
     });
 
+    it('still lists legacy-subdir jobs (back-compat)', () => {
+      fixture = createFixture({
+        'jobs/in-progress/milestone-v6.0.md': WELL_FORMED_JOB,
+        'jobs/completed/milestone-v5.0.md': ALL_COMPLETED_JOB,
+      });
+      const result = listJobs(fixture.cwd);
+
+      assert.equal(result.in_progress.length, 1);
+      assert.equal(result.completed.length, 1);
+      assert.equal(result.in_progress[0].version, 'v6.0');
+      assert.equal(result.completed[0].version, 'v5.0');
+    });
+
+    it('dedupes a job present both flat and in a legacy subdir (by version)', () => {
+      fixture = createFixture({
+        'jobs/milestone-v6.0.md': WELL_FORMED_JOB,
+        'jobs/in-progress/milestone-v6.0.md': WELL_FORMED_JOB,
+      });
+      const result = listJobs(fixture.cwd);
+      assert.equal(result.in_progress.length, 1, 'flat + legacy same version should dedupe to 1');
+      assert.equal(result.in_progress[0].version, 'v6.0');
+    });
+
+    it('creates no legacy subdirs (read-only on the filesystem)', () => {
+      fixture = createFixture({
+        'jobs/milestone-v6.0.md': WELL_FORMED_JOB,
+      });
+      listJobs(fixture.cwd);
+
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending')), false);
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress')), false);
+      assert.equal(fs.existsSync(path.join(fixture.cwd, 'jobs', 'completed')), false);
+    });
+
     it('shows check flag false when --no-check was used', () => {
       fixture = createFixture({
         'jobs/completed/milestone-v5.0.md': ALL_COMPLETED_JOB,