gsd-pi 2.50.0-dev.d210a87 → 2.51.0-dev.7d435fe

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

@@ -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`):
 

package/dist/resources/extensions/gsd/error-classifier.js

@@ -0,0 +1,105 @@
+/**
+ * Unified error classifier for provider/network/server errors.
+ *
+ * Consolidates patterns from:
+ *  - isTransientNetworkError()  in preferences-models.ts
+ *  - classifyProviderError()    in provider-error-pause.ts
+ *
+ * Single entry point: classifyError(errorMsg, retryAfterMs?)
+ *
+ * @see https://github.com/gsd-build/gsd/issues/2577
+ */
+export function createRetryState() {
+    return { networkRetryCount: 0, consecutiveTransientCount: 0, currentRetryModelId: undefined };
+}
+export function resetRetryState(state) {
+    state.networkRetryCount = 0;
+    state.consecutiveTransientCount = 0;
+    state.currentRetryModelId = undefined;
+}
+// ── Classification ──────────────────────────────────────────────────────────
+const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429/i;
+const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i;
+const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
+// ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
+const CONNECTION_RE = /terminated|connection.?refused|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
+const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i;
+const RESET_DELAY_RE = /reset in (\d+)s/i;
+/**
+ * Classify an error message into one of the ErrorClass kinds.
+ *
+ * Classification order:
+ *  1. Permanent (auth/billing/quota) — unless also rate-limited
+ *  2. Rate limit (429, rate.?limit, too many requests)
+ *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
+ *  4. Server (500/502/503, overloaded, server_error)
+ *  5. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
+ *  6. Stream truncation (malformed JSON from mid-stream cut)
+ *  7. Unknown
+ */
+export function classifyError(errorMsg, retryAfterMs) {
+    const isPermanent = PERMANENT_RE.test(errorMsg);
+    const isRateLimit = RATE_LIMIT_RE.test(errorMsg);
+    // 1. Permanent — but rate limit takes precedence
+    if (isPermanent && !isRateLimit) {
+        return { kind: "permanent" };
+    }
+    // 2. Rate limit
+    if (isRateLimit) {
+        if (retryAfterMs != null && retryAfterMs > 0) {
+            return { kind: "rate-limit", retryAfterMs };
+        }
+        const resetMatch = errorMsg.match(RESET_DELAY_RE);
+        const delayMs = resetMatch ? Number(resetMatch[1]) * 1000 : 60_000;
+        return { kind: "rate-limit", retryAfterMs: delayMs };
+    }
+    // 3. Network errors — same-model retry candidate
+    if (NETWORK_RE.test(errorMsg)) {
+        // Exclude if also matches permanent signals (already handled above for
+        // rate-limit, but double-check for non-rate-limit permanent overlap like
+        // "billing" appearing alongside "network").
+        return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
+    }
+    // 4. Server errors — try fallback model
+    if (SERVER_RE.test(errorMsg)) {
+        return { kind: "server", retryAfterMs: retryAfterMs ?? 30_000 };
+    }
+    // 5. Connection errors — try fallback model
+    if (CONNECTION_RE.test(errorMsg)) {
+        return { kind: "connection", retryAfterMs: retryAfterMs ?? 15_000 };
+    }
+    // 6. Stream truncation — downstream symptom of connection drop
+    if (STREAM_RE.test(errorMsg)) {
+        return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
+    }
+    // 7. Unknown
+    return { kind: "unknown" };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/** Returns true for all transient (auto-resumable) error kinds. */
+export function isTransient(cls) {
+    switch (cls.kind) {
+        case "network":
+        case "rate-limit":
+        case "server":
+        case "stream":
+        case "connection":
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Backward-compatible thin wrapper.
+ *
+ * Returns true when the error is a transient *network* error specifically
+ * (worth retrying the same model). Permanent signals (auth, billing, quota)
+ * cause this to return false even if a network keyword is present.
+ */
+export function isTransientNetworkError(errorMsg) {
+    if (!errorMsg)
+        return false;
+    const cls = classifyError(errorMsg);
+    return cls.kind === "network";
+}

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

@@ -1,8 +1,8 @@
 /**
- * GSD bootstrappers for .gitignore and preferences.md
+ * GSD bootstrappers for .gitignore and PREFERENCES.md
  *
  * Ensures baseline .gitignore exists with universally-correct patterns.
- * Creates an empty preferences.md template if it doesn't exist.
+ * Creates an empty PREFERENCES.md template if it doesn't exist.
  * Both idempotent — non-destructive if already present.
  */
 import { join } from "node:path";
@@ -190,16 +190,16 @@ export function untrackRuntimeFiles(basePath) {
     }
 }
 /**
- * Ensure basePath/.gsd/preferences.md exists as an empty template.
+ * Ensure basePath/.gsd/PREFERENCES.md exists as an empty template.
  * Creates the file with frontmatter only if it doesn't exist.
  * Returns true if created, false if already exists.
  *
- * Checks both lowercase (canonical) and uppercase (legacy) to avoid
- * creating a duplicate when an uppercase file already exists.
+ * Checks both uppercase (canonical) and lowercase (legacy) to avoid
+ * creating a duplicate when a lowercase file already exists.
  */
 export function ensurePreferences(basePath) {
-    const preferencesPath = join(gsdRoot(basePath), "preferences.md");
-    const legacyPath = join(gsdRoot(basePath), "PREFERENCES.md");
+    const preferencesPath = join(gsdRoot(basePath), "PREFERENCES.md");
+    const legacyPath = join(gsdRoot(basePath), "preferences.md");
     if (existsSync(preferencesPath) || existsSync(legacyPath)) {
         return false;
     }