gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

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

@@ -638,6 +638,140 @@ 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("#2912: stale SQUASH_MSG and MERGE_MSG are cleaned before squash merge", () => {
+    // Verifies that the pre-merge cleanup (step 7b) removes all three merge
+    // artifacts — not just MERGE_HEAD — so that `git merge --squash` never
+    // encounters leftover state from a prior interrupted operation.
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M294");
+
+    addSliceToMilestone(repo, wtPath, "M294", "S01", "Feature C", [
+      { file: "feature-c.ts", content: "export const c = true;\n", message: "add feature c" },
+    ]);
+
+    const roadmap = makeRoadmap("M294", "Stale merge artifacts", [
+      { id: "S01", title: "Feature C" },
+    ]);
+
+    // Plant stale merge artifacts in the git dir to simulate a prior
+    // interrupted merge.  The pre-merge cleanup must remove all of them.
+    const gitDir = join(repo, ".git");
+    writeFileSync(join(gitDir, "SQUASH_MSG"), "stale squash message\n");
+    writeFileSync(join(gitDir, "MERGE_MSG"), "stale merge message\n");
+
+    mergeMilestoneToMain(repo, "M294", roadmap);
+
+    assert.ok(
+      !existsSync(join(gitDir, "SQUASH_MSG")),
+      "#2912: stale SQUASH_MSG must be removed by pre-merge cleanup",
+    );
+    assert.ok(
+      !existsSync(join(gitDir, "MERGE_MSG")),
+      "#2912: stale MERGE_MSG must be removed by pre-merge 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,6 +20,7 @@ import {
   enterAutoWorktree,
   getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
+  syncGsdStateToWorktree,
 } from "../../auto-worktree.ts";
 
 // Note: execSync is used intentionally in tests for git operations with
@@ -286,4 +287,62 @@ 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");
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/integration/doctor-false-positives.test.ts

@@ -0,0 +1,243 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runGSDDoctor } from "../../doctor.js";
+import { parsePlan } from "../../parsers-legacy.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeBase(): { base: string; gsd: string; mDir: string } {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-fp-"));
+  const gsd = join(base, ".gsd");
+  const mDir = join(gsd, "milestones", "M001");
+  mkdirSync(join(mDir, "slices"), { recursive: true });
+  return { base, gsd, mDir };
+}
+
+function writeRoadmap(mDir: string, content: string): void {
+  writeFileSync(join(mDir, "M001-ROADMAP.md"), content);
+}
+
+function writeSlice(mDir: string, sliceId: string, planContent: string): string {
+  const sDir = join(mDir, "slices", sliceId);
+  const tDir = join(sDir, "tasks");
+  mkdirSync(tDir, { recursive: true });
+  writeFileSync(join(sDir, `${sliceId}-PLAN.md`), planContent);
+  return sDir;
+}
+
+describe('doctor false-positives (#3105)', async () => {
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Bug 1: Orphaned worktree directory recreated by appendDoctorHistory
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test('Bug 1: orphaned worktree check ignores dirs containing only .gsd/doctor-history.jsonl', async () => {
+    // Simulate: a worktree dir that only contains .gsd/doctor-history.jsonl
+    // (created by appendDoctorHistory writing to the worktree-scoped path).
+    // The orphan check should NOT warn about this directory.
+    const { base, gsd } = makeBase();
+    writeRoadmap(join(gsd, "milestones", "M001"), `# M001: Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(join(gsd, "milestones", "M001"), "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    // Create a worktree directory that only has .gsd/doctor-history.jsonl
+    const wtDir = join(gsd, "worktrees", "M042");
+    const wtGsdDir = join(wtDir, ".gsd");
+    mkdirSync(wtGsdDir, { recursive: true });
+    writeFileSync(join(wtGsdDir, "doctor-history.jsonl"), '{"ts":"2026-01-01","ok":true}\n');
+
+    const result = await runGSDDoctor(base, { fix: false });
+
+    // Should NOT produce worktree_directory_orphaned for a dir that only has doctor history
+    const orphanIssues = result.issues.filter(
+      i => i.code === "worktree_directory_orphaned" && i.unitId === "M042"
+    );
+    assert.equal(orphanIssues.length, 0,
+      "should not warn about worktree dir that only contains .gsd/doctor-history.jsonl");
+
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Bug 2: blocker_discovered + all tasks done = unfixable deadlock
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test('Bug 2: blocker_discovered with all tasks done should not warn (implicitly resolved)', async () => {
+    // Scenario: blocker was discovered and resolved within the same task.
+    // blocker_discovered: true, no REPLAN, but all tasks are done.
+    // Neither blocker_discovered_no_replan nor stale_replan_file should fire.
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Blocker Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01",
+      "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+provides: []
+requires: []
+affects: []
+key_files: []
+key_decisions: []
+patterns_established: []
+observability_surfaces: []
+drill_down_paths: []
+duration: 10m
+verification_result: passed
+completed_at: 2026-01-01T00:00:00Z
+blocker_discovered: true
+---
+
+# T01: Task
+
+**Done**
+
+## What Happened
+Found a blocker, resolved it in-task.
+
+## Diagnostics
+- log
+`);
+
+    const result = await runGSDDoctor(base, { fix: false });
+
+    // Should NOT produce blocker_discovered_no_replan when all tasks are done
+    const blockerIssues = result.issues.filter(i => i.code === "blocker_discovered_no_replan");
+    assert.equal(blockerIssues.length, 0,
+      "should not warn about blocker_discovered when all tasks are done (blocker was implicitly resolved)");
+
+    // Also should NOT produce stale_replan_file (no REPLAN exists, so this shouldn't fire anyway)
+    const staleReplanIssues = result.issues.filter(i => i.code === "stale_replan_file");
+    assert.equal(staleReplanIssues.length, 0,
+      "should not produce stale_replan_file when no REPLAN exists");
+
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  test('Bug 2: blocker_discovered with incomplete tasks should still warn', async () => {
+    // Sanity check: when there IS an incomplete task and blocker_discovered, warn as before.
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Blocker Warn Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01",
+      "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task A** `est:10m`\n  Done.\n- [ ] **T02: Task B** `est:10m`\n  Pending.\n");
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+provides: []
+requires: []
+affects: []
+key_files: []
+key_decisions: []
+patterns_established: []
+observability_surfaces: []
+drill_down_paths: []
+duration: 10m
+verification_result: passed
+completed_at: 2026-01-01T00:00:00Z
+blocker_discovered: true
+---
+
+# T01: Task A
+
+**Done**
+
+## What Happened
+Found blocker, but T02 is still pending.
+
+## Diagnostics
+- log
+`);
+
+    const result = await runGSDDoctor(base, { fix: false });
+
+    const blockerIssues = result.issues.filter(i => i.code === "blocker_discovered_no_replan");
+    assert.ok(blockerIssues.length > 0,
+      "should still warn about blocker_discovered when some tasks are not done");
+
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Bug 3: Multi-task plan — T02+ outside ## Tasks section
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test('Bug 3: parsePlan finds all tasks even when interleaved with detail sections', () => {
+    // Multi-task plan where T02 checkbox appears after T01's ## Steps heading,
+    // which ends the ## Tasks section for extractSection().
+    const planContent = `# S01: Demo Slice
+
+**Goal:** Build the demo
+**Demo:** Run it
+
+## Must-Haves
+- Feature A
+
+## Tasks
+- [x] **T01: First task** \`est:30m\`
+  Implement the first thing.
+## Steps
+1. Step one
+2. Step two
+## Must-Haves
+- Requirement A
+- [x] **T02: Second task** \`est:1h\`
+  Implement the second thing.
+## Steps
+1. Step one
+2. Step two
+`;
+
+    const plan = parsePlan(planContent);
+    const taskIds = plan.tasks.map(t => t.id);
+
+    assert.ok(taskIds.includes("T01"), "should find T01");
+    assert.ok(taskIds.includes("T02"), "should find T02 even when after T01 detail headings");
+    assert.equal(plan.tasks.length, 2, "should find exactly 2 tasks");
+  });
+
+  test('Bug 3: task_file_not_in_plan should not fire for T02 in multi-task plan', async () => {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Multi-Task Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+
+    // Plan with interleaved headings (the problematic format)
+    const sDir = writeSlice(mDir, "S01", `# S01: Demo Slice
+
+**Goal:** Build the demo
+**Demo:** Run it
+
+## Must-Haves
+- Feature A
+
+## Tasks
+- [x] **T01: First task** \`est:30m\`
+  Implement the first thing.
+## Steps
+1. Step one
+## Must-Haves
+- Req A
+- [x] **T02: Second task** \`est:1h\`
+  Implement the second thing.
+## Steps
+1. Step one
+`);
+
+    // Both tasks have summaries on disk
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), "---\nstatus: done\ncompleted_at: 2026-01-01T00:00:00Z\n---\n# T01\nDone.\n");
+    writeFileSync(join(sDir, "tasks", "T02-SUMMARY.md"), "---\nstatus: done\ncompleted_at: 2026-01-01T00:00:00Z\n---\n# T02\nDone.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+
+    // T02 should NOT be flagged as "not in plan"
+    const notInPlan = result.issues.filter(
+      i => i.code === "task_file_not_in_plan" && i.message.includes("T02")
+    );
+    assert.equal(notInPlan.length, 0,
+      "should not report T02 as 'not in plan' when it exists in the interleaved plan format");
+
+    rmSync(base, { recursive: true, force: true });
+  });
+});

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

