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

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/steer-worktree-path.test.ts

@@ -0,0 +1,108 @@
+// GSD Extension - Steer Worktree Path Resolution Test
+// Regression test for #3476: /gsd steer must write overrides to the worktree .gsd/,
+// not the project root .gsd/, when a worktree is active.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { appendOverride, loadActiveOverrides } from "../files.ts";
+import { getAutoWorktreePath } from "../auto-worktree.ts";
+
+describe("steer worktree path resolution (#3476)", () => {
+  let projectRoot: string;
+  let worktreePath: string;
+
+  beforeEach(() => {
+    projectRoot = mkdtempSync(join(tmpdir(), "gsd-steer-wt-"));
+    mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+    // Simulate a worktree with its own .gsd directory
+    worktreePath = join(projectRoot, ".gsd", "worktrees", "M001");
+    mkdirSync(join(worktreePath, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
+
+  test("appendOverride writes to worktree .gsd/ when worktree path is used", async () => {
+    await appendOverride(worktreePath, "Use Postgres instead of SQLite", "M001/S01/T01");
+
+    // Override should be in the worktree .gsd/
+    const wtOverrides = join(worktreePath, ".gsd", "OVERRIDES.md");
+    assert.ok(existsSync(wtOverrides), "override file exists in worktree .gsd/");
+
+    const content = readFileSync(wtOverrides, "utf-8");
+    assert.ok(content.includes("Use Postgres instead of SQLite"), "override content is correct");
+
+    // Override should NOT be in the project root .gsd/
+    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
+    assert.ok(!existsSync(rootOverrides), "no override file in project root .gsd/");
+  });
+
+  test("loadActiveOverrides reads from worktree .gsd/ when worktree path is used", async () => {
+    await appendOverride(worktreePath, "Switch to JWT auth", "M001/S02/T01");
+
+    // Loading from worktree should find the override
+    const wtOverrides = await loadActiveOverrides(worktreePath);
+    assert.equal(wtOverrides.length, 1, "one active override in worktree");
+    assert.equal(wtOverrides[0].change, "Switch to JWT auth");
+
+    // Loading from project root should find nothing
+    const rootOverrides = await loadActiveOverrides(projectRoot);
+    assert.equal(rootOverrides.length, 0, "no overrides in project root");
+  });
+
+  test("appendOverride falls back to project root when no worktree exists", async () => {
+    await appendOverride(projectRoot, "Use Redis cache", "M001/S01/T01");
+
+    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
+    assert.ok(existsSync(rootOverrides), "override file exists in project root .gsd/");
+
+    const content = readFileSync(rootOverrides, "utf-8");
+    assert.ok(content.includes("Use Redis cache"), "override content is correct");
+  });
+
+  test("getAutoWorktreePath returns null for worktree without valid .git file", () => {
+    // The worktree directory exists but has no .git file — this is an inactive/
+    // leftover worktree. getAutoWorktreePath must return null so handleSteer
+    // does not route overrides to a dead worktree.
+    const result = getAutoWorktreePath(projectRoot, "M001");
+    assert.equal(result, null, "returns null for worktree without .git file");
+  });
+
+  test("override routing: inactive worktree directory should not receive overrides", async () => {
+    // Simulate the handleSteer path-resolution logic:
+    // When no auto-mode is running, even if a worktree dir exists,
+    // overrides must go to the project root.
+    const autoRunning = false; // no live session
+    const wtPath = autoRunning ? getAutoWorktreePath(projectRoot, "M001") : null;
+    const targetPath = wtPath ?? projectRoot;
+
+    await appendOverride(targetPath, "Should go to project root", "M001/S01/T01");
+
+    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
+    const wtOverrides = join(worktreePath, ".gsd", "OVERRIDES.md");
+
+    assert.ok(existsSync(rootOverrides), "override written to project root");
+    assert.ok(!existsSync(wtOverrides), "override NOT written to inactive worktree");
+  });
+
+  test("override routing: active worktree with valid .git should receive overrides", async () => {
+    // Simulate the handleSteer path-resolution logic with active auto-mode.
+    // getAutoWorktreePath requires a valid .git file, so even with autoRunning=true,
+    // it returns null for our test worktree (no real .git). This confirms the
+    // double-gate: both autoRunning AND valid worktree must be true.
+    const autoRunning = true;
+    const wtPath = autoRunning ? getAutoWorktreePath(projectRoot, "M001") : null;
+    const targetPath = wtPath ?? projectRoot;
+
+    // Without a valid .git file, falls back to project root
+    await appendOverride(targetPath, "Falls back without .git", "M001/S01/T01");
+
+    const rootOverrides = join(projectRoot, ".gsd", "OVERRIDES.md");
+    assert.ok(existsSync(rootOverrides), "override written to project root (no valid .git in worktree)");
+  });
+});

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/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/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({