gsd-pi 2.50.0-dev.d210a87 → 2.51.0-dev.7d435fe

package/src/resources/extensions/gsd/memory-store.ts

@@ -125,6 +125,9 @@ export function getActiveMemoriesRanked(limit = 30): Memory[] {
 /**
  * Generate the next memory ID: MEM + zero-padded 3-digit from MAX(seq).
  * Returns MEM001 if no memories exist.
+ *
+ * NOTE: For race-safe creation, prefer createMemory() which inserts with a
+ * placeholder ID then updates to the seq-derived ID atomically.
  */
 export function nextMemoryId(): string {
   if (!isDbAvailable()) return 'MEM001';
@@ -147,7 +150,9 @@ export function nextMemoryId(): string {
 // ─── Mutation Functions ─────────────────────────────────────────────────────
 
 /**
- * Insert a new memory with auto-assigned ID.
+ * Insert a new memory with a race-safe auto-assigned ID.
+ * Uses AUTOINCREMENT seq to derive the ID after insert, avoiding
+ * the read-then-write race in concurrent scenarios (e.g. worktrees).
  * Returns the assigned ID, or null on failure.
  */
 export function createMemory(fields: {
@@ -162,13 +167,14 @@ export function createMemory(fields: {
   if (!adapter) return null;
 
   try {
-    const id = nextMemoryId();
     const now = new Date().toISOString();
+    // Insert with a temporary placeholder ID — seq is auto-assigned
+    const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
     adapter.prepare(
       `INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
        VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`,
     ).run({
-      ':id': id,
+      ':id': placeholder,
       ':category': fields.category,
       ':content': fields.content,
       ':confidence': fields.confidence ?? 0.8,
@@ -177,7 +183,16 @@ export function createMemory(fields: {
       ':created_at': now,
       ':updated_at': now,
     });
-    return id;
+    // Derive the real ID from the assigned seq
+    const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
+    if (!row) return placeholder; // fallback — should not happen
+    const seq = row['seq'] as number;
+    const realId = `MEM${String(seq).padStart(3, '0')}`;
+    adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
+      ':real_id': realId,
+      ':placeholder': placeholder,
+    });
+    return realId;
   } catch {
     return null;
   }
@@ -331,20 +346,16 @@ export function enforceMemoryCap(max = 50): void {
     if (count <= max) return;
 
     const excess = count - max;
-    // Find the IDs of the lowest-ranked active memories
-    const rows = adapter.prepare(
-      `SELECT id FROM memories
-       WHERE superseded_by IS NULL
-       ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-       LIMIT :limit`,
-    ).all({ ':limit': excess });
-
-    const now = new Date().toISOString();
-    for (const row of rows) {
-      adapter.prepare(
-        'UPDATE memories SET superseded_by = :reason, updated_at = :now WHERE id = :id',
-      ).run({ ':reason': 'CAP_EXCEEDED', ':now': now, ':id': row['id'] as string });
-    }
+    // Batch update: supersede lowest-ranked active memories in a single statement
+    adapter.prepare(
+      `UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
+       WHERE id IN (
+         SELECT id FROM memories
+         WHERE superseded_by IS NULL
+         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
+         LIMIT :limit
+       )`,
+    ).run({ ':now': new Date().toISOString(), ':limit': excess });
   } catch {
     // non-fatal
   }

package/src/resources/extensions/gsd/milestone-actions.ts

@@ -20,6 +20,7 @@ import {
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
+import { isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 
 // ─── Park ──────────────────────────────────────────────────────────────────
 
@@ -52,6 +53,14 @@ export function parkMilestone(basePath: string, milestoneId: string, reason: str
   ].join("\n");
 
   writeFileSync(parkedPath, content, "utf-8");
+  // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
+  if (isDbAvailable()) {
+    try {
+      updateMilestoneStatus(milestoneId, "parked");
+    } catch (err) {
+      process.stderr.write(`gsd: parkMilestone DB sync failed for ${milestoneId}: ${(err as Error).message}\n`);
+    }
+  }
   invalidateAllCaches();
   return true;
 }
@@ -70,6 +79,14 @@ export function unparkMilestone(basePath: string, milestoneId: string): boolean
   if (!existsSync(parkedPath)) return false; // not parked
 
   unlinkSync(parkedPath);
+  // Sync DB status so deriveStateFromDb picks up the unparked milestone (#2694)
+  if (isDbAvailable()) {
+    try {
+      updateMilestoneStatus(milestoneId, "active");
+    } catch (err) {
+      process.stderr.write(`gsd: unparkMilestone DB sync failed for ${milestoneId}: ${(err as Error).message}\n`);
+    }
+  }
   invalidateAllCaches();
   return true;
 }

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

@@ -125,18 +125,6 @@ export function getNextFallbackModel(
   }
 }
 
-/**
- * Detect whether an error message indicates a transient network error
- * (worth retrying the same model) vs a permanent provider error
- * (auth failure, quota exceeded, etc. -- should fall back immediately).
- */
-export function isTransientNetworkError(errorMsg: string): boolean {
-  if (!errorMsg) return false;
-  const hasNetworkSignal = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i.test(errorMsg);
-  const hasPermanentSignal = /auth|unauthorized|forbidden|invalid.*key|quota|billing/i.test(errorMsg);
-  return hasNetworkSignal && !hasPermanentSignal;
-}
-
 /**
  * Validate a model ID string.
  * Returns true if the ID looks like a valid model identifier.
@@ -308,7 +296,7 @@ export function resolveContextSelection(): import("./types.js").ContextSelection
 }
 
 /**
- * Resolve the search provider preference from preferences.md.
+ * Resolve the search provider preference from PREFERENCES.md.
  * Returns undefined if not configured (caller falls back to existing behavior).
  */
 export function resolveSearchProviderFromPreferences(): GSDPreferences["search_provider"] | undefined {

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

@@ -68,7 +68,6 @@ export {
   resolveModelForUnit,
   resolveModelWithFallbacksForUnit,
   getNextFallbackModel,
-  isTransientNetworkError,
   validateModelId,
   updatePreferencesModels,
   resolveDynamicRoutingConfig,
@@ -87,7 +86,7 @@ function gsdHome(): string {
 }
 
 function globalPreferencesPath(): string {
-  return join(gsdHome(), "preferences.md");
+  return join(gsdHome(), "PREFERENCES.md");
 }
 
 function legacyGlobalPreferencesPath(): string {
@@ -95,15 +94,15 @@ function legacyGlobalPreferencesPath(): string {
 }
 
 function projectPreferencesPath(): string {
-  return join(gsdRoot(process.cwd()), "preferences.md");
+  return join(gsdRoot(process.cwd()), "PREFERENCES.md");
 }
-// Bootstrap in gitignore.ts historically created PREFERENCES.md (uppercase) by mistake.
-// Check uppercase as a fallback so those files aren't silently ignored.
-function globalPreferencesPathUppercase(): string {
-  return join(gsdHome(), "PREFERENCES.md");
+// Legacy: older versions used lowercase preferences.md.
+// Check lowercase as a fallback so those files aren't silently ignored.
+function globalPreferencesPathLegacy(): string {
+  return join(gsdHome(), "preferences.md");
 }
-function projectPreferencesPathUppercase(): string {
-  return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+function projectPreferencesPathLegacy(): string {
+  return join(gsdRoot(process.cwd()), "preferences.md");
 }
 
 export function getGlobalGSDPreferencesPath(): string {
@@ -122,13 +121,13 @@ export function getProjectGSDPreferencesPath(): string {
 
 export function loadGlobalGSDPreferences(): LoadedGSDPreferences | null {
   return loadPreferencesFile(globalPreferencesPath(), "global")
-    ?? loadPreferencesFile(globalPreferencesPathUppercase(), "global")
+    ?? loadPreferencesFile(globalPreferencesPathLegacy(), "global")
     ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
 }
 
 export function loadProjectGSDPreferences(): LoadedGSDPreferences | null {
   return loadPreferencesFile(projectPreferencesPath(), "project")
-    ?? loadPreferencesFile(projectPreferencesPathUppercase(), "project");
+    ?? loadPreferencesFile(projectPreferencesPathLegacy(), "project");
 }
 
 export function loadEffectiveGSDPreferences(): LoadedGSDPreferences | null {
@@ -223,7 +222,7 @@ export function parsePreferencesMarkdown(content: string): GSDPreferences | null
 
   if (!_warnedUnrecognizedFormat) {
     _warnedUnrecognizedFormat = true;
-    console.warn("[parsePreferencesMarkdown] preferences.md exists but uses an unrecognized format — skipping.");
+    console.warn("[parsePreferencesMarkdown] PREFERENCES.md exists but uses an unrecognized format — skipping.");
   }
   return null;
 }
@@ -502,7 +501,7 @@ export function resolvePreDispatchHooks(): PreDispatchHookConfig[] {
  * Resolve the effective git isolation mode from preferences.
  * Returns "none" (default), "worktree", or "branch".
  *
- * Default is "none" so GSD works out of the box without preferences.md.
+ * Default is "none" so GSD works out of the box without PREFERENCES.md.
  * Worktree isolation requires explicit opt-in because it depends on git
  * branch infrastructure that must be set up before use.
  */

package/src/resources/extensions/gsd/prompts/system.md

@@ -92,7 +92,7 @@ Titles live inside file content (headings, frontmatter), not in file or director
 
 ### Isolation Model
 
-Auto-mode supports three isolation modes (configured in `.gsd/preferences.md` under `taskIsolation.mode`):
+Auto-mode supports three isolation modes (configured in `.gsd/PREFERENCES.md` under `taskIsolation.mode`):
 
 - **worktree** (default): Work happens in `.gsd/worktrees/<MID>/`, a full git worktree on the `milestone/<MID>` branch. Each worktree has its own working copy and `.gsd/` directory. Squash-merged back to the integration branch on milestone completion.
 - **branch**: Work happens in the project root on a `milestone/<MID>` branch. No worktree directory — files are checked out in-place.

package/src/resources/extensions/gsd/provider-error-pause.ts

@@ -2,63 +2,6 @@ export type ProviderErrorPauseUI = {
   notify(message: string, level?: "info" | "warning" | "error" | "success"): void;
 };
 
-/**
- * Classify a provider error as transient (auto-resume) or permanent (manual resume).
- *
- * Transient: rate limits, server errors (500/502/503), overloaded, internal errors.
- * These are expected to self-resolve and should auto-resume after a delay.
- *
- * Permanent: auth errors, invalid API key, billing issues.
- * These require user intervention and should pause indefinitely.
- */
-export function classifyProviderError(errorMsg: string): {
-  isTransient: boolean;
-  isRateLimit: boolean;
-  suggestedDelayMs: number;
-} {
-  const isRateLimit = /rate.?limit|too many requests|429/i.test(errorMsg);
-  const isServerError = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i.test(errorMsg);
-
-  // Connection/process errors — transient, auto-resume after brief backoff (#2309).
-  // These indicate the process was killed, the connection was reset, or a network
-  // blip occurred. They are NOT permanent failures.
-  const isConnectionError = /terminated|connection.?reset|connection.?refused|other side closed|fetch failed|network.?(?:is\s+)?unavailable|ECONNREFUSED|ECONNRESET|EPIPE/i.test(errorMsg);
-
-  // Permanent errors — never auto-resume
-  const isPermanent = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i.test(errorMsg);
-
-  if (isPermanent && !isRateLimit) {
-    return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
-  }
-
-  if (isRateLimit) {
-    // Try to extract retry-after from the message
-    const resetMatch = errorMsg.match(/reset in (\d+)s/i);
-    const delayMs = resetMatch ? Number(resetMatch[1]) * 1000 : 60_000; // default 60s for rate limits
-    return { isTransient: true, isRateLimit: true, suggestedDelayMs: delayMs };
-  }
-
-  if (isServerError) {
-    return { isTransient: true, isRateLimit: false, suggestedDelayMs: 30_000 }; // 30s for server errors
-  }
-
-  if (isConnectionError) {
-    return { isTransient: true, isRateLimit: false, suggestedDelayMs: 15_000 }; // 15s for connection errors
-  }
-
-  // Stream-truncation JSON parse errors — transient (#2572).
-  // When the API stream is cut mid-chunk, pi tries to reassemble the partial
-  // tool-call JSON and gets a SyntaxError. This is the downstream symptom of
-  // a connection drop — same root cause as ECONNRESET, one layer up.
-  const isMalformedStream = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i.test(errorMsg);
-  if (isMalformedStream) {
-    return { isTransient: true, isRateLimit: false, suggestedDelayMs: 15_000 }; // 15s, same as connection errors
-  }
-
-  // Unknown error — treat as permanent (user reviews)
-  return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
-}
-
 /**
  * Pause auto-mode due to a provider error.
  *

package/src/resources/extensions/gsd/rule-registry.ts

@@ -524,7 +524,7 @@ export class RuleRegistry {
   formatHookStatus(): string {
     const entries = this.getHookStatus();
     if (entries.length === 0) {
-      return "No hooks configured. Add post_unit_hooks or pre_dispatch_hooks to .gsd/preferences.md";
+      return "No hooks configured. Add post_unit_hooks or pre_dispatch_hooks to .gsd/PREFERENCES.md";
     }
 
     const lines: string[] = ["Configured Hooks:", ""];

package/src/resources/extensions/gsd/service-tier.ts

@@ -27,15 +27,27 @@ const SERVICE_TIER_SCOPE_NOTE = "Only affects gpt-5.4 models, regardless of prov
 
 // ─── Gating ──────────────────────────────────────────────────────────────────
 
+/**
+ * Model ID prefixes (bare, without provider) that support OpenAI service tiers.
+ *
+ * This list is the fallback for callers that only have a model ID string.
+ * The authoritative source of truth is `model.capabilities.supportsServiceTier`
+ * (set via CAPABILITY_PATCHES in packages/pi-ai/src/models.ts). When callers
+ * have access to the full Model object, prefer reading capabilities directly.
+ *
+ * See: https://github.com/gsd-build/gsd-2/issues/2546
+ */
+const SERVICE_TIER_MODEL_PREFIXES = ["gpt-5.4"] as const;
+
 /**
  * Returns true when the given model ID supports OpenAI service tiers.
- * Currently only gpt-5.4 variants qualify.
+ * Reads from SERVICE_TIER_MODEL_PREFIXES — update that list, not this function.
  */
 export function supportsServiceTier(modelId: string): boolean {
   if (!modelId) return false;
   // Strip provider prefix if present (e.g. "openai/gpt-5.4" → "gpt-5.4")
   const bare = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
-  return bare.startsWith("gpt-5.4");
+  return SERVICE_TIER_MODEL_PREFIXES.some((prefix) => bare.startsWith(prefix));
 }
 
 // ─── Status Formatting ───────────────────────────────────────────────────────

package/src/resources/extensions/gsd/state.ts

@@ -211,7 +211,24 @@ export async function deriveState(basePath: string): Promise<GSDState> {
 
   // Dual-path: try DB-backed derivation first when hierarchy tables are populated
   if (isDbAvailable()) {
-    const dbMilestones = getAllMilestones();
+    let dbMilestones = getAllMilestones();
+
+    // Disk→DB reconciliation (#2631): when the milestones table is empty
+    // (e.g. failed initial migration per #2529), the reconciliation code
+    // inside deriveStateFromDb is unreachable. Populate from disk here so
+    // the DB path activates correctly.
+    if (dbMilestones.length === 0) {
+      const diskIds = findMilestoneIds(basePath);
+      let synced = false;
+      for (const diskId of diskIds) {
+        if (!isGhostMilestone(basePath, diskId)) {
+          insertMilestone({ id: diskId, status: 'active' });
+          synced = true;
+        }
+      }
+      if (synced) dbMilestones = getAllMilestones();
+    }
+
     if (dbMilestones.length > 0) {
       const stopDbTimer = debugTime("derive-state-db");
       result = await deriveStateFromDb(basePath);
@@ -562,7 +579,10 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── All slices done → validating/completing ─────────────────────────
-  const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
+  // Guard: [].every() === true (vacuous truth). Without the length check,
+  // an empty slice array causes a premature phase transition to
+  // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
+  const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isStatusDone(s.status));
   if (allSlicesDone) {
     const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
     const validationContent = validationFile ? await loadFile(validationFile) : null;

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

@@ -0,0 +1,61 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { parseMilestoneTarget } from "../commands/handlers/auto.js";
+
+describe("parseMilestoneTarget", () => {
+  it("extracts a simple milestone ID", () => {
+    const result = parseMilestoneTarget("auto M016");
+    assert.equal(result.milestoneId, "M016");
+    assert.equal(result.rest, "auto");
+  });
+
+  it("extracts a milestone ID with unique suffix", () => {
+    const result = parseMilestoneTarget("auto M001-a3b4c5 --verbose");
+    assert.equal(result.milestoneId, "M001-a3b4c5");
+    assert.equal(result.rest, "auto --verbose");
+  });
+
+  it("returns null when no milestone ID is present", () => {
+    const result = parseMilestoneTarget("auto --verbose");
+    assert.equal(result.milestoneId, null);
+    assert.equal(result.rest, "auto --verbose");
+  });
+
+  it("extracts milestone ID with flags in any order", () => {
+    const result = parseMilestoneTarget("auto --verbose M003 --debug");
+    assert.equal(result.milestoneId, "M003");
+    assert.equal(result.rest, "auto --verbose --debug");
+  });
+
+  it("returns null for plain 'auto'", () => {
+    const result = parseMilestoneTarget("auto");
+    assert.equal(result.milestoneId, null);
+    assert.equal(result.rest, "auto");
+  });
+
+  it("extracts from 'next' command", () => {
+    const result = parseMilestoneTarget("next M012");
+    assert.equal(result.milestoneId, "M012");
+    assert.equal(result.rest, "next");
+  });
+
+  it("handles milestone ID at the start of input", () => {
+    const result = parseMilestoneTarget("M007");
+    assert.equal(result.milestoneId, "M007");
+    assert.equal(result.rest, "");
+  });
+
+  it("picks the first milestone ID when multiple appear", () => {
+    // Edge case: user accidentally types two. First one wins.
+    const result = parseMilestoneTarget("auto M001 M002");
+    assert.equal(result.milestoneId, "M001");
+    // M002 remains in rest since only the first match is removed
+    assert.ok(result.rest.includes("M002"));
+  });
+
+  it("does not match bare numbers without M prefix", () => {
+    const result = parseMilestoneTarget("auto 016");
+    assert.equal(result.milestoneId, null);
+  });
+});

package/src/resources/extensions/gsd/tests/claude-import-marketplace-discovery.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Portable tests for marketplace discovery in claude-import.
+ *
+ * Validates that categorizePluginRoots correctly discovers marketplace repos
+ * nested inside container directories (the Claude Code convention), and that
+ * discoverClaudePlugins recognizes .claude-plugin/plugin.json in addition to
+ * package.json.
+ *
+ * Uses temp-dir fixtures — no real marketplace repos required.
+ *
+ * Fixes: https://github.com/gsd-build/gsd-2/issues/2717
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { categorizePluginRoots } from "../claude-import.js";
+
+describe("categorizePluginRoots", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "gsd-mktplace-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should detect a direct marketplace root", () => {
+    // Root itself has .claude-plugin/marketplace.json
+    mkdirSync(join(tmpDir, ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(tmpDir, ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "direct", plugins: [] })
+    );
+
+    const { marketplaces, flat } = categorizePluginRoots([tmpDir]);
+
+    assert.equal(marketplaces.length, 1);
+    assert.equal(marketplaces[0], tmpDir);
+    assert.equal(flat.length, 0);
+  });
+
+  it("should discover marketplace repos nested one level inside a container directory", () => {
+    // Simulate ~/.claude/plugins/marketplaces/ with two marketplace subdirs
+    const mktA = join(tmpDir, "marketplace-a");
+    const mktB = join(tmpDir, "marketplace-b");
+
+    mkdirSync(join(mktA, ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(mktA, ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "a", plugins: [] })
+    );
+
+    mkdirSync(join(mktB, ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(mktB, ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "b", plugins: [] })
+    );
+
+    const { marketplaces, flat } = categorizePluginRoots([tmpDir]);
+
+    assert.equal(marketplaces.length, 2);
+    assert.ok(marketplaces.includes(mktA));
+    assert.ok(marketplaces.includes(mktB));
+    assert.equal(flat.length, 0);
+  });
+
+  it("should fall back to flat when no child is a marketplace", () => {
+    // Container with no marketplace subdirs
+    mkdirSync(join(tmpDir, "some-dir"), { recursive: true });
+
+    const { marketplaces, flat } = categorizePluginRoots([tmpDir]);
+
+    assert.equal(marketplaces.length, 0);
+    assert.equal(flat.length, 1);
+    assert.equal(flat[0], tmpDir);
+  });
+
+  it("should handle a mix of direct marketplace and container roots", () => {
+    // Root A is a direct marketplace
+    const directRoot = join(tmpDir, "direct");
+    mkdirSync(join(directRoot, ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(directRoot, ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "direct", plugins: [] })
+    );
+
+    // Root B is a container with a child marketplace
+    const container = join(tmpDir, "container");
+    const child = join(container, "child-marketplace");
+    mkdirSync(join(child, ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(child, ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "child", plugins: [] })
+    );
+
+    // Root C has nothing
+    const emptyRoot = join(tmpDir, "empty");
+    mkdirSync(emptyRoot, { recursive: true });
+
+    const { marketplaces, flat } = categorizePluginRoots([
+      directRoot,
+      container,
+      emptyRoot,
+    ]);
+
+    assert.equal(marketplaces.length, 2);
+    assert.ok(marketplaces.includes(directRoot));
+    assert.ok(marketplaces.includes(child));
+    assert.equal(flat.length, 1);
+    assert.equal(flat[0], emptyRoot);
+  });
+
+  it("should not duplicate when the same marketplace appears via multiple roots", () => {
+    // Direct reference AND container reference to the same marketplace
+    const mkt = join(tmpDir, "mkt");
+    mkdirSync(join(mkt, ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(mkt, ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "mkt", plugins: [] })
+    );
+
+    const { marketplaces } = categorizePluginRoots([mkt, tmpDir]);
+
+    assert.equal(marketplaces.length, 1);
+    assert.equal(marketplaces[0], mkt);
+  });
+
+  it("should skip .git and node_modules subdirectories", () => {
+    // Put a marketplace.json inside .git — should be ignored
+    mkdirSync(join(tmpDir, ".git", ".claude-plugin"), { recursive: true });
+    writeFileSync(
+      join(tmpDir, ".git", ".claude-plugin", "marketplace.json"),
+      JSON.stringify({ name: "hidden", plugins: [] })
+    );
+
+    const { marketplaces, flat } = categorizePluginRoots([tmpDir]);
+
+    assert.equal(marketplaces.length, 0);
+    assert.equal(flat.length, 1);
+  });
+
+  it("should handle non-existent root gracefully", () => {
+    const missing = join(tmpDir, "does-not-exist");
+    // categorizePluginRoots receives paths from uniqueExistingDirs, but
+    // be defensive — it should not crash on a missing root
+    const { marketplaces, flat } = categorizePluginRoots([missing]);
+
+    assert.equal(marketplaces.length, 0);
+    assert.equal(flat.length, 1); // falls through to flat
+  });
+});
+
+describe("discoverClaudePlugins — Claude plugin.json recognition", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "gsd-plugin-disc-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should discover a plugin with .claude-plugin/plugin.json (no package.json)", async () => {
+    // Simulate a cached Claude marketplace plugin
+    const pluginDir = join(tmpDir, "my-plugin");
+    mkdirSync(join(pluginDir, ".claude-plugin"), { recursive: true });
+    mkdirSync(join(pluginDir, "skills", "my-skill"), { recursive: true });
+    writeFileSync(
+      join(pluginDir, ".claude-plugin", "plugin.json"),
+      JSON.stringify({ name: "my-plugin", version: "1.0.0", description: "Test plugin" })
+    );
+    writeFileSync(join(pluginDir, "skills", "my-skill", "SKILL.md"), "# My Skill");
+
+    // Import discoverClaudePlugins dynamically since it depends on getClaudeSearchRoots
+    // which uses hardcoded paths. Instead, test the flat-path discovery logic directly
+    // by checking that the plugin.json file is recognized.
+    const claudePluginPath = join(pluginDir, ".claude-plugin", "plugin.json");
+    assert.ok(existsSync(claudePluginPath), "Claude plugin.json should exist");
+
+    // The fix ensures walkDirs checks for .claude-plugin/plugin.json in addition
+    // to package.json. We verify the file structure is correct for discovery.
+    const pkgPath = join(pluginDir, "package.json");
+    assert.ok(!existsSync(pkgPath), "package.json should NOT exist — this is a Claude plugin");
+  });
+});

package/src/resources/extensions/gsd/tests/claude-import-tui.test.ts

@@ -126,7 +126,7 @@ describe(
 
 		before(() => {
 			tempDir = mkdtempSync(join(tmpdir(), 'gsd-tui-test-'));
-			prefsPath = join(tempDir, 'preferences.md');
+			prefsPath = join(tempDir, 'PREFERENCES.md');
 			prefs = { version: 1 };
 		});
 

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

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+test("commands-config source-level: tool key lookup skips empty api_key entries", () => {
+  const source = readFileSync(join(__dirname, "..", "commands-config.ts"), "utf-8");
+  assert.ok(
+    source.includes('getCredentialsForProvider(providerId)'),
+    "commands-config should read the full credential list",
+  );
+  assert.ok(
+    source.includes('c.type === "api_key" && c.key'),
+    "commands-config should require a non-empty api_key when resolving stored tool keys",
+  );
+  assert.ok(
+    !source.includes("auth.get(tool.id)"),
+    "commands-config should not rely on auth.get(tool.id), which can return an empty shadowing entry",
+  );
+});