@@ -645,6 +645,78 @@ describe('doctor-git', async () => {
     } else {
     }
 
+    // ─── Test: stale_uncommitted_changes detection & auto-snapshot ──────
+    test('stale_uncommitted_changes (detected and auto-committed)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Make the last commit appear old by amending its date to 45 min ago
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      // Also set committer date so git log %ct reflects it
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      // Modify an already-tracked file (nativeAddTracked uses git add -u,
+      // which only stages tracked files — new untracked files are not staged)
+      writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
+
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+      assert.ok(staleIssues.length > 0, "detects stale uncommitted changes");
+      assert.ok(staleIssues[0]?.message.includes("minute"), "message mentions minutes");
+      assert.ok(staleIssues[0]?.fixable === true, "stale uncommitted changes is fixable");
+
+      // Fix should create a gsd snapshot commit
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes("gsd snapshot")),
+        "fix creates a gsd snapshot commit",
+      );
+
+      // Verify the snapshot commit was created with the gsd snapshot tag
+      const log = run("git log -1 --oneline", dir);
+      assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
+    });
+
+    // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──
+    test('stale_uncommitted_changes (no false positive on recent commit)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create uncommitted changes (but last commit is fresh — just created)
+      writeFileSync(join(dir, "fresh-dirty.txt"), "recent changes\n");
+
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+      assert.deepStrictEqual(staleIssues.length, 0, "recent commit with dirty tree NOT flagged as stale");
+    });
+
+    // ─── Test: stale_uncommitted_changes NOT flagged when tree is clean ──
+    test('stale_uncommitted_changes (no false positive on clean tree)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Make the last commit appear old
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      // No uncommitted changes — tree is clean
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+      assert.deepStrictEqual(staleIssues.length, 0, "old commit with clean tree NOT flagged as stale");
+    });
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

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

