gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/src/resources/extensions/gsd/tests/worktree-db-respawn-truncation.test.ts

@@ -0,0 +1,140 @@
+/**
+ * worktree-db-respawn-truncation.test.ts — Regression test for #2815.
+ *
+ * Verifies that syncProjectRootToWorktree does NOT delete a non-empty
+ * worktree gsd.db. On worker respawn, gsd-migrate populates the DB
+ * (~1.7MB) before the auto-loop calls syncProjectRootToWorktree. The
+ * sync step must preserve the freshly-migrated DB to avoid truncating
+ * it to 0 bytes and causing "no such table: slices" failures.
+ *
+ * Covers:
+ *   - Non-empty worktree gsd.db preserved after sync (#2815)
+ *   - Empty (0-byte) worktree gsd.db still deleted (#853 preserved)
+ *   - WAL/SHM sidecar files cleaned up when empty DB is deleted
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { syncProjectRootToWorktree } from '../auto-worktree.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+
+function createBase(name: string): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-wt-respawn-${name}-`));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+describe('worktree-db-respawn-truncation (#2815)', async () => {
+
+  // ─── 1. Non-empty worktree gsd.db preserved after sync ───────────────
+  console.log('\n=== 1. non-empty worktree gsd.db preserved after sync (#2815) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Set up milestone artifacts in main project root
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Simulate a freshly-migrated worktree DB (non-empty, like after gsd-migrate)
+      // Real DBs are ~1.7MB; we use a smaller payload to prove the size check works
+      const fakeDbContent = Buffer.alloc(4096, 0x42); // 4KB non-empty DB
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), fakeDbContent);
+
+      const sizeBefore = statSync(join(wtBase, '.gsd', 'gsd.db')).size;
+      assert.ok(sizeBefore > 0, 'gsd.db is non-empty before sync');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      // The non-empty DB must survive the sync
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'gsd.db')),
+        '#2815: non-empty gsd.db must not be deleted by sync',
+      );
+      const sizeAfter = statSync(join(wtBase, '.gsd', 'gsd.db')).size;
+      assert.equal(
+        sizeAfter,
+        sizeBefore,
+        '#2815: gsd.db size must be unchanged after sync',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 2. Empty (0-byte) worktree gsd.db still deleted ─────────────────
+  console.log('\n=== 2. empty (0-byte) worktree gsd.db still deleted (#853) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Create an empty (0-byte) gsd.db — this is stale/corrupt and should be deleted
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), '');
+      assert.ok(existsSync(join(wtBase, '.gsd', 'gsd.db')), 'empty gsd.db exists before sync');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      assert.ok(
+        !existsSync(join(wtBase, '.gsd', 'gsd.db')),
+        '#853: empty gsd.db must still be deleted after sync',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 3. Milestone artifacts still synced when DB is preserved ────────
+  console.log('\n=== 3. milestone artifacts still synced even when DB preserved ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
+      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# Plan');
+
+      // Non-empty DB in worktree
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), 'populated-db-data');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      // Artifacts must still be synced
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')),
+        'milestone artifacts synced even with preserved DB',
+      );
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md')),
+        'slice artifacts synced even with preserved DB',
+      );
+      // DB must still exist
+      assert.ok(
+        existsSync(join(wtBase, '.gsd', 'gsd.db')),
+        '#2815: DB preserved alongside artifact sync',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+});

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -0,0 +1,175 @@
+/**
+ * worktree-db-same-file.test.ts — Regression test for #2823.
+ *
+ * Verifies that reconcileWorktreeDb() does not ATTACH a WAL-mode DB file
+ * to itself when the worktree DB path resolves to the same physical file
+ * as the main DB path (shared-WAL / symlink layout).
+ *
+ * Also verifies that the auto-loop classifies "database disk image is
+ * malformed" as an infrastructure error to prevent wasting retries.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  reconcileWorktreeDb,
+  insertDecision,
+} from "../gsd-db.ts";
+import { isInfrastructureError } from "../auto/infra-errors.ts";
+
+// ─── Fix 1 & 2: reconcileWorktreeDb same-file guard ─────────────────
+
+describe("#2823: reconcileWorktreeDb same-file guard", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "gsd-2823-"));
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("returns zero result when both paths resolve to the same file", () => {
+    const mainGsd = join(tmpDir, "main", ".gsd");
+    mkdirSync(mainGsd, { recursive: true });
+    const mainDbPath = join(mainGsd, "gsd.db");
+
+    // Create a real DB at mainDbPath
+    openDatabase(mainDbPath);
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Test decision",
+      choice: "Test choice",
+      rationale: "Test rationale",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    // Create a worktree path that resolves to the same file via symlink
+    const wtGsd = join(tmpDir, "worktree", ".gsd");
+    mkdirSync(join(tmpDir, "worktree"), { recursive: true });
+    symlinkSync(mainGsd, wtGsd, "junction");
+    const worktreeDbPath = join(wtGsd, "gsd.db");
+
+    // Both paths exist and resolve to the same physical file
+    assert.ok(existsSync(mainDbPath), "main DB exists");
+    assert.ok(existsSync(worktreeDbPath), "worktree DB path exists (via symlink)");
+
+    // This should NOT attempt ATTACH — should return zero result
+    const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+
+    assert.equal(result.decisions, 0, "no decisions reconciled");
+    assert.equal(result.requirements, 0, "no requirements reconciled");
+    assert.equal(result.artifacts, 0, "no artifacts reconciled");
+    assert.equal(result.conflicts.length, 0, "no conflicts");
+  });
+
+  test("returns zero result when both paths are identical strings", () => {
+    const mainGsd = join(tmpDir, "project", ".gsd");
+    mkdirSync(mainGsd, { recursive: true });
+    const dbPath = join(mainGsd, "gsd.db");
+
+    openDatabase(dbPath);
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Test",
+      choice: "Test",
+      rationale: "Test",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    // Same exact path — should bail immediately
+    const result = reconcileWorktreeDb(dbPath, dbPath);
+
+    assert.equal(result.decisions, 0);
+    assert.equal(result.conflicts.length, 0);
+  });
+
+  test("still reconciles when paths are genuinely different files", () => {
+    // Main DB
+    const mainGsd = join(tmpDir, "main", ".gsd");
+    mkdirSync(mainGsd, { recursive: true });
+    const mainDbPath = join(mainGsd, "gsd.db");
+
+    openDatabase(mainDbPath);
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Main decision",
+      choice: "Main choice",
+      rationale: "Main rationale",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    closeDatabase();
+
+    // Create a separate worktree DB with different data
+    const wtGsd = join(tmpDir, "worktree", ".gsd");
+    mkdirSync(wtGsd, { recursive: true });
+    const worktreeDbPath = join(wtGsd, "gsd.db");
+
+    openDatabase(worktreeDbPath);
+    insertDecision({
+      id: "D002",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "WT decision",
+      choice: "WT choice",
+      rationale: "WT rationale",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    closeDatabase();
+
+    // Re-open main and reconcile — should work normally
+    openDatabase(mainDbPath);
+    const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+
+    assert.ok(
+      result.decisions > 0,
+      "should reconcile decisions from a genuinely different DB",
+    );
+  });
+});
+
+// ─── Fix 3: infrastructure error classification ─────────────────────
+
+describe("#2823: malformed DB classified as infrastructure error", () => {
+  test("database disk image is malformed is detected as infra error", () => {
+    const err = new Error("database disk image is malformed");
+    const code = isInfrastructureError(err);
+    assert.ok(code !== null, "should be classified as infrastructure error");
+    assert.equal(code, "SQLITE_CORRUPT");
+  });
+
+  test("other SQLite errors are not falsely classified", () => {
+    const err = new Error("SQLITE_BUSY: database is locked");
+    const code = isInfrastructureError(err);
+    assert.equal(code, null, "SQLITE_BUSY should not be infra error (it's transient)");
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-nested-git-safety.test.ts

@@ -0,0 +1,101 @@
+/**
+ * worktree-nested-git-safety.test.ts — #2616
+ *
+ * When scaffolding tools (create-next-app, cargo init, etc.) run inside a
+ * worktree, they create nested .git directories. Git treats these as gitlinks
+ * (mode 160000) without a .gitmodules entry, so the worktree cleanup destroys
+ * the only copy of those object databases — causing permanent data loss.
+ *
+ * This test verifies that removeWorktree detects nested .git directories
+ * (orphaned gitlinks) and absorbs or removes them before cleanup so files
+ * are tracked as regular content instead of unreachable gitlink pointers.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const srcPath = join(import.meta.dirname, "..", "worktree-manager.ts");
+const src = readFileSync(srcPath, "utf-8");
+
+console.log("\n=== #2616: Worktree cleanup detects nested .git directories ===");
+
+// ── Test 1: removeWorktree scans for nested .git directories ─────────
+
+const removeWorktreeIdx = src.indexOf("export function removeWorktree");
+assertTrue(removeWorktreeIdx > 0, "worktree-manager.ts exports removeWorktree");
+
+const fnBody = src.slice(removeWorktreeIdx, removeWorktreeIdx + 5000);
+
+const detectsNestedGit =
+  fnBody.includes("nested") && fnBody.includes(".git") ||
+  fnBody.includes("gitlink") ||
+  fnBody.includes("160000") ||
+  fnBody.includes("findNestedGitDirs") ||
+  fnBody.includes("nestedGitDirs");
+
+assertTrue(
+  detectsNestedGit,
+  "removeWorktree detects nested .git directories or gitlinks (#2616)",
+);
+
+// ── Test 2: A helper function exists to find nested .git directories ──
+
+const hasNestedGitHelper =
+  src.includes("findNestedGitDirs") ||
+  src.includes("detectNestedGitDirs") ||
+  src.includes("scanNestedGit") ||
+  src.includes("absorbNestedGit") ||
+  src.includes("nestedGitDirs");
+
+assertTrue(
+  hasNestedGitHelper,
+  "worktree-manager has a helper to find nested .git directories (#2616)",
+);
+
+// ── Test 3: Nested .git dirs are absorbed or removed before cleanup ───
+
+const absorbsOrRemoves =
+  fnBody.includes("absorb") ||
+  fnBody.includes("rmSync") && fnBody.includes("nested") ||
+  (fnBody.includes("nestedGitDirs") || fnBody.includes("findNestedGitDirs")) &&
+    (fnBody.includes("rm") || fnBody.includes("absorb") || fnBody.includes("remove"));
+
+assertTrue(
+  absorbsOrRemoves,
+  "removeWorktree absorbs or removes nested .git dirs before cleanup (#2616)",
+);
+
+// ── Test 4: A warning is logged when nested .git dirs are found ───────
+
+const warnsAboutNestedGit =
+  fnBody.includes("nested") && fnBody.includes("logWarning") ||
+  fnBody.includes("gitlink") && fnBody.includes("logWarning") ||
+  fnBody.includes("scaffold") && fnBody.includes("logWarning");
+
+assertTrue(
+  warnsAboutNestedGit,
+  "removeWorktree warns when nested .git directories are detected (#2616)",
+);
+
+// ── Test 5: The findNestedGitDirs helper correctly identifies nested repos ──
+// Verify the helper scans subdirectories but skips .gsd/, node_modules/, .git/
+
+const helperBody = src.includes("findNestedGitDirs")
+  ? src.slice(src.indexOf("findNestedGitDirs"))
+  : "";
+
+const skipsExcludedDirs =
+  helperBody.includes("node_modules") ||
+  helperBody.includes(".gsd") ||
+  helperBody.includes("skip") ||
+  helperBody.includes("exclude");
+
+assertTrue(
+  skipsExcludedDirs,
+  "findNestedGitDirs skips node_modules and other excluded directories (#2616)",
+);
+
+report();

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

@@ -481,7 +481,8 @@ test("mergeAndExit resolves roadmap from worktree when missing at project root (
 
   // Should have called mergeMilestoneToMain, not bare teardown
   assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 1);
-  assert.equal(findCalls(deps.calls, "teardownAutoWorktree").length, 0);
+  // #2945 Bug 3: secondary teardown is now called after merge for cleanup
+  assert.equal(findCalls(deps.calls, "teardownAutoWorktree").length, 1);
   assert.equal(s.basePath, "/project"); // restored
   assert.ok(ctx.messages.some((m) => m.msg.includes("merged to main")));
 });
@@ -913,3 +914,49 @@ test("isolationDegraded is reset by session.reset() (#2483)", () => {
 
   assert.equal(s.isolationDegraded, false);
 });
+
+// ─── #2625 — Default isolation mode change must not orphan worktree commits ──
+
+test("mergeAndExit still merges when mode is 'none' but session is in a worktree (#2625)", () => {
+  // Scenario: user upgraded from a version where default was "worktree" to one
+  // where default is "none". They have an active worktree with committed work.
+  // mergeAndExit must detect the active worktree and merge regardless of config.
+  const s = makeSession({
+    basePath: "/project/.gsd/worktrees/M001",
+    originalBasePath: "/project",
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => true,
+    getIsolationMode: () => "none", // config says "none" — but we ARE in a worktree
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.mergeAndExit("M001", ctx);
+
+  // Must still merge — not skip silently
+  assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 1,
+    "must call mergeMilestoneToMain even when isolation mode is 'none' but we are in a worktree");
+  assert.equal(s.basePath, "/project", "basePath must be restored to project root");
+  assert.ok(ctx.messages.some((m) => m.msg.includes("merged to main")),
+    "must notify about the merge");
+});
+
+test("mergeAndExit in none mode remains a no-op when NOT in a worktree (#2625)", () => {
+  // When mode is "none" and we are genuinely not in a worktree, it should still be a no-op.
+  const s = makeSession({
+    basePath: "/project",
+    originalBasePath: "/project",
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => false,
+    getIsolationMode: () => "none",
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.mergeAndExit("M001", ctx);
+
+  assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 0,
+    "must NOT merge when not in a worktree and mode is none");
+});

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -100,8 +100,8 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 3. gsd.db deleted in worktree after sync ─────────────────────────
-  console.log('\n=== 3. gsd.db deleted in worktree after sync ===');
+  // ─── 3. empty gsd.db deleted in worktree after sync ────────────────────
+  console.log('\n=== 3. empty gsd.db deleted in worktree after sync ===');
   {
     const mainBase = createBase('main');
     const wtBase = createBase('wt');
@@ -111,13 +111,37 @@ describe('worktree-sync-milestones', async () => {
       mkdirSync(m001Dir, { recursive: true });
       writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
 
-      // Worktree has a stale gsd.db
-      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), 'stale data');
+      // Worktree has an empty (0-byte) gsd.db — stale/corrupt
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), '');
       assert.ok(existsSync(join(wtBase, '.gsd', 'gsd.db')), 'gsd.db exists before sync');
 
       syncProjectRootToWorktree(mainBase, wtBase, 'M001');
 
-      assert.ok(!existsSync(join(wtBase, '.gsd', 'gsd.db')), '#853: gsd.db deleted after sync');
+      assert.ok(!existsSync(join(wtBase, '.gsd', 'gsd.db')), '#853: empty gsd.db deleted after sync');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 3b. non-empty gsd.db preserved in worktree after sync (#2815) ───
+  console.log('\n=== 3b. non-empty gsd.db preserved in worktree after sync (#2815) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Worktree has a populated gsd.db (e.g. from gsd-migrate on respawn)
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), 'migrated-db-content');
+      assert.ok(existsSync(join(wtBase, '.gsd', 'gsd.db')), 'gsd.db exists before sync');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      assert.ok(existsSync(join(wtBase, '.gsd', 'gsd.db')), '#2815: non-empty gsd.db preserved after sync');
     } finally {
       cleanup(mainBase);
       cleanup(wtBase);

package/src/resources/extensions/gsd/tests/zombie-gsd-state.test.ts

@@ -0,0 +1,95 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
+
+// ─── #2942: Zombie .gsd state skips init wizard ─────────────────────────────
+//
+// A partially initialized .gsd/ (symlink exists but no PREFERENCES.md or
+// milestones/) causes the init wizard gate in showSmartEntry to be skipped,
+// resulting in an uninitialized project session.
+
+console.log("\n=== #2942: zombie .gsd state must not skip init wizard ===");
+
+// ── guided-flow.ts — init wizard gate must check bootstrap completeness ──
+
+const guidedFlowSrc = readFileSync(
+  join(import.meta.dirname, "..", "guided-flow.ts"),
+  "utf-8",
+);
+
+// Find the showSmartEntry function
+const smartEntryIdx = guidedFlowSrc.indexOf("export async function showSmartEntry(");
+assertTrue(smartEntryIdx >= 0, "guided-flow.ts defines showSmartEntry");
+
+// Extract the region between showSmartEntry and the first showProjectInit call
+// This is where the init wizard gate lives.
+const afterSmartEntry = smartEntryIdx >= 0 ? guidedFlowSrc.slice(smartEntryIdx, smartEntryIdx + 3000) : "";
+
+// The gate must NOT be a bare `!existsSync(gsdRoot(basePath))` check.
+// It must also verify that bootstrap artifacts (PREFERENCES.md or milestones/) exist.
+assertTrue(
+  afterSmartEntry.includes("PREFERENCES.md") || afterSmartEntry.includes("PREFERENCES"),
+  "init wizard gate checks for PREFERENCES.md, not just .gsd/ existence (#2942)",
+);
+
+assertTrue(
+  afterSmartEntry.includes("milestones"),
+  "init wizard gate checks for milestones/ directory, not just .gsd/ existence (#2942)",
+);
+
+// The init wizard should be shown when .gsd/ exists but has no bootstrap artifacts.
+// The old code was: if (!existsSync(gsdRoot(basePath))) { ... showProjectInit ... }
+// The fix should use a compound check so zombie states trigger the wizard.
+// Verify we no longer have the bare existence check as the sole gate.
+
+// Find the specific init wizard gate pattern — the detection preamble block.
+const detectionPreambleIdx = afterSmartEntry.indexOf("Detection preamble");
+const detectionRegion = detectionPreambleIdx >= 0
+  ? afterSmartEntry.slice(detectionPreambleIdx, detectionPreambleIdx + 600)
+  : afterSmartEntry.slice(0, 1500);
+
+// The gate condition must reference PREFERENCES.md or milestones (bootstrap artifacts)
+assertMatch(
+  detectionRegion,
+  /PREFERENCES\.md|milestones/,
+  "detection preamble gate references bootstrap artifacts, not just directory existence (#2942)",
+);
+
+// ── auto-start.ts — milestones/ dir creation must not be dead code ──────────
+
+console.log("\n=== #2942: auto-start milestones/ bootstrap not dead code ===");
+
+const autoStartSrc = readFileSync(
+  join(import.meta.dirname, "..", "auto-start.ts"),
+  "utf-8",
+);
+
+// After ensureGsdSymlink, the code that creates milestones/ must check for
+// the milestones directory specifically (not .gsd/ which ensureGsdSymlink already created).
+const symlinkIdx = autoStartSrc.indexOf("ensureGsdSymlink(base)");
+assertTrue(symlinkIdx >= 0, "auto-start.ts calls ensureGsdSymlink(base)");
+
+const afterSymlink = symlinkIdx >= 0 ? autoStartSrc.slice(symlinkIdx, symlinkIdx + 800) : "";
+
+// The milestones bootstrap must check milestones path, not gsdDir
+// Old (dead) code: if (!existsSync(gsdDir)) { mkdirSync(join(gsdDir, "milestones"), ...) }
+// Fixed code should check: if (!existsSync(milestonesPath)) or similar
+assertTrue(
+  afterSymlink.includes("milestones") && afterSymlink.includes("mkdirSync"),
+  "auto-start.ts creates milestones/ directory after ensureGsdSymlink (#2942)",
+);
+
+// The guard for milestones/ creation should NOT be `!existsSync(gsdDir)` —
+// that's dead code since ensureGsdSymlink already created gsdDir.
+// It should check for the milestones/ dir directly.
+const mkdirRegion = afterSymlink.slice(0, afterSymlink.indexOf("mkdirSync") + 200);
+assertMatch(
+  mkdirRegion,
+  /existsSync\([^)]*milestones/,
+  "milestones bootstrap checks milestones path existence, not .gsd/ (#2942)",
+);
+
+report();