gsd-pi 2.70.0 → 2.70.1-dev.366a872

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -23,12 +23,14 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
             details: { operation: "save_summary", error: "db_unavailable" },
+            isError: true,
         };
     }
     if (!isSupportedSummaryArtifactType(params.artifact_type)) {
         return {
             content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
             details: { operation: "save_summary", error: "invalid_artifact_type" },
+            isError: true,
         };
     }
     const contextGuard = shouldBlockContextArtifactSaveInSnapshot(loadWriteGateSnapshot(basePath), params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
@@ -36,6 +38,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
             details: { operation: "save_summary", error: "context_write_blocked" },
+            isError: true,
         };
     }
     try {
@@ -68,6 +71,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
             details: { operation: "save_summary", error: msg },
+            isError: true,
         };
     }
 }
@@ -77,6 +81,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete task." }],
             details: { operation: "complete_task", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -87,6 +92,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error completing task: ${result.error}` }],
                 details: { operation: "complete_task", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -106,6 +112,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error completing task: ${msg}` }],
             details: { operation: "complete_task", error: msg },
+            isError: true,
         };
     }
 }
@@ -115,6 +122,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete slice." }],
             details: { operation: "complete_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -167,6 +175,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
                 details: { operation: "complete_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -186,6 +195,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error completing slice: ${msg}` }],
             details: { operation: "complete_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -195,6 +205,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete milestone." }],
             details: { operation: "complete_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -204,6 +215,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
             return {
                 content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
                 details: { operation: "complete_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -221,6 +233,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
             details: { operation: "complete_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -230,6 +243,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
             details: { operation: "validate_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -238,6 +252,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
             return {
                 content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
                 details: { operation: "validate_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -256,6 +271,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
             details: { operation: "validate_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -265,6 +281,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot reassess roadmap." }],
             details: { operation: "reassess_roadmap", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -273,6 +290,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error reassessing roadmap: ${result.error}` }],
                 details: { operation: "reassess_roadmap", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -292,6 +310,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
             details: { operation: "reassess_roadmap", error: msg },
+            isError: true,
         };
     }
 }
@@ -301,6 +320,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available." }],
             details: { operation: "save_gate_result", error: "db_unavailable" },
+            isError: true,
         };
     }
     const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
@@ -308,6 +328,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],
             details: { operation: "save_gate_result", error: "invalid_gate_id" },
+            isError: true,
         };
     }
     const validVerdicts = ["pass", "flag", "omitted"];
@@ -315,6 +336,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error: Invalid verdict "${params.verdict}". Must be one of: ${validVerdicts.join(", ")}` }],
             details: { operation: "save_gate_result", error: "invalid_verdict" },
+            isError: true,
         };
     }
     try {
@@ -339,6 +361,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving gate result: ${msg}` }],
             details: { operation: "save_gate_result", error: msg },
+            isError: true,
         };
     }
 }
@@ -348,6 +371,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan milestone." }],
             details: { operation: "plan_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -356,6 +380,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error planning milestone: ${result.error}` }],
                 details: { operation: "plan_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -373,6 +398,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
             details: { operation: "plan_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -382,6 +408,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan slice." }],
             details: { operation: "plan_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -390,6 +417,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error planning slice: ${result.error}` }],
                 details: { operation: "plan_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -409,6 +437,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error planning slice: ${msg}` }],
             details: { operation: "plan_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -418,6 +447,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan slice." }],
             details: { operation: "replan_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -426,6 +456,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error replanning slice: ${result.error}` }],
                 details: { operation: "replan_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -445,6 +476,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
             details: { operation: "replan_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -455,6 +487,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available." }],
                 details: { operation: "milestone_status", error: "db_unavailable" },
+                isError: true,
             };
         }
         const adapter = _getAdapter();
@@ -503,6 +536,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
             details: { operation: "milestone_status", error: msg },
+            isError: true,
         };
     }
 }

package/dist/resources/extensions/gsd/validate-directory.js

