@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/dist/resources/extensions/gsd/migrate/planning-writer.js

@@ -0,0 +1,203 @@
+// Project/App: gsd-pi
+// File Purpose: DB → .planning/ projection. Parallel to writer.ts (which
+// emits .gsd/). Produces the .planning/ markdown shape that gsd-core reads.
+//
+// Layout policy (spec §4.4): emits the layout recorded in the compat marker.
+// v1 supports flat-phases; multi-milestone and legacy-milestone-dir are stubbed
+// with a clear error until fixtures exist to validate them.
+import { mkdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import { getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
+import { saveFile } from "../files.js";
+import { applyPlanningProjectionWrites, } from "../compat/planning-compat.js";
+function planningRoot(basePath) {
+    return join(basePath, ".planning");
+}
+function slugify(title, fallback) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+    return slug || fallback;
+}
+function pad(n, width = 2) {
+    return String(n).padStart(width, "0");
+}
+/**
+ * Format a roadmap for the flat-phases layout. Mirrors the checkbox line
+ * format that parsers.ts parsePhaseEntry recognizes: `- [x] NN — Title`.
+ */
+function formatPlanningRoadmapFlat(entries) {
+    const lines = ["# Roadmap", "", "## Phases", ""];
+    for (const e of entries) {
+        const box = e.done ? "[x]" : "[ ]";
+        lines.push(`- ${box} ${pad(e.number)} — ${e.title}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Format STATE.md in gsd-core's phase-progress schema. gsd-pi is authoritative
+ * for status; this is a one-way DB→projection (edits to STATE.md are not
+ * re-imported — see spec §7).
+ */
+function formatPlanningState(activeMilestone, totalPhases, completedPhases) {
+    const pct = totalPhases === 0 ? 0 : Math.round((completedPhases / totalPhases) * 100);
+    const ts = new Date().toISOString();
+    return [
+        "---",
+        "gsd_state_version: 1.0",
+        `milestone: ${activeMilestone}`,
+        'milestone_name: "milestone"',
+        "status: active",
+        `stopped_at: Phase 01 — in progress`,
+        `last_updated: "${ts}"`,
+        `last_activity: ${ts.slice(0, 10)}`,
+        "progress:",
+        `  total_phases: ${totalPhases}`,
+        `  completed_phases: ${completedPhases}`,
+        `  total_plans: ${totalPhases}`,
+        `  completed_plans: ${completedPhases}`,
+        `  percent: ${pct}`,
+        "---",
+        "",
+        "# Project State",
+        "",
+        "Current Phase: **01**",
+        "Status: **active**",
+        "",
+    ].join("\n");
+}
+function formatPlanningProject(title) {
+    return `# ${title}\n`;
+}
+/**
+ * Format a phase plan file with the XML-tagged structure parsers.ts
+ * parseOldPlan recognizes: <objective>, <tasks>, <verification>.
+ */
+function formatPlanningPlan(phaseNum, planNum, title, tasks) {
+    const lines = [];
+    lines.push(`# ${pad(phaseNum)}-${pad(planNum)}: ${title}`, "");
+    lines.push("<objective>");
+    lines.push(`${title}.`);
+    lines.push("</objective>");
+    lines.push("");
+    lines.push("<tasks>");
+    for (const t of tasks) {
+        const est = t.estimate ? ` _(${t.estimate})_` : "";
+        lines.push(`- [ ] **${t.id}**: ${t.title}${est}`);
+    }
+    lines.push("</tasks>");
+    lines.push("");
+    lines.push("<verification>");
+    lines.push("All tasks complete and tests pass.");
+    lines.push("</verification>");
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Project DB state to .planning/ in the recorded layout.
+ * Reads DB directly (canonical source). Writes via saveFile (atomic).
+ *
+ * v1: flat-phases only. Each milestone's slices become sequentially-numbered
+ * phase dirs; each task within a slice becomes a plan file (NN-MM-PLAN.md).
+ */
+export async function writePlanningDirectory(basePath, layout) {
+    if (layout !== "flat-phases") {
+        // v1: flat-phases only. multi-milestone and legacy-milestone-dir need
+        // fixtures to validate the reverse-mapping (transformer.ts is non-injective
+        // — three layouts collapse to one .gsd/ shape); stub until then.
+        throw new Error(`writePlanningDirectory: layout "${layout}" not yet supported (v1 supports flat-phases only)`);
+    }
+    const root = planningRoot(basePath);
+    mkdirSync(root, { recursive: true });
+    const paths = [];
+    const projectionWrites = [];
+    const toPlanningRel = (absPath) => relative(root, absPath).replace(/\\/g, "/");
+    const milestones = getAllMilestones();
+    if (milestones.length === 0) {
+        return { paths, layout };
+    }
+    // Flat-phases: each slice becomes one phase. Tasks within become plan files.
+    let phaseNum = 0;
+    const roadmapEntries = [];
+    for (const milestone of milestones) {
+        const slices = getMilestoneSlices(milestone.id);
+        for (const slice of slices) {
+            phaseNum++;
+            const phaseSlug = slugify(slice.title || slice.id, slice.id.toLowerCase());
+            const phaseDirName = `${pad(phaseNum)}-${phaseSlug}`;
+            const phaseDir = join(root, "phases", phaseDirName);
+            mkdirSync(phaseDir, { recursive: true });
+            const tasks = getSliceTasks(milestone.id, slice.id);
+            const isDone = tasks.length > 0 && tasks.every((t) => t.status === "complete");
+            roadmapEntries.push({
+                number: phaseNum,
+                title: slice.title || slice.id,
+                done: isDone,
+            });
+            if (tasks.length === 0) {
+                // Empty phase — write a single placeholder plan so the dir isn't empty.
+                const planPath = join(phaseDir, `${pad(phaseNum)}-01-PLAN.md`);
+                await saveFile(planPath, formatPlanningPlan(phaseNum, 1, slice.title || slice.id, []));
+                paths.push(planPath);
+                projectionWrites.push({
+                    relPath: toPlanningRel(planPath),
+                    entities: [`${milestone.id}/${slice.id}`],
+                });
+            }
+            else {
+                for (let ti = 0; ti < tasks.length; ti++) {
+                    const task = tasks[ti];
+                    const planNum = ti + 1;
+                    const planPath = join(phaseDir, `${pad(phaseNum)}-${pad(planNum)}-PLAN.md`);
+                    await saveFile(planPath, formatPlanningPlan(phaseNum, planNum, task.title || task.id, [
+                        {
+                            id: task.id,
+                            title: task.title || task.id,
+                            estimate: task.estimate || undefined,
+                        },
+                    ]));
+                    paths.push(planPath);
+                    projectionWrites.push({
+                        relPath: toPlanningRel(planPath),
+                        entities: [`${milestone.id}/${slice.id}/${task.id}`],
+                    });
+                }
+            }
+        }
+    }
+    // If no slices produced any phases, write a single empty phase so ROADMAP.md
+    // isn't blank and the layout is still discoverable.
+    if (roadmapEntries.length === 0) {
+        const phaseDirName = `${pad(1)}-milestone`;
+        const phaseDir = join(root, "phases", phaseDirName);
+        mkdirSync(phaseDir, { recursive: true });
+        const planPath = join(phaseDir, `${pad(1)}-01-PLAN.md`);
+        await saveFile(planPath, formatPlanningPlan(1, 1, milestones[0].title || milestones[0].id, []));
+        paths.push(planPath);
+        projectionWrites.push({
+            relPath: toPlanningRel(planPath),
+            entities: [milestones[0].id],
+        });
+        roadmapEntries.push({ number: 1, title: milestones[0].title || milestones[0].id, done: false });
+    }
+    // Root files
+    const milestoneEntities = milestones.map((m) => m.id);
+    const roadmapPath = join(root, "ROADMAP.md");
+    await saveFile(roadmapPath, formatPlanningRoadmapFlat(roadmapEntries));
+    paths.push(roadmapPath);
+    projectionWrites.push({ relPath: toPlanningRel(roadmapPath), entities: milestoneEntities });
+    const completedPhases = roadmapEntries.filter((e) => e.done).length;
+    const statePath = join(root, "STATE.md");
+    await saveFile(statePath, formatPlanningState(milestones[0].id, roadmapEntries.length, completedPhases));
+    paths.push(statePath);
+    projectionWrites.push({ relPath: toPlanningRel(statePath), entities: [milestones[0].id] });
+    const projectPath = join(root, "PROJECT.md");
+    await saveFile(projectPath, formatPlanningProject(milestones[0].title || milestones[0].id));
+    paths.push(projectPath);
+    projectionWrites.push({ relPath: toPlanningRel(projectPath), entities: [milestones[0].id] });
+    applyPlanningProjectionWrites(basePath, projectionWrites);
+    return { paths, layout };
+}

package/dist/resources/extensions/gsd/migrate-external.js

@@ -6,12 +6,13 @@
  * symlink replaces the original directory so all paths remain valid.
  */
 import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
-import { externalGsdRoot, isInsideWorktree } from "./repo-identity.js";
+import { externalGsdRoot, externalStateAlreadyExistsForProject, isInsideWorktree } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
 import { hasGitTrackedGsdFiles } from "./gitignore.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
+import { gsdRoot, milestonesDir, resolveGsdRootFile } from "./paths.js";
 /**
  * Migrate a legacy in-project `.gsd/` directory to external storage.
  *
@@ -73,6 +74,15 @@ export function migrateToExternalState(basePath) {
             return { migrated: false };
         }
     }
+    // If external state already contains project data, this is not a legacy
+    // migration source. It is likely an already-migrated project whose symlink
+    // was replaced by a real directory, so copying would risk data loss.
+    if (externalStateAlreadyExistsForProject(basePath)) {
+        return {
+            migrated: false,
+            error: "External state already exists for this project; leaving local .gsd directory untouched to avoid overwriting authoritative state",
+        };
+    }
     const externalPath = externalGsdRoot(basePath);
     const migratingPath = join(basePath, ".gsd.migrating");
     try {
@@ -80,13 +90,13 @@ export function migrateToExternalState(basePath) {
         mkdirSync(externalPath, { recursive: true });
         // Rename .gsd -> .gsd.migrating (atomic lock).
         // On Windows, NTFS may reject rename with EPERM if file descriptors are
-        // open (VS Code watchers, antivirus on-access scan). Fall back to
-        // copy+delete (#1292).
+        // open (VS Code watchers, antivirus on-access scan). WSL/DrvFs can report
+        // the same transient lock as EACCES. Fall back to copy+delete (#1292).
         try {
             renameSync(localGsd, migratingPath);
         }
         catch (renameErr) {
-            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY") {
+            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY" || renameErr?.code === "EACCES") {
                 try {
                     cpSync(localGsd, migratingPath, { recursive: true, force: true });
                     rmSync(localGsd, { recursive: true, force: true });
@@ -109,6 +119,7 @@ export function migrateToExternalState(basePath) {
         }
         // Copy contents to external dir, skipping worktrees/
         const entries = readdirSync(migratingPath, { withFileTypes: true });
+        const copyFailures = [];
         for (const entry of entries) {
             if (entry.name === "worktrees")
                 continue; // worktrees stay local
@@ -122,9 +133,17 @@ export function migrateToExternalState(basePath) {
                     cpSync(src, dst, { force: true });
                 }
             }
-            catch {
-                // Non-fatal: continue with other files
+            catch (copyErr) {
+                copyFailures.push(`${entry.name}: ${getErrorMessage(copyErr)}`);
+            }
+        }
+        if (copyFailures.length > 0) {
+            try {
+                rmSync(localGsd, { force: true });
             }
+            catch { /* may not exist */ }
+            renameSync(migratingPath, localGsd);
+            return { migrated: false, error: `Migration copy failed: ${copyFailures.join("; ")}` };
         }
         // Create symlink .gsd -> external path
         symlinkSync(externalPath, localGsd, "junction");
@@ -159,6 +178,9 @@ export function migrateToExternalState(basePath) {
             catch { /* best-effort restore */ }
             return { migrated: false, error: `Migration verification failed: ${getErrorMessage(verifyErr)}` };
         }
+        // Remove .gsd.migrating once the junction is verified. The git-index cleanup
+        // below is best-effort and does not need the staging copy to survive.
+        rmSync(migratingPath, { recursive: true, force: true });
         // Clean the git index — any .gsd/* files tracked before migration now
         // sit behind the symlink and git can't follow it, causing them to show
         // as deleted. Remove them from the index so the working tree stays clean.
@@ -174,8 +196,6 @@ export function migrateToExternalState(basePath) {
         catch {
             // Non-fatal — git may be unavailable or nothing was tracked
         }
-        // Remove .gsd.migrating only after symlink is verified and index is clean
-        rmSync(migratingPath, { recursive: true, force: true });
         return { migrated: true };
     }
     catch (err) {
@@ -194,17 +214,68 @@ export function migrateToExternalState(basePath) {
         };
     }
 }
+export function isCurrentGsdStateIntactForMigratingCleanup(basePath) {
+    try {
+        const stateFile = resolveGsdRootFile(basePath, "STATE");
+        const milestonesPath = milestonesDir(basePath);
+        const dbPath = join(gsdRoot(basePath), "gsd.db");
+        const hasDbFile = existsSync(dbPath);
+        const hasNonEmptyDb = hasDbFile && statSync(dbPath).size > 0;
+        return existsSync(stateFile) && existsSync(milestonesPath) && hasNonEmptyDb;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeResolvedPath(p) {
+    const normalized = p.replaceAll("\\", "/").replace(/\/+$/, "");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isLocalGsdExternalStateJunction(basePath, localGsd) {
+    try {
+        const stat = lstatSync(localGsd);
+        if (!stat.isSymbolicLink())
+            return false;
+        const resolved = normalizeResolvedPath(realpathSync(localGsd));
+        const resolvedExternal = normalizeResolvedPath(realpathSync(externalGsdRoot(basePath)));
+        return resolved === resolvedExternal;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Recover from a failed migration (`.gsd.migrating` exists).
- * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist.
+ * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist, or removes an
+ * orphaned staging directory when `.gsd` is already a verified external state
+ * junction, or an intact real directory, with intact current state.
  */
 export function recoverFailedMigration(basePath) {
     const localGsd = join(basePath, ".gsd");
     const migratingPath = join(basePath, ".gsd.migrating");
     if (!existsSync(migratingPath))
         return false;
-    if (existsSync(localGsd))
-        return false; // both exist -- ambiguous, don't touch
+    if (existsSync(localGsd)) {
+        if (!isCurrentGsdStateIntactForMigratingCleanup(basePath))
+            return false;
+        if (!isLocalGsdExternalStateJunction(basePath, localGsd)) {
+            try {
+                const stat = lstatSync(localGsd);
+                if (!stat.isDirectory())
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
+        try {
+            rmSync(migratingPath, { recursive: true, force: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     try {
         renameSync(migratingPath, localGsd);
         return true;

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -1,9 +1,10 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
-import { milestonesDir, resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
+import { findMilestoneIds } from "./milestone-ids.js";
+import { resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
 function zeroCounts() {
     return { milestones: 0, slices: 0, tasks: 0 };
 }
@@ -44,6 +45,27 @@ function scanHasExtraIdentities(a, b) {
         hasExtra(a.slices, b.slices) ||
         hasExtra(a.tasks, b.tasks));
 }
+function paddedMilestoneId(id) {
+    return /^\d+$/.test(id) ? `M${id.padStart(3, "0")}` : null;
+}
+function replaceSetPrefix(values, from, to) {
+    for (const value of [...values]) {
+        if (value !== from && !value.startsWith(`${from}/`))
+            continue;
+        values.delete(value);
+        values.add(`${to}${value.slice(from.length)}`);
+    }
+}
+function alignNumericMarkdownIdsWithDb(markdownScan, dbScan) {
+    for (const dbId of dbScan.milestones) {
+        const paddedId = paddedMilestoneId(dbId);
+        if (!paddedId || dbScan.milestones.has(paddedId) || !markdownScan.milestones.has(paddedId))
+            continue;
+        replaceSetPrefix(markdownScan.milestones, paddedId, dbId);
+        replaceSetPrefix(markdownScan.slices, paddedId, dbId);
+        replaceSetPrefix(markdownScan.tasks, paddedId, dbId);
+    }
+}
 /**
  * True when the DB holds any milestone/slice/task identity the markdown lacks —
  * i.e. a `/gsd recover --confirm` (markdown → DB) would DELETE authoritative DB
@@ -55,19 +77,9 @@ export function recoverWouldDeleteDbRows(basePath) {
     return scanHasExtraIdentities(scanDbHierarchy(), scanMarkdownHierarchy(basePath));
 }
 export function scanMarkdownHierarchy(basePath) {
-    const root = milestonesDir(basePath);
-    if (!existsSync(root))
-        return emptyScan();
     const scan = emptyScan();
-    for (const entry of readdirSync(root, { withFileTypes: true })) {
-        if (!entry.isDirectory() || !/^M\d+/.test(entry.name))
-            continue;
-        // Use the CANONICAL milestone id (e.g. "M001" or "M001-a1b2c3"), matching
-        // scanDbHierarchy's milestone.id — not the raw directory name, which may
-        // carry a legacy descriptor (e.g. "M001-some-descriptor"). The canonical id
-        // both keys the identity sets AND resolves files correctly: resolveFile's
-        // prefix/legacy-pattern matching handles the descriptor dir either way.
-        const milestoneId = entry.name.match(/^(M\d+(?:-[a-z0-9]{6})?)/)?.[1] ?? entry.name;
+    // findMilestoneIds handles both flat-phase (NN-slug) and legacy (M###) dirs.
+    for (const milestoneId of findMilestoneIds(basePath)) {
         scan.counts.milestones++;
         scan.milestones.add(milestoneId);
         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
@@ -135,6 +147,7 @@ export async function checkMarkdownHierarchyAgainstDb(basePath) {
     refreshWorkflowDatabaseFromDisk();
     const dbScan = scanDbHierarchy();
     const beforeDb = dbScan.counts;
+    alignNumericMarkdownIdsWithDb(markdownScan, dbScan);
     // Discussion-phase scratch: a milestone dir with no ROADMAP and no DB row is
     // a pre-registration discussion artifact (CONTEXT/CONTEXT-DRAFT only — the
     // queued DB row is inserted only at discussion handoff). Treating it as

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -12,7 +12,7 @@
  */
 import { existsSync, rmSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
+import { resolveMilestonePath, resolveMilestoneFile, relMilestoneFile, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
 import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
@@ -52,7 +52,8 @@ export function parkMilestone(basePath, milestoneId, reason) {
         if (summaryFile)
             return false;
     }
-    const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
+    // Use relMilestoneFile for layout-aware path (legacy: M001-PARKED.md, flat-phase: 01-PARKED.md)
+    const parkedPath = join(basePath, relMilestoneFile(basePath, milestoneId, "PARKED"));
     if (existsSync(parkedPath))
         return false; // already parked
     const content = [
@@ -89,7 +90,8 @@ export function unparkMilestone(basePath, milestoneId) {
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
-    const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
+    // Use relMilestoneFile for layout-aware path (legacy: M001-PARKED.md, flat-phase: 01-PARKED.md)
+    const parkedPath = join(basePath, relMilestoneFile(basePath, milestoneId, "PARKED"));
     const hadParkedFile = existsSync(parkedPath);
     const dbThinksParked = isDbAvailable() && getMilestone(milestoneId)?.status === "parked";
     // Recover the reverse desync too: DB can still say "parked" even when the

package/dist/resources/extensions/gsd/milestone-closeout.js

@@ -18,6 +18,7 @@ import { logWarning } from "./workflow-logger.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { buildCompleteMilestonePrompt } from "./auto-prompts.js";
 import { proveMilestoneCloseout } from "./milestone-closeout-proof.js";
+import { checkCloseoutConsistencyGate } from "./closeout-consistency-gate.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { commitPendingMilestoneCloseoutChanges, findMissingSummaries, isVerificationNotApplicable, readUatGateVerdict, } from "./auto-dispatch.js";
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
@@ -171,6 +172,15 @@ export async function evaluateCompleteMilestoneDispatch(ctx) {
             }
         }
     }
+    if (isDbAvailable()) {
+        // Repair only the missing-validation closeout case here; existing guards below
+        // and post-unit proof remain responsible for blocking incomplete closeouts.
+        checkCloseoutConsistencyGate(mid, {
+            allowOpenMilestone: true,
+            allowPassThroughValidation: true,
+            artifactBasePath: resolveCanonicalMilestoneRoot(basePath, mid),
+        });
+    }
     const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
     if (validationFile) {
         const validationContent = await loadFile(validationFile);
@@ -213,8 +223,8 @@ export async function evaluateCompleteMilestoneDispatch(ctx) {
                         const skippedByPreference = /skip(?:ped)?[\s\-]+(?:by|per|due to)\s+(?:preference|budget|profile)/i.test(validationContent);
                         const skippedByTrivialVariant = /trivial-scope pipeline variant/i.test(validationContent);
                         const structuredMatch = validationContent.includes("Operational") &&
-                            (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED"));
-                        const proseMatch = /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(validationContent);
+                            (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED") || validationContent.includes("PASS") || validationContent.includes("COVERED"));
+                        const proseMatch = /[Oo]perational[\s\S]{0,2000}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(validationContent);
                         const hasOperationalCheck = skippedByMarker ||
                             skippedByPreference ||
                             skippedByTrivialVariant ||

package/dist/resources/extensions/gsd/milestone-ids.js

@@ -5,9 +5,11 @@
  * Consumed by 15+ modules across the GSD extension. Zero side-effects.
  */
 import { randomInt } from "node:crypto";
+import { join } from "node:path";
 import { logWarning } from "./workflow-logger.js";
 import { readdirSync, existsSync } from "node:fs";
-import { milestonesDir } from "./paths.js";
+import { milestonesDir, gsdProjectionRoot } from "./paths.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 import { loadQueueOrder, sortByQueueOrder } from "./queue-order.js";
 import { getErrorMessage } from "./error-utils.js";
 // ─── Regex ──────────────────────────────────────────────────────────────────
@@ -121,26 +123,85 @@ export function clearReservedMilestoneIds() {
     reservedMilestoneIds.clear();
 }
 // ─── Discovery ──────────────────────────────────────────────────────────────
-/** Scan the milestones directory and return IDs sorted by queue order (or numeric fallback). */
-export function findMilestoneIds(basePath) {
-    const dir = milestonesDir(basePath);
+function scanMilestoneIdsFromDir(basePath, dir) {
+    const legacyNumericIds = idsWithLegacyNumericDirs(basePath);
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => {
+        // Legacy layout: exact M001 or M001-abcdef directory name
+        if (MILESTONE_ID_RE.test(d.name)) {
+            return d.name;
+        }
+        // Legacy recovery/imports may contain bare numeric milestone directories
+        // (for example `milestones/15/15-ROADMAP.md`). The DB can preserve that
+        // id, and rebuild renders it, so drift scans must see it too.
+        if (/^\d+$/.test(d.name)) {
+            return d.name;
+        }
+        // Legacy layout: M001-abcdef-slug descriptor directories
+        const legacyMatch = d.name.match(/^(M\d{3}(?:-[a-z0-9]{6})?)-/);
+        if (legacyMatch) {
+            return legacyMatch[1];
+        }
+        // Flat-phase layout: NN-slug → M00N (slug may encode M00N or M00N-abcdef)
+        const flatMatch = d.name.match(/^(\d+)-(.+)$/);
+        if (flatMatch) {
+            const phaseNum = parseInt(flatMatch[1], 10);
+            const fromSlug = normalizeDiscussMilestoneId(flatMatch[2]);
+            if (MILESTONE_ID_RE.test(fromSlug)) {
+                return fromSlug;
+            }
+            const numericId = String(phaseNum);
+            if (legacyNumericIds.has(numericId)) {
+                return numericId;
+            }
+            return `M${String(phaseNum).padStart(3, "0")}`;
+        }
+        return null;
+    })
+        .filter((id) => id !== null);
+}
+function idsWithLegacyNumericDirs(basePath) {
+    const legacyDir = join(gsdProjectionRoot(basePath), "milestones");
+    const ids = new Set();
     try {
-        const ids = readdirSync(dir, { withFileTypes: true })
-            .filter((d) => d.isDirectory())
-            .map((d) => {
-            const match = d.name.match(/^(M\d+(?:-[a-z0-9]{6})?)/);
-            return match ? match[1] : null;
-        })
-            .filter((id) => id !== null);
-        // Apply custom queue order if available, else fall back to numeric sort
-        const customOrder = loadQueueOrder(basePath);
-        return sortByQueueOrder(ids, customOrder);
+        for (const entry of readdirSync(legacyDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && /^\d+$/.test(entry.name))
+                ids.add(entry.name);
+        }
     }
     catch (err) {
-        // Log why milestone scanning failed — silent [] here causes infinite loops (#456)
-        if (existsSync(dir)) {
-            logWarning("engine", `findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
+        // A missing legacy directory is the common, benign case (nothing to
+        // consult). Only surface a real failure when the directory exists but
+        // could not be read.
+        if (existsSync(legacyDir)) {
+            logWarning("engine", `idsWithLegacyNumericDirs: ${legacyDir} exists but readdirSync failed — ${getErrorMessage(err)}`);
+        }
+    }
+    return ids;
+}
+/** Scan the milestones directory and return IDs sorted by queue order (or numeric fallback). */
+export function findMilestoneIds(basePath) {
+    const root = gsdProjectionRoot(basePath);
+    const dirs = [milestonesDir(basePath)];
+    const legacyDir = join(root, "milestones");
+    if (legacyDir !== dirs[0] && existsSync(legacyDir))
+        dirs.push(legacyDir);
+    const phasesDir = join(root, LAYOUT_SEGMENTS.level1);
+    if (phasesDir !== dirs[0] && existsSync(phasesDir))
+        dirs.push(phasesDir);
+    const ids = new Set();
+    for (const dir of dirs) {
+        try {
+            for (const id of scanMilestoneIdsFromDir(basePath, dir))
+                ids.add(id);
+        }
+        catch (err) {
+            if (existsSync(dir)) {
+                logWarning("engine", `findMilestoneIds: ${dir} exists but readdirSync failed — ${getErrorMessage(err)}`);
+            }
         }
-        return [];
     }
+    const customOrder = loadQueueOrder(basePath);
+    return sortByQueueOrder([...ids], customOrder);
 }