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

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

@@ -0,0 +1,150 @@
+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));
+}
+
+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);
+      assert.ok(block);
+      assert.match(block!, /browser-executable/);
+      assert.match(block!, /Playwright scaffolding/);
+    } 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 });
+    }
+  });
+});

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

@@ -17,9 +17,11 @@ import {
   getRequiredWorkflowToolsForAutoUnit,
   getRequiredWorkflowToolsForGuidedUnit,
   resolveWorkflowMcpProjectRoot,
+  isWorkflowMcpSurfaceTool,
   supportsStructuredQuestions,
   usesWorkflowMcpTransport,
 } from "../workflow-mcp.ts";
+import { DB_WORKFLOW_TOOL_NAMES } from "../workflow-tool-surface.ts";
 
 const MCP_STDIO_TIMEOUT_MS = 90_000;
 
@@ -109,6 +111,18 @@ test("workflow MCP capability surface includes native legacy gsd aliases", () =>
   assert.equal(err, null);
 });
 
+test("workflow MCP capability surface includes every shared workflow contract tool", () => {
+  for (const name of DB_WORKFLOW_TOOL_NAMES) {
+    assert.equal(isWorkflowMcpSurfaceTool(name), true, `${name} should be in workflow MCP surface`);
+  }
+});
+
+test("workflow MCP capability surface preserves session and read tools outside DB contracts", () => {
+  for (const name of ["gsd_execute", "gsd_status", "gsd_progress", "gsd_doctor", "gsd_graph"]) {
+    assert.equal(isWorkflowMcpSurfaceTool(name), true, `${name} should stay in workflow MCP surface`);
+  }
+});
+
 test("deep project setup units declare required workflow MCP tools", () => {
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("discuss-project"), [
     "ask_user_questions",
@@ -615,23 +629,47 @@ test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
 });
 
-test("supportsStructuredQuestions disables local workflow MCP questions unless explicitly enabled", () => {
+test("supportsStructuredQuestions recognizes workflow MCP question tools", () => {
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {
       authMode: "externalCli",
       baseUrl: "local://claude-code",
       env: {},
     }),
-    false,
+    true,
   );
   assert.equal(
     supportsStructuredQuestions(["mcp__gsd-workflow__ask_user_questions"], {
       authMode: "externalCli",
       baseUrl: "local://claude-code",
-      env: { GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS: "1" } as NodeJS.ProcessEnv,
+      env: {},
+    }),
+    true,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["mcp__gsd-workflow__*"], {
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      env: {},
     }),
     true,
   );
+  assert.equal(
+    supportsStructuredQuestions(["mcp__gsd-browser__*"], {
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      env: {},
+    }),
+    false,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["mcp__gsd-workflow__ask_user_questions"], {
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      env: { GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS: "0" } as NodeJS.ProcessEnv,
+    }),
+    false,
+  );
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {
       authMode: "oauth",
@@ -648,6 +686,39 @@ test("supportsStructuredQuestions disables local workflow MCP questions unless e
   );
 });
 
+test("supportsStructuredQuestions gates non-local externalCli providers", () => {
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "externalCli",
+      env: {},
+    }),
+    true,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "externalCli",
+      baseUrl: "https://api.example.com",
+      env: {},
+    }),
+    true,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "externalCli",
+      env: { GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS: "0" } as NodeJS.ProcessEnv,
+    }),
+    false,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "externalCli",
+      baseUrl: "https://api.example.com",
+      env: { GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS: "0" } as NodeJS.ProcessEnv,
+    }),
+    false,
+  );
+});
+
 test("transport compatibility passes when required tools fit current MCP surface", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
@@ -835,7 +906,7 @@ test("transport compatibility now allows replan-slice over workflow MCP surface"
   assert.equal(error, null);
 });
 
-test("transport compatibility rejects MCP tools not connected in active tool surface", () => {
+test("transport compatibility accepts workflow MCP tools absent from parent active tool surface", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
     ["gsd_summary_save"],
@@ -850,10 +921,10 @@ test("transport compatibility rejects MCP tools not connected in active tool sur
     },
   );
 
-  assert.match(error ?? "", /requires gsd_summary_save/);
+  assert.equal(error, null);
 });
 
