@opengsd/gsd-pi 1.5.0-dev.553dc518 → 1.5.0-dev.c4c8885f

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -13,13 +13,12 @@ import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
 import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTasksBySliceIds, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
-import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, gsdProjectionRoot, gsdRoot, buildMilestoneFileName, buildTaskFileName, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, targetMilestoneFile, targetSliceFile, gsdProjectionRoot, gsdRoot, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache, milestonesDir, legacyMilestonesDir, isLegacyMilestonesLayout, resolveMilestonePath, relSliceFile, canonicalPhaseDirName } from "./paths.js";
 import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "./compat/compat-marker.js";
-import { planFileName, milestoneIdToPhaseNum, sliceIdToPlanNum, } from "./layout-policy.js";
 // ─── Compat marker invalidation ───────────────────────────────────────────
 // Every successful projection write pushes its (basePath, projectionPath,
 // entities) here; invalidateCaches() drains it and refreshes .gsd/.compat.json
@@ -134,19 +133,6 @@ function sanitizeInlineRoadmapText(value) {
         .replace(/\s+/g, " ")
         .trim();
 }
-function resolveRoadmapProjectionPath(basePath, milestoneId) {
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const existing = resolveMilestonePath(basePath, milestoneId);
-    const legacyBase = legacyMilestonesDir(basePath);
-    const isLegacyLayout = existing
-        ? existing.startsWith(legacyBase + "/") || existing.startsWith(legacyBase + "\\")
-        : isLegacyMilestonesLayout(basePath);
-    const phaseDir = existing ?? join(isLegacyLayout ? legacyBase : milestonesDir(basePath), isLegacyLayout ? milestoneId : canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    const roadmapFileName = isLegacyLayout
-        ? `${milestoneId}-ROADMAP.md`
-        : `${String(phaseNum).padStart(2, "0")}-ROADMAP.md`;
-    return join(phaseDir, roadmapFileName);
-}
 function isMilestoneFlatPhaseLayout(basePath, milestoneId) {
     const existing = resolveMilestonePath(basePath, milestoneId);
     const legacyBase = legacyMilestonesDir(basePath);
@@ -492,7 +478,7 @@ export async function renderRoadmapFromDb(basePath, milestoneId) {
     // clear "write the ROADMAP" failure) instead of a misleading stub.
     if (slices.length === 0 && !milestone.vision.trim()) {
         logWarning("projection", `renderRoadmapFromDb skipped unplanned milestone ${milestoneId} (zero slices, empty vision) — refusing to write a stub ROADMAP`);
-        const absPath = resolveRoadmapProjectionPath(basePath, milestoneId);
+        const absPath = targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestone.title);
         if (existsSync(absPath)) {
             const artifactPath = toArtifactPath(absPath, basePath);
             unlinkSync(absPath);
@@ -506,7 +492,7 @@ export async function renderRoadmapFromDb(basePath, milestoneId) {
         }
         return { skipped: "unplanned-milestone" };
     }
-    const absPath = resolveRoadmapProjectionPath(basePath, milestoneId);
+    const absPath = targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestone.title);
     const artifactPath = toArtifactPath(absPath, basePath);
     const content = renderRoadmapMarkdown(milestone, slices);
     await writeAndStore(absPath, artifactPath, content, {
@@ -536,21 +522,15 @@ export async function renderMilestoneArtifactsFromDb(basePath, milestoneId) {
     const artifacts = getMilestoneScopedArtifacts(milestoneId);
     if (artifacts.length === 0)
         return false;
-    const phaseDir = resolveMilestonePath(basePath, milestoneId) ??
-        join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    mkdirSync(phaseDir, { recursive: true });
-    const legacyBase = legacyMilestonesDir(basePath);
-    const isLegacy = phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\");
+    const milestone = getMilestone(milestoneId);
     let wrote = false;
     for (const artifact of artifacts) {
         if (artifact.artifact_type === "ROADMAP")
             continue;
         if (!artifact.full_content.trim())
             continue;
-        const fileName = isLegacy
-            ? `${milestoneId}-${artifact.artifact_type}.md`
-            : buildMilestoneFileName(milestoneId, artifact.artifact_type);
-        const absPath = join(phaseDir, fileName);
+        const absPath = targetMilestoneFile(basePath, milestoneId, artifact.artifact_type, milestone?.title);
+        mkdirSync(dirname(absPath), { recursive: true });
         const artifactPath = toArtifactPath(absPath, basePath);
         await writeAndStore(absPath, artifactPath, artifact.full_content, {
             artifact_type: artifact.artifact_type,
@@ -664,20 +644,11 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
     if (!slice) {
         return false; // No slice data — skip silently
     }
-    // Flat-phase: resolve or create the phase dir, since resolveSlicePath only
-    // finds existing dirs. In flat-phase the slice "path" is the phase dir.
-    let slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
-    if (!slicePath) {
-        const mDir = milestonesDir(basePath);
-        const dirName = canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title);
-        slicePath = join(mDir, dirName);
-        mkdirSync(slicePath, { recursive: true });
-    }
+    const milestoneTitle = getMilestone(milestoneId)?.title;
     let wrote = false;
-    // Write SUMMARY — flat-phase: NN-MM-SUMMARY.md inside phase dir
     if (slice.full_summary_md) {
-        const summaryName = planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), "SUMMARY");
-        const summaryAbs = join(slicePath, summaryName);
+        const summaryAbs = targetSliceFile(basePath, milestoneId, sliceId, "SUMMARY", milestoneTitle);
+        mkdirSync(dirname(summaryAbs), { recursive: true });
         const summaryArtifact = toArtifactPath(summaryAbs, basePath);
         await writeAndStore(summaryAbs, summaryArtifact, slice.full_summary_md, {
             artifact_type: "SUMMARY",
@@ -686,10 +657,9 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
         }, basePath);
         wrote = true;
     }
-    // Write UAT — flat-phase: NN-MM-UAT.md inside phase dir
     if (slice.full_uat_md) {
-        const uatName = planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), "UAT");
-        const uatAbs = join(slicePath, uatName);
+        const uatAbs = targetSliceFile(basePath, milestoneId, sliceId, "UAT", milestoneTitle);
+        mkdirSync(dirname(uatAbs), { recursive: true });
         const uatArtifact = toArtifactPath(uatAbs, basePath);
         await writeAndStore(uatAbs, uatArtifact, slice.full_uat_md, {
             artifact_type: "UAT",
@@ -874,7 +844,7 @@ function detectStaleRendersImpl(basePath) {
         // TODO(flat-phase): roadmap checkbox parsing may not match flat-phase
         // roadmap format, causing false-positive drift loops. Skip during transition.
         /*
-        const roadmapPath = resolveRoadmapProjectionPath(basePath, milestone.id);
+        const roadmapPath = targetMilestoneFile(basePath, milestone.id, "ROADMAP", milestone.title);
         if (existsSync(roadmapPath)) {
           try {
             const parsed = parseProjectionByIdentity(roadmapPath, parseRoadmap) as ReturnType<typeof parseRoadmap>;
@@ -961,34 +931,27 @@ function detectStaleRendersImpl(basePath) {
                     }
                 }
             }
-            // Check missing slice summary/UAT files
+            // Check missing slice summary/UAT files. Use the same target helper as
+            // renderSliceSummary so detection and repair agree on flat-phase vs legacy
+            // output locations.
             const sliceRow = getSlice(milestone.id, slice.id);
             if (sliceRow && sliceRow.status === "complete") {
-                // Use the SAME path construction as renderSliceSummary (planFileName format)
-                // so the detector and repair always agree on the file location.
-                const slicePath = resolveSlicePath(basePath, milestone.id, slice.id);
-                if (slicePath) {
-                    const phaseNum = milestoneIdToPhaseNum(milestone.id);
-                    const planNum = sliceIdToPlanNum(slice.id);
-                    if (sliceRow.full_summary_md) {
-                        const summaryName = planFileName(phaseNum, planNum, "SUMMARY");
-                        const summaryAbsPath = join(slicePath, summaryName);
-                        if (!existsSync(summaryAbsPath)) {
-                            stale.push({
-                                path: summaryAbsPath,
-                                reason: `${slice.id} is complete with summary in DB but SUMMARY.md missing on disk`,
-                            });
-                        }
+                if (sliceRow.full_summary_md) {
+                    const summaryAbsPath = targetSliceFile(basePath, milestone.id, slice.id, "SUMMARY", milestone.title);
+                    if (!existsSync(summaryAbsPath)) {
+                        stale.push({
+                            path: summaryAbsPath,
+                            reason: `${slice.id} is complete with summary in DB but SUMMARY.md missing on disk`,
+                        });
                     }
-                    if (sliceRow.full_uat_md) {
-                        const uatName = planFileName(phaseNum, planNum, "UAT");
-                        const uatAbsPath = join(slicePath, uatName);
-                        if (!existsSync(uatAbsPath)) {
-                            stale.push({
-                                path: uatAbsPath,
-                                reason: `${slice.id} is complete with UAT in DB but UAT.md missing on disk`,
-                            });
-                        }
+                }
+                if (sliceRow.full_uat_md) {
+                    const uatAbsPath = targetSliceFile(basePath, milestone.id, slice.id, "UAT", milestone.title);
+                    if (!existsSync(uatAbsPath)) {
+                        stale.push({
+                            path: uatAbsPath,
+                            reason: `${slice.id} is complete with UAT in DB but UAT.md missing on disk`,
+                        });
                     }
                 }
             }
@@ -1013,12 +976,8 @@ export function roadmapRenderMarksSliceDone(roadmapContent, sliceId) {
     return parseRoadmap(roadmapContent).slices.some((slice) => slice.id === sliceId && slice.done);
 }
 export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanData) {
-    // Flat-phase: replan file lives in the phase dir
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const planNum = sliceIdToPlanNum(sliceId);
-    const absPath = join(slicePath, planFileName(phaseNum, planNum, "REPLAN"));
+    const absPath = targetSliceFile(basePath, milestoneId, sliceId, "REPLAN", getMilestone(milestoneId)?.title);
+    mkdirSync(dirname(absPath), { recursive: true });
     const artifactPath = toArtifactPath(absPath, basePath);
     const lines = [];
     lines.push(`# ${sliceId} Replan`);
@@ -1045,24 +1004,8 @@ export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanD
     return { replanPath: absPath, content };
 }
 export async function renderAssessmentFromDb(basePath, milestoneId, sliceId, assessmentData) {
-    // Flat-phase: the assessment file lives in the phase dir, NOT in a slices/SID/
-    // subdir. resolveSlicePath() detects a slices/SID/ dir unconditionally, so a
-    // stray slices/SID/ created by an earlier planning step would send this write
-    // to a hybrid path (wrong dir, flat filename) that verification cannot find.
-    // Guard with the same legacy-base check relSlicePath() uses so flat-phase
-    // milestones always target the phase dir.
-    const mDir = resolveMilestonePath(basePath, milestoneId);
-    const legacyBase = legacyMilestonesDir(basePath);
-    const isLegacyLayout = mDir
-        ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
-        : false;
-    const fallbackDir = join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    const slicePath = isLegacyLayout
-        ? (resolveSlicePath(basePath, milestoneId, sliceId) ?? fallbackDir)
-        : (mDir ?? fallbackDir);
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const planNum = sliceIdToPlanNum(sliceId);
-    const absPath = join(slicePath, planFileName(phaseNum, planNum, "ASSESSMENT"));
+    const absPath = targetSliceFile(basePath, milestoneId, sliceId, "ASSESSMENT", getMilestone(milestoneId)?.title);
+    mkdirSync(dirname(absPath), { recursive: true });
     const artifactPath = toArtifactPath(absPath, basePath);
     const lines = [];
     lines.push(`# ${sliceId} Assessment`);

package/dist/resources/extensions/gsd/md-importer.js

@@ -4,14 +4,14 @@
 //
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
-import { join, basename } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, transaction, updateMilestoneStatus, updateSliceStatus, _getAdapter, } from './gsd-db.js';
 import { openWorkflowDatabasePath } from './db-workspace.js';
-import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, legacyMilestonesDir, gsdRoot, resolveTaskFiles, resolveMilestonePath, } from './paths.js';
+import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, 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 { parseContextDependsOn, parseSummary } from './files.js';
 import { logWarning } from './workflow-logger.js';
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
 const VALID_MADE_BY = new Set(['human', 'agent', 'collaborative']);
@@ -662,21 +662,63 @@ export function migrateHierarchyToDb(basePath) {
             for (const taskEntry of plan.tasks) {
                 // Per K002: use 'complete' not 'done'
                 let taskStatus = taskEntry.done ? 'complete' : 'pending';
-                // 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) {
-                        const summaryFile = join(tDir, `${taskEntry.id}-SUMMARY.md`);
-                        if (!existsSync(summaryFile)) {
-                            taskStatus = 'pending';
-                            process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} marked done but missing summary — importing as pending\n`);
-                        }
+                // Resolve the per-task SUMMARY.md. Legacy layout keeps summaries under
+                // a tasks/ subdir; flat-phase writes TID-SUMMARY.md directly in the
+                // phase dir (execute-task's gsd_task_complete writes it there). A tasks/
+                // subdir may still exist in flat-phase for auxiliary artifacts — its
+                // mere existence must NOT redirect summary resolution into tasks/ (#1208).
+                const slicePath = resolveSlicePath(basePath, milestoneId, sliceEntry.id);
+                let taskSummaryFile = null;
+                let isLegacySlice = false;
+                // Legacy layout keeps per-task summaries under a tasks/ subdir. Its
+                // presence — not merely "is this a legacy slice" — is what makes a
+                // missing summary a downgrade signal. resolveTasksDir returns null when
+                // no such dir exists, so a legacy slice whose checkbox is the only
+                // completion signal (no tasks/ dir at all) is left complete on import.
+                let legacyTasksDir = null;
+                if (slicePath) {
+                    isLegacySlice = basename(dirname(slicePath)) === 'slices';
+                    legacyTasksDir = isLegacySlice
+                        ? resolveTasksDir(basePath, milestoneId, sliceEntry.id)
+                        : null;
+                    const summaryDir = legacyTasksDir ?? slicePath;
+                    taskSummaryFile = join(summaryDir, `${taskEntry.id}-SUMMARY.md`);
+                }
+                const hasTaskSummary = taskSummaryFile !== null && existsSync(taskSummaryFile);
+                // Pre-migration consistency (legacy tasks/ layout only): if a task is
+                // marked done but its tasks/ dir has no per-task SUMMARY.md, import it
+                // as pending so it gets re-executed rather than silently entering the DB
+                // as complete. A legacy slice with no tasks/ dir (checkbox-only
+                // completion) and flat-phase layout are both left as-is here.
+                if (taskStatus === 'complete' && legacyTasksDir !== null && !hasTaskSummary) {
+                    taskStatus = 'pending';
+                    process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} marked done but missing summary — importing as pending\n`);
+                }
+                // Lost-update guard (#1222): a per-task SUMMARY.md is the durable
+                // completion attestation written by gsd_task_complete. When the plan
+                // checkbox is stale-unchecked but the SUMMARY exists on disk, a
+                // re-import must NOT downgrade the completed task back to pending — that
+                // silent revert is the lost-update that hard-stopped auto-mode after the
+                // first execute-task. The surviving SUMMARY wins over a stale checkbox.
+                // reopen-task removes the SUMMARY, so this never re-completes an
+                // intentionally reopened task.
+                // Flat-phase summaries are phase-scoped (T01-SUMMARY.md); when a milestone
+                // has multiple slices, require the summary parent frontmatter to match so
+                // one slice's completion does not attest a sibling's same-named task.
+                let summaryAttestsCompletion = hasTaskSummary;
+                if (summaryAttestsCompletion && !isLegacySlice && roadmap.slices.length > 1 && taskSummaryFile) {
+                    try {
+                        const summaryContent = readFileSync(taskSummaryFile, 'utf-8');
+                        summaryAttestsCompletion = parseSummary(summaryContent).frontmatter.parent === sliceEntry.id;
+                    }
+                    catch {
+                        summaryAttestsCompletion = false;
                     }
                 }
+                if (taskStatus === 'pending' && summaryAttestsCompletion) {
+                    taskStatus = 'complete';
+                    process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} unchecked in plan but SUMMARY.md present — importing as complete (#1222)\n`);
+                }
                 insertTask({
                     id: taskEntry.id,
                     sliceId: sliceEntry.id,
@@ -687,6 +729,12 @@ export function migrateHierarchyToDb(basePath) {
                         files: taskEntry.files ?? [],
                         verify: taskEntry.verify ?? '',
                     },
+                    // #1222 (metadata half): re-import derives status from the plan/summary
+                    // but has none of the execution prose gsd_task_complete wrote to the DB.
+                    // Preserve the existing row's execution columns and completed_at so a
+                    // re-import cannot blank a completed task's summary metadata or refresh
+                    // its completion timestamp — the DB row is strictly richer than the plan.
+                    preserveCompletionMetadata: true,
                 });
                 counts.tasks++;
             }
@@ -699,14 +747,32 @@ export function migrateHierarchyToDb(basePath) {
             if (!sliceEntry.done) {
                 const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
                 const hasSliceSummary = sliceSummaryPath !== null && existsSync(sliceSummaryPath);
+                const slicePathForTasks = resolveSlicePath(basePath, milestoneId, sliceEntry.id);
+                const isLegacySliceLayout = slicePathForTasks !== null
+                    && basename(dirname(slicePathForTasks)) === 'slices';
+                const taskSummaryDir = slicePathForTasks
+                    ? (isLegacySliceLayout
+                        ? (resolveTasksDir(basePath, milestoneId, sliceEntry.id) ?? slicePathForTasks)
+                        : slicePathForTasks)
+                    : null;
                 const allTasksDone = plan.tasks.length > 0 && plan.tasks.every(t => {
-                    if (!t.done)
-                        return false;
-                    const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
-                    // Flat-phase has no per-task summary files — checkbox state is authoritative.
-                    if (!tDir)
-                        return true;
-                    return existsSync(join(tDir, `${t.id}-SUMMARY.md`));
+                    const taskSummaryFile = taskSummaryDir !== null
+                        ? join(taskSummaryDir, `${t.id}-SUMMARY.md`)
+                        : null;
+                    const hasTaskSummary = taskSummaryFile !== null && existsSync(taskSummaryFile);
+                    let summaryAttestsCompletion = hasTaskSummary;
+                    if (summaryAttestsCompletion && !isLegacySliceLayout && roadmap.slices.length > 1 && taskSummaryFile) {
+                        try {
+                            const summaryContent = readFileSync(taskSummaryFile, 'utf-8');
+                            summaryAttestsCompletion = parseSummary(summaryContent).frontmatter.parent === sliceEntry.id;
+                        }
+                        catch {
+                            summaryAttestsCompletion = false;
+                        }
+                    }
+                    // Match per-task import rules above: SUMMARY attestation wins over a stale
+                    // checkbox (#1222); flat-phase checkboxes are authoritative without summary.
+                    return summaryAttestsCompletion || (t.done && !isLegacySliceLayout);
                 });
                 if (allTasksDone && hasSliceSummary) {
                     if (_getAdapter()) {

package/dist/resources/extensions/gsd/metrics.js

@@ -172,7 +172,7 @@ export function snapshotUnitMetrics(ctx, unitType, unitId, startedAt, model, opt
         ledger.units.push(unit);
     }
     saveLedger(basePath, ledger);
-    if (isUnifiedAuditEnabled()) {
+    if (isUnifiedAuditEnabled(basePath)) {
         emitUokAuditEvent(basePath, buildAuditEnvelope({
             traceId: opts?.traceId ?? `metrics:${unitType}:${unitId}`,
             turnId: opts?.turnId,
@@ -324,7 +324,7 @@ export function snapshotUnitMetricsByScope(scope, ctx, unitType, unitId, started
         scopedLedger.units.push(unit);
     }
     saveLedger(base, scopedLedger);
-    if (isUnifiedAuditEnabled()) {
+    if (isUnifiedAuditEnabled(base)) {
         emitUokAuditEvent(base, buildAuditEnvelope({
             traceId: opts?.traceId ?? `metrics:${unitType}:${unitId}`,
             turnId: opts?.turnId,

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

@@ -56,14 +56,40 @@ function replaceSetPrefix(values, from, to) {
         values.add(`${to}${value.slice(from.length)}`);
     }
 }
+/**
+ * Rewrite one milestone identity across EVERY markdown identity set. The
+ * roadmapless subset is a view of `milestones`, so it must speak the same
+ * aligned vocabulary; otherwise the discussion-phase exclusion below keys off
+ * the stale bare id, fails its `dbScan.milestones.has(...)` membership check,
+ * and decrements the milestone count even though the aligned identity remains
+ * in the set, reporting false drift for a milestone that is actually in sync.
+ * Centralising the set list here keeps every alignment path from silently
+ * missing a set (the defect that regressed the suffixed roadmapless case).
+ */
+function realignMilestonePrefix(markdownScan, from, to) {
+    replaceSetPrefix(markdownScan.milestones, from, to);
+    replaceSetPrefix(markdownScan.slices, from, to);
+    replaceSetPrefix(markdownScan.tasks, from, to);
+    replaceSetPrefix(markdownScan.milestonesWithoutRoadmap, from, to);
+}
 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);
+        realignMilestonePrefix(markdownScan, paddedId, dbId);
+    }
+}
+function bareMilestoneId(id) {
+    const match = id.match(/^(M\d{3})-[a-z0-9]{6}$/);
+    return match?.[1] ?? null;
+}
+function alignBareMarkdownIdsWithSuffixedDb(markdownScan, dbScan) {
+    for (const dbId of dbScan.milestones) {
+        const bareId = bareMilestoneId(dbId);
+        if (!bareId || dbScan.milestones.has(bareId) || !markdownScan.milestones.has(bareId))
+            continue;
+        realignMilestonePrefix(markdownScan, bareId, dbId);
     }
 }
 /**
@@ -148,6 +174,7 @@ export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const dbScan = scanDbHierarchy();
     const beforeDb = dbScan.counts;
     alignNumericMarkdownIdsWithDb(markdownScan, dbScan);
+    alignBareMarkdownIdsWithSuffixedDb(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