gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.96d4bb599

package/src/resources/extensions/gsd/tests/auto-migrating-recovery.test.ts

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { recoverFailedMigration } from "../migrate-external.ts";
+
+// Regression tests for #4416: `.gsd.migrating` must be healed before auto-mode
+// proceeds, including on the resume path in auto.ts (fixed at auto.ts:1325).
+// The `recoverFailedMigration` function is already called in `auto-start.ts:350`
+// for fresh-start sessions. The fix adds an identical call to `auto.ts:startAuto`
+// so that resume sessions (triggered by a persisted paused-session.json) also heal
+// a leftover `.gsd.migrating` directory before acquiring the session lock.
+
+test("recoverFailedMigration renames .gsd.migrating to .gsd when .gsd is absent", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-recovery-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const migratingPath = join(base, ".gsd.migrating");
+  mkdirSync(join(migratingPath, "milestones"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected recovery to succeed");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd must exist after recovery");
+  assert.ok(!existsSync(migratingPath), ".gsd.migrating must not exist after recovery");
+});
+
+test("recoverFailedMigration returns false when .gsd.migrating is absent (nothing to do)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-noop-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const recovered = recoverFailedMigration(base);
+  assert.equal(recovered, false, "no migration to recover");
+});
+
+test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exist (ambiguous)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-ambig-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+  assert.equal(recovered, false, "should not touch ambiguous state");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd must still exist");
+  assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
+});
+
+test("recoverFailedMigration preserves contents of .gsd.migrating", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-contents-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const migratingPath = join(base, ".gsd.migrating");
+  mkdirSync(join(migratingPath, "milestones", "M001"), { recursive: true });
+  writeFileSync(join(migratingPath, "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+  recoverFailedMigration(base);
+
+  const roadmap = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+  assert.ok(existsSync(roadmap), "Milestone file must be accessible via .gsd after recovery");
+});

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -247,6 +247,18 @@ test("model policy receives task metadata for requirement-vector decisions", ()
   );
 });
 
