gsd-pi 2.62.0 → 2.62.1-dev.1ae2b74

package/src/resources/extensions/gsd/commands-handlers.ts

@@ -20,7 +20,8 @@ import {
   selectDoctorScope,
   filterDoctorIssues,
 } from "./doctor.js";
-import { isAutoActive } from "./auto.js";
+import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
+import { getAutoWorktreePath } from "./auto-worktree.js";
 import { projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
 
@@ -222,7 +223,19 @@ export async function handleSteer(change: string, ctx: ExtensionCommandContext,
   const sid = state.activeSlice?.id ?? "none";
   const tid = state.activeTask?.id ?? "none";
   const appliedAt = `${mid}/${sid}/${tid}`;
-  await appendOverride(basePath, change, appliedAt);
+
+  // Resolve the correct target path: only route to a worktree when auto-mode
+  // is actively running there (in-process or remote). A worktree directory may
+  // exist from a previous session without being the active runtime path —
+  // writing there without a live session would silently drop the override.
+  const autoRunning = isAutoActive() || checkRemoteAutoSession(basePath).running;
+  const wtPath = autoRunning && mid !== "none"
+    ? getAutoWorktreePath(basePath, mid)
+    : null;
+  const targetPath = wtPath ?? basePath;
+  await appendOverride(targetPath, change, appliedAt);
+
+  const overrideLoc = wtPath ? "worktree `.gsd/OVERRIDES.md`" : "`.gsd/OVERRIDES.md`";
 
   if (isAutoActive()) {
     pi.sendMessage({
@@ -232,14 +245,14 @@ export async function handleSteer(change: string, ctx: ExtensionCommandContext,
         "",
         `**Override:** ${change}`,
         "",
-        "This override has been saved to `.gsd/OVERRIDES.md` and will be injected into all future task prompts.",
+        `This override has been saved to ${overrideLoc} and will be injected into all future task prompts.`,
         "A document rewrite unit will run before the next task to propagate this change across all active plan documents.",
         "",
         "If you are mid-task, finish your current work respecting this override. The next dispatched unit will be a document rewrite.",
       ].join("\n"),
       display: false,
     }, { triggerTurn: true });
-    ctx.ui.notify(`Override registered: "${change}". Will be applied before next task dispatch.`, "info");
+    ctx.ui.notify(`Override registered (${overrideLoc}): "${change}". Will be applied before next task dispatch.`, "info");
   } else {
     pi.sendMessage({
       customType: "gsd-hard-steer",
@@ -248,13 +261,13 @@ export async function handleSteer(change: string, ctx: ExtensionCommandContext,
         "",
         `**Override:** ${change}`,
         "",
-        "This override has been saved to `.gsd/OVERRIDES.md`.",
-        "Before continuing, read `.gsd/OVERRIDES.md` and update the current plan documents to reflect this change.",
+        `This override has been saved to ${overrideLoc}.`,
+        `Before continuing, read ${overrideLoc} and update the current plan documents to reflect this change.`,
         "Focus on: active slice plan, incomplete task plans, and DECISIONS.md.",
       ].join("\n"),
       display: false,
     }, { triggerTurn: true });
-    ctx.ui.notify(`Override registered: "${change}". Update plan documents to reflect this change.`, "info");
+    ctx.ui.notify(`Override registered (${overrideLoc}): "${change}". Update plan documents to reflect this change.`, "info");
   }
 }
 

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

@@ -272,6 +272,10 @@ export interface SaveRequirementFields {
 /**
  * Save a new requirement to DB and regenerate REQUIREMENTS.md.
  * Auto-assigns the next ID via nextRequirementId().
+ *
+ * The ID computation and insert are wrapped in a single transaction
+ * to prevent parallel race conditions (same pattern as saveDecisionToDb).
+ *
  * Returns the assigned ID.
  */
 export async function saveRequirementToDb(
@@ -281,24 +285,37 @@ export async function saveRequirementToDb(
   try {
     const db = await import('./gsd-db.js');
 
-    const id = await nextRequirementId();
-
-    const requirement: Requirement = {
-      id,
-      class: fields.class,
-      status: fields.status ?? 'active',
-      description: fields.description,
-      why: fields.why,
-      source: fields.source,
-      primary_owner: fields.primary_owner ?? '',
-      supporting_slices: fields.supporting_slices ?? '',
-      validation: fields.validation ?? '',
-      notes: fields.notes ?? '',
-      full_content: '',
-      superseded_by: null,
-    };
-
-    db.upsertRequirement(requirement);
+    // Atomic ID assignment + insert inside a transaction.
+    const id = db.transaction(() => {
+      const adapter = db._getAdapter();
+      if (!adapter) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+
+      const row = adapter
+        .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM requirements')
+        .get();
+      const maxNum = row ? (row['max_num'] as number | null) : null;
+      const nextId = (maxNum == null || isNaN(maxNum))
+        ? 'R001'
+        : `R${String(maxNum + 1).padStart(3, '0')}`;
+
+      const requirement: Requirement = {
+        id: nextId,
+        class: fields.class,
+        status: fields.status ?? 'active',
+        description: fields.description,
+        why: fields.why,
+        source: fields.source,
+        primary_owner: fields.primary_owner ?? '',
+        supporting_slices: fields.supporting_slices ?? '',
+        validation: fields.validation ?? '',
+        notes: fields.notes ?? '',
+        full_content: '',
+        superseded_by: null,
+      };
+
+      db.upsertRequirement(requirement);
+      return nextId;
+    });
 
     // Fetch all requirements for full file regeneration
     const adapter = db._getAdapter();
@@ -358,6 +375,11 @@ export interface SaveDecisionFields {
 /**
  * Save a new decision to DB and regenerate DECISIONS.md.
  * Auto-assigns the next ID via nextDecisionId().
+ *
+ * The ID computation (SELECT MAX) and insert are wrapped in a single
+ * transaction to prevent parallel tool calls from computing the same ID
+ * and silently overwriting each other (#3326, #3339, #3459).
+ *
  * Returns the assigned ID.
  */
 export async function saveDecisionToDb(
@@ -367,18 +389,33 @@ export async function saveDecisionToDb(
   try {
     const db = await import('./gsd-db.js');
 
-    const id = await nextDecisionId();
-
-    db.upsertDecision({
-      id,
-      when_context: fields.when_context ?? '',
-      scope: fields.scope,
-      decision: fields.decision,
-      choice: fields.choice,
-      rationale: fields.rationale,
-      revisable: fields.revisable ?? 'Yes',
-      made_by: fields.made_by ?? 'agent',
-      superseded_by: null,
+    // Atomic ID assignment + insert inside a transaction to prevent
+    // parallel calls from racing on the same MAX(id) value.
+    const id = db.transaction(() => {
+      const adapter = db._getAdapter();
+      if (!adapter) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+
+      const row = adapter
+        .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
+        .get();
+      const maxNum = row ? (row['max_num'] as number | null) : null;
+      const nextId = (maxNum == null || isNaN(maxNum))
+        ? 'D001'
+        : `D${String(maxNum + 1).padStart(3, '0')}`;
+
+      db.upsertDecision({
+        id: nextId,
+        when_context: fields.when_context ?? '',
+        scope: fields.scope,
+        decision: fields.decision,
+        choice: fields.choice,
+        rationale: fields.rationale,
+        revisable: fields.revisable ?? 'Yes',
+        made_by: fields.made_by ?? 'agent',
+        superseded_by: null,
+      });
+
+      return nextId;
     });
 
     // Fetch all decisions (including superseded for the full register)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -259,6 +259,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       _telemetry.markdownDeriveCount++;
     }
   } else {
+    logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
     result = await _deriveStateImpl(basePath);
     _telemetry.markdownDeriveCount++;
   }

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

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

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

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