gsd-pi 2.71.0-dev.977c553 → 2.71.0-dev.d4d916a

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/register-shortcuts.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -37,10 +37,10 @@ test("dashboard shortcut resolves the project root instead of the current worktr
   });
 
   let capturedHandler: ((ctx: any) => Promise<void>) | null = null;
-  const shortcuts: Array<{ description: string; handler: (ctx: any) => Promise<void> }> = [];
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
   const pi = {
-    registerShortcut: (_key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
-      shortcuts.push(shortcut);
+    registerShortcut: (key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push({ key: String(key), ...shortcut });
       if (!capturedHandler) {
         capturedHandler = shortcut.handler;
       }
@@ -69,5 +69,63 @@ test("dashboard shortcut resolves the project root instead of the current worktr
 
   assert.ok(customCalls > 0, "shortcut opens the dashboard overlay when project root is resolved");
   assert.equal(notices.length, 0, "shortcut does not fall back to the missing-.gsd warning");
-  assert.equal(shortcuts.length, 3, "all GSD shortcuts are still registered");
+  assert.equal(shortcuts.length, 5, "all GSD shortcuts are still registered");
+  const keys = shortcuts.map((shortcut) => shortcut.key);
+  assert.ok(keys.includes("ctrl+alt+g"), "primary dashboard shortcut is registered");
+  assert.ok(keys.includes("ctrl+shift+g"), "fallback dashboard shortcut is registered");
+  assert.ok(keys.includes("ctrl+alt+n"), "primary notifications shortcut is registered");
+  assert.ok(keys.includes("ctrl+shift+n"), "fallback notifications shortcut is registered");
+  assert.ok(keys.includes("ctrl+alt+p"), "primary parallel shortcut is registered");
+  // No Ctrl+Shift+P fallback — conflicts with cycleModelBackward (shift+ctrl+p)
+  assert.ok(!keys.includes("ctrl+shift+p"), "parallel fallback must not be registered (conflicts with cycleModelBackward)");
+});
+
+test("parallel shortcut passes resolved project root into overlay", async (t) => {
+  const base = makeTempDir("parallel-root");
+  const worktreeRoot = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(worktreeRoot);
+  t.after(() => {
+    process.chdir(originalCwd);
+    cleanup(base);
+  });
+
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
+  registerShortcuts({
+    registerShortcut: (key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push({ key: String(key), ...shortcut });
+    },
+  } as any);
+
+  const parallelShortcut = shortcuts.find((shortcut) => shortcut.key === "ctrl+alt+p");
+  assert.ok(parallelShortcut, "parallel shortcut is registered");
+
+  let capturedBasePath: string | undefined;
+  await parallelShortcut!.handler({
+    hasUI: true,
+    ui: {
+      custom: async (factory: any) => {
+        const overlay = factory(
+          { requestRender() {} },
+          { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+          null,
+          () => {},
+        );
+        capturedBasePath = (overlay as any).basePath;
+        overlay.dispose?.();
+        return true;
+      },
+      notify: () => {},
+    },
+  });
+
+  assert.ok(capturedBasePath, "parallel shortcut should construct overlay with a basePath");
+  assert.equal(
+    realpathSync(capturedBasePath),
+    realpathSync(base),
+    "parallel overlay should use the resolved project root, not the worktree cwd",
+  );
 });

package/src/resources/extensions/gsd/tests/session-model-override.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  clearSessionModelOverride,
+  getSessionModelOverride,
+  setSessionModelOverride,
+} from "../session-model-override.js";
+
+const phasesSource = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+
+test("setSessionModelOverride stores provider/model for the session", () => {
+  const sessionId = `session-override-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "openai-codex", id: "gpt-5.4" });
+
+  const override = getSessionModelOverride(sessionId);
+  assert.equal(override?.provider, "openai-codex");
+  assert.equal(override?.id, "gpt-5.4");
+});
+
+test("clearSessionModelOverride removes the session override", () => {
+  const sessionId = `session-clear-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "anthropic", id: "claude-sonnet-4-6" });
+  clearSessionModelOverride(sessionId);
+  assert.equal(getSessionModelOverride(sessionId), undefined);
+});
+
+test("auto dispatch threads manual session model override into selectAndApplyModel", () => {
+  assert.ok(
+    phasesSource.includes("s.manualSessionModelOverride"),
+    "auto/phases.ts should pass s.manualSessionModelOverride into selectAndApplyModel",
+  );
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -0,0 +1,90 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const gsdDir = resolve(import.meta.dirname, "..");
+
+function readGsdFile(relativePath: string): string {
+  return readFileSync(resolve(gsdDir, relativePath), "utf-8");
+}
+
+test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
+  const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
+  const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
+  const guidedFlowSrc = readGsdFile("guided-flow.ts");
+
+  assert.ok(
+    !autoHandlerSrc.includes("await startAuto("),
+    "auto command handler should not await startAuto from the active agent turn",
+  );
+  assert.ok(
+    !workflowHandlerSrc.includes("await startAuto("),
+    "workflow command handler should not await startAuto from the active agent turn",
+  );
+  assert.ok(
+    !guidedFlowSrc.includes("await startAuto("),
+    "guided flow should not await startAuto from the active agent turn",
+  );
+
+  assert.ok(
+    autoHandlerSrc.includes("startAutoDetached("),
+    "auto command handler should launch auto-mode through startAutoDetached",
+  );
+  assert.ok(
+    workflowHandlerSrc.includes("startAutoDetached("),
+    "workflow handler should launch auto-mode through startAutoDetached",
+  );
+  assert.ok(
+    guidedFlowSrc.includes("startAutoDetached("),
+    "guided flow should launch auto-mode through startAutoDetached",
+  );
+});
+
+test("startAutoDetached reports failures asynchronously (#3733)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+
+  assert.ok(
+    autoSrc.includes("export function startAutoDetached"),
+    "auto.ts should export startAutoDetached",
+  );
+  assert.ok(
+    autoSrc.includes("void startAuto(ctx, pi, base, verboseMode, options).catch"),
+    "startAutoDetached should launch startAuto without awaiting it",
+  );
+  assert.ok(
+    autoSrc.includes("ctx.ui.notify(`Auto-start failed: ${message}`, \"error\")"),
+    "startAutoDetached should surface async startup failures to the user",
+  );
+});
+
+test("detached auto-start preserves milestone lock across pause/stop cleanup (#3733)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const sessionSrc = readGsdFile("auto/session.ts");
+
+  assert.ok(
+    autoSrc.includes("milestoneLock?: string | null"),
+    "startAuto/startAutoDetached options should carry an explicit milestone lock",
+  );
+  assert.ok(
+    autoSrc.includes("s.sessionMilestoneLock = options.milestoneLock ?? null;"),
+    "startAuto should capture the requested milestone lock before async work begins",
+  );
+  assert.ok(
+    autoSrc.includes("milestoneLock: s.sessionMilestoneLock ?? undefined"),
+    "pause metadata should persist the detached milestone lock for resume",
+  );
+  assert.ok(
+    autoSrc.includes("s.sessionMilestoneLock = meta.milestoneLock ?? null;"),
+    "resume should restore the persisted milestone lock",
+  );
+  assert.ok(
+    autoSrc.includes("restoreMilestoneLockEnv();"),
+    "auto cleanup should restore the previous process milestone-lock env",
+  );
+
+  assert.ok(
+    sessionSrc.includes("sessionMilestoneLock: string | null = null;"),
+    "AutoSession should track the detached milestone lock explicitly",
+  );
+});

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/ollama/index.ts