@@ -1455,4 +1455,72 @@ describe('git-service', async () => {
     try { rmSync(repo, { recursive: true, force: true }); } catch {}
     try { rmSync(externalGsd, { recursive: true, force: true }); } catch {}
   });
+
+  // ─── autoCommit: absorbs preceding gsd snapshot commits ─────────────────
+
+  test('autoCommit: absorbs preceding gsd snapshot commits', () => {
+    const repo = initTempRepo();
+
+    // Simulate 2 gsd snapshot commits
+    createFile(repo, "file1.ts", "v1");
+    run("git add -A", repo);
+    run('git commit -m "gsd snapshot: uncommitted changes after 35m inactivity"', repo);
+
+    createFile(repo, "file2.ts", "v2");
+    run("git add -A", repo);
+    run('git commit -m "gsd snapshot: pre-dispatch, uncommitted changes after 40m inactivity"', repo);
+
+    // Verify we have 3 commits (init + 2 snapshots)
+    const countBefore = run("git rev-list --count HEAD", repo);
+    assert.deepStrictEqual(countBefore, "3", "precondition: 3 commits before autoCommit");
+
+    // Now make a real change and autoCommit
+    createFile(repo, "feature.ts", "real work");
+
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.autoCommit("execute-task", "S01/T01");
+    assert.ok(msg !== null, "autoCommit succeeds");
+
+    // Should be 2 commits: init + squashed real commit (snapshots absorbed)
+    const countAfter = run("git rev-list --count HEAD", repo);
+    assert.deepStrictEqual(countAfter, "2", "snapshot commits absorbed into real commit");
+
+    // All files should be present
+    const files = run("git show --name-only HEAD", repo);
+    assert.ok(files.includes("file1.ts"), "file1.ts from snapshot 1 preserved");
+    assert.ok(files.includes("file2.ts"), "file2.ts from snapshot 2 preserved");
+    assert.ok(files.includes("feature.ts"), "feature.ts from real commit preserved");
+
+    // No gsd snapshot commits in log
+    const log = run("git log --oneline", repo);
+    assert.ok(!log.includes("gsd snapshot"), "no gsd snapshot commits remain in history");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  // ─── autoCommit: does not absorb non-snapshot commits ───────────────────
+
+  test('autoCommit: does not absorb non-snapshot commits', () => {
+    const repo = initTempRepo();
+
+    // Create a normal (non-snapshot) commit
+    createFile(repo, "earlier.ts", "earlier work");
+    run("git add -A", repo);
+    run('git commit -m "feat: earlier work"', repo);
+
+    const countBefore = run("git rev-list --count HEAD", repo);
+    assert.deepStrictEqual(countBefore, "2", "precondition: 2 commits before autoCommit");
+
+    // Make a real change and autoCommit
+    createFile(repo, "feature.ts", "new work");
+
+    const svc = new GitServiceImpl(repo);
+    svc.autoCommit("execute-task", "S01/T02");
+
+    // Should be 3 commits — earlier commit not absorbed
+    const countAfter = run("git rev-list --count HEAD", repo);
+    assert.deepStrictEqual(countAfter, "3", "non-snapshot commits NOT absorbed");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
 });