gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -52,6 +52,16 @@ async function executeToolInDir(tool: any, params: Record<string, unknown>, dir:
   }
 }
 
+async function executeToolWithContextRoot(tool: any, params: Record<string, unknown>, processDir: string, contextRoot: string) {
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(processDir);
+    return await tool.execute("test-call-id", params, undefined, undefined, { cwd: contextRoot });
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
 // ─── Registration ─────────────────────────────────────────────────────────────
 
 test("registerJournalTools registers gsd_journal_query tool", () => {
@@ -126,6 +136,28 @@ test("gsd_journal_query respects limit parameter", async () => {
   }
 });
 
+test("gsd_journal_query uses context cwd instead of process cwd", async () => {
+  const processBase = makeTmpBase();
+  const contextBase = makeTmpBase();
+  try {
+    emitJournalEvent(processBase, makeEntry({ seq: 0, flowId: "process-flow" }));
+    emitJournalEvent(contextBase, makeEntry({ seq: 0, flowId: "context-flow" }));
+
+    const pi = makeMockPi();
+    registerJournalTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolWithContextRoot(tool, { limit: 5 }, processBase, contextBase);
+    const entries = JSON.parse(result.content[0].text) as JournalEntry[];
+
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].flowId, "context-flow");
+  } finally {
+    cleanup(processBase);
+    cleanup(contextBase);
+  }
+});
+
 // ─── Error Handling ───────────────────────────────────────────────────────────
 
 test("gsd_journal_query handles errors gracefully", async () => {

package/src/resources/extensions/gsd/tests/knowledge.test.ts

@@ -249,6 +249,28 @@ test('loadKnowledgeBlock: reports globalSizeKb above 4KB threshold', () => {
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('loadKnowledgeBlock: caps repeated system prompt knowledge by default with source path', () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-kb-')));
+  const gsdHome = join(tmp, 'home');
+  const cwd = join(tmp, 'project');
+  mkdirSync(join(cwd, '.gsd'), { recursive: true });
+  mkdirSync(join(gsdHome, 'agent'), { recursive: true });
+  writeFileSync(join(cwd, '.gsd', 'KNOWLEDGE.md'), `K001: ${'large project knowledge '.repeat(1200)}`);
+
+  const original = process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+  delete process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+  try {
+    const result = loadKnowledgeBlock(gsdHome, cwd);
+    assert.ok(result.block.includes('Source: `'));
+    assert.ok(result.block.length <= 12_500, `knowledge block ${result.block.length} should stay near default cap`);
+    assert.ok(result.block.includes('[Knowledge Truncated]'));
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+    else process.env.PI_GSD_KNOWLEDGE_MAX_CHARS = original;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 // ─── inlineKnowledgeBudgeted — issue #4719 ─────────────────────────────────
 // Milestone-phase prompts must not inject the full KNOWLEDGE.md. The budgeted
 // helper scopes by milestone-level keywords and caps the injected size.
@@ -315,6 +337,31 @@ test('inlineKnowledgeBudgeted: caps payload below budget for large files', async
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('inlineKnowledgeBudgeted: default budget keeps auto prompt knowledge compact', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const entries = Array.from({ length: 300 }, (_, i) =>
+    `### Entry ${i}: shared topic\n${'default budget filler '.repeat(25)}\n`,
+  ).join('\n');
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), `# Project Knowledge\n\n## Patterns\n\n${entries}`);
+
+  const result = await inlineKnowledgeBudgeted(tmp, ['shared']);
+  assert.ok(result !== null, 'should return content');
+  assert.ok(
+    result!.length <= 12_500,
+    `default payload ${result!.length} chars should stay near the 12k budget`,
+  );
+  assert.match(
+    result!,
+    /\[\.\.\.truncated \d+ chars; rerun with narrower scope if needed\]/,
+    'should include truncation note when default budget is exceeded',
+  );
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
 test('inlineKnowledgeBudgeted: returns null when no KNOWLEDGE.md exists', async () => {
   const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
   const gsdDir = join(tmp, '.gsd');

package/src/resources/extensions/gsd/tests/lazy-pi-tui-import.test.ts

@@ -1,15 +1,53 @@
-// Structural contract: shared/mod.ts must never import @gsd/pi-tui.
-// TUI-dependent exports live in shared/tui.ts instead.
+// GSD2 — Shared barrel import behavior without TUI dependency loading
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-test("shared/mod.ts has no import from @gsd/pi-tui", () => {
-  const src = readFileSync(join(__dirname, "../../shared/mod.ts"), "utf-8");
-  assert.ok(!src.includes("@gsd/pi-tui"), "mod.ts must not import @gsd/pi-tui");
+test("shared/mod.ts imports without resolving @gsd/pi-tui", () => {
+  const tmp = mkdtempSync(join(process.env.TMPDIR ?? "/tmp", "gsd-shared-mod-"));
+  const loaderPath = join(tmp, "block-pi-tui-loader.mjs");
+  writeFileSync(
+    loaderPath,
+    [
+      "export async function resolve(specifier, context, nextResolve) {",
+      "  if (specifier === '@gsd/pi-tui') throw new Error('unexpected @gsd/pi-tui import');",
+      "  return nextResolve(specifier, context);",
+      "}",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  try {
+    const sharedModPath = join(__dirname, "../../shared/mod.ts");
+    const resolveTsPath = join(__dirname, "resolve-ts.mjs");
+    const result = spawnSync(
+      process.execPath,
+      [
+        "--experimental-strip-types",
+        "--import",
+        resolveTsPath,
+        "--experimental-loader",
+        loaderPath,
+        "--input-type=module",
+        "--eval",
+        `await import(${JSON.stringify(sharedModPath)});`,
+      ],
+      { encoding: "utf-8" },
+    );
+
+    assert.equal(
+      result.status,
+      0,
+      `shared/mod.ts should import without @gsd/pi-tui; stderr:\n${result.stderr}`,
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });

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,16 +5,11 @@
 
 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";
 
 import { decideMemoryPressure } from "../auto/workflow-kernel.ts";
+import { completeWorkflowIteration } from "../auto/workflow-iteration-completion.ts";
 import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
-
 describe("memory pressure monitoring (#3331)", () => {
   test("measureMemoryPressure reports pressure above threshold", () => {
     const snapshot = measureMemoryPressure({
@@ -41,10 +36,6 @@ describe("memory pressure monitoring (#3331)", () => {
     assert.equal(snapshot.pressured, true);
   });
 
-  test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
-    assert.match(loopSource, /iteration\s*%\s*MEMORY_CHECK_INTERVAL\s*===\s*0/);
-  });
-
   test("memory pressure triggers graceful stopAuto", () => {
     const decision = decideMemoryPressure({
       pressured: true,
@@ -60,34 +51,29 @@ describe("memory pressure monitoring (#3331)", () => {
 });
 
 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("completeIteration centralizes stuck-state persistence for both loop paths (#4382)", () => {
-    assert.match(loopSource, /const completeIteration = \(\): void =>/);
-    assert.match(loopSource, /completeWorkflowIteration\(/);
-    assert.match(loopSource, /saveStuckState:\s*\(\)\s*=>\s*saveStuckState\(s,\s*loopState\)/);
-    assert.match(loopSource, /completeIteration,/);
-    assert.match(loopSource, /completeIteration\(\);/);
+  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

@@ -33,11 +33,39 @@ import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { WorktreeResolver } from "../worktree-resolver.ts";
+import { WorktreeLifecycle, type WorktreeLifecycleDeps } 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: LegacyTestDeps had three fields Lifecycle does not need
+// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
+// Permit them in test fixtures so existing override patterns keep working —
+// Lifecycle ignores the extras via structural typing.
+type LegacyTestDeps = WorktreeLifecycleDeps & {
+  shouldUseWorktreeIsolation?: () => boolean;
+  syncWorktreeStateBack?: (
+    mainBasePath: string,
+    worktreePath: string,
+    milestoneId: string,
+  ) => { synced: string[] };
+  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
+};
+
+/**
+ * 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 +83,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,
@@ -70,6 +98,7 @@ function makeDeps(
     getAutoWorktreePath: () => null,
     autoCommitCurrentBranch: () => undefined,
     getCurrentBranch: () => "worktree/M001",
+    checkoutBranch: () => undefined,
     autoWorktreeBranch: (mid: string) => `worktree/${mid}`,
     resolveMilestoneFile: () => null, // no roadmap → early return path
     readFileSync: () => "",
@@ -79,6 +108,7 @@ function makeDeps(
     loadEffectiveGSDPreferences: () => ({ preferences: {} }),
     invalidateAllCaches: () => undefined,
     captureIntegrationBranch: () => undefined,
+    worktreeProjection: new WorktreeStateProjection(),
     ...overrides,
   };
 }
@@ -125,7 +155,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(
@@ -156,7 +186,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(
@@ -180,7 +210,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
       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);
+  }
+});