@@ -45,6 +45,30 @@ const WINDOWS_BLOCKED_PATHS = new Set([
     "C:\\Program Files",
     "C:\\Program Files (x86)",
 ]);
+const WINDOWS_BLOCKED_SUFFIXES = new Set([
+    "\\",
+    "\\windows",
+    "\\windows\\system32",
+    "\\program files",
+    "\\program files (x86)",
+]);
+function normalizePathForComparison(dirPath) {
+    let normalized = dirPath.replace(/[/\\]+$/, "");
+    if (normalized === "") {
+        normalized = "/";
+    }
+    else if (/^[A-Za-z]:$/.test(normalized)) {
+        normalized += "\\";
+    }
+    return platform() === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isBlockedWindowsPath(normalized) {
+    if (!/^[a-z]:\\/.test(normalized)) {
+        return false;
+    }
+    const suffix = normalized.slice(2);
+    return WINDOWS_BLOCKED_SUFFIXES.has(suffix);
+}
 // ─── Core Validation ────────────────────────────────────────────────────────────
 /**
  * Validate whether a directory is safe for GSD to operate in.
@@ -67,16 +91,10 @@ export function validateDirectory(dirPath) {
     }
     // Normalize trailing slashes for consistent comparison.
     // Special cases: "/" → "/" (not ""), "C:\" → "C:\" (not "C:")
-    let normalized = resolved.replace(/[/\\]+$/, "");
-    if (normalized === "") {
-        normalized = "/";
-    }
-    else if (/^[A-Za-z]:$/.test(normalized)) {
-        normalized = normalized + "\\";
-    }
+    const normalized = normalizePathForComparison(resolved);
     // ── Check 1: Blocked system paths ──────────────────────────────────────
     const blockedPaths = platform() === "win32" ? WINDOWS_BLOCKED_PATHS : UNIX_BLOCKED_PATHS;
-    if (blockedPaths.has(normalized)) {
+    if (platform() === "win32" ? isBlockedWindowsPath(normalized) : blockedPaths.has(normalized)) {
         return {
             safe: false,
             severity: "blocked",
@@ -86,10 +104,10 @@ export function validateDirectory(dirPath) {
     // ── Check 2: Home directory itself (not subdirs) ───────────────────────
     let resolvedHome;
     try {
-        resolvedHome = realpathSync(resolve(homedir())).replace(/[/\\]+$/, "");
+        resolvedHome = normalizePathForComparison(realpathSync(resolve(homedir())));
     }
     catch {
-        resolvedHome = resolve(homedir()).replace(/[/\\]+$/, "");
+        resolvedHome = normalizePathForComparison(resolve(homedir()));
     }
     if (normalized === resolvedHome) {
         return {
@@ -101,10 +119,10 @@ export function validateDirectory(dirPath) {
     // ── Check 3: Temp directory root ───────────────────────────────────────
     let resolvedTmp;
     try {
-        resolvedTmp = realpathSync(resolve(tmpdir())).replace(/[/\\]+$/, "");
+        resolvedTmp = normalizePathForComparison(realpathSync(resolve(tmpdir())));
     }
     catch {
-        resolvedTmp = resolve(tmpdir()).replace(/[/\\]+$/, "");
+        resolvedTmp = normalizePathForComparison(resolve(tmpdir()));
     }
     if (normalized === resolvedTmp) {
         return {

package/dist/resources/extensions/gsd/workflow-events.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteSync } from "./atomic-write.js";
+import { withFileLockSync } from "./file-lock.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── Session ID ───────────────────────────────────────────────────────────
 /**
@@ -88,17 +89,28 @@ export function findForkPoint(logA, logB) {
 export function compactMilestoneEvents(basePath, milestoneId) {
     const logPath = join(basePath, ".gsd", "event-log.jsonl");
     const archivePath = join(basePath, ".gsd", `event-log-${milestoneId}.jsonl.archived`);
-    const allEvents = readEvents(logPath);
-    const toArchive = allEvents.filter((e) => e.params.milestoneId === milestoneId);
-    const remaining = allEvents.filter((e) => e.params.milestoneId !== milestoneId);
-    if (toArchive.length === 0) {
-        return { archived: 0 };
-    }
-    // Write archived events to .jsonl.archived file (crash-safe)
-    atomicWriteSync(archivePath, toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n");
-    // Truncate active log to remaining events only
-    atomicWriteSync(logPath, remaining.length > 0
-        ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
-        : "");
-    return { archived: toArchive.length };
+    return withFileLockSync(logPath, () => {
+        const allEvents = readEvents(logPath);
+        // Single-pass partition to halve the work (per reviewer agent)
+        const toArchive = [];
+        const remaining = [];
+        for (const e of allEvents) {
+            if (e.params.milestoneId === milestoneId) {
+                toArchive.push(e);
+            }
+            else {
+                remaining.push(e);
+            }
+        }
+        if (toArchive.length === 0) {
+            return { archived: 0 };
+        }
+        // Write archived events to .jsonl.archived file (crash-safe)
+        atomicWriteSync(archivePath, toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n");
+        // Truncate active log to remaining events only
+        atomicWriteSync(logPath, remaining.length > 0
+            ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
+            : "");
+        return { archived: toArchive.length };
+    });
 }

package/dist/resources/extensions/gsd/workflow-mcp-auto-prep.js

@@ -0,0 +1,56 @@
+import { ensureProjectWorkflowMcpConfig, } from "./mcp-project-config.js";
+import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
+function getAuthModeSafe(ctx, provider) {
+    if (!provider)
+        return undefined;
+    const getAuthMode = ctx.modelRegistry?.getProviderAuthMode;
+    if (typeof getAuthMode !== "function")
+        return undefined;
+    try {
+        return getAuthMode(provider);
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasClaudeCodeProvider(ctx) {
+    return getAuthModeSafe(ctx, "claude-code") === "externalCli";
+}
+function isClaudeCodeProviderReady(ctx) {
+    const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
+    if (typeof readyCheck !== "function")
+        return false;
+    try {
+        return readyCheck("claude-code");
+    }
+    catch {
+        return false;
+    }
+}
+export function shouldAutoPrepareWorkflowMcp(ctx) {
+    const provider = ctx.model?.provider;
+    const baseUrl = ctx.model?.baseUrl;
+    const authMode = getAuthModeSafe(ctx, provider);
+    if (usesWorkflowMcpTransport(authMode, baseUrl))
+        return true;
+    if (provider === "claude-code")
+        return true;
+    if (hasClaudeCodeProvider(ctx))
+        return true;
+    return isClaudeCodeProviderReady(ctx);
+}
+export function prepareWorkflowMcpForProject(ctx, projectRoot) {
+    if (!shouldAutoPrepareWorkflowMcp(ctx))
+        return null;
+    try {
+        const result = ensureProjectWorkflowMcpConfig(projectRoot);
+        if (result.status !== "unchanged") {
+            ctx.ui?.notify?.(`Claude Code MCP prepared at ${result.configPath}`, "info");
+        }
+        return result;
+    }
+    catch (err) {
+        ctx.ui?.notify?.(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root.`, "warning");
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -287,6 +287,17 @@ export function getRequiredWorkflowToolsForAutoUnit(unitType) {
 export function usesWorkflowMcpTransport(authMode, baseUrl) {
     return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
 }
+export function supportsStructuredQuestions(activeTools, options = {}) {
+    if (!activeTools.includes("ask_user_questions"))
+        return false;
+    // Workflow MCP currently exposes ask_user_questions via MCP form elicitation.
+    // Local external CLI transports such as Claude Code can invoke the tool, but
+    // do not reliably complete that elicitation round-trip yet, so guided discuss
+    // prompts must fall back to plain-text questioning.
+    if (usesWorkflowMcpTransport(options.authMode, options.baseUrl))
+        return false;
+    return true;
+}
 export function getWorkflowTransportSupportError(provider, requiredTools, options = {}) {
     if (!provider || requiredTools.length === 0)
         return null;
@@ -299,7 +310,7 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
     const unitLabel = options.unitType ? ` for ${options.unitType}` : "";
     const providerLabel = `"${provider}"`;
     if (!launch) {
-        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
+        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
     }
     const missing = [...new Set(requiredTools)].filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     if (missing.length === 0)

package/dist/resources/extensions/slash-commands/audit.js

@@ -1,3 +1,4 @@
+import { mkdirSync } from "node:fs";
 export default function auditCommand(pi) {
     pi.registerCommand("audit", {
         description: "Audit the current codebase against a specific goal and write a structured report to .gsd/audits/",
@@ -26,7 +27,7 @@ export default function auditCommand(pi) {
                 .slice(0, 40);
             const outputPath = `.gsd/audits/${timestamp}-${slug}.md`;
             // ── Step 3: Ensure the output directory exists ───────────────────────
-            await pi.exec("mkdir", ["-p", ".gsd/audits"]);
+            mkdirSync(".gsd/audits", { recursive: true });
             // ── Step 4: Send the audit prompt to the agent ───────────────────────
             const prompt = `You are conducting a codebase audit. This is a **read-only recce** — you will explore the codebase deeply and produce a structured report. You must NOT edit any code or create any files other than the audit report itself.
 

package/dist/resources/extensions/subagent/isolation.js

@@ -14,8 +14,10 @@ const execFile = promisify(execFileCb);
 // ============================================================================
 // Directory helpers
 // ============================================================================
-function encodeCwd(cwd) {
-    return cwd.replace(/\//g, "--");
+export function encodeCwd(cwd) {
+    // Encode the entire cwd so Windows drive letters, separators, and UNC
+    // prefixes cannot leak into the isolation path.
+    return Buffer.from(cwd, "utf8").toString("base64url");
 }
 const gsdHome = process.env.GSD_HOME || path.join(os.homedir(), ".gsd");
 function getIsolationBaseDir(cwd, taskId) {

package/dist/update-check.d.ts

@@ -8,6 +8,7 @@ interface UpdateCheckCache {
 export declare function compareSemver(a: string, b: string): number;
 export declare function readUpdateCache(cachePath?: string): UpdateCheckCache | null;
 export declare function writeUpdateCache(cache: UpdateCheckCache, cachePath?: string): void;
+export declare function fetchLatestVersionFromRegistry(registryUrl?: string, fetchTimeoutMs?: number): Promise<string | null>;
 export interface UpdateCheckOptions {
     currentVersion?: string;
     cachePath?: string;

package/dist/update-check.js

@@ -7,6 +7,7 @@ const CACHE_FILE = join(appRoot, '.update-check');
 const NPM_PACKAGE_NAME = 'gsd-pi';
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const FETCH_TIMEOUT_MS = 5000;
+const DEFAULT_REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
 /**
  * Compares two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
  */
@@ -42,6 +43,29 @@ export function writeUpdateCache(cache, cachePath = CACHE_FILE) {
         // Non-fatal — don't block startup if cache write fails
     }
 }
