gsd-pi 2.51.0 → 2.52.0-dev.655ad8a

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,12 +1,38 @@
 import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
-import { getNextFallbackModel, isTransientNetworkError, resolveModelWithFallbacksForUnit } from "../preferences.js";
-import { classifyProviderError, pauseAutoForProviderError } from "../provider-error-pause.js";
+import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
+import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
+import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
-const networkRetryCounters = new Map();
+import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
+const retryState = createRetryState();
+const MAX_NETWORK_RETRIES = 2;
 const MAX_TRANSIENT_AUTO_RESUMES = 3;
-let consecutiveTransientErrors = 0;
+async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
+    retryState.consecutiveTransientCount += 1;
+    const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
+    const retryAfterMs = baseRetryAfterMs * 2 ** Math.max(0, retryState.consecutiveTransientCount - 1);
+    const allowAutoResume = retryState.consecutiveTransientCount <= MAX_TRANSIENT_AUTO_RESUMES;
+    if (!allowAutoResume) {
+        ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
+    }
+    await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi, {
+        message: `Provider error: ${errorDetail}`,
+        category: "provider",
+        isTransient: allowAutoResume,
+        retryAfterMs,
+    }), {
+        isRateLimit,
+        isTransient: allowAutoResume,
+        retryAfterMs,
+        resume: allowAutoResume
+            ? () => {
+                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
+            }
+            : undefined,
+    });
+}
 export async function handleAgentEnd(pi, event, ctx) {
     if (checkAutoStartAfterDiscuss()) {
         clearDiscussionFlowState();
@@ -24,93 +50,96 @@ export async function handleAgentEnd(pi, event, ctx) {
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
         const errorDetail = "errorMessage" in lastMsg && lastMsg.errorMessage ? `: ${lastMsg.errorMessage}` : "";
         const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
-        if (isTransientNetworkError(errorMsg)) {
+        const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
+        // ── 1. Classify ──────────────────────────────────────────────────────
+        const cls = classifyError(errorMsg, explicitRetryAfterMs);
+        // ── 2. Decide & Act ──────────────────────────────────────────────────
+        // --- Network errors: same-model retry with backoff ---
+        if (cls.kind === "network") {
             const currentModelId = ctx.model?.id ?? "unknown";
-            const retryKey = `network-retry:${currentModelId}`;
-            const currentRetries = networkRetryCounters.get(retryKey) ?? 0;
-            const maxRetries = 2;
-            if (currentRetries < maxRetries) {
-                networkRetryCounters.set(retryKey, currentRetries + 1);
-                const attempt = currentRetries + 1;
-                const delayMs = attempt * 3000;
-                ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${maxRetries} in ${delayMs / 1000}s...`, "warning");
+            if (retryState.currentRetryModelId !== currentModelId) {
+                retryState.networkRetryCount = 0;
+                retryState.currentRetryModelId = currentModelId;
+            }
+            if (retryState.networkRetryCount < MAX_NETWORK_RETRIES) {
+                retryState.networkRetryCount += 1;
+                retryState.consecutiveTransientCount += 1;
+                const attempt = retryState.networkRetryCount;
+                const delayMs = attempt * cls.retryAfterMs;
+                ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${MAX_NETWORK_RETRIES} in ${delayMs / 1000}s...`, "warning");
                 setTimeout(() => {
                     pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — retrying after transient network error.", display: false }, { triggerTurn: true });
                 }, delayMs);
                 return;
             }
-            networkRetryCounters.delete(retryKey);
+            // Network retries exhausted — fall through to model fallback
+            retryState.networkRetryCount = 0;
+            retryState.currentRetryModelId = undefined;
             ctx.ui.notify(`Network retries exhausted for ${currentModelId}. Attempting model fallback.`, "warning");
         }
-        const dash = getAutoDashboardData();
-        if (dash.currentUnit) {
-            const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
-            if (modelConfig && modelConfig.fallbacks.length > 0) {
-                const availableModels = ctx.modelRegistry.getAvailable();
-                const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
-                if (nextModelId) {
-                    networkRetryCounters.clear();
-                    const slashIdx = nextModelId.indexOf("/");
-                    const modelToSet = slashIdx !== -1
-                        ? availableModels.find((m) => m.provider.toLowerCase() === nextModelId.substring(0, slashIdx).toLowerCase() && m.id.toLowerCase() === nextModelId.substring(slashIdx + 1).toLowerCase())
-                        : (availableModels.find((m) => m.id === nextModelId && m.provider === ctx.model?.provider) ?? availableModels.find((m) => m.id === nextModelId));
-                    if (modelToSet) {
-                        const ok = await pi.setModel(modelToSet, { persist: false });
-                        if (ok) {
-                            ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
-                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
-                            return;
+        // --- Transient errors: try model fallback first, then pause ---
+        // Rate limits are often per-model, so switching models can bypass them.
+        if (cls.kind === "rate-limit" || cls.kind === "network" || cls.kind === "server" || cls.kind === "connection" || cls.kind === "stream") {
+            // Try model fallback
+            const dash = getAutoDashboardData();
+            if (dash.currentUnit) {
+                const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+                if (modelConfig && modelConfig.fallbacks.length > 0) {
+                    const availableModels = ctx.modelRegistry.getAvailable();
+                    const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
+                    if (nextModelId) {
+                        retryState.networkRetryCount = 0;
+                        retryState.currentRetryModelId = undefined;
+                        const modelToSet = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
+                        if (modelToSet) {
+                            const ok = await pi.setModel(modelToSet, { persist: false });
+                            if (ok) {
+                                ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
+                                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                                return;
+                            }
                         }
                     }
                 }
             }
-        }
-        const sessionModel = getAutoModeStartModel();
-        if (sessionModel) {
-            if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
-                const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
-                if (startModel) {
-                    const ok = await pi.setModel(startModel, { persist: false });
-                    if (ok) {
-                        networkRetryCounters.clear();
-                        ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
-                        pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
-                        return;
+            // Try restoring session model
+            const sessionModel = getAutoModeStartModel();
+            if (sessionModel) {
+                if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
+                    const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
+                    if (startModel) {
+                        const ok = await pi.setModel(startModel, { persist: false });
+                        if (ok) {
+                            retryState.networkRetryCount = 0;
+                            retryState.currentRetryModelId = undefined;
+                            ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
+                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                            return;
+                        }
                     }
                 }
             }
         }
-        const classification = classifyProviderError(errorMsg);
-        const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
-        if (classification.isTransient) {
-            consecutiveTransientErrors += 1;
-        }
-        else {
-            consecutiveTransientErrors = 0;
+        // --- Transient fallback: pause with auto-resume ---
+        if (isTransient(cls)) {
+            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, cls.kind === "rate-limit");
+            return;
         }
-        const baseRetryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
-        const retryAfterMs = classification.isTransient
-            ? baseRetryAfterMs * 2 ** Math.max(0, consecutiveTransientErrors - 1)
-            : baseRetryAfterMs;
-        const allowAutoResume = classification.isTransient && consecutiveTransientErrors <= MAX_TRANSIENT_AUTO_RESUMES;
-        if (classification.isTransient && !allowAutoResume) {
-            ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
-        }
-        await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi), {
-            isRateLimit: classification.isRateLimit,
-            isTransient: allowAutoResume,
-            retryAfterMs,
-            resume: allowAutoResume
-                ? () => {
-                    pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
-                }
-                : undefined,
+        // --- Permanent / unknown: pause indefinitely ---
+        await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi, {
+            message: `Provider error: ${errorDetail}`,
+            category: "provider",
+            isTransient: false,
+        }), {
+            isRateLimit: false,
+            isTransient: false,
+            retryAfterMs: 0,
         });
         return;
     }
+    // ── Success path ─────────────────────────────────────────────────────────
     try {
-        consecutiveTransientErrors = 0;
-        networkRetryCounters.clear();
+        resetRetryState(retryState);
         resolveAgentEnd(event);
     }
     catch (err) {

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
+import { setLogBasePath } from "../workflow-logger.js";
 /**
  * Resolve the correct DB path for the current working directory.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -35,9 +36,14 @@ export async function ensureDbOpen() {
         const basePath = process.cwd();
         const dbPath = resolveProjectRootDbPath(basePath);
         const gsdDir = join(basePath, ".gsd");
+        // Derive the project root from the DB path (strip .gsd/gsd.db)
+        const projectRoot = join(dbPath, "..", "..");
         // Open existing DB file (may be at project root for worktrees)
         if (existsSync(dbPath)) {
-            return db.openDatabase(dbPath);
+            const opened = db.openDatabase(dbPath);
+            if (opened)
+                setLogBasePath(projectRoot);
+            return opened;
         }
         // No DB file — create + migrate from Markdown if .gsd/ has content
         if (existsSync(gsdDir)) {
@@ -47,6 +53,7 @@ export async function ensureDbOpen() {
             if (hasDecisions || hasRequirements || hasMilestones) {
                 const opened = db.openDatabase(dbPath);
                 if (opened) {
+                    setLogBasePath(projectRoot);
                     try {
                         const { migrateFromMarkdown } = await import("../md-importer.js");
                         migrateFromMarkdown(basePath);
@@ -58,7 +65,10 @@ export async function ensureDbOpen() {
                 return opened;
             }
             // .gsd/ exists but has no Markdown content (fresh project) — create empty DB
-            return db.openDatabase(dbPath);
+            const opened = db.openDatabase(dbPath);
+            if (opened)
+                setLogBasePath(projectRoot);
+            return opened;
         }
         return false;
     }

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

@@ -227,7 +227,7 @@ export function registerHooks(pi) {
     pi.on("tool_execution_start", async (event) => {
         if (!isAutoActive())
             return;
-        markToolStart(event.toolCallId);
+        markToolStart(event.toolCallId, event.toolName);
     });
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);

package/dist/resources/extensions/gsd/claude-import.js

@@ -79,16 +79,50 @@ function isMarketplacePath(pluginPath) {
 }
 /**
  * Detect which plugin roots are marketplaces and which are legacy flat paths.
+ *
+ * Claude Code stores marketplace sources under ~/.claude/plugins/marketplaces/.
+ * Each subdirectory (e.g. marketplaces/confluent/) is a marketplace repo that
+ * contains .claude-plugin/marketplace.json. The parent directory itself does not
+ * have a marketplace.json, so we scan one level deeper when the root isn't
+ * directly a marketplace.
  */
-function categorizePluginRoots(pluginRoots) {
+export function categorizePluginRoots(pluginRoots) {
     const marketplaces = [];
     const flat = [];
+    const seen = new Set();
     for (const root of pluginRoots) {
         if (isMarketplacePath(root)) {
-            marketplaces.push(root);
+            if (!seen.has(root)) {
+                marketplaces.push(root);
+                seen.add(root);
+            }
         }
         else {
-            flat.push(root);
+            // The root itself isn't a marketplace — check if it's a container of
+            // marketplaces (e.g. ~/.claude/plugins/marketplaces/ contains subdirs
+            // like confluent/, claude-hud/, each with their own marketplace.json).
+            let foundChild = false;
+            try {
+                const entries = readdirSync(root, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    if (SKIP_DIRS.has(entry.name))
+                        continue;
+                    const childPath = join(root, entry.name);
+                    if (isMarketplacePath(childPath) && !seen.has(childPath)) {
+                        marketplaces.push(childPath);
+                        seen.add(childPath);
+                        foundChild = true;
+                    }
+                }
+            }
+            catch {
+                // Can't read directory — fall through to flat
+            }
+            if (!foundChild) {
+                flat.push(root);
+            }
         }
     }
     return { marketplaces, flat };
@@ -145,20 +179,37 @@ export function discoverClaudePlugins(cwd) {
     const seen = new Set();
     for (const root of pluginRoots) {
         walkDirs(root, (dir) => {
+            // Recognize both npm-style plugins (package.json) and Claude Code plugins
+            // (.claude-plugin/plugin.json). Claude marketplace-installed plugins use
+            // the latter format exclusively.
             const pkgPath = join(dir, "package.json");
-            if (!existsSync(pkgPath))
+            const claudePluginPath = join(dir, ".claude-plugin", "plugin.json");
+            const hasPkg = existsSync(pkgPath);
+            const hasClaudePlugin = existsSync(claudePluginPath);
+            if (!hasPkg && !hasClaudePlugin)
                 return;
             const resolvedDir = resolve(dir);
             if (seen.has(resolvedDir))
                 return;
             seen.add(resolvedDir);
             let packageName;
-            try {
-                const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-                packageName = pkg.name;
+            if (hasPkg) {
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+                    packageName = pkg.name;
+                }
+                catch {
+                    packageName = undefined;
+                }
             }
-            catch {
-                packageName = undefined;
+            else if (hasClaudePlugin) {
+                try {
+                    const manifest = JSON.parse(readFileSync(claudePluginPath, "utf8"));
+                    packageName = manifest.name;
+                }
+                catch {
+                    packageName = undefined;
+                }
             }
             results.push({
                 type: "plugin",

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

@@ -4,6 +4,7 @@ import { enableDebug } from "../../debug-logger.js";
 import { isAutoActive, isAutoPaused, pauseAuto, startAuto, stopAuto, stopAutoRemote } from "../../auto.js";
 import { handleRate } from "../../commands-rate.js";
 import { guardRemoteSession, projectRoot } from "../context.js";
+import { findMilestoneIds } from "../../milestone-id-utils.js";
 /**
  * Parse --yolo flag and optional file path from the auto command string.
  * Supports: `/gsd auto --yolo path/to/file.md` or `/gsd auto -y path/to/file.md`
@@ -22,6 +23,40 @@ function parseYoloFlag(trimmed) {
     const rest = trimmed.replace(match[0], "").replace(/\s+/g, " ").trim();
     return { yoloSeedFile: filePath, rest };
 }
+/**
+ * Extract a milestone ID (e.g. M016 or M001-a3b4c5) from the command string.
+ * Returns the matched ID and the remaining string with the ID removed.
+ * The milestone ID pattern matches the format used by findMilestoneIds: M\d+ with
+ * an optional -[a-z0-9]{6} suffix for unique milestone IDs.
+ */
+export function parseMilestoneTarget(input) {
+    const match = input.match(/\b(M\d+(?:-[a-z0-9]{6})?)\b/);
+    if (!match)
+        return { milestoneId: null, rest: input };
+    const rest = input.replace(match[0], "").replace(/\s+/g, " ").trim();
+    return { milestoneId: match[1], rest };
+}
+/**
+ * Set GSD_MILESTONE_LOCK to target a specific milestone, then run `fn`.
+ * Clears the env var when `fn` resolves or rejects, so the lock does not
+ * leak into subsequent commands in the same process.
+ */
+async function withMilestoneLock(milestoneId, fn) {
+    const previous = process.env.GSD_MILESTONE_LOCK;
+    process.env.GSD_MILESTONE_LOCK = milestoneId;
+    try {
+        await fn();
+    }
+    finally {
+        // Restore previous value (undefined → delete, else restore).
+        if (previous === undefined) {
+            delete process.env.GSD_MILESTONE_LOCK;
+        }
+        else {
+            process.env.GSD_MILESTONE_LOCK = previous;
+        }
+    }
+}
 export async function handleAutoCommand(trimmed, ctx, pi) {
     if (trimmed === "next" || trimmed.startsWith("next ")) {
         if (trimmed.includes("--dry-run")) {
@@ -29,23 +64,46 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             await handleDryRun(ctx, projectRoot());
             return true;
         }
-        const verboseMode = trimmed.includes("--verbose");
-        const debugMode = trimmed.includes("--debug");
+        const { milestoneId, rest: afterMilestone } = parseMilestoneTarget(trimmed);
+        const verboseMode = afterMilestone.includes("--verbose");
+        const debugMode = afterMilestone.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
-        await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
+        // Validate the milestone target exists and is not already complete.
+        if (milestoneId) {
+            const allIds = findMilestoneIds(projectRoot());
+            if (!allIds.includes(milestoneId)) {
+                ctx.ui.notify(`Milestone ${milestoneId} does not exist. Available: ${allIds.join(", ") || "(none)"}`, "error");
+                return true;
+            }
+        }
+        if (milestoneId) {
+            await withMilestoneLock(milestoneId, () => startAuto(ctx, pi, projectRoot(), verboseMode, { step: true }));
+        }
+        else {
+            await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
+        }
         return true;
     }
     if (trimmed === "auto" || trimmed.startsWith("auto ")) {
-        const { yoloSeedFile, rest } = parseYoloFlag(trimmed);
-        const verboseMode = rest.includes("--verbose");
-        const debugMode = rest.includes("--debug");
+        const { yoloSeedFile, rest: afterYolo } = parseYoloFlag(trimmed);
+        const { milestoneId, rest: afterMilestone } = parseMilestoneTarget(afterYolo);
+        const verboseMode = afterMilestone.includes("--verbose");
+        const debugMode = afterMilestone.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
+        // Validate the milestone target exists and is not already complete.
+        if (milestoneId) {
+            const allIds = findMilestoneIds(projectRoot());
+            if (!allIds.includes(milestoneId)) {
+                ctx.ui.notify(`Milestone ${milestoneId} does not exist. Available: ${allIds.join(", ") || "(none)"}`, "error");
+                return true;
+            }
+        }
         if (yoloSeedFile) {
             const resolved = resolve(projectRoot(), yoloSeedFile);
             if (!existsSync(resolved)) {
@@ -63,6 +121,11 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             const { showHeadlessMilestoneCreation } = await import("../../guided-flow.js");
             await showHeadlessMilestoneCreation(ctx, pi, projectRoot(), seedContent);
         }
+        else if (milestoneId) {
+            // Target a specific milestone — use GSD_MILESTONE_LOCK so state
+            // derivation only sees this milestone (#2521).
+            await withMilestoneLock(milestoneId, () => startAuto(ctx, pi, projectRoot(), verboseMode));
+        }
         else {
             await startAuto(ctx, pi, projectRoot(), verboseMode);
         }

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

@@ -18,6 +18,11 @@ export const TOOL_KEYS = [
     { id: "jina", env: "JINA_API_KEY", label: "Jina Page Extract", hint: "jina.ai/api" },
     { id: "groq", env: "GROQ_API_KEY", label: "Groq Voice", hint: "console.groq.com" },
 ];
+function getStoredToolKey(auth, providerId) {
+    const creds = auth.getCredentialsForProvider(providerId);
+    const cred = creds.find((c) => c.type === "api_key" && c.key);
+    return cred?.type === "api_key" ? cred.key : undefined;
+}
 /**
  * Load tool API keys from auth.json into environment variables.
  * Called at session startup to ensure tools have access to their credentials.
@@ -29,9 +34,9 @@ export function loadToolApiKeys() {
             return;
         const auth = AuthStorage.create(authPath);
         for (const tool of TOOL_KEYS) {
-            const cred = auth.get(tool.id);
-            if (cred && cred.type === "api_key" && cred.key && !process.env[tool.env]) {
-                process.env[tool.env] = cred.key;
+            const key = getStoredToolKey(auth, tool.id);
+            if (key && !process.env[tool.env]) {
+                process.env[tool.env] = key;
             }
         }
     }
@@ -49,13 +54,13 @@ export async function handleConfig(ctx) {
     // Show current status
     const statusLines = ["GSD Tool Configuration\n"];
     for (const tool of TOOL_KEYS) {
-        const hasKey = !!process.env[tool.env] || !!auth.get(tool.id)?.key;
+        const hasKey = !!process.env[tool.env] || !!getStoredToolKey(auth, tool.id);
         statusLines.push(`  ${hasKey ? "\u2713" : "\u2717"} ${tool.label}${hasKey ? "" : ` \u2014 get key at ${tool.hint}`}`);
     }
     ctx.ui.notify(statusLines.join("\n"), "info");
     // Ask which tools to configure
     const options = TOOL_KEYS.map(t => {
-        const hasKey = !!process.env[t.env] || !!auth.get(t.id)?.key;
+        const hasKey = !!process.env[t.env] || !!getStoredToolKey(auth, t.id);
         return `${t.label} ${hasKey ? "(configured \u2713)" : "(not set)"}`;
     });
     options.push("(done)");

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -337,7 +337,7 @@ async function configureGit(ctx, prefs) {
     const gitBooleanFields = [
         { key: "auto_push", label: "Auto-push commits after committing", defaultVal: false },
         { key: "push_branches", label: "Push milestone branches to remote", defaultVal: false },
-        { key: "snapshots", label: "Create WIP snapshot commits during long tasks", defaultVal: false },
+        { key: "snapshots", label: "Create WIP snapshot commits during long tasks", defaultVal: true },
     ];
     for (const field of gitBooleanFields) {
         const current = git[field.key];
@@ -361,7 +361,7 @@ async function configureGit(ctx, prefs) {
     }
     // pre_merge_check
     const currentPreMerge = git.pre_merge_check !== undefined ? String(git.pre_merge_check) : "";
-    const preMergeChoice = await ctx.ui.select(`Pre-merge check${currentPreMerge ? ` (current: ${currentPreMerge})` : " (default: false)"}:`, ["true", "false", "auto", "(keep current)"]);
+    const preMergeChoice = await ctx.ui.select(`Pre-merge check${currentPreMerge ? ` (current: ${currentPreMerge})` : " (default: auto)"}:`, ["true", "false", "auto", "(keep current)"]);
     if (preMergeChoice && preMergeChoice !== "(keep current)") {
         if (preMergeChoice === "auto") {
             git.pre_merge_check = "auto";
@@ -487,7 +487,7 @@ export async function configureMode(ctx, prefs) {
     if (modeStr && modeStr !== "(keep current)") {
         if (modeStr.startsWith("solo")) {
             prefs.mode = "solo";
-            ctx.ui.notify("Mode: solo — defaults: auto_push=true, push_branches=false, pre_merge_check=false, merge_strategy=squash, isolation=worktree, unique_milestone_ids=false", "info");
+            ctx.ui.notify("Mode: solo — defaults: auto_push=true, push_branches=false, pre_merge_check=auto, merge_strategy=squash, isolation=worktree, unique_milestone_ids=false", "info");
         }
         else if (modeStr.startsWith("team")) {
             prefs.mode = "team";
@@ -650,7 +650,7 @@ export function serializePreferencesToFrontmatter(prefs) {
 }
 export async function ensurePreferencesFile(path, ctx, scope) {
     if (!existsSync(path)) {
-        const template = await loadFile(join(dirname(fileURLToPath(import.meta.url)), "templates", "preferences.md"));
+        const template = await loadFile(join(dirname(fileURLToPath(import.meta.url)), "templates", "PREFERENCES.md"));
         if (!template) {
             ctx.ui.notify("Could not load GSD preferences template.", "error");
             return;

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

@@ -277,8 +277,8 @@ function detectV2Gsd(basePath) {
     const gsdPath = gsdRoot(basePath);
     if (!existsSync(gsdPath))
         return null;
-    const hasPreferences = existsSync(join(gsdPath, "preferences.md")) ||
-        existsSync(join(gsdPath, "PREFERENCES.md"));
+    const hasPreferences = existsSync(join(gsdPath, "PREFERENCES.md")) ||
+        existsSync(join(gsdPath, "preferences.md"));
     const hasContext = existsSync(join(gsdPath, "CONTEXT.md"));
     let milestoneCount = 0;
     const milestonesPath = join(gsdPath, "milestones");
@@ -596,8 +596,8 @@ function detectVerificationCommands(basePath, detectedFiles, packageManager) {
  * Check if global GSD setup exists (has ~/.gsd/ with preferences).
  */
 export function hasGlobalSetup() {
-    return (existsSync(join(gsdHome, "preferences.md")) ||
-        existsSync(join(gsdHome, "PREFERENCES.md")));
+    return (existsSync(join(gsdHome, "PREFERENCES.md")) ||
+        existsSync(join(gsdHome, "preferences.md")));
 }
 /**
  * Check if this is the very first time GSD has been used on this machine.
@@ -607,8 +607,8 @@ export function isFirstEverLaunch() {
     if (!existsSync(gsdHome))
         return true;
     // If we have preferences, not first launch
-    if (existsSync(join(gsdHome, "preferences.md")) ||
-        existsSync(join(gsdHome, "PREFERENCES.md"))) {
+    if (existsSync(join(gsdHome, "PREFERENCES.md")) ||
+        existsSync(join(gsdHome, "preferences.md"))) {
         return false;
     }
     // If we have auth.json, not first launch (onboarding.ts already ran)

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -1,6 +1,6 @@
 # GSD Preferences Reference
 
-Full documentation for `~/.gsd/preferences.md` (global) and `.gsd/preferences.md` (project).
+Full documentation for `~/.gsd/PREFERENCES.md` (global) and `.gsd/PREFERENCES.md` (project).
 
 ---
 
@@ -51,8 +51,8 @@ skill_rules: []
 
 Preferences are loaded from two locations and merged:
 
-1. **Global:** `~/.gsd/preferences.md` — applies to all projects
-2. **Project:** `.gsd/preferences.md` — applies to the current project only
+1. **Global:** `~/.gsd/PREFERENCES.md` — applies to all projects
+2. **Project:** `.gsd/PREFERENCES.md` — applies to the current project only
 
 **Merge behavior** (see `mergePreferences()` in `preferences.ts`):
 
@@ -126,8 +126,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `auto_push`: boolean — automatically push commits to the remote after committing. Default: `false`.
   - `push_branches`: boolean — push the milestone branch to the remote after commits. Default: `false`.
   - `remote`: string — git remote name to push to. Default: `"origin"`.
-  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `false`.
-  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a worktree back to the integration branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `false`.
+  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `true`.
+  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a worktree back to the integration branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `"auto"`.
   - `commit_type`: string — override the conventional commit type prefix. Must be one of: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`, `perf`, `ci`, `build`, `style`. Default: inferred from diff content.
   - `main_branch`: string — the primary branch name for new git repos (e.g., `"main"`, `"master"`, `"trunk"`). Also used by `getMainBranch()` as the preferred branch when auto-detection is ambiguous. Default: `"main"`.
   - `merge_strategy`: `"squash"` or `"merge"` — controls how worktree branches are merged back. `"squash"` combines all commits into one; `"merge"` preserves individual commits. Default: `"squash"`.