gsd-pi 2.70.1 → 2.71.0-dev.06b86c6

package/src/resources/extensions/gsd/tests/file-lock.test.ts

@@ -0,0 +1,103 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { withFileLock, withFileLockSync } from "../file-lock.ts";
+
+const require = createRequire(import.meta.url);
+
+function hasProperLockfile(): boolean {
+  try {
+    require("proper-lockfile");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+test("withFileLockSync: executes callback when file does not exist", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  try {
+    const missingPath = join(dir, "missing.txt");
+    let called = 0;
+    const result = withFileLockSync(missingPath, () => {
+      called++;
+      return "ok";
+    });
+
+    assert.equal(result, "ok");
+    assert.equal(called, 1, "callback should execute exactly once");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLock: executes callback when file does not exist", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  try {
+    const missingPath = join(dir, "missing.txt");
+    let called = 0;
+    const result = await withFileLock(missingPath, async () => {
+      called++;
+      return "ok";
+    });
+
+    assert.equal(result, "ok");
+    assert.equal(called, 1, "callback should execute exactly once");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLockSync: falls back to unlocked callback on ELOCKED", () => {
+  if (!hasProperLockfile() || process.platform === "win32") {
+    return;
+  }
+
+  const lockfile = require("proper-lockfile");
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  const filePath = join(dir, "locked.jsonl");
+  writeFileSync(filePath, "{}\n", "utf-8");
+
+  const release = lockfile.lockSync(filePath, { retries: 0, stale: 10000 });
+  try {
+    let called = 0;
+    const result = withFileLockSync(filePath, () => {
+      called++;
+      return "fallback-ok";
+    });
+    assert.equal(result, "fallback-ok");
+    assert.equal(called, 1, "callback should run even when lock acquisition fails");
+  } finally {
+    release();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLock: falls back to unlocked callback on ELOCKED", async () => {
+  if (!hasProperLockfile() || process.platform === "win32") {
+    return;
+  }
+
+  const lockfile = require("proper-lockfile");
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  const filePath = join(dir, "locked.jsonl");
+  writeFileSync(filePath, "{}\n", "utf-8");
+
+  const release = await lockfile.lock(filePath, { retries: 0, stale: 10000 });
+  try {
+    let called = 0;
+    const result = await withFileLock(filePath, async () => {
+      called++;
+      return "fallback-ok";
+    });
+    assert.equal(result, "fallback-ok");
+    assert.equal(called, 1, "callback should run even when lock acquisition fails");
+  } finally {
+    await release();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/gsd-no-project-error.test.ts

@@ -0,0 +1,73 @@
+/**
+ * GSDNoProjectError — tests for friendly home-directory error handling.
+ *
+ * Verifies that GSDNoProjectError is thrown for blocked directories and
+ * that the dispatcher catches it with a user-friendly message.
+ */
+
+import 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 contextSrc = readFileSync(join(__dirname, "..", "commands", "context.ts"), "utf-8");
+const dispatcherSrc = readFileSync(join(__dirname, "..", "commands", "dispatcher.ts"), "utf-8");
+
+// ─── GSDNoProjectError class ──────────────────────────────────────────────
+
+test("GSDNoProjectError class is exported from context.ts", () => {
+  assert.ok(
+    contextSrc.includes("export class GSDNoProjectError extends Error"),
+    "GSDNoProjectError should be an exported Error subclass",
+  );
+});
+
+test("GSDNoProjectError sets name property", () => {
+  assert.ok(
+    contextSrc.includes('this.name = "GSDNoProjectError"'),
+    "GSDNoProjectError should set its name for instanceof checks",
+  );
+});
+
+// ─── projectRoot blocked directory handling ───────────────────────────────
+
+test("projectRoot uses validateDirectory and checks for blocked severity", () => {
+  assert.ok(
+    contextSrc.includes("validateDirectory(pathToCheck)"),
+    "projectRoot should call validateDirectory",
+  );
+  assert.ok(
+    contextSrc.includes('result.severity === "blocked"'),
+    "projectRoot should check for blocked severity",
+  );
+});
+
+test("projectRoot throws GSDNoProjectError on blocked directory", () => {
+  assert.ok(
+    contextSrc.includes("throw new GSDNoProjectError"),
+    "projectRoot should throw GSDNoProjectError when directory is blocked",
+  );
+});
+
+// ─── Dispatcher catch ─────────────────────────────────────────────────────
+
+test("dispatcher catches GSDNoProjectError with user-friendly message", () => {
+  assert.ok(
+    dispatcherSrc.includes("err instanceof GSDNoProjectError"),
+    "dispatcher should catch GSDNoProjectError specifically",
+  );
+  assert.ok(
+    dispatcherSrc.includes("cd"),
+    "error message should suggest cd-ing into a project directory",
+  );
+});
+
+test("dispatcher re-throws non-GSDNoProjectError exceptions", () => {
+  assert.ok(
+    dispatcherSrc.includes("throw err"),
+    "dispatcher should re-throw unexpected errors",
+  );
+});

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -187,6 +187,23 @@ describe("notification-store", () => {
     assert.ok(!entries.some((e) => e.message === "suppressed"));
   });
 
+  test("appendNotification suppresses identical messages within the dedup window", (t) => {
+    initNotificationStore(tmp);
+    let now = 1_000;
+    t.mock.method(Date, "now", () => now);
+
+    appendNotification("same", "warning");
+    now += 1_000;
+    appendNotification("same", "warning");
+    now += 31_000;
+    appendNotification("same", "warning");
+
+    const entries = readNotifications();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].message, "same");
+    assert.equal(entries[1].message, "same");
+  });
+
   test("suppressPersistence is ref-counted", () => {
     initNotificationStore(tmp);
     suppressPersistence();

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -0,0 +1,25 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { initNotificationStore, appendNotification, _resetNotificationStore } from "../notification-store.js";
+import { buildNotificationWidgetLines } from "../notification-widget.js";
+
+test("buildNotificationWidgetLines includes slash-command fallback for unread notifications", () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-notification-widget-"));
+  try {
+    mkdirSync(join(tmp, ".gsd"), { recursive: true });
+    _resetNotificationStore();
+    initNotificationStore(tmp);
+    appendNotification("Need attention", "warning");
+
+    const lines = buildNotificationWidgetLines();
+    assert.equal(lines.length, 1);
+    assert.match(lines[0]!, /\/gsd notifications/);
+  } finally {
+    _resetNotificationStore();
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1107,6 +1107,38 @@ describe("checkTaskOrdering false positive regression (#3677)", () => {
     assert.equal(results[0].target, "`later.ts` — needed first");
     assert.ok(results[0].message.includes("sequence violation"));
   });
+
+  test("existing on-disk files do not trigger ordering violations just because a later task modifies them", () => {
+    const tempDir = join(tmpdir(), `pre-exec-ordering-existing-file-${Date.now()}`);
+    const existingFile = "frontend/src/__tests__/ProcurementPage29.test.tsx";
+
+    mkdirSync(join(tempDir, "frontend", "src", "__tests__"), { recursive: true });
+    writeFileSync(join(tempDir, existingFile), "// existing file");
+
+    try {
+      const tasks = [
+        createTask({
+          id: "T01",
+          sequence: 0,
+          files: [],
+          inputs: ["`frontend/src/__tests__/ProcurementPage29.test.tsx` — contains matchMedia stub to remove"],
+          expected_output: [],
+        }),
+        createTask({
+          id: "T03",
+          sequence: 2,
+          files: [],
+          inputs: [],
+          expected_output: ["frontend/src/__tests__/ProcurementPage29.test.tsx"],
+        }),
+      ];
+
+      const results = checkTaskOrdering(tasks, tempDir);
+      assert.equal(results.length, 0, "Pre-existing files should not be treated as created by later tasks");
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
 });
 
 // ─── checkFilePathConsistency additional edge cases ──────────────────────────
@@ -1175,6 +1207,23 @@ describe("checkFilePathConsistency additional edge cases", () => {
     assert.equal(results![0].blocking, true);
   });
 
+  test("multi-word prose inputs are ignored by path consistency checks", () => {
+    const tasks = [
+      createTask({
+        id: "T01",
+        files: [],
+        inputs: [
+          "Current WIZARD_PRODUCTS enum",
+          "Existing test patterns in wizard.test.ts",
+        ],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, "/tmp");
+    assert.equal(results.length, 0, "Prose planning hints should not be treated as missing file paths");
+  });
+
   test("empty inputs array produces no results", () => {
     // A task with no inputs and only files should produce zero results from
     // consistency check — files are not checked (#3626).

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -42,9 +42,19 @@ test("system prompt references CODEBASE.md and /gsd codebase", () => {
   assert.match(prompt, /auto-refreshes it when tracked files change/i);
 });
 
+test("system prompt hard rules forbid fabricating user responses", () => {
+  const prompt = readPrompt("system");
+  assert.match(prompt, /never fabricate, simulate, or role-play user responses/i);
+  assert.match(prompt, /never generate markers like `?\[User\]`?, `?\[Human\]`?, `?User:`?/i);
+  assert.match(prompt, /ask one question round \(1-3 questions\), then stop and wait for the user's actual response/i);
+  assert.match(prompt, /ask_user_questions.*only valid structured user input/i);
+});
+
 test("discuss prompt allows implementation questions when they materially matter", () => {
   const prompt = readPrompt("discuss");
   assert.match(prompt, /Lead with experience, but ask implementation when it materially matters/i);
+  assert.match(prompt, /Never fabricate, simulate, or role-play user responses/i);
+  assert.match(prompt, /Ask one question round \(1-3 questions\) per turn, then stop and wait for the user's actual response/i);
   assert.match(prompt, /one gate, not two/i);
   assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
 });
@@ -56,6 +66,8 @@ test("guided discussion prompts avoid wrap-up prompts after every round", () =>
   assert.match(slicePrompt, /Do \*\*not\*\* ask a meta "ready to wrap up\?" question after every round/i);
   assert.doesNotMatch(milestonePrompt, /I think I have a solid picture of this milestone\. Ready to wrap up/i);
   assert.doesNotMatch(slicePrompt, /I think I have a solid picture of this slice\. Ready to wrap up/i);
+  assert.match(milestonePrompt, /Never fabricate or simulate user input/i);
+  assert.match(slicePrompt, /Never fabricate or simulate user input/i);
 });
 
 test("guided milestone discussion scopes depth verification to the milestone id", () => {
@@ -64,6 +76,13 @@ test("guided milestone discussion scopes depth verification to the milestone id"
   assert.doesNotMatch(prompt, /depth_verification_confirm" — this enables the write-gate downstream/i, "legacy global depth gate wording should be gone");
 });
 
+test("queue prompt requires waiting for user response between rounds", () => {
+  const prompt = readPrompt("queue");
+  assert.match(prompt, /Never fabricate or simulate user input during this discussion/i);
+  assert.match(prompt, /Ask 1-3 questions per round, then wait for the user's response before asking the next round\./i);
+  assert.doesNotMatch(prompt, /treat that as permission to continue/i);
+});
+
 test("guided-resume-task prompt preserves recovery state until work is superseded", () => {
   const prompt = readPrompt("guided-resume-task");
   assert.match(prompt, /Do \*\*not\*\* delete the continue file immediately/i);

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -101,6 +101,13 @@ test("classifyError detects quota exceeded as permanent", () => {
   assert.ok(!isTransient(result));
 });
 
+test("classifyError treats plain 'Connection error.' as transient connection failure (#3594)", () => {
+  const result = classifyError("Connection error.");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "connection");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
+});
+
 test("classifyError treats unknown error as not transient", () => {
   const result = classifyError("something went wrong");
   assert.ok(!isTransient(result));

package/src/resources/extensions/gsd/tests/secure-env-collect.test.ts

@@ -317,3 +317,48 @@ test("secure_env_collect #2997: null from ctx.ui.custom() is still treated as sk
 		"Key returning null must NOT be in applied list",
 	);
 });
+
+test("secure_env_collect: falls back to secure input prompt when custom UI is unavailable", async (t) => {
+	const { collectSecretsFromManifest } = await loadOrchestrator();
+
+	const tmp = makeTempDir("sec-input-fallback-test");
+	t.after(() => {
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	const manifest = makeManifest([
+		{ key: "SECRET_FROM_INPUT_FALLBACK", status: "pending", formatHint: "starts with sk-" },
+	]);
+	await writeManifestFile(tmp, manifest);
+
+	let callIndex = 0;
+	const inputCalls: Array<{ title: string; placeholder?: string; opts?: { secure?: boolean } }> = [];
+	const mockCtx = {
+		cwd: tmp,
+		hasUI: true,
+		ui: {
+			custom: async (_factory: any) => {
+				callIndex++;
+				if (callIndex <= 1) return null; // summary screen dismiss
+				return undefined; // collect screen unavailable on this surface
+			},
+			input: async (title: string, placeholder?: string, opts?: { secure?: boolean }) => {
+				inputCalls.push({ title, placeholder, opts });
+				return "  sk-test-fallback-value  ";
+			},
+		},
+	};
+
+	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+
+	assert.ok(
+		result.applied.includes("SECRET_FROM_INPUT_FALLBACK"),
+		"Fallback input should collect and apply the key",
+	);
+	assert.ok(
+		!result.skipped.includes("SECRET_FROM_INPUT_FALLBACK"),
+		"Fallback input should not mark the key as skipped",
+	);
+	assert.equal(inputCalls.length, 1, "Fallback input should be requested once");
+	assert.equal(inputCalls[0]?.opts?.secure, true, "Fallback input should request secure entry when supported");
+});

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -61,6 +61,13 @@ describe("#2883: isToolInvocationError classification", () => {
     );
   });
 
+  test("detects Node v18+ JSON parse variant with property-value text", () => {
+    assert.equal(
+      isToolInvocationError("Expected ',' or '}' after property value in JSON at position 4096"),
+      true,
+    );
+  });
+
   test("detects Unexpected end of JSON input", () => {
     assert.equal(
       isToolInvocationError("Unexpected end of JSON input"),

package/src/resources/extensions/gsd/tests/validate-milestone-prompt-verification-classes.test.ts

@@ -0,0 +1,18 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptPath = join(process.cwd(), "src/resources/extensions/gsd/prompts/validate-milestone.md");
+const prompt = readFileSync(promptPath, "utf-8");
+
+test("validate-milestone reviewer C requires canonical verification class names", () => {
+  assert.match(prompt, /\*\*Reviewer C[\s\S]*Verification Classes/i);
+  assert.match(prompt, /exact class names [`']?Contract[`']?, [`']?Integration[`']?, [`']?Operational[`']?, and [`']?UAT[`']?/i);
+  assert.match(prompt, /If no verification classes were planned, say that explicitly/i);
+});
+
+test("validate-milestone prompt routes verification class analysis into verificationClasses", () => {
+  assert.match(prompt, /pass it in `verificationClasses`/i);
+  assert.match(prompt, /Extract the `Verification Classes` subsection from Reviewer C and pass it verbatim in `verificationClasses`/);
+});

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

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { prepareWorkflowMcpForProject, shouldAutoPrepareWorkflowMcp } from "../workflow-mcp-auto-prep.ts";
+
+test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is ready", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: (provider: string) => provider === "claude-code",
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is registered", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: (provider: string) => provider === "claude-code" ? "externalCli" : "apiKey",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp stays disabled when neither transport nor provider readiness match", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, false);
+});
+
+test("prepareWorkflowMcpForProject warns with /gsd mcp init guidance when prep fails", () => {
+  const notifications: Array<{ message: string; level: "info" | "warning" | "error" | "success" }> = [];
+  const result = prepareWorkflowMcpForProject(
+    {
+      model: { provider: "claude-code", baseUrl: "local://claude-code" },
+      modelRegistry: {
+        getProviderAuthMode: () => "externalCli",
+        isProviderRequestReady: () => true,
+      },
+      ui: {
+        notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+          notifications.push({ message, level: level ?? "info" });
+        },
+      },
+    },
+    "/",
+  );
+
+  assert.equal(result, null);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0].level, "warning");
+  assert.match(notifications[0].message, /Please run \/gsd mcp init \./);
+});