@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

package/src/resources/extensions/gsd/tests/unit-registry.test.ts

@@ -0,0 +1,163 @@
+// gsd-pi — ADR-033 Unit Registry parity guard.
+//
+// Pins every view derived from UNIT_REGISTRY to the exact values the
+// hand-maintained tables held before the registry existed. A failure here
+// means a registry edit changed a derived surface — intended changes update
+// the pinned expectation in the same diff.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  KNOWN_UNIT_TYPES,
+  UNIT_REGISTRY,
+  EXECUTE_TASK_UNIT_TYPES,
+  SECTION_CLOSE_GATE_UNIT_TYPES,
+  getUnitDescriptor,
+  getUnitPhaseChain,
+} from "../unit-registry.ts";
+import {
+  AUTO_UNIT_SCOPED_TOOLS,
+  UNIT_TOOL_CONTRACTS,
+  getUnitToolSurfaceContract,
+} from "../unit-tool-contracts.ts";
+import { UNIT_MANIFESTS } from "../unit-context-manifest.ts";
+import { phaseChainForUnit } from "../preferences-models.ts";
+
+// ─── Pinned pre-registry values ───────────────────────────────────────────
+
+const EXPECTED_KNOWN_UNIT_TYPES = [
+  "research-milestone",
+  "plan-milestone",
+  "discuss-milestone",
+  "validate-milestone",
+  "complete-milestone",
+  "research-slice",
+  "plan-slice",
+  "refine-slice",
+  "replan-slice",
+  "complete-slice",
+  "reassess-roadmap",
+  "execute-task",
+  "reactive-execute",
+  "run-uat",
+  "gate-evaluate",
+  "rewrite-docs",
+  "triage-captures",
+  "quick-task",
+  "workflow-preferences",
+  "discuss-project",
+  "discuss-requirements",
+  "research-decision",
+  "research-project",
+];
+
+// The contract table carried two keys KNOWN_UNIT_TYPES never had (variants)
+// and lacked two it did have (sidecars without contracts).
+const EXPECTED_CONTRACT_ONLY_TYPES = ["discuss-slice", "execute-task-simple"];
+const EXPECTED_CONTRACT_LESS_TYPES = ["triage-captures", "quick-task"];
+
+const EXPECTED_EXECUTE_TASK_SET = ["execute-task", "execute-task-simple", "reactive-execute"];
+const EXPECTED_SECTION_CLOSE_SET = [
+  ...EXPECTED_EXECUTE_TASK_SET,
+  "complete-slice",
+  "validate-milestone",
+];
+
+const EXPECTED_PHASE_CHAINS: Record<string, string[] | undefined> = {
+  "research-milestone": ["research"],
+  "research-slice": ["research"],
+  "research-project": ["research"],
+  "plan-milestone": ["planning"],
+  "plan-slice": ["planning"],
+  "refine-slice": ["planning"],
+  "replan-slice": ["planning"],
+  "discuss-milestone": ["discuss", "planning"],
+  "discuss-slice": ["discuss", "planning"],
+  "discuss-project": ["discuss", "planning"],
+  "discuss-requirements": ["discuss", "planning"],
+  "workflow-preferences": ["discuss", "planning"],
+  "research-decision": ["discuss", "planning"],
+  "execute-task": ["execution"],
+  "reactive-execute": ["execution"],
+  "execute-task-simple": ["execution_simple", "execution"],
+  "complete-slice": ["completion"],
+  "complete-milestone": ["completion"],
+  "worktree-merge": ["completion"],
+  "run-uat": ["uat", "completion"],
+  "reassess-roadmap": ["validation", "planning"],
+  "rewrite-docs": ["validation", "planning"],
+  "gate-evaluate": ["validation", "planning"],
+  "validate-milestone": ["validation", "planning"],
+  "triage-captures": undefined,
+  "quick-task": undefined,
+  subagent: ["subagent"],
+  "subagent/scout": ["subagent"],
+  "no-such-unit": undefined,
+};
+
+// ─── Derived-view parity ──────────────────────────────────────────────────
+
+test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
+  assert.deepEqual([...KNOWN_UNIT_TYPES], EXPECTED_KNOWN_UNIT_TYPES);
+});
+
+test("UNIT_TOOL_CONTRACTS keeps the pre-registry key set, asymmetries included", () => {
+  const contractKeys = Object.keys(UNIT_TOOL_CONTRACTS);
+  for (const variant of EXPECTED_CONTRACT_ONLY_TYPES) {
+    assert.ok(contractKeys.includes(variant), `variant ${variant} must keep its contract`);
+    assert.ok(!KNOWN_UNIT_TYPES.includes(variant as never), `${variant} must stay out of KNOWN_UNIT_TYPES`);
+  }
+  for (const sidecar of EXPECTED_CONTRACT_LESS_TYPES) {
+    assert.ok(!contractKeys.includes(sidecar), `${sidecar} must stay contract-less`);
+    assert.equal(getUnitToolSurfaceContract(sidecar), undefined);
+  }
+  const expectedKeys = [
+    ...EXPECTED_KNOWN_UNIT_TYPES.filter((t) => !EXPECTED_CONTRACT_LESS_TYPES.includes(t)),
+    ...EXPECTED_CONTRACT_ONLY_TYPES,
+  ].sort();
+  assert.deepEqual([...contractKeys].sort(), expectedKeys);
+});
+
+test("scope-class Sets match the pre-registry hand-maintained Sets", () => {
+  assert.deepEqual([...EXECUTE_TASK_UNIT_TYPES].sort(), [...EXPECTED_EXECUTE_TASK_SET].sort());
+  assert.deepEqual([...SECTION_CLOSE_GATE_UNIT_TYPES].sort(), [...EXPECTED_SECTION_CLOSE_SET].sort());
+});
+
+test("phaseChainForUnit matches the pre-registry switch for every known input", () => {
+  for (const [unitType, expected] of Object.entries(EXPECTED_PHASE_CHAINS)) {
+    assert.deepEqual(
+      phaseChainForUnit(unitType),
+      expected,
+      `phase chain for ${unitType}`,
+    );
+  }
+});
+
+test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
+  for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
+    assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);
+  }
+  assert.deepEqual(
+    Object.keys(AUTO_UNIT_SCOPED_TOOLS).sort(),
+    Object.keys(UNIT_TOOL_CONTRACTS).sort(),
+  );
+});
+
+// ─── Registry-internal coherence ──────────────────────────────────────────
+
+test("every primary unit type has a manifest; manifests cover nothing else", () => {
+  const manifestKeys = Object.keys(UNIT_MANIFESTS).sort();
+  assert.deepEqual(manifestKeys, [...KNOWN_UNIT_TYPES].sort());
+});
+
+test("every registry row is reachable through the descriptor accessor", () => {
+  for (const unitType of Object.keys(UNIT_REGISTRY)) {
+    const descriptor = getUnitDescriptor(unitType);
+    assert.ok(descriptor, `descriptor for ${unitType}`);
+    assert.ok(["primary", "variant"].includes(descriptor.kind));
+    assert.ok(["execute-task", "section-close", "standard"].includes(descriptor.scopeClass));
+    assert.equal(getUnitPhaseChain(unitType), descriptor.phaseChain);
+  }
+  assert.equal(getUnitDescriptor("no-such-unit"), undefined);
+});