+function normalizeLatestVersion(version) {
+    if (typeof version !== 'string')
+        return null;
+    const trimmed = version.trim().replace(/^v/, '');
+    return trimmed.length > 0 ? trimmed : null;
+}
+export async function fetchLatestVersionFromRegistry(registryUrl = DEFAULT_REGISTRY_URL, fetchTimeoutMs = FETCH_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
+    try {
+        const res = await fetch(registryUrl, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return normalizeLatestVersion(data.version);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 function printUpdateBanner(current, latest) {
     process.stderr.write(`  ${chalk.yellow('Update available:')} ${chalk.dim(`v${current}`)} → ${chalk.bold(`v${latest}`)}\n` +
         `  ${chalk.dim('Run')} npm update -g gsd-pi ${chalk.dim('or')} /gsd update ${chalk.dim('to upgrade')}\n\n`);
@@ -53,7 +77,7 @@ function printUpdateBanner(current, latest) {
 export async function checkForUpdates(options = {}) {
     const currentVersion = options.currentVersion || process.env.GSD_VERSION || '0.0.0';
     const cachePath = options.cachePath || CACHE_FILE;
-    const registryUrl = options.registryUrl || `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+    const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
     const checkIntervalMs = options.checkIntervalMs ?? CHECK_INTERVAL_MS;
     const fetchTimeoutMs = options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
     const onUpdate = options.onUpdate || printUpdateBanner;
@@ -65,16 +89,8 @@ export async function checkForUpdates(options = {}) {
         }
         return;
     }
-    // Fetch latest version from npm registry
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
     try {
-        const res = await fetch(registryUrl, { signal: controller.signal });
-        clearTimeout(timeout);
-        if (!res.ok)
-            return;
-        const data = (await res.json());
-        const latestVersion = data.version;
+        const latestVersion = await fetchLatestVersionFromRegistry(registryUrl, fetchTimeoutMs);
         if (!latestVersion)
             return;
         writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath);
@@ -85,9 +101,6 @@ export async function checkForUpdates(options = {}) {
     catch {
         // Network error or timeout — silently ignore, don't block startup
     }
-    finally {
-        clearTimeout(timeout);
-    }
 }
 const PROMPT_TIMEOUT_MS = 30_000;
 /**
@@ -101,7 +114,7 @@ const PROMPT_TIMEOUT_MS = 30_000;
 export async function checkAndPromptForUpdates(options = {}) {
     const currentVersion = options.currentVersion || process.env.GSD_VERSION || '0.0.0';
     const cachePath = options.cachePath || CACHE_FILE;
-    const registryUrl = options.registryUrl || `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+    const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
     const checkIntervalMs = options.checkIntervalMs ?? CHECK_INTERVAL_MS;
     const fetchTimeoutMs = options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
     // Determine latest version (from cache or network)
@@ -111,25 +124,15 @@ export async function checkAndPromptForUpdates(options = {}) {
         latestVersion = cache.latestVersion;
     }
     else {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
         try {
-            const res = await fetch(registryUrl, { signal: controller.signal });
-            clearTimeout(timeout);
-            if (res.ok) {
-                const data = (await res.json());
-                if (data.version) {
-                    latestVersion = data.version;
-                    writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath);
-                }
+            latestVersion = await fetchLatestVersionFromRegistry(registryUrl, fetchTimeoutMs);
+            if (latestVersion) {
+                writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath);
             }
         }
         catch {
             // Network unavailable — silently skip
         }
-        finally {
-            clearTimeout(timeout);
-        }
     }
     if (!latestVersion || compareSemver(latestVersion, currentVersion) <= 0) {
         return false;

package/dist/update-cmd.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { compareSemver } from './update-check.js';
+import { compareSemver, fetchLatestVersionFromRegistry } from './update-check.js';
 const NPM_PACKAGE = 'gsd-pi';
 export async function runUpdate() {
     const current = process.env.GSD_VERSION || '0.0.0';
@@ -10,16 +10,8 @@ export async function runUpdate() {
     const reset = '\x1b[0m';
     process.stdout.write(`${dim}Current version:${reset} v${current}\n`);
     process.stdout.write(`${dim}Checking npm registry...${reset}\n`);
-    // Fetch latest version — bypass npm client cache to avoid stale results (#3445)
-    let latest;
-    try {
-        latest = execSync(`npm view ${NPM_PACKAGE} version --fetch-retry-mintimeout=3000`, {
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-            env: { ...process.env, npm_config_cache: '' },
-        }).trim();
-    }
-    catch {
+    const latest = await fetchLatestVersionFromRegistry();
+    if (!latest) {
         process.stderr.write(`${yellow}Failed to reach npm registry.${reset}\n`);
         process.exit(1);
     }

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-Nl6lg7zP5dNgNBV1107v1
+eMly3KqfZihJJAHQGmxvO