gsd-pi 2.22.0 → 2.23.0

package/dist/resources/extensions/gsd/tests/auto-lock-creation.test.ts

@@ -0,0 +1,186 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { writeLock, readCrashLock, clearLock, isLockProcessAlive } from "../crash-recovery.ts";
+
+// ─── writeLock creates auto.lock in .gsd/ ────────────────────────────────
+
+test("writeLock creates auto.lock with correct structure", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  writeLock(dir, "starting", "M001", 0);
+
+  const lockPath = join(dir, ".gsd", "auto.lock");
+  assert.ok(existsSync(lockPath), "auto.lock should exist after writeLock");
+
+  const data = JSON.parse(readFileSync(lockPath, "utf-8"));
+  assert.equal(data.pid, process.pid, "lock should contain current PID");
+  assert.equal(data.unitType, "starting", "lock should contain unit type");
+  assert.equal(data.unitId, "M001", "lock should contain unit ID");
+  assert.equal(data.completedUnits, 0, "lock should show 0 completed units");
+  assert.ok(data.startedAt, "lock should have startedAt timestamp");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("writeLock updates existing lock with new unit info", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  writeLock(dir, "starting", "M001", 0);
+  writeLock(dir, "execute-task", "M001/S01/T01", 2, "/tmp/session.jsonl");
+
+  const data = JSON.parse(readFileSync(join(dir, ".gsd", "auto.lock"), "utf-8"));
+  assert.equal(data.unitType, "execute-task", "lock should be updated to new unit type");
+  assert.equal(data.unitId, "M001/S01/T01", "lock should be updated to new unit ID");
+  assert.equal(data.completedUnits, 2, "completed count should be updated");
+  assert.equal(data.sessionFile, "/tmp/session.jsonl", "session file should be recorded");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── readCrashLock reads auto.lock data ──────────────────────────────────
+
+test("readCrashLock returns null when no lock file exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const lock = readCrashLock(dir);
+  assert.equal(lock, null, "should return null when no lock file");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("readCrashLock returns lock data when file exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  writeLock(dir, "plan-milestone", "M002", 5);
+  const lock = readCrashLock(dir);
+
+  assert.ok(lock, "should return lock data");
+  assert.equal(lock!.unitType, "plan-milestone");
+  assert.equal(lock!.unitId, "M002");
+  assert.equal(lock!.completedUnits, 5);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── clearLock removes auto.lock ─────────────────────────────────────────
+
+test("clearLock removes the lock file", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  writeLock(dir, "starting", "M001", 0);
+  assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "lock should exist before clear");
+
+  clearLock(dir);
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "lock should be removed after clear");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("clearLock is safe when no lock file exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Should not throw
+  clearLock(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── isLockProcessAlive detects live vs dead PIDs ────────────────────────
+
+test("isLockProcessAlive returns false for dead PID", () => {
+  const lock = {
+    pid: 9999999,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  assert.equal(isLockProcessAlive(lock), false, "dead PID should return false");
+});
+
+test("isLockProcessAlive returns false for own PID (recycled)", () => {
+  const lock = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  assert.equal(isLockProcessAlive(lock), false, "own PID should return false (recycled)");
+});
+
+test("isLockProcessAlive returns false for invalid PID", () => {
+  const lock = {
+    pid: -1,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  assert.equal(isLockProcessAlive(lock), false, "negative PID should return false");
+});
+
+// ─── Cross-process detection via lock file ───────────────────────────────
+
+test("lock file enables cross-process auto-mode detection", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Use the parent process PID — guaranteed alive on all platforms (Unix and Windows).
+  // PID 1 (init) only works on Unix; on Windows it doesn't exist.
+  const alivePid = process.ppid;
+  const lockData = {
+    pid: alivePid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 3,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const lock = readCrashLock(dir);
+  assert.ok(lock, "should read the lock");
+  assert.equal(lock!.pid, alivePid);
+
+  // Parent PID is always alive — isLockProcessAlive should detect it
+  const alive = isLockProcessAlive(lock!);
+  assert.equal(alive, true, "parent PID should be detected as alive");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("stale lock from dead process is detected as not alive", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Simulate a stale lock from a process that no longer exists
+  const lockData = {
+    pid: 9999999,
+    startedAt: "2026-03-01T00:00:00Z",
+    unitType: "plan-slice",
+    unitId: "M001/S02",
+    unitStartedAt: "2026-03-01T00:05:00Z",
+    completedUnits: 1,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const lock = readCrashLock(dir);
+  assert.ok(lock, "should read the stale lock");
+  assert.equal(isLockProcessAlive(lock!), false, "dead process should not be alive");
+
+  rmSync(dir, { recursive: true, force: true });
+});

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

@@ -320,3 +320,67 @@ test("verifyExpectedArtifact detects roadmap [x] change despite parse cache", ()
     cleanup(base);
   }
 });
+
+// ─── verifyExpectedArtifact: plan-slice empty scaffold regression (#699) ──
+
+test("verifyExpectedArtifact rejects plan-slice with empty scaffold", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Test Slice\n\n## Tasks\n\n");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      false,
+      "Empty scaffold should not be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with actual tasks", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Implement feature** `est:2h`",
+      "- [ ] **T02: Write tests** `est:1h`",
+    ].join("\n"));
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Plan with task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with completed tasks", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: Implement feature** `est:2h`",
+      "- [ ] **T02: Write tests** `est:1h`",
+    ].join("\n"));
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Plan with completed task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -0,0 +1,123 @@
+/**
+ * auto-skip-loop.test.ts — Tests for the consecutive-skip loop breaker.
+ *
+ * Regression for #728: auto-mode infinite skip loop on previously completed
+ * plan-slice units when deriveState keeps returning the same unit.
+ *
+ * The skip paths in dispatchNextUnit track consecutive skips per unit via
+ * unitConsecutiveSkips. When the same unit is skipped > MAX_CONSECUTIVE_SKIPS
+ * times without a real dispatch in between, the completion record is evicted
+ * so deriveState can reconcile.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _getUnitConsecutiveSkips,
+  _resetUnitConsecutiveSkips,
+  MAX_CONSECUTIVE_SKIPS,
+} from "../auto.ts";
+import { persistCompletedKey, removePersistedKey, loadPersistedKeys } from "../auto-recovery.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-skip-loop-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+async function main(): Promise<void> {
+  // ─── Counter starts at zero ────────────────────────────────────────────
+  console.log("\n=== skip loop counter: initial state ===");
+  {
+    _resetUnitConsecutiveSkips();
+    const map = _getUnitConsecutiveSkips();
+    assertEq(map.size, 0, "counter map starts empty after reset");
+  }
+
+  // ─── Counter increments correctly ────────────────────────────────────
+  console.log("\n=== skip loop counter: increments on repeated calls ===");
+  {
+    _resetUnitConsecutiveSkips();
+    const map = _getUnitConsecutiveSkips();
+    const key = "plan-slice/M001/S04";
+
+    for (let i = 1; i <= MAX_CONSECUTIVE_SKIPS; i++) {
+      const prev = map.get(key) ?? 0;
+      map.set(key, prev + 1);
+    }
+
+    assertEq(map.get(key), MAX_CONSECUTIVE_SKIPS, `counter reaches MAX_CONSECUTIVE_SKIPS (${MAX_CONSECUTIVE_SKIPS})`);
+  }
+
+  // ─── Threshold constant is sane ──────────────────────────────────────
+  console.log("\n=== skip loop counter: threshold is reasonable ===");
+  {
+    assertTrue(MAX_CONSECUTIVE_SKIPS >= 3, "threshold allows a few legitimate skips");
+    assertTrue(MAX_CONSECUTIVE_SKIPS <= 10, "threshold catches loops quickly");
+  }
+
+  // ─── Reset clears all keys ────────────────────────────────────────────
+  console.log("\n=== skip loop counter: reset clears all keys ===");
+  {
+    _resetUnitConsecutiveSkips();
+    const map = _getUnitConsecutiveSkips();
+    map.set("plan-slice/M001/S01", 2);
+    map.set("plan-slice/M001/S02", 1);
+    assertEq(map.size, 2, "map has 2 entries before reset");
+
+    _resetUnitConsecutiveSkips();
+    assertEq(_getUnitConsecutiveSkips().size, 0, "map empty after reset");
+  }
+
+  // ─── Eviction path: persistCompletedKey + removePersistedKey round-trip
+  //     (simulates what the loop-breaker does) ───────────────────────────
+  console.log("\n=== skip loop counter: eviction removes persisted key ===");
+  {
+    _resetUnitConsecutiveSkips();
+    const base = makeTmpBase();
+    try {
+      const key = "plan-slice/M001/S04";
+      const keySet = new Set<string>();
+
+      persistCompletedKey(base, key);
+      loadPersistedKeys(base, keySet);
+      assertTrue(keySet.has(key), "key persisted before eviction");
+
+      // Simulate loop-breaker eviction
+      keySet.delete(key);
+      removePersistedKey(base, key);
+      const keySet2 = new Set<string>();
+      loadPersistedKeys(base, keySet2);
+      assertTrue(!keySet2.has(key), "key absent after eviction");
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── Counter resets per-key, not globally ─────────────────────────────
+  console.log("\n=== skip loop counter: per-key isolation ===");
+  {
+    _resetUnitConsecutiveSkips();
+    const map = _getUnitConsecutiveSkips();
+    map.set("plan-slice/M001/S04", MAX_CONSECUTIVE_SKIPS + 1);
+    map.set("plan-slice/M001/S05", 1);
+
+    // Deleting S04 (eviction) should not affect S05
+    map.delete("plan-slice/M001/S04");
+    assertTrue(!map.has("plan-slice/M001/S04"), "S04 evicted");
+    assertEq(map.get("plan-slice/M001/S05"), 1, "S05 counter unaffected");
+  }
+
+  _resetUnitConsecutiveSkips();
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

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

@@ -585,6 +585,64 @@ Discovered an issue.
     rmSync(dtBase, { recursive: true, force: true });
   }
 
+  // ─── unresolvable_dependency: range syntax dep warns ─────────────────
+  console.log("\n=== doctor: unresolvable_dependency warns for leftover range ID ===");
+  {
+    // Simulate a roadmap where expandDependencies did NOT expand (pre-fix stored artifact)
+    // by writing a dep that looks like a range but doesn't match any real slice.
+    const base = mkdtempSync(join(tmpdir(), "gsd-doctor-udep-"));
+    const mDir2 = join(base, ".gsd", "milestones", "M001");
+    const sDir2 = join(mDir2, "slices", "S01");
+    const tDir2 = join(sDir2, "tasks");
+    mkdirSync(tDir2, { recursive: true });
+    writeFileSync(join(mDir2, "M001-ROADMAP.md"), [
+      "# M001: Test",
+      "",
+      "## Slices",
+      "- [x] **S01: Done** `risk:low` `depends:[]`",
+      "  > After this: done",
+      "- [ ] **S02: Blocked** `risk:low` `depends:[S99]`",
+      "  > After this: also done",
+    ].join("\n") + "\n");
+    writeFileSync(join(sDir2, "S01-PLAN.md"), "# S01\n\n**Goal:** g\n**Demo:** d\n\n## Tasks\n- [x] **T01: t** `est:5m`\n");
+    writeFileSync(join(tDir2, "T01-SUMMARY.md"), "---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01\n## What Happened\nDone.\n");
+
+    const r = await runGSDDoctor(base, { fix: false });
+    const udepIssues = r.issues.filter(i => i.code === "unresolvable_dependency");
+    assertTrue(udepIssues.length > 0, "unresolvable_dependency fires for unknown dep S99");
+    assertEq(udepIssues[0]?.severity, "warning", "severity is warning");
+    assertTrue(udepIssues[0]?.message.includes("S99"), "message names the bad dep");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ─── unresolvable_dependency: valid deps do not warn ─────────────────
+  console.log("\n=== doctor: no unresolvable_dependency for valid deps ===");
+  {
+    const base = mkdtempSync(join(tmpdir(), "gsd-doctor-udep-ok-"));
+    const mDir2 = join(base, ".gsd", "milestones", "M001");
+    const sDir2 = join(mDir2, "slices", "S01");
+    const tDir2 = join(sDir2, "tasks");
+    mkdirSync(tDir2, { recursive: true });
+    writeFileSync(join(mDir2, "M001-ROADMAP.md"), [
+      "# M001: Test",
+      "",
+      "## Slices",
+      "- [x] **S01: Done** `risk:low` `depends:[]`",
+      "  > After this: done",
+      "- [ ] **S02: Next** `risk:low` `depends:[S01]`",
+      "  > After this: next done",
+    ].join("\n") + "\n");
+    writeFileSync(join(sDir2, "S01-PLAN.md"), "# S01\n\n**Goal:** g\n**Demo:** d\n\n## Tasks\n- [x] **T01: t** `est:5m`\n");
+    writeFileSync(join(tDir2, "T01-SUMMARY.md"), "---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01\n## What Happened\nDone.\n");
+
+    const r = await runGSDDoctor(base, { fix: false });
+    const udepIssues = r.issues.filter(i => i.code === "unresolvable_dependency");
+    assertEq(udepIssues.length, 0, "no unresolvable_dependency for valid S01 dep");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
   report();
 }
 

package/dist/resources/extensions/gsd/tests/in-flight-tool-tracking.test.ts

@@ -1,6 +1,6 @@
 /**
  * In-flight tool tracking tests — verifies that markToolStart/markToolEnd
- * correctly manage the in-flight tools set used by the idle watchdog to
+ * correctly manage the in-flight tools map used by the idle watchdog to
  * distinguish "agent waiting on long-running tool" from "agent is idle".
  *
  * Background: The idle watchdog checks every 15s for agent progress. Without
@@ -8,12 +8,15 @@
  * can run 20+ minutes for evaluations, deployments, test suites) are falsely
  * declared idle and interrupted by recovery steering messages.
  *
- * The fix hooks tool_execution_start/end events to track active tool calls.
- * When tools are in-flight, the watchdog resets lastProgressAt instead of
- * triggering idle recovery.
+ * The fix hooks tool_execution_start/end events to track active tool calls
+ * with start timestamps. When tools are in-flight and started recently
+ * (< idleTimeoutMs), the watchdog resets lastProgressAt instead of triggering
+ * idle recovery. When a tool has been in-flight for longer than idleTimeoutMs,
+ * it is treated as stuck (e.g., `command &` keeping stdout open) and recovery
+ * proceeds anyway.
  */
 
-import { markToolStart, markToolEnd, isAutoActive } from "../auto.ts";
+import { markToolStart, markToolEnd, isAutoActive, getOldestInFlightToolAgeMs } from "../auto.ts";
 import { createTestContext } from './test-helpers.ts';
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -49,9 +52,17 @@ const { assertEq, assertTrue, report } = createTestContext();
 // ═══ Integration contract: expected exports from auto.ts ═════════════════════
 
 {
-  console.log("\n=== auto.ts exports markToolStart and markToolEnd ===");
+  console.log("\n=== auto.ts exports markToolStart, markToolEnd, and getOldestInFlightToolAgeMs ===");
   assertEq(typeof markToolStart, "function", "markToolStart should be a function");
   assertEq(typeof markToolEnd, "function", "markToolEnd should be a function");
+  assertEq(typeof getOldestInFlightToolAgeMs, "function", "getOldestInFlightToolAgeMs should be a function");
+}
+
+{
+  console.log("\n=== getOldestInFlightToolAgeMs: returns 0 when no tools in-flight ===");
+  // When auto-mode is inactive, inFlightTools map is empty → age is 0
+  const age = getOldestInFlightToolAgeMs();
+  assertEq(age, 0, "should return 0 when no tools are in-flight");
 }
 
 {