gsd-pi 2.48.0-dev.ced2eca → 2.49.0-dev.9e177e9

package/src/resources/extensions/gsd/templates/task-plan.md

@@ -17,6 +17,30 @@ skills_used:
 
 {{description}}
 
+## Failure Modes
+
+<!-- Q5: What breaks when dependencies fail? OMIT ENTIRELY for tasks with no external dependencies. -->
+
+| Dependency | On error | On timeout | On malformed response |
+|------------|----------|-----------|----------------------|
+| {{dependency}} | {{errorStrategy}} | {{timeoutStrategy}} | {{malformedStrategy}} |
+
+## Load Profile
+
+<!-- Q6: What breaks at 10x load? OMIT ENTIRELY for tasks with no shared resources or scaling concerns. -->
+
+- **Shared resources**: {{sharedResources — DB connections, caches, rate limiters, or none}}
+- **Per-operation cost**: {{perOpCost — N API calls, M DB queries, K bytes, or trivial}}
+- **10x breakpoint**: {{whatBreaksFirst — pool exhaustion, rate limit, memory, or N/A}}
+
+## Negative Tests
+
+<!-- Q7: What negative tests prove robustness? OMIT ENTIRELY for trivial tasks. -->
+
+- **Malformed inputs**: {{malformedInputTests — empty string, null, oversized, wrong type}}
+- **Error paths**: {{errorPathTests — network timeout, auth failure, 5xx, invalid JSON}}
+- **Boundary conditions**: {{boundaryTests — empty list, max length, zero, off-by-one}}
+
 ## Steps
 
 1. {{step}}

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -116,7 +116,7 @@ test("auto-timers.ts idle watchdog catch calls resolveAgentEndCancelled", () =>
   // Check that resolveAgentEndCancelled is called near this catch
   const catchRegion = source.slice(Math.max(0, idleCatchIdx - 200), idleCatchIdx + 200);
   assert.ok(
-    catchRegion.includes("resolveAgentEndCancelled()"),
+    catchRegion.includes("resolveAgentEndCancelled("),
     "idle watchdog catch block must call resolveAgentEndCancelled",
   );
 });
@@ -129,7 +129,7 @@ test("auto-timers.ts hard timeout catch calls resolveAgentEndCancelled", () => {
   assert.ok(hardCatchIdx > -1, "hard timeout catch block must exist");
   const catchRegion = source.slice(Math.max(0, hardCatchIdx - 200), hardCatchIdx + 200);
   assert.ok(
-    catchRegion.includes("resolveAgentEndCancelled()"),
+    catchRegion.includes("resolveAgentEndCancelled("),
     "hard timeout catch block must call resolveAgentEndCancelled",
   );
 });

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

@@ -1745,6 +1745,41 @@ test("resolveAgentEndCancelled prevents orphaned promise after abort path", asyn
   assert.equal(result.status, "cancelled");
 });
 
+test("resolveAgentEndCancelled with errorContext passes it through to resolved promise", async () => {
+  _resetPendingResolve();
+
+  const { _setCurrentResolve } = await import("../auto/resolve.js");
+
+  const p = new Promise<UnitResult>((r) => {
+    _setCurrentResolve(r);
+  });
+
+  resolveAgentEndCancelled({ message: "test timeout", category: "timeout", isTransient: true });
+
+  const resolved = await p;
+  assert.equal(resolved.status, "cancelled");
+  assert.ok(resolved.errorContext, "errorContext must be present");
+  assert.equal(resolved.errorContext!.category, "timeout");
+  assert.equal(resolved.errorContext!.message, "test timeout");
+  assert.equal(resolved.errorContext!.isTransient, true);
+});
+
+test("resolveAgentEndCancelled without args produces no errorContext field", async () => {
+  _resetPendingResolve();
+
+  const { _setCurrentResolve } = await import("../auto/resolve.js");
+
+  const p = new Promise<UnitResult>((r) => {
+    _setCurrentResolve(r);
+  });
+
+  resolveAgentEndCancelled();
+
+  const resolved = await p;
+  assert.equal(resolved.status, "cancelled");
+  assert.equal(resolved.errorContext, undefined, "errorContext must not be present when no args passed");
+});
+
 // ─── #1571: artifact verification retry ──────────────────────────────────────
 
 test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)", async () => {

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

