gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

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

@@ -10,9 +10,10 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 
-const SKILLS_DIR = join(getAgentDir(), "skills");
+/** Industry-standard skills.sh global skills directory */
+const SKILLS_DIR = join(homedir(), ".agents", "skills");
 
 export interface DiscoveredSkill {
   name: string;

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

@@ -15,7 +15,7 @@
 
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 import type { UnitMetrics, MetricsLedger } from "./metrics.js";
 import { formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
 import { getSkillLastUsed, detectStaleSkills } from "./skill-telemetry.js";
@@ -208,7 +208,7 @@ export function formatSkillDetail(basePath: string, skillName: string): string {
   }
 
   // Check for SKILL.md existence
-  const skillPath = join(getAgentDir(), "skills", skillName, "SKILL.md");
+  const skillPath = join(homedir(), ".agents", "skills", skillName, "SKILL.md");
   if (existsSync(skillPath)) {
     const stat = require("node:fs").statSync(skillPath);
     lines.push("");

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

@@ -13,7 +13,7 @@
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
 
 // ─── In-memory state ──────────────────────────────────────────────────────────
 
@@ -30,8 +30,14 @@ const activelyLoadedSkills = new Set<string>();
  * Called before each unit starts.
  */
 export function captureAvailableSkills(): void {
-  const skillsDir = join(getAgentDir(), "skills");
-  availableSkills = listSkillNames(skillsDir);
+  const skillsDir = join(homedir(), ".agents", "skills");
+  const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+  const names = listSkillNames(skillsDir);
+  // 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]);
+  availableSkills = [...all];
   activelyLoadedSkills.clear();
 }
 
@@ -99,8 +105,12 @@ export function detectStaleSkills(
   const stale: string[] = [];
 
   // Check all installed skills, not just those with usage data
-  const skillsDir = join(getAgentDir(), "skills");
-  const installed = listSkillNames(skillsDir);
+  const skillsDir = join(homedir(), ".agents", "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 installed = [...installedSet];
 
   for (const skill of installed) {
     const lastTs = lastUsed.get(skill);

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

@@ -34,7 +34,8 @@ import {
   gsdRoot,
 } from './paths.js';
 
-import { milestoneIdSort, findMilestoneIds } from './milestone-ids.js';
+import { findMilestoneIds } from './milestone-ids.js';
+import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
 import { join, resolve } from 'path';
@@ -149,8 +150,14 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
   if (isDbAvailable()) {
     const allMilestones = getAllMilestones();
     if (allMilestones.length > 0) {
-      const sorted = [...allMilestones].sort((a, b) => a.id.localeCompare(b.id));
-      for (const m of sorted) {
+      // Respect queue-order.json so /gsd queue reordering is honored (#2556).
+      // Without this, the DB path uses lexicographic sort while the dispatch
+      // guard uses queue order — causing a deadlock.
+      const customOrder = loadQueueOrder(basePath);
+      const sortedIds = sortByQueueOrder(allMilestones.map(m => m.id), customOrder);
+      const byId = new Map(allMilestones.map(m => [m.id, m]));
+      for (const id of sortedIds) {
+        const m = byId.get(id)!;
         if (m.status === "complete" || m.status === "done" || m.status === "parked") continue;
         return m.id;
       }
@@ -204,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);
@@ -304,8 +328,12 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       } as MilestoneRow);
     }
   }
-  // Re-sort so milestones are in canonical order after injection
-  allMilestones.sort((a, b) => milestoneIdSort(a.id, b.id));
+  // Re-sort so milestones follow queue order (same as dispatch guard) (#2556)
+  const customOrder = loadQueueOrder(basePath);
+  const sortedIds = sortByQueueOrder(allMilestones.map(m => m.id), customOrder);
+  const byId = new Map(allMilestones.map(m => [m.id, m]));
+  allMilestones.length = 0;
+  for (const id of sortedIds) allMilestones.push(byId.get(id)!);
 
   // Parallel worker isolation: when locked, filter to just the locked milestone
   const milestoneLock = process.env.GSD_MILESTONE_LOCK;
@@ -551,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/templates/{preferences.md → PREFERENCES.md}

@@ -71,6 +71,8 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# experimental:
+#   rtk: false
 ---
 
 # GSD Skill Preferences

package/src/resources/extensions/gsd/templates/milestone-validation.md

@@ -35,6 +35,18 @@ validated_at: {{date}}
 
 - **{{requirementId}}**: {{status}} — {{disposition: covered by remediation slice / acceptable gap / needs attention}}
 
+## Verification Class Compliance
+
+<!-- If verification classes were defined during planning, document whether each
+     was addressed. Use N/A for classes that were empty or "none" in planning. -->
+
+| Class | Planned | Evidence | Status |
+|-------|---------|----------|--------|
+| Contract | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+| Integration | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+| Operational | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+| UAT | {{planned_or_none}} | {{evidence_or_none}} | {{MET / NOT MET / N/A}} |
+
 ## Remediation Slices
 
 <!-- New slices appended to the roadmap to address auto-remediable gaps.

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

@@ -1,5 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
 import {
   unitVerb,
@@ -11,6 +13,9 @@ import {
   extractUatSliceId,
 } from "../auto-dashboard.ts";
 
+const autoSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto.ts"), "utf-8");
+const dashboardSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto-dashboard.ts"), "utf-8");
+
 // ─── unitVerb ─────────────────────────────────────────────────────────────
 
 test("unitVerb maps known unit types to verbs", () => {
@@ -180,6 +185,17 @@ test("formatAutoElapsed returns empty string for negative autoStartTime", () =>
   assert.equal(formatAutoElapsed(NaN), "");
 });
 
+test("getAutoDashboardData returns RTK savings in the dashboard payload", () => {
+  assert.match(autoSource, /const rtkSavings = sessionId && s\.basePath/);
+  assert.match(autoSource, /rtkSavings,/);
+});
+
+test("auto progress widget renders RTK savings under the footer stats line", () => {
+  assert.match(dashboardSource, /formatRtkSavingsLabel/);
+  assert.match(dashboardSource, /getRtkSessionSavings\(accessors\.getBasePath\(\), sessionId\)/);
+  assert.match(dashboardSource, /lines\.push\(rightAlign\("", theme\.fg\("dim", cachedRtkLabel\), width\)\);/);
+});
+
 // ─── extractUatSliceId ───────────────────────────────────────────────────
 
 test("extractUatSliceId extracts slice ID from M001/S01 format", () => {

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

@@ -140,7 +140,7 @@ test("isLockProcessAlive returns false for dead PID", () => {
   assert.equal(isLockProcessAlive(lock), false, "dead PID should return false");
 });
 
-test("isLockProcessAlive returns false for own PID (recycled)", () => {
+test("#2470: isLockProcessAlive returns true for own PID (we hold the lock)", () => {
   const lock = {
     pid: process.pid,
     startedAt: new Date().toISOString(),
@@ -148,7 +148,7 @@ test("isLockProcessAlive returns false for own PID (recycled)", () => {
     unitId: "M001/S01/T01",
     unitStartedAt: new Date().toISOString(),
   };
-  assert.equal(isLockProcessAlive(lock), false, "own PID should return false (recycled)");
+  assert.equal(isLockProcessAlive(lock), true, "own PID means we are alive — not stale (#2470)");
 });
 
 test("isLockProcessAlive returns false for invalid PID", () => {

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

@@ -882,6 +882,74 @@ test("autoLoop handles dispatch stop action", async (t) => {
   );
 });
 
+// #2474: warning-level dispatch stop should pause (resumable), not hard-stop
+test("autoLoop pauses instead of stopping for warning-level dispatch stop", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "stop" as const,
+        reason: 'UAT verdict for S01 is "partial" — blocking progression.',
+        level: "warning" as const,
+      };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(
+    deps.callLog.includes("resolveDispatch"),
+    "should have called resolveDispatch",
+  );
+  assert.ok(
+    deps.callLog.includes("pauseAuto"),
+    "warning-level stop should call pauseAuto (resumable)",
+  );
+  assert.ok(
+    !deps.callLog.includes("stopAuto"),
+    "warning-level stop should NOT call stopAuto (hard stop)",
+  );
+});
+
+// #2474: error-level dispatch stop should still hard-stop
+test("autoLoop hard-stops for error-level dispatch stop", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "stop" as const,
+        reason: "Cannot complete milestone: missing SUMMARY files.",
+        level: "error" as const,
+      };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(
+    deps.callLog.includes("stopAuto"),
+    "error-level stop should call stopAuto (hard stop)",
+  );
+  assert.ok(
+    !deps.callLog.includes("pauseAuto"),
+    "error-level stop should NOT call pauseAuto",
+  );
+});
+
 test("autoLoop handles dispatch skip action by continuing", async (t) => {
   _resetPendingResolve();
 

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",
+  );
+});

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

@@ -5,6 +5,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { invalidateAllCaches } from '../cache.ts';
+import { parseUnitId } from "../unit-id.ts";
 
 // loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
 // In a worktree the file may not exist there yet, so we resolve prompts
@@ -222,8 +223,7 @@ describe("complete-milestone", () => {
 
       const unitType = "complete-milestone";
       const unitId = "M001";
-      const parts = unitId.split("/");
-      const mid = parts[0]!;
+      const { milestone: mid } = parseUnitId(unitId);
 
       // This is the exact logic from diagnoseExpectedArtifact for "complete-milestone"
       const result = `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v12 after quality gates table)
+  // Verify schema version is current (v14 after indexes + slice_dependencies)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 12, 'schema version should be 12');
+  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();