gsd-pi 2.61.0-dev.7aed0bf → 2.62.0-dev.a987556

package/src/resources/extensions/gsd/preferences-models.ts

@@ -107,6 +107,84 @@ export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedMode
   };
 }
 
+/**
+ * Resolve the default session model from GSD preferences.
+ *
+ * Used at auto-mode bootstrap to override the session model that was
+ * determined by settings.json (defaultProvider/defaultModel).  When
+ * PREFERENCES.md (or project preferences) configures an `execution` model
+ * we treat that as the session default.  Falls back through execution →
+ * planning → first configured model.
+ *
+ * Accepts an optional `sessionProvider` for bare model IDs that don't
+ * include an explicit provider prefix (e.g. `gpt-5.4` instead of
+ * `openai-codex/gpt-5.4`).  When a bare ID is found and sessionProvider
+ * is available, the session provider is used.  Without sessionProvider,
+ * bare IDs are still returned with provider set to the bare ID itself
+ * so downstream resolution (resolveModelId) can match it.
+ *
+ * Returns `{ provider, id }` or `undefined` if no model preference is
+ * configured.
+ */
+export function resolveDefaultSessionModel(
+  sessionProvider?: string,
+): { provider: string; id: string } | undefined {
+  const prefs = loadEffectiveGSDPreferences();
+  if (!prefs?.preferences.models) return undefined;
+
+  const m = prefs.preferences.models as GSDModelConfigV2;
+
+  // Priority: execution → planning → first configured value
+  const candidates: Array<string | GSDPhaseModelConfig | undefined> = [
+    m.execution,
+    m.planning,
+    m.research,
+    m.discuss,
+    m.completion,
+    m.validation,
+    m.subagent,
+  ];
+
+  for (const cfg of candidates) {
+    if (!cfg) continue;
+
+    // Normalize to provider + id from the various config shapes
+    let provider: string | undefined;
+    let id: string;
+
+    if (typeof cfg === "string") {
+      const slashIdx = cfg.indexOf("/");
+      if (slashIdx !== -1) {
+        provider = cfg.slice(0, slashIdx);
+        id = cfg.slice(slashIdx + 1);
+      } else {
+        // Bare model ID (e.g. "gpt-5.4") — use session provider as context
+        provider = sessionProvider;
+        id = cfg;
+      }
+    } else {
+      // Object config: { model, provider?, fallbacks? }
+      if (cfg.provider) {
+        provider = cfg.provider;
+      } else if (cfg.model.includes("/")) {
+        const slashIdx = cfg.model.indexOf("/");
+        provider = cfg.model.slice(0, slashIdx);
+        id = cfg.model.slice(slashIdx + 1);
+        return { provider, id };
+      } else {
+        provider = sessionProvider;
+      }
+      id = cfg.model;
+    }
+
+    if (provider && id) {
+      return { provider, id };
+    }
+  }
+
+  return undefined;
+}
+
 /**
  * Determines the next fallback model to try when the current model fails.
  * If the current model is not in the configured list, returns the primary model.

package/src/resources/extensions/gsd/preferences-skills.ts

@@ -24,13 +24,18 @@ export type { GSDSkillRule, SkillDiscoveryMode, SkillResolution, SkillResolution
 
 /**
  * Known skill directories, in priority order.
- * Global skills (~/.agents/skills/) take precedence over project skills.
+ * Searches both the skills.sh ecosystem directory (~/.agents/skills/) and
+ * Claude Code's official directory (~/.claude/skills/). Project-level
+ * directories for both conventions are included as well.
  * Legacy ~/.gsd/agent/skills/ is included as a fallback for pre-migration installs.
  */
 export function getSkillSearchDirs(cwd: string): Array<{ dir: string; method: SkillResolution["method"] }> {
   const dirs: Array<{ dir: string; method: SkillResolution["method"] }> = [
     { dir: join(homedir(), ".agents", "skills"), method: "user-skill" },
     { dir: join(cwd, ".agents", "skills"), method: "project-skill" },
+    // Claude Code official skill directories
+    { dir: join(homedir(), ".claude", "skills"), method: "user-skill" },
+    { dir: join(cwd, ".claude", "skills"), method: "project-skill" },
   ];
   // Legacy fallback — read skills from old GSD directory only if migration hasn't completed
   const legacyDir = join(homedir(), ".gsd", "agent", "skills");

package/src/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -30,7 +30,7 @@ Ask **1–3 questions per round**. Keep each question focused on one of:
 - **The biggest technical unknowns / risks** — what could fail, what hasn't been proven
 - **What external systems/services this touches** — APIs, databases, third-party services
 
-**If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` for each round. 1–3 questions per call, each as a separate question object. Keep option labels short (3–5 words). Always include a freeform "Other / let me explain" option. When the user picks that option or writes a long freeform answer, switch to plain text follow-up for that thread before resuming structured questions.
+**If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` for each round. 1–3 questions per call, each as a separate question object. Keep option labels short (3–5 words). Always include a freeform "Other / let me explain" option. When the user picks that option or writes a long freeform answer, switch to plain text follow-up for that thread before resuming structured questions. **IMPORTANT: Call `ask_user_questions` exactly once per turn. Never make multiple calls with the same or overlapping questions — wait for the user's response before asking the next round.**
 
 **If `{{structuredQuestionsAvailable}}` is `false`:** ask questions in plain text. Keep each round to 1–3 focused questions. Wait for answers before asking the next round.
 

package/src/resources/extensions/gsd/prompts/guided-discuss-slice.md

@@ -22,7 +22,7 @@ Do **not** go deep — just enough that your questions reflect what's actually t
 
 ### Question rounds
 
-Ask **1–3 questions per round** using `ask_user_questions`. Keep each question focused on one of:
+Ask **1–3 questions per round** using `ask_user_questions`. **Call `ask_user_questions` exactly once per turn — never make multiple calls with the same or overlapping questions. Wait for the user's response before asking the next round.** Keep each question focused on one of:
 - **UX and user-facing behaviour** — what does the user see, click, trigger, or experience?
 - **Edge cases and failure states** — what happens when things go wrong or are in unusual states?
 - **Scope boundaries** — what is explicitly in vs out for this slice? What deferred to later?

package/src/resources/extensions/gsd/skill-catalog.ts

@@ -935,13 +935,16 @@ export async function installPacksBatched(
 
 /**
  * Check if any skills from a pack are already installed.
+ * Searches both the skills.sh ecosystem directory and Claude Code's official directory.
  */
 export function isPackInstalled(pack: SkillPack): boolean {
-  const skillsDir = join(homedir(), ".agents", "skills");
-  if (!existsSync(skillsDir)) return false;
+  const skillsDirs = [
+    join(homedir(), ".agents", "skills"),
+    join(homedir(), ".claude", "skills"),
+  ];
 
   return pack.skills.every((name) =>
-    existsSync(join(skillsDir, name, "SKILL.md")),
+    skillsDirs.some((dir) => existsSync(join(dir, name, "SKILL.md"))),
   );
 }
 

package/src/resources/extensions/gsd/skill-discovery.ts

@@ -12,8 +12,9 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
-/** Industry-standard skills.sh global skills directory */
+/** Skills directories — skills.sh ecosystem + Claude Code official */
 const SKILLS_DIR = join(homedir(), ".agents", "skills");
+const CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
 
 export interface DiscoveredSkill {
   name: string;
@@ -58,8 +59,9 @@ export function detectNewSkills(): DiscoveredSkill[] {
   for (const dir of current) {
     if (baselineSkills.has(dir)) continue;
 
-    const skillMdPath = join(SKILLS_DIR, dir, "SKILL.md");
-    if (!existsSync(skillMdPath)) continue;
+    // Check both skill directories for the SKILL.md file
+    const skillMdPath = resolveSkillMdPath(dir);
+    if (!skillMdPath) continue;
 
     const meta = parseSkillFrontmatter(skillMdPath);
     if (meta) {
@@ -97,10 +99,10 @@ ${entries}
 
 // ─── Internals ────────────────────────────────────────────────────────────────
 
-function listSkillDirs(): string[] {
-  if (!existsSync(SKILLS_DIR)) return [];
+function listSkillDirsFrom(dir: string): string[] {
+  if (!existsSync(dir)) return [];
   try {
-    return readdirSync(SKILLS_DIR, { withFileTypes: true })
+    return readdirSync(dir, { withFileTypes: true })
       .filter(d => d.isDirectory())
       .map(d => d.name);
   } catch {
@@ -108,6 +110,13 @@ function listSkillDirs(): string[] {
   }
 }
 
+function listSkillDirs(): string[] {
+  const names = new Set<string>();
+  for (const name of listSkillDirsFrom(SKILLS_DIR)) names.add(name);
+  for (const name of listSkillDirsFrom(CLAUDE_SKILLS_DIR)) names.add(name);
+  return [...names];
+}
+
 function parseSkillFrontmatter(path: string): { name?: string; description?: string } | null {
   try {
     const content = readFileSync(path, "utf-8");
@@ -131,6 +140,14 @@ function parseSkillFrontmatter(path: string): { name?: string; description?: str
   }
 }
 
+function resolveSkillMdPath(skillName: string): string | null {
+  for (const dir of [SKILLS_DIR, CLAUDE_SKILLS_DIR]) {
+    const candidate = join(dir, skillName, "SKILL.md");
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
 function escapeXml(text: string): string {
   return text
     .replace(/&/g, "&amp;")

package/src/resources/extensions/gsd/skill-health.ts

@@ -207,9 +207,13 @@ export function formatSkillDetail(basePath: string, skillName: string): string {
     lines.push(`  ${date}  ${u.id.padEnd(20)}  ${formatTokenCount(u.tokens.total).padStart(8)} tokens  ${formatCost(u.cost)}`);
   }
 
-  // Check for SKILL.md existence
-  const skillPath = join(homedir(), ".agents", "skills", skillName, "SKILL.md");
-  if (existsSync(skillPath)) {
+  // Check for SKILL.md existence — search both ecosystem and Claude Code directories
+  const candidatePaths = [
+    join(homedir(), ".agents", "skills", skillName, "SKILL.md"),
+    join(homedir(), ".claude", "skills", skillName, "SKILL.md"),
+  ];
+  const skillPath = candidatePaths.find(p => existsSync(p));
+  if (skillPath) {
     const stat = statSync(skillPath);
     lines.push("");
     lines.push(`SKILL.md: ${skillPath}`);

package/src/resources/extensions/gsd/skill-telemetry.ts

@@ -31,12 +31,14 @@ const activelyLoadedSkills = new Set<string>();
  */
 export function captureAvailableSkills(): void {
   const skillsDir = join(homedir(), ".agents", "skills");
+  const claudeSkillsDir = join(homedir(), ".claude", "skills");
   const legacyDir = join(homedir(), ".gsd", "agent", "skills");
   const names = listSkillNames(skillsDir);
+  const claudeNames = listSkillNames(claudeSkillsDir);
   // Include skills still in the legacy directory only if migration hasn't completed
   const legacyMigrated = existsSync(join(legacyDir, ".migrated-to-agents"));
   const legacyNames = legacyMigrated ? [] : listSkillNames(legacyDir);
-  const all = new Set([...names, ...legacyNames]);
+  const all = new Set([...names, ...claudeNames, ...legacyNames]);
   availableSkills = [...all];
   activelyLoadedSkills.clear();
 }
@@ -106,10 +108,11 @@ export function detectStaleSkills(
 
   // Check all installed skills, not just those with usage data
   const skillsDir = join(homedir(), ".agents", "skills");
+  const claudeSkillsDir = join(homedir(), ".claude", "skills");
   const legacyDir = join(homedir(), ".gsd", "agent", "skills");
   const legacyMigrated = existsSync(join(legacyDir, ".migrated-to-agents"));
   const legacyNames = legacyMigrated ? [] : listSkillNames(legacyDir);
-  const installedSet = new Set([...listSkillNames(skillsDir), ...legacyNames]);
+  const installedSet = new Set([...listSkillNames(skillsDir), ...listSkillNames(claudeSkillsDir), ...legacyNames]);
   const installed = [...installedSet];
 
   for (const skill of installed) {

package/src/resources/extensions/gsd/tests/ask-user-questions-dedup.test.ts

@@ -0,0 +1,120 @@
+// ask-user-questions-dedup — Regression tests for per-turn deduplication
+//
+// Verifies that duplicate ask_user_questions calls within a single turn
+// return cached results instead of re-dispatching (especially to remote
+// channels like Discord). Also verifies the strict loop guard threshold
+// for interactive tools.
+//
+// Regression: duplicate questions were sent to Discord when the LLM called
+// ask_user_questions multiple times with the same question set in one turn,
+// causing user confusion and tool failure cascading to plain text fallback.
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  checkToolCallLoop,
+  resetToolCallLoopGuard,
+} from "../bootstrap/tool-call-loop-guard.ts";
+import {
+  resetAskUserQuestionsCache,
+  questionSignature,
+} from "../../ask-user-questions.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Strict loop guard: ask_user_questions blocks on 2nd identical call
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe("ask_user_questions dedup", () => {
+  beforeEach(() => {
+    resetToolCallLoopGuard();
+    resetAskUserQuestionsCache();
+  });
+
+  test("loop guard blocks 2nd identical ask_user_questions call", () => {
+    const args = { questions: [{ id: "app_coverage", question: "Which apps?" }] };
+
+    const first = checkToolCallLoop("ask_user_questions", args);
+    assert.equal(first.block, false, "First call should be allowed");
+
+    const second = checkToolCallLoop("ask_user_questions", args);
+    assert.equal(second.block, true, "2nd identical call should be blocked");
+    assert.ok(second.reason!.includes("ask_user_questions"), "Reason should name the tool");
+  });
+
+  test("loop guard allows different ask_user_questions calls", () => {
+    const args1 = { questions: [{ id: "app_coverage", question: "Which apps?" }] };
+    const args2 = { questions: [{ id: "testing_focus", question: "What priority?" }] };
+
+    const first = checkToolCallLoop("ask_user_questions", args1);
+    assert.equal(first.block, false, "First call allowed");
+
+    const second = checkToolCallLoop("ask_user_questions", args2);
+    assert.equal(second.block, false, "Different question set should be allowed");
+  });
+
+  test("non-interactive tools still use normal threshold of 4", () => {
+    const args = { query: "same query" };
+
+    for (let i = 1; i <= 4; i++) {
+      const result = checkToolCallLoop("web_search", args);
+      assert.equal(result.block, false, `web_search call ${i} should be allowed`);
+    }
+
+    const fifth = checkToolCallLoop("web_search", args);
+    assert.equal(fifth.block, true, "5th identical web_search should be blocked");
+  });
+
+  test("cache resets independently from loop guard", () => {
+    // Verify the reset function exists and is callable
+    resetAskUserQuestionsCache();
+    // No error means the cache module is properly exported and functional
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // questionSignature: full-payload hashing prevents stale cache hits
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test("same IDs with different question text produce different signatures", () => {
+    const q1 = [{ id: "scope", header: "Scope", question: "Which apps to cover?",
+      options: [{ label: "All", description: "Everything" }] }];
+    const q2 = [{ id: "scope", header: "Scope", question: "Which services to test?",
+      options: [{ label: "All", description: "Everything" }] }];
+
+    assert.notEqual(questionSignature(q1), questionSignature(q2),
+      "Different question text with same ID must produce different signatures");
+  });
+
+  test("same IDs with different options produce different signatures", () => {
+    const q1 = [{ id: "scope", header: "Scope", question: "Pick one",
+      options: [{ label: "A", description: "Option A" }] }];
+    const q2 = [{ id: "scope", header: "Scope", question: "Pick one",
+      options: [{ label: "B", description: "Option B" }] }];
+
+    assert.notEqual(questionSignature(q1), questionSignature(q2),
+      "Different options with same ID must produce different signatures");
+  });
+
+  test("identical payloads in different order produce same signature", () => {
+    const q1 = [
+      { id: "b", header: "B", question: "Q2", options: [{ label: "X", description: "x" }] },
+      { id: "a", header: "A", question: "Q1", options: [{ label: "Y", description: "y" }] },
+    ];
+    const q2 = [
+      { id: "a", header: "A", question: "Q1", options: [{ label: "Y", description: "y" }] },
+      { id: "b", header: "B", question: "Q2", options: [{ label: "X", description: "x" }] },
+    ];
+
+    assert.equal(questionSignature(q1), questionSignature(q2),
+      "Same questions in different order must produce the same signature");
+  });
+
+  test("allowMultiple difference produces different signature", () => {
+    const q1 = [{ id: "scope", header: "Scope", question: "Pick",
+      options: [{ label: "A", description: "a" }], allowMultiple: false }];
+    const q2 = [{ id: "scope", header: "Scope", question: "Pick",
+      options: [{ label: "A", description: "a" }], allowMultiple: true }];
+
+    assert.notEqual(questionSignature(q1), questionSignature(q2),
+      "allowMultiple difference must produce different signatures");
+  });
+});

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

@@ -7,8 +7,10 @@ const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
 const source = readFileSync(sourcePath, "utf-8");
 
 test("bootstrapAutoSession snapshots ctx.model before guided-flow entry (#2829)", () => {
-  const snapshotIdx = source.indexOf("const startModelSnapshot = ctx.model");
-  assert.ok(snapshotIdx > -1, "auto-start.ts should snapshot ctx.model at bootstrap start");
+  // #3517 changed the snapshot to prefer GSD preferences, but the ordering
+  // guarantee still holds: the snapshot must be built before guided-flow.
+  const snapshotIdx = source.indexOf("const startModelSnapshot = preferredModel");
+  assert.ok(snapshotIdx > -1, "auto-start.ts should snapshot model at bootstrap start");
 
   const firstDiscussIdx = source.indexOf('await showSmartEntry(ctx, pi, base, { step: requestedStepMode });');
   assert.ok(firstDiscussIdx > -1, "auto-start.ts should route through showSmartEntry during guided flow");
@@ -26,3 +28,21 @@ test("bootstrapAutoSession restores autoModeStartModel from the early snapshot (
   const snapshotRefIdx = source.indexOf("provider: startModelSnapshot.provider", assignmentIdx);
   assert.ok(snapshotRefIdx > -1, "autoModeStartModel should be restored from startModelSnapshot");
 });
+
+test("bootstrapAutoSession prefers GSD PREFERENCES.md over settings.json for start model (#3517)", () => {
+  // resolveDefaultSessionModel() should be called before the snapshot is built
+  const preferredIdx = source.indexOf("const preferredModel = resolveDefaultSessionModel(");
+  assert.ok(preferredIdx > -1, "auto-start.ts should call resolveDefaultSessionModel()");
+
+  // Session provider should be passed for bare model ID resolution
+  const withProviderIdx = source.indexOf("resolveDefaultSessionModel(ctx.model?.provider)");
+  assert.ok(withProviderIdx > -1, "auto-start.ts should pass ctx.model?.provider for bare ID resolution");
+
+  const snapshotIdx = source.indexOf("const startModelSnapshot = preferredModel");
+  assert.ok(snapshotIdx > -1, "startModelSnapshot should use preferredModel when available");
+
+  assert.ok(
+    preferredIdx < snapshotIdx,
+    "resolveDefaultSessionModel() must be called before building startModelSnapshot",
+  );
+});

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

@@ -0,0 +1,107 @@
+// GSD-2 — Regression tests for #3512: gsd-auto-wrapup mid-turn interruption
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const autoTimersPath = join(import.meta.dirname, "..", "auto-timers.ts");
+const autoTimersSrc = readFileSync(autoTimersPath, "utf-8");
+
+const autoPath = join(import.meta.dirname, "..", "auto.ts");
+const autoSrc = readFileSync(autoPath, "utf-8");
+
+const runUnitPath = join(import.meta.dirname, "..", "auto", "run-unit.ts");
+const runUnitSrc = readFileSync(runUnitPath, "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`.
+    // It must check getInFlightToolCount() before deciding whether to trigger.
+    // Use the section marker comment to isolate the soft timeout block.
+    const startMarker = "── 1. Soft timeout warning";
+    const endMarker = "── 2. Idle watchdog";
+    const softTimeoutSection = autoTimersSrc.slice(
+      autoTimersSrc.indexOf(startMarker),
+      autoTimersSrc.indexOf(endMarker),
+    );
+    assert.ok(
+      softTimeoutSection.length > 0,
+      "Could not locate soft timeout section",
+    );
+
+    // Must reference getInFlightToolCount to gate the trigger
+    assert.ok(
+      softTimeoutSection.includes("getInFlightToolCount"),
+      "Soft timeout wrapup must gate triggerTurn behind getInFlightToolCount() check",
+    );
+
+    // Must NOT have a hardcoded triggerTurn: true
+    assert.ok(
+      !softTimeoutSection.includes("triggerTurn: true"),
+      "Soft timeout wrapup must not use hardcoded triggerTurn: true",
+    );
+  });
+
+  test("context-pressure wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
+    // The context budget sendMessage must NOT use a hardcoded `triggerTurn: true`.
+    // Use the section marker to isolate the context-pressure block.
+    const startMarker = "── 4. Context-pressure continue-here monitor";
+    const contextSection = autoTimersSrc.slice(
+      autoTimersSrc.indexOf(startMarker),
+    );
+    assert.ok(
+      contextSection.length > 0,
+      "Could not locate context budget section",
+    );
+
+    // Must reference getInFlightToolCount to gate the trigger
+    assert.ok(
+      contextSection.includes("getInFlightToolCount"),
+      "Context budget wrapup must gate triggerTurn behind getInFlightToolCount() check",
+    );
+
+    // Must NOT have a hardcoded triggerTurn: true
+    assert.ok(
+      !contextSection.includes("triggerTurn: true"),
+      "Context budget wrapup must not use hardcoded triggerTurn: true",
+    );
+  });
+});
+
+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
+    // notifications from triggering extra LLM turns after stop.
+    const stopAutoSection = autoSrc.slice(
+      autoSrc.indexOf("export async function stopAuto("),
+      autoSrc.indexOf("export async function pauseAuto("),
+    );
+    assert.ok(stopAutoSection, "Could not locate stopAuto function");
+    assert.ok(
+      stopAutoSection.includes("clearQueue"),
+      "stopAuto must call clearQueue() to flush queued follow-up messages",
+    );
+  });
+
+  test("pauseAuto calls clearQueue()", () => {
+    // pauseAuto must also flush queued messages — same issue as stopAuto.
+    const pauseAutoSection = autoSrc.slice(
+      autoSrc.indexOf("export async function pauseAuto("),
+    );
+    assert.ok(pauseAutoSection, "Could not locate pauseAuto function");
+    assert.ok(
+      pauseAutoSection.includes("clearQueue"),
+      "pauseAuto must call clearQueue() to flush queued follow-up messages",
+    );
+  });
+
+  test("run-unit.ts still has its existing clearQueue() call (baseline)", () => {
+    // Verify the original clearQueue pattern in run-unit.ts hasn't been removed.
+    assert.ok(
+      runUnitSrc.includes("clearQueue"),
+      "run-unit.ts must retain its clearQueue() call after unit completion",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/claude-skill-dirs.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Tests for Claude Code skill directory support in getSkillSearchDirs().
+ *
+ * Verifies that ~/.claude/skills/ and .claude/skills/ are included in
+ * the skill search path alongside ~/.agents/skills/ and .agents/skills/.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getSkillSearchDirs } from "../preferences-skills.ts";
+
+describe("getSkillSearchDirs — Claude Code directory support", () => {
+  const cwd = "/tmp/test-project";
+
+  test("includes ~/.agents/skills/ as user-skill", () => {
+    const dirs = getSkillSearchDirs(cwd);
+    const agents = dirs.find((d) => d.dir === join(homedir(), ".agents", "skills"));
+    assert.ok(agents, "should include ~/.agents/skills/");
+    assert.equal(agents!.method, "user-skill");
+  });
+
+  test("includes .agents/skills/ as project-skill", () => {
+    const dirs = getSkillSearchDirs(cwd);
+    const projectAgents = dirs.find((d) => d.dir === join(cwd, ".agents", "skills"));
+    assert.ok(projectAgents, "should include .agents/skills/");
+    assert.equal(projectAgents!.method, "project-skill");
+  });
+
+  test("includes ~/.claude/skills/ as user-skill", () => {
+    const dirs = getSkillSearchDirs(cwd);
+    const claude = dirs.find((d) => d.dir === join(homedir(), ".claude", "skills"));
+    assert.ok(claude, "should include ~/.claude/skills/");
+    assert.equal(claude!.method, "user-skill");
+  });
+
+  test("includes .claude/skills/ as project-skill", () => {
+    const dirs = getSkillSearchDirs(cwd);
+    const projectClaude = dirs.find((d) => d.dir === join(cwd, ".claude", "skills"));
+    assert.ok(projectClaude, "should include .claude/skills/");
+    assert.equal(projectClaude!.method, "project-skill");
+  });
+
+  test("~/.agents/skills/ appears before ~/.claude/skills/ (priority order)", () => {
+    const dirs = getSkillSearchDirs(cwd);
+    const agentsIdx = dirs.findIndex((d) => d.dir === join(homedir(), ".agents", "skills"));
+    const claudeIdx = dirs.findIndex((d) => d.dir === join(homedir(), ".claude", "skills"));
+    assert.ok(agentsIdx < claudeIdx, "~/.agents/skills/ should have higher priority than ~/.claude/skills/");
+  });
+});

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -358,6 +358,47 @@ describe('db-writer', () => {
     }
   });
 
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Parallel save race condition regression (#3326, #3339, #3459)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  test('parallel saveDecisionToDb calls produce unique IDs', async () => {
+    const tmpDir = makeTmpDir();
+    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+    openDatabase(dbPath);
+
+    try {
+      // Fire 5 saves concurrently — before the fix, all would get D001
+      const results = await Promise.all([
+        saveDecisionToDb({ scope: 'a', decision: 'd1', choice: 'c1', rationale: 'r1' }, tmpDir),
+        saveDecisionToDb({ scope: 'b', decision: 'd2', choice: 'c2', rationale: 'r2' }, tmpDir),
+        saveDecisionToDb({ scope: 'c', decision: 'd3', choice: 'c3', rationale: 'r3' }, tmpDir),
+        saveDecisionToDb({ scope: 'd', decision: 'd4', choice: 'c4', rationale: 'r4' }, tmpDir),
+        saveDecisionToDb({ scope: 'e', decision: 'd5', choice: 'c5', rationale: 'r5' }, tmpDir),
+      ]);
+
+      const ids = results.map((r) => r.id);
+      const uniqueIds = new Set(ids);
+
+      // All 5 IDs must be unique
+      assert.equal(uniqueIds.size, 5, `Expected 5 unique IDs, got ${uniqueIds.size}: ${ids.join(', ')}`);
+
+      // IDs should be D001-D005 (order may vary due to concurrency)
+      for (const id of ids) {
+        assert.match(id, /^D\d{3}$/, `ID ${id} should match D### pattern`);
+      }
+
+      // Verify all 5 exist in DB
+      for (const id of ids) {
+        const row = getDecisionById(id);
+        assert.ok(row, `Decision ${id} should exist in DB`);
+      }
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
   // updateRequirementInDb Tests
   // ═══════════════════════════════════════════════════════════════════════════