gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

package/src/resources/extensions/gsd/tests/empty-db-reconciliation.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Regression test for #2631: deriveState disk→DB reconciliation must
+ * run even when the milestones table starts empty.
+ *
+ * When getAllMilestones() returns [] (e.g. after a failed initial migration),
+ * the reconciliation code inside deriveStateFromDb was unreachable because
+ * deriveState only called it when dbMilestones.length > 0. The fix moves
+ * disk→DB sync into deriveState itself, before the length check.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveState, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+} from "../gsd-db.ts";
+
+test("deriveState populates empty DB from disk milestones (#2631)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-empty-db-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    // Create a milestone on disk with a CONTEXT file (not a ghost)
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+      "# M001: Test Milestone\n\nSome context about this milestone.",
+    );
+
+    // Open DB — milestones table is empty (simulating failed migration)
+    openDatabase(":memory:");
+    const before = getAllMilestones();
+    assert.equal(before.length, 0, "DB should start with 0 milestones");
+
+    // deriveState should reconcile disk → DB
+    invalidateStateCache();
+    const state = await deriveState(base);
+
+    // After deriveState, the DB should now have the disk milestone
+    const after = getAllMilestones();
+    assert.ok(after.length > 0, "DB should have milestones after reconciliation");
+    assert.equal(after[0]!.id, "M001", "reconciled milestone should be M001");
+
+    // State should reflect the milestone (not "No milestones found")
+    assert.ok(
+      state.activeMilestone !== null,
+      "activeMilestone should not be null after reconciliation",
+    );
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deriveState does NOT insert ghost milestones into DB (#2631 guard)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-empty-db-"));
+  // Create a ghost milestone directory (empty — no CONTEXT, no ROADMAP)
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    openDatabase(":memory:");
+    invalidateStateCache();
+    await deriveState(base);
+
+    const milestones = getAllMilestones();
+    assert.equal(milestones.length, 0, "ghost milestone should NOT be inserted");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/forensics-dedup.test.ts

@@ -46,34 +46,3 @@ describe("forensics dedup (#2096)", () => {
       "opt-in notice must mention duplicate detection");
   });
 });