-test("transport compatibility checks all required tools against active tool surface", () => {
+test("transport compatibility still checks non-MCP tools against parent active tool surface", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
     ["gsd_summary_save", "secure_env_collect"],
@@ -868,9 +939,54 @@ test("transport compatibility checks all required tools against active tool surf
     },
   );
 
-  assert.match(error ?? "", /requires.*(?:gsd_summary_save|secure_env_collect)/);
-  assert.match(error ?? "", /gsd_summary_save/);
-  assert.match(error ?? "", /secure_env_collect/);
+  assert.match(error ?? "", /requires secure_env_collect/);
+  assert.doesNotMatch(error ?? "", /gsd_summary_save/);
+});
+
+test("transport compatibility allows plan-slice MCP tools when parent surface is scoped (regression #457)", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    getRequiredWorkflowToolsForAutoUnit("plan-slice"),
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "plan-slice",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      activeTools: [
+        "ScheduleWakeup",
+        "ToolSearch",
+        "ask_user_questions",
+        "async_bash",
+        "await_job",
+        "bash",
+        "bg_shell",
+        "cancel_job",
+        "capture_thought",
+        "discover_configs",
+        "edit",
+        "fetch_page",
+        "get_library_docs",
+        "gsd_checkpoint_db",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_milestone_status",
+        "gsd_resume",
+        "mcp_call",
+        "mcp_discover",
+        "mcp_servers",
+        "memory_query",
+        "read",
+        "resolve_library",
+        "secure_env_collect",
+        "subagent",
+        "write",
+      ],
+    },
+  );
+
+  assert.equal(error, null);
 });
 
 test("transport compatibility still blocks units whose MCP tools are not exposed", () => {
@@ -895,6 +1011,7 @@ test("discuss-milestone guided flow does not abort when all required tools are o
   // Guided flow starts the workflow MCP server as part of dispatch, so the
   // parent session active-tool list is not authoritative for MCP tools.
   const discussMilestoneTools = [
+    "ask_user_questions",
     "gsd_summary_save",
     "gsd_requirement_save",
     "gsd_requirement_update",

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

@@ -109,6 +109,21 @@ test("ensureWorkspaceGitReadyForPath blocks product file conflicts", async () =>
   }
 });
 
+test("ensureWorkspaceGitReadyForPath does not block on staged files with trailing whitespace", async () => {
+  // Regression test for #599: git diff --check exits non-zero for whitespace
+  // errors as well as conflict markers. Staged files from auto-generated code
+  // often have trailing whitespace; these must not trigger the conflict gate.
+  const base = makeTempRepo("gsd-ws-git-whitespace-");
+  try {
+    writeFileSync(join(base, "app.ts"), "const x = 1;   \n"); // trailing whitespace
+    git(base, "add", "app.ts");
+    const ready = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(ready.ok, true, "trailing whitespace in staged files must not block");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("isWorkspaceGitAllowedCommand allowlists doctor, closeout, and dispatch complete-milestone", () => {
   assert.equal(isWorkspaceGitAllowedCommand("doctor"), true);
   assert.equal(isWorkspaceGitAllowedCommand("doctor fix"), true);

package/src/resources/extensions/gsd/tests/worktree-manager.test.ts

@@ -121,6 +121,27 @@ describe("createWorktree", () => {
     run("git rev-parse --git-dir", info.path);
     assert.ok(!existsSync(join(info.path, "orphan.txt")), "stale file removed by recovery");
   });
+
+  test("removes stale worktree directory with .git file not registered with git and recreates", () => {
+    // Simulate the scenario from issue #590: removeWorktree() failed to delete
+    // the directory (e.g. EPERM on Windows) but git worktree prune cleaned up
+    // the registry — leaving an orphaned directory with a .git *file* (not
+    // directory) that git no longer knows about.
+    const staleDir = worktreePath(base, "M010");
+    mkdirSync(staleDir, { recursive: true });
+    // Write a .git file (worktree gitdir pointer) — not a directory
+    writeFileSync(join(staleDir, ".git"), "gitdir: ../../../../.git/worktrees/M010\n", "utf-8");
+    writeFileSync(join(staleDir, "orphan.txt"), "stale leftover\n", "utf-8");
+
+    // createWorktree must detect the orphan (not in git worktree list), clean it
+    // up, and succeed — not throw GSD_STALE_STATE as if it were a live conflict.
+    const info = createWorktree(base, "M010");
+    assert.strictEqual(info.name, "M010");
+    assert.ok(existsSync(info.path));
+    assert.ok(existsSync(join(info.path, ".git")), "recovered worktree has .git marker");
+    run("git rev-parse --git-dir", info.path);
+    assert.ok(!existsSync(join(info.path, "orphan.txt")), "stale file removed by recovery");
+  });
 });
 
 describe("createWorktree — duplicate rejection", () => {

package/src/resources/extensions/gsd/tests/worktree-projection-writers.test.ts

@@ -171,7 +171,7 @@ test("validate-milestone invoked from the project root writes VALIDATION under t
   const projectProjection = join(projectRoot, ".gsd", "milestones", MID, "M001-VALIDATION.md");
   assert.equal(result.validationPath, expected);
   assert.equal(existsSync(expected), true);
-  assert.equal(existsSync(projectProjection), false);
+  assert.equal(existsSync(projectProjection), true, "VALIDATION should mirror to project root for consistent reads");
 });
 
 test("complete-milestone writes SUMMARY under the active worktree projection", async (t) => {

package/src/resources/extensions/gsd/tests/worktree-telemetry.test.ts

@@ -18,6 +18,7 @@ import {
   emitWorktreeOrphaned,
   emitAutoExit,
   emitCanonicalRootRedirect,
+  autoExitReasonForTerminalOutcome,
   normalizeAutoExitReason,
   summarizeWorktreeTelemetry,
   percentile,
@@ -117,6 +118,27 @@ test("normalizeAutoExitReason maps new buckets and ignores casing", () => {
   }
 });
 
+test("autoExitReasonForTerminalOutcome maps typed terminal outcomes", () => {
+  assert.equal(
+    autoExitReasonForTerminalOutcome({
+      code: "all-complete",
+      displayReason: "All milestones complete",
+      allMilestonesComplete: true,
+    }),
+    "all-complete",
+  );
+  assert.equal(
+    autoExitReasonForTerminalOutcome({
+      code: "settlement-blocked",
+      displayReason: "Milestone complete, merge blocked",
+      nextAction: "Retry closeout",
+      milestoneId: "M001",
+      allMilestonesComplete: false,
+    }),
+    "blocked",
+  );
+});
+
 test("summarizeWorktreeTelemetry only counts unmerged exits from active worktrees", (t) => {
   const base = makeTmpBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -340,6 +340,8 @@ test('write-gate: reopening a gate revokes its previous verified approval', () =
 // ═══════════════════════════════════════════════════════════════════════
 
 import {
+  applyAskUserQuestionsGateResult,
+  formatPendingAskUserQuestionsGateMessage,
   isGateQuestionId,
   shouldBlockPendingGate,
   shouldBlockPendingGateBash,
@@ -379,6 +381,83 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
 });
 
+test('write-gate: applyAskUserQuestionsGateResult keeps cancelled pending gate waiting', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-waiting-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: { cancelled: true, interrupted: true },
+    });
+
+    assert.deepEqual(result, {
+      status: 'waiting',
+      pendingGateId: gateId,
+      interrupted: true,
+    });
+    assert.strictEqual(getPendingGate(base), gateId, 'cancelled question must leave gate pending');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), false, 'cancelled question must not verify depth');
+    assert.match(
+      formatPendingAskUserQuestionsGateMessage(gateId, true),
+      /Re-call ask_user_questions with the same gate question id/,
+    );
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: applyAskUserQuestionsGateResult verifies confirmed pending gate', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-verified-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+  const confirmLabel = 'Confirm depth (Recommended)';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: confirmLabel }, { label: 'Needs adjustment' }],
+      }],
+      details: {
+        response: {
+          answers: {
+            [gateId]: { selected: confirmLabel },
+          },
+        },
+      },
+    });
+
+    assert.deepEqual(result, {
+      status: 'verified',
+      gateId,
+      milestoneId: 'M001',
+    });
+    assert.strictEqual(getPendingGate(base), null, 'confirmed gate must clear pending state');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), true, 'confirmed gate must verify milestone depth');
+    assert.ok(
+      loadWriteGateSnapshot(base).verifiedApprovalGates?.includes(gateId) ?? false,
+      'confirmed gate must record verified approval',
+    );
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 // ─── Scenario 21: shouldBlockPendingGate blocks non-safe tools when gate is pending ──
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {