@ktpartners/dgs-platform 2.9.0 → 3.3.0

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

@@ -5,11 +5,13 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInternal, pathExistsInternal, generateSlugInternal, getMilestoneInfo, normalizePhaseName, toPosixPath, output, error, resolveProjectPath, getProjectRoot, isV2Install, getProjectFolders, getV2Hint } = require('./core.cjs');
+const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInternal, pathExistsInternal, generateSlugInternal, getMilestoneInfo, normalizePhaseName, toPosixPath, output, error, resolveProjectPath, getProjectRoot, isV2Install, getProjectFolders, getV2Hint, safeReadFile } = require('./core.cjs');
 const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
 const { getPlanningRoot, PROJECTS_DIR } = require('./paths.cjs');
 const { parseReposMd, validateReposMdEager } = require('./repos.cjs');
 const { getCadence, pullAll } = require('./sync.cjs');
+const { detectQuickMode, generateQuickId, getActiveQuick } = require('./quick.cjs');
+const { listProjectsReadonly } = require('./projects.cjs');
 
 /**
  * Safely resolve the current git author string.
@@ -221,9 +223,7 @@ function cmdInitExecutePhase(cwd, phase, raw) {
     // Config flags
     commit_docs: config.commit_docs,
     parallelization: config.parallelization,
-    branching_strategy: config.branching_strategy,
-    phase_branch_template: config.phase_branch_template,
-    milestone_branch_template: config.milestone_branch_template,
+    branching_strategy: 'milestone',
     verifier_enabled: config.verifier,
     base_branch: config.base_branch,
     sync_push: config.sync_push,
@@ -246,25 +246,14 @@ function cmdInitExecutePhase(cwd, phase, raw) {
     plan_count: phaseInfo?.plans?.length || 0,
     incomplete_count: phaseInfo?.incomplete_plans?.length || 0,
 
-    // Branch name (pre-computed with {project} resolution)
+    // Branch name (milestone worktree model — always uses milestone template)
     branch_name: (() => {
-      let template, resolved;
-      if (config.branching_strategy === 'phase' && phaseInfo) {
-        template = config.phase_branch_template;
-        resolved = resolveProjectInTemplate(template, ctx.current_project);
-        if (resolved.error) return resolved.error;
-        return resolved.value
-          .replace('{phase}', phaseInfo.phase_number)
-          .replace('{slug}', phaseInfo.phase_slug || 'phase');
-      } else if (config.branching_strategy === 'milestone') {
-        template = config.milestone_branch_template;
-        resolved = resolveProjectInTemplate(template, ctx.current_project);
-        if (resolved.error) return resolved.error;
-        return resolved.value
-          .replace('{milestone}', milestone.version)
-          .replace('{slug}', generateSlugInternal(milestone.name) || 'milestone');
-      }
-      return null;
+      const template = 'dgs/{project}/{milestone}-{slug}';
+      const resolved = resolveProjectInTemplate(template, ctx.current_project);
+      if (resolved.error) return resolved.error;
+      return resolved.value
+        .replace('{milestone}', milestone.version)
+        .replace('{slug}', generateSlugInternal(milestone.name) || 'milestone');
     })(),
 
     // Milestone info
@@ -395,12 +384,28 @@ function cmdInitPlanPhase(cwd, phase, raw) {
   output(result, raw);
 }
 
-function cmdInitNewProject(cwd, raw) {
+function cmdInitNewProject(cwd, slugArg, raw) {
   const config = loadConfig(cwd);
   const ctx = resolveProjectContext(cwd);
   const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
   const milestone = getMilestoneInfo(cwd);
 
+  // Resolve slug override (optional positional arg from CLI).
+  // When supplied AND we're on a v2 install, override the per-slug paths
+  // so `init new-project <slug>` reflects whether THAT slug exists,
+  // independent of the currently active project. v1 mode silently falls
+  // back to ctx.root behaviour because v1 has no projects/<slug>/ layout.
+  let effectiveRoot = ctx.root;
+  let slugOverride = null;
+  if (slugArg && typeof slugArg === 'string' && slugArg.trim()) {
+    const candidate = generateSlugInternal(slugArg.trim());
+    if (candidate && isV2Install(cwd)) {
+      slugOverride = candidate;
+      effectiveRoot = path.join(planRootRel, 'projects', slugOverride);
+    }
+  }
+  const rootForPaths = effectiveRoot;
+
   // Detect Brave Search API key availability
   const homedir = require('os').homedir();
   const braveKeyFile = path.join(homedir, '.dgs', 'brave_api_key');
@@ -437,8 +442,8 @@ function cmdInitNewProject(cwd, raw) {
     cadence_pull: getCadence('new-project').pull,
     cadence_push: getCadence('new-project').push,
 
-    // Existing state (project-qualified)
-    project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
+    // Existing state (project-qualified, slug-override aware)
+    project_exists: rootForPaths ? pathExistsInternal(cwd, path.join(rootForPaths, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
     has_codebase_map: pathExistsInternal(cwd, path.join(planRootRel, 'codebase')),
     planning_exists: pathExistsInternal(cwd, planRootRel),
 
@@ -457,12 +462,12 @@ function cmdInitNewProject(cwd, raw) {
     // Enhanced search
     brave_search_available: hasBraveSearch,
 
-    // File paths (project-qualified)
-    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
-    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
-    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
-    requirements_path: ctx.root ? path.join(ctx.root, 'REQUIREMENTS.md') : path.join(planRootRel, 'REQUIREMENTS.md'),
-    research_dir: ctx.root ? path.join(ctx.root, 'research') : path.join(planRootRel, 'research'),
+    // File paths (project-qualified, slug-override aware)
+    project_path: rootForPaths ? path.join(rootForPaths, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    state_path: rootForPaths ? path.join(rootForPaths, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    roadmap_path: rootForPaths ? path.join(rootForPaths, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    requirements_path: rootForPaths ? path.join(rootForPaths, 'REQUIREMENTS.md') : path.join(planRootRel, 'REQUIREMENTS.md'),
+    research_dir: rootForPaths ? path.join(rootForPaths, 'research') : path.join(planRootRel, 'research'),
 
     // Milestone info (product-level, shared across projects)
     milestone_version: milestone.version,
@@ -471,7 +476,13 @@ function cmdInitNewProject(cwd, raw) {
     // v2 context
     dgs_mode: ctx.dgs_mode,
     current_project: ctx.current_project,
-    project_root: ctx.root,
+    // project_root reflects override when a slug arg is supplied (so the
+    // workflow can write directly to the requested project's folder), otherwise
+    // it still reports the active project root.
+    project_root: rootForPaths,
+    // requested_slug: the normalized slug arg (or null when no slug arg / v1 fallback).
+    // The workflow uses this to distinguish "active project" from "requested project".
+    requested_slug: slugOverride,
     guard: ctx.guard,
     v2_hint: ctx.v2_hint || null,
   };
@@ -514,6 +525,10 @@ function cmdInitNewMilestone(cwd, raw) {
     roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
     state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
 
+    // Product-level MILESTONES.md (authoritative for global version/phase continuity across projects)
+    product_milestones_path: path.join(planRootRel, 'MILESTONES.md'),
+    product_milestones_exists: pathExistsInternal(cwd, path.join(planRootRel, 'MILESTONES.md')),
+
     // Author
     author: resolveAuthorSafe(cwd),
 
@@ -533,22 +548,50 @@ function cmdInitQuick(cwd, description, raw) {
   const config = loadConfig(cwd);
   const ctx = resolveProjectContext(cwd);
   const now = new Date();
-  const slug = description ? generateSlugInternal(description)?.substring(0, 40) : null;
   const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
 
-  // Generate collision-resistant quick task ID: YYMMDD-xxx
-  // xxx = 2-second precision blocks since midnight, encoded as 3-char Base36 (lowercase)
-  // Range: 000 (00:00:00) to xbz (23:59:58), guaranteed 3 chars for any time of day.
-  // Provides ~2s uniqueness window per user — practically collision-free across a team.
-  const quickBase = ctx.root ? path.join(ctx.root, 'quick') : path.join(planRootRel, 'quick');
-  const yy = String(now.getFullYear()).slice(-2);
-  const mm = String(now.getMonth() + 1).padStart(2, '0');
-  const dd = String(now.getDate()).padStart(2, '0');
-  const dateStr = yy + mm + dd;
-  const secondsSinceMidnight = now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds();
-  const timeBlocks = Math.floor(secondsSinceMidnight / 2);
-  const timeEncoded = timeBlocks.toString(36).padStart(3, '0');
-  const quickId = dateStr + '-' + timeEncoded;
+  // Parse --main flag out of description string
+  const forceMain = /\s*--main\s*/.test(description || '');
+  const cleanDescription = (description || '').replace(/\s*--main\s*/g, ' ').trim() || null;
+
+  // Hoist getActiveQuick lookup so both `slug` and `quickId` derive from
+  // the same canonical source (the worktree slug stored in config.local.json).
+  // The worktree slug has already been truncated to 50 chars by worktrees.cjs;
+  // re-sanitising the description here would produce a divergent (51-char)
+  // descSlug, leaving an orphan directory on disk after every quick task.
+  // See: bug 260428-k7f.
+  const activeQuick = getActiveQuick(cwd);
+  const hasActiveQuickSlug = activeQuick && /^\d{6}-[a-z0-9]{3}-/.test(activeQuick.slug);
+
+  const slug = hasActiveQuickSlug
+    ? activeQuick.slug.slice(11)  // strip "{quickId}-" prefix (10 chars + 1 dash)
+    : (cleanDescription ? generateSlugInternal(cleanDescription)?.substring(0, 40).replace(/-+$/, '') : null);
+
+  // Detect quick mode: product-level vs milestone-context
+  const quickMode = detectQuickMode(cwd, forceMain);
+
+  // Quick task ID: YYMMDD-xxx. For product-level quicks with an active worktree,
+  // extract the quickId from the worktree slug (startProductQuick embeds it as the
+  // prefix). For fast mode and milestone-context, generate a fresh one.
+  const isProductMode = quickMode.mode === 'product';
+  const quickBase = isProductMode
+    ? path.join(planRootRel, 'quick')
+    : (ctx.root ? path.join(ctx.root, 'quick') : path.join(planRootRel, 'quick'));
+  const quickId = hasActiveQuickSlug
+    ? activeQuick.slug.slice(0, 10)
+    : generateQuickId(now);
+
+  // Auto-create product-level STATE.md on demand (matches project STATE.md
+  // auto-creation behavior elsewhere). Keep skeleton minimal — the /dgs:quick
+  // workflow adds ### Quick Tasks Completed on first use; we only need the
+  // ### Blockers/Concerns anchor so later inserts succeed.
+  if (isProductMode) {
+    const absoluteStatePath = path.resolve(cwd, planRootRel, 'STATE.md');
+    if (!fs.existsSync(absoluteStatePath)) {
+      const skeleton = '# Project State\n\n## Current Position\n\n(Product-level state — quick tasks tracked here.)\n\n## Accumulated Context\n\n### Blockers/Concerns\n\nNone yet.\n';
+      fs.writeFileSync(absoluteStatePath, skeleton, 'utf-8');
+    }
+  }
 
   const result = {
     // Models
@@ -567,7 +610,7 @@ function cmdInitQuick(cwd, description, raw) {
     // Quick task info
     quick_id: quickId,
     slug: slug,
-    description: description || null,
+    description: cleanDescription,
 
     // Timestamps
     date: now.toISOString().split('T')[0],
@@ -576,9 +619,14 @@ function cmdInitQuick(cwd, description, raw) {
     // Paths (project-qualified)
     quick_dir: quickBase,
     task_dir: slug ? path.join(quickBase, `${quickId}-${slug}`) : null,
-    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    state_path: isProductMode
+      ? path.join(planRootRel, 'STATE.md')
+      : (ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md')),
 
     // File existence
+    // roadmap_exists stays project-scoped for both modes: the quick workflow
+    // only reads ROADMAP.md for project context (phase/milestone labels), and
+    // product-level quicks still run against the currently active project.
     roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
     planning_exists: pathExistsInternal(cwd, planRootRel),
 
@@ -844,17 +892,23 @@ function cmdInitTodos(cwd, area, raw, workflow) {
   const now = new Date();
   const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
 
-  // List todos (reuse existing logic) — project-qualified
-  const pendingBase = path.join(planRootRel, 'todos', 'pending');
-  const pendingDir = path.join(cwd, pendingBase);
+  // List todos — flat directory (status in frontmatter), with legacy fallback
+  const todosBase = path.join(planRootRel, 'todos');
+  const todosDir = path.join(cwd, todosBase);
   let count = 0;
   const todos = [];
+  const seenFiles = new Set();
 
+  // Flat directory scan (new layout — status in frontmatter)
   try {
-    const files = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md'));
+    const files = fs.readdirSync(todosDir).filter(f => f.endsWith('.md'));
     for (const file of files) {
       try {
-        const content = fs.readFileSync(path.join(pendingDir, file), 'utf-8');
+        const content = fs.readFileSync(path.join(todosDir, file), 'utf-8');
+        const statusMatch = content.match(/^status:\s*(.+)$/m);
+        const todoStatus = statusMatch ? statusMatch[1].trim() : 'pending';
+        if (todoStatus !== 'pending') continue;  // Only show pending todos
+
         const createdMatch = content.match(/^created:\s*(.+)$/m);
         const titleMatch = content.match(/^title:\s*(.+)$/m);
         const areaMatch = content.match(/^area:\s*(.+)$/m);
@@ -863,19 +917,46 @@ function cmdInitTodos(cwd, area, raw, workflow) {
         if (area && todoArea !== area) continue;
 
         count++;
+        seenFiles.add(file);
         todos.push({
           file,
           created: createdMatch ? createdMatch[1].trim() : 'unknown',
           title: titleMatch ? titleMatch[1].trim() : 'Untitled',
           area: todoArea,
-          path: pendingBase + '/' + file,
+          path: todosBase + '/' + file,
+        });
+      } catch {}
+    }
+  } catch {}
+
+  // Legacy fallback: check todos/pending/
+  const legacyPendingDir = path.join(cwd, todosBase, 'pending');
+  try {
+    const files = fs.readdirSync(legacyPendingDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+      if (seenFiles.has(file)) continue;
+      try {
+        const content = fs.readFileSync(path.join(legacyPendingDir, file), 'utf-8');
+        const createdMatch = content.match(/^created:\s*(.+)$/m);
+        const titleMatch = content.match(/^title:\s*(.+)$/m);
+        const areaMatch = content.match(/^area:\s*(.+)$/m);
+        const todoArea = areaMatch ? areaMatch[1].trim() : 'general';
+
+        if (area && todoArea !== area) continue;
+
+        count++;
+        todos.push({
+          file,
+          created: createdMatch ? createdMatch[1].trim() : 'unknown',
+          title: titleMatch ? titleMatch[1].trim() : 'Untitled',
+          area: todoArea,
+          path: todosBase + '/pending/' + file,
         });
       } catch {}
     }
   } catch {}
 
   const completedBase = path.join(planRootRel, 'todos', 'completed');
-  const todosBase = path.join(planRootRel, 'todos');
 
   const result = {
     // Config
@@ -894,14 +975,14 @@ function cmdInitTodos(cwd, area, raw, workflow) {
     todos,
     area_filter: area || null,
 
-    // Paths (project-qualified)
-    pending_dir: pendingBase,
+    // Paths (project-qualified) — pending_dir now points to flat todos/
+    pending_dir: todosBase,
     completed_dir: completedBase,
 
     // File existence
     planning_exists: pathExistsInternal(cwd, planRootRel),
     todos_dir_exists: pathExistsInternal(cwd, todosBase),
-    pending_dir_exists: pathExistsInternal(cwd, pendingBase),
+    pending_dir_exists: pathExistsInternal(cwd, todosBase),
 
     // Author
     author: resolveAuthorSafe(cwd),
@@ -959,9 +1040,7 @@ function cmdInitMilestoneOp(cwd, raw, workflow) {
     // Config
     commit_docs: config.commit_docs,
     base_branch: config.base_branch,
-    branching_strategy: config.branching_strategy,
-    phase_branch_template: config.phase_branch_template,
-    milestone_branch_template: config.milestone_branch_template,
+    branching_strategy: 'milestone',
     sync_push: config.sync_push,
     sync_pull: config.sync_pull,
     cadence_pull: cadence.pull,
@@ -1236,6 +1315,222 @@ function cmdInitProgress(cwd, raw) {
   output(result, raw);
 }
 
+// ─── cmdInitProgressAll — Product-level dashboard ────────────────────────────
+
+/**
+ * Parse the product-level STATE.md "Quick Tasks Completed" table and return
+ * the most recent rows (up to `limit`). Returns [] if STATE.md or the table
+ * is missing.
+ */
+function parseProductQuickTasks(planningRoot, limit) {
+  const statePath = path.join(planningRoot, 'STATE.md');
+  const content = safeReadFile(statePath);
+  if (!content) return [];
+
+  const lines = content.split('\n');
+  const rows = [];
+  let inTable = false;
+  let headerSeen = false;
+
+  for (const line of lines) {
+    if (!inTable) {
+      if (/^###\s+Quick Tasks Completed/i.test(line)) {
+        inTable = true;
+      }
+      continue;
+    }
+    // Inside the Quick Tasks section
+    if (!line.startsWith('|')) {
+      if (rows.length > 0 || headerSeen) break; // end of table
+      continue;
+    }
+    // It's a table row
+    if (!headerSeen) {
+      if (/^\|\s*#\s*\|\s*Description/i.test(line)) {
+        headerSeen = true;
+      }
+      continue;
+    }
+    // Skip separator row
+    if (/^\|[\s-]+\|/.test(line)) continue;
+    // Data row
+    const cells = line.split('|').map(c => c.trim());
+    // cells[0] is '' before first pipe; real cells are cells[1..n-1]
+    if (cells.length < 6) continue;
+    rows.push({
+      id: cells[1],
+      description: cells[2],
+      date: cells[3],
+      commit: cells[4],
+      status: cells[5],
+      directory: cells[6] || '',
+    });
+  }
+
+  // Keep order as in file; take last `limit` (most recent appended last)
+  return rows.slice(-limit);
+}
+
+/**
+ * Parse the product-level MILESTONES.md for shipped milestone headers.
+ * Returns at most `limit` milestones in file order (top = most recent).
+ */
+function parseProductShippedMilestones(planningRoot, limit) {
+  const mPath = path.join(planningRoot, 'MILESTONES.md');
+  const content = safeReadFile(mPath);
+  if (!content) return [];
+
+  const regex = /^##\s+(v[\d.]+)\s+(.+?)\s+\(Shipped:\s+(\d{4}-\d{2}-\d{2})\)/gm;
+  const entries = [];
+  let m;
+  while ((m = regex.exec(content)) !== null) {
+    entries.push({ version: m[1], name: m[2].trim(), shipped_date: m[3] });
+    if (entries.length >= limit) break;
+  }
+  return entries;
+}
+
+/**
+ * Parse milestone info from an arbitrary ROADMAP.md file (project-scoped).
+ * Uses the same regexes as core.getMilestoneInfo but reads any path.
+ * Returns { milestone_version, milestone_name } or both nulls if none found.
+ */
+function parseProjectMilestone(roadmapPath) {
+  const roadmap = safeReadFile(roadmapPath);
+  if (!roadmap) return { milestone_version: null, milestone_name: null };
+
+  // 🚧 marker: "- 🚧 **v2.1 Belgium** — Phases 24-28 (in progress)"
+  const inProgressMatch = roadmap.match(/🚧\s*\*\*v(\d+\.\d+)\s+([^*]+)\*\*/);
+  if (inProgressMatch) {
+    return { milestone_version: 'v' + inProgressMatch[1], milestone_name: inProgressMatch[2].trim() };
+  }
+
+  // Bullet list: "- 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 { milestone_version: 'v' + bulletMatch[1], milestone_name: bulletMatch[2].trim() };
+  }
+
+  // Heading format (strip shipped <details> blocks)
+  const cleaned = roadmap.replace(/<details>[\s\S]*?<\/details>/gi, '');
+  const headingMatch = cleaned.match(/#{2,3}\s+v(\d+\.\d+)[:\s]+([^\n(]+)/);
+  if (headingMatch) {
+    return { milestone_version: 'v' + headingMatch[1], milestone_name: headingMatch[2].trim() };
+  }
+
+  return { milestone_version: null, milestone_name: null };
+}
+
+/**
+ * Count .md files in a directory (non-recursive). Returns 0 on any error
+ * (missing dir, permissions, etc).
+ */
+function countMdFiles(dir, excludePredicate) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    let count = 0;
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      if (!e.name.endsWith('.md')) continue;
+      if (excludePredicate && excludePredicate(e.name)) continue;
+      count++;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Count .md files in a flat directory that have a specific frontmatter status.
+ * Used for ideas/todos/jobs that use frontmatter-based status instead of subdirectories.
+ */
+function countMdFilesByStatus(dir, status) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    let count = 0;
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      if (!e.name.endsWith('.md')) continue;
+      if (e.name === 'manifest.json') continue;
+      try {
+        const content = fs.readFileSync(path.join(dir, e.name), 'utf-8');
+        const statusMatch = content.match(/^---\n[\s\S]*?^status:\s*(.+)/m);
+        if (statusMatch && statusMatch[1].trim() === status) count++;
+      } catch { /* skip unreadable files */ }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+function cmdInitProgressAll(cwd, raw) {
+  const config = loadConfig(cwd);
+  const planningRoot = getPlanningRoot(cwd);
+
+  // listProjectsReadonly handles ghost projects internally via warnings
+  const { projects: allProjects, warnings } = listProjectsReadonly(cwd);
+
+  const activeProjects = allProjects.filter(p => !p.status.toLowerCase().includes('completed'));
+  const completedProjects = allProjects.filter(p => p.status.toLowerCase().includes('completed'));
+
+  // Enrich each active project with milestone info from its ROADMAP.md
+  const enrichedProjects = activeProjects.map(p => {
+    const roadmapPath = path.join(planningRoot, 'projects', p.name, 'ROADMAP.md');
+    const { milestone_version, milestone_name } = parseProjectMilestone(roadmapPath);
+    return {
+      name: p.name,
+      status: p.status,
+      current_phase: p.current_phase,
+      progress: p.progress,
+      repos_touched: p.repos_touched,
+      milestone_version,
+      milestone_name,
+    };
+  });
+
+  // Product-level aggregates
+  const quickTasksRecent = parseProductQuickTasks(planningRoot, 5);
+  const shippedMilestonesRecent = parseProductShippedMilestones(planningRoot, 5);
+
+  const backlog = {
+    todos: countMdFilesByStatus(path.join(planningRoot, 'todos'), 'pending'),
+    ideas: countMdFilesByStatus(path.join(planningRoot, 'ideas'), 'pending'),
+    specs: countMdFiles(path.join(planningRoot, 'specs')),
+    debug_active: countMdFiles(path.join(planningRoot, 'debug'), name => name.includes('resolved')),
+  };
+
+  const result = {
+    planner_model: resolveModelInternal(cwd, 'dgs-planner'),
+    executor_model: resolveModelInternal(cwd, 'dgs-executor'),
+    commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('progress').pull,
+    cadence_push: getCadence('progress').push,
+
+    product: {
+      product_name: config.product_name || null,
+      active_count: activeProjects.length,
+      completed_count: completedProjects.length,
+      quick_tasks_recent: quickTasksRecent,
+      shipped_milestones_recent: shippedMilestonesRecent,
+      backlog,
+    },
+
+    projects: enrichedProjects,
+    warnings,
+
+    author: resolveAuthorSafe(cwd),
+    dgs_mode: isV2Install(cwd) ? 'v2' : 'v1',
+    planning_root: path.relative(cwd, planningRoot) || '.',
+  };
+
+  applySyncPull(cwd, 'progress', result);
+  output(result, raw);
+}
+
 module.exports = {
   cmdInitExecutePhase,
   cmdInitPlanPhase,
@@ -1250,5 +1545,6 @@ module.exports = {
   cmdInitMilestoneOp,
   cmdInitMapCodebase,
   cmdInitProgress,
+  cmdInitProgressAll,
   applySyncPull,
 };