gsd-pi 2.70.0-dev.55a1c68 → 2.70.0-dev.c236ea4

package/packages/pi-coding-agent/src/core/lsp/config.ts

@@ -172,16 +172,49 @@ export function hasRootMarkers(cwd: string, markers: string[]): boolean {
 // Local Binary Resolution
 // =============================================================================
 
-const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDir: string }> = [
-	{ markers: ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"], binDir: "node_modules/.bin" },
-	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDir: ".venv/bin" },
-	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDir: "venv/bin" },
-	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDir: ".env/bin" },
-	{ markers: ["Gemfile", "Gemfile.lock"], binDir: "vendor/bundle/bin" },
-	{ markers: ["Gemfile", "Gemfile.lock"], binDir: "bin" },
-	{ markers: ["go.mod", "go.sum"], binDir: "bin" },
+const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDirs: string[] }> = [
+	{ markers: ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"], binDirs: ["node_modules/.bin"] },
+	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDirs: [".venv/bin", ".venv/Scripts"] },
+	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDirs: ["venv/bin", "venv/Scripts"] },
+	{ markers: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"], binDirs: [".env/bin", ".env/Scripts"] },
+	{ markers: ["Gemfile", "Gemfile.lock"], binDirs: ["vendor/bundle/bin"] },
+	{ markers: ["Gemfile", "Gemfile.lock"], binDirs: ["bin"] },
+	{ markers: ["go.mod", "go.sum"], binDirs: ["bin"] },
 ];
 
