@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/tests/root-write-leak-guard.test.ts

@@ -7,7 +7,26 @@ import { closeSync, ftruncateSync, openSync, statSync, writeFileSync } from "nod
 import { join } from "node:path";
 
 import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";
-import { cleanup, git, makeTempRepo } from "./test-utils.ts";
+import { cleanup, createFile, git, makeTempRepo } from "./test-utils.ts";
+
+test("captureRootDirtySnapshot ignores unignored GSD root runtime directories", () => {
+  const base = makeTempRepo("gsd-root-dirty-runtime-");
+  try {
+    createFile(base, ".gsd/STATE.md", "state\n");
+    createFile(base, ".gsd-backups/snap-001", "backup\n");
+    createFile(base, ".gsd-worktrees/M001/file.txt", "worktree\n");
+    createFile(base, "src/foo.ts", "export {};\n");
+
+    const snapshot = captureRootDirtySnapshot(base);
+
+    assert.equal(snapshot.has(".gsd/STATE.md"), false);
+    assert.equal(snapshot.has(".gsd-backups/snap-001"), false);
+    assert.equal(snapshot.has(".gsd-worktrees/M001/file.txt"), false);
+    assert.equal(snapshot.has("src/foo.ts"), true);
+  } finally {
+    cleanup(base);
+  }
+});
 
 test("captureRootDirtySnapshot does not read dirty files larger than Node's Buffer limit", () => {
   const base = makeTempRepo("gsd-root-dirty-large-");

package/src/resources/extensions/gsd/tests/round-trip-property.test.ts

@@ -0,0 +1,137 @@
+// Project/App: gsd-pi
+// File Purpose: Round-trip property test — for any gsd-core .gsd/ fixture,
+// import → render → import must produce a stable hierarchy snapshot, and
+// re-rendering must produce stable markdown. Catches lossy-projection bugs
+// that would otherwise silently destroy state across cross-tool round-trips.
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { cpSync, mkdtempSync, rmSync, readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+import { openDatabase, closeDatabase, getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import { renderAllFromDb } from "../markdown-renderer.ts";
+import { invalidateStateCache } from "../state.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_ROOT = join(__dirname, "__fixtures__", "round-trip");
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+function copyFixture(name: string): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-rt-${randomUUID()}`));
+  cpSync(join(FIXTURE_ROOT, name), base, { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+
+interface HierarchySnapshot {
+  milestones: Array<{ id: string; title: string; status: string }>;
+  slices: Array<{ mid: string; id: string; title: string; status: string }>;
+  tasks: Array<{ mid: string; sid: string; id: string; title: string; status: string }>;
+}
+
+function snapshotHierarchy(): HierarchySnapshot {
+  const milestones = getAllMilestones().map((m) => ({ id: m.id, title: m.title, status: m.status }));
+  const slices: HierarchySnapshot["slices"] = [];
+  const tasks: HierarchySnapshot["tasks"] = [];
+  for (const m of milestones) {
+    for (const s of getMilestoneSlices(m.id)) {
+      slices.push({ mid: m.id, id: s.id, title: s.title, status: s.status });
+      for (const t of getSliceTasks(m.id, s.id)) {
+        tasks.push({ mid: m.id, sid: s.id, id: t.id, title: t.title, status: t.status });
+      }
+    }
+  }
+  // Sort for stable comparison across DB row-order variations.
+  const cmp = <T extends { id: string }>(a: T, b: T) => a.id.localeCompare(b.id);
+  milestones.sort(cmp);
+  slices.sort((a, b) => `${a.mid}/${a.id}`.localeCompare(`${b.mid}/${b.id}`));
+  tasks.sort((a, b) => `${a.mid}/${a.sid}/${a.id}`.localeCompare(`${b.mid}/${b.sid}/${b.id}`));
+  return { milestones, slices, tasks };
+}
+
+test("round-trip is stable: import → render → import produces the same hierarchy snapshot", async () => {
+  // Only .gsd/-bearing fixtures — the .planning/ fixtures belong to the
+  // planning round-trip suite (different layout, no .gsd/ to import from).
+  const fixtures = readdirSync(FIXTURE_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(join(FIXTURE_ROOT, d.name, ".gsd")))
+    .map((d) => d.name);
+
+  assert.ok(fixtures.length > 0, "expected at least one round-trip fixture");
+
+  for (const name of fixtures) {
+    const base = copyFixture(name);
+    openDatabase(join(base, ".gsd", "gsd.db"));
+
+    // Pass 1: import fixture markdown → DB
+    migrateHierarchyToDb(base);
+    invalidateStateCache();
+    const snapshot1 = snapshotHierarchy();
+    assert.ok(snapshot1.milestones.length > 0, `fixture ${name}: expected at least one milestone after import`);
+
+    // Render DB → markdown (projection)
+    const render1 = await renderAllFromDb(base);
+    assert.deepEqual(render1.errors, [], `pass 1 render errors for ${name}: ${JSON.stringify(render1.errors)}`);
+
+    // Pass 2: re-import the projected markdown → DB. migrateHierarchyToDb is
+    // an idempotent upsert (INSERT OR IGNORE), so this simulates a second tool
+    // opening the re-projected files and importing them.
+    migrateHierarchyToDb(base);
+    invalidateStateCache();
+    const snapshot2 = snapshotHierarchy();
+
+    // Property: hierarchy must be stable across the round-trip.
+    assert.deepEqual(
+      snapshot2,
+      snapshot1,
+      `round-trip drift for fixture ${name}: hierarchy changed across import → render → import`,
+    );
+  }
+});
+
+test("round-trip is idempotent: rendering twice produces stable markdown", async () => {
+  const fixtures = readdirSync(FIXTURE_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(join(FIXTURE_ROOT, d.name, ".gsd")))
+    .map((d) => d.name);
+
+  for (const name of fixtures) {
+    const base = copyFixture(name);
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    migrateHierarchyToDb(base);
+    invalidateStateCache();
+    await renderAllFromDb(base);
+
+    // Snapshot all rendered markdown files (normalized: CRLF→LF, trailing
+    // whitespace trimmed) so cosmetic differences don't false-positive.
+    const snapshotFiles = (b: string): Record<string, string> => {
+      const out: Record<string, string> = {};
+      const walk = (dir: string) => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          const p = join(dir, e.name);
+          if (e.isDirectory()) walk(p);
+          else if (e.name.endsWith(".md")) {
+            out[p.replace(b + "/", "")] = readFileSync(p, "utf-8").replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n");
+          }
+        }
+      };
+      walk(join(b, ".gsd"));
+      return out;
+    };
+    const after1 = snapshotFiles(base);
+
+    // Render again
+    await renderAllFromDb(base);
+    const after2 = snapshotFiles(base);
+
+    assert.deepEqual(after2, after1, `re-rendering changed markdown for fixture ${name}`);
+  }
+});

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -177,10 +177,22 @@ test("auto Unit tool scope allows status/read helpers named by closeout prompts"
   }
 });
 
-test("auto Unit tool scope blocks stale per-task planner in slice planning phases", () => {
-  for (const unitType of ["plan-slice", "refine-slice", "replan-slice"]) {
+test("auto Unit tool scope allows reactive-execute status and diagnostic tools", () => {
+  for (const toolName of ["gsd_milestone_status", "gsd_exec"]) {
+    const result = shouldBlockAutoUnitToolCall("reactive-execute", toolName);
+    assert.equal(result.block, false, `reactive-execute should be able to call ${toolName}`);
+  }
+});
+
+test("auto Unit tool scope allows incremental task planning during plan-slice", () => {
+  const result = shouldBlockAutoUnitToolCall("plan-slice", "gsd_plan_task");
+  assert.equal(result.block, false, "plan-slice should be able to call gsd_plan_task incrementally");
+});
+
+test("auto Unit tool scope still blocks per-task planner outside plan-slice", () => {
+  for (const unitType of ["refine-slice", "replan-slice"]) {
     const result = shouldBlockAutoUnitToolCall(unitType, "gsd_plan_task");
-    assert.equal(result.block, true, `${unitType} should not call stale gsd_plan_task`);
+    assert.equal(result.block, true, `${unitType} should not call gsd_plan_task`);
   }
 });
 

package/src/resources/extensions/gsd/tests/session-lock-transient-read.test.ts

@@ -8,6 +8,7 @@
  *
  * Tests:
  *   - readExistingLockDataWithRetry retries on transient read failure
+ *   - readExistingLockDataWithRetry sleeps between retries without CPU spin
  *   - readExistingLockDataWithRetry returns data when file becomes readable after retries
  *   - readExistingLockDataWithRetry returns null only when ALL retries exhausted
  *   - onCompromised does not declare compromise when lock file is transiently unreadable
@@ -75,6 +76,31 @@ async function main(): Promise<void> {
     }
   }
 
+  // ─── 2b. Retry delay sleeps without CPU spin ──────────────────────────────
+  console.log('\n=== 2b. readExistingLockDataWithRetry sleeps between retry attempts ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+    const originalWait = Atomics.wait;
+    const waits: Array<number | undefined> = [];
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      Atomics.wait = ((_typedArray: Int32Array, _index: number, _value: number, timeout?: number) => {
+        waits.push(timeout);
+        return 'timed-out';
+      }) as typeof Atomics.wait;
+
+      const result = readExistingLockDataWithRetry(lockFile, { maxAttempts: 3, delayMs: 17 });
+      assertEq(result, null, 'null for missing file after instrumented retries');
+      assertEq(waits.length, 2, 'sleep called only between failed attempts');
+      assertEq(waits, [17, 17], 'sleep preserves delayMs across retries');
+    } finally {
+      Atomics.wait = originalWait;
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
   // ─── 3. readExistingLockDataWithRetry recovers after transient rename ──────
   console.log('\n=== 3. readExistingLockDataWithRetry recovers after transient unavailability ===');
   {
@@ -96,8 +122,8 @@ async function main(): Promise<void> {
 
       // Simulate transient unavailability: move file away, spawn a child process
       // to restore it shortly after. The child runs outside our event loop so it
-      // fires even during busy-wait retries. Give the test extra retry budget so
-      // it stays stable under full-suite CPU contention.
+      // fires even during synchronous retry sleeps. Give the test extra retry
+      // budget so it stays stable under full-suite CPU contention.
       renameSync(lockFile, tmpFile);
       spawn('bash', ['-c', `sleep 0.05 && mv "${tmpFile}" "${lockFile}"`], { stdio: 'ignore', detached: true }).unref();
 

package/src/resources/extensions/gsd/tests/single-writer-invariant.test.ts

@@ -365,6 +365,7 @@ test("DB Workspace Interface owns database open-state and maintenance calls", as
     "openWorkflowDatabase",
     "openWorkflowDatabaseByScope",
     "openWorkflowDatabaseByWorkspace",
+    "openWorkflowDatabaseIsolated",
     "openWorkflowDatabasePath",
     "refreshWorkflowDatabaseFromDisk",
     "resolveProjectRootDbPath",

package/src/resources/extensions/gsd/tests/stale-dirlistcache-4648.test.ts

@@ -13,7 +13,13 @@ import { resolveMilestoneFile, clearPathCache } from "../paths.ts";
 
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-4648-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // Seed one content file so the dir is recognised as a content-bearing legacy
+  // milestone by dirIsContentBearingLegacyMilestone. The stale-cache tests then
+  // verify that a SECOND file written to the same dir is NOT detected until the
+  // path cache is cleared (the original behaviour under test is preserved).
+  writeFileSync(join(mDir, "M001-RESEARCH.md"), "# M001 research\n");
   return base;
 }
 

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

@@ -48,6 +48,16 @@ function makeRecordingPi() {
   } as any;
 }
 
+function makeRecordingCtx() {
+  const notifications: Array<{ message: string; level: string }> = [];
+  return {
+    notifications,
+    ui: {
+      notify: (message: string, level: string) => { notifications.push({ message, level }); },
+    },
+  } as any;
+}
+
 // ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
 
 {
@@ -111,6 +121,52 @@ function makeRecordingPi() {
   }
 }
 
+// ═══ plan-slice timeout recovery verifies stale PLAN before advancing ═══════
+
+{
+  console.log("\n=== plan-slice timeout recovery rejects stale placeholder PLAN ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-stale-plan-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      "# S01: Slice\n\n## Tasks\n\nPlanning was interrupted before task rows were persisted.\n",
+      "utf-8",
+    );
+
+    const ctx = makeRecordingCtx();
+    const pi = makeRecordingPi();
+    const result = await recoverTimedOutUnit(ctx, pi, "plan-slice", "M001/S01", "idle", {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    });
+
+    assert.equal(result, "recovered", "invalid existing plan should enter steering recovery");
+    assert.equal(pi.messages.length, 1, "invalid existing plan should trigger steering instead of advancing");
+    assert.ok(
+      ctx.notifications.some((entry: { message: string }) => entry.message.includes("steering plan-slice M001/S01")),
+      "recovery notification should describe steering, not artifact advance",
+    );
+    assert.ok(
+      !ctx.notifications.some((entry: { message: string }) => entry.message.includes("artifact already exists on disk. Advancing.")),
+      "stale placeholder plan should not use the advance-on-existence path",
+    );
+    const runtime = JSON.parse(readFileSync(join(base, ".gsd", "runtime", "units", "plan-slice-M001-S01.json"), "utf-8"));
+    assert.equal(runtime.phase, "recovered", "stale placeholder plan must not be finalized");
+    assert.equal(runtime.recoveryAttempts, 1, "steering recovery attempt should be recorded");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {