gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/memory-decay-factor.test.ts

@@ -0,0 +1,90 @@
+// gsd-2 / memoryDecayFactor unit tests
+//
+// Pure-function boundary tests for the V28 time-decay scoring helper.
+// The function maps last_hit_at → multiplier in [0.7, 1.0] used by
+// queryMemoriesRanked to down-weight stale memories without fully suppressing
+// them. These tests pin the contract:
+//
+//   - null / invalid / future timestamps → 1.0 (no decay penalty)
+//   - 0 days ago → 1.0
+//   - linear decay between 0 and 90 days
+//   - 90+ days ago → 0.7 floor
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { memoryDecayFactor } from "../memory-store.ts";
+
+const DAY_MS = 86_400_000;
+
+function isoDaysAgo(days: number): string {
+  return new Date(Date.now() - days * DAY_MS).toISOString();
+}
+
+test("memoryDecayFactor: null lastHitAt returns 1.0 (never-hit = no decay)", () => {
+  assert.equal(memoryDecayFactor(null), 1.0);
+});
+
+test("memoryDecayFactor: invalid timestamp string returns 1.0 (defensive)", () => {
+  assert.equal(memoryDecayFactor("not-a-date"), 1.0);
+  assert.equal(memoryDecayFactor(""), 1.0);
+});
+
+test("memoryDecayFactor: future timestamp clamps to daysAgo=0 → 1.0", () => {
+  // Clock skew or manual DB edits can yield future last_hit_at values.
+  // The factor must stay within [0.7, 1.0] regardless.
+  const future = new Date(Date.now() + 30 * DAY_MS).toISOString();
+  const factor = memoryDecayFactor(future);
+  assert.ok(factor <= 1.0, `factor must not exceed 1.0, got ${factor}`);
+  assert.ok(factor >= 0.7, `factor must not fall below 0.7, got ${factor}`);
+  assert.equal(factor, 1.0);
+});
+
+test("memoryDecayFactor: 0 days ago returns 1.0", () => {
+  const factor = memoryDecayFactor(new Date().toISOString());
+  // Tiny clock drift between now-string and Date.now() inside the function;
+  // assert it's effectively 1.0 within float tolerance.
+  assert.ok(Math.abs(factor - 1.0) < 1e-6, `expected ≈1.0, got ${factor}`);
+});
+
+test("memoryDecayFactor: 30 days ago returns ~0.90 (linear midpoint)", () => {
+  // Formula: 1.0 - 0.3 * (30/90) = 1.0 - 0.1 = 0.90
+  const factor = memoryDecayFactor(isoDaysAgo(30));
+  assert.ok(Math.abs(factor - 0.90) < 1e-3, `expected ≈0.90, got ${factor}`);
+});
+
+test("memoryDecayFactor: 60 days ago returns ~0.80", () => {
+  // Formula: 1.0 - 0.3 * (60/90) = 1.0 - 0.2 = 0.80
+  const factor = memoryDecayFactor(isoDaysAgo(60));
+  assert.ok(Math.abs(factor - 0.80) < 1e-3, `expected ≈0.80, got ${factor}`);
+});
+
+test("memoryDecayFactor: 90 days ago returns 0.70 (floor)", () => {
+  const factor = memoryDecayFactor(isoDaysAgo(90));
+  assert.ok(Math.abs(factor - 0.70) < 1e-3, `expected ≈0.70, got ${factor}`);
+});
+
+test("memoryDecayFactor: 180 days ago stays at 0.70 floor", () => {
+  const factor = memoryDecayFactor(isoDaysAgo(180));
+  assert.equal(factor, 0.70);
+});
+
+test("memoryDecayFactor: result always in [0.7, 1.0] for any input", () => {
+  const samples: (string | null)[] = [
+    null,
+    "",
+    "garbage",
+    new Date(0).toISOString(),
+    isoDaysAgo(0),
+    isoDaysAgo(15),
+    isoDaysAgo(45),
+    isoDaysAgo(89),
+    isoDaysAgo(91),
+    isoDaysAgo(365),
+    new Date(Date.now() + 365 * DAY_MS).toISOString(),
+  ];
+  for (const s of samples) {
+    const f = memoryDecayFactor(s);
+    assert.ok(f >= 0.7 && f <= 1.0, `factor out of [0.7, 1.0] for ${s}: ${f}`);
+  }
+});

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -5,65 +5,75 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
+import { decideMemoryPressure } from "../auto/workflow-kernel.ts";
+import { completeWorkflowIteration } from "../auto/workflow-iteration-completion.ts";
+import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
 
 describe("memory pressure monitoring (#3331)", () => {
-  test("checkMemoryPressure function exists", () => {
-    assert.match(loopSource, /function checkMemoryPressure/);
-  });
+  test("measureMemoryPressure reports pressure above threshold", () => {
+    const snapshot = measureMemoryPressure({
+      threshold: 0.5,
+      deps: {
+        memoryUsage: () => ({ heapUsed: 768 * 1024 * 1024 }),
+        heapLimitBytes: () => 1024 * 1024 * 1024,
+      },
+    });
 
-  test("MEMORY_PRESSURE_THRESHOLD constant is defined", () => {
-    assert.match(loopSource, /MEMORY_PRESSURE_THRESHOLD\s*=\s*0\.\d+/);
+    assert.equal(snapshot.pressured, true);
+    assert.equal(snapshot.heapMB, 768);
+    assert.equal(snapshot.limitMB, 1024);
   });
 
-  test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
-    assert.match(loopSource, /iteration\s*%\s*MEMORY_CHECK_INTERVAL\s*===\s*0/);
+  test("measureMemoryPressure defaults to a sub-100-percent threshold", () => {
+    const snapshot = measureMemoryPressure({
+      deps: {
+        memoryUsage: () => ({ heapUsed: 3584 * 1024 * 1024 }),
+        heapLimitBytes: () => 4096 * 1024 * 1024,
+      },
+    });
+
+    assert.equal(snapshot.pressured, true);
   });
 
   test("memory pressure triggers graceful stopAuto", () => {
-    assert.match(loopSource, /mem\.pressured/);
-    assert.match(loopSource, /Stopping gracefully to prevent OOM/);
+    const decision = decideMemoryPressure({
+      pressured: true,
+      heapMB: 3900,
+      limitMB: 4096,
+      pct: 0.95,
+      iteration: 10,
+    });
+
+    assert.equal(decision.action, "stop");
+    assert.match(decision.stopMessage, /Stopping gracefully to prevent OOM/);
   });
 });
 
 describe("stuck detection persistence (#3704)", () => {
-  test("loadStuckState function exists", () => {
-    assert.match(loopSource, /function loadStuckState/);
-  });
-
-  test("saveStuckState function exists", () => {
-    assert.match(loopSource, /function saveStuckState/);
-  });
-
-  // Phase C: API changed from (basePath) to (session) — recentUnits is
-  // now reconstructed from unit_dispatches and stuckRecoveryAttempts
-  // persists in runtime_kv (worker scope).
-  test("loopState initialized from persisted state", () => {
-    assert.match(loopSource, /loadStuckState\(s\)/);
-  });
-
-  test("stuck state saved after each iteration", () => {
-    assert.match(loopSource, /saveStuckState\(s,\s*loopState\)/);
-  });
-
   // Phase C: stuck-state.json file IO deleted; persistence moved to
   // unit_dispatches (recentUnits) + runtime_kv (stuckRecoveryAttempts).
   // The stuck-state-via-db.test.ts suite covers the round-trip.
 
-  test("saveStuckState called in standard dev path as well as custom engine path (#4382)", () => {
-    // Count all call-sites of saveStuckState (excluding the function definition itself).
-    // After the fix, both the custom-engine path and the standard dev path must each
-    // call saveStuckState so stuckRecoveryAttempts survives session restarts.
-    const callMatches = loopSource.match(/saveStuckState\(s,\s*loopState\)/g) ?? [];
-    assert.ok(
-      callMatches.length >= 2,
-      `saveStuckState must be called in both the custom-engine path and the standard dev path ` +
-      `(found ${callMatches.length} call(s) — standard path is missing its call, #4382)`,
-    );
+  test("completeWorkflowIteration saves stuck state while clearing recovery counters (#4382)", () => {
+    const calls: string[] = [];
+    const state = {
+      consecutiveErrors: 2,
+      consecutiveCooldowns: 1,
+      recentErrorMessages: ["boom"],
+    };
+
+    completeWorkflowIteration(state, {
+      emitIterationEnd: () => calls.push("emit"),
+      saveStuckState: () => calls.push("save"),
+      logIterationComplete: () => calls.push("log"),
+    });
+
+    assert.deepEqual(calls, ["emit", "save", "log"]);
+    assert.deepEqual(state, {
+      consecutiveErrors: 0,
+      consecutiveCooldowns: 0,
+      recentErrorMessages: [],
+    });
   });
 });

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

@@ -29,15 +29,49 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { WorktreeResolver } from "../worktree-resolver.ts";
+import {
+  WorktreeLifecycle,
+  type WorktreeLifecycleDeps,
+  type WorktreeLifecycleTestOverrides,
+} from "../worktree-lifecycle.ts";
+import { WorktreeStateProjection } from "../worktree-state-projection.ts";
 import { MergeConflictError } from "../git-service.ts";
-import type { WorktreeResolverDeps } from "../worktree-resolver.ts";
 import type { AutoSession } from "../auto/session.ts";
 
+// Test-local: extras the WorktreeResolver-era fixture passed but Lifecycle
+// does not need (shouldUseWorktreeIsolation, syncWorktreeStateBack,
+// captureIntegrationBranch). Lifecycle ignores them via structural typing.
+// The C1-C4-inlined primitive overrides come from
+// `WorktreeLifecycleTestOverrides`, the test seam exported by the Module.
+type LegacyTestDeps = WorktreeLifecycleDeps & WorktreeLifecycleTestOverrides & {
+  shouldUseWorktreeIsolation?: () => boolean;
+  syncWorktreeStateBack?: (
+    mainBasePath: string,
+    worktreePath: string,
+    milestoneId: string,
+  ) => { synced: string[] };
+  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
+  GitServiceImpl?: new (basePath: string, gitConfig: unknown) => unknown;
+};
+
+/**
+ * Shim factory preserving the legacy WorktreeResolver throw shape for
+ * `mergeAndExit` so the existing assert.throws bodies migrate verbatim.
+ */
+function makeResolver(s: AutoSession, deps: LegacyTestDeps) {
+  const lifecycle = new WorktreeLifecycle(s, deps);
+  return {
+    mergeAndExit: (mid: string, ctx: { notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void }) => {
+      const r = lifecycle.exitMilestone(mid, { merge: true }, ctx);
+      if (!r.ok && r.cause instanceof Error) throw r.cause;
+    },
+  };
+}
+
 // ─── Test-only session double ───────────────────────────────────────────
 // `AutoSession` is a large class but `WorktreeResolver` only reads a few
 // fields from it (basePath, originalBasePath, currentMilestoneId).
@@ -55,8 +89,8 @@ function makeSession(basePath: string): AutoSession {
  * boring-tech approach — no mocking library, just plain objects.
  */
 function makeDeps(
-  overrides: Partial<WorktreeResolverDeps> = {},
-): WorktreeResolverDeps {
+  overrides: Partial<LegacyTestDeps> = {},
+): LegacyTestDeps {
   return {
     isInAutoWorktree: () => true,
     shouldUseWorktreeIsolation: () => true,
@@ -68,8 +102,14 @@ function makeDeps(
     enterAutoWorktree: () => "",
     enterBranchModeForMilestone: () => undefined,
     getAutoWorktreePath: () => null,
-    autoCommitCurrentBranch: () => undefined,
+    autoCommitCurrentBranch: (
+      _basePath: string,
+      _unitType: string,
+      _unitId: string,
+      _taskContext?: unknown,
+    ) => null,
     getCurrentBranch: () => "worktree/M001",
+    checkoutBranch: () => undefined,
     autoWorktreeBranch: (mid: string) => `worktree/${mid}`,
     resolveMilestoneFile: () => null, // no roadmap → early return path
     readFileSync: () => "",
@@ -79,6 +119,9 @@ function makeDeps(
     loadEffectiveGSDPreferences: () => ({ preferences: {} }),
     invalidateAllCaches: () => undefined,
     captureIntegrationBranch: () => undefined,
+    worktreeProjection: new WorktreeStateProjection(),
+    // ADR-016 phase 2 / C4 (#5627): GitServiceImpl constructor → factory.
+    gitServiceFactory: () => ({}) as never,
     ...overrides,
   };
 }
@@ -98,14 +141,36 @@ function makeNotifyCtx(): {
 
 describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", () => {
   let baseDir: string;
+  const savedCwd = process.cwd();
 
   beforeEach(() => {
     baseDir = mkdtempSync(join(tmpdir(), "merge-conflict-stops-loop-"));
     // Fake out a milestone directory so mergeAndExit reaches mergeMilestoneToMain.
     mkdirSync(join(baseDir, ".gsd", "milestones", "M001"), { recursive: true });
+    // ADR-016 phase 2 / C1 (#5624): worktree-lifecycle.ts now calls
+    // node:fs.readFileSync directly (the dep was retired), so the roadmap
+    // file must exist on disk for the test to reach mergeMilestoneToMain.
+    writeFileSync(
+      join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# M001\n",
+    );
+    // ADR-016 phase 2 / C3 (#5626): `getIsolationMode` is also inlined.
+    // Without explicit isolation preferences the mode defaults to "none"
+    // and the merge short-circuits before the test's mocked
+    // `mergeMilestoneToMain` is reached. Write a preferences file so the
+    // standalone routes through worktree-mode merge.
+    writeFileSync(
+      join(baseDir, ".gsd", "preferences.md"),
+      "## Git\n- isolation: worktree\n",
+    );
   });
 
   afterEach(() => {
+    // ADR-016 phase 2 / C2 (#5625): the inlined `mergeMilestoneStandalone`
+    // chdirs into the project root before the merge body runs. Restore
+    // cwd before deleting `baseDir` so the next test's `process.cwd()`
+    // doesn't fail with ENOENT.
+    try { process.chdir(savedCwd); } catch { /* best-effort */ }
     try {
       rmSync(baseDir, { recursive: true, force: true });
     } catch {
@@ -117,7 +182,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
     const conflicted = ["src/feature.ts", "README.md"];
     const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
     const deps = makeDeps({
-      resolveMilestoneFile: (_base, _mid, type) =>
+      resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
       mergeMilestoneToMain: () => {
@@ -125,7 +190,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
       },
     });
 
-    const resolver = new WorktreeResolver(makeSession(baseDir), deps);
+    const resolver = makeResolver(makeSession(baseDir), deps);
     const ctx = makeNotifyCtx();
 
     assert.throws(
@@ -148,7 +213,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
     const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
     class FakePermError extends Error {}
     const deps = makeDeps({
-      resolveMilestoneFile: (_base, _mid, type) =>
+      resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
       mergeMilestoneToMain: () => {
@@ -156,7 +221,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
       },
     });
 
-    const resolver = new WorktreeResolver(makeSession(baseDir), deps);
+    const resolver = makeResolver(makeSession(baseDir), deps);
     const ctx = makeNotifyCtx();
 
     assert.throws(
@@ -174,13 +239,13 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
   test("successful merge does not throw", () => {
     const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
     const deps = makeDeps({
-      resolveMilestoneFile: (_base, _mid, type) =>
+      resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
       mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
     });
 
-    const resolver = new WorktreeResolver(makeSession(baseDir), deps);
+    const resolver = makeResolver(makeSession(baseDir), deps);
     const ctx = makeNotifyCtx();
 
     // Should not throw — the success path.

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

@@ -13,6 +13,9 @@ import { parseRoadmap, parsePlan } from '../parsers-legacy.ts';
 import { parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
 import { invalidateAllCaches } from '../cache.ts';
+import { ensureDbOpen } from '../bootstrap/dynamic-tools.ts';
+import { closeDatabase, getAllMilestones } from '../gsd-db.ts';
+import { importWrittenMigrationToDb } from '../migrate/command.ts';
 import type {
   GSDProject,
   GSDMilestone,
@@ -250,6 +253,51 @@ test('Scenario 1: Incomplete project — write, parse, deriveState', async () =>
     }
 });
 
+test('Scenario 1b: written migration imports into authoritative DB state', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-db-import-'));
+    try {
+      const project = buildIncompleteProject();
+      await writeGSDDirectory(project, base);
+
+      assert.equal(await ensureDbOpen(base), true, 'db import: ensureDbOpen creates authoritative DB');
+
+      invalidateAllCaches();
+      const before = await deriveState(base);
+      assert.equal(before.activeMilestone, null, 'db import: markdown-only migration is invisible before DB import');
+
+      const imported = await importWrittenMigrationToDb(base);
+      assert.deepStrictEqual(imported.hierarchy, { milestones: 1, slices: 2, tasks: 3 }, 'db import: hierarchy counts');
+
+      invalidateAllCaches();
+      const after = await deriveState(base);
+      assert.deepStrictEqual(after.phase, 'executing', 'db import: deriveState sees imported DB hierarchy');
+      assert.deepStrictEqual(after.activeMilestone?.id, 'M001', 'db import: active milestone');
+      assert.deepStrictEqual(after.activeSlice?.id, 'S02', 'db import: active slice');
+      assert.deepStrictEqual(after.activeTask?.id, 'T03', 'db import: active task');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
+});
+
+test('Scenario 1c: DB import verification fails when preview counts do not match', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-db-check-'));
+    try {
+      const project = buildIncompleteProject();
+      await writeGSDDirectory(project, base);
+
+      const preview = generatePreview(project);
+      await assert.rejects(
+        () => importWrittenMigrationToDb(base, { ...preview, totalTasks: preview.totalTasks + 1 }),
+        /migration DB import verification failed: tasks 3\/4/,
+      );
+      assert.deepStrictEqual(getAllMilestones(), [], 'db import: failed verification rolls back hierarchy rewrite');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
+});
+
   // ─── Scenario 2: Fully complete project ────────────────────────────────
 
 test('Scenario 2: Fully complete project — deriveState phase', async () => {

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

@@ -0,0 +1,127 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+
+import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
+import {
+  _getAdapter,
+  closeDatabase,
+  getAllMilestones,
+  getSliceTasks,
+} from "../gsd-db.ts";
+import {
+  autoImportMarkdownHierarchyIfDbMismatch,
+  countMarkdownHierarchy,
+} from "../migration-auto-check.ts";
+import { writeGSDDirectory } from "../migrate/writer.ts";
+import type { GSDProject } from "../migrate/types.ts";
+
+function makeBase(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-migration-auto-check-"));
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function projectFixture(): GSDProject {
+  return {
+    projectContent: "# Legacy Project\n",
+    decisionsContent: "",
+    requirements: [],
+    milestones: [
+      {
+        id: "M001",
+        title: "Legacy Milestone",
+        vision: "Carry forward previous work",
+        successCriteria: ["Existing task is visible"],
+        research: null,
+        boundaryMap: [],
+        slices: [
+          {
+            id: "S01",
+            title: "Legacy Slice",
+            risk: "medium",
+            depends: [],
+            done: false,
+            demo: "Legacy slice demo",
+            goal: "Legacy slice demo",
+            research: null,
+            summary: null,
+            tasks: [
+              {
+                id: "T01",
+                title: "Legacy Task",
+                description: "Task carried from markdown",
+                done: false,
+                estimate: "",
+                files: ["src/index.ts"],
+                mustHaves: [],
+                summary: null,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+test("migration auto-check imports markdown hierarchy when DB is empty", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    assert.deepEqual(countMarkdownHierarchy(base), { milestones: 1, slices: 1, tasks: 1 });
+
+    assert.equal(await ensureDbOpen(base), true);
+    assert.equal(getAllMilestones().length, 0, "fresh authoritative DB starts empty");
+
+    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(result.action, "imported");
+    assert.equal(result.reason, "db-empty");
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
+    assert.equal(getAllMilestones().length, 1);
+    assert.equal(getSliceTasks("M001", "S01").length, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check repairs DB hierarchy count mismatch", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    await autoImportMarkdownHierarchyIfDbMismatch(base);
+
+    _getAdapter()!.prepare("DELETE FROM tasks WHERE milestone_id = ? AND slice_id = ? AND id = ?").run("M001", "S01", "T01");
+    assert.equal(getSliceTasks("M001", "S01").length, 0, "test fixture simulates stale DB task count");
+
+    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(result.action, "imported");
+    assert.equal(result.reason, "count-mismatch");
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 0 });
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
+    assert.equal(getSliceTasks("M001", "S01").length, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check leaves matching DB hierarchy alone", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    await autoImportMarkdownHierarchyIfDbMismatch(base);
+
+    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});