@opengsd/gsd-pi 1.0.1 → 1.0.2-dev.0ee79e5

package/src/resources/extensions/gsd/health-widget.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Always-on ambient health signal rendered below the editor.
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";

package/src/resources/extensions/gsd/knowledge-backfill.ts

@@ -1,4 +1,4 @@
-// GSD2 — KNOWLEDGE.md -> memories backfill (ADR-013 Stage 2b).
+// gsd-pi — KNOWLEDGE.md -> memories backfill (ADR-013 Stage 2b).
 //
 // Idempotent migration of `.gsd/KNOWLEDGE.md` Patterns and Lessons rows into
 // the `memories` table. Patterns become memories with `category: "pattern"`;

package/src/resources/extensions/gsd/knowledge-capture.ts

@@ -1,4 +1,4 @@
-// GSD2 — KNOWLEDGE.md write-side cutover (ADR-013 Stage 2c).
+// gsd-pi — KNOWLEDGE.md write-side cutover (ADR-013 Stage 2c).
 //
 // Replaces the legacy `appendKnowledge` file-append path for Patterns and
 // Lessons with `createMemory` calls. Rules (K###) continue to flow through

package/src/resources/extensions/gsd/knowledge-parser.ts

@@ -1,4 +1,4 @@
-// GSD-2 — KNOWLEDGE.md parsing helpers shared by the consolidation scanner,
+// gsd-pi — KNOWLEDGE.md parsing helpers shared by the consolidation scanner,
 // the Patterns/Lessons backfill, and the hybrid projection renderer
 // (ADR-013 Stage 2a/2b).
 //

package/src/resources/extensions/gsd/knowledge-projection.ts

@@ -1,4 +1,4 @@
-// GSD2 — KNOWLEDGE.md hybrid projection renderer (ADR-013 Stage 2b).
+// gsd-pi — KNOWLEDGE.md hybrid projection renderer (ADR-013 Stage 2b).
 //
 // Renders `.gsd/KNOWLEDGE.md` as a hybrid file:
 //   - Rules section: read directly from the existing KNOWLEDGE.md (manual,

package/src/resources/extensions/gsd/legacy-telemetry.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Runtime counters for telemetry-gated legacy compatibility paths.
 
 import { mkdirSync, writeFileSync } from "node:fs";
@@ -7,7 +7,6 @@ import { dirname } from "node:path";
 import { logWarning } from "./workflow-logger.js";
 
 export type LegacyTelemetryCounter =
-  | "legacy.markdownFallbackUsed"
   | "legacy.workflowEngineUsed"
   | "legacy.uokFallbackUsed"
   | "legacy.mcpAliasUsed"
