gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

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

@@ -11,10 +11,6 @@ import {
   diagnoseExpectedArtifact,
   buildLoopRemediationSteps,
   selfHealRuntimeRecords,
-  completedKeysPath,
-  persistCompletedKey,
-  removePersistedKey,
-  loadPersistedKeys,
 } from "../auto-recovery.ts";
 import { parseRoadmap, clearParseCache } from "../files.ts";
 import { invalidateAllCaches } from "../cache.ts";
@@ -201,143 +197,6 @@ test("buildLoopRemediationSteps returns null for unknown type", () => {
   }
 });
 
-// ─── Completed-unit key persistence ───────────────────────────────────────
-
-test("completedKeysPath returns path inside .gsd", () => {
-  const path = completedKeysPath("/project");
-  assert.ok(path.includes(".gsd"));
-  assert.ok(path.includes("completed-units.json"));
-});
-
-test("persistCompletedKey and loadPersistedKeys round-trip", () => {
-  const base = makeTmpBase();
-  try {
-    persistCompletedKey(base, "execute-task/M001/S01/T01");
-    persistCompletedKey(base, "plan-slice/M001/S02");
-
-    const keys = new Set<string>();
-    loadPersistedKeys(base, keys);
-
-    assert.ok(keys.has("execute-task/M001/S01/T01"));
-    assert.ok(keys.has("plan-slice/M001/S02"));
-    assert.equal(keys.size, 2);
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("persistCompletedKey is idempotent", () => {
-  const base = makeTmpBase();
-  try {
-    persistCompletedKey(base, "execute-task/M001/S01/T01");
-    persistCompletedKey(base, "execute-task/M001/S01/T01");
-
-    const keys = new Set<string>();
-    loadPersistedKeys(base, keys);
-    assert.equal(keys.size, 1);
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("removePersistedKey removes a key", () => {
-  const base = makeTmpBase();
-  try {
-    persistCompletedKey(base, "a");
-    persistCompletedKey(base, "b");
-    removePersistedKey(base, "a");
-
-    const keys = new Set<string>();
-    loadPersistedKeys(base, keys);
-    assert.ok(!keys.has("a"));
-    assert.ok(keys.has("b"));
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("loadPersistedKeys handles missing file gracefully", () => {
-  const base = makeTmpBase();
-  try {
-    const keys = new Set<string>();
-    assert.doesNotThrow(() => loadPersistedKeys(base, keys));
-    assert.equal(keys.size, 0);
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("removePersistedKey is safe when file doesn't exist", () => {
-  const base = makeTmpBase();
-  try {
-    assert.doesNotThrow(() => removePersistedKey(base, "nonexistent"));
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── Dual-load across worktree boundary (#769) ───────────────────────────
-
-test("loadPersistedKeys unions keys from project root and worktree", () => {
-  // Simulate two separate .gsd directories (project root + worktree)
-  // each with a different set of completed keys. Loading from both
-  // into the same Set should produce the union.
-  const projectRoot = makeTmpBase();
-  const worktree = makeTmpBase();
-  try {
-    // Persist different keys in each location
-    persistCompletedKey(projectRoot, "execute-task/M001/S01/T01");
-    persistCompletedKey(projectRoot, "plan-slice/M001/S02");
-
-    persistCompletedKey(worktree, "execute-task/M001/S01/T02");
-    persistCompletedKey(worktree, "plan-slice/M001/S02"); // overlap
-
-    // Load from both into the same set (mimicking startup dual-load)
-    const keys = new Set<string>();
-    loadPersistedKeys(projectRoot, keys);
-    loadPersistedKeys(worktree, keys);
-
-    assert.ok(keys.has("execute-task/M001/S01/T01"), "key from project root");
-    assert.ok(keys.has("plan-slice/M001/S02"), "shared key");
-    assert.ok(keys.has("execute-task/M001/S01/T02"), "key from worktree");
-    assert.equal(keys.size, 3, "union should deduplicate overlapping keys");
-  } finally {
-    cleanup(projectRoot);
-    cleanup(worktree);
-  }
-});
-
-test("completed-units.json set-union merge produces correct result", () => {
-  // Verify that a manual set-union merge correctly merges two JSON arrays
-  // of completed-unit keys.
-  const projectRoot = makeTmpBase();
-  const worktree = makeTmpBase();
-  try {
-    // Write keys to both locations
-    const prKeysFile = join(projectRoot, ".gsd", "completed-units.json");
-    const wtKeysFile = join(worktree, ".gsd", "completed-units.json");
-
-    writeFileSync(prKeysFile, JSON.stringify(["a", "b"]));
-    writeFileSync(wtKeysFile, JSON.stringify(["b", "c", "d"]));
-
-    // Perform a set-union merge of two JSON key arrays
-    const srcKeys: string[] = JSON.parse(readFileSync(wtKeysFile, "utf8"));
-    let dstKeys: string[] = [];
-    if (existsSync(prKeysFile)) {
-      dstKeys = JSON.parse(readFileSync(prKeysFile, "utf8"));
-    }
-    const merged = [...new Set([...dstKeys, ...srcKeys])];
-    writeFileSync(prKeysFile, JSON.stringify(merged, null, 2));
-
-    // Verify the merged result
-    const result: string[] = JSON.parse(readFileSync(prKeysFile, "utf8"));
-    assert.deepStrictEqual(result.sort(), ["a", "b", "c", "d"]);
-  } finally {
-    cleanup(projectRoot);
-    cleanup(worktree);
-  }
-});
-
 // ─── verifyExpectedArtifact: parse cache collision regression ─────────────
 
 test("verifyExpectedArtifact detects roadmap [x] change despite parse cache", () => {
@@ -528,9 +387,9 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", ()
 
 // ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
 
-test("selfHealRuntimeRecords clears stale record when artifact exists at worktree base (#769)", async () => {
-  // Simulate worktree layout: the runtime record AND the artifact both live
-  // under the worktree's .gsd/, not the main project root.
+test("selfHealRuntimeRecords clears stale dispatched records (#769)", async () => {
+  // selfHealRuntimeRecords now only clears stale dispatched records (>1h).
+  // No completedKeySet parameter — deriveState is sole authority.
   const worktreeBase = makeTmpBase();
   const mainBase = makeTmpBase();
   try {
@@ -541,10 +400,6 @@ test("selfHealRuntimeRecords clears stale record when artifact exists at worktre
       phase: "dispatched",
     });
 
-    // Write the UAT result artifact in the worktree .gsd/milestones/
-    const uatPath = join(worktreeBase, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT-RESULT.md");
-    writeFileSync(uatPath, "---\nresult: pass\n---\n# UAT Result\nAll tests passed.\n");
-
     // Verify the runtime record exists before heal
     const before = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
     assert.ok(before, "runtime record should exist before heal");
@@ -555,32 +410,23 @@ test("selfHealRuntimeRecords clears stale record when artifact exists at worktre
       ui: { notify: (msg: string) => { notifications.push(msg); } },
     } as any;
 
-    // Call selfHeal with worktreeBase — this is the fix: using the worktree path
-    // so both the runtime record and artifact are found
-    const completedKeys = new Set<string>();
-    await selfHealRuntimeRecords(worktreeBase, mockCtx, completedKeys);
+    // Call selfHeal with worktreeBase — should clear the stale record
+    await selfHealRuntimeRecords(worktreeBase, mockCtx);
 
     // The stale record should be cleared
     const after = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
     assert.equal(after, null, "runtime record should be cleared after heal");
-
-    // The completion key should be persisted
-    assert.ok(completedKeys.has("run-uat/M001/S01"), "completion key should be added");
     assert.ok(notifications.some(n => n.includes("Self-heal")), "should emit self-heal notification");
 
-    // Now verify that calling with mainBase does NOT find/clear anything (the old bug)
-    // Write a stale record at mainBase but NO artifact there
+    // Write a stale record at mainBase
     writeUnitRuntimeRecord(mainBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
       phase: "dispatched",
     });
-    const mainKeys = new Set<string>();
-    await selfHealRuntimeRecords(mainBase, mockCtx, mainKeys);
+    await selfHealRuntimeRecords(mainBase, mockCtx);
 
-    // The record at mainBase should be cleared by the stale timeout (>1h),
-    // but the completion key should NOT be set (artifact doesn't exist at mainBase)
+    // The record at mainBase should also be cleared by the stale timeout (>1h)
     const afterMain = readUnitRuntimeRecord(mainBase, "run-uat", "M001/S01");
     assert.equal(afterMain, null, "stale record at main base should be cleared by timeout");
-    assert.ok(!mainKeys.has("run-uat/M001/S01"), "completion key should NOT be set when artifact is missing");
   } finally {
     cleanup(worktreeBase);
     cleanup(mainBase);

package/src/resources/extensions/gsd/tests/auto-secrets-gate.test.ts

@@ -2,11 +2,10 @@
  * Integration tests for the secrets collection gate in startAuto().
  *
  * Exercises getManifestStatus() → collectSecretsFromManifest() composition
- * end-to-end using real filesystem state. Proves the gate paths:
+ * end-to-end using real filesystem state. Proves the three gate paths:
  *   1. No manifest exists — gate skips silently
- *   2. Pending keys exist — gate triggers collection (direct call)
+ *   2. Pending keys exist — gate triggers collection
  *   3. No pending keys — gate skips silently
- *   4. Pending keys in auto-mode — session pauses instead of blocking (#1146)
  *
  * Uses temp directories with real .gsd/milestones/M001/ structure, mirroring
  * the pattern from manifest-status.test.ts.
@@ -19,7 +18,6 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { getManifestStatus } from '../files.ts';
 import { collectSecretsFromManifest } from '../../get-secrets-from-user.ts';
-import { AutoSession } from '../auto/session.ts';
 
 function makeTempDir(prefix: string): string {
   const dir = join(tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -148,110 +146,6 @@ test('secrets gate: pending keys exist — gate triggers collection, manifest up
 
 // ─── Scenario 3: No pending keys — all collected or in env ──────────────────
 
-// ─── Scenario 4: Pending keys pause AutoSession instead of blocking (#1146) ──
-
-test('secrets gate: pending keys set pausedForSecrets on AutoSession', async () => {
-  const tmp = makeTempDir('gate-pause-session');
-  try {
-    // Ensure pending keys are NOT in env
-    delete process.env.GSD_PAUSE_TEST_KEY_A;
-    delete process.env.GSD_PAUSE_TEST_KEY_B;
-
-    writeManifest(tmp, `# Secrets Manifest
-
-**Milestone:** M001
-**Generated:** 2025-06-20T10:00:00Z
-
-### GSD_PAUSE_TEST_KEY_A
-
-**Service:** ServiceA
-**Status:** pending
-**Destination:** dotenv
-
-1. Get key A from dashboard
-
-### GSD_PAUSE_TEST_KEY_B
-
-**Service:** ServiceB
-**Status:** pending
-**Destination:** dotenv
-
-1. Get key B from dashboard
-`);
-
-    // Verify manifest has pending keys
-    const status = await getManifestStatus(tmp, 'M001');
-    assert.notStrictEqual(status, null, 'manifest should exist');
-    assert.deepStrictEqual(status!.pending, ['GSD_PAUSE_TEST_KEY_A', 'GSD_PAUSE_TEST_KEY_B']);
-
-    // Simulate what auto-start.ts now does: set pause flags on session
-    const session = new AutoSession();
-    session.active = true;
-    session.currentMilestoneId = 'M001';
-
-    // The new gate logic: if pending keys exist, pause instead of collecting
-    if (status!.pending.length > 0) {
-      session.paused = true;
-      session.pausedForSecrets = true;
-    }
-
-    assert.strictEqual(session.paused, true, 'session should be paused');
-    assert.strictEqual(session.pausedForSecrets, true, 'pausedForSecrets flag should be set');
-
-    // Verify reset() clears pausedForSecrets
-    session.reset();
-    assert.strictEqual(session.pausedForSecrets, false, 'reset() should clear pausedForSecrets');
-  } finally {
-    delete process.env.GSD_PAUSE_TEST_KEY_A;
-    delete process.env.GSD_PAUSE_TEST_KEY_B;
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test('secrets gate: no pending keys do not set pausedForSecrets', async () => {
-  const tmp = makeTempDir('gate-no-pause');
-  const savedKey = process.env.GSD_NO_PAUSE_TEST_KEY;
-  try {
-    process.env.GSD_NO_PAUSE_TEST_KEY = 'already-set';
-
-    writeManifest(tmp, `# Secrets Manifest
-
-**Milestone:** M001
-**Generated:** 2025-06-20T10:00:00Z
-
-### GSD_NO_PAUSE_TEST_KEY
-
-**Service:** ServiceX
-**Status:** pending
-**Destination:** dotenv
-
-1. Already in env
-`);
-
-    const status = await getManifestStatus(tmp, 'M001');
-    assert.notStrictEqual(status, null, 'manifest should exist');
-    assert.deepStrictEqual(status!.pending, [], 'no pending keys — already in env');
-
-    // Simulate gate logic — no pending keys, no pause
-    const session = new AutoSession();
-    session.active = true;
-
-    if (status!.pending.length > 0) {
-      session.paused = true;
-      session.pausedForSecrets = true;
-    }
-
-    assert.strictEqual(session.paused, false, 'session should NOT be paused');
-    assert.strictEqual(session.pausedForSecrets, false, 'pausedForSecrets should NOT be set');
-  } finally {
-    delete process.env.GSD_NO_PAUSE_TEST_KEY;
-    if (savedKey !== undefined) process.env.GSD_NO_PAUSE_TEST_KEY = savedKey;
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-// ─── Scenario 3: No pending keys — all collected or in env ──────────────────
-
 test('secrets gate: no pending keys — getManifestStatus shows pending.length === 0', async () => {
   const tmp = makeTempDir('gate-no-pending');
   const savedKey = process.env.GSD_GATE_TEST_ENVKEY;

package/src/resources/extensions/gsd/tests/auto-session-encapsulation.test.ts

@@ -145,8 +145,7 @@ test("AutoSession.reset() references every instance property", () => {
   assert.ok(resetMatch, "AutoSession.reset() method not found");
   const resetBody = resetMatch![1]!;
 
-  // completedKeySet is intentionally not cleared (documented in reset())
-  const intentionallySkipped = new Set(["completedKeySet"]);
+  const intentionallySkipped = new Set<string>([]);
 
   const missingFromReset: string[] = [];
   for (const prop of properties) {
@@ -182,7 +181,6 @@ test("AutoSession.toJSON() includes key diagnostic properties", () => {
     "basePath",
     "currentMilestoneId",
     "currentUnit",
-    "dispatching",
   ];
 
   const missing = requiredDiagnostics.filter(prop => !toJSONBody.includes(prop));

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

@@ -32,9 +32,6 @@ function createTempRepo(): string {
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
   writeFileSync(join(dir, "README.md"), "# test\n");
-  // Mirror production: GSD runtime dirs are gitignored so autoCommitDirtyState
-  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
-  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
   run("git add .", dir);

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

@@ -153,6 +153,64 @@ async function main(): Promise<void> {
     // After teardown, originalBase should be null
     assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
 
+    // ─── #778: reconcile plan checkboxes on re-attach ─────────────────
+    console.log("\n=== #778: reconcile plan checkboxes on re-attach ===");
+    {
+      // Simulate: T01 [x] was committed to milestone branch, T02 [x] was
+      // written to project root by syncStateToProjectRoot() but the
+      // auto-commit crashed before it fired. On restart the worktree is
+      // re-created from the milestone branch HEAD (T02 still [ ]).
+      // reconcilePlanCheckboxes should forward-apply T02 [x] from the root.
+
+      const planRelPath = join(".gsd", "milestones", "M004", "slices", "S01", "S01-PLAN.md");
+      const planDir = join(tempDir, ".gsd", "milestones", "M004", "slices", "S01");
+      const { mkdirSync: mkdir, writeFileSync: write, readFileSync: read } = await import("node:fs");
+
+      // Plan on integration branch (project root): T01 [x], T02 [x]
+      mkdir(planDir, { recursive: true });
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+
+      // Write integration-branch plan to git so milestone branch starts from it
+      run(`git add .`, tempDir);
+      run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
+
+      // Create milestone branch with only T01 [x] (simulating crash before T02 commit)
+      const milestoneBranch = "milestone/M004";
+      run(`git checkout -b ${milestoneBranch}`, tempDir);
+      mkdir(planDir, { recursive: true });
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [ ] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+      run(`git add .`, tempDir);
+      run(`git commit -m "milestone: only T01 checked"`, tempDir);
+      run(`git checkout main`, tempDir);
+
+      // Restore project root plan (T01+T02 [x]) — simulates syncStateToProjectRoot
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+
+      // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
+      const wtPath = createAutoWorktree(tempDir, "M004");
+
+      try {
+        const wtPlanPath = join(wtPath, planRelPath);
+        assertTrue(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
+
+        const wtPlan = read(wtPlanPath, "utf-8");
+        assertTrue(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
+        assertTrue(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
+        assertTrue(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
+      } finally {
+        teardownAutoWorktree(tempDir, "M004");
+      }
+    }
+
   } finally {
     // Always restore cwd and clean up
     process.chdir(savedCwd);

package/src/resources/extensions/gsd/tests/dispatch-guard.test.ts

@@ -71,58 +71,3 @@ test("dispatch guard works without git repo", () => {
     rmSync(repo, { recursive: true, force: true });
   }
 });
-
-test("dispatch guard skips parked milestones — they do not block later milestones", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-parked-"));
-  try {
-    // M004 is parked with incomplete slices
-    mkdirSync(join(repo, ".gsd", "milestones", "M004"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M004", "M004-ROADMAP.md"),
-      "# M004: Parked Milestone\n\n## Slices\n- [ ] **S01: Unfinished** `risk:high` `depends:[]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M004", "M004-PARKED.md"),
-      "---\nparked_at: 2026-03-18T09:00:00.000Z\nreason: \"Parked via /gsd park\"\n---\n\n# M004 — Parked\n");
-
-    // M010 is the target milestone
-    mkdirSync(join(repo, ".gsd", "milestones", "M010"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M010", "M010-ROADMAP.md"),
-      "# M010: Active Milestone\n\n## Slices\n- [ ] **S01: First** `risk:high` `depends:[]`\n");
-
-    // M004's incomplete S01 should NOT block M010/S01 because M004 is parked
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M010/S01"),
-      null,
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
-});
-
-test("dispatch guard still blocks on non-parked incomplete milestones", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-mixed-"));
-  try {
-    // M003 is parked — should be skipped
-    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Parked\n\n## Slices\n- [ ] **S01: Unfinished** `risk:high` `depends:[]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-PARKED.md"),
-      "---\nparked_at: 2026-03-18T09:00:00.000Z\nreason: \"Parked\"\n---\n");
-
-    // M005 is NOT parked and has incomplete slices — should block
-    mkdirSync(join(repo, ".gsd", "milestones", "M005"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M005", "M005-ROADMAP.md"),
-      "# M005: Active Incomplete\n\n## Slices\n- [ ] **S01: Pending** `risk:low` `depends:[]`\n");
-
-    // M010 is the target
-    mkdirSync(join(repo, ".gsd", "milestones", "M010"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M010", "M010-ROADMAP.md"),
-      "# M010: Target\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n");
-
-    // M005/S01 should block M010/S01 (M003 is parked, so skipped)
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M010/S01"),
-      "Cannot dispatch plan-slice M010/S01: earlier slice M005/S01 is not complete.",
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
-});

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

@@ -159,4 +159,26 @@ describe('headless query', () => {
     assert.equal(snap.state.activeMilestone!.id, 'M001')
     assert.equal(snap.next.action, 'dispatch')
   })
+
+  it('reports all milestones complete with a clean stop reason', async () => {
+    writeRoadmap(base, 'M001', `# M001: Test Milestone
+
+## Slices
+
+- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > Done.
+`)
+    writeFileSync(
+      join(base, '.gsd', 'milestones', 'M001', 'M001-SUMMARY.md'),
+      '# M001 Summary\n\nComplete.',
+    )
+
+    const result = await handleQuery(base)
+    const snap = result.data as QuerySnapshot
+
+    assert.equal(result.exitCode, 0)
+    assert.equal(snap.state.phase, 'complete')
+    assert.equal(snap.next.action, 'stop')
+    assert.equal(snap.next.reason, 'All milestones complete.')
+  })
 })

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

@@ -38,9 +38,6 @@ function createTempRepo(): string {
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
   writeFileSync(join(dir, "README.md"), "# test\n");
-  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
-  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
-  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   run("git add .", dir);
   run("git commit -m init", dir);
   run("git branch -M main", dir);
@@ -125,23 +122,23 @@ test("worktree swap on milestone transition: merge old, create new", () => {
 
 // ─── Verify the transition code path exists in auto.ts ──────────────────────
 
-test("auto.ts milestone transition block contains worktree lifecycle", () => {
+test("auto-loop.ts milestone transition block contains worktree lifecycle", () => {
   const autoSrc = readFileSync(
-    join(__dirname, "..", "auto.ts"),
+    join(__dirname, "..", "auto-loop.ts"),
     "utf-8",
   );
 
-  // The fix adds worktree merge + create inside the milestone transition block
+  // The resolver handles worktree merge + enter inside the milestone transition block
   assert.ok(
     autoSrc.includes("Worktree lifecycle on milestone transition"),
-    "auto.ts should contain the worktree lifecycle comment marker",
+    "auto-loop.ts should contain the worktree lifecycle comment marker",
   );
   assert.ok(
-    autoSrc.includes("mergeMilestoneToMain") && autoSrc.includes("mid !== s.currentMilestoneId"),
-    "auto.ts should call mergeMilestoneToMain during milestone transition",
+    autoSrc.includes("resolver.mergeAndExit") && autoSrc.includes("mid !== s.currentMilestoneId"),
+    "auto-loop.ts should call resolver.mergeAndExit during milestone transition",
   );
   assert.ok(
-    autoSrc.includes("createAutoWorktree") && autoSrc.includes("Created auto-worktree for"),
-    "auto.ts should create new worktree for incoming milestone",
+    autoSrc.includes("resolver.enterMilestone"),
+    "auto-loop.ts should call resolver.enterMilestone for incoming milestone",
   );
 });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -277,13 +277,11 @@ test("index.ts tracks consecutive transient errors for escalating backoff", () =
 test("index.ts resets consecutive transient error counter on success", () => {
   const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
 
-  // After successful unit completion, the counter must be reset
-  const marker = "successful unit completion";
-  const successSection = indexSource.indexOf(marker);
-  assert.ok(successSection > -1, "must have success section that clears network retries");
-  const nearbyCode = indexSource.slice(Math.max(0, successSection - 100), successSection + 200);
+  // After successful unit completion, the counter must be reset.
+  // Use a regex across the success block so CRLF checkouts on Windows do not
+  // push the reset line outside a fixed substring window.
   assert.ok(
-    nearbyCode.includes("consecutiveTransientErrors = 0"),
+    /consecutiveTransientErrors\s*=\s*0\s*;[\s\S]{0,250}successful unit completion/.test(indexSource),
     "consecutive transient error counter must be reset on successful unit completion (#1166)",
   );
 });

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -334,7 +334,7 @@ async function main(): Promise<void> {
         ].join('\n'),
       );
 
-      // human-experience UAT — should not dispatch
+      // human-experience UAT still dispatches, but auto-mode later pauses for manual review
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
 
       const state = {
@@ -351,8 +351,8 @@ async function main(): Promise<void> {
       const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
       assertEq(
         result,
-        null,
-        'human-experience UAT is skipped — auto-mode only dispatches artifact-driven UATs',
+        { sliceId: 'S01', uatType: 'human-experience' },
+        'human-experience UAT dispatches so auto-mode can pause for manual review',
       );
     } finally {
       cleanup(base);