@@ -57,7 +57,15 @@ async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
 	}
 
 	const models = await discoverModels();
-	if (models.length === 0) return true; // Running but no models pulled
+	if (models.length === 0) {
+		// No local models means there's nothing usable to register in GSD.
+		// Keep the footer/status clean instead of advertising Ollama availability.
+		if (providerRegistered) {
+			pi.unregisterProvider("ollama");
+			providerRegistered = false;
+		}
+		return false;
+	}
 
 	const baseUrl = client.getOllamaHost();
 
@@ -115,9 +123,11 @@ export default function ollama(pi: ExtensionAPI) {
 		} else {
 			probeAndRegister(pi)
 				.then((found) => {
-					if (found) ctx.ui.setStatus("ollama", "Ollama");
+					ctx.ui.setStatus("ollama", found ? "Ollama" : undefined);
 				})
-				.catch(() => {});
+				.catch(() => {
+					ctx.ui.setStatus("ollama", undefined);
+				});
 		}
 	});
 

package/src/resources/extensions/ollama/ollama-status-indicator.test.ts

@@ -0,0 +1,28 @@
+/**
+ * Regression test: don't show an Ollama footer status unless Ollama is
+ * actually usable (running with at least one discovered model).
+ */
+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 src = readFileSync(join(__dirname, "index.ts"), "utf-8");
+
+test("probeAndRegister returns false when no Ollama models are discovered", () => {
+	assert.match(
+		src,
+		/if \(models\.length === 0\)[\s\S]*return false;/,
+		"running-without-models should not be treated as available",
+	);
+});
+
+test("interactive session clears ollama footer status when unavailable", () => {
+	assert.match(
+		src,
+		/ctx\.ui\.setStatus\("ollama", found \? "Ollama" : undefined\)/,
+		"status should be cleared when probeAndRegister reports unavailable",
+	);
+});

package/src/resources/skills/create-skill/SKILL.md

@@ -78,6 +78,8 @@ Based on the user's message, route directly to the appropriate workflow:
 **If user intent is unclear, ask minimal clarifying questions:**
 - "Create a MIDI skill" → "Task-execution skill (does MIDI tasks) or domain expertise (complete MIDI knowledge base)?"
 - "Work on my skill" → "Which skill? What do you want to do with it?"
+- Ask one clarifying question round at a time, then wait for the user's actual response before asking another.
+- Never fabricate or simulate user responses while clarifying (for example, fake `[User]` markers or imagined answers).
 
 Then proceed directly to the workflow.
 </routing>