@@ -10,7 +10,6 @@ import {
   verifyExpectedArtifact,
   diagnoseExpectedArtifact,
   buildLoopRemediationSteps,
-  selfHealRuntimeRecords,
   hasImplementationArtifacts,
 } from "../auto-recovery.ts";
 import { parseRoadmap, parsePlan } from "../parsers-legacy.ts";
@@ -112,7 +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("UAT-RESULT"));
+  assert.ok(uatResult!.includes("UAT"));
 });
 
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
@@ -572,85 +571,6 @@ test("verifyExpectedArtifact plan-slice fails after deleting a rendered task pla
   }
 });
 
-// ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
-
-test("selfHealRuntimeRecords clears stale dispatched records (#769)", async (t) => {
-  // selfHealRuntimeRecords now only clears stale dispatched records (>1h).
-  // No completedKeySet parameter — deriveState is sole authority.
-  const worktreeBase = makeTmpBase();
-  const mainBase = makeTmpBase();
-  t.after(() => {
-    cleanup(worktreeBase);
-    cleanup(mainBase);
-  });
-
-  const { writeUnitRuntimeRecord, readUnitRuntimeRecord } = await import("../unit-runtime.ts");
-
-  // Write a stale runtime record in the worktree .gsd/runtime/units/
-  writeUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
-    phase: "dispatched",
-  });
-
-  // Verify the runtime record exists before heal
-  const before = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
-  assert.ok(before, "runtime record should exist before heal");
-
-  // Mock ExtensionContext with minimal notify
-  const notifications: string[] = [];
-  const mockCtx = {
-    ui: { notify: (msg: string) => { notifications.push(msg); } },
-  } as any;
-
-  // 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");
-  assert.ok(notifications.some(n => n.includes("Self-heal")), "should emit self-heal notification");
-
-  // Write a stale record at mainBase
-  writeUnitRuntimeRecord(mainBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
-    phase: "dispatched",
-  });
-  await selfHealRuntimeRecords(mainBase, mockCtx);
-
-  // 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");
-});
-
-// ─── #1625: selfHealRuntimeRecords on resume clears paused-session leftovers ──
-
-test("selfHealRuntimeRecords clears recently-paused dispatched records on resume (#1625)", async (t) => {
-  // When pauseAuto closes out a unit but clearUnitRuntimeRecord silently fails
-  // (e.g. permission error), selfHealRuntimeRecords on resume should still
-  // clean up stale dispatched records that are >1h old.
-  const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const { writeUnitRuntimeRecord, readUnitRuntimeRecord } = await import("../unit-runtime.ts");
-
-  // Simulate a record left behind after a pause — aged >1h to be considered stale
-  writeUnitRuntimeRecord(base, "execute-task", "M001/S01/T01", Date.now() - 3700_000, {
-    phase: "dispatched",
-  });
-
-  const before = readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01");
-  assert.ok(before, "dispatched record should exist before resume heal");
-  assert.equal(before!.phase, "dispatched");
-
-  const notifications: string[] = [];
-  const mockCtx = {
-    ui: { notify: (msg: string) => { notifications.push(msg); } },
-  } as any;
-
-  await selfHealRuntimeRecords(base, mockCtx);
-
-  const after = readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01");
-  assert.equal(after, null, "stale dispatched record should be cleared on resume (#1625)");
-});
-
 // ─── #793: invalidateAllCaches unblocks skip-loop ─────────────────────────
 // When the skip-loop breaker fires, it must call invalidateAllCaches() (not
 // just invalidateStateCache()) to clear path/parse caches that deriveState

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v10 after M001 planning migrations)
+  // Verify schema version is current (v12 after quality gates table)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 11, 'schema version should be 11');
+  assertEq(versionRow?.['v'], 12, 'schema version should be 12');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v11 after state machine migration)
+  // Verify schema version is current (v12 after quality gates table)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 11, 'schema version should be 11');
+  assertEq(versionRow?.['v'], 12, 'schema version should be 12');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -48,35 +48,32 @@ test("#2313: completed-units.json should not be blindly wiped to [] on milestone
 // ─── Bug 2: metrics.json should be in the sync file lists ──────────────────
 
 test("#2313: syncStateToProjectRoot should sync metrics.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree-sync.ts");
+  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
   const syncSrc = readFileSync(syncSrcPath, "utf-8");
 
   // syncStateToProjectRoot should copy metrics.json from worktree to project root
   assert.ok(
     syncSrc.includes("metrics.json"),
-    "auto-worktree-sync.ts should reference metrics.json for sync",
+    "auto-worktree.ts should reference metrics.json for sync",
   );
 });
 
