gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

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

@@ -0,0 +1,126 @@
+/**
+ * dispatch-stall-guard.test.ts — Verifies defensive guards against dispatch stalls (#1073).
+ *
+ * After a slice completes, dispatchNextUnit must reliably dispatch the next unit.
+ * These tests verify:
+ * 1. newSession() has timeout protection (prevents permanent hang if session creation stalls)
+ * 2. handleAgentEnd has a dispatch hang guard (catches dispatchNextUnit itself hanging)
+ * 3. Session timeout constants are exported for configurability
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
+const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
+
+function getAutoTsSource(): string {
+  return readFileSync(AUTO_TS_PATH, "utf-8");
+}
+
+function getSessionTsSource(): string {
+  return readFileSync(SESSION_TS_PATH, "utf-8");
+}
+
+// ── Session timeout constants ───────────────────────────────────────────────
+
+test("AutoSession exports NEW_SESSION_TIMEOUT_MS constant", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("NEW_SESSION_TIMEOUT_MS"),
+    "auto/session.ts must export NEW_SESSION_TIMEOUT_MS for newSession() timeout",
+  );
+});
+
+test("AutoSession exports DISPATCH_HANG_TIMEOUT_MS constant", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("DISPATCH_HANG_TIMEOUT_MS"),
+    "auto/session.ts must export DISPATCH_HANG_TIMEOUT_MS for dispatch hang detection",
+  );
+});
+
+test("NEW_SESSION_TIMEOUT_MS is a reasonable value (15-120 seconds)", () => {
+  const source = getSessionTsSource();
+  const match = source.match(/NEW_SESSION_TIMEOUT_MS\s*=\s*(\d[\d_]*)/);
+  assert.ok(match, "NEW_SESSION_TIMEOUT_MS must have a numeric value");
+  const value = parseInt(match![1]!.replace(/_/g, ""), 10);
+  assert.ok(value >= 15_000 && value <= 120_000,
+    `NEW_SESSION_TIMEOUT_MS must be 15-120s, got ${value}ms`,
+  );
+});
+
+test("DISPATCH_HANG_TIMEOUT_MS is greater than NEW_SESSION_TIMEOUT_MS", () => {
+  const source = getSessionTsSource();
+  const sessionMatch = source.match(/NEW_SESSION_TIMEOUT_MS\s*=\s*(\d[\d_]*)/);
+  const dispatchMatch = source.match(/DISPATCH_HANG_TIMEOUT_MS\s*=\s*(\d[\d_]*)/);
+  assert.ok(sessionMatch && dispatchMatch, "Both timeout constants must exist");
+  const sessionTimeout = parseInt(sessionMatch![1]!.replace(/_/g, ""), 10);
+  const dispatchTimeout = parseInt(dispatchMatch![1]!.replace(/_/g, ""), 10);
+  assert.ok(dispatchTimeout > sessionTimeout,
+    `DISPATCH_HANG_TIMEOUT_MS (${dispatchTimeout}) must be > NEW_SESSION_TIMEOUT_MS (${sessionTimeout})`,
+  );
+});
+
+// ── newSession() timeout in dispatchNextUnit ─────────────────────────────────
+
+test("dispatchNextUnit wraps newSession() with Promise.race timeout", () => {
+  const source = getAutoTsSource();
+  // Search the full file — dispatchNextUnit is very large
+  assert.ok(
+    source.includes("Promise.race") && source.includes("NEW_SESSION_TIMEOUT_MS"),
+    "dispatchNextUnit must use Promise.race with NEW_SESSION_TIMEOUT_MS to timeout newSession() (#1073)",
+  );
+});
+
+test("dispatchNextUnit handles newSession() timeout gracefully", () => {
+  const source = getAutoTsSource();
+  // Must notify user when session times out
+  assert.ok(
+    source.includes("Session creation timed out") || source.includes("Session creation failed"),
+    "dispatchNextUnit must notify user when newSession() times out or fails (#1073)",
+  );
+});
+
+// ── Dispatch hang guard in handleAgentEnd ────────────────────────────────────
+
+test("handleAgentEnd has a dispatch hang guard before dispatchNextUnit", () => {
+  const source = getAutoTsSource();
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  assert.ok(fnIdx > -1, "handleAgentEnd must exist");
+
+  // Find the section between step mode check and dispatchNextUnit call
+  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── Step Mode", fnIdx + 100));
+  assert.ok(
+    fnBlock.includes("DISPATCH_HANG_TIMEOUT_MS") || fnBlock.includes("dispatchHangGuard"),
+    "handleAgentEnd must have a dispatch hang guard before calling dispatchNextUnit (#1073)",
+  );
+});
+
+test("dispatch hang guard is cleared in finally block", () => {
+  const source = getAutoTsSource();
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── Step Mode", fnIdx + 100));
+  assert.ok(
+    fnBlock.includes("clearTimeout(dispatchHangGuard)"),
+    "dispatch hang guard must be cleared in finally block to prevent false alarms (#1073)",
+  );
+});
+
+// ── Constants are imported in auto.ts ────────────────────────────────────────
+
+test("auto.ts imports NEW_SESSION_TIMEOUT_MS and DISPATCH_HANG_TIMEOUT_MS", () => {
+  const source = getAutoTsSource();
+  assert.ok(
+    source.includes("NEW_SESSION_TIMEOUT_MS"),
+    "auto.ts must import NEW_SESSION_TIMEOUT_MS from session.ts",
+  );
+  assert.ok(
+    source.includes("DISPATCH_HANG_TIMEOUT_MS"),
+    "auto.ts must import DISPATCH_HANG_TIMEOUT_MS from session.ts",
+  );
+});

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -10,11 +10,15 @@ export function resolve(specifier, context, nextResolve) {
     specifier = new URL("packages/pi-ai/dist/index.js", ROOT).href;
   } else if (specifier === "@gsd/pi-agent-core") {
     specifier = new URL("packages/pi-agent-core/dist/index.js", ROOT).href;
-  } 
-  // 2. Mapping .js to .ts for local imports when running tests from src/
+  }
+  // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types
   else if (specifier.endsWith('.js') && (specifier.startsWith('./') || specifier.startsWith('../'))) {
     if (context.parentURL && context.parentURL.includes('/src/')) {
-      specifier = specifier.replace(/\.js$/, '.ts');
+      if (specifier.includes('/dist/')) {
+        specifier = specifier.replace('/dist/', '/src/').replace(/\.js$/, '.ts');
+      } else {
+        specifier = specifier.replace(/\.js$/, '.ts');
+      }
     }
   }
 

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

@@ -115,6 +115,81 @@ test("fixLevel:all (default) — detects AND fixes completion issues", async ()
   }
 });
 
+test("fixLevel:all — marks indented roadmap checkboxes done (#1063)", async () => {
+  const tmp = makeTmp("indented-roadmap");
+  try {
+    buildScaffold(tmp);
+
+    // Overwrite roadmap with indented checkbox (LLM formatting drift)
+    writeFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+  - [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+    > Demo text
+`);
+
+    const report = await runGSDDoctor(tmp, { fix: true });
+
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    // Should mark [x] while preserving the leading whitespace
+    assert.ok(roadmapContent.includes("  - [x] **S01"), "indented roadmap checkbox should be marked done");
+    // Verify indentation is preserved: line should start with "  -", not just "-"
+    const checkedLine = roadmapContent.split("\n").find(l => l.includes("[x] **S01"));
+    assert.ok(checkedLine?.startsWith("  -"), `should preserve leading whitespace, got: "${checkedLine}"`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:all — marks indented task checkboxes done (#1063)", async () => {
+  const tmp = makeTmp("indented-task");
+  try {
+    const gsd = join(tmp, ".gsd");
+    const m = join(gsd, "milestones", "M001");
+    const s = join(m, "slices", "S01", "tasks");
+    mkdirSync(s, { recursive: true });
+
+    writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+`);
+
+    // Plan with indented checkbox
+    writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
+
+**Goal:** test
+
+## Tasks
+
+  - [ ] **T01: Do stuff** \`est:5m\`
+`);
+
+    writeFileSync(join(s, "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+duration: 5m
+verification_result: passed
+completed_at: 2026-01-01
+---
+
+# T01: Do stuff
+
+Done.
+`);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    const planContent = readFileSync(join(m, "slices", "S01", "S01-PLAN.md"), "utf8");
+    assert.ok(planContent.includes("  - [x] **T01"), "indented task checkbox should be marked done");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 test("fixLevel:task — still fixes task-level bookkeeping (checkbox marking)", async () => {
   const tmp = makeTmp("task-checkbox");
   try {

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

@@ -72,20 +72,6 @@ function writePreferencesFile(dir: string, isolation: "none" | "worktree" | "bra
   writeFileSync(join(gsdDir, "preferences.md"), `---\ngit:\n  isolation: "${isolation}"\n---\n`);
 }
 
-/**
- * Write preferences to the test runner's cwd .gsd/preferences.md.
- * loadEffectiveGSDPreferences() resolves PROJECT_PREFERENCES_PATH at module
- * load time from process.cwd(), so we must write there — not to the temp dir.
- */
-const RUNNER_PREFS_PATH = join(process.cwd(), ".gsd", "preferences.md");
-function writeRunnerPreferences(isolation: "none" | "worktree" | "branch"): void {
-  mkdirSync(join(process.cwd(), ".gsd"), { recursive: true });
-  writeFileSync(RUNNER_PREFS_PATH, `---\ngit:\n  isolation: "${isolation}"\n---\n`);
-}
-function removeRunnerPreferences(): void {
-  try { rmSync(RUNNER_PREFS_PATH); } catch { /* ignore if already gone */ }
-}
-
 /** Create a repo with an in-progress milestone. */
 function createRepoWithActiveMilestone(): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
