gsd-pi 2.62.0 → 2.62.1

package/dist/resources/extensions/ask-user-questions.js

@@ -33,6 +33,31 @@ const AskUserQuestionsParams = Type.Object({
         description: "Questions to show the user. Prefer 1 and do not exceed 3.",
     }),
 });
+// ─── Per-turn deduplication ──────────────────────────────────────────────────
+// Prevents duplicate question dispatches (especially to remote channels like
+// Discord) when the LLM calls ask_user_questions multiple times with the same
+// questions in a single turn. Keyed by full canonicalized payload (id, header,
+// question, options, allowMultiple) — not just IDs — so that calls with the
+// same IDs but different text/options are treated as distinct.
+import { createHash } from "node:crypto";
+const turnCache = new Map();
+/** @internal Exported for testing only. */
+export function questionSignature(questions) {
+    const canonical = questions
+        .map((q) => ({
+        id: q.id,
+        header: q.header,
+        question: q.question,
+        options: (q.options || []).map((o) => ({ label: o.label, description: o.description })),
+        allowMultiple: !!q.allowMultiple,
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
+}
+/** Reset the dedup cache. Called on session boundaries. */
+export function resetAskUserQuestionsCache() {
+    turnCache.clear();
+}
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
 function errorResult(message, questions = []) {
@@ -73,6 +98,15 @@ export default function AskUserQuestions(pi) {
         ],
         parameters: AskUserQuestionsParams,
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+            // ── Per-turn dedup: return cached result for identical question sets ──
+            const sig = questionSignature(params.questions);
+            const cached = turnCache.get(sig);
+            if (cached) {
+                return {
+                    content: [{ type: "text", text: cached.content[0].text + "\n(Returned cached answer — this question set was already asked this turn.)" }],
+                    details: cached.details,
+                };
+            }
             // Validation
             if (params.questions.length === 0 || params.questions.length > 3) {
                 return errorResult("Error: questions must contain 1-3 items", params.questions);
@@ -87,8 +121,14 @@ export default function AskUserQuestions(pi) {
             // this is a no-op when the user has not set up Slack/Discord/Telegram.
             const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
             const remoteResult = await tryRemoteQuestions(params.questions, signal);
-            if (remoteResult)
+            if (remoteResult) {
+                // Cache successful remote results to prevent duplicate Discord dispatches
+                const remoteDetails = remoteResult.details;
+                if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
+                    turnCache.set(sig, remoteResult);
+                }
                 return { ...remoteResult, details: remoteResult.details };
+            }
             if (!ctx.hasUI) {
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }
@@ -131,7 +171,7 @@ export default function AskUserQuestions(pi) {
                         { selected: a.answers.length === 1 ? a.answers[0] : a.answers, notes: "" },
                     ])),
                 };
-                return {
+                const fallbackResult = {
                     content: [{ type: "text", text: JSON.stringify({ answers }) }],
                     details: {
                         questions: params.questions,
@@ -139,6 +179,8 @@ export default function AskUserQuestions(pi) {
                         cancelled: false,
                     },
                 };
+                turnCache.set(sig, fallbackResult);
+                return fallbackResult;
             }
             // Check if cancelled (empty answers = user exited)
             const hasAnswers = Object.keys(result.answers).length > 0;
@@ -148,10 +190,12 @@ export default function AskUserQuestions(pi) {
                     details: { questions: params.questions, response: null, cancelled: true },
                 };
             }
-            return {
+            const successResult = {
                 content: [{ type: "text", text: formatForLLM(result) }],
                 details: { questions: params.questions, response: result, cancelled: false },
             };
+            turnCache.set(sig, successResult);
+            return successResult;
         },
         // ─── Rendering ────────────────────────────────────────────────────────
         renderCall(args, theme) {

package/dist/resources/extensions/gsd/auto-start.js

@@ -39,6 +39,7 @@ import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
+import { resolveDefaultSessionModel } from "./preferences-models.js";
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
  * through secrets collection, returning when ready for the first
@@ -89,12 +90,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     }
     // Capture the user's session model before guided-flow dispatch can apply a
     // phase-specific planning model for a discuss turn (#2829).
-    const startModelSnapshot = ctx.model
-        ? {
-            provider: ctx.model.provider,
-            id: ctx.model.id,
-        }
-        : null;
+    //
+    // GSD PREFERENCES.md takes priority over the session model from settings.json
+    // (#3517).  The session model (ctx.model) comes from findInitialModel() which
+    // reads defaultProvider/defaultModel from ~/.gsd/agent/settings.json.  When
+    // the user has explicit model preferences in PREFERENCES.md, those should win.
+    const preferredModel = resolveDefaultSessionModel(ctx.model?.provider);
+    const startModelSnapshot = preferredModel
+        ?? (ctx.model
+            ? { provider: ctx.model.provider, id: ctx.model.id }
+            : null);
     try {
         // Validate GSD_PROJECT_ID early so the user gets immediate feedback
         const customProjectId = process.env.GSD_PROJECT_ID;

package/dist/resources/extensions/gsd/auto-timers.js

@@ -92,6 +92,10 @@ export function startUnitSupervision(sctx) {
             phase: "wrapup-warning-sent",
             wrapupWarningSent: true,
         });
+        // Only trigger a new turn if no tools are currently in flight.
+        // Triggering during active tool calls causes tool results to be skipped
+        // with "Skipped due to queued user message", leading to provider errors (#3512).
+        const softTrigger = getInFlightToolCount() === 0;
         pi.sendMessage({
             customType: "gsd-auto-wrapup",
             display: s.verbose,
@@ -104,7 +108,7 @@ export function startUnitSupervision(sctx) {
                 "3. mark task or slice state on disk correctly",
                 "4. leave precise resume notes if anything remains unfinished",
             ].join("\n"),
-        }, { triggerTurn: true });
+        }, { triggerTurn: softTrigger });
     }, softTimeoutMs);
     // ── 2. Idle watchdog ──
     s.idleWatchdogHandle = setInterval(async () => {
@@ -245,6 +249,8 @@ export function startUnitSupervision(sctx) {
         if (s.verbose) {
             ctx.ui.notify(`Context at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%) — sending wrap-up signal.`, "info");
         }
+        // Only trigger a new turn if no tools are currently in flight (#3512).
+        const contextTrigger = getInFlightToolCount() === 0;
         pi.sendMessage({
             customType: "gsd-auto-wrapup",
             display: s.verbose,
@@ -258,7 +264,7 @@ export function startUnitSupervision(sctx) {
                 "4. Leave precise resume notes if anything remains unfinished",
                 "Do NOT start new sub-tasks or investigations.",
             ].join("\n"),
-        }, { triggerTurn: true });
+        }, { triggerTurn: contextTrigger });
         if (s.continueHereHandle) {
             clearInterval(s.continueHereHandle);
             s.continueHereHandle = null;

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -234,10 +234,29 @@ export function syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneI
     // openDatabase re-creates it, causing "no such table" failures (#2815).
     try {
         const wtDb = join(wtGsd, "gsd.db");
+        let deleteSidecars = false;
         if (existsSync(wtDb)) {
             const size = statSync(wtDb).size;
             if (size === 0) {
                 unlinkSync(wtDb);
+                deleteSidecars = true;
+            }
+        }
+        else {
+            // Main DB already missing — sidecars are orphaned from a previous
+            // partial cleanup and must still be removed.
+            deleteSidecars = true;
+        }
+        // Always clean up WAL/SHM sidecar files when the main DB was deleted
+        // or is already missing. Orphaned WAL/SHM files cause SQLite WAL
+        // recovery on next open, which triggers a CPU spin on Node 24's
+        // node:sqlite DatabaseSync implementation (#2478).
+        if (deleteSidecars) {
+            for (const suffix of ["-wal", "-shm"]) {
+                const f = wtDb + suffix;
+                if (existsSync(f)) {
+                    unlinkSync(f);
+                }
             }
         }
     }

package/dist/resources/extensions/gsd/auto.js

@@ -377,6 +377,18 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-locks", { error: e instanceof Error ? e.message : String(e) });
         }
+        // ── Step 1b: Flush queued follow-up messages (#3512) ──
+        // Late async notifications (async_job_result, gsd-auto-wrapup) can trigger
+        // extra LLM turns after stop. Flush them the same way run-unit.ts does.
+        try {
+            const cmdCtxAny = s.cmdCtx;
+            if (typeof cmdCtxAny?.clearQueue === "function") {
+                cmdCtxAny.clearQueue();
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-queue", { error: e instanceof Error ? e.message : String(e) });
+        }
         // ── Step 2: Skill state ──
         try {
             clearSkillSnapshot();
@@ -589,6 +601,18 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     if (!s.active)
         return;
     clearUnitTimeout();
+    // Flush queued follow-up messages (#3512).
+    // Late async notifications (async_job_result, gsd-auto-wrapup) can trigger
+    // extra LLM turns after pause. Flush them the same way run-unit.ts does.
+    try {
+        const cmdCtxAny = s.cmdCtx;
+        if (typeof cmdCtxAny?.clearQueue === "function") {
+            cmdCtxAny.clearQueue();
+        }
+    }
+    catch (e) {
+        debugLog("pause-cleanup-queue", { error: e instanceof Error ? e.message : String(e) });
+    }
     // Unblock any pending unit promise so the auto-loop is not orphaned.
     // Pass errorContext so runUnitPhase can distinguish user-initiated pause
     // from provider-error pause and avoid hard-stopping (#2762).

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -14,6 +14,7 @@ import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markTool
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
+import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
@@ -25,6 +26,7 @@ export function registerHooks(pi) {
     pi.on("session_start", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
+        resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
         // Apply show_token_cost preference (#1515)
         try {
@@ -60,6 +62,7 @@ export function registerHooks(pi) {
     pi.on("session_switch", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
+        resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
         loadToolApiKeys();
@@ -69,6 +72,7 @@ export function registerHooks(pi) {
     });
     pi.on("agent_end", async (event, ctx) => {
         resetToolCallLoopGuard();
+        resetAskUserQuestionsCache();
         await handleAgentEnd(pi, event, ctx);
     });
     // Squash-merge quick-task branch back to the original branch after the

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -13,8 +13,12 @@
  */
 import { createHash } from "node:crypto";
 const MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
+/** Interactive/user-facing tools where even 1 duplicate is confusing. */
+const STRICT_LOOP_TOOLS = new Set(["ask_user_questions"]);
+const MAX_CONSECUTIVE_STRICT = 1;
 let consecutiveCount = 0;
 let lastSignature = "";
+let lastToolName = "";
 let enabled = true;
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName, args) {
@@ -45,8 +49,12 @@ export function checkToolCallLoop(toolName, args) {
     else {
         consecutiveCount = 1;
         lastSignature = sig;
+        lastToolName = toolName;
     }
-    if (consecutiveCount > MAX_CONSECUTIVE_IDENTICAL_CALLS) {
+    const threshold = STRICT_LOOP_TOOLS.has(toolName)
+        ? MAX_CONSECUTIVE_STRICT
+        : MAX_CONSECUTIVE_IDENTICAL_CALLS;
+    if (consecutiveCount > threshold) {
         return {
             block: true,
             reason: `Tool loop detected: ${toolName} called ${consecutiveCount} times ` +
@@ -61,6 +69,7 @@ export function checkToolCallLoop(toolName, args) {
 export function resetToolCallLoopGuard() {
     consecutiveCount = 0;
     lastSignature = "";
+    lastToolName = "";
     enabled = true;
 }
 /** Disable the guard (e.g. during shutdown). */
@@ -68,6 +77,7 @@ export function disableToolCallLoopGuard() {
     enabled = false;
     consecutiveCount = 0;
     lastSignature = "";
+    lastToolName = "";
 }
 /** Get current consecutive count for diagnostics. */
 export function getToolCallLoopCount() {

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -11,7 +11,8 @@ import { gsdRoot } from "./paths.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { appendOverride, appendKnowledge } from "./files.js";
 import { formatDoctorIssuesForPrompt, formatDoctorReport, formatDoctorReportJson, runGSDDoctor, 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";
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
@@ -172,7 +173,17 @@ export async function handleSteer(change, ctx, pi) {
     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({
             customType: "gsd-hard-steer",
@@ -181,14 +192,14 @@ export async function handleSteer(change, ctx, pi) {
                 "",
                 `**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({
@@ -198,13 +209,13 @@ export async function handleSteer(change, ctx, pi) {
                 "",
                 `**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");
     }
 }
 export async function handleKnowledge(args, ctx) {

package/dist/resources/extensions/gsd/db-writer.js

@@ -11,7 +11,7 @@ import { resolve } from 'node:path';
 import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
-import { GSDError, GSD_IO_ERROR } from './errors.js';
+import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
@@ -234,27 +234,44 @@ export async function nextRequirementId() {
 /**
  * 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(fields, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        const id = await nextRequirementId();
-        const 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'] : null;
+            const nextId = (maxNum == null || isNaN(maxNum))
+                ? 'R001'
+                : `R${String(maxNum + 1).padStart(3, '0')}`;
+            const 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();
         let allRequirements = [];
@@ -300,22 +317,41 @@ export async function saveRequirementToDb(fields, basePath) {
 /**
  * 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(fields, basePath) {
     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'] : 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)
         const adapter = db._getAdapter();

package/dist/resources/extensions/gsd/preferences-models.js

@@ -87,6 +87,80 @@ export function resolveModelWithFallbacksForUnit(unitType) {
         fallbacks: phaseConfig.fallbacks ?? [],
     };
 }
+/**
+ * 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) {
+    const prefs = loadEffectiveGSDPreferences();
+    if (!prefs?.preferences.models)
+        return undefined;
+    const m = prefs.preferences.models;
+    // Priority: execution → planning → first configured value
+    const candidates = [
+        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;
+        let id;
+        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/dist/resources/extensions/gsd/preferences-skills.js

@@ -12,13 +12,18 @@ import { validatePreferences } from "./preferences-validation.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 /**
  * 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) {
     const dirs = [
         { 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/dist/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/dist/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/dist/resources/extensions/gsd/skill-catalog.js

@@ -887,12 +887,14 @@ export async function installPacksBatched(packs, onProgress) {
 }
 /**
  * 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) {
-    const skillsDir = join(homedir(), ".agents", "skills");
-    if (!existsSync(skillsDir))
-        return false;
-    return pack.skills.every((name) => existsSync(join(skillsDir, name, "SKILL.md")));
+    const skillsDirs = [
+        join(homedir(), ".agents", "skills"),
+        join(homedir(), ".claude", "skills"),
+    ];
+    return pack.skills.every((name) => skillsDirs.some((dir) => existsSync(join(dir, name, "SKILL.md"))));
 }
 // ─── Init Wizard Integration ──────────────────────────────────────────────────
 /**