-test("#2313: syncWorktreeStateBack should include metrics.json in root files list", () => {
+test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_STATE_FILES", () => {
   const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
   const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
 
-  // Find the rootFiles array in syncWorktreeStateBack
-  const syncBackIdx = autoWorktreeSrc.indexOf("syncWorktreeStateBack");
-  assert.ok(syncBackIdx !== -1, "syncWorktreeStateBack exists");
+  // Find the ROOT_STATE_FILES constant (single source of truth for both sync directions)
+  const constIdx = autoWorktreeSrc.indexOf("ROOT_STATE_FILES");
+  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
 
-  const rootFilesIdx = autoWorktreeSrc.indexOf("rootFiles", syncBackIdx);
-  assert.ok(rootFilesIdx !== -1, "rootFiles list exists in syncWorktreeStateBack");
-
-  // Get the rootFiles array content
-  const arrayStart = autoWorktreeSrc.indexOf("[", rootFilesIdx);
+  // Get the array content
+  const arrayStart = autoWorktreeSrc.indexOf("[", constIdx);
   const arrayEnd = autoWorktreeSrc.indexOf("]", arrayStart);
   const rootFilesBlock = autoWorktreeSrc.slice(arrayStart, arrayEnd);
 
   assert.ok(
     rootFilesBlock.includes("metrics.json"),
-    "metrics.json should be in syncWorktreeStateBack rootFiles list",
+    "metrics.json should be in ROOT_STATE_FILES list",
   );
 });
 

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

@@ -15,7 +15,7 @@ import assert from 'node:assert/strict';
  *   - Report formatting
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, utimesSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -102,6 +102,120 @@ describe('doctor-environment', async () => {
       assert.deepStrictEqual(depsCheck!.status, "ok", "existing node_modules is ok");
     });
 