+test("dynamic routing passes provider-qualified model keys to the router", () => {
+  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
+  assert.ok(
+    src.includes("routingEligibleModels.map(m => `${m.provider}/${m.id}`)"),
+    "selectAndApplyModel should preserve provider prefixes for dynamic routing candidates",
+  );
+  assert.ok(
+    !src.includes("routingEligibleModels.map(m => m.id)"),
+    "selectAndApplyModel must not strip providers before resolving tier_models",
+  );
+});
+
 test("resolveModelId: anthropic wins over claude-code when session provider is not claude-code", () => {
   const availableModels = [
     { id: "claude-sonnet-4-6", provider: "claude-code" },

package/src/resources/extensions/gsd/tests/auto-prompts-fallback.test.ts

@@ -0,0 +1,35 @@
+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 { buildSourceFilePaths } from "../auto-prompts.ts";
+
+// Regression test for #4416: the fallback string must not mention `rg` because
+// auto-mode runs on systems where ripgrep is not installed (e.g. Windows).
+test("buildSourceFilePaths fallback does not reference rg or ripgrep", (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-prompts-fallback-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // No GSD files exist in tmp — forces the fallback branch.
+  const result = buildSourceFilePaths(tmp, "M001");
+
+  assert.ok(
+    !result.includes("rg ") && !result.includes("`rg`") && !result.includes("ripgrep"),
+    `Fallback string must not reference rg/ripgrep. Got: ${result}`,
+  );
+  assert.ok(result.length > 0, "Fallback string must not be empty");
+});
+
+test("buildSourceFilePaths with sid also produces rg-free fallback", (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-prompts-fallback-sid-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const result = buildSourceFilePaths(tmp, "M001", "S01");
+
+  assert.ok(
+    !result.includes("rg ") && !result.includes("`rg`") && !result.includes("ripgrep"),
+    `Fallback string must not reference rg/ripgrep. Got: ${result}`,
+  );
+});

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

@@ -5,7 +5,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
+import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
+import { resolveMilestoneFile } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
@@ -712,3 +713,124 @@ test("verifyExpectedArtifact checks pending gate-evaluate artifacts without ESM
 
   assert.equal(verified, false, "pending gates should keep gate-evaluate unverified");
 });
+
+// ─── #4414 regressions ────────────────────────────────────────────────────────
+
+test("#4414: writeBlockerPlaceholder invalidates path cache so dispatch guard sees file", () => {
+  const base = makeTmpBase();
+  try {
+    // Prime the readdir cache by resolving a DIFFERENT file first — this
+    // mirrors the stuck-loop condition where the dispatch guard cached an
+    // empty directory listing before the placeholder was written.
+    invalidateAllCaches();
+    assert.equal(
+      resolveMilestoneFile(base, "M001", "RESEARCH"),
+      null,
+      "no RESEARCH file yet",
+    );
+
+    const result = writeBlockerPlaceholder(
+      "research-milestone",
+      "M001",
+      base,
+      "verification retries exhausted",
+    );
+    assert.ok(result, "placeholder path returned");
+
+    // After writeBlockerPlaceholder, the dispatch guard must see the new file
+    // immediately — otherwise the rule re-fires (#4414, 7× re-dispatch).
+    const postResolve = resolveMilestoneFile(base, "M001", "RESEARCH");
+    assert.ok(
+      postResolve,
+      "resolveMilestoneFile finds the placeholder post-write (cache invalidated)",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("#4414: parallel-research sentinel path does not collide with RESEARCH suffix", () => {
+  const base = makeTmpBase();
+  try {
+    // Write only the parallel-research blocker (sentinel).
+    const sentinel = resolveExpectedArtifactPath(
+      "research-slice",
+      "M001/parallel-research",
+      base,
+    );
+    assert.ok(sentinel, "sentinel path resolves for parallel-research");
+    writeFileSync(sentinel!, "# blocker\n", "utf-8");
+
+    // Critical: the sentinel filename must NOT be matched by the legacy regex
+    // used when callers look up milestone-level RESEARCH. Otherwise the
+    // dispatch guard for research-milestone would short-circuit falsely.
+    const milestoneResearch = resolveMilestoneFile(base, "M001", "RESEARCH");
+    assert.equal(
+      milestoneResearch,
+      null,
+      "sentinel must not be mistaken for M001-RESEARCH.md via legacy pattern match",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("#4414: verifyExpectedArtifact parallel-research succeeds when all research-ready slices have RESEARCH", () => {
+  const base = makeTmpBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S03", "tasks"), { recursive: true });
+
+    // Minimal roadmap with three slices
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      [
+        "# M001: Regression",
+        "",
+        "## Slices",
+        "",
+        "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+        "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+        "- [ ] **S03: Gamma** `risk:low` `depends:[]`",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    // Only 2 of 3 have RESEARCH — should fail verification
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+      "# research",
+      "utf-8",
+    );
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-RESEARCH.md"),
+      "# research",
+      "utf-8",
+    );
+
+    clearParseCache();
+    invalidateAllCaches();
+    assert.equal(
+      verifyExpectedArtifact("research-slice", "M001/parallel-research", base),
+      false,
+      "missing S03 RESEARCH → verification fails",
+    );
+
+    // All three RESEARCH present → verification passes
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S03", "S03-RESEARCH.md"),
+      "# research",
+      "utf-8",
+    );
+    clearParseCache();
+    invalidateAllCaches();
+    assert.equal(
+      verifyExpectedArtifact("research-slice", "M001/parallel-research", base),
+      true,
+      "all slices have RESEARCH → verification passes",
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -15,6 +15,9 @@ const autoSrc = readFileSync(autoPath, "utf-8");
 const runUnitPath = join(import.meta.dirname, "..", "auto", "run-unit.ts");
 const runUnitSrc = readFileSync(runUnitPath, "utf-8");
 
+const registerHooksPath = join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts");
+const registerHooksSrc = readFileSync(registerHooksPath, "utf-8");
+
 describe("#3512: gsd-auto-wrapup must not interrupt in-flight tool calls", () => {
   test("soft timeout wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
     // The soft timeout sendMessage must NOT use a hardcoded `triggerTurn: true`.
@@ -70,6 +73,42 @@ describe("#3512: gsd-auto-wrapup must not interrupt in-flight tool calls", () =>
   });
 });
 
+describe("#4276: pending/skipped tools stay visible to auto-mode hooks", () => {
+  test("tool_call handler marks GSD tools in-flight before execution_start", () => {
+    const startMarker = 'pi.on("tool_call", async (event, ctx) => {';
+    const endMarker = 'pi.on("tool_result", async (event) => {';
+    const toolCallSection = registerHooksSrc.slice(
+      registerHooksSrc.indexOf(startMarker),
+      registerHooksSrc.indexOf(endMarker),
+    );
+
+    assert.ok(toolCallSection.length > 0, "Could not locate tool_call handler section");
+    assert.ok(
+      toolCallSection.includes("markToolStart(event.toolCallId, event.toolName)"),
+      "tool_call handler must mark tools pending before tool_execution_start fires",
+    );
+  });
+
+  test("tool_result handler clears pending tools and records queued-skip errors", () => {
+    const startMarker = 'pi.on("tool_result", async (event) => {';
+    const endMarker = 'pi.on("tool_execution_start", async (event) => {';
+    const toolResultSection = registerHooksSrc.slice(
+      registerHooksSrc.indexOf(startMarker),
+      registerHooksSrc.indexOf(endMarker),
+    );
+
+    assert.ok(toolResultSection.length > 0, "Could not locate tool_result handler section");
+    assert.ok(
+      toolResultSection.includes("markToolEnd(event.toolCallId)"),
+      "tool_result handler must clear pending tool tracking even when execution hooks never fire",
+    );
+    assert.ok(
+      toolResultSection.includes("recordToolInvocationError(event.toolName, errorText)"),
+      "tool_result handler must surface queued-skip errors for GSD tools",
+    );
+  });
+});
+
 describe("#3512: pauseAuto and stopAuto must flush queued follow-up messages", () => {
   test("stopAuto calls clearQueue()", () => {
     // stopAuto must flush queued messages to prevent late async_job_result

package/src/resources/extensions/gsd/tests/autocomplete-regressions-1675.test.ts

@@ -44,6 +44,14 @@ test("/gsd description includes discuss", () => {
   );
 });
 
+test("/gsd description includes debug", () => {
+  const pi = createMockPi();
+  registerGSDCommand(pi as any);
+
+  const gsd = pi.commands.get("gsd");
+  assert.ok(gsd.description.includes("debug"), "description should include debug");
+});
+
 test("/gsd next completions include --debug", () => {
   const pi = createMockPi();
   registerGSDCommand(pi as any);
@@ -54,6 +62,18 @@ test("/gsd next completions include --debug", () => {
   assert.ok(debug, "next --debug should appear in completions");
 });
 
+test("/gsd debug completions include list|status|continue|--diagnose", () => {
+  const pi = createMockPi();
+  registerGSDCommand(pi as any);
+
+  const gsd = pi.commands.get("gsd");
+  const completions = gsd.getArgumentCompletions("debug ");
+  const values = completions.map((c: any) => c.value);
+  for (const expected of ["debug list", "debug status", "debug continue", "debug --diagnose"]) {
+    assert.ok(values.includes(expected), `missing completion: ${expected}`);
+  }
+});
+
 test("/gsd widget completions include full|small|min|off", () => {
   const pi = createMockPi();
   registerGSDCommand(pi as any);
@@ -66,6 +86,25 @@ test("/gsd widget completions include full|small|min|off", () => {
   }
 });
 
+test("/gsd logs completions still include debug after adding /gsd debug", () => {
+  const pi = createMockPi();
+  registerGSDCommand(pi as any);
+
+  const gsd = pi.commands.get("gsd");
+  const completions = gsd.getArgumentCompletions("logs ");
+  const values = completions.map((c: any) => c.value);
+  assert.ok(values.includes("logs debug"), "logs debug completion should remain available");
+});
+
+test("/gsd help full includes /gsd debug command", async () => {
+  const ctx = createMockCtx();
+
+  await handleGSDCommand("help full", ctx as any, {} as any);
+
+  const helpText = ctx.notifications.map((n) => n.message).join("\n");
+  assert.match(helpText, /\/gsd debug\s+Create\/list\/continue persistent debug sessions/);
+});
+
 test("bare /gsd skip shows usage and does not fall through to unknown-command warning", async () => {
   const ctx = createMockCtx();
 

package/src/resources/extensions/gsd/tests/commands-do.test.ts

@@ -40,6 +40,8 @@ const ROUTES: Route[] = [
   { keywords: ["backlog", "parking lot", "later", "someday"], command: "backlog" },
   { keywords: ["add tests", "write tests", "generate tests", "test coverage"], command: "add-tests" },
   { keywords: ["next", "step", "next step", "what's next"], command: "next" },
+  { keywords: ["logs", "debug logs", "log files"], command: "logs" },
+  { keywords: ["debug", "debug session", "investigate", "troubleshoot", "diagnose issue"], command: "debug" },
 ];
 
 interface MatchResult {
@@ -120,8 +122,54 @@ test("/gsd do: prefers longer keyword match", () => {
   assert.ok(match.score >= 12);
 });
 
+test("/gsd do: routes debug troubleshooting intent to debug", () => {
+  const match = matchRoute("debug this flaky oauth callback");
+  assert.ok(match);
+  assert.equal(match.command, "debug");
+});
+
+test("/gsd do: keeps 'debug logs' routed to logs (longer keyword wins)", () => {
+  const match = matchRoute("show me debug logs for today");
+  assert.ok(match);
+  assert.equal(match.command, "logs");
+});
+
 test("/gsd do: routes 'session report' to session-report", () => {
   const match = matchRoute("show me the session report");
   assert.ok(match);
   assert.equal(match.command, "session-report");
 });
+
+test("/gsd do: routes 'diagnose issue' to debug (not doctor)", () => {
+  // 'diagnose issue' is an explicit keyword on the debug route to distinguish
+  // session-level issue diagnosis from /gsd doctor health checks.
+  const match = matchRoute("diagnose issue with oauth callback");
+  assert.ok(match);
+  assert.equal(match.command, "debug");
+});
+
+test("/gsd do: routes 'investigate flaky test' to debug", () => {
+  const match = matchRoute("investigate flaky test in CI");
+  assert.ok(match);
+  assert.equal(match.command, "debug");
+});
+
+test("/gsd do: 'debug logs' keyword wins over bare 'debug' (longer keyword precedence)", () => {
+  // 'debug logs' (10 chars) > 'debug' (5 chars)
+  const logsMatch = matchRoute("debug logs for the last run");
+  assert.ok(logsMatch);
+  assert.equal(logsMatch.command, "logs");
+  assert.ok(logsMatch.score >= 10, `expected score >= 10, got ${logsMatch.score}`);
+
+  // Bare 'debug' without 'logs' should still route to debug.
+  const debugMatch = matchRoute("debug the payment timeout issue");
+  assert.ok(debugMatch);
+  assert.equal(debugMatch.command, "debug");
+});
+
+test("/gsd do: 'diagnose' alone routes to doctor (health check), not debug", () => {
+  // 'diagnose' maps to the doctor route; 'diagnose issue' maps to debug.
+  const match = matchRoute("diagnose my project");
+  assert.ok(match);
+  assert.equal(match.command, "doctor");
+});