@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -90,6 +90,8 @@ import { clearPathCache } from "../../paths.ts";
 // Fixture Helpers
 // ═══════════════════════════════════════════════════════════════════════════
 
+const UAT_VERDICT_GATE_RULE_NAME = "uat-verdict-gate (non-PASS observed; closeout enforces)";
+
 function makeTempDir(): string {
   return mkdtempSync(join(tmpdir(), "gsd-edge-cases-"));
 }
@@ -280,7 +282,7 @@ function buildDispatchCtx(
 
 function getUatVerdictGate(): import("../../auto-dispatch.ts").DispatchRule {
   const rule = DISPATCH_RULES.find(
-    r => r.name === "uat-verdict-gate (non-PASS blocks progression)",
+    r => r.name === UAT_VERDICT_GATE_RULE_NAME,
   );
   assert.ok(rule, "uat-verdict-gate rule should be registered");
   return rule;
@@ -867,7 +869,7 @@ describe("dispatch failure modes", () => {
     // Verify critical ordering constraints
     const summarizeIdx = ruleNames.indexOf("summarizing → complete-slice");
     const runUatIdx = ruleNames.indexOf("run-uat (post-completion)");
-    const uatGateIdx = ruleNames.indexOf("uat-verdict-gate (non-PASS blocks progression)");
+    const uatGateIdx = ruleNames.indexOf(UAT_VERDICT_GATE_RULE_NAME);
     const executeIdx = ruleNames.indexOf("executing → execute-task");
 
     // summarizing should come before execute-task

package/src/resources/extensions/gsd/tests/integration/workspace-collapse-integration.test.ts

@@ -25,10 +25,8 @@ import {
   markDepthVerified,
   clearDiscussionFlowState,
 } from "../../bootstrap/write-gate.ts";
-import {
-  teardownAutoWorktree,
-  _resetAutoWorktreeOriginalBaseForTests,
-} from "../../auto-worktree.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../../auto-worktree-teardown.ts";
 import {
   openDatabaseByWorkspace,
   closeAllDatabases,

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -40,6 +40,7 @@ import { readUnitRuntimeRecord } from "../unit-runtime.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
   closeDatabase,
+  getTask,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -445,7 +446,7 @@ test("runDispatch retries when complete-milestone summary exists on disk and stu
   assert.equal(stopCalls, 0, "artifact-based recovery should not hard-stop the loop");
 });
 
-test("runDispatch pauses when execute-task artifacts exist but DB status is still open", async (t) => {
+test("runDispatch promotes execute-task DB status when artifacts exist but DB status is still open (#1204)", async (t) => {
   const capture = createEventCapture();
   let pauseCalls = 0;
   let stopCalls = 0;
@@ -522,16 +523,16 @@ test("runDispatch pauses when execute-task artifacts exist but DB status is stil
 
   const result = await runDispatch(ic, preData, loopState);
 
-  assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
-  assert.equal(pauseCalls, 1, "execute-task disk/db mismatch should pause auto-mode");
-  assert.equal(stopCalls, 0, "execute-task disk/db mismatch should not hard-stop the loop");
-  assert.equal(invalidateCalls, 0, "mismatch should not clear caches and continue toward redispatch");
-  assert.equal(loopState.recentUnits.length, 3, "mismatch should keep the stuck window intact");
-  assert.equal(loopState.stuckRecoveryAttempts, 1, "mismatch should not reset the recovery counter");
+  assert.equal(result.action, "continue");
+  assert.equal(pauseCalls, 0, "disk-verified promotion should not pause auto-mode");
+  assert.equal(stopCalls, 0, "disk-verified promotion should not hard-stop the loop");
+  assert.equal(invalidateCalls, 1, "successful promotion should invalidate caches before retrying");
+  assert.equal(loopState.recentUnits.length, 0, "successful promotion should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 1 recovery increments the attempt counter");
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete", "the open DB task should be promoted to complete");
 });
 
-test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB status is still open", async (t) => {
+test("runDispatch promotes execute-task DB status at Level 2 when artifacts exist but DB status is still open (#1204)", async (t) => {
   const capture = createEventCapture();
   let pauseCalls = 0;
   let stopCalls = 0;
@@ -601,13 +602,13 @@ test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB sta
 
   const result = await runDispatch(ic, preData, loopState);
 
-  assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
-  assert.equal(pauseCalls, 1, "Level 2 execute-task disk/db mismatch should pause auto-mode");
-  assert.equal(stopCalls, 0, "Level 2 execute-task disk/db mismatch should not hard-stop the loop");
+  assert.equal(result.action, "continue");
+  assert.equal(pauseCalls, 0, "Level 2 disk-verified promotion should not pause auto-mode");
+  assert.equal(stopCalls, 0, "Level 2 disk-verified promotion should not hard-stop the loop");
   assert.equal(invalidateCalls, 1, "Level 2 should invalidate caches before the final artifact recheck");
-  assert.equal(loopState.recentUnits.length, 3, "Level 2 mismatch should keep the stuck window intact");
-  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 2 mismatch should not reset the recovery counter");
+  assert.equal(loopState.recentUnits.length, 0, "Level 2 successful promotion should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 2 does not reset the recovery counter");
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete", "the open DB task should be promoted to complete");
 });
 
 test("runDispatch clears execute-task stuck state when artifacts and DB status are complete", async (t) => {

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

@@ -22,6 +22,8 @@ import {
   getMilestoneSlices,
   getSliceTasks,
   updateSliceStatus,
+  insertGateRow,
+  saveGateResult,
   _getAdapter,
 } from '../gsd-db.ts';
 import {
@@ -44,6 +46,7 @@ import {
   parseSummary,
   parseTaskPlanFile,
   clearParseCache,
+  extractSection,
 } from '../files.ts';
 import { clearPathCache, _clearGsdRootCache } from '../paths.ts';
 import { invalidateStateCache } from '../state.ts';
@@ -645,6 +648,125 @@ test('── markdown-renderer: slice plan summarizes task descriptions without
   }
 });
 
+test('── markdown-renderer: renderPlanFromDb marks flagged slice gates ──', async () => {
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  clearAllCaches();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    scaffoldDirs(tmpDir, 'M001', ['S01']);
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Risky slice',
+      status: 'pending',
+      demo: 'Reviewers can see flagged gates.',
+      planning: {
+        goal: 'Persist gate concern state.',
+        successCriteria: '- Flagged gates stay visible',
+      },
+    });
+    insertTask({
+      id: 'T01',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Render gate state',
+      status: 'pending',
+    });
+    insertGateRow({ milestoneId: 'M001', sliceId: 'S01', gateId: 'Q3', scope: 'slice' });
+    insertGateRow({ milestoneId: 'M001', sliceId: 'S01', gateId: 'Q4', scope: 'slice' });
+
+    const findings = '- Shared gate findings.';
+    saveGateResult({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      gateId: 'Q3',
+      verdict: 'flag',
+      rationale: 'Concern recorded.',
+      findings,
+    });
+    saveGateResult({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      gateId: 'Q4',
+      verdict: 'pass',
+      rationale: 'No concern.',
+      findings,
+    });
+
+    const rendered = await renderPlanFromDb(tmpDir, 'M001', 'S01');
+    const threatSurface = extractSection(rendered.content, 'Threat Surface');
+    const requirementImpact = extractSection(rendered.content, 'Requirement Impact');
+
+    assert.ok(threatSurface?.includes('> **Warning:** Verdict: flag - concerns recorded below'));
+    assert.ok(threatSurface?.includes(findings));
+    assert.ok(!requirementImpact?.includes('Verdict: flag'), 'passing gate should not render a flag warning');
+    assert.ok(requirementImpact?.includes(findings), 'passing gate still renders findings');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+});
+
+test('── markdown-renderer: renderTaskPlanFromDb marks flagged task gates ──', async () => {
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  clearAllCaches();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    scaffoldDirs(tmpDir, 'M001', ['S01']);
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'pending' });
+    insertTask({
+      id: 'T01',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Task gate render',
+      status: 'pending',
+      planning: {
+        description: 'Render task quality gates.',
+      },
+    });
+    insertGateRow({ milestoneId: 'M001', sliceId: 'S01', gateId: 'Q5', scope: 'task', taskId: 'T01' });
+    insertGateRow({ milestoneId: 'M001', sliceId: 'S01', gateId: 'Q6', scope: 'task', taskId: 'T01' });
+
+    const findings = '- Same task findings.';
+    saveGateResult({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      taskId: 'T01',
+      gateId: 'Q5',
+      verdict: 'flag',
+      rationale: 'Concern recorded.',
+      findings,
+    });
+    saveGateResult({
+      milestoneId: 'M001',
+      sliceId: 'S01',
+      taskId: 'T01',
+      gateId: 'Q6',
+      verdict: 'pass',
+      rationale: 'No concern.',
+      findings,
+    });
+
+    const rendered = await renderTaskPlanFromDb(tmpDir, 'M001', 'S01', 'T01');
+    const failureModes = extractSection(rendered.content, 'Failure Modes');
+    const loadProfile = extractSection(rendered.content, 'Load Profile');
+
+    assert.ok(failureModes?.includes('> **Warning:** Verdict: flag - concerns recorded below'));
+    assert.ok(failureModes?.includes(findings));
+    assert.ok(!loadProfile?.includes('Verdict: flag'), 'passing task gate should not render a flag warning');
+    assert.ok(loadProfile?.includes(findings), 'passing task gate still renders findings');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+});
+
 test('── markdown-renderer: renderTaskPlanFromDb throws for missing task ──', async () => {
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');

package/src/resources/extensions/gsd/tests/merge-closeout-consistency-gate.test.ts

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { checkCloseoutConsistencyGate } from "../closeout-consistency-gate.ts";
 import {
   closeDatabase,

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -95,7 +95,7 @@ function makeDeps(
     isInAutoWorktree: () => true,
     shouldUseWorktreeIsolation: () => true,
     getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     syncWorktreeStateBack: () => ({ synced: [] }),
     teardownAutoWorktree: () => undefined,
     createAutoWorktree: () => "",
@@ -185,7 +185,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
       resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
-      mergeMilestoneToMain: () => {
+      mergeMilestone: () => {
         throw new MergeConflictError(conflicted, "squash", "worktree/M001", "main");
       },
     });
@@ -216,7 +216,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
       resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
-      mergeMilestoneToMain: () => {
+      mergeMilestone: () => {
         throw new FakePermError("EACCES: permission denied");
       },
     });
@@ -242,7 +242,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
       resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
-      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+      mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     });
 
     const resolver = makeResolver(makeSession(baseDir), deps);

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { delimiter, join } from "node:path";
 import { execFileSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { closeDatabase, insertAssessment, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
 import { _clearGsdRootCache } from "../paths.ts";

package/src/resources/extensions/gsd/tests/merge-self-branch-guard.test.ts

@@ -19,7 +19,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/migrate-external-worktree.test.ts

@@ -16,6 +16,7 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { migrateToExternalState, recoverFailedMigration } from "../migrate-external.ts";
+import { externalGsdRoot } from "../repo-identity.ts";
 
 function run(command: string, cwd: string): string {
   return execSync(command, {
@@ -119,6 +120,121 @@ describe("migrate-external worktree guard (#2970)", () => {
   });
 });
 
+describe("migrateToExternalState rename fallback (#1179)", () => {
+  test("falls back to copy/delete when rename fails with EACCES", () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-eacces-")));
+    const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-eacces-")));
+    const previousStateDir = process.env.GSD_STATE_DIR;
+    const previousProjectId = process.env.GSD_PROJECT_ID;
+    const originalRenameSync = fs.renameSync;
+    const localGsd = join(base, ".gsd");
+    const migratingPath = join(base, ".gsd.migrating");
+    let renameAttempts = 0;
+
+    process.env.GSD_STATE_DIR = stateDir;
+    process.env.GSD_PROJECT_ID = "rename-eacces";
+
+    try {
+      run("git init -b main", base);
+      mkdirSync(localGsd, { recursive: true });
+      writeFileSync(join(localGsd, "PREFERENCES.md"), "# prefs\n", "utf-8");
+
+      fs.renameSync = ((src, dst) => {
+        if (String(src) === localGsd && String(dst) === migratingPath) {
+          renameAttempts += 1;
+          const error = new Error("simulated WSL/DrvFs rename lock") as NodeJS.ErrnoException;
+          error.code = "EACCES";
+          throw error;
+        }
+        return originalRenameSync(src, dst);
+      }) as typeof fs.renameSync;
+      syncBuiltinESMExports();
+
+      const result = migrateToExternalState(base);
+
+      assert.equal(result.migrated, true, "EACCES rename failure should use copy/delete fallback");
+      assert.equal(result.error, undefined);
+      assert.equal(renameAttempts, 1, "should exercise the EACCES rename fallback once");
+      assert.equal(readFileSync(join(stateDir, "projects", "rename-eacces", "PREFERENCES.md"), "utf-8"), "# prefs\n");
+      assert.equal(readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8"), "# prefs\n");
+      assert.ok(!existsSync(migratingPath), "backup staging dir must be removed after successful migration");
+    } finally {
+      fs.renameSync = originalRenameSync;
+      syncBuiltinESMExports();
+      if (previousStateDir === undefined) {
+        delete process.env.GSD_STATE_DIR;
+      } else {
+        process.env.GSD_STATE_DIR = previousStateDir;
+      }
+      if (previousProjectId === undefined) {
+        delete process.env.GSD_PROJECT_ID;
+      } else {
+        process.env.GSD_PROJECT_ID = previousProjectId;
+      }
+      rmSync(base, { recursive: true, force: true });
+      rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("migrateToExternalState already-migrated external state guard (#1178)", () => {
+  test("skips migration when external state already exists for a real local .gsd directory", () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-already-external-")));
+    const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-already-external-")));
+    const previousStateDir = process.env.GSD_STATE_DIR;
+    const previousProjectId = process.env.GSD_PROJECT_ID;
+    process.env.GSD_STATE_DIR = stateDir;
+
+    try {
+      run("git init -b main", base);
+      run('git config user.name "Test"', base);
+      run('git config user.email "test@example.com"', base);
+      writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+      run("git add README.md", base);
+      run('git commit -m "init"', base);
+
+      const externalPath = externalGsdRoot(base);
+      const identity = externalPath.split(/[\\/]/).pop();
+      assert.ok(identity, "external state path must include an identity segment");
+      mkdirSync(externalPath, { recursive: true });
+      writeFileSync(join(base, ".gsd-id"), `${identity}\n`, "utf-8");
+      writeFileSync(join(externalPath, "gsd.db"), "newer external state\n", "utf-8");
+
+      mkdirSync(join(base, ".gsd"), { recursive: true });
+      writeFileSync(join(base, ".gsd", "gsd.db"), "stale local state\n", "utf-8");
+
+      const result = migrateToExternalState(base);
+
+      assert.equal(result.migrated, false, "already-migrated project must not re-run migration");
+      assert.match(result.error ?? "", /external state already exists/i);
+      assert.equal(
+        readFileSync(join(externalPath, "gsd.db"), "utf-8"),
+        "newer external state\n",
+        "newer external gsd.db must not be overwritten by stale local state",
+      );
+      assert.equal(
+        readFileSync(join(base, ".gsd", "gsd.db"), "utf-8"),
+        "stale local state\n",
+        "local real .gsd directory should be left for explicit recovery",
+      );
+      assert.ok(!existsSync(join(base, ".gsd.migrating")), "migration staging dir must not be created");
+    } finally {
+      if (previousStateDir === undefined) {
+        delete process.env.GSD_STATE_DIR;
+      } else {
+        process.env.GSD_STATE_DIR = previousStateDir;
+      }
+      if (previousProjectId === undefined) {
+        delete process.env.GSD_PROJECT_ID;
+      } else {
+        process.env.GSD_PROJECT_ID = previousProjectId;
+      }
+      rmSync(base, { recursive: true, force: true });
+      rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("migrateToExternalState copy failure rollback (#1047)", () => {
   test("restores .gsd when a source entry fails to copy", () => {
     const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-copy-fail-")));

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

@@ -250,6 +250,73 @@ test("migration auto-check canonicalizes a legacy descriptor milestone dir (no f
   }
 });
 
+test("migration auto-check recognizes suffixed flat-phase projection directories", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+
+    insertMilestone({
+      id: "M001-re4q3k",
+      title: "Clean GSD Continuation Readiness",
+      status: "complete",
+      planning: { vision: "Keep continuation state readable." },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001-re4q3k",
+      title: "Readiness slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "Readable continuation state.",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001-re4q3k",
+      title: "Readiness task",
+      status: "complete",
+    });
+    insertMilestone({
+      id: "M002-a1rwmq",
+      title: "Support Command Policy Hardening",
+      status: "complete",
+      planning: { vision: "Harden support command policy." },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M002-a1rwmq",
+      title: "Policy slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "Policy is hardened.",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M002-a1rwmq",
+      title: "Policy task",
+      status: "complete",
+    });
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected flat-phase markdown projections to render");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 2, slices: 2, tasks: 2 });
+    assert.deepEqual(result.beforeDb, { milestones: 2, slices: 2, tasks: 2 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("migration auto-check refreshes a stale open DB handle before comparing", async () => {
   const base = makeBase();
   try {
@@ -372,6 +439,30 @@ test("migration auto-check still compares a roadmapless milestone that HAS a DB
   }
 });
 
+test("migration auto-check aligns a roadmapless milestone dir to its suffixed DB row (no false drift)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    // Team-mode suffixed milestone whose markdown dir has no ROADMAP yet (e.g. a
+    // freshly handed-off / zero-slice milestone). Markdown discovers the bare
+    // "M001"; the DB stores the authoritative suffixed "M001-re4q3k". The
+    // bare-to-suffixed alignment must rewrite EVERY markdown set, including the
+    // roadmapless subset, so the discussion-phase exclusion sees the DB row and
+    // does not decrement the milestone count into false drift.
+    insertMilestone({ id: "M001-re4q3k", title: "Suffixed milestone", status: "queued" });
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 0, tasks: 0 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 0, tasks: 0 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra rows", async () => {
   const base = makeBase();
   try {