+    // ── Stale Dependencies: marker file check (#1974) ──────────────────
+    console.log("\n=== env: npm marker file newer than lockfile → ok (#1974) ===");
+    {
+      // Simulate the exact bug scenario:
+      // 1. node_modules dir mtime is old (no entries added/removed recently)
+      // 2. package-lock.json mtime is recent (npm rewrote it)
+      // 3. node_modules/.package-lock.json mtime is between dir and lockfile
+      //    (npm wrote it during the same install that rewrote the lockfile)
+      //
+      // The bug: code compares lockfile mtime vs dir mtime → false positive warning
+      // The fix: compare lockfile mtime vs marker file mtime → correctly ok
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+
+      // Simulate the exact bug: npm install with "up to date" rewrites the
+      // lockfile and the marker, but no packages are added/removed so the
+      // directory mtime should be old. We write the marker first (which
+      // bumps dir mtime), then force the dir mtime back to the past.
+      //
+      // Timeline: dir(T-120s) < lockfile(T-5s) ≈ marker(T-5s)
+      // Bug: code compares lockfile vs dir → false positive stale warning
+      // Fix: code compares lockfile vs marker → correctly reports ok
+      const dirTime = new Date(Date.now() - 120_000);
+      const installTime = new Date(Date.now() - 5_000);
+
+      // Write marker file (this bumps dir mtime as a side effect)
+      writeFileSync(join(dir, "node_modules", ".package-lock.json"), "{}");
+      utimesSync(join(dir, "node_modules", ".package-lock.json"), installTime, installTime);
+
+      // Force dir mtime back to the past — simulates no top-level entries changed
+      utimesSync(join(dir, "node_modules"), dirTime, dirTime);
+
+      // Lockfile written at install time (same as marker, or slightly after)
+      writeFileSync(join(dir, "package-lock.json"), "{}");
+      utimesSync(join(dir, "package-lock.json"), installTime, installTime);
+
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.equal(depsCheck!.status, "ok", "npm marker newer than lockfile → not stale");
+    }
+
+    console.log("\n=== env: yarn marker file newer than lockfile → ok (#1974) ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+
+      const dirTime = new Date(Date.now() - 120_000);
+      const installTime = new Date(Date.now() - 5_000);
+
+      writeFileSync(join(dir, "node_modules", ".yarn-integrity"), "{}");
+      utimesSync(join(dir, "node_modules", ".yarn-integrity"), installTime, installTime);
+      utimesSync(join(dir, "node_modules"), dirTime, dirTime);
+
+      writeFileSync(join(dir, "yarn.lock"), "");
+      utimesSync(join(dir, "yarn.lock"), installTime, installTime);
+
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.equal(depsCheck!.status, "ok", "yarn marker newer than lockfile → not stale");
+    }
+
+    console.log("\n=== env: pnpm marker file newer than lockfile → ok (#1974) ===");
+    {
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+
+      const dirTime = new Date(Date.now() - 120_000);
+      const installTime = new Date(Date.now() - 5_000);
+
+      writeFileSync(join(dir, "node_modules", ".modules.yaml"), "{}");
+      utimesSync(join(dir, "node_modules", ".modules.yaml"), installTime, installTime);
+      utimesSync(join(dir, "node_modules"), dirTime, dirTime);
+
+      writeFileSync(join(dir, "pnpm-lock.yaml"), "");
+      utimesSync(join(dir, "pnpm-lock.yaml"), installTime, installTime);
+
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.equal(depsCheck!.status, "ok", "pnpm marker newer than lockfile → not stale");
+    }
+
+    console.log("\n=== env: no marker file falls back to dir mtime → stale warning (#1974) ===");
+    {
+      // No marker file exists, lockfile newer than dir → should still warn
+      const dir = createProjectDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      mkdirSync(join(dir, "node_modules"), { recursive: true });
+
+      const past = new Date(Date.now() - 60_000);
+      utimesSync(join(dir, "node_modules"), past, past);
+
+      writeFileSync(join(dir, "package-lock.json"), "{}");
+      // No marker file written — fallback to dir mtime comparison
+
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.equal(depsCheck!.status, "warning", "no marker + lockfile newer → stale warning");
+    }
+
     // ── Env File Check ─────────────────────────────────────────────────
     test('env: .env.example without .env detected', () => {
       const dir = createProjectDir({

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

@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
 import { runGSDDoctor } from "../doctor.ts";
+import { closeDatabase } from "../gsd-db.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-fixlevel-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -112,6 +113,70 @@ test("fixLevel:all — no reconciliation issue codes are reported", async (t) =>
   assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap should remain unchecked");
 });
 
+test("legacy roadmap fallback: future slices are treated as pending, active slice is not", async (t) => {
+  const tmp = makeTmp("legacy-pending-fallback");
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  // Force the legacy parser branch.
+  try { closeDatabase(); } catch { /* noop */ }
+
+  const gsd = join(tmp, ".gsd");
+  const m = join(gsd, "milestones", "M001");
+  const s01 = join(m, "slices", "S01", "tasks");
+  mkdirSync(s01, { recursive: true });
+
+  writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [x] **S01: Done Slice** \`risk:low\` \`depends:[]\`
+  > Done
+- [ ] **S02: Active Slice** \`risk:medium\` \`depends:[S01]\`
+  > In progress
+- [ ] **S03: Future Slice** \`risk:low\` \`depends:[S02]\`
+  > Later
+- [ ] **S04: Future Slice Two** \`risk:low\` \`depends:[S03]\`
+  > Later
+`);
+
+  writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Done Slice
+
+**Goal:** done
+
+## Tasks
+
+- [x] **T01: Done task** \`est:5m\`
+`);
+
+  // Active slice exists in state/registry but has no directory yet — this should
+  // still be reported as a real error, while future untouched slices should be skipped.
+  const report = await runGSDDoctor(tmp, { scope: "M001" });
+  const missingSliceDirUnits = report.issues
+    .filter(i => i.code === "missing_slice_dir")
+    .map(i => i.unitId)
+    .sort();
+
+  assert.deepStrictEqual(
+    missingSliceDirUnits,
+    ["M001/S02"],
+    "legacy fallback should only report the active slice, not future unstarted slices",
+  );
+
+  const missingTasksDirUnits = report.issues
+    .filter(i => i.code === "missing_tasks_dir")
+    .map(i => i.unitId)
+    .sort();
+
+  assert.deepStrictEqual(
+    missingTasksDirUnits,
+    [],
+    "future slices without directories should be skipped before missing_tasks_dir checks",
+  );
+});
+
 test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
   const tmp = makeTmp("delimiter-fix");
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -141,7 +206,6 @@ test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
 
   const report = await runGSDDoctor(tmp, { fix: true });
 
