gsd-pi 2.75.0 → 2.76.0-dev.b072ebb73

package/src/resources/extensions/gsd/tests/discuss-milestone-structured-questions.test.ts

@@ -0,0 +1,64 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+function makeState(phase: GSDState["phase"]): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Structured Questions" },
+    activeSlice: null,
+    activeTask: null,
+    phase,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+function makeContext(
+  basePath: string,
+  phase: GSDState["phase"],
+  structuredQuestionsAvailable: "true" | "false",
+): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Structured Questions",
+    state: makeState(phase),
+    prefs: undefined,
+    structuredQuestionsAvailable,
+  };
+}
+
+test("auto-dispatch passes structuredQuestionsAvailable=true into discuss-milestone prompt", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-structured-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const result = await resolveDispatch(makeContext(tmp, "needs-discussion", "true"));
+
+  assert.equal(result.action, "dispatch");
+  assert.equal(result.unitType, "discuss-milestone");
+  assert.match(
+    result.prompt,
+    /\*\*Structured questions available: true\*\*/,
+  );
+});
+
+test("auto-dispatch preserves structuredQuestionsAvailable=false for discuss-milestone prompt", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-milestone-plain-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const result = await resolveDispatch(makeContext(tmp, "pre-planning", "false"));
+
+  assert.equal(result.action, "dispatch");
+  assert.equal(result.unitType, "discuss-milestone");
+  assert.match(
+    result.prompt,
+    /\*\*Structured questions available: false\*\*/,
+  );
+});

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -0,0 +1,67 @@
+/**
+ * dispatch-complete-milestone-guard.test.ts — #4324
+ *
+ * Verify that the completing-milestone dispatch rule has a defense-in-depth
+ * DB status guard. When the DB marks a milestone as closed, the rule must
+ * return skip instead of dispatching a redundant complete-milestone unit.
+ * This prevents silent data loss when the legacy filesystem state-derivation
+ * path produces a stale completing-milestone phase.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceFile = join(__dirname, "..", "auto-dispatch.ts");
+
+describe("completing-milestone dispatch guard (#4324)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("imports isClosedStatus from status-guards", () => {
+    assert.match(source, /import\s*\{[^}]*isClosedStatus[^}]*\}\s*from\s*["']\.\/status-guards/);
+  });
+
+  test("checks DB milestone status before dispatching complete-milestone", () => {
+    assert.match(source, /isClosedStatus\(milestone\.status\)/);
+  });
+
+  test("isClosedStatus guard appears in the completing-milestone rule", () => {
+    // The completing-milestone phase check and the isClosedStatus guard
+    // must both appear in the same rule, with the guard before dispatch.
+    const phaseCheck = source.indexOf('phase !== "completing-milestone"');
+    assert.ok(phaseCheck > -1, "completing-milestone phase check should exist");
+
+    // Find the isClosedStatus guard after the phase check
+    const guardIdx = source.indexOf("isClosedStatus(milestone.status)", phaseCheck);
+    assert.ok(guardIdx > -1, "isClosedStatus guard should appear after the phase check");
+
+    // Find the skip return after the guard
+    const skipIdx = source.indexOf('action: "skip"', guardIdx);
+    assert.ok(skipIdx > -1, "skip action should follow the isClosedStatus guard");
+
+    // The skip should come before the dispatch in this rule
+    const dispatchIdx = source.indexOf('unitType: "complete-milestone"', skipIdx);
+    assert.ok(dispatchIdx > -1, "complete-milestone dispatch should exist after the skip guard");
+  });
+
+  test("imports updateMilestoneStatus for DB reconciliation", () => {
+    assert.match(source, /import\s*\{[^}]*updateMilestoneStatus[^}]*\}\s*from\s*["']\.\/gsd-db/);
+  });
+
+  test("reconciles DB when SUMMARY exists on disk but DB is out of sync", () => {
+    const phaseCheck = source.indexOf('phase !== "completing-milestone"');
+    // The SUMMARY-exists reconciliation guard must appear in this rule
+    const summaryGuard = source.indexOf('resolveMilestoneFile(basePath, mid, "SUMMARY")', phaseCheck);
+    assert.ok(summaryGuard > -1, "SUMMARY file check should exist in the completing-milestone rule");
+
+    const reconcileCall = source.indexOf('updateMilestoneStatus(mid, "complete"', summaryGuard);
+    assert.ok(reconcileCall > -1, "updateMilestoneStatus reconciliation should follow the SUMMARY check");
+
+    // Reconciliation must happen before the dispatch action
+    const dispatchIdx = source.indexOf('unitType: "complete-milestone"', reconcileCall);
+    assert.ok(dispatchIdx > -1, "reconciliation should appear before the dispatch action");
+  });
+});

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -14,8 +14,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
-import { join } from "node:path";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync, chmodSync } from "node:fs";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
@@ -219,6 +219,9 @@ test("runProviderChecks returns error for Anthropic when no key present", () =>
     GH_TOKEN: undefined,
     GITHUB_TOKEN: undefined,
     HOME: tmpHome,
+    // Use a PATH that contains no AI CLI binaries (claude, codex, gemini, etc.)
+    // so the claude-code route is not considered available
+    PATH: tmpHome,
   }, () => {
     try {
       const results = runProviderChecks();
@@ -295,26 +298,115 @@ test("runProviderChecks detects key from auth.json", () => {
 });
 
 test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
-  withEnv({ ANTHROPIC_API_KEY: undefined, ANTHROPIC_OAUTH_TOKEN: undefined, COPILOT_GITHUB_TOKEN: undefined, GH_TOKEN: undefined, GITHUB_TOKEN: undefined }, () => {
-    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
-    const agentDir = join(tmpHome, ".gsd", "agent");
-    mkdirSync(agentDir, { recursive: true });
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+  const agentDir = join(tmpHome, ".gsd", "agent");
+  mkdirSync(agentDir, { recursive: true });
 
-    // Empty key — what onboarding writes when user skips
-    const authData = {
-      anthropic: { type: "api_key", key: "" },
-    };
-    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+  // Empty key — what onboarding writes when user skips
+  const authData = {
+    anthropic: { type: "api_key", key: "" },
+  };
+  writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
 
-    withEnv({ HOME: tmpHome }, () => {
+  withEnv({
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    HOME: tmpHome,
+    // Exclude AI CLI binaries so the claude-code route is not considered available
+    PATH: tmpHome,
+  }, () => {
+    const results = runProviderChecks();
+    const anthropic = results.find(r => r.name === "anthropic");
+    assert.ok(anthropic, "anthropic should be present");
+    assert.equal(anthropic!.status, "error", "empty placeholder key should count as not configured");
+  });
+
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks detects custom provider keys from models.json", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-custom-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-custom-repo-")));
+  const agentDir = join(tmpHome, ".gsd", "agent");
+  mkdirSync(agentDir, { recursive: true });
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: custom-model",
+      "    provider: custom-provider",
+      "---",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(join(agentDir, "models.json"), JSON.stringify({
+    providers: {
+      "custom-provider": {
+        api: "openai-completions",
+        apiKey: "x",
+        baseUrl: "https://example.invalid/v1",
+        models: [{ id: "custom-model", name: "Custom Model" }],
+      },
+    },
+  }));
+
+  withEnv({
+    HOME: tmpHome,
+    CUSTOM_PROVIDER_API_KEY: undefined,
+    PATH: tmpHome,
+  }, () => {
+    withCwd(repo, () => {
       const results = runProviderChecks();
-      const anthropic = results.find(r => r.name === "anthropic");
-      assert.ok(anthropic, "anthropic should be present");
-      assert.equal(anthropic!.status, "error", "empty placeholder key should count as not configured");
+      const custom = results.find(r => r.name === "custom-provider");
+      assert.ok(custom, "custom provider result should exist");
+      assert.equal(custom!.status, "ok", "models.json apiKey should satisfy custom provider auth");
+      assert.ok(custom!.message.includes("models.json"), "should report models.json source");
+      assert.equal(summariseProviderIssues(results), null, "custom models.json key should not raise dashboard warning");
     });
+  });
 
-    rmSync(tmpHome, { recursive: true, force: true });
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks reports missing custom provider key without models.json apiKey", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-custom-missing-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-custom-missing-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: custom-provider/custom-model",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    CUSTOM_PROVIDER_API_KEY: undefined,
+    PATH: tmpHome,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const custom = results.find(r => r.name === "custom-provider");
+      assert.ok(custom, "provider-qualified custom model should be checked");
+      assert.equal(custom!.status, "error", "missing custom provider key should still be reported");
+    });
   });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
 });
 
 // ─── runProviderChecks — cross-provider routing ──────────────────────────────
@@ -507,7 +599,7 @@ test("runProviderChecks reports ok for Google via google-gemini-cli auth.json (#
 
   // google-gemini-cli OAuth in auth.json (no google API key)
   const authData = {
-    "google-gemini-cli": { type: "oauth", apiKey: "ya29.gemini-cli-token", expires: Date.now() + 3_600_000 },
+    "google-gemini-cli": { type: "oauth", expires: Date.now() + 3_600_000 },
   };
   writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
 
@@ -610,6 +702,72 @@ test("runProviderChecks reports ok for claude-code without any API key", () => {
   rmSync(tmpHome, { recursive: true, force: true });
 });
 
+test("runProviderChecks reports ok for Anthropic via claude-code binary in PATH", () => {
+  // Simulate a user who has no Anthropic API key but has the claude CLI installed.
+  // Their PREFERENCES use a claude model without an explicit provider, so the doctor
+  // infers "anthropic" — but the claude-code route should satisfy it.
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cc-route-home-")));
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(binDir, { recursive: true });
+
+  // Create a fake `claude` binary so the PATH scan finds it
+  const fakeClaude = join(binDir, "claude");
+  writeFileSync(fakeClaude, "#!/bin/sh\necho mock\n");
+  chmodSync(fakeClaude, 0o755);
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    PATH: `${binDir}${delimiter}${process.env.PATH ?? ""}`,
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when claude CLI binary is in PATH");
+      assert.ok(anthropic!.message.toLowerCase().includes("claude"), "should mention claude-code as source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks detects claude.cmd in PATH on Windows (#4503)", { skip: process.platform !== "win32" }, () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cc-win-route-home-")));
+  const binDir = join(tmpHome, "bin");
+  mkdirSync(binDir, { recursive: true });
+
+  // On Windows, users commonly install Claude via a .cmd shim.
+  const fakeClaudeCmd = join(binDir, "claude.cmd");
+  writeFileSync(fakeClaudeCmd, "@echo off\r\necho mock\r\n");
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+    // Explicitly use ';' to mirror Windows PATH entries.
+    PATH: `${binDir};${process.env.PATH ?? ""}`,
+    PATHEXT: ".COM;.EXE;.BAT;.CMD",
+  }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when claude.cmd is in PATH");
+      assert.ok(anthropic!.message.toLowerCase().includes("claude"), "should mention claude-code as source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
 test("PROVIDER_ROUTES includes google-gemini-cli as route for google (#2922)", async () => {
   const { readFileSync: readFS } = await import("node:fs");
   const { dirname: dirn, join: joinPath } = await import("node:path");

package/src/resources/extensions/gsd/tests/enhanced-verification-integration.test.ts

@@ -70,6 +70,11 @@ function createTask(overrides: Partial<TaskRow> = {}): TaskRow {
     observability_impact: "",
     full_plan_md: "",
     sequence: overrides.sequence ?? 0,
+    blocker_source: "",
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
     ...overrides,
   };
 }