@@ -22,7 +21,6 @@ export interface LegacyTelemetryReport {
 }
 
 const COUNTERS: LegacyTelemetryCounter[] = [
-  "legacy.markdownFallbackUsed",
   "legacy.workflowEngineUsed",
   "legacy.uokFallbackUsed",
   "legacy.mcpAliasUsed",
@@ -37,7 +35,6 @@ const values: LegacyTelemetrySnapshot = Object.fromEntries(
 const warnedCounters = new Set<LegacyTelemetryCounter>();
 
 const DIAGNOSTICS: Record<LegacyTelemetryCounter, string> = {
-  "legacy.markdownFallbackUsed": "Deprecated markdown state fallback used; migrate projects to DB-authoritative state before removing markdown derivation.",
   "legacy.workflowEngineUsed": "Deprecated workflow engine path used; prefer auto-milestone workflow templates before removing legacy engines.",
   "legacy.uokFallbackUsed": "Deprecated UOK fallback path used; resolve UOK kernel blockers before removing parity fallback wrappers.",
   "legacy.mcpAliasUsed": "Deprecated MCP alias tool used; update callers to the canonical gsd_* tool name before alias removal.",

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Markdown projection renderer for GSD workflow database rows.
 // GSD Markdown Renderer — DB → Markdown file generation
 //

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

@@ -175,8 +175,8 @@ export function parseRequirementsSections(content: string): Requirement[] {
       continue;
     }
 
-    // Check for requirement heading (### RXXX — Title)
-    const reqMatch = line.match(/^###\s+(R\d+)\s*[—–-]\s*(.+)/);
+    // Check for requirement heading (### RXXX — Title or ### NET-01 — Title)
+    const reqMatch = line.match(/^###\s+([A-Z][A-Z0-9]*-\d+|R\d+)\s*[—–-]\s*(.+)/i);
     if (reqMatch) {
       flushReq();
       if (currentSectionStatus !== null) {

package/src/resources/extensions/gsd/memory-backfill.ts

@@ -1,4 +1,4 @@
-// GSD2 — Decisions -> memories backfill (ADR-013 step 5)
+// gsd-pi — Decisions -> memories backfill (ADR-013 step 5)
 //
 // Idempotent migration that copies every decisions row (active and
 // superseded — see Stage 2a note below) into the memories table with

package/src/resources/extensions/gsd/memory-consolidation-scanner.ts

@@ -1,4 +1,4 @@
-// GSD-2 — ADR-013 Phase 6 preflight scanner.
+// gsd-pi — ADR-013 Phase 6 preflight scanner.
 //
 // Read-only detection of rows in the legacy knowledge surfaces (decisions
 // table, `.gsd/KNOWLEDGE.md`) that lack a corresponding `memories` row.

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

@@ -1,4 +1,4 @@
-// GSD-2 + metrics.ts: token & cost tracking for auto-mode units
+// gsd-pi + metrics.ts: token & cost tracking for auto-mode units
 /**
  * GSD Metrics — Token & Cost Tracking
  *

package/src/resources/extensions/gsd/migrate/audit.ts

@@ -1,4 +1,4 @@
-// GSD-2 - /gsd migrate audit helpers.
+// gsd-pi - /gsd migrate audit helpers.
 // File Purpose: Legacy archive, migration manifest, and projection verification support.
 
 import { cpSync, existsSync, readFileSync } from "node:fs";
@@ -28,6 +28,10 @@ export interface LegacyArchiveResult {
 export interface MigrationProjectionVerification {
   markdown: HierarchyCounts;
   db: HierarchyCounts;
+  dbReadiness: {
+    phase: string;
+    registry: number;
+  };
   rendered: number;
   skipped: number;
   errors: string[];
@@ -84,7 +88,7 @@ export async function archiveLegacyPlanningDirectory(
     sourcePath,
     archivePath: relToGsd(targetRoot, archivePath),
     strategy: "full-source-copy",
-    note: "Full .planning source copied so legacy content without a GSD-2 field is not lost.",
+    note: "Full .planning source copied so legacy content without a gsd-pi field is not lost.",
   };
 
   await saveFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
@@ -125,6 +129,7 @@ export async function verifyMigrationProjection(
   return {
     markdown,
     db,
+    dbReadiness: { phase: "not-checked", registry: 0 },
     rendered: render.rendered,
     skipped: render.skipped,
     errors,
@@ -156,6 +161,7 @@ function formatMigrationMarkdown(input: MigrationAuditInput): string {
     "",
     `- DB: ${input.verification.db.milestones}M/${input.verification.db.slices}S/${input.verification.db.tasks}T`,
     `- Markdown: ${input.verification.markdown.milestones}M/${input.verification.markdown.slices}S/${input.verification.markdown.tasks}T`,
+    `- DB readiness: ${input.verification.dbReadiness.phase} (${input.verification.dbReadiness.registry} milestone(s) visible)`,
     `- Rendered: ${input.verification.rendered}`,
     `- Skipped: ${input.verification.skipped}`,
     "",

package/src/resources/extensions/gsd/migrate/command.ts

@@ -6,7 +6,7 @@
  * All business logic lives in the pipeline modules (S01–S03).
  *
  * After a successful write, offers a read-only review that audits the output
- * for GSD-2 standards compliance.
+ * for gsd-pi standards compliance.
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
@@ -27,7 +27,7 @@ import type { MigrationPreview, WrittenFiles } from "./writer.js";
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { clearArtifacts, clearDecisions, clearRequirements, clearEngineHierarchy, transaction } from "../gsd-db.js";
 import { migrateFromMarkdown } from "../md-importer.js";
-import { invalidateStateCache } from "../state.js";
+import { deriveState, invalidateStateCache } from "../state.js";
 import {
   archiveLegacyPlanningDirectory,
   verifyMigrationProjection,
@@ -100,6 +100,25 @@ export async function importWrittenMigrationToDb(
   return counts;
 }
 
+export async function assertMigrationDbReadiness(
+  targetRoot: string,
+  preview: MigrationPreview,
+): Promise<{ phase: string; registry: number }> {
+  invalidateStateCache();
+  const state = await deriveState(targetRoot);
+  const dbUnavailable = state.blockers.some((blocker) => blocker.includes("DB unavailable"));
+  if (dbUnavailable) {
+    throw new Error(`migration DB readiness failed: ${state.blockers.join("; ")}`);
+  }
+  if (state.registry.length !== preview.milestoneCount) {
+    throw new Error(`migration DB readiness failed: registry ${state.registry.length}/${preview.milestoneCount}`);
+  }
+  return {
+    phase: state.phase,
+    registry: state.registry.length,
+  };
+}
+
 export async function executeMigrationWrite(
   sourcePath: string,
   targetRoot: string,
@@ -114,6 +133,7 @@ export async function executeMigrationWrite(
     const legacyArchive = await archiveLegacyPlanningDirectory(sourcePath, targetRoot);
     const imported = await importWrittenMigrationToDb(targetRoot, preview);
     const verification = await verifyMigrationProjection(targetRoot, preview);
+    verification.dbReadiness = await assertMigrationDbReadiness(targetRoot, preview);
     const audit = await writeMigrationAudit({
       sourcePath,
       targetRoot,
@@ -144,9 +164,12 @@ function formatPreviewStats(preview: MigrationPreview): string {
   ];
   if (preview.requirements.total > 0) {
     lines.push(
-      `- Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred)`,
+      `- Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred, ${preview.requirements.outOfScope} out of scope)`,
     );
   }
+  if (preview.migrationInputs) {
+    lines.push(`- Legacy inputs: ${preview.migrationInputs.milestonePhaseDirs} milestone phase dir(s), ${preview.migrationInputs.decisions} decision file(s), ${preview.migrationInputs.seeds} seed file(s)`);
+  }
   return lines.join("\n");
 }
 
@@ -248,9 +271,12 @@ export async function handleMigrate(
 
   if (preview.requirements.total > 0) {
     lines.push(
-      `Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred)`,
+      `Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred, ${preview.requirements.outOfScope} out of scope)`,
     );
   }
+  if (preview.migrationInputs) {
+    lines.push(`Legacy inputs: ${preview.migrationInputs.milestonePhaseDirs} milestone phase dir(s), ${preview.migrationInputs.decisions} decision file(s), ${preview.migrationInputs.seeds} seed file(s)`);
+  }
 
   const targetGsdExists = existsSync(gsdRoot(targetRoot));
   if (targetGsdExists) {
@@ -315,7 +341,7 @@ export async function handleMigrate(
       `Legacy source archived at ${execution.legacyArchive.archivePath}`,
       `Migration audit written at ${execution.audit.migrationPath}`,
       "",
-      "The agent can now review the migrated output against GSD-2 standards —",
+      "The agent can now review the migrated output against gsd-pi standards —",
       "checking structure, content quality, deriveState() round-trip, and",
       "requirement statuses. The review is read-only by default.",
     ],

package/src/resources/extensions/gsd/migrate/index.ts

@@ -32,7 +32,7 @@ export type {
   ValidationResult,
   ValidationIssue,
   ValidationSeverity,
-  // Output types (GSD-2 format)
+  // Output types (gsd-pi format)
   GSDProject,
   GSDMilestone,
   GSDSlice,

package/src/resources/extensions/gsd/migrate/parser.ts

@@ -23,6 +23,8 @@ import type {
   PlanningQuickTask,
   PlanningMilestone,
   PlanningResearch,
+  PlanningDecision,
+  PlanningSeed,
   PlanningPhaseFile,
 } from './types.js';
 
@@ -73,9 +75,11 @@ function parseQuickDir(dirName: string): { number: number; slug: string } | null
 
 /** Plan file pattern: NN-NN-PLAN.md (e.g. 29-01-PLAN.md) or NN-NNb-PLAN.md. */
 const PLAN_RE = /^(\d+(?:\.\d+)?)-(\d+[a-z]?)-PLAN\.md$/i;
+const SHORT_PLAN_RE = /^(\d+[a-z]?)-PLAN\.md$/i;
 
 /** Summary file pattern: NN-NN-SUMMARY.md (e.g. 29-01-SUMMARY.md) or NN-NNb-SUMMARY.md. */
 const SUMMARY_RE = /^(\d+(?:\.\d+)?)-(\d+[a-z]?)-SUMMARY\.md$/i;
+const SHORT_SUMMARY_RE = /^(\d+[a-z]?)-SUMMARY\.md$/i;
 
 /** Research file pattern: contains RESEARCH (case-insensitive) */
 const RESEARCH_RE = /research/i;
@@ -103,17 +107,17 @@ function scanPhaseDirectory(phaseDir: string, dirName: string, parsed: ReturnTyp
     // Skip directories within phase dirs
     if (isDir(entryPath)) continue;
 
-    const planMatch = entry.match(PLAN_RE);
+    const planMatch = entry.match(PLAN_RE) ?? entry.match(SHORT_PLAN_RE);
     if (planMatch) {
-      const planNumber = planMatch[2];
+      const planNumber = planMatch[2] ?? planMatch[1];
       const content = readFileSync(entryPath, 'utf-8');
       phase.plans[planNumber] = parseOldPlan(content, entry, planNumber);
       continue;
     }
 
-    const summaryMatch = entry.match(SUMMARY_RE);
+    const summaryMatch = entry.match(SUMMARY_RE) ?? entry.match(SHORT_SUMMARY_RE);
     if (summaryMatch) {
-      const planNumber = summaryMatch[2];
+      const planNumber = summaryMatch[2] ?? summaryMatch[1];
       const content = readFileSync(entryPath, 'utf-8');
       phase.summaries[planNumber] = parseOldSummary(content, entry, planNumber);
       continue;
@@ -184,19 +188,37 @@ function scanMilestonesDirectory(msDir: string): PlanningMilestone[] {
   if (entries.length === 0) return [];
 
   // Group files by milestone ID prefix (e.g. "v2.2" from "v2.2-ROADMAP.md")
-  const grouped = new Map<string, { requirements: string | null; roadmap: string | null; extraFiles: PlanningPhaseFile[] }>();
+  const grouped = new Map<string, { requirements: string | null; roadmap: string | null; phases: Record<string, PlanningPhase>; extraFiles: PlanningPhaseFile[] }>();
+
+  function ensureMilestone(id: string) {
+    if (!grouped.has(id)) grouped.set(id, { requirements: null, roadmap: null, phases: {}, extraFiles: [] });
+    return grouped.get(id)!;
+  }
 
   for (const entry of entries) {
     const entryPath = join(msDir, entry);
-    if (isDir(entryPath)) continue;
+    if (isDir(entryPath)) {
+      const phasesMatch = entry.match(/^(.+)-phases$/i);
+      if (!phasesMatch) continue;
+      const ms = ensureMilestone(phasesMatch[1]);
+      const phaseDirs = listDir(entryPath).sort();
+      for (const dirName of phaseDirs) {
+        if (dirName.startsWith('.')) continue;
+        const dirPath = join(entryPath, dirName);
+        if (!isDir(dirPath)) continue;
+        const parsed = parsePhaseDir(dirName);
+        if (!parsed) continue;
+        ms.phases[dirName] = scanPhaseDirectory(dirPath, dirName, parsed);
+      }
+      continue;
+    }
 
     // Extract milestone ID: everything before the first dash-followed-by-uppercase or common suffix
     const idMatch = entry.match(/^(.+?)-(ROADMAP|REQUIREMENTS|SUMMARY)\.md$/i);
     if (idMatch) {
       const id = idMatch[1];
       const type = idMatch[2].toUpperCase();
-      if (!grouped.has(id)) grouped.set(id, { requirements: null, roadmap: null, extraFiles: [] });
-      const ms = grouped.get(id)!;
+      const ms = ensureMilestone(id);
       const content = readFileSync(entryPath, 'utf-8');
 
       if (type === 'REQUIREMENTS') ms.requirements = content;
@@ -206,9 +228,9 @@ function scanMilestonesDirectory(msDir: string): PlanningMilestone[] {
       // Non-standard file — try to extract ID from filename
       const simpleMatch = entry.match(/^(.+?)\./);
       const id = simpleMatch ? simpleMatch[1] : entry;
-      if (!grouped.has(id)) grouped.set(id, { requirements: null, roadmap: null, extraFiles: [] });
+      const ms = ensureMilestone(id);
       const content = readFileSync(entryPath, 'utf-8');
-      grouped.get(id)!.extraFiles.push({ fileName: entry, content });
+      ms.extraFiles.push({ fileName: entry, content });
     }
   }
 
@@ -216,6 +238,7 @@ function scanMilestonesDirectory(msDir: string): PlanningMilestone[] {
     id,
     requirements: data.requirements,
     roadmap: data.roadmap,
+    phases: data.phases,
     extraFiles: data.extraFiles,
   }));
 }
@@ -236,6 +259,28 @@ function scanResearchDirectory(researchDir: string): PlanningResearch[] {
   return research;
 }
 
+function scanDecisionDirectory(decisionsDir: string): PlanningDecision[] {
+  return scanFlatMarkdownDirectory(decisionsDir);
+}
+
+function scanSeedDirectory(seedsDir: string): PlanningSeed[] {
+  return scanFlatMarkdownDirectory(seedsDir);
+}
+
+function scanFlatMarkdownDirectory<T extends PlanningPhaseFile>(dir: string): T[] {
+  const entries = listDir(dir).sort();
+  const files: T[] = [];
+
+  for (const entry of entries) {
+    const entryPath = join(dir, entry);
+    if (isDir(entryPath)) continue;
+    const content = readFileSync(entryPath, 'utf-8');
+    files.push({ fileName: entry, content } as T);
+  }
+
+  return files;
+}
+
 // ─── Main Orchestrator ─────────────────────────────────────────────────────
 
 /**
@@ -307,6 +352,12 @@ export async function parsePlanningDirectory(path: string): Promise<PlanningProj
   const researchDir = join(path, 'research');
   const research = isDir(researchDir) ? scanResearchDirectory(researchDir) : [];
 
+  const decisionsDir = join(path, 'decisions');
+  const decisions = isDir(decisionsDir) ? scanDecisionDirectory(decisionsDir) : [];
+
+  const seedsDir = join(path, 'seeds');
+  const seeds = isDir(seedsDir) ? scanSeedDirectory(seedsDir) : [];
+
   return {
     path,
     project,
@@ -318,6 +369,8 @@ export async function parsePlanningDirectory(path: string): Promise<PlanningProj
     quickTasks,
     milestones,
     research,
+    decisions,
+    seeds,
     validation,
   };
 }

package/src/resources/extensions/gsd/migrate/parsers.ts

@@ -610,6 +610,23 @@ export function parseOldRequirements(content: string): PlanningRequirement[] {
       continue;
     }
 
+    const emojiReqMatch = line.match(/^-\s+(✅|✓|⏳|✗)\s+([A-Z][A-Z0-9]*-\d+|R\d+)\s*:\s*(.+)$/i);
+    if (emojiReqMatch) {
+      flushReq();
+      const marker = emojiReqMatch[1];
+      const id = emojiReqMatch[2].trim();
+      const desc = emojiReqMatch[3].trim();
+      const status = marker === '✗' ? 'rejected' : marker === '⏳' ? 'active' : 'validated';
+      requirements.push({
+        id,
+        title: desc,
+        status,
+        description: desc,
+        raw: line,
+      });
+      continue;
+    }
+
     // Description or metadata within a requirement
     if (currentReq) {
       currentRaw.push(line);

package/src/resources/extensions/gsd/migrate/preview.ts

@@ -46,6 +46,7 @@ export function generatePreview(project: GSDProject): MigrationPreview {
     decisions: {
       total: countCanonicalDecisionRows(project.decisionsContent),
     },
+    migrationInputs: project.migrationInputs,
     milestoneCount: project.milestones.length,
     totalSlices,
     totalTasks,

package/src/resources/extensions/gsd/migrate/safety.ts

@@ -1,4 +1,4 @@
-// GSD-2 - /gsd migrate safety helpers.
+// gsd-pi - /gsd migrate safety helpers.
 // File Purpose: Path resolution, target guards, backup, and restore support for v1 migration.
 
 import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";

package/src/resources/extensions/gsd/migrate/transformer.ts

@@ -10,6 +10,7 @@ import type {
   PlanningRoadmapMilestone,
   PlanningResearch,
   PlanningRequirement,
+  PlanningMilestone,
   GSDProject,
   GSDMilestone,
   GSDSlice,
@@ -19,6 +20,7 @@ import type {
   GSDTaskSummaryData,
   GSDBoundaryEntry,
 } from './types.js';
+import { parseOldRequirements } from './parsers.js';
 
 // ─── Helpers ───────────────────────────────────────────────────────────────
 
@@ -241,18 +243,22 @@ function buildMilestoneFromEntries(
 
 const VALID_STATUSES = new Set(['active', 'validated', 'deferred']);
 const COMPLETE_ALIASES = new Set(['complete', 'completed', 'done', 'shipped']);
+const OUT_OF_SCOPE_ALIASES = new Set(['rejected', 'reject', 'out-of-scope', 'out of scope']);
 
-function normalizeStatus(status: string): 'active' | 'validated' | 'deferred' {
+function normalizeStatus(status: string): 'active' | 'validated' | 'deferred' | 'out-of-scope' {
   const lower = status.toLowerCase().trim();
   if (VALID_STATUSES.has(lower)) return lower as 'active' | 'validated' | 'deferred';
   if (COMPLETE_ALIASES.has(lower)) return 'validated';
+  if (OUT_OF_SCOPE_ALIASES.has(lower)) return 'out-of-scope';
   return 'active';
 }
 
 function normalizeRequirementId(id: string): string | null {
-  const match = id.trim().match(/^R(\d+)$/i);
-  if (!match) return null;
-  return `R${match[1].padStart(3, '0')}`;
+  const trimmed = id.trim().toUpperCase();
+  const rMatch = trimmed.match(/^R(\d+)$/);
+  if (rMatch) return `R${rMatch[1].padStart(3, '0')}`;
+  if (/^[A-Z][A-Z0-9]*-\d+$/.test(trimmed)) return trimmed;
+  return null;
 }
 
 function mapRequirements(reqs: PlanningRequirement[]): GSDRequirement[] {
@@ -302,6 +308,16 @@ function mapRequirements(reqs: PlanningRequirement[]): GSDRequirement[] {
   });
 }
 
+function collectRequirements(parsed: PlanningProject): PlanningRequirement[] {
+  const requirements = [...parsed.requirements];
+  for (const milestone of parsed.milestones) {
+    if (milestone.requirements) {
+      requirements.push(...parseOldRequirements(milestone.requirements));
+    }
+  }
+  return requirements;
+}
+
 // ─── Project-Level Derivation ──────────────────────────────────────────────
 
 function deriveVision(parsed: PlanningProject): string {
@@ -327,6 +343,10 @@ function deriveVision(parsed: PlanningProject): string {
 function deriveDecisions(parsed: PlanningProject): string {
   // Extract key decisions from phase summaries if available
   const decisions: string[] = [];
+  const decisionFiles = [...parsed.decisions].sort((a, b) => a.fileName.localeCompare(b.fileName));
+  for (const decision of decisionFiles) {
+    decisions.push(extractDecisionTitle(decision.fileName, decision.content));
+  }
   for (const phase of Object.values(parsed.phases)) {
     for (const summary of Object.values(phase.summaries)) {
       const kd = summary.frontmatter['key-decisions'] ?? [];
@@ -354,16 +374,66 @@ function deriveDecisions(parsed: PlanningProject): string {
   return lines.join('\n') + '\n';
 }
 
+function extractDecisionTitle(fileName: string, content: string): string {
+  const heading = content.split('\n').find((line) => /^#\s+/.test(line.trim()));
+  if (heading) return heading.replace(/^#\s+/, '').trim();
+  return fileName.replace(/\.md$/i, '').replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/-/g, ' ');
+}
+
+function buildMilestoneFromLegacyMilestone(source: PlanningMilestone, index: number): GSDMilestone {
+  const entries: PlanningRoadmapEntry[] = [];
+  if (source.roadmap) {
+    entries.push(...parseRoadmapEntries(source.roadmap));
+  }
+
+  const phases = source.phases;
+  if (entries.length === 0) {
+    for (const phase of Object.values(phases).sort((a, b) => a.number - b.number)) {
+      entries.push({
+        number: phase.number,
+        title: phase.slug,
+        done: Object.keys(phase.summaries).length > 0,
+        raw: '',
+      });
+    }
+  }
+
+  const title = `${source.id} Migration`;
+  return buildMilestoneFromEntries(milestoneId(index + 1), title, entries, phases, []);
+}
+
+function parseRoadmapEntries(content: string): PlanningRoadmapEntry[] {
+  const entries: PlanningRoadmapEntry[] = [];
+  for (const line of content.split('\n')) {
+    const match = line.match(/^-\s+\[([ xX])\]\s+(\d+(?:\.\d+)?)\s+[—–-]\s+(.+)$/);
+    if (!match) continue;
+    entries.push({
+      number: Number(match[2]),
+      title: match[3].trim(),
+      done: match[1].toLowerCase() === 'x',
+      raw: line,
+    });
+  }
+  return entries;
+}
+
 // ─── Main Entry Point ──────────────────────────────────────────────────────
 
 export function transformToGSD(parsed: PlanningProject): GSDProject {
   const milestones: GSDMilestone[] = [];
 
   const roadmap = parsed.roadmap;
+  const legacyMilestonesWithPhases = parsed.milestones.filter((milestone) => Object.keys(milestone.phases).length > 0);
+  const hasMilestoneDirectories = legacyMilestonesWithPhases.length > 0;
   const isMultiMilestone = roadmap !== null && roadmap.milestones.length > 0;
   const hasFlatPhases = roadmap !== null && roadmap.phases.length > 0;
 
-  if (isMultiMilestone) {
+  if (hasMilestoneDirectories) {
+    const sorted = [...legacyMilestonesWithPhases].sort((a, b) => a.id.localeCompare(b.id, undefined, { numeric: true, sensitivity: 'base' }));
+    for (let mi = 0; mi < sorted.length; mi++) {
+      milestones.push(buildMilestoneFromLegacyMilestone(sorted[mi], mi));
+    }
+  } else if (isMultiMilestone) {
     // Multi-milestone mode: each roadmap milestone section → one GSDMilestone
     for (let mi = 0; mi < roadmap!.milestones.length; mi++) {
       const rm = roadmap!.milestones[mi];
@@ -405,7 +475,12 @@ export function transformToGSD(parsed: PlanningProject): GSDProject {
   return {
     milestones,
     projectContent: parsed.project ?? '',
-    requirements: mapRequirements(parsed.requirements),
+    requirements: mapRequirements(collectRequirements(parsed)),
     decisionsContent: deriveDecisions(parsed),
+    migrationInputs: {
+      milestonePhaseDirs: parsed.milestones.filter((milestone) => Object.keys(milestone.phases).length > 0).length,
+      decisions: parsed.decisions.length,
+      seeds: parsed.seeds.length,
+    },
   };
 }

package/src/resources/extensions/gsd/migrate/types.ts

@@ -40,6 +40,10 @@ export interface PlanningProject {
   milestones: PlanningMilestone[];
   /** Research files from top-level research/ directory */
   research: PlanningResearch[];
+  /** Decision files from decisions/ directory */
+  decisions: PlanningDecision[];
+  /** Seed files from seeds/ directory */
+  seeds: PlanningSeed[];
   /** Validation result from pre-flight checks */
   validation: ValidationResult;
 }
@@ -198,6 +202,20 @@ export interface PlanningResearch {
   content: string;
 }
 
+export interface PlanningDecision {
+  /** File name */
+  fileName: string;
+  /** Raw content */
+  content: string;
+}
+
+export interface PlanningSeed {
+  /** File name */
+  fileName: string;
+  /** Raw content */
+  content: string;
+}
+
 // ─── Config ────────────────────────────────────────────────────────────────
 
 export interface PlanningConfig {
@@ -231,6 +249,8 @@ export interface PlanningMilestone {
   requirements: string | null;
   /** Roadmap file content, null if missing */
   roadmap: string | null;
+  /** Per-milestone phase directories keyed by full directory name */
+  phases: Record<string, PlanningPhase>;
   /** Any other files */
   extraFiles: PlanningPhaseFile[];
 }
@@ -257,7 +277,7 @@ export interface PlanningPhaseFile {
 
 // ═══════════════════════════════════════════════════════════════════════════
 // GSD Output Types — produced by transformer, consumed by writer (S03)
-// Mirror GSD-2 runtime shapes so deriveState() works on migrated output.
+// Mirror gsd-pi runtime shapes so deriveState() works on migrated output.
 // ═══════════════════════════════════════════════════════════════════════════
 
 export interface GSDProject {
@@ -267,6 +287,14 @@ export interface GSDProject {
   requirements: GSDRequirement[];
   /** Empty or pass-through from old project key decisions */
   decisionsContent: string;
+  /** Counts surfaced in preview/audit for legacy inputs that used to be skipped. */
+  migrationInputs?: GSDMigrationInputs;
+}
+
+export interface GSDMigrationInputs {
+  milestonePhaseDirs: number;
+  decisions: number;
+  seeds: number;
 }
 
 export interface GSDMilestone {