-  const delimiterIssues = report.issues.filter(i => i.code === "delimiter_in_title");
   // The milestone-level delimiter is auto-fixed, but the report may or may not include it
   // depending on whether it was fixed successfully. Just verify it ran without crashing.
   assert.ok(report.issues !== undefined, "doctor produces a report");

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

@@ -145,6 +145,56 @@ describe('doctor-git', async () => {
     } else {
     }
 
+    // ─── Test 1b: Orphaned worktree fix when cwd is inside worktree (#1946) ──
+    // Reproduces the deadlock: if process.cwd() is inside the orphaned worktree,
+    // the doctor must chdir out before removing it — not skip the removal.
+    if (process.platform !== "win32") {
+    console.log("\n=== orphaned_auto_worktree (cwd inside worktree) ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create worktree with milestone/M001 branch under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const wtPath = realpathSync(join(dir, ".gsd", "worktrees", "M001"));
+
+      // Simulate the deadlock: set cwd inside the orphaned worktree
+      const previousCwd = process.cwd();
+      process.chdir(wtPath);
+      try {
+        const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
+
+        // The fix must NOT skip removal — it should chdir out and remove
+        assert.ok(
+          !fixed.fixesApplied.some(f => f.includes("skipped removing worktree")),
+          "does NOT skip removal when cwd is inside worktree",
+        );
+        assert.ok(
+          fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
+          "removes orphaned worktree even when cwd was inside it",
+        );
+
+        // Verify worktree is gone
+        const wtList = run("git worktree list", dir);
+        assert.ok(!wtList.includes("milestone/M001"), "worktree removed after fix with cwd inside");
+
+        // Verify cwd was moved out (should be basePath, not still inside worktree)
+        const newCwd = process.cwd();
+        assert.ok(
+          !newCwd.startsWith(wtPath),
+          "cwd moved out of worktree after fix",
+        );
+      } finally {
+        // Restore cwd — the worktree dir may be gone, so chdir to previousCwd
+        try { process.chdir(previousCwd); } catch { process.chdir(dir); }
+      }
+    }
+    } else {
+      console.log("\n=== orphaned_auto_worktree (cwd inside worktree — skipped on Windows) ===");
+    }
+
     // ─── Test 2: Stale milestone branch detection & fix ────────────────
     // Skip on Windows: git branch glob matching and path resolution
     // behave differently in Windows temp dirs.