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

package/src/resources/extensions/gsd/guided-flow.ts

@@ -50,7 +50,7 @@ import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.j
 import { nativeAddAll, nativeCommit, nativeHasCommittedHead, nativeIsRepo, nativeInit } from "./native-git-bridge.js";
 import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
-import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js";
+import { getIsolationMode, loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "./uok/plan-v2.js";
@@ -921,7 +921,7 @@ function resolveAvailableModel<T extends { id: string; provider: string }>(
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
  */
-function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string, pi: ExtensionAPI, ctx: ExtensionCommandContext, preparationContext?: string): string {
+function buildDiscussPrompt(nextId: string, preamble: string, basePath: string, pi: ExtensionAPI, ctx: ExtensionCommandContext, preparationContext?: string): string {
   const milestoneRel = `.gsd/milestones/${nextId}`;
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
   const inlinedTemplates = [
@@ -931,7 +931,7 @@ function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string,
     inlineTemplate("roadmap", "Roadmap"),
     inlineTemplate("decisions", "Decisions"),
   ].join("\n\n---\n\n");
-  return loadPrompt("discuss", {
+  return prependLanguageDirective(basePath, loadPrompt("discuss", {
     milestoneId: nextId,
     preamble,
     preparationContext: preparationContext ?? "",
@@ -941,14 +941,26 @@ function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string,
     inlinedTemplates,
     commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): context, requirements, and roadmap`),
     multiMilestoneCommitInstruction: buildDocsCommitInstruction("docs: project plan — N milestones"),
-  });
+  }));
+}
+
+/**
+ * Prepend the configured response-language directive to a dispatched discuss
+ * prompt so the discuss/QA conversation is held in the language set in
+ * PREFERENCES.md (#1210). No-op when no language is configured.
+ */
+function prependLanguageDirective(basePath: string, prompt: string): string {
+  const directive = renderLanguageDirectiveForPrompt(
+    loadEffectiveGSDPreferences(basePath)?.preferences,
+  );
+  return directive ? `${directive}\n\n${prompt}` : prompt;
 }
 
 /**
  * Build the discuss prompt for headless milestone creation.
  * Uses the discuss-headless prompt template with seed context injected.
  */
-function buildHeadlessDiscussPrompt(nextId: string, seedContext: string, _basePath: string): string {
+function buildHeadlessDiscussPrompt(nextId: string, seedContext: string, basePath: string): string {
   const milestoneRel = `.gsd/milestones/${nextId}`;
   const inlinedTemplates = [
     inlineTemplate("project", "Project"),
@@ -957,7 +969,7 @@ function buildHeadlessDiscussPrompt(nextId: string, seedContext: string, _basePa
     inlineTemplate("roadmap", "Roadmap"),
     inlineTemplate("decisions", "Decisions"),
   ].join("\n\n---\n\n");
-  return loadPrompt("discuss-headless", {
+  return prependLanguageDirective(basePath, loadPrompt("discuss-headless", {
     milestoneId: nextId,
     seedContext,
     contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
@@ -965,7 +977,7 @@ function buildHeadlessDiscussPrompt(nextId: string, seedContext: string, _basePa
     inlinedTemplates,
     commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): context, requirements, and roadmap`),
     multiMilestoneCommitInstruction: buildDocsCommitInstruction("docs: project plan — N milestones"),
-  });
+  }));
 }
 
 /**

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

@@ -142,7 +142,7 @@ export function emitJournalEvent(basePath: string, entry: JournalEntry): void {
     // Silent failure — journal must never break auto-mode
   }
 
-  if (!isUnifiedAuditEnabled()) return;
+  if (!isUnifiedAuditEnabled(basePath)) return;
   try {
     const causedBy = entry.causedBy
       ? `${entry.causedBy.flowId}:${entry.causedBy.seq}`

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

@@ -38,9 +38,10 @@ import {
   resolveSlicePath,
   resolveTaskFile,
   resolveTasksDir,
+  targetMilestoneFile,
+  targetSliceFile,
   gsdProjectionRoot,
   gsdRoot,
-  buildMilestoneFileName,
   buildTaskFileName,
   buildSliceFileName,
 } from "./paths.js";
@@ -52,9 +53,6 @@ import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "./com
 import type { RiskLevel } from "./types.js";
 import {
   phaseDirName,
-  planFileName,
-  milestoneIdToPhaseNum,
-  sliceIdToPlanNum,
   derivePhaseSlug,
 } from "./layout-policy.js";
 
@@ -176,23 +174,6 @@ function sanitizeInlineRoadmapText(value: string | null | undefined): string {
     .trim();
 }
 
-function resolveRoadmapProjectionPath(basePath: string, milestoneId: string): string {
-  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: string, milestoneId: string): boolean {
   const existing = resolveMilestonePath(basePath, milestoneId);
   const legacyBase = legacyMilestonesDir(basePath);
@@ -600,7 +581,7 @@ export async function renderRoadmapFromDb(
       "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);
@@ -614,7 +595,7 @@ export async function renderRoadmapFromDb(
     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);
 
@@ -655,25 +636,20 @@ export async function renderMilestoneArtifactsFromDb(
   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,
@@ -824,22 +800,12 @@ export async function renderSliceSummary(
     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, {
@@ -850,10 +816,9 @@ export async function renderSliceSummary(
     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, {
@@ -1080,7 +1045,7 @@ function detectStaleRendersImpl(basePath: string): StaleEntry[] {
     // 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>;
@@ -1172,36 +1137,28 @@ function detectStaleRendersImpl(basePath: string): StaleEntry[] {
         }
       }
 
-      // 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`,
+            });
           }
         }
       }
@@ -1257,12 +1214,14 @@ export async function renderReplanFromDb(
   sliceId: string,
   replanData: ReplanData,
 ): Promise<{ replanPath: string; content: string }> {
-  // 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: string[] = [];
@@ -1299,24 +1258,14 @@ export async function renderAssessmentFromDb(
   sliceId: string,
   assessmentData: AssessmentData,
 ): Promise<{ assessmentPath: string; content: string }> {
-  // 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: string[] = [];

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, basename } from 'node:path';
+import { join, relative, basename, dirname } from 'node:path';
 import type { Decision, Requirement } from './types.js';
 import {
   upsertDecision,
@@ -24,6 +24,7 @@ import {
   resolveGsdRootFile,
   resolveMilestoneFile,
   resolveSliceFile,
+  resolveSlicePath,
   resolveTasksDir,
   legacyMilestonesDir,
   gsdRoot,
@@ -33,7 +34,7 @@ import {
 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 ───────────────────────────────────────────────────
@@ -816,23 +817,68 @@ export function migrateHierarchyToDb(basePath: string): {
         // Per K002: use 'complete' not 'done'
         let taskStatus: string = 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: string | null = 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: string | null = 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,
@@ -844,6 +890,12 @@ export function migrateHierarchyToDb(basePath: string): {
             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++;
       }
@@ -857,12 +909,31 @@ export function migrateHierarchyToDb(basePath: string): {
       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/src/resources/extensions/gsd/metrics.ts

@@ -265,7 +265,7 @@ export function snapshotUnitMetrics(
   }
   saveLedger(basePath, ledger);
 
-  if (isUnifiedAuditEnabled()) {
+  if (isUnifiedAuditEnabled(basePath)) {
     emitUokAuditEvent(
       basePath,
       buildAuditEnvelope({
@@ -458,7 +458,7 @@ export function snapshotUnitMetricsByScope(
   }
   saveLedger(base, scopedLedger);
 
-  if (isUnifiedAuditEnabled()) {
+  if (isUnifiedAuditEnabled(base)) {
     emitUokAuditEvent(
       base,
       buildAuditEnvelope({

package/src/resources/extensions/gsd/migration-auto-check.ts

@@ -102,13 +102,41 @@ function replaceSetPrefix(values: Set<string>, from: string, to: string): void {
   }
 }
 
+/**
+ * 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: HierarchyScan, from: string, to: string): void {
+  replaceSetPrefix(markdownScan.milestones, from, to);
+  replaceSetPrefix(markdownScan.slices, from, to);
+  replaceSetPrefix(markdownScan.tasks, from, to);
+  replaceSetPrefix(markdownScan.milestonesWithoutRoadmap, from, to);
+}
+
 function alignNumericMarkdownIdsWithDb(markdownScan: HierarchyScan, dbScan: HierarchyScan): void {
   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: string): string | null {
+  const match = id.match(/^(M\d{3})-[a-z0-9]{6}$/);
+  return match?.[1] ?? null;
+}
+
+function alignBareMarkdownIdsWithSuffixedDb(markdownScan: HierarchyScan, dbScan: HierarchyScan): void {
+  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);
   }
 }
 
@@ -208,6 +236,7 @@ export async function checkMarkdownHierarchyAgainstDb(
   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