@@ -146,12 +132,12 @@ async function main(): Promise<void> {
       mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
       run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
 
-      const detect = await runGSDDoctor(dir);
+      const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
       assertTrue(orphanIssues.length > 0, "detects orphaned worktree");
       assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
 
-      const fixed = await runGSDDoctor(dir, { fix: true });
+      const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
       assertTrue(fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")), "fix removes orphaned worktree");
 
       // Verify worktree is gone
@@ -174,12 +160,12 @@ async function main(): Promise<void> {
       // Create a milestone/M001 branch (no worktree)
       run("git branch milestone/M001", dir);
 
-      const detect = await runGSDDoctor(dir);
+      const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
       const staleIssues = detect.issues.filter(i => i.code === "stale_milestone_branch");
       assertTrue(staleIssues.length > 0, "detects stale milestone branch");
       assertEq(staleIssues[0]?.unitId, "M001", "stale branch unitId is M001");
 
-      const fixed = await runGSDDoctor(dir, { fix: true });
+      const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
       assertTrue(fixed.fixesApplied.some(f => f.includes("deleted stale branch")), "fix deletes stale branch");
 
       // Verify branch is gone
@@ -265,7 +251,7 @@ async function main(): Promise<void> {
       mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
       run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
 
-      const detect = await runGSDDoctor(dir);
+      const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
       assertEq(orphanIssues.length, 0, "active worktree NOT flagged as orphaned");
     }
@@ -287,15 +273,9 @@ async function main(): Promise<void> {
       mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
       run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
 
-      // Write preferences to runner's cwd (where the module resolves project prefs)
-      writeRunnerPreferences("none");
-      try {
-        const result = await runGSDDoctor(dir);
-        const orphanIssues = result.issues.filter(i => i.code === "orphaned_auto_worktree");
-        assertEq(orphanIssues.length, 0, "none-mode: orphaned worktree NOT detected");
-      } finally {
-        removeRunnerPreferences();
-      }
+      const result = await runGSDDoctor(dir, { isolationMode: "none" });
+      const orphanIssues = result.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertEq(orphanIssues.length, 0, "none-mode: orphaned worktree NOT detected");
     }
     } else {
       console.log("\n=== none-mode skips orphaned worktree (skipped on Windows) ===");
@@ -311,15 +291,9 @@ async function main(): Promise<void> {
       // Create a milestone/M001 branch (no worktree)
       run("git branch milestone/M001", dir);
 
-      // Write preferences to runner's cwd
-      writeRunnerPreferences("none");
-      try {
-        const result = await runGSDDoctor(dir);
-        const staleIssues = result.issues.filter(i => i.code === "stale_milestone_branch");
-        assertEq(staleIssues.length, 0, "none-mode: stale branch NOT detected");
-      } finally {
-        removeRunnerPreferences();
-      }
+      const result = await runGSDDoctor(dir, { isolationMode: "none" });
+      const staleIssues = result.issues.filter(i => i.code === "stale_milestone_branch");
+      assertEq(staleIssues.length, 0, "none-mode: stale branch NOT detected");
     }
     } else {
       console.log("\n=== none-mode skips stale branch (skipped on Windows) ===");
@@ -335,15 +309,9 @@ async function main(): Promise<void> {
       const headHash = run("git rev-parse HEAD", dir);
       writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
 
-      // Write preferences to runner's cwd
-      writeRunnerPreferences("none");
-      try {
-        const result = await runGSDDoctor(dir);
-        const mergeIssues = result.issues.filter(i => i.code === "corrupt_merge_state");
-        assertTrue(mergeIssues.length > 0, "none-mode: corrupt merge state IS detected");
-      } finally {
-        removeRunnerPreferences();
-      }
+      const result = await runGSDDoctor(dir, { isolationMode: "none" });
+      const mergeIssues = result.issues.filter(i => i.code === "corrupt_merge_state");
+      assertTrue(mergeIssues.length > 0, "none-mode: corrupt merge state IS detected");
     }
 
     // ─── Test 10: none-mode still detects tracked runtime files ────────
@@ -359,15 +327,9 @@ async function main(): Promise<void> {
       run("git add -f .gsd/activity/test.log", dir);
       run("git commit -m \"track runtime file\"", dir);
 
-      // Write preferences to runner's cwd
-      writeRunnerPreferences("none");
-      try {
-        const result = await runGSDDoctor(dir);
-        const trackedIssues = result.issues.filter(i => i.code === "tracked_runtime_files");
-        assertTrue(trackedIssues.length > 0, "none-mode: tracked runtime files IS detected");
-      } finally {
-        removeRunnerPreferences();
-      }
+      const result = await runGSDDoctor(dir, { isolationMode: "none" });
+      const trackedIssues = result.issues.filter(i => i.code === "tracked_runtime_files");
+      assertTrue(trackedIssues.length > 0, "none-mode: tracked runtime files IS detected");
     }
 
   } finally {