gsd-pi 2.62.0-dev.f6ad485 → 2.62.1-dev.1ae2b74

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
   // ═══════════════════════════════════════════════════════════════════════════

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

@@ -1,5 +1,6 @@
 /**
- * Tests for model config isolation between concurrent instances (#650, #1065).
+ * Tests for model config isolation between concurrent instances (#650, #1065)
+ * and GSD preferences override of settings.json defaults (#3517).
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -155,3 +156,76 @@ describe("session model recovery on error (#1065)", () => {
       "Recovery should be skipped when no session model was captured");
   });
 });
+
+// ─── GSD Preferences override settings.json (#3517) ─────────────────────────
+
+describe("GSD preferences override settings.json for session model (#3517)", () => {
+  it("preferredModel takes priority over ctx.model when both are available", () => {
+    // Simulates auto-start.ts logic: preferredModel ?? ctx.model snapshot
+    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" };
+    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+
+    const startModelSnapshot = preferredModel
+      ?? { provider: ctxModel.provider, id: ctxModel.id };
+
+    assert.equal(startModelSnapshot.provider, "openai-codex",
+      "preferredModel provider should win over ctx.model");
+    assert.equal(startModelSnapshot.id, "gpt-5.4",
+      "preferredModel id should win over ctx.model");
+  });
+
+  it("falls back to ctx.model when no GSD preferences are configured", () => {
+    const preferredModel: { provider: string; id: string } | undefined = undefined;
+    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+
+    const startModelSnapshot = preferredModel
+      ?? { provider: ctxModel.provider, id: ctxModel.id };
+
+    assert.equal(startModelSnapshot.provider, "claude-code",
+      "should fall back to ctx.model provider when no preferences");
+    assert.equal(startModelSnapshot.id, "claude-sonnet-4-6",
+      "should fall back to ctx.model id when no preferences");
+  });
+
+  it("handles null ctx.model with no preferences gracefully", () => {
+    const preferredModel: { provider: string; id: string } | undefined = undefined;
+    // Use a function to prevent TS from narrowing to `never` in the ternary
+    function getCtxModel(): { provider: string; id: string } | null { return null; }
+    const ctxModel = getCtxModel();
+
+    const startModelSnapshot = preferredModel
+      ?? (ctxModel ? { provider: ctxModel.provider, id: ctxModel.id } : null);
+
+    assert.equal(startModelSnapshot, null,
+      "should be null when neither preferences nor ctx.model exist");
+  });
+
+  it("bare model ID uses session provider when available", () => {
+    // Simulates: PREFERENCES.md has "gpt-5.4" (no provider), session is openai-codex
+    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" }; // from resolveDefaultSessionModel("openai-codex")
+    const ctxModel = { provider: "openai-codex", id: "claude-sonnet-4-6" };
+
+    const startModelSnapshot = preferredModel
+      ?? { provider: ctxModel.provider, id: ctxModel.id };
+
+    assert.equal(startModelSnapshot.provider, "openai-codex");
+    assert.equal(startModelSnapshot.id, "gpt-5.4",
+      "bare model ID from preferences should still override ctx.model");
+  });
+
+  it("stale settings.json does not leak when preferences are set", () => {
+    // Scenario: settings.json has claude-code, PREFERENCES.md has openai-codex
+    const settingsJsonDefault = { provider: "claude-code", id: "claude-sonnet-4-6" };
+    const preferencesModel = { provider: "openai-codex", id: "gpt-5.4" };
+
+    // auto-start.ts captures preferredModel first, which preempts settingsJsonDefault
+    const startModelSnapshot = preferencesModel ?? settingsJsonDefault;
+
+    assert.equal(startModelSnapshot.provider, "openai-codex",
+      "PREFERENCES.md must override stale settings.json provider");
+    assert.equal(startModelSnapshot.id, "gpt-5.4",
+      "PREFERENCES.md must override stale settings.json model");
+    assert.notEqual(startModelSnapshot.provider, settingsJsonDefault.provider,
+      "settings.json provider must NOT leak through");
+  });
+});

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -136,17 +136,30 @@ console.log('\n── Loop guard: nested args are not stripped ──');
     assert.deepStrictEqual(getToolCallLoopCount(), 1, `Each unique nested call should reset count to 1`);
   }
 
-  // Truly identical nested calls should still be detected
+  // Truly identical nested calls should still be detected.
+  // ask_user_questions has a strict threshold of 1, so the 2nd identical call is blocked.
+  resetToolCallLoopGuard();
+  const first = checkToolCallLoop('ask_user_questions', {
+    questions: [{ id: 'same', question: 'Same?' }],
+  });
+  assert.ok(first.block === false, 'First ask_user_questions call should be allowed');
+  const blocked = checkToolCallLoop('ask_user_questions', {
+    questions: [{ id: 'same', question: 'Same?' }],
+  });
+  assert.ok(blocked.block === true, '2nd identical ask_user_questions call should be blocked (strict threshold)');
+
+  // Non-strict tools still allow up to 4 identical calls
   resetToolCallLoopGuard();
   for (let i = 1; i <= 4; i++) {
-    checkToolCallLoop('ask_user_questions', {
+    const r = checkToolCallLoop('web_search', {
       questions: [{ id: 'same', question: 'Same?' }],
     });
+    assert.ok(r.block === false, `web_search call ${i} should be allowed (normal threshold)`);
   }
-  const blocked = checkToolCallLoop('ask_user_questions', {
+  const blockedNormal = checkToolCallLoop('web_search', {
     questions: [{ id: 'same', question: 'Same?' }],
   });
-  assert.ok(blocked.block === true, 'Identical nested calls should still be blocked');
+  assert.ok(blockedNormal.block === true, '5th identical web_search call should be blocked');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/workflow-logger.test.ts

@@ -217,12 +217,26 @@ describe("workflow-logger", () => {
       assert.ok(formatted.includes("\n"));
     });
 
-    test("does not include context in formatted output", () => {
+    test("includes context fields in formatted output", () => {
       logError("tool", "failed", { cmd: "complete_task" });
       const entries = drainLogs();
       const formatted = formatForNotification(entries);
-      assert.equal(formatted, "[tool] failed");
-      assert.ok(!formatted.includes("complete_task"));
+      assert.equal(formatted, "[tool] failed (cmd: complete_task)");
+    });
+
+    test("excludes error key from context to avoid redundancy", () => {
+      logError("tool", "disk write failed", { error: "ENOSPC", path: "/tmp/foo" });
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.ok(formatted.includes("path: /tmp/foo"));
+      assert.ok(!formatted.includes("error: ENOSPC"));
+    });
+
+    test("formats entry without context unchanged", () => {
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[intercept] blocked write");
     });
   });
 
@@ -279,44 +293,6 @@ describe("workflow-logger", () => {
     });
   });
 
-  describe("audit log persistence", () => {
-    let dir: string;
-
-    beforeEach(() => {
-      dir = makeTempDir("wl-audit-");
-    });
-
-    afterEach(() => {
-      setLogBasePath("");
-      cleanup(dir);
-    });
-
-    test("writes entry to .gsd/audit-log.jsonl after setLogBasePath", () => {
-      setLogBasePath(dir);
-      logError("engine", "audit test entry");
-
-      const auditPath = join(dir, ".gsd", "audit-log.jsonl");
-      assert.ok(existsSync(auditPath), "audit-log.jsonl should exist");
-      const content = readFileSync(auditPath, "utf-8");
-      const entry = JSON.parse(content.trim());
-      assert.equal(entry.severity, "error");
-      assert.equal(entry.component, "engine");
-      assert.equal(entry.message, "audit test entry");
-    });
-
-    test("_resetLogs does not clear the audit base path", () => {
-      setLogBasePath(dir);
-      _resetLogs();
-      logError("engine", "post-reset entry");
-
-      const auditPath = join(dir, ".gsd", "audit-log.jsonl");
-      assert.ok(existsSync(auditPath), "audit-log.jsonl should exist after _resetLogs");
-      const content = readFileSync(auditPath, "utf-8");
-      const entry = JSON.parse(content.trim());
-      assert.equal(entry.message, "post-reset entry");
-    });
-  });
-
   describe("new log components (db, dispatch)", () => {
     test("logError with 'db' component stores correct component", () => {
       logError("db", "failed to copy DB to worktree", { error: "ENOENT" });

package/src/resources/extensions/gsd/tests/worktree-db-respawn-truncation.test.ts

@@ -100,8 +100,87 @@ describe('worktree-db-respawn-truncation (#2815)', async () => {
     }
   }
 
-  // ─── 3. Milestone artifacts still synced when DB is preserved ────────
-  console.log('\n=== 3. milestone artifacts still synced even when DB preserved ===');
+  // ─── 3. WAL/SHM sidecar files cleaned up when empty DB is deleted (#2478) ──
+  console.log('\n=== 3. orphaned WAL/SHM cleaned up alongside empty gsd.db (#2478) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Create an empty (0-byte) gsd.db plus orphaned WAL and SHM files —
+      // this is the exact state that causes Node 24 node:sqlite CPU spin (#2478).
+      const wtGsd = join(wtBase, '.gsd');
+      writeFileSync(join(wtGsd, 'gsd.db'), '');
+      writeFileSync(join(wtGsd, 'gsd.db-wal'), Buffer.alloc(605672, 0xAA));
+      writeFileSync(join(wtGsd, 'gsd.db-shm'), Buffer.alloc(32768, 0xBB));
+
+      assert.ok(existsSync(join(wtGsd, 'gsd.db')), 'gsd.db exists before sync');
+      assert.ok(existsSync(join(wtGsd, 'gsd.db-wal')), 'gsd.db-wal exists before sync');
+      assert.ok(existsSync(join(wtGsd, 'gsd.db-shm')), 'gsd.db-shm exists before sync');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      assert.ok(
+        !existsSync(join(wtGsd, 'gsd.db')),
+        '#2478: empty gsd.db must be deleted',
+      );
+      assert.ok(
+        !existsSync(join(wtGsd, 'gsd.db-wal')),
+        '#2478: orphaned gsd.db-wal must be deleted alongside gsd.db',
+      );
+      assert.ok(
+        !existsSync(join(wtGsd, 'gsd.db-shm')),
+        '#2478: orphaned gsd.db-shm must be deleted alongside gsd.db',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 4. Orphaned WAL/SHM cleaned up even when gsd.db already missing (#2478) ──
+  console.log('\n=== 4. orphaned WAL/SHM cleaned up even without gsd.db (#2478) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      // Orphaned WAL/SHM with NO gsd.db at all — can happen from a previous
+      // partial cleanup. These must still be cleaned up.
+      const wtGsd = join(wtBase, '.gsd');
+      writeFileSync(join(wtGsd, 'gsd.db-wal'), Buffer.alloc(1024, 0xAA));
+      writeFileSync(join(wtGsd, 'gsd.db-shm'), Buffer.alloc(1024, 0xBB));
+
+      assert.ok(!existsSync(join(wtGsd, 'gsd.db')), 'gsd.db does not exist');
+      assert.ok(existsSync(join(wtGsd, 'gsd.db-wal')), 'orphaned gsd.db-wal exists');
+      assert.ok(existsSync(join(wtGsd, 'gsd.db-shm')), 'orphaned gsd.db-shm exists');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      assert.ok(
+        !existsSync(join(wtGsd, 'gsd.db-wal')),
+        '#2478: orphaned gsd.db-wal must be deleted even without main db file',
+      );
+      assert.ok(
+        !existsSync(join(wtGsd, 'gsd.db-shm')),
+        '#2478: orphaned gsd.db-shm must be deleted even without main db file',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 5. Milestone artifacts still synced when DB is preserved ────────
+  console.log('\n=== 5. milestone artifacts still synced even when DB preserved ===');
   {
     const mainBase = createBase('main');
     const wtBase = createBase('wt');

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -292,13 +292,11 @@ export async function handleCompleteSlice(
     // Toggle roadmap checkbox via renderer module
     const roadmapToggled = await renderRoadmapCheckboxes(basePath, params.milestoneId);
     if (!roadmapToggled) {
-      process.stderr.write(
-        `gsd-db: complete_slice — could not find roadmap for ${params.milestoneId}, skipping checkbox toggle\n`,
-      );
+      logWarning("tool", `complete_slice — could not find roadmap for ${params.milestoneId}, skipping checkbox toggle`);
     }
   } catch (renderErr) {
     // Disk render failed — roll back DB status so state stays consistent
-    logWarning("tool", `complete_slice — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
+    logWarning("tool", `complete_slice — disk render failed for ${params.milestoneId}/${params.sliceId}, rolling back DB status`, { error: (renderErr as Error).message });
     updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
     invalidateStateCache();
     return { error: `disk render failed: ${(renderErr as Error).message}` };
@@ -325,7 +323,7 @@ export async function handleCompleteSlice(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    logWarning("tool", `complete-slice post-mutation hook warning: ${(hookErr as Error).message}`);
+    logWarning("tool", `complete-slice post-mutation hook failed for ${params.milestoneId}/${params.sliceId}`, { error: (hookErr as Error).message });
   }
 
   return {

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -174,17 +174,22 @@ export function summarizeLogs(): string | null {
 
 /**
  * Format entries for display (used by auto-loop post-unit notification).
- * Note: context fields are not included in the formatted output.
+ * Includes key context fields (file paths, commands) when present.
  */
 export function formatForNotification(entries: readonly LogEntry[]): string {
   if (entries.length === 0) return "";
-  if (entries.length === 1) {
-    const e = entries[0];
-    return `[${e.component}] ${e.message}`;
-  }
-  return entries
-    .map((e) => `[${e.component}] ${e.message}`)
-    .join("\n");
+  return entries.map((e) => {
+    let line = `[${e.component}] ${e.message}`;
+    if (e.context) {
+      const ctxParts = Object.entries(e.context)
+        .filter(([k]) => k !== "error") // error is redundant with message
+        .map(([k, v]) => v.includes(",") ? `${k}: "${v}"` : `${k}: ${v}`);
+      if (ctxParts.length > 0) {
+        line += ` (${ctxParts.join(", ")})`;
+      }
+    }
+    return line;
+  }).join("\n");
 }
 
 /**

package/src/resources/extensions/gsd/workflow-reconcile.ts

@@ -348,7 +348,9 @@ function _reconcileWorktreeLogsInner(
   if (conflicts.length > 0) {
     // D-04: atomic all-or-nothing — block entire merge
     writeConflictsFile(mainBasePath, conflicts, worktreeBasePath);
-    logError("reconcile", `${conflicts.length} conflict(s) detected`, { count: String(conflicts.length), path: join(mainBasePath, ".gsd", "CONFLICTS.md") });
+    const conflictSummary = conflicts.slice(0, 3).map(c => `${c.entityType}:${c.entityId}`).join(", ");
+    const truncated = conflicts.length > 3 ? `... and ${conflicts.length - 3} more` : "";
+    logError("reconcile", `${conflicts.length} conflict(s) detected on ${conflictSummary}${truncated}. Details: .gsd/CONFLICTS.md`, { count: String(conflicts.length), path: join(mainBasePath, ".gsd", "CONFLICTS.md") });
     return { autoMerged: 0, conflicts };
   }
 

package/src/resources/extensions/shared/tests/ask-user-freetext.test.ts

@@ -10,12 +10,13 @@
  * triggers a follow-up free-text input prompt via ctx.ui.input().
  */
 
-import { describe, it } from "node:test";
+import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
 
 // The ask-user-questions extension registers a tool via pi.registerTool().
 // We capture that registration and call execute() directly with a mock context.
 import AskUserQuestions from "../../ask-user-questions.js";
+import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
 
 interface CapturedTool {
 	name: string;
@@ -73,6 +74,10 @@ function makeMockCtx(opts: {
 }
 
 describe("ask-user-questions RPC fallback free-text", () => {
+	beforeEach(() => {
+		resetAskUserQuestionsCache();
+	});
+
 	it("prompts for free-text input when user selects 'None of the above'", async () => {
 		const tool = captureTool();
 		const { ctx, selectCalls, inputCalls } = makeMockCtx({