gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/src/resources/extensions/gsd/tests/cache-staleness-regression.test.ts

@@ -0,0 +1,317 @@
+/**
+ * cache-staleness-regression.test.ts — Regression tests for stale cache bugs.
+ *
+ * The GSD parser caches are critical for performance but have caused multiple
+ * production bugs when not invalidated at the right time.
+ *
+ * Regression coverage for:
+ *   #1249  Stale caches in discuss loop → slice appears "not discussed"
+ *   #1240  Stale caches after milestone creation → "No roadmap yet"
+ *   #1236  Same root cause as #1240
+ *
+ * Pattern: derive state → write file → invalidate cache → derive again → verify update
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { deriveState, invalidateStateCache } from '../state.ts';
+import { invalidateAllCaches } from '../cache.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-cache-stale-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeMilestoneFile(base: string, mid: string, suffix: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-${suffix}.md`), content);
+}
+
+function writeSliceFile(base: string, mid: string, sid: string, suffix: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
+}
+
+async function main(): Promise<void> {
+
+  // ─── 1. Regression #1240: New roadmap detected after cache invalidation ─
+  console.log('\n=== 1. #1240: roadmap written after first derive → detected after invalidation ===');
+  {
+    const base = createBase();
+    try {
+      // Step 1: Create milestone with just context (no roadmap)
+      writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001: Test\n\nBuild a thing.\n');
+
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state1 = await deriveState(base);
+      assertEq(state1.phase, 'pre-planning', 'initial: pre-planning (no roadmap)');
+
+      // Step 2: Write roadmap (simulating what the LLM does during planning)
+      const roadmap = [
+        '# M001: Test',
+        '',
+        '## Slices',
+        '',
+        '- [ ] **S01: First Slice** `risk:low` `depends:[]`',
+        '',
+        '## Boundary Map',
+        '',
+      ].join('\n');
+      writeMilestoneFile(base, 'M001', 'ROADMAP', roadmap);
+
+      // Step 3: WITHOUT invalidation, the old state might be cached
+      // The state cache has a 100ms TTL, so wait just past it
+      await new Promise(r => setTimeout(r, 150));
+
+      // Step 4: Invalidate and re-derive — should see the new roadmap
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state2 = await deriveState(base);
+      assertEq(state2.phase, 'planning', '#1240: after roadmap write + invalidation → planning phase');
+      assertEq(state2.activeSlice?.id, 'S01', '#1240: S01 is now the active slice');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── 2. Regression #1249: Slice context detected after cache invalidation ─
+  console.log('\n=== 2. #1249: slice context written mid-loop → detected after invalidation ===');
+  {
+    const base = createBase();
+    try {
+      // Create a milestone in needs-discussion phase (CONTEXT-DRAFT, no CONTEXT)
+      const mDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(mDir, { recursive: true });
+      writeFileSync(join(mDir, 'M001-CONTEXT-DRAFT.md'), '# Draft\n\nSome ideas.\n');
+
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state1 = await deriveState(base);
+      assertEq(state1.phase, 'needs-discussion', 'initial: needs-discussion');
+
+      // Simulate: discussion completes, CONTEXT.md is written
+      writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001: Test\n\nFull context after discussion.\n');
+
+      // Wait past TTL
+      await new Promise(r => setTimeout(r, 150));
+
+      // Without invalidation, we'd still see 'needs-discussion'
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state2 = await deriveState(base);
+      // Should now be pre-planning (has context, but no roadmap yet)
+      // Actually needs-discussion won't trigger because now CONTEXT exists
+      // The state should advance past needs-discussion
+      assertTrue(
+        state2.phase !== 'needs-discussion',
+        '#1249: after context write + invalidation → not stuck in needs-discussion',
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── 3. State cache TTL expires naturally ─────────────────────────────
+  console.log('\n=== 3. state cache TTL: fresh reads after 100ms ===');
+  {
+    const base = createBase();
+    try {
+      writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
+
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state1 = await deriveState(base);
+      assertEq(state1.phase, 'pre-planning', 'initial: pre-planning');
+
+      // Write roadmap immediately
+      writeMilestoneFile(base, 'M001', 'ROADMAP', [
+        '# M001: Test',
+        '',
+        '## Slices',
+        '',
+        '- [ ] **S01: Slice** `risk:low` `depends:[]`',
+        '',
+      ].join('\n'));
+
+      // Immediately after writing (within 100ms TTL), the cache might be stale
+      const state2 = await deriveState(base);
+      // This MAY still show pre-planning if within TTL — that's expected behavior
+
+      // Wait past TTL
+      await new Promise(r => setTimeout(r, 150));
+
+      // ALSO invalidate parse cache (not just state cache)
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state3 = await deriveState(base);
+      assertEq(state3.phase, 'planning', 'after TTL expiry + invalidation → planning');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── 4. Task completion detection after file write ────────────────────
+  console.log('\n=== 4. task marked done in plan → state advances ===');
+  {
+    const base = createBase();
+    try {
+      writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
+      writeMilestoneFile(base, 'M001', 'ROADMAP', [
+        '# M001: Test',
+        '',
+        '## Slices',
+        '',
+        '- [ ] **S01: Slice** `risk:low` `depends:[]`',
+        '',
+      ].join('\n'));
+      writeSliceFile(base, 'M001', 'S01', 'PLAN', [
+        '# S01: Slice',
+        '',
+        '## Tasks',
+        '',
+        '- [ ] **T01: First Task** `est:1h`',
+        '- [ ] **T02: Second Task** `est:1h`',
+      ].join('\n'));
+      // Write task plan files
+      const tasksDir = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+      mkdirSync(tasksDir, { recursive: true });
+      writeFileSync(join(tasksDir, 'T01-PLAN.md'), '# T01\nDo thing.');
+      writeFileSync(join(tasksDir, 'T02-PLAN.md'), '# T02\nDo other thing.');
+
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state1 = await deriveState(base);
+      assertEq(state1.activeTask?.id, 'T01', 'initial: T01 is active task');
+
+      // Mark T01 as done by rewriting the plan
+      writeSliceFile(base, 'M001', 'S01', 'PLAN', [
+        '# S01: Slice',
+        '',
+        '## Tasks',
+        '',
+        '- [x] **T01: First Task** `est:1h`',
+        '- [ ] **T02: Second Task** `est:1h`',
+      ].join('\n'));
+
+      await new Promise(r => setTimeout(r, 150));
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state2 = await deriveState(base);
+      assertEq(state2.activeTask?.id, 'T02', 'after T01 done → T02 is active task');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── 5. Slice completion detection ────────────────────────────────────
+  console.log('\n=== 5. all tasks done → summarizing phase ===');
+  {
+    const base = createBase();
+    try {
+      writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
+      writeMilestoneFile(base, 'M001', 'ROADMAP', [
+        '# M001: Test',
+        '',
+        '## Slices',
+        '',
+        '- [ ] **S01: First** `risk:low` `depends:[]`',
+        '- [ ] **S02: Second** `risk:low` `depends:[S01]`',
+        '',
+      ].join('\n'));
+      writeSliceFile(base, 'M001', 'S01', 'PLAN', [
+        '# S01',
+        '',
+        '## Tasks',
+        '',
+        '- [ ] **T01: Task** `est:1h`',
+      ].join('\n'));
+      const tasksDir = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+      mkdirSync(tasksDir, { recursive: true });
+      writeFileSync(join(tasksDir, 'T01-PLAN.md'), '# T01\nDo it.');
+
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state1 = await deriveState(base);
+      assertEq(state1.phase, 'executing', 'initial: executing');
+
+      // Mark task done
+      writeSliceFile(base, 'M001', 'S01', 'PLAN', [
+        '# S01',
+        '',
+        '## Tasks',
+        '',
+        '- [x] **T01: Task** `est:1h`',
+      ].join('\n'));
+
+      await new Promise(r => setTimeout(r, 150));
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state2 = await deriveState(base);
+      assertEq(state2.phase, 'summarizing', 'after all tasks done → summarizing');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── 6. Roadmap slice marked done → advance to next slice ─────────────
+  console.log('\n=== 6. roadmap slice marked [x] → next slice active ===');
+  {
+    const base = createBase();
+    try {
+      writeMilestoneFile(base, 'M001', 'CONTEXT', '# M001\n\nDesc.\n');
+      writeMilestoneFile(base, 'M001', 'ROADMAP', [
+        '# M001: Test',
+        '',
+        '## Slices',
+        '',
+        '- [ ] **S01: First** `risk:low` `depends:[]`',
+        '- [ ] **S02: Second** `risk:low` `depends:[S01]`',
+        '',
+      ].join('\n'));
+
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state1 = await deriveState(base);
+      assertEq(state1.activeSlice?.id, 'S01', 'initial: S01 active');
+
+      // Mark S01 as done in roadmap
+      writeMilestoneFile(base, 'M001', 'ROADMAP', [
+        '# M001: Test',
+        '',
+        '## Slices',
+        '',
+        '- [x] **S01: First** `risk:low` `depends:[]`',
+        '- [ ] **S02: Second** `risk:low` `depends:[S01]`',
+        '',
+      ].join('\n'));
+
+      await new Promise(r => setTimeout(r, 150));
+      invalidateAllCaches();
+      invalidateStateCache();
+      const state2 = await deriveState(base);
+      assertEq(state2.activeSlice?.id, 'S02', 'after S01 done → S02 active');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -1086,9 +1086,9 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
-  // ─── smartStage always excludes .gsd/ ──────────────────────────────
+  // ─── smartStage excludes runtime files but allows milestone artifacts ──
 
-  console.log("\n=== smartStage always excludes .gsd/ ===");
+  console.log("\n=== smartStage excludes runtime files, allows milestone artifacts ===");
 
   {
     const repo = mkdtempSync(join(tmpdir(), "gsd-smart-stage-excludes-"));
@@ -1098,21 +1098,30 @@ async function main(): Promise<void> {
     writeFileSync(join(repo, "README.md"), "init");
     run("git add -A && git commit -m init", repo);
 
-    // Create .gsd/ planning files + a normal source file
+    // Create .gsd/ runtime files + milestone artifacts + a normal source file
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+    mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
+    mkdirSync(join(repo, ".gsd", "activity"), { recursive: true });
     writeFileSync(join(repo, ".gsd", "milestones", "M001", "ROADMAP.md"), "# Roadmap");
     writeFileSync(join(repo, ".gsd", "preferences.md"), "---\nversion: 1\n---");
+    writeFileSync(join(repo, ".gsd", "STATE.md"), "# State");
+    writeFileSync(join(repo, ".gsd", "runtime", "units.json"), "{}");
+    writeFileSync(join(repo, ".gsd", "activity", "log.jsonl"), "{}");
     writeFileSync(join(repo, "src.ts"), "const x = 1;");
 
-    // smartStage always excludes .gsd/ — state is managed externally
+    // smartStage excludes only runtime paths, not all of .gsd/ (#1326)
     const svc = new GitServiceImpl(repo);
     const msg = svc.commit({ message: "test commit" });
-    assertTrue(msg !== null, "smartStage: commit succeeds with non-.gsd files");
+    assertTrue(msg !== null, "smartStage: commit succeeds");
 
-    // .gsd/ files should NOT be in the commit
     const committed = run("git show --name-only HEAD", repo);
-    assertTrue(!committed.includes(".gsd/"), "smartStage: .gsd/ files not in commit");
     assertTrue(committed.includes("src.ts"), "smartStage: source files ARE in commit");
+    // Runtime files should NOT be committed
+    assertTrue(!committed.includes(".gsd/STATE.md"), "smartStage: STATE.md excluded (runtime)");
+    assertTrue(!committed.includes(".gsd/runtime/"), "smartStage: runtime/ excluded");
+    assertTrue(!committed.includes(".gsd/activity/"), "smartStage: activity/ excluded");
+    // Milestone artifacts SHOULD be committed when not gitignored (#1326)
+    assertTrue(committed.includes(".gsd/milestones/"), "smartStage: milestone artifacts ARE committed");
 
     rmSync(repo, { recursive: true, force: true });
   }

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

@@ -510,11 +510,8 @@ test("dispatch returns stop when phase=executing but activeSlice is null (corrup
 
 // ─── Phase 6: Worktree & Lock Consistency ────────────────────────────────
 
-test("repoIdentity returns same hash for main repo and worktree", async () => {
-  // This test verifies the fix for #1288 — identity hash must be stable
-  // across worktree and non-worktree contexts.
+test("repoIdentity returns a 12-char hex hash", async () => {
   const { repoIdentity } = await import("../repo-identity.ts");
-  // Call from the current directory (main repo)
   const hash = repoIdentity(process.cwd());
   assert.ok(hash.length === 12, `hash should be 12 hex chars, got: ${hash}`);
   assert.match(hash, /^[a-f0-9]{12}$/, `hash should be hex, got: ${hash}`);
@@ -609,10 +606,48 @@ test("session lock: onCompromised handler exists in both primary and retry paths
   const compromisedMatches = [...lockSource.matchAll(/onCompromised/g)];
   // Should have at least 2 onCompromised handlers (primary + retry)
   // plus the flag declaration and the check in validateSessionLock
-  assert.ok(compromisedMatches.length >= 3, 
+  assert.ok(compromisedMatches.length >= 3,
     `expected ≥3 onCompromised references (primary + retry + flag), got ${compromisedMatches.length}`);
 });
 
+test("session lock: both onCompromised handlers null _releaseFunction (#1315)", async () => {
+  const lockSource = readFileSync(
+    "src/resources/extensions/gsd/session-lock.ts", "utf-8"
+  );
+  // Extract onCompromised handler blocks — both should set _releaseFunction = null
+  const handlers = lockSource.match(/onCompromised:\s*\(\)\s*=>\s*\{[^}]+\}/g) || [];
+  assert.ok(handlers.length >= 2, `expected ≥2 onCompromised handlers, got ${handlers.length}`);
+  for (const h of handlers) {
+    assert.ok(h.includes("_releaseFunction = null"),
+      `onCompromised handler should null _releaseFunction: ${h}`);
+  }
+});
+
+test("session lock: exit handler uses ensureExitHandler to prevent double-registration (#1315)", async () => {
+  const lockSource = readFileSync(
+    "src/resources/extensions/gsd/session-lock.ts", "utf-8"
+  );
+  // Should use ensureExitHandler instead of direct process.once("exit") in acquire paths
+  const directExitHandlers = (lockSource.match(/process\.once\("exit"/g) || []).length;
+  const ensureExitCalls = (lockSource.match(/ensureExitHandler\(/g) || []).length;
+  // Only 1 direct process.once("exit") allowed — inside ensureExitHandler itself
+  assert.ok(directExitHandlers <= 1,
+    `expected ≤1 direct process.once("exit") (inside ensureExitHandler), got ${directExitHandlers}`);
+  assert.ok(ensureExitCalls >= 2,
+    `expected ≥2 ensureExitHandler calls (primary + retry path), got ${ensureExitCalls}`);
+});
+
+test("signal handler: SIGINT handler registered alongside SIGTERM (#1315)", async () => {
+  const supervisorSource = readFileSync(
+    "src/resources/extensions/gsd/auto-supervisor.ts", "utf-8"
+  );
+  // registerSigtermHandler should register on both SIGTERM and SIGINT
+  assert.ok(supervisorSource.includes('process.on("SIGINT"') || supervisorSource.includes("process.on('SIGINT'"),
+    "registerSigtermHandler should register SIGINT handler");
+  assert.ok(supervisorSource.includes('process.off("SIGINT"') || supervisorSource.includes("process.off('SIGINT'"),
+    "deregisterSigtermHandler should deregister SIGINT handler");
+});
+
 // ─── Scope 5: Crash Recovery — Message Guidance per Unit Type ────────────
 
 test("crash recovery: formatCrashInfo includes guidance for bootstrap crash", async () => {