-
-describe("forensics dedup ordering (#2704)", () => {
-  it("{{dedupSection}} appears before Investigation Protocol in the prompt template", () => {
-    const prompt = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
-    const dedupIndex = prompt.indexOf("{{dedupSection}}");
-    const investigationIndex = prompt.indexOf("## Investigation Protocol");
-    assert.ok(dedupIndex !== -1, "prompt must contain {{dedupSection}}");
-    assert.ok(investigationIndex !== -1, "prompt must contain ## Investigation Protocol");
-    assert.ok(
-      dedupIndex < investigationIndex,
-      `{{dedupSection}} (index ${dedupIndex}) must appear before Investigation Protocol (index ${investigationIndex}) — dedup should run before expensive investigation to avoid wasting tokens on already-fixed bugs`,
-    );
-  });
-
-  it("DEDUP_PROMPT_SECTION contains a decision gate to skip investigation", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    // The dedup section must instruct the agent to skip investigation when a match is found
-    assert.ok(
-      source.includes("Skip full investigation") || source.includes("skip full investigation") || source.includes("Skip investigation"),
-      "DEDUP_PROMPT_SECTION must contain a decision gate telling the agent to skip full investigation when a duplicate is found",
-    );
-  });
-
-  it("DEDUP_PROMPT_SECTION heading reflects pre-investigation role", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(
-      source.includes("Pre-Investigation") || source.includes("pre-investigation"),
-      "DEDUP_PROMPT_SECTION heading must indicate it runs before investigation, not just before issue creation",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/gsd-tools.test.ts

@@ -21,10 +21,8 @@ import {
 import {
   saveDecisionToDb,
   updateRequirementInDb,
-  saveRequirementToDb,
   saveArtifactToDb,
   nextDecisionId,
-  nextRequirementId,
 } from '../db-writer.ts';
 import type { Requirement } from '../types.ts';
 
@@ -162,11 +160,18 @@ describe('gsd-tools', () => {
       assert.ok(mdContent.includes('R001'), 'REQUIREMENTS.md should contain R001');
       assert.ok(mdContent.includes('validated'), 'REQUIREMENTS.md should reflect updated status');
 
-      // Updating non-existent requirement upserts (creates it) — see #2919
-      await updateRequirementInDb('R999', { status: 'deferred' }, tmpDir);
-      const upserted = getRequirementById('R999');
-      assert.ok(upserted !== null, 'R999 should be created by upsert');
-      assert.deepStrictEqual(upserted!.status, 'deferred', 'Upserted requirement should have the updated status');
+      // Updating non-existent requirement throws
+      let threwForMissing = false;
+      try {
+        await updateRequirementInDb('R999', { status: 'deferred' }, tmpDir);
+      } catch (err) {
+        threwForMissing = true;
+        assert.ok(
+          (err as Error).message.includes('R999'),
+          'Error should mention the missing requirement ID',
+        );
+      }
+      assert.ok(threwForMissing, 'Should throw for non-existent requirement');
 
       closeDatabase();
     } finally {
@@ -258,124 +263,6 @@ describe('gsd-tools', () => {
     assert.deepStrictEqual(fallbackId, 'D001', 'nextDecisionId should return D001 when DB unavailable');
   });
 
-  test('gsd_requirement_save creates new requirement', async () => {
-    const tmpDir = makeTmpDir();
-    try {
-      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-      openDatabase(dbPath);
-
-      // (a) saveRequirementToDb creates a new requirement with auto-assigned ID
-      const result = await saveRequirementToDb(
-        {
-          class: 'functional',
-          status: 'active',
-          description: 'Must support dark mode',
-          why: 'Accessibility requirement',
-          source: 'user-research',
-        },
-        tmpDir,
-      );
-
-      assert.deepStrictEqual(result.id, 'R001', 'First requirement should be R001');
-
-      // Verify DB row exists
-      const row = getRequirementById('R001');
-      assert.ok(row !== null, 'Requirement R001 should exist in DB');
-      assert.deepStrictEqual(row!.class, 'functional', 'Class should match');
-      assert.deepStrictEqual(row!.description, 'Must support dark mode', 'Description should match');
-      assert.deepStrictEqual(row!.status, 'active', 'Status should match');
-
-      // Verify REQUIREMENTS.md was generated
-      const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
-      assert.ok(fs.existsSync(mdPath), 'REQUIREMENTS.md should be created');
-      const mdContent = fs.readFileSync(mdPath, 'utf-8');
-      assert.ok(mdContent.includes('R001'), 'REQUIREMENTS.md should contain R001');
-      assert.ok(mdContent.includes('dark mode'), 'REQUIREMENTS.md should contain description');
-
-      // (b) Auto-assigns correct next ID
-      const result2 = await saveRequirementToDb(
-        {
-          class: 'non-functional',
-          status: 'active',
-          description: 'Must load in under 2 seconds',
-          why: 'Performance SLA',
-          source: 'design',
-        },
-        tmpDir,
-      );
-      assert.deepStrictEqual(result2.id, 'R002', 'Second requirement should be R002');
-
-      closeDatabase();
-    } finally {
-      cleanupDir(tmpDir);
-    }
-  });
-
-  test('nextRequirementId computes correct next ID', async () => {
-    const tmpDir = makeTmpDir();
-    try {
-      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-      openDatabase(dbPath);
-
-      // No requirements yet
-      const id1 = await nextRequirementId();
-      assert.deepStrictEqual(id1, 'R001', 'Should return R001 when no requirements exist');
-
-      // Add one requirement
-      upsertRequirement({
-        id: 'R001',
-        class: 'functional',
-        status: 'active',
-        description: 'Test',
-        why: '',
-        source: '',
-        primary_owner: '',
-        supporting_slices: '',
-        validation: '',
-        notes: '',
-        full_content: '',
-        superseded_by: null,
-      });
-
-      const id2 = await nextRequirementId();
-      assert.deepStrictEqual(id2, 'R002', 'Should return R002 after R001 exists');
-
-      closeDatabase();
-    } finally {
-      cleanupDir(tmpDir);
-    }
-  });
-
-  test('gsd_requirement_update upserts when requirement not in DB', async () => {
-    const tmpDir = makeTmpDir();
-    try {
-      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-      openDatabase(dbPath);
-
-      // Requirement R025 does NOT exist in DB — simulates the bug scenario
-      // where requirements exist in REQUIREMENTS.md but were never imported.
-      // updateRequirementInDb should create the row instead of throwing.
-      await updateRequirementInDb(
-        'R025',
-        { status: 'validated', validation: 'Integration tests pass' },
-        tmpDir,
-      );
-
-      const created = getRequirementById('R025');
-      assert.ok(created !== null, 'R025 should be created by upsert');
-      assert.deepStrictEqual(created!.status, 'validated', 'Status should be set');
-      assert.deepStrictEqual(created!.validation, 'Integration tests pass', 'Validation should be set');
-
-      // Verify REQUIREMENTS.md was generated
-      const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
-      assert.ok(fs.existsSync(mdPath), 'REQUIREMENTS.md should be created');
-
-      closeDatabase();
-    } finally {
-      cleanupDir(tmpDir);
-    }
-  });
-
   test('Tool result format', async () => {
     const tmpDir = makeTmpDir();
     try {

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -6,7 +6,6 @@ import { tmpdir } from "node:os";
 import {
   buildHealthLines,
   detectHealthWidgetProjectState,
-  formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
 
@@ -35,8 +34,6 @@ function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData
     providerIssue: null,
     environmentErrorCount: 0,
     environmentWarningCount: 0,
-    lastCommitEpoch: null,
-    lastCommitMessage: null,
     lastRefreshed: Date.now(),
     ...overrides,
   };
@@ -101,70 +98,6 @@ test("buildHealthLines: active state with issues reports issue summary", (t) =>
   assert.match(lines[0]!, /Env: 1 error/);
 });
 
-// ── Last commit display ──────────────────────────────────────────────────
-
-test("buildHealthLines: shows last commit with relative time and message", (t) => {
-  const epoch = Math.floor(Date.now() / 1000) - 300; // 5 minutes ago
-  const lines = buildHealthLines(activeData({
-    lastCommitEpoch: epoch,
-    lastCommitMessage: "feat(widget): add health display",
-  }));
-  assert.equal(lines.length, 1);
-  assert.match(lines[0]!, /Last commit: 5m ago/);
-  assert.match(lines[0]!, /feat\(widget\): add health display/);
-});
-
-test("buildHealthLines: truncates long commit messages", (t) => {
-  const epoch = Math.floor(Date.now() / 1000) - 60;
-  const longMsg = "a".repeat(80);
-  const lines = buildHealthLines(activeData({
-    lastCommitEpoch: epoch,
-    lastCommitMessage: longMsg,
-  }));
-  assert.equal(lines.length, 1);
-  assert.match(lines[0]!, /a{49}…/);
-  assert.ok(!lines[0]!.includes("a".repeat(51)), "message is truncated");
-});
-
-test("buildHealthLines: no last commit section when epoch is null", (t) => {
-  const lines = buildHealthLines(activeData({ lastCommitEpoch: null }));
-  assert.equal(lines.length, 1);
-  assert.ok(!lines[0]!.includes("Last commit"), "no last commit when null");
-});
-
-test("buildHealthLines: last commit without message shows only time", (t) => {
-  const epoch = Math.floor(Date.now() / 1000) - 3600; // 1 hour ago
-  const lines = buildHealthLines(activeData({
-    lastCommitEpoch: epoch,
-    lastCommitMessage: null,
-  }));
-  assert.equal(lines.length, 1);
-  assert.match(lines[0]!, /Last commit: 1h ago/);
-  assert.ok(!lines[0]!.includes(" — "), "no dash separator when no message");
-});
-
-// ── formatRelativeTime ───────────────────────────────────────────────────
-
-test("formatRelativeTime: just now for <60s", () => {
-  const epoch = Math.floor(Date.now() / 1000) - 30;
-  assert.equal(formatRelativeTime(epoch), "just now");
-});
-
-test("formatRelativeTime: minutes", () => {
-  const epoch = Math.floor(Date.now() / 1000) - 300;
-  assert.equal(formatRelativeTime(epoch), "5m ago");
-});
-
-test("formatRelativeTime: hours", () => {
-  const epoch = Math.floor(Date.now() / 1000) - 7200;
-  assert.equal(formatRelativeTime(epoch), "2h ago");
-});
-
-test("formatRelativeTime: days", () => {
-  const epoch = Math.floor(Date.now() / 1000) - 172800;
-  assert.equal(formatRelativeTime(epoch), "2d ago");
-});
-
 test("detectHealthWidgetProjectState: metrics file alone does not imply project", (t) => {
   const dir = makeTempDir("metrics-only");
   t.after(() => { cleanup(dir); });

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

@@ -111,51 +111,7 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
 
   const uatResult = resolveExpectedArtifactPath("run-uat", "M001/S01", base);
   assert.ok(uatResult);
-  assert.ok(uatResult!.includes("ASSESSMENT"));
-});
-
-// ─── run-uat artifact path contract (#2873) ──────────────────────────────
-
-test("resolveExpectedArtifactPath for run-uat returns ASSESSMENT path, not UAT (#2873)", (t) => {
-  // The run-uat prompt instructs the agent to call gsd_summary_save with
-  // artifact_type: "ASSESSMENT", which writes S##-ASSESSMENT.md. The artifact
-  // verification path must match — otherwise verification fails and auto-mode
-  // retries the unit in an infinite loop.
-  const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const result = resolveExpectedArtifactPath("run-uat", "M001/S01", base);
-  assert.ok(result, "run-uat should resolve to a non-null artifact path");
-  assert.ok(
-    result!.endsWith("S01-ASSESSMENT.md"),
-    `run-uat artifact path should end with S01-ASSESSMENT.md, got: ${result}`,
-  );
-});
-
-test("diagnoseExpectedArtifact for run-uat references ASSESSMENT (#2873)", (t) => {
-  const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const diag = diagnoseExpectedArtifact("run-uat", "M001/S01", base);
-  assert.ok(diag, "run-uat should have a diagnostic message");
-  assert.ok(
-    diag!.includes("ASSESSMENT"),
-    `run-uat diagnostic should reference ASSESSMENT, got: ${diag}`,
-  );
-});
-
-test("verifyExpectedArtifact passes for run-uat when ASSESSMENT file exists (#2873)", (t) => {
-  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_summary_save,
-  // but verification looked for S##-UAT.md, causing false stuck retries.
-  const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  // Write the ASSESSMENT file (what gsd_summary_save actually produces)
-  const assessPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
-  writeFileSync(assessPath, "---\nverdict: PASS\n---\n# UAT Assessment\n");
-
-  const verified = verifyExpectedArtifact("run-uat", "M001/S01", base);
-  assert.ok(verified, "verifyExpectedArtifact should pass when ASSESSMENT file exists");
+  assert.ok(uatResult!.includes("UAT"));
 });
 
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
@@ -741,72 +697,6 @@ test("verifyExpectedArtifact complete-milestone fails with only .gsd/ files (#17
   assert.equal(result, false, "complete-milestone should fail verification when only .gsd/ files present");
 });
 
-// ─── reconcileMergeState: silent nativeCommit failure (#2542) ─────────────
-
-import { reconcileMergeState } from "../../auto-recovery.ts";
-import { chmodSync } from "node:fs";
-
-function makeMockCtx(): { ctx: any; notifications: Array<{ msg: string; level: string }> } {
-  const notifications: Array<{ msg: string; level: string }> = [];
-  const ctx = {
-    ui: {
-      notify(msg: string, level: string) {
-        notifications.push({ msg, level });
-      },
-    },
-  };
-  return { ctx, notifications };
-}
-
-test("reconcileMergeState returns false and notifies error when nativeCommit fails (#2542)", (t) => {
-  const base = makeGitBase();
-  t.after(() => cleanup(base));
-
-  // Create a second branch with a commit, then start a merge on main
-  execFileSync("git", ["checkout", "-b", "feature"], { cwd: base, stdio: "ignore" });
-  writeFileSync(join(base, "feature.txt"), "feature content");
-  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
-  execFileSync("git", ["commit", "-m", "add feature"], { cwd: base, stdio: "ignore" });
-  execFileSync("git", ["checkout", "main"], { cwd: base, stdio: "ignore" });
-
-  // Start merge (no conflicts — fast path with MERGE_HEAD)
-  execFileSync("git", ["merge", "--no-ff", "--no-commit", "feature"], { cwd: base, stdio: "ignore" });
-
-  // Verify MERGE_HEAD exists
-  assert.ok(existsSync(join(base, ".git", "MERGE_HEAD")), "MERGE_HEAD should exist");
-
-  // Make .git/objects read-only so git cannot write the commit object,
-  // causing nativeCommit to throw a non-"nothing to commit" error.
-  const objectsDir = join(base, ".git", "objects");
-  chmodSync(objectsDir, 0o444);
-  t.after(() => { try { chmodSync(objectsDir, 0o755); } catch { /* cleanup */ } });
-
-  const { ctx, notifications } = makeMockCtx();
-  const result = reconcileMergeState(base, ctx);
-
-  // The function should return false to signal reconciliation failure
-  // (Currently it silently swallows the error and returns true — this test should FAIL before the fix)
-  assert.equal(result, false, "reconcileMergeState should return false when nativeCommit fails");
-  const errorNotifications = notifications.filter(n => n.level === "error");
-  assert.ok(errorNotifications.length > 0, "should notify an error when nativeCommit fails");
-  assert.ok(
-    errorNotifications[0].msg.includes("Failed to finalize"),
-    "error notification should describe the commit failure",
-  );
-});
-
-test("reconcileMergeState returns true when no merge state present", (t) => {
-  // When there's no MERGE_HEAD or SQUASH_MSG, reconcileMergeState returns false (no dirty state)
-  const base = makeGitBase();
-  t.after(() => cleanup(base));
-
-  const { ctx, notifications } = makeMockCtx();
-  const result = reconcileMergeState(base, ctx);
-
-  assert.equal(result, false, "should return false when no merge state exists");
-  assert.equal(notifications.length, 0, "should not notify when no merge state present");
-});
-
 test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -638,107 +638,6 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be false when only .gsd/ files were merged");
   });
 
-  test("#2912: MERGE_HEAD cleaned up after squash-merge conflict", () => {
-    const repo = freshRepo();
-    const wtPath = createAutoWorktree(repo, "M291");
-
-    // Create a file on main that will conflict with the milestone branch
-    run("git checkout main", repo);
-    writeFileSync(join(repo, "conflict.ts"), "// main version\nexport const x = 1;\n");
-    run("git add .", repo);
-    run("git commit -m 'add conflict.ts on main'", repo);
-
-    // Switch back to milestone branch and create conflicting content
-    run("git checkout milestone/M291", wtPath);
-    writeFileSync(join(wtPath, "conflict.ts"), "// milestone version\nexport const x = 2;\n");
-    run("git add .", wtPath);
-    run("git commit -m 'add conflict.ts on milestone'", wtPath);
-
-    const roadmap = makeRoadmap("M291", "Conflict milestone", [
-      { id: "S01", title: "Conflict test" },
-    ]);
-
-    // The merge should throw MergeConflictError due to conflict.ts
-    let threw = false;
-    try {
-      mergeMilestoneToMain(repo, "M291", roadmap);
-    } catch (err: unknown) {
-      threw = true;
-      // Verify it's a merge conflict error
-      assert.ok(
-        err instanceof Error && err.message.includes("conflict"),
-        "should throw a conflict-related error",
-      );
-    }
-    assert.ok(threw, "mergeMilestoneToMain must throw on code conflict");
-
-    // BUG #2912: MERGE_HEAD must NOT be left on disk after the error
-    const mergeHeadPath = join(repo, ".git", "MERGE_HEAD");
-    assert.ok(
-      !existsSync(mergeHeadPath),
-      "#2912: MERGE_HEAD must be cleaned up after merge conflict error",
-    );
-  });
-
-  test("#2912: stale MERGE_HEAD from native merge is cleaned after successful commit", () => {
-    const repo = freshRepo();
-    const wtPath = createAutoWorktree(repo, "M292");
-
-    addSliceToMilestone(repo, wtPath, "M292", "S01", "Feature A", [
-      { file: "feature-a.ts", content: "export const a = true;\n", message: "add feature a" },
-    ]);
-
-    const roadmap = makeRoadmap("M292", "Clean merge", [
-      { id: "S01", title: "Feature A" },
-    ]);
-
-    // Simulate what libgit2's merge implementation does: it creates MERGE_HEAD
-    // even for squash merges (unlike CLI git). We plant MERGE_HEAD before calling
-    // mergeMilestoneToMain to verify the success path cleans it up.
-    // We cannot plant it before the call because the function manages checkout
-    // internally, so instead we verify after the call.
-    mergeMilestoneToMain(repo, "M292", roadmap);
-
-    // After successful merge+commit, MERGE_HEAD must not linger
-    const mergeHeadPath = join(repo, ".git", "MERGE_HEAD");
-    assert.ok(
-      !existsSync(mergeHeadPath),
-      "#2912: MERGE_HEAD must be cleaned up after successful merge",
-    );
-  });
-
-  test("#2912: planted MERGE_HEAD is cleaned up in success path", () => {
-    // This test directly verifies the cleanup code handles a MERGE_HEAD file
-    // left by the native (libgit2) merge path. We hook into the merge by
-    // planting MERGE_HEAD right after nativeMergeSquash would create it.
-    const repo = freshRepo();
-    const wtPath = createAutoWorktree(repo, "M293");
-
-    addSliceToMilestone(repo, wtPath, "M293", "S01", "Feature B", [
-      { file: "feature-b.ts", content: "export const b = true;\n", message: "add feature b" },
-    ]);
-
-    const roadmap = makeRoadmap("M293", "Planted MERGE_HEAD", [
-      { id: "S01", title: "Feature B" },
-    ]);
-
-    // Plant a fake MERGE_HEAD in the git dir to simulate libgit2 behavior.
-    // We need to do this after the function checks out main but before it
-    // commits. Since we can't intercept mid-function, we plant it before
-    // the call. If the function cleans it up, the test passes.
-    const gitDir = join(repo, ".git");
-    const fakeHead = run("git rev-parse HEAD", repo);
-    writeFileSync(join(gitDir, "MERGE_HEAD"), fakeHead + "\n");
-
-    mergeMilestoneToMain(repo, "M293", roadmap);
-
-    // The planted MERGE_HEAD must be cleaned up
-    assert.ok(
-      !existsSync(join(gitDir, "MERGE_HEAD")),
-      "#2912: planted MERGE_HEAD must be removed by success-path cleanup",
-    );
-  });
-
   test("#1906: codeFilesChanged=true when real code is merged", () => {
     const repo = freshRepo();
     const wtPath = createAutoWorktree(repo, "M190");

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

@@ -20,7 +20,6 @@ import {
   enterAutoWorktree,
   getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
-  syncGsdStateToWorktree,
 } from "../../auto-worktree.ts";
 
 // Note: execSync is used intentionally in tests for git operations with
@@ -287,62 +286,4 @@ describe("auto-worktree lifecycle", () => {
       teardownAutoWorktree(tempDir, "M004");
     }
   });
-
-  test("#2791: mcp.json copied into worktree via copyPlanningArtifacts", () => {
-    tempDir = createTempRepo();
-    const msDir = join(tempDir, ".gsd", "milestones", "M003");
-    mkdirSync(msDir, { recursive: true });
-    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
-    run("git add .", tempDir);
-    run("git commit -m \"add milestone\"", tempDir);
-
-    // Create mcp.json in .gsd/ AFTER the commit (untracked, like real usage).
-    // copyPlanningArtifacts should copy it into the worktree's .gsd/.
-    writeFileSync(
-      join(tempDir, ".gsd", "mcp.json"),
-      JSON.stringify({ servers: { test: { command: "echo" } } }),
-    );
-
-    const wtPath = createAutoWorktree(tempDir, "M003");
-
-    try {
-      assert.ok(
-        existsSync(join(wtPath, ".gsd", "mcp.json")),
-        "mcp.json should be copied into worktree .gsd/ on creation",
-      );
-    } finally {
-      teardownAutoWorktree(tempDir, "M003");
-    }
-  });
-
-  test("#2791: mcp.json synced via syncGsdStateToWorktree (ROOT_STATE_FILES)", () => {
-    tempDir = createTempRepo();
-    const msDir = join(tempDir, ".gsd", "milestones", "M003");
-    mkdirSync(msDir, { recursive: true });
-    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
-    run("git add .", tempDir);
-    run("git commit -m \"add milestone\"", tempDir);
-
-    // Create worktree first (no mcp.json yet)
-    const wtPath = createAutoWorktree(tempDir, "M003");
-
-    try {
-      // Now add mcp.json to the main .gsd/ after worktree was created
-      writeFileSync(
-        join(tempDir, ".gsd", "mcp.json"),
-        JSON.stringify({ servers: { test: { command: "echo" } } }),
-      );
-
-      // Sync should pick up the new mcp.json
-      const { synced } = syncGsdStateToWorktree(tempDir, wtPath);
-
-      assert.ok(synced.includes("mcp.json"), "mcp.json should be in the synced list");
-      assert.ok(
-        existsSync(join(wtPath, ".gsd", "mcp.json")),
-        "mcp.json should exist in worktree after sync",
-      );
-    } finally {
-      teardownAutoWorktree(tempDir, "M003");
-    }
-  });
 });