package/src/resources/extensions/gsd/tests/user-input-boundary.test.ts

@@ -2,7 +2,11 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import * as userInputBoundary from "../user-input-boundary.ts";
-import { isAwaitingUserInput, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.ts";
+import {
+  isAwaitingUserInput,
+  messageHasPendingAskUserQuestionsTool,
+  shouldPauseForUserApprovalQuestion,
+} from "../user-input-boundary.ts";
 
 test("lastAssistantText extracts the latest assistant text block content", () => {
   const lastAssistantText = (userInputBoundary as {
@@ -73,6 +77,87 @@ test("isAwaitingUserInput does not trigger on thinking-block approval phrases",
   assert.equal(shouldPauseForUserApprovalQuestion("discuss-requirements", messages), false);
 });
 
+test("messageHasPendingAskUserQuestionsTool detects in-flight structured question tools", () => {
+  // state: "running" with no externalResult → still in-flight
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "text", text: "Which direction?" },
+        { type: "toolCall", name: "mcp__gsd-workflow__ask_user_questions", state: "running" },
+      ],
+    }),
+    true,
+  );
+
+  // no state, no externalResult — streaming block that hasn't completed yet
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "toolCall", name: "ask_user_questions" },
+      ],
+    }),
+    true,
+  );
+
+  // state: "completed" — legacy state-based completion
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "toolCall", name: "ask_user_questions", state: "completed" },
+      ],
+    }),
+    false,
+  );
+
+  // externalResult present — Claude Code signals completion via externalResult, not state
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "toolCall", name: "ask_user_questions", externalResult: { content: [], isError: false } },
+      ],
+    }),
+    false,
+  );
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        {
+          type: "toolCall",
+          name: "ask_user_questions",
+          externalResult: { content: [{ type: "text", text: "answer" }], isError: false },
+        },
+      ],
+    }),
+    false,
+  );
+
+  // serverToolUse shape (claude-code-cli MCP path) — no externalResult → in-flight
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "serverToolUse", name: "mcp__gsd-workflow__ask_user_questions" },
+      ],
+    }),
+    true,
+  );
+  // serverToolUse shape — externalResult present → completed
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "serverToolUse", name: "ask_user_questions", externalResult: { content: [], isError: false } },
+      ],
+    }),
+    false,
+  );
+});
+
 test("isAwaitingUserInput still triggers on text-block question marks when thinking is also present", () => {
   // When thinking + text are both present and the text asks a question, it should still pause.
   const messages = [

package/src/resources/extensions/gsd/tests/validate-milestone-stuck-guard.test.ts

@@ -12,6 +12,7 @@ import { clearPathCache } from "../paths.ts";
 import {
   openDatabase,
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
 } from "../gsd-db.ts";
@@ -222,6 +223,44 @@ describe("validate-milestone stuck-loop guard (#4094)", () => {
     assert.equal(s.pendingVerificationRetry, null);
   });
 
+  test("continues when DB pass overrides stale worktree needs-attention after /gsd verdict", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    writeWorktreeValidationFile("needs-attention");
+
+    const worktreeValidationPath = join(
+      tempDir,
+      ".gsd",
+      "worktrees",
+      "M001",
+      ".gsd",
+      "milestones",
+      "M001",
+      "M001-VALIDATION.md",
+    );
+    insertAssessment({
+      path: worktreeValidationPath,
+      milestoneId: "M001",
+      sliceId: null,
+      taskId: null,
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: pass\n---\n\n# Validation\nManually overridden via /gsd verdict\n",
+    });
+    invalidateAllCaches();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.equal(ctx.ui.notify.mock.callCount(), 0);
+  });
+
   test("retries when no VALIDATION file exists yet", async () => {
     insertMilestone({ id: "M001" });
     insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });

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

@@ -0,0 +1,193 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  buildWebAppUatGuidanceBlock,
+  detectWebApp,
+  findPlaywrightTestScript,
+  hasPlaywrightTestDependency,
+} from "../web-app-uat.ts";
+
+function scaffoldProject(root: string, pkg: Record<string, unknown>): void {
+  writeFileSync(join(root, "package.json"), JSON.stringify(pkg, null, 2));
+}
+
+const LEGACY_ENGINE = { engine: "legacy", source: "probe", reason: "test" } as const;
+const MANAGED_ENGINE = { engine: "gsd-browser", source: "probe", reason: "test" } as const;
+const OFF_ENGINE = { engine: "off", source: "env", reason: "test" } as const;
+
+describe("web-app-uat guidance", () => {
+  test("returns null for non-web projects", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      writeFileSync(join(root, "README.md"), "# CLI tool\n");
+      assert.equal(detectWebApp(root), false);
+      assert.equal(buildWebAppUatGuidanceBlock(root), null);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("returns guidance for react/vite web apps", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0", "react-dom": "19.0.0" },
+        devDependencies: { vite: "6.0.0" },
+        scripts: { dev: "vite" },
+      });
+      assert.equal(detectWebApp(root), true);
+      const block = buildWebAppUatGuidanceBlock(root, LEGACY_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /browser-executable/);
+      assert.match(block!, /Playwright-backed `browser_\*` tools/);
+      assert.match(block!, /Playwright scaffolding/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("describes the managed gsd-browser engine when it is the resolved backing", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, MANAGED_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /managed gsd-browser engine/);
+      assert.match(block!, /browser-executable/);
+      assert.doesNotMatch(block!, /Playwright-backed/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("steers to runtime-executable UAT when browser tools are off", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, OFF_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /browser tools are disabled/);
+      assert.doesNotMatch(block!, /- `browser-executable`/);
+      // mixed/live-runtime require browser tools per UAT_MODE_POLICIES, so the
+      // bullet must drop out too — recommending them would dead-end at dispatch.
+      assert.doesNotMatch(block!, /- `mixed`/);
+      assert.doesNotMatch(block!, /interactive `browser_\*` checks/);
+      assert.match(block!, /runtime-executable/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("detects existing Playwright and npm script", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { next: "15.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0", playwright: "1.60.0" },
+        scripts: { "test:e2e": "playwright test" },
+      });
+      assert.equal(hasPlaywrightTestDependency(root), true);
+      assert.equal(findPlaywrightTestScript(root), "npm run test:e2e");
+      const block = buildWebAppUatGuidanceBlock(root);
+      assert.ok(block);
+      assert.match(block!, /dependency detected/);
+      assert.match(block!, /npm run test:e2e/);
+      assert.doesNotMatch(block!, /Playwright scaffolding/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("does not mistake a non-playwright e2e script as playwright", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0" },
+        scripts: { e2e: "cypress run", dev: "vite" },
+      });
+      // The e2e script runs Cypress, not Playwright — must not be returned
+      assert.equal(findPlaywrightTestScript(root), null);
+      const block = buildWebAppUatGuidanceBlock(root);
+      assert.ok(block);
+      // Playwright dep is present so guidance shows "dependency detected", not "scaffolding"
+      assert.match(block!, /dependency detected/);
+      assert.doesNotMatch(block!, /Playwright scaffolding/);
+      // Falls back to generic npx command because no playwright-named script exists
+      assert.doesNotMatch(block!, /npm run e2e/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("recognises playwright via script value even without a local dependency", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { next: "15.0.0" },
+        scripts: { "test:e2e": "npx playwright test" },
+      });
+      assert.equal(hasPlaywrightTestDependency(root), false);
+      assert.equal(findPlaywrightTestScript(root), "npm run test:e2e");
+      const block = buildWebAppUatGuidanceBlock(root);
+      assert.ok(block);
+      // Script-based detection should trigger "dependency detected" path, not scaffolding
+      assert.match(block!, /dependency detected/);
+      assert.match(block!, /npm run test:e2e/);
+      assert.doesNotMatch(block!, /Playwright scaffolding/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("does not treat playwright install script as a test command", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0" },
+        // postinstall runs 'playwright install' (browser setup), not a test
+        scripts: { postinstall: "playwright install", "test:e2e": "npx playwright test" },
+      });
+      // install script must not be returned; the real test script should be
+      assert.equal(findPlaywrightTestScript(root), "npm run test:e2e");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("returns null when only an install script mentions playwright", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0" },
+        scripts: { postinstall: "playwright install --with-deps" },
+      });
+      assert.equal(findPlaywrightTestScript(root), null);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("detects static sites via index.html", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      mkdirSync(join(root, "public"), { recursive: true });
+      writeFileSync(join(root, "public", "index.html"), "<html></html>");
+      assert.equal(detectWebApp(root), true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});