@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/mcp-filter.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 
@@ -21,12 +21,50 @@ interface DiscoveredMcpServer {
   config: unknown;
 }
 
+interface JsonFileSignature {
+  exists: boolean;
+  mtimeMs?: number;
+  size?: number;
+}
+
+interface ProjectMcpDiscoveryCacheEntry {
+  signatures: JsonFileSignature[];
+  servers: DiscoveredMcpServer[];
+}
+
+const projectMcpDiscoveryCache = new Map<string, ProjectMcpDiscoveryCacheEntry>();
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
-function readJsonFile(path: string, ignoreParseErrors = false): unknown | undefined {
-  if (!existsSync(path)) return undefined;
+function getJsonFileSignature(path: string, ignoreAccessErrors = false): JsonFileSignature {
+  try {
+    const stats = statSync(path);
+    return { exists: true, mtimeMs: stats.mtimeMs, size: stats.size };
+  } catch (err) {
+    const code = isRecord(err) ? err.code : undefined;
+    if (code === "ENOENT" || code === "ENOTDIR" || ignoreAccessErrors) return { exists: false };
+    throw err;
+  }
+}
+
+function jsonFileSignaturesEqual(a: JsonFileSignature[], b: JsonFileSignature[]): boolean {
+  if (a.length !== b.length) return false;
+  return a.every((signature, index) => {
+    const other = b[index];
+    return signature.exists === other.exists
+      && signature.mtimeMs === other.mtimeMs
+      && signature.size === other.size;
+  });
+}
+
+function readJsonFile(
+  path: string,
+  ignoreParseErrors = false,
+  signature = getJsonFileSignature(path, ignoreParseErrors),
+): unknown | undefined {
+  if (!signature.exists) return undefined;
   try {
     return JSON.parse(readFileSync(path, "utf-8")) as unknown;
   } catch (err) {
@@ -41,13 +79,23 @@ function collectServerEntries(servers: unknown): DiscoveredMcpServer[] {
 }
 
 export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
-  const mcpJsonPath = resolve(projectDir, ".mcp.json");
-  const settingsPath = resolve(projectDir, ".claude", "settings.json");
-  const localSettingsPath = resolve(projectDir, ".claude", "settings.local.json");
+  const resolvedProjectDir = resolve(projectDir);
+  const mcpJsonPath = resolve(resolvedProjectDir, ".mcp.json");
+  const settingsPath = resolve(resolvedProjectDir, ".claude", "settings.json");
+  const localSettingsPath = resolve(resolvedProjectDir, ".claude", "settings.local.json");
+  const signatures = [
+    getJsonFileSignature(mcpJsonPath, true),
+    getJsonFileSignature(settingsPath, true),
+    getJsonFileSignature(localSettingsPath, true),
+  ];
+  const cached = projectMcpDiscoveryCache.get(resolvedProjectDir);
+  if (cached && jsonFileSignaturesEqual(cached.signatures, signatures)) {
+    return [...cached.servers];
+  }
 
-  const mcpJson = readJsonFile(mcpJsonPath) as McpJsonFile | undefined;
-  const settings = readJsonFile(settingsPath, true) as ClaudeSettingsFile | undefined;
-  const localSettings = readJsonFile(localSettingsPath, true) as ClaudeSettingsFile | undefined;
+  const mcpJson = readJsonFile(mcpJsonPath, false, signatures[0]) as McpJsonFile | undefined;
+  const settings = readJsonFile(settingsPath, true, signatures[1]) as ClaudeSettingsFile | undefined;
+  const localSettings = readJsonFile(localSettingsPath, true, signatures[2]) as ClaudeSettingsFile | undefined;
 
   const seen = new Set<string>();
   const discovered: DiscoveredMcpServer[] = [];
@@ -61,7 +109,8 @@ export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
     seen.add(entry.name);
     discovered.push(entry);
   }
-  return discovered;
+  projectMcpDiscoveryCache.set(resolvedProjectDir, { signatures, servers: discovered });
+  return [...discovered];
 }
 
 function isWorkflowMcpServerConfig(config: unknown): boolean {

package/src/resources/extensions/gsd/md-importer.ts

@@ -5,7 +5,7 @@
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { join, relative, basename } from 'node:path';
 import type { Decision, Requirement } from './types.js';
 import {
   upsertDecision,
@@ -24,13 +24,14 @@ import {
   resolveGsdRootFile,
   resolveMilestoneFile,
   resolveSliceFile,
-  resolveSlicePath,
   resolveTasksDir,
-  milestonesDir,
+  legacyMilestonesDir,
   gsdRoot,
   resolveTaskFiles,
+  resolveMilestonePath,
 } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
+import { milestoneIdToPhaseNum } from './layout-policy.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { parseContextDependsOn } from './files.js';
 import { logWarning } from './workflow-logger.js';
@@ -329,7 +330,7 @@ function importRequirements(gsdDir: string): number {
 
 /** Artifact suffixes to look for at each hierarchy level */
 const MILESTONE_SUFFIXES = ['ROADMAP', 'CONTEXT', 'RESEARCH', 'ASSESSMENT', 'SUMMARY', 'VALIDATION'];
-const SLICE_SUFFIXES = ['PLAN', 'SUMMARY', 'RESEARCH', 'CONTEXT', 'ASSESSMENT', 'UAT'];
+const SLICE_SUFFIXES = ['PLAN', 'SUMMARY', 'RESEARCH', 'CONTEXT', 'CONTEXT-DRAFT', 'ASSESSMENT', 'UAT', 'CONTINUE'];
 const TASK_SUFFIXES = ['PLAN', 'SUMMARY', 'CONTINUE', 'CONTEXT', 'RESEARCH'];
 
 /**
@@ -359,75 +360,220 @@ function importHierarchyArtifacts(gsdDir: string): number {
     }
   }
 
-  // Walk milestones
+  // Walk phases (flat-phase layout: phases/NN-slug/, legacy: milestones/M001/)
   const milestoneIds = findMilestoneIds(gsdDir);
-  const msDir = milestonesDir(gsdDir);
+  const legacyDir = legacyMilestonesDir(gsdDir);
 
   for (const milestoneId of milestoneIds) {
-    // Find the actual milestone directory name (handles legacy naming)
-    const milestoneDirName = findDirByPrefix(msDir, milestoneId);
-    if (!milestoneDirName) continue;
-    const milestoneFullPath = join(msDir, milestoneDirName);
+    // Use resolveMilestonePath so canonical-name / newest-dir selection matches
+    // the same logic used by the renderer and reconciler, preventing import and
+    // render from landing on different phase trees for the same milestone.
+    const resolvedPhaseFullPath = resolveMilestonePath(gsdDir, milestoneId);
+
+    if (!resolvedPhaseFullPath) {
+      // Last resort: findDirByPrefix for legacy dirs
+      const milestoneDirName = findDirByPrefix(legacyDir, milestoneId);
+      if (!milestoneDirName) continue;
+      count += importLegacyMilestoneArtifacts(
+        join(legacyDir, milestoneDirName),
+        milestoneDirName,
+        milestoneId,
+      );
+      continue;
+    }
 
-    // Milestone-level files
-    count += importFilesAtLevel(
-      milestoneFullPath,
-      milestoneId,
+    // Determine if this is a legacy (milestones/) or flat-phase (phases/) dir.
+    const legacyDirNorm = legacyDir.replace(/\\/g, "/");
+    const resolvedNorm = resolvedPhaseFullPath.replace(/\\/g, "/");
+    const isLegacyResolved = resolvedNorm.startsWith(legacyDirNorm + "/") || resolvedNorm === legacyDirNorm;
+
+    const phaseDirName = basename(resolvedPhaseFullPath);
+    if (isLegacyResolved) {
+      count += importLegacyMilestoneArtifacts(resolvedPhaseFullPath, phaseDirName, milestoneId);
+      continue;
+    }
+    const phaseFullPath = resolvedPhaseFullPath;
+    const phaseNum = milestoneIdToPhaseNum(milestoneId);
+
+    // Phase-level files (flat-phase: NN-SUFFIX.md, legacy: M001-SUFFIX.md)
+    const phasePrefix = `${String(phaseNum).padStart(2, "0")}`;
+    const artifactBase = `phases/${phaseDirName}`;
+    let phaseArtifacts = importFilesAtLevel(
+      phaseFullPath,
+      phasePrefix,
       MILESTONE_SUFFIXES,
-      `milestones/${milestoneDirName}`,
+      artifactBase,
       milestoneId,
       null,
       null,
     );
+    if (phaseArtifacts === 0) {
+      phaseArtifacts = importFilesAtLevel(
+        phaseFullPath,
+        milestoneId,
+        MILESTONE_SUFFIXES,
+        artifactBase,
+        milestoneId,
+        null,
+        null,
+      );
+    }
+    count += phaseArtifacts;
 
-    // Walk slices
-    const slicesDir = join(milestoneFullPath, 'slices');
-    if (!existsSync(slicesDir)) continue;
-
-    const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
-      .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
-      .map(d => d.name)
+    // Flat-phase: plan files are NN-MM-SUFFIX.md inside the phase dir.
+    // Also check legacy slices/ subdir for backward compat.
+    const planFiles = readdirSync(phaseFullPath, { withFileTypes: true })
+      .filter(f => f.isFile() && /^\d+-\d+-/.test(f.name))
+      .map(f => f.name)
       .sort();
 
-    for (const sliceDirName of sliceDirs) {
-      const sliceId = sliceDirName.match(/^(S\d+)/)?.[1] ?? sliceDirName;
-      const sliceFullPath = join(slicesDir, sliceDirName);
+    for (const planFile of planFiles) {
+      const planMatch = planFile.match(/^\d+-(\d+)-([A-Z0-9-]+)\.md$/i);
+      if (!planMatch) continue;
+      const planNum = parseInt(planMatch[1]!, 10);
+      const sliceId = `S${String(planNum).padStart(2, '0')}`;
+      const suffix = planMatch[2]!.toUpperCase();
+      const filePath = join(phaseFullPath, planFile);
+      if (!existsSync(filePath)) continue;
+
+      const content = readFileSync(filePath, 'utf-8');
+      insertArtifact({
+        path: `${artifactBase}/${planFile}`,
+        artifact_type: suffix,
+        milestone_id: milestoneId,
+        slice_id: sliceId,
+        task_id: null,
+        full_content: content,
+      });
+      count++;
+    }
+
+    // Legacy fallback: walk slices/ subdir if it exists
+    const slicesDir = join(phaseFullPath, 'slices');
+    if (existsSync(slicesDir)) {
+      const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
+        .map(d => d.name)
+        .sort();
+
+      for (const sliceDirName of sliceDirs) {
+        const sliceId = sliceDirName.match(/^(S\d+)/)?.[1] ?? sliceDirName;
+        const sliceFullPath = join(slicesDir, sliceDirName);
+
+        count += importFilesAtLevel(
+          sliceFullPath,
+          sliceId,
+          SLICE_SUFFIXES,
+          `phases/${phaseDirName}/slices/${sliceDirName}`,
+          milestoneId,
+          sliceId,
+          null,
+        );
+
+        // Legacy tasks walk
+        const tasksDir = join(sliceFullPath, 'tasks');
+        if (!existsSync(tasksDir)) continue;
+
+        for (const suffix of TASK_SUFFIXES) {
+          const taskFiles = resolveTaskFiles(tasksDir, suffix);
+          for (const taskFileName of taskFiles) {
+            const taskId = taskFileName.match(/^(T\d+)/)?.[1] ?? null;
+            const taskFilePath = join(tasksDir, taskFileName);
+            if (!existsSync(taskFilePath)) continue;
+
+            const content = readFileSync(taskFilePath, 'utf-8');
+            const relPath = `phases/${phaseDirName}/slices/${sliceDirName}/tasks/${taskFileName}`;
+
+            insertArtifact({
+              path: relPath,
+              artifact_type: suffix,
+              milestone_id: milestoneId,
+              slice_id: sliceId,
+              task_id: taskId,
+              full_content: content,
+            });
+            count++;
+          }
+        }
+      }
+    }
 
-      // Slice-level files
-      count += importFilesAtLevel(
-        sliceFullPath,
-        sliceId,
-        SLICE_SUFFIXES,
-        `milestones/${milestoneDirName}/slices/${sliceDirName}`,
+    // Partial migration may leave nested milestones/M00N/ content alongside phases/.
+    const milestoneDirName = findDirByPrefix(legacyDir, milestoneId);
+    if (milestoneDirName) {
+      count += importLegacyMilestoneArtifacts(
+        join(legacyDir, milestoneDirName),
+        milestoneDirName,
         milestoneId,
-        sliceId,
-        null,
       );
+    }
+  }
 
-      // Walk tasks
-      const tasksDir = join(sliceFullPath, 'tasks');
-      if (!existsSync(tasksDir)) continue;
-
-      for (const suffix of TASK_SUFFIXES) {
-        const taskFiles = resolveTaskFiles(tasksDir, suffix);
-        for (const taskFileName of taskFiles) {
-          const taskId = taskFileName.match(/^(T\d+)/)?.[1] ?? null;
-          const taskFilePath = join(tasksDir, taskFileName);
-          if (!existsSync(taskFilePath)) continue;
-
-          const content = readFileSync(taskFilePath, 'utf-8');
-          const relPath = `milestones/${milestoneDirName}/slices/${sliceDirName}/tasks/${taskFileName}`;
-
-          insertArtifact({
-            path: relPath,
-            artifact_type: suffix,
-            milestone_id: milestoneId,
-            slice_id: sliceId,
-            task_id: taskId,
-            full_content: content,
-          });
-          count++;
-        }
+  return count;
+}
+
+/** Walk a pre-flat-phase milestones/M001/ tree when no phases/NN-slug dir exists. */
+function importLegacyMilestoneArtifacts(
+  milestoneFullPath: string,
+  milestoneDirName: string,
+  milestoneId: string,
+): number {
+  let count = 0;
+
+  count += importFilesAtLevel(
+    milestoneFullPath,
+    milestoneId,
+    MILESTONE_SUFFIXES,
+    `milestones/${milestoneDirName}`,
+    milestoneId,
+    null,
+    null,
+  );
+
+  const slicesDir = join(milestoneFullPath, 'slices');
+  if (!existsSync(slicesDir)) return count;
+
+  const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
+    .map(d => d.name)
+    .sort();
+
+  for (const sliceDirName of sliceDirs) {
+    const sliceId = sliceDirName.match(/^(S\d+)/)?.[1] ?? sliceDirName;
+    const sliceFullPath = join(slicesDir, sliceDirName);
+
+    count += importFilesAtLevel(
+      sliceFullPath,
+      sliceId,
+      SLICE_SUFFIXES,
+      `milestones/${milestoneDirName}/slices/${sliceDirName}`,
+      milestoneId,
+      sliceId,
+      null,
+    );
+
+    const tasksDir = join(sliceFullPath, 'tasks');
+    if (!existsSync(tasksDir)) continue;
+
+    for (const suffix of TASK_SUFFIXES) {
+      const taskFiles = resolveTaskFiles(tasksDir, suffix);
+      for (const taskFileName of taskFiles) {
+        const taskId = taskFileName.match(/^(T\d+)/)?.[1] ?? null;
+        const taskFilePath = join(tasksDir, taskFileName);
+        if (!existsSync(taskFilePath)) continue;
+
+        const content = readFileSync(taskFilePath, 'utf-8');
+        const relPath = `milestones/${milestoneDirName}/slices/${sliceDirName}/tasks/${taskFileName}`;
+
+        insertArtifact({
+          path: relPath,
+          artifact_type: suffix,
+          milestone_id: milestoneId,
+          slice_id: sliceId,
+          task_id: taskId,
+          full_content: content,
+        });
+        count++;
       }
     }
   }
@@ -504,9 +650,10 @@ function findFileByPrefixAndSuffix(dir: string, idPrefix: string, suffix: string
     const target = `${idPrefix}-${suffix}.md`.toUpperCase();
     const direct = entries.find(e => e.toUpperCase() === target);
     if (direct) return direct;
-    // Legacy: ID-DESCRIPTOR-SUFFIX.md
+    // Legacy: ID-DESCRIPTOR-SUFFIX.md — exclude double-numbered (NN-NN-*) slice
+    // files so a phase-prefix like "01" never matches a slice file "01-01-SUMMARY.md".
     const pattern = new RegExp(`^${idPrefix}-.*-${suffix}\\.md$`, 'i');
-    const match = entries.find(e => pattern.test(e));
+    const match = entries.find(e => pattern.test(e) && !/^\d+-\d+-/.test(e));
     return match ?? null;
   } catch {
     return null;
@@ -669,9 +816,11 @@ export function migrateHierarchyToDb(basePath: string): {
         // Per K002: use 'complete' not 'done'
         let taskStatus: string = taskEntry.done ? 'complete' : 'pending';
 
-        // Pre-migration consistency: if task is marked done in the plan but has
-        // no summary file on disk, import as 'pending' so it gets re-executed
-        // rather than silently importing bad state as the new DB authority.
+        // Pre-migration consistency (legacy layout only): if a task is marked
+        // done but has no per-task SUMMARY.md, import it as pending so it gets
+        // re-executed rather than silently entering the DB as complete.
+        // Flat-phase has no per-task summary files by design — the checkbox
+        // state is the authoritative completion signal and is imported as-is.
         if (taskStatus === 'complete') {
           const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
           if (tDir) {
@@ -709,10 +858,11 @@ export function migrateHierarchyToDb(basePath: string): {
         const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
         const hasSliceSummary = sliceSummaryPath !== null && existsSync(sliceSummaryPath);
         const allTasksDone = plan.tasks.length > 0 && plan.tasks.every(t => {
+          if (!t.done) return false;
           const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
-          if (!tDir) return t.done;
-          const summaryFile = join(tDir, `${t.id}-SUMMARY.md`);
-          return t.done && existsSync(summaryFile);
+          // Flat-phase has no per-task summary files — checkbox state is authoritative.
+          if (!tDir) return true;
+          return existsSync(join(tDir, `${t.id}-SUMMARY.md`));
         });
         if (allTasksDone && hasSliceSummary) {
           if (_getAdapter()) {

package/src/resources/extensions/gsd/metrics.ts

@@ -846,12 +846,22 @@ function defaultLedger(): MetricsLedger {
   return { version: 1, projectStartedAt: Date.now(), units: [] };
 }
 
+export const METRICS_LEDGER_KEEP_UNITS = 1500;
+
+function compareUnitsByTime(a: UnitMetrics, b: UnitMetrics): number {
+  return a.finishedAt - b.finishedAt || a.startedAt - b.startedAt;
+}
+
+function keepNewestUnits(units: UnitMetrics[], keepCount = METRICS_LEDGER_KEEP_UNITS): UnitMetrics[] {
+  return units.length > keepCount ? [...units].sort(compareUnitsByTime).slice(-keepCount) : units;
+}
+
 /**
  * Prune the metrics ledger to at most `keepCount` most-recent unit entries.
  *
  * Called by the doctor when the ledger exceeds the bloat threshold.
- * Keeps the newest entries (highest index = most recent) and discards
- * the oldest from the head of the array. Preserves `projectStartedAt`.
+ * Keeps the newest entries by unit timestamps and discards the oldest.
+ * Preserves `projectStartedAt`.
  *
  * Updates both the on-disk file and the in-memory ledger if it is loaded,
  * so the current session sees the pruned state immediately.
@@ -862,11 +872,11 @@ export function pruneMetricsLedger(base: string, keepCount: number): number {
   const disk = loadLedgerFromDisk(base);
   if (!disk || disk.units.length <= keepCount) return 0;
   const removed = disk.units.length - keepCount;
-  disk.units = disk.units.slice(-keepCount);
+  disk.units = keepNewestUnits(disk.units, keepCount);
   saveJsonFile(metricsPath(base), disk);
   // Keep the in-memory ledger in sync if it is loaded for this session.
   if (ledger) {
-    ledger.units = ledger.units.slice(-keepCount);
+    ledger.units = keepNewestUnits(ledger.units, keepCount);
   }
   // Invalidate all scoped ledger cache entries. Prune is rare; clearing the
   // entire map is simpler than tracking which entry belongs to `base`. Without
@@ -1024,12 +1034,14 @@ function saveLedger(base: string, data: MetricsLedger): void {
       // Read current on-disk state and merge with worker's in-memory units.
       // Worker units take precedence on conflict (by finishedAt in deduplicateUnits).
       const onDisk = loadJsonFileOrNull(path, isMetricsLedger);
-      if (onDisk && onDisk.units.length > 0) {
-        const merged = deduplicateUnits([...onDisk.units, ...data.units]);
-        saveJsonFile(path, { ...data, units: merged });
-      } else {
-        saveJsonFile(path, data);
-      }
+      const dataUnits = keepNewestUnits(data.units);
+      const merged =
+        onDisk && onDisk.units.length > 0
+          ? deduplicateUnits([...keepNewestUnits(onDisk.units), ...dataUnits])
+          : dataUnits;
+      merged.sort(compareUnitsByTime);
+      data.units = keepNewestUnits(merged);
+      saveJsonFile(path, data);
     } finally {
       releaseLock(lockPath);
     }
@@ -1040,6 +1052,7 @@ function saveLedger(base: string, data: MetricsLedger): void {
     // to a torn write caused by two writers simultaneously executing the
     // read-merge-write sequence without mutual exclusion.
     logWarning("fs", "saveLedger: lock not acquired — falling back to direct write (no merge)");
+    data.units = keepNewestUnits(data.units);
     saveJsonFile(path, data);
   }
 }

package/src/resources/extensions/gsd/migrate/layout-detect.ts

@@ -0,0 +1,38 @@
+// Project/App: gsd-pi
+// File Purpose: Classify a parsed .planning/ tree into its layout so the
+// round-trip writer can recreate the same structure gsd-core wrote.
+//
+// This extracts the implicit 3-way branch that was buried in transformer.ts
+// transformToGSD (lines 425-467). Priority matches the transformer's if/else
+// chain: legacy-milestone-dir > multi-milestone > flat-phases.
+
+import type { PlanningProject } from "./types.js";
+import type { PlanningLayout } from "../compat/compat-marker.js";
+
+/**
+ * Determine which .planning/ layout a parsed project uses. Returns null when
+ * no layout signal is present (caller decides: treat as inactive or error).
+ *
+ * Priority (must match transformer.ts transformToGSD):
+ *   1. legacy-milestone-dir — milestones/<id>/ contains <id>-phases/ subdirs
+ *      with phase content. Detected when parsed.milestones has any entry with
+ *      non-empty phases.
+ *   2. multi-milestone — ROADMAP.md parsed into milestone sections.
+ *      Detected when roadmap.milestones.length > 0.
+ *   3. flat-phases — ROADMAP.md parsed into checkbox phase lines only.
+ *      Detected when roadmap.phases.length > 0.
+ */
+export function detectPlanningLayout(parsed: PlanningProject): PlanningLayout | null {
+  const hasMilestoneDirectories = parsed.milestones.some(
+    (m) => Object.keys(m.phases).length > 0,
+  );
+  if (hasMilestoneDirectories) return "legacy-milestone-dir";
+
+  const isMultiMilestone = parsed.roadmap !== null && parsed.roadmap.milestones.length > 0;
+  if (isMultiMilestone) return "multi-milestone";
+
+  const hasFlatPhases = parsed.roadmap !== null && parsed.roadmap.phases.length > 0;
+  if (hasFlatPhases) return "flat-phases";
+
+  return null;
+}