+function getWindowsBinaryCandidates(command: string): string[] {
+	const ext = path.extname(command).toLowerCase();
+	if (ext) {
+		return [command];
+	}
+
+	return [
+		command,
+		`${command}.cmd`,
+		`${command}.bat`,
+		`${command}.exe`,
+	];
+}
+
+export function resolveLocalBinaryPath(command: string, cwd: string, isWindows: boolean): string | null {
+	for (const { markers, binDirs } of LOCAL_BIN_PATHS) {
+		if (!hasRootMarkers(cwd, markers)) continue;
+
+		for (const binDir of binDirs) {
+			const basePath = path.join(cwd, binDir, command);
+			const candidates = isWindows ? getWindowsBinaryCandidates(basePath) : [basePath];
+
+			for (const candidate of candidates) {
+				if (fs.existsSync(candidate)) {
+					return candidate;
+				}
+			}
+		}
+	}
+
+	return null;
+}
+
 export function which(command: string): string | null {
 	// On Windows, prefer `where.exe` over `which` — MSYS/Git Bash's `which`
 	// returns POSIX paths (/c/Users/...) that Node's spawn() can't execute.
@@ -196,15 +229,8 @@ export function which(command: string): string | null {
 }
 
 export function resolveCommand(command: string, cwd: string): string | null {
-	for (const { markers, binDir } of LOCAL_BIN_PATHS) {
-		if (hasRootMarkers(cwd, markers)) {
-			const localPath = path.join(cwd, binDir, command);
-			if (fs.existsSync(localPath)) {
-				return localPath;
-			}
-		}
-	}
-
+	const localPath = resolveLocalBinaryPath(command, cwd, process.platform === "win32");
+	if (localPath) return localPath;
 	return which(command);
 }
 

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -341,6 +341,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingBudgets: settingsManager.getThinkingBudgets(),
 		maxRetryDelayMs: settingsManager.getRetrySettings().maxDelayMs,
 		externalToolExecution: (m) => modelRegistry.getProviderAuthMode(m.provider) === "externalCli",
+		getProviderOptions: async (currentModel) => {
+			if (currentModel.provider !== "claude-code") return undefined;
+			const runner = extensionRunnerRef.current;
+			if (!runner?.hasUI()) return undefined;
+			return {
+				extensionUIContext: runner.getUIContext(),
+			};
+		},
 		getApiKey: async (provider) => {
 			// Use the provider argument from the in-flight request;
 			// agent.state.model may already be switched mid-turn.

package/packages/pi-coding-agent/src/modes/interactive/slash-command-handlers.ts

@@ -305,11 +305,13 @@ async function handleShareCommand(ctx: SlashCommandContext): Promise<void> {
 		ctx.showStatus("Share cancelled");
 	};
 
-	try {
-		const result = await new Promise<{ stdout: string; stderr: string; code: number | null }>((resolve) => {
-			proc = spawn("gh", ["gist", "create", "--public=false", tmpFile]);
-			let stdout = "";
-			let stderr = "";
+		try {
+			const result = await new Promise<{ stdout: string; stderr: string; code: number | null }>((resolve) => {
+				proc = spawn("gh", ["gist", "create", "--public=false", tmpFile], {
+					shell: process.platform === "win32",
+				});
+				let stdout = "";
+				let stderr = "";
 			proc.stdout?.on("data", (data) => {
 				stdout += data.toString();
 			});

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -16,10 +16,12 @@ import type {
 	SimpleStreamOptions,
 	ToolCall,
 } from "@gsd/pi-ai";
+import type { ExtensionUIContext } from "@gsd/pi-coding-agent";
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
+import { showInterviewRound, type Question, type RoundResult } from "../shared/tui.js";
 import type {
 	SDKAssistantMessage,
 	SDKMessage,
@@ -45,6 +47,46 @@ type ToolCallWithExternalResult = ToolCall & {
 	externalResult?: ExternalToolResultPayload;
 };
 
+interface ClaudeCodeStreamOptions extends SimpleStreamOptions {
+	extensionUIContext?: ExtensionUIContext;
+}
+
+interface SdkElicitationRequestOption {
+	const?: string;
+	title?: string;
+}
+
+interface SdkElicitationFieldSchema {
+	type?: string;
+	title?: string;
+	description?: string;
+	oneOf?: SdkElicitationRequestOption[];
+	items?: {
+		anyOf?: SdkElicitationRequestOption[];
+	};
+}
+
+interface SdkElicitationRequest {
+	serverName: string;
+	message: string;
+	mode?: "form" | "url";
+	requestedSchema?: {
+		type?: string;
+		properties?: Record<string, SdkElicitationFieldSchema>;
+	};
+}
+
+interface SdkElicitationResult {
+	action: "accept" | "decline" | "cancel";
+	content?: Record<string, string | string[]>;
+}
+
+interface ParsedElicitationQuestion extends Question {
+	noteFieldId?: string;
+}
+
+const OTHER_OPTION_LABEL = "None of the above";
+
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -172,6 +214,174 @@ export function makeStreamExhaustedErrorMessage(model: string, lastTextContent:
 	return message;
 }
 
+function readElicitationChoices(options: SdkElicitationRequestOption[] | undefined): string[] {
+	if (!Array.isArray(options)) return [];
+	return options
+		.map((option) => (typeof option?.const === "string" ? option.const : typeof option?.title === "string" ? option.title : ""))
+		.filter((option): option is string => option.length > 0);
+}
+
+export function parseAskUserQuestionsElicitation(
+	request: Pick<SdkElicitationRequest, "mode" | "requestedSchema">,
+): ParsedElicitationQuestion[] | null {
+	if (request.mode && request.mode !== "form") return null;
+	const properties = request.requestedSchema?.properties;
+	if (!properties || typeof properties !== "object") return null;
+
+	const questions: ParsedElicitationQuestion[] = [];
+
+	for (const [fieldId, rawField] of Object.entries(properties)) {
+		if (fieldId.endsWith("__note")) continue;
+		if (!rawField || typeof rawField !== "object") return null;
+
+		const header = typeof rawField.title === "string" && rawField.title.length > 0 ? rawField.title : fieldId;
+		const question = typeof rawField.description === "string" ? rawField.description : "";
+
+		if (rawField.type === "array") {
+			const options = readElicitationChoices(rawField.items?.anyOf).map((label) => ({ label, description: "" }));
+			if (options.length === 0) return null;
+			questions.push({
+				id: fieldId,
+				header,
+				question,
+				options,
+				allowMultiple: true,
+			});
+			continue;
+		}
+
+		if (rawField.type === "string") {
+			const noteFieldId = Object.prototype.hasOwnProperty.call(properties, `${fieldId}__note`)
+				? `${fieldId}__note`
+				: undefined;
+			const options = readElicitationChoices(rawField.oneOf)
+				.filter((label) => label !== OTHER_OPTION_LABEL)
+				.map((label) => ({ label, description: "" }));
+			if (options.length === 0) return null;
+			questions.push({
+				id: fieldId,
+				header,
+				question,
+				options,
+				noteFieldId,
+			});
+			continue;
+		}
+
+		return null;
+	}
+
+	return questions.length > 0 ? questions : null;
+}
+
+export function roundResultToElicitationContent(
+	questions: ParsedElicitationQuestion[],
+	result: RoundResult,
+): Record<string, string | string[]> {
+	const content: Record<string, string | string[]> = {};
+
+	for (const question of questions) {
+		const answer = result.answers[question.id];
+		if (!answer) continue;
+
+		if (question.allowMultiple) {
+			const selected = Array.isArray(answer.selected) ? answer.selected : [answer.selected];
+			content[question.id] = selected;
+			continue;
+		}
+
+		const selected = Array.isArray(answer.selected) ? answer.selected[0] ?? "" : answer.selected;
+		content[question.id] = selected;
+		if (question.noteFieldId && selected === OTHER_OPTION_LABEL && answer.notes.trim().length > 0) {
+			content[question.noteFieldId] = answer.notes.trim();
+		}
+	}
+
+	return content;
+}
+
+function buildElicitationPromptTitle(request: SdkElicitationRequest, question: ParsedElicitationQuestion): string {
+	const parts = [
+		request.serverName ? `[${request.serverName}]` : "",
+		question.header,
+		question.question,
+	].filter((part) => part && part.trim().length > 0);
+	return parts.join("\n\n");
+}
+
+async function promptElicitationWithDialogs(
+	request: SdkElicitationRequest,
+	questions: ParsedElicitationQuestion[],
+	ui: ExtensionUIContext,
+	signal: AbortSignal,
+): Promise<SdkElicitationResult> {
+	const content: Record<string, string | string[]> = {};
+
+	for (const question of questions) {
+		const title = buildElicitationPromptTitle(request, question);
+
+		if (question.allowMultiple) {
+			const selected = await ui.select(title, question.options.map((option) => option.label), {
+				allowMultiple: true,
+				signal,
+			});
+			if (Array.isArray(selected)) {
+				if (selected.length === 0) return { action: "cancel" };
+				content[question.id] = selected;
+				continue;
+			}
+			if (typeof selected === "string" && selected.length > 0) {
+				content[question.id] = [selected];
+				continue;
+			}
+			return { action: "cancel" };
+		}
+
+		const selected = await ui.select(title, [...question.options.map((option) => option.label), OTHER_OPTION_LABEL], { signal });
+		if (typeof selected !== "string" || selected.length === 0) {
+			return { action: "cancel" };
+		}
+
+		content[question.id] = selected;
+		if (question.noteFieldId && selected === OTHER_OPTION_LABEL) {
+			const note = await ui.input(`${question.header} note`, "Explain your answer", { signal });
+			if (note === undefined) return { action: "cancel" };
+			if (note.trim().length > 0) {
+				content[question.noteFieldId] = note.trim();
+			}
+		}
+	}
+
+	return { action: "accept", content };
+}
+
+export function createClaudeCodeElicitationHandler(
+	ui: ExtensionUIContext | undefined,
+): ((request: SdkElicitationRequest, options: { signal: AbortSignal }) => Promise<SdkElicitationResult>) | undefined {
+	if (!ui) return undefined;
+
+	return async (request, { signal }) => {
+		if (request.mode === "url") {
+			return { action: "decline" };
+		}
+
+		const questions = parseAskUserQuestionsElicitation(request);
+		if (!questions) {
+			return { action: "decline" };
+		}
+
+		const interviewResult = await showInterviewRound(questions, { signal }, { ui } as any).catch(() => undefined);
+		if (interviewResult && Object.keys(interviewResult.answers).length > 0) {
+			return {
+				action: "accept",
+				content: roundResultToElicitationContent(questions, interviewResult),
+			};
+		}
+
+		return promptElicitationWithDialogs(request, questions, ui, signal);
+	};
+}
+
 // ---------------------------------------------------------------------------
 // SDK options builder
 // ---------------------------------------------------------------------------
@@ -182,7 +392,11 @@ export function makeStreamExhaustedErrorMessage(model: string, lastTextContent:
  * Extracted for testability — callers can verify session persistence,
  * beta flags, and other configuration without mocking the full SDK.
  */
-export function buildSdkOptions(modelId: string, prompt: string): Record<string, unknown> {
+export function buildSdkOptions(
+	modelId: string,
+	prompt: string,
+	extraOptions: Record<string, unknown> = {},
+): Record<string, unknown> {
 	const mcpServers = buildWorkflowMcpServers();
 	return {
 		pathToClaudeCodeExecutable: getClaudePath(),
@@ -196,6 +410,7 @@ export function buildSdkOptions(modelId: string, prompt: string): Record<string,
 		systemPrompt: { type: "preset", preset: "claude_code" },
 		...(mcpServers ? { mcpServers } : {}),
 		betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
+		...extraOptions,
 	};
 }
 
@@ -359,7 +574,17 @@ async function pumpSdkMessages(
 		}
 
 		const prompt = buildPromptFromContext(context);
-		const sdkOpts = buildSdkOptions(modelId, prompt);
+		const sdkOpts = buildSdkOptions(
+			modelId,
+			prompt,
+			typeof (options as ClaudeCodeStreamOptions | undefined)?.extensionUIContext === "object"
+				? {
+						onElicitation: createClaudeCodeElicitationHandler(
+							(options as ClaudeCodeStreamOptions | undefined)?.extensionUIContext,
+						),
+					}
+				: {},
+		);
 
 		const queryResult = sdk.query({
 			prompt,

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -7,9 +7,12 @@ import {
 	makeStreamExhaustedErrorMessage,
 	buildPromptFromContext,
 	buildSdkOptions,
+	createClaudeCodeElicitationHandler,
 	extractToolResultsFromSdkUserMessage,
 	getClaudeLookupCommand,
+	parseAskUserQuestionsElicitation,
 	parseClaudeLookupOutput,
+	roundResultToElicitationContent,
 } from "../stream-adapter.ts";
 import type { Context, Message } from "@gsd/pi-ai";
 import type { SDKUserMessage } from "../sdk-types.ts";
@@ -309,6 +312,175 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			process.env.GSD_CLI_PATH = prev.GSD_CLI_PATH;
 		}
 	});
+
+	test("buildSdkOptions preserves runtime callbacks such as onElicitation", () => {
+		const prev = {
+			GSD_WORKFLOW_MCP_COMMAND: process.env.GSD_WORKFLOW_MCP_COMMAND,
+			GSD_WORKFLOW_MCP_NAME: process.env.GSD_WORKFLOW_MCP_NAME,
+			GSD_WORKFLOW_MCP_ARGS: process.env.GSD_WORKFLOW_MCP_ARGS,
+			GSD_WORKFLOW_MCP_ENV: process.env.GSD_WORKFLOW_MCP_ENV,
+			GSD_WORKFLOW_MCP_CWD: process.env.GSD_WORKFLOW_MCP_CWD,
+		};
+		const onElicitation = async () => ({ action: "decline" as const });
+		try {
+			delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+			delete process.env.GSD_WORKFLOW_MCP_NAME;
+			delete process.env.GSD_WORKFLOW_MCP_ARGS;
+			delete process.env.GSD_WORKFLOW_MCP_ENV;
+			delete process.env.GSD_WORKFLOW_MCP_CWD;
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test", { onElicitation });
+			assert.equal(options.onElicitation, onElicitation);
+		} finally {
+			process.env.GSD_WORKFLOW_MCP_COMMAND = prev.GSD_WORKFLOW_MCP_COMMAND;
+			process.env.GSD_WORKFLOW_MCP_NAME = prev.GSD_WORKFLOW_MCP_NAME;
+			process.env.GSD_WORKFLOW_MCP_ARGS = prev.GSD_WORKFLOW_MCP_ARGS;
+			process.env.GSD_WORKFLOW_MCP_ENV = prev.GSD_WORKFLOW_MCP_ENV;
+			process.env.GSD_WORKFLOW_MCP_CWD = prev.GSD_WORKFLOW_MCP_CWD;
+		}
+	});
+});
+
+describe("stream-adapter — MCP elicitation bridge", () => {
+	const askUserQuestionsRequest = {
+		serverName: "gsd-workflow",
+		message: "Please answer the following question(s).",
+		mode: "form" as const,
+		requestedSchema: {
+			type: "object" as const,
+			properties: {
+				storage_scope: {
+					type: "string",
+					title: "Storage",
+					description: "Does this app need to sync across devices?",
+					oneOf: [
+						{ const: "Local-only (Recommended)", title: "Local-only (Recommended)" },
+						{ const: "Cloud-synced", title: "Cloud-synced" },
+						{ const: "None of the above", title: "None of the above" },
+					],
+				},
+				storage_scope__note: {
+					type: "string",
+					title: "Storage Note",
+					description: "Optional note for None of the above.",
+				},
+				platform: {
+					type: "array",
+					title: "Platform",
+					description: "Where should it run?",
+					items: {
+						anyOf: [
+							{ const: "Web", title: "Web" },
+							{ const: "Desktop", title: "Desktop" },
+							{ const: "Mobile", title: "Mobile" },
+						],
+					},
+				},
+			},
+		},
+	};
+
+	test("parseAskUserQuestionsElicitation rebuilds interview questions from the MCP schema", () => {
+		const questions = parseAskUserQuestionsElicitation(askUserQuestionsRequest);
+		assert.deepEqual(questions, [
+			{
+				id: "storage_scope",
+				header: "Storage",
+				question: "Does this app need to sync across devices?",
+				options: [
+					{ label: "Local-only (Recommended)", description: "" },
+					{ label: "Cloud-synced", description: "" },
+				],
+				noteFieldId: "storage_scope__note",
+			},
+			{
+				id: "platform",
+				header: "Platform",
+				question: "Where should it run?",
+				options: [
+					{ label: "Web", description: "" },
+					{ label: "Desktop", description: "" },
+					{ label: "Mobile", description: "" },
+				],
+				allowMultiple: true,
+			},
+		]);
+	});
+
+	test("roundResultToElicitationContent preserves notes for None of the above", () => {
+		const questions = parseAskUserQuestionsElicitation(askUserQuestionsRequest);
+		assert.ok(questions);
+
+		const content = roundResultToElicitationContent(questions, {
+			endInterview: false,
+			answers: {
+				storage_scope: {
+					selected: "None of the above",
+					notes: "Needs selective sync later",
+				},
+				platform: {
+					selected: ["Web", "Desktop"],
+					notes: "",
+				},
+			},
+		});
+
+		assert.deepEqual(content, {
+			storage_scope: "None of the above",
+			storage_scope__note: "Needs selective sync later",
+			platform: ["Web", "Desktop"],
+		});
+	});
+
+	test("createClaudeCodeElicitationHandler accepts interview-style answers from custom UI", async () => {
+		const handler = createClaudeCodeElicitationHandler({
+			custom: async (_factory: any) => ({
+				endInterview: false,
+				answers: {
+					storage_scope: {
+						selected: "Cloud-synced",
+						notes: "",
+					},
+					platform: {
+						selected: ["Web", "Mobile"],
+						notes: "",
+					},
+				},
+			}),
+		} as any);
+
+		assert.ok(handler);
+		const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+		assert.deepEqual(result, {
+			action: "accept",
+			content: {
+				storage_scope: "Cloud-synced",
+				platform: ["Web", "Mobile"],
+			},
+		});
+	});
+
+	test("createClaudeCodeElicitationHandler falls back to dialog prompts when custom UI is unavailable", async () => {
+		const ui = {
+			custom: async () => undefined,
+			select: async (_title: string, options: string[], opts?: { allowMultiple?: boolean }) => {
+				if (opts?.allowMultiple) return ["Desktop", "Mobile"];
+				return options.includes("None of the above") ? "None of the above" : options[0];
+			},
+			input: async () => "CLI-only deployment target",
+		};
+		const handler = createClaudeCodeElicitationHandler(ui as any);
+		assert.ok(handler);
+
+		const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+		assert.deepEqual(result, {
+			action: "accept",
+			content: {
+				storage_scope: "None of the above",
+				storage_scope__note: "CLI-only deployment target",
+				platform: ["Desktop", "Mobile"],
+			},
+		});
+	});
 });
 
 describe("stream-adapter — Windows Claude path lookup (#3770)", () => {

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -997,7 +997,7 @@ export async function buildDiscussMilestonePrompt(mid: string, midTitle: string,
     milestoneId: mid,
     milestoneTitle: midTitle,
     inlinedTemplates: discussTemplates,
-    structuredQuestionsAvailable: "true",
+    structuredQuestionsAvailable: "false",
     commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
     fastPathInstruction: "",
   });
@@ -1503,7 +1503,9 @@ export async function buildCompleteMilestonePrompt(
   try {
     const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
     if (isDbAvailable()) {
-      sliceIds = getMilestoneSlices(mid).map(s => s.id);
+      sliceIds = getMilestoneSlices(mid)
+        .filter(s => s.status !== "skipped")
+        .map(s => s.id);
     }
   } catch (err) {
     logWarning("prompt", `buildCompleteMilestonePrompt DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1597,7 +1599,9 @@ export async function buildValidateMilestonePrompt(
   try {
     const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
     if (isDbAvailable()) {
-      valSliceIds = getMilestoneSlices(mid).map(s => s.id);
+      valSliceIds = getMilestoneSlices(mid)
+        .filter(s => s.status !== "skipped")
+        .map(s => s.id);
     }
   } catch (err) {
     logWarning("prompt", `buildValidateMilestonePrompt slice IDs lookup failed: ${err instanceof Error ? err.message : String(err)}`);

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

@@ -125,9 +125,9 @@ import {
 } from "./metrics.js";
 import { setLogBasePath, logWarning, logError } from "./workflow-logger.js";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
-import { createRequire } from "node:module";
 import { atomicWriteSync } from "./atomic-write.js";
 import {
   autoCommitCurrentBranch,
@@ -1334,13 +1334,17 @@ export async function startAuto(
     restoreHookState(s.basePath);
     // Re-sync managed resources on resume so long-lived auto sessions pick up
     // bundled extension updates before resume-time verification/state logic runs.
+    // GSD_PKG_ROOT is set by loader.ts and points to the gsd-pi package root.
+    // The relative import ("../../../resource-loader.js") only works from the source
+    // tree; deployed extensions live at ~/.gsd/agent/extensions/gsd/ where the
+    // relative path resolves to ~/.gsd/agent/resource-loader.js which doesn't exist.
+    // Using GSD_PKG_ROOT constructs a correct absolute path in both contexts (#3949).
     const agentDir = process.env.GSD_CODING_AGENT_DIR || join(process.env.GSD_HOME || homedir(), ".gsd", "agent");
-    // Resolve resource-loader from the gsd-pi package root — the relative
-    // "../../../resource-loader.js" path only works from the source tree but
-    // breaks when extensions are deployed to ~/.gsd/agent/extensions/gsd/.
-    const _req = createRequire(import.meta.url);
-    const pkgRoot = dirname(_req.resolve("gsd-pi/package.json"));
-    const { initResources } = await import(join(pkgRoot, "dist", "resource-loader.js"));
+    const pkgRoot = process.env.GSD_PKG_ROOT;
+    const resourceLoaderPath = pkgRoot
+      ? pathToFileURL(join(pkgRoot, "dist", "resource-loader.js")).href
+      : new URL("../../../resource-loader.js", import.meta.url).href;
+    const { initResources } = await import(resourceLoaderPath);
     initResources(agentDir);
     // Open the project DB before rebuild/derive so resume uses DB-backed
     // state instead of falling back to stale markdown parsing (#2940).

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

@@ -25,6 +25,26 @@ import { getAutoWorktreePath } from "./auto-worktree.js";
 import { projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
 
+const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/gsd-pi/latest";
+const UPDATE_FETCH_TIMEOUT_MS = 5000;
+
+async function fetchLatestVersionForCommand(): Promise<string | null> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
+
+  try {
+    const res = await fetch(UPDATE_REGISTRY_URL, { signal: controller.signal });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { version?: string };
+    const latest = typeof data.version === "string" ? data.version.trim().replace(/^v/, "") : "";
+    return latest.length > 0 ? latest : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 export function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
   const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
   const workflow = readFileSync(workflowPath, "utf-8");
@@ -394,13 +414,8 @@ export async function handleUpdate(ctx: ExtensionCommandContext): Promise<void>
 
   ctx.ui.notify(`Current version: v${current}\nChecking npm registry...`, "info");
 
-  let latest: string;
-  try {
-    latest = execSync(`npm view ${NPM_PACKAGE} version`, {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
+  const latest = await fetchLatestVersionForCommand();
+  if (!latest) {
     ctx.ui.notify("Failed to reach npm registry. Check your network connection.", "error");
     return;
   }