gsd-pi 2.31.2-dev.64d8832 → 2.31.2-dev.c8d7e03

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

@@ -0,0 +1,127 @@
+/**
+ * auto-reentrancy-guard.test.ts — Tests for the unconditional reentrancy guard.
+ *
+ * Regression for #1272: auto-mode stuck-loop where gap watchdog or
+ * pendingAgentEndRetry could enter dispatchNextUnit concurrently during
+ * recursive skip chains because the reentrancy guard was bypassed when
+ * skipDepth > 0.
+ *
+ * The fix makes the guard unconditional (`if (s.dispatching)` without
+ * `&& s.skipDepth === 0`), and defers recursive re-dispatch via
+ * setImmediate/setTimeout so s.dispatching is released first.
+ */
+
+import {
+  _getDispatching,
+  _setDispatching,
+  _getSkipDepth,
+  _setSkipDepth,
+} from "../auto.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  // ─── Test-only accessors work ───────────────────────────────────────────
+  console.log("\n=== reentrancy guard: test accessors round-trip ===");
+  {
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching starts false");
+
+    _setDispatching(true);
+    assertEq(_getDispatching(), true, "dispatching set to true");
+
+    _setDispatching(false);
+    assertEq(_getDispatching(), false, "dispatching reset to false");
+  }
+
+  // ─── skipDepth accessors ────────────────────────────────────────────────
+  console.log("\n=== reentrancy guard: skipDepth accessors round-trip ===");
+  {
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth starts at 0");
+
+    _setSkipDepth(3);
+    assertEq(_getSkipDepth(), 3, "skipDepth set to 3");
+
+    _setSkipDepth(0);
+    assertEq(_getSkipDepth(), 0, "skipDepth reset to 0");
+  }
+
+  // ─── Guard blocks even when skipDepth > 0 (#1272 regression) ───────────
+  console.log("\n=== reentrancy guard: blocks when dispatching=true regardless of skipDepth ===");
+  {
+    // Simulate the scenario from #1272: dispatching=true + skipDepth>0
+    // The old guard (`if (s.dispatching && s.skipDepth === 0)`) would allow
+    // concurrent entry when skipDepth > 0. The fix makes the check
+    // unconditional on skipDepth.
+    _setDispatching(true);
+    _setSkipDepth(2);
+
+    // Verify dispatching is true — guard should block regardless of skipDepth
+    assertTrue(
+      _getDispatching() === true,
+      "dispatching flag is true during skip chain"
+    );
+
+    // The actual reentrancy guard in dispatchNextUnit checks:
+    //   if (s.dispatching) { return; }
+    // We verify the state that would trigger the guard:
+    const wouldBlock = _getDispatching(); // unconditional check
+    const wouldBlockOld = _getDispatching() && _getSkipDepth() === 0; // old check
+
+    assertTrue(wouldBlock === true, "new guard blocks when dispatching=true, skipDepth=2");
+    assertTrue(wouldBlockOld === false, "old guard WOULD NOT block when dispatching=true, skipDepth=2 (the bug)");
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  // ─── Guard allows entry when dispatching=false ──────────────────────────
+  console.log("\n=== reentrancy guard: allows entry when dispatching=false ===");
+  {
+    _setDispatching(false);
+    _setSkipDepth(0);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=0");
+
+    _setDispatching(false);
+    _setSkipDepth(3);
+    assertTrue(!_getDispatching(), "guard allows entry when dispatching=false, skipDepth=3");
+
+    _setSkipDepth(0);
+  }
+
+  // ─── skipDepth does not affect guard decision (the fix) ─────────────────
+  console.log("\n=== reentrancy guard: skipDepth is irrelevant to guard decision ===");
+  {
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(true);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === true,
+        `guard blocks at skipDepth=${depth} when dispatching=true`
+      );
+    }
+
+    for (const depth of [0, 1, 2, 5]) {
+      _setDispatching(false);
+      _setSkipDepth(depth);
+      assertTrue(
+        _getDispatching() === false,
+        `guard allows at skipDepth=${depth} when dispatching=false`
+      );
+    }
+
+    // Clean up
+    _setDispatching(false);
+    _setSkipDepth(0);
+  }
+
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -6,7 +6,8 @@
 //   (a)–(j)  extractUatType classification (17 assertions from T01)
 //   (k)      run-uat prompt template loading and content integrity (8 assertions)
 //   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
-//   (m)      stale replay guard: existing UAT-RESULT never re-dispatches (2 assertions)
+//   (m)      non-artifact UAT skip: human-experience UATs are not dispatched (1 assertion)
+//   (n)      stale replay guard: existing UAT-RESULT never re-dispatches (1 assertion)
 
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
@@ -254,8 +255,8 @@ async function main(): Promise<void> {
     'prompt contains artifact-driven execution language (artifact/execute/run)',
   );
   assertTrue(
-    /surfaced for human review/i.test(promptResult ?? ''),
-    'prompt contains "surfaced for human review" text for non-artifact-driven path',
+    !/surfaced for human review/i.test(promptResult ?? ''),
+    'prompt does not contain "surfaced for human review" (non-artifact UATs are skipped, not dispatched)',
   );
 
   // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
@@ -310,8 +311,56 @@ async function main(): Promise<void> {
     }
   }
 
-  // ─── (m) stale replay guard: existing UAT-RESULT never re-dispatches ─────
-  console.log('\n── (m) stale replay guard');
+  // ─── (m) non-artifact UATs are skipped (not dispatched) ─────────────────
+  console.log('\n── (m) non-artifact UAT skip');
+
+  {
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // human-experience UAT — should not dispatch
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assertEq(
+        result,
+        null,
+        'human-experience UAT is skipped — auto-mode only dispatches artifact-driven UATs',
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── (n) existing UAT-RESULT never re-dispatches ──────────────────────
+  console.log('\n── (n) stale replay guard');
 
   {
     const base = createFixtureBase();
@@ -334,7 +383,7 @@ async function main(): Promise<void> {
       );
 
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: surfaced-for-human-review\n---\n');
+      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: FAIL\n---\n');
 
       const state = {
         activeMilestone: { id: 'M001', title: 'Test roadmap' },
@@ -351,7 +400,7 @@ async function main(): Promise<void> {
       assertEq(
         result,
         null,
-        'existing UAT-RESULT with non-PASS verdict does not re-dispatch run-uat; verdict gate owns blocking',
+        'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
       );
     } finally {
       cleanup(base);