gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -277,6 +277,14 @@ function buildDispatchCtx(
   };
 }
 
+function getUatVerdictGate(): import("../../auto-dispatch.ts").DispatchRule {
+  const rule = DISPATCH_RULES.find(
+    r => r.name === "uat-verdict-gate (non-PASS blocks progression)",
+  );
+  assert.ok(rule, "uat-verdict-gate rule should be registered");
+  return rule;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Suite
 // ═══════════════════════════════════════════════════════════════════════════
@@ -355,10 +363,13 @@ describe("state derivation failures", () => {
     const state2 = await deriveState(base);
     assert.equal(state2.phase, "executing", "cached result should still show executing");
 
-    // After explicit invalidation, should reflect the DB mutation
+    // After explicit invalidation, should reflect the DB mutation and reconcile
+    // missing plan tasks instead of prematurely summarizing a partial DB row set.
     invalidateStateCache();
     const state3 = await deriveState(base);
-    assert.equal(state3.phase, "summarizing", "after cache invalidation should show summarizing");
+    assert.equal(state3.phase, "executing", "after cache invalidation should continue with the missing plan task");
+    assert.equal(state3.activeTask?.id, "T02", "missing plan task T02 should be imported and selected");
+    assert.deepEqual(state3.progress?.tasks, { done: 1, total: 2 });
   });
 
   test("corrupt ROADMAP: binary content does not crash deriveState", async () => {
@@ -691,7 +702,7 @@ describe("transition boundary failures", () => {
     );
   });
 
-  test("blocked state: all slices have unmet deps → fallback picks slice", async () => {
+  test("blocked state: all slices have unmet deps → blocks", async () => {
     base = makeTempDir();
     const mDir = join(base, ".gsd", "milestones", "M001");
     mkdirSync(join(mDir, "slices", "S01", "tasks"), { recursive: true });
@@ -736,9 +747,9 @@ describe("transition boundary failures", () => {
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);
-    // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
-    assert.equal(state.phase, "planning", "circular deps: fallback picks a slice instead of blocking");
-    assert.ok(state.activeSlice !== null, "activeSlice set via fallback");
+    assert.equal(state.phase, "blocked", "circular deps: no slice should be selected through unmet deps");
+    assert.equal(state.activeSlice, null, "activeSlice should remain null when all deps are blocked");
+    assert.ok(state.blockers.some(b => b.includes("No slice eligible")));
   });
 });
 
@@ -868,6 +879,132 @@ describe("dispatch failure modes", () => {
     // run-uat should come before uat-verdict-gate
     assert.ok(runUatIdx < uatGateIdx, "run-uat should precede uat-verdict-gate");
   });
+
+  test("UAT verdict gate: ASSESSMENT FAIL blocks closed slice progression", async () => {
+    base = createFullFixture();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(
+      join(s01Dir, "S01-UAT.md"),
+      "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+    );
+    writeFileSync(
+      join(s01Dir, "S01-ASSESSMENT.md"),
+      "---\nverdict: FAIL\n---\n# UAT Assessment\n",
+    );
+
+    const ctx = buildDispatchCtx(base, "M001", {
+      phase: "planning",
+      activeSlice: { id: "S02", title: "Second" },
+      activeTask: null,
+    });
+    ctx.prefs = { uat_dispatch: true } as any;
+
+    const result = await getUatVerdictGate().match(ctx);
+    assert.equal(result?.action, "stop", "ASSESSMENT FAIL should block progression");
+    assert.ok(
+      (result as any).reason?.includes('UAT verdict for S01 is "fail"'),
+      "stop reason should report normalized ASSESSMENT verdict",
+    );
+  });
+
+  test("UAT verdict gate: ROADMAP fallback gates done slices when DB is unavailable", async () => {
+    base = createFullFixture();
+    const mDir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(
+      join(mDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Edge Case Milestone",
+        "",
+        "## Vision",
+        "Prove edge case correctness.",
+        "",
+        "## Success Criteria",
+        "- All edge cases handled",
+        "",
+        "## Slices",
+        "",
+        "- [x] **S01: First Feature** `risk:low` `depends:[]`",
+        "  - After this: First feature proven.",
+        "",
+        "- [ ] **S02: Second Feature** `risk:low` `depends:[]`",
+        "  - After this: Second feature proven.",
+        "",
+        "## Boundary Map",
+        "",
+        "| From | To | Produces | Consumes |",
+        "|------|----|----------|----------|",
+        "| S01 | terminal | feature-a | nothing |",
+        "| S02 | terminal | feature-b | nothing |",
+      ].join("\n"),
+    );
+
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(
+      join(s01Dir, "S01-UAT.md"),
+      "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+    );
+    writeFileSync(
+      join(s01Dir, "S01-ASSESSMENT.md"),
+      "---\nverdict: needs-remediation\n---\n# UAT Assessment\n",
+    );
+
+    const ctx = buildDispatchCtx(base, "M001", {
+      phase: "planning",
+      activeSlice: { id: "S02", title: "Second" },
+      activeTask: null,
+    });
+    ctx.prefs = { uat_dispatch: true } as any;
+
+    const result = await getUatVerdictGate().match(ctx);
+    assert.equal(result?.action, "stop", "ROADMAP done slices should be gated without DB");
+    assert.ok(
+      (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
+      "stop reason should report normalized ASSESSMENT verdict from disk fallback",
+    );
+  });
+
+  for (const status of ["done", "skipped"]) {
+    test(`UAT verdict gate: legacy closed status "${status}" is gated`, async () => {
+      base = createFullFixture();
+      openDatabase(join(base, ".gsd", "gsd.db"));
+      insertMilestone({ id: "M001", title: "Active", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "First", status });
+      insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+
+      const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      writeFileSync(
+        join(s01Dir, "S01-UAT.md"),
+        "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+      );
+      writeFileSync(
+        join(s01Dir, "S01-ASSESSMENT.md"),
+        "---\nverdict: needs-remediation\n---\n# UAT Assessment\n",
+      );
+
+      const ctx = buildDispatchCtx(base, "M001", {
+        phase: "planning",
+        activeSlice: { id: "S02", title: "Second" },
+        activeTask: null,
+      });
+      ctx.prefs = { uat_dispatch: true } as any;
+
+      const result = await getUatVerdictGate().match(ctx);
+      assert.equal(
+        result?.action,
+        "stop",
+        `${status} slices should be treated as closed for UAT verdict gating`,
+      );
+      assert.ok(
+        (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
+        "stop reason should report normalized ASSESSMENT verdict",
+      );
+    });
+  }
 });
 
 // ─────────────────────────────────────────────────────────────────────────
@@ -1155,7 +1292,7 @@ describe("dispatch guard integration", () => {
     assert.ok(existsSync(validationPath), "VALIDATION file should be written");
     const content = readFileSync(validationPath, "utf-8");
     assert.ok(content.includes("verdict: pass"), "should contain pass verdict");
-    assert.ok(content.includes("skipped by preference"), "should note it was skipped");
+    assert.ok(content.includes("`skip_milestone_validation` preference"), "should note it was skipped via the preference path (#4781)");
   });
 
   test("rewrite-docs circuit breaker: exceeding MAX attempts resolves all overrides", async () => {

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -936,9 +936,11 @@ describe("state-machine-live-validation", () => {
       insertMilestone({ id: "M001", title: "Active", status: "active" });
       insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "in_progress" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "pending" });
+      insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", status: "pending" });
 
       // Complete task + slice
       await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      await handleCompleteTask(makeTaskParams("T02", "S01", "M001") as any, base);
       await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
 
@@ -946,9 +948,11 @@ describe("state-machine-live-validation", () => {
       await handleReopenSlice({ milestoneId: "M001", sliceId: "S01" }, base);
       assert.equal(getSlice("M001", "S01")!.status, "in_progress");
       assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
+      assert.equal(getTask("M001", "S01", "T02")!.status, "pending");
 
       // Re-complete task + slice succeeds
       await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      await handleCompleteTask(makeTaskParams("T02", "S01", "M001") as any, base);
       const r = await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(!("error" in r), `re-complete slice: ${JSON.stringify(r)}`);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -48,9 +48,7 @@ import type { WindowEntry } from "../../auto/types.ts";
 import {
   AutoSession,
   NEW_SESSION_TIMEOUT_MS,
-  MAX_UNIT_DISPATCHES,
   STUB_RECOVERY_THRESHOLD,
-  MAX_LIFETIME_DISPATCHES,
 } from "../../auto/session.ts";
 
 // ── Auto-loop types ──────────────────────────────────────────────────────
@@ -364,14 +362,6 @@ describe("session management", () => {
     assert.equal(NEW_SESSION_TIMEOUT_MS, 120_000, "session timeout should be 120s");
   });
 
-  test("MAX_UNIT_DISPATCHES limits retries for a single unit", () => {
-    assert.equal(MAX_UNIT_DISPATCHES, 3, "max unit dispatches should be 3");
-  });
-
-  test("MAX_LIFETIME_DISPATCHES is the absolute limit per unit", () => {
-    assert.equal(MAX_LIFETIME_DISPATCHES, 6, "max lifetime dispatches should be 6");
-  });
-
   test("STUB_RECOVERY_THRESHOLD triggers recovery after N stub completions", () => {
     assert.equal(STUB_RECOVERY_THRESHOLD, 2, "stub recovery threshold should be 2");
   });
@@ -392,12 +382,8 @@ describe("session management", () => {
     s.unitDispatchCount.set(unitId, 2);
     assert.equal(s.unitDispatchCount.get(unitId), 2);
 
-    // Exceeding MAX_UNIT_DISPATCHES
-    s.unitDispatchCount.set(unitId, MAX_UNIT_DISPATCHES + 1);
-    assert.ok(
-      s.unitDispatchCount.get(unitId)! > MAX_UNIT_DISPATCHES,
-      "should track count beyond max for detection",
-    );
+    s.unitDispatchCount.set(unitId, 4);
+    assert.equal(s.unitDispatchCount.get(unitId), 4);
   });
 
   test("AutoSession toJSON() provides diagnostic snapshot", () => {

package/src/resources/extensions/gsd/tests/interrupted-session-ui.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -126,11 +126,8 @@ test("guided-flow stale paused-session scenario is suppressed when no resumable
   }
 });
 
-test("guided-flow source uses step-aware resume and clears stale paused metadata without changing discuss handoff semantics", () => {
-  const source = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  assert.ok(source.includes('const interrupted = await assessInterruptedSession(basePath);'));
-  assert.ok(source.includes('resumeLabel = interrupted.pausedSession?.stepMode'));
-  assert.ok(source.includes('step: interrupted.pausedSession?.stepMode ?? false'));
-  assert.ok(source.includes('unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"))'));
-  assert.ok(source.includes('pendingAutoStartMap.set(basePath,'));
-});
+// Note: the prior source-grep test that scanned guided-flow.ts for five
+// string literals was removed under #4827. The invariants it encoded
+// (step-aware resume + stale paused-session cleanup + pendingAutoStartMap
+// side effect) should be covered by a runtime drive of guided-flow —
+// tracked as a follow-up.

package/src/resources/extensions/gsd/tests/mcp-client-security.test.ts

@@ -1,12 +1,19 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
 
 import {
   _buildMcpChildEnvForTest,
   _buildMcpTrustConfirmOptionsForTest,
 } from "../../mcp-client/index.ts";
 
+// Note: four source-grep tests that scanned `mcp-client/index.ts` for
+// Map<> shapes, catch-block structure, and closeAll body were removed
+// under #4827. They encoded implementation shape rather than behaviour —
+// any refactor (extracted helper, different Map key type, rearranged
+// cleanup order) broke the greps without a real regression. Runtime
+// coverage of connectServer/closeAll with a mocked failing transport
+// is tracked as a follow-up.
+
 test("MCP stdio child env only includes safe inherited keys plus explicit config env", () => {
   const previousSecret = process.env.SECRET_MCP_TEST_TOKEN;
   const previousPath = process.env.PATH;
@@ -38,39 +45,3 @@ test("MCP stdio trust confirmation is abort-aware", () => {
   assert.equal(options.timeout, 120_000);
   assert.equal(options.signal, controller.signal);
 });
-
-test("MCP client uses a single in-flight connection per canonical server", () => {
-  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
-
-  assert.match(source, /const pendingConnections = new Map<string, Promise<Client>>\(\)/);
-  assert.match(source, /const pending = pendingConnections\.get\(config\.name\)/);
-  assert.match(source, /pendingConnections\.set\(config\.name, connectionPromise\)/);
-  assert.match(source, /pendingConnections\.delete\(config\.name\)/);
-  assert.match(source, /env: config\.env \?\? \{\}/);
-});
-
-test("MCP stdio trust is persisted only after a successful connection", () => {
-  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
-  const connectIndex = source.indexOf("await client.connect(transport");
-  const trustIndex = source.indexOf("trustedStdioServers.add(approvedTrustKey)");
-
-  assert.ok(connectIndex > -1, "connectServer should await client.connect");
-  assert.ok(trustIndex > connectIndex, "trust should be recorded after client.connect succeeds");
-  assert.doesNotMatch(source, /assertTrustedStdioServer[\s\S]*trustedStdioServers\.add\(trustKey\)/);
-});
-
-test("MCP client closes transports after failed connection attempts", () => {
-  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
-
-  assert.match(source, /catch \(err\) \{[\s\S]*await transport\.close\(\)/);
-  assert.match(source, /catch \(err\) \{[\s\S]*await client\.close\(\)/);
-  assert.match(source, /catch \(err\) \{[\s\S]*throw err/);
-});
-
-test("MCP client clears process-local trust and closes transports on session cleanup", () => {
-  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
-
-  assert.match(source, /async function closeAll\(\)[\s\S]*await conn\.transport\.close\(\)/);
-  assert.match(source, /async function closeAll\(\)[\s\S]*pendingConnections\.clear\(\)/);
-  assert.match(source, /async function closeAll\(\)[\s\S]*trustedStdioServers\.clear\(\)/);
-});

package/src/resources/extensions/gsd/tests/memory-extractor.test.ts

@@ -1,4 +1,4 @@
-import { parseMemoryResponse, _resetExtractionState, buildMemoryLLMCall } from '../memory-extractor.ts';
+import { parseMemoryResponse, buildMemoryLLMCall } from '../memory-extractor.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -159,16 +159,6 @@ test('integration: mixed action lifecycle', () => {
   closeDatabase();
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: _resetExtractionState
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('memory-extractor: reset extraction state', () => {
-  // Just verify it doesn't throw
-  _resetExtractionState();
-  assert.ok(true, '_resetExtractionState should not throw');
-});
-
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-extractor: buildMemoryLLMCall resolves OAuth API key via modelRegistry
 // Regression test for #2959 — OAuth users had broken memory extraction
@@ -200,8 +190,8 @@ test('memory-extractor: buildMemoryLLMCall resolves API key from modelRegistry f
   assert.ok(llmCallFn !== null, 'buildMemoryLLMCall should return a function when models are available');
 
   // The function should have resolved the API key eagerly via modelRegistry.getApiKey.
-  // Give the async getApiKey a tick to resolve.
-  await new Promise(resolve => setTimeout(resolve, 50));
+  // Await the exposed promise deterministically instead of polling via setTimeout.
+  await llmCallFn!.apiKeyReady;
   assert.ok(getApiKeyCalled, 'buildMemoryLLMCall must call modelRegistry.getApiKey() to resolve OAuth tokens');
 });
 
@@ -246,8 +236,8 @@ test('memory-extractor: buildMemoryLLMCall prefers haiku model', async () => {
   const llmCallFn = buildMemoryLLMCall(ctx);
   assert.ok(llmCallFn !== null, 'should return a function');
 
-  // Wait for the async getApiKey to resolve
-  await new Promise(resolve => setTimeout(resolve, 50));
+  // Await the exposed API-key-ready promise deterministically.
+  await llmCallFn!.apiKeyReady;
   assert.strictEqual(resolvedModelId, 'claude-3-5-haiku-20241022',
     'should resolve API key for haiku model, not sonnet');
 });