gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

package/packages/pi-coding-agent/src/core/resource-loader-cache-reset.test.ts

@@ -0,0 +1,42 @@
+// GSD-2 — Regression test for #3616: reload() must reset jiti extension loader cache
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(
+	join(process.cwd(), "packages/pi-coding-agent/src/core/resource-loader.ts"),
+	"utf-8",
+);
+
+describe("#3616 — reload() must invalidate jiti module cache", () => {
+	test("resource-loader imports resetExtensionLoaderCache from loader.js", () => {
+		assert.ok(
+			source.includes("resetExtensionLoaderCache"),
+			"resource-loader.ts should import resetExtensionLoaderCache",
+		);
+		assert.ok(
+			source.includes('from "./extensions/loader.js"'),
+			"resetExtensionLoaderCache should be imported from extensions/loader.js",
+		);
+	});
+
+	test("reload() calls resetExtensionLoaderCache before loadExtensions", () => {
+		const reloadStart = source.indexOf("async reload(): Promise<void>");
+		assert.ok(reloadStart >= 0, "should find reload() method");
+		const reloadBody = source.slice(reloadStart, reloadStart + 4000);
+
+		const resetIdx = reloadBody.indexOf("resetExtensionLoaderCache()");
+		assert.ok(resetIdx >= 0, "reload() should call resetExtensionLoaderCache()");
+
+		const loadIdx = reloadBody.indexOf("loadExtensions(");
+		assert.ok(loadIdx >= 0, "reload() should call loadExtensions");
+
+		assert.ok(
+			resetIdx < loadIdx,
+			"resetExtensionLoaderCache() must be called BEFORE loadExtensions to ensure fresh modules",
+		);
+	});
+});

package/packages/pi-coding-agent/src/core/resource-loader.ts

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import chalk from "chalk";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { loadThemeFromPath, type Theme } from "../modes/interactive/theme/theme.js";
@@ -9,7 +9,7 @@ import type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.js";
 export type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.js";
 
 import { createEventBus, type EventBus } from "./event-bus.js";
-import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
+import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions, resetExtensionLoaderCache } from "./extensions/loader.js";
 import type { Extension, ExtensionFactory, ExtensionRuntime, LoadExtensionsResult } from "./extensions/types.js";
 import { DefaultPackageManager, type PathMetadata } from "./package-manager.js";
 import type { PromptTemplate } from "./prompt-templates.js";
@@ -121,6 +121,7 @@ export interface DefaultResourceLoaderOptions {
 	additionalPromptTemplatePaths?: string[];
 	additionalThemePaths?: string[];
 	extensionFactories?: ExtensionFactory[];
+	bundledExtensionKeys?: Set<string>;
 	noExtensions?: boolean;
 	noSkills?: boolean;
 	noPromptTemplates?: boolean;
@@ -161,6 +162,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 	private settingsManager: SettingsManager;
 	private eventBus: EventBus;
 	private packageManager: DefaultPackageManager;
+	private bundledExtensionKeys: Set<string>;
 	private additionalExtensionPaths: string[];
 	private additionalSkillPaths: string[];
 	private additionalPromptTemplatePaths: string[];
@@ -218,6 +220,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 			agentDir: this.agentDir,
 			settingsManager: this.settingsManager,
 		});
+		this.bundledExtensionKeys = options.bundledExtensionKeys ?? new Set();
 		this.additionalExtensionPaths = options.additionalExtensionPaths ?? [];
 		this.additionalSkillPaths = options.additionalSkillPaths ?? [];
 		this.additionalPromptTemplatePaths = options.additionalPromptTemplatePaths ?? [];
@@ -317,6 +320,10 @@ export class DefaultResourceLoader implements ResourceLoader {
 	}
 
 	async reload(): Promise<void> {
+		// Invalidate the shared jiti module cache so updated extension code
+		// on disk is re-compiled instead of served from the stale cache (#3616).
+		resetExtensionLoaderCache();
+
 		const resolvedPaths = await this.packageManager.resolve();
 		const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
 			temporary: true,
@@ -827,66 +834,96 @@ export class DefaultResourceLoader implements ResourceLoader {
 	}
 
 	private detectExtensionConflicts(extensions: Extension[]): Array<{ path: string; message: string }> {
-		const conflicts: Array<{ path: string; message: string }> = [];
-
-		// Track which extension registered each tool, command, and flag
-		const toolOwners = new Map<string, string>();
-		const commandOwners = new Map<string, string>();
-		const flagOwners = new Map<string, string>();
-
-		for (const ext of extensions) {
-			// Check tools
-			for (const toolName of ext.tools.keys()) {
-				const existingOwner = toolOwners.get(toolName);
-				if (existingOwner && existingOwner !== ext.path) {
-					// Determine if the existing owner is a bundled extension by checking
-					// its name against the canonical bundled extensions list
-					const ownerName = this.getExtensionNameFromPath(existingOwner);
-					const isBuiltIn = this.bundledExtensionNames.has(ownerName);
-					const hint = isBuiltIn
-						? ` (built-in tool supersedes — consider removing ${ext.path})`
-						: "";
-					conflicts.push({
-						path: ext.path,
-						message: `Tool "${toolName}" conflicts with ${existingOwner}${hint}`,
-					});
-				} else {
-					toolOwners.set(toolName, ext.path);
-				}
-			}
+		return detectExtensionConflicts(extensions, this.bundledExtensionKeys, join(this.agentDir, "extensions"));
+	}
+}
 
-			// Check commands
-			for (const commandName of ext.commands.keys()) {
-				const existingOwner = commandOwners.get(commandName);
-				if (existingOwner && existingOwner !== ext.path) {
-					const ownerName = this.getExtensionNameFromPath(existingOwner);
-					const isBuiltIn = this.bundledExtensionNames.has(ownerName);
-					const hint = isBuiltIn
-						? ` (built-in command supersedes — consider removing ${ext.path})`
-						: "";
-					conflicts.push({
-						path: ext.path,
-						message: `Command "/${commandName}" conflicts with ${existingOwner}${hint}`,
-					});
-				} else {
-					commandOwners.set(commandName, ext.path);
-				}
+/**
+ * Extract the extension directory name (key) from a full extension path.
+ * Given extensionsDir `/home/user/.gsd/agent/extensions` and
+ * ownerPath `/home/user/.gsd/agent/extensions/mcp-client/index.js`,
+ * returns `"mcp-client"`.  Returns `undefined` when the path is not
+ * under extensionsDir.
+ */
+export function extractExtensionKey(ownerPath: string, extensionsDir: string): string | undefined {
+	const normalizedDir = resolve(extensionsDir);
+	const normalizedPath = resolve(ownerPath);
+	const prefix = normalizedDir.endsWith(sep) ? normalizedDir : `${normalizedDir}${sep}`;
+	if (!normalizedPath.startsWith(prefix)) {
+		return undefined;
+	}
+	const relPath = relative(normalizedDir, normalizedPath);
+	const firstSegment = relPath.split(/[\\/]/)[0];
+	return firstSegment?.replace(/\.(?:ts|js)$/, "") || undefined;
+}
+
+/**
+ * Detect tool/command/flag name collisions across loaded extensions.
+ *
+ * When the first-registered owner of a name is a bundled extension
+ * (its key appears in `bundledExtensionKeys`), the conflict message
+ * includes a "supersedes" hint so downstream display can downgrade the
+ * severity from "Extension load error" to "Extension conflict".
+ */
+export function detectExtensionConflicts(
+	extensions: Extension[],
+	bundledExtensionKeys: Set<string>,
+	extensionsDir: string,
+): Array<{ path: string; message: string }> {
+	const conflicts: Array<{ path: string; message: string }> = [];
+
+	const toolOwners = new Map<string, string>();
+	const commandOwners = new Map<string, string>();
+	const flagOwners = new Map<string, string>();
+
+	const isBundled = (ownerPath: string): boolean => {
+		const key = extractExtensionKey(ownerPath, extensionsDir);
+		return key !== undefined && bundledExtensionKeys.has(key);
+	};
+
+	for (const ext of extensions) {
+		for (const toolName of ext.tools.keys()) {
+			const existingOwner = toolOwners.get(toolName);
+			if (existingOwner && existingOwner !== ext.path) {
+				const hint = isBundled(existingOwner)
+					? ` (built-in tool supersedes — consider removing ${ext.path})`
+					: "";
+				conflicts.push({
+					path: ext.path,
+					message: `Tool "${toolName}" conflicts with ${existingOwner}${hint}`,
+				});
+			} else {
+				toolOwners.set(toolName, ext.path);
 			}
+		}
 
-			// Check flags
-			for (const flagName of ext.flags.keys()) {
-				const existingOwner = flagOwners.get(flagName);
-				if (existingOwner && existingOwner !== ext.path) {
-					conflicts.push({
-						path: ext.path,
-						message: `Flag "--${flagName}" conflicts with ${existingOwner}`,
-					});
-				} else {
-					flagOwners.set(flagName, ext.path);
-				}
+		for (const commandName of ext.commands.keys()) {
+			const existingOwner = commandOwners.get(commandName);
+			if (existingOwner && existingOwner !== ext.path) {
+				const hint = isBundled(existingOwner)
+					? ` (built-in command supersedes — consider removing ${ext.path})`
+					: "";
+				conflicts.push({
+					path: ext.path,
+					message: `Command "/${commandName}" conflicts with ${existingOwner}${hint}`,
+				});
+			} else {
+				commandOwners.set(commandName, ext.path);
 			}
 		}
 
-		return conflicts;
+		for (const flagName of ext.flags.keys()) {
+			const existingOwner = flagOwners.get(flagName);
+			if (existingOwner && existingOwner !== ext.path) {
+				conflicts.push({
+					path: ext.path,
+					message: `Flag "--${flagName}" conflicts with ${existingOwner}`,
+				});
+			} else {
+				flagOwners.set(flagName, ext.path);
+			}
+		}
 	}
+
+	return conflicts;
 }

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

@@ -214,6 +214,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
+	// Flush extension provider registrations so extension-provided models (e.g. claude-code/*)
+	// are available in the registry before model resolution. Without this, findInitialModel()
+	// cannot find extension models and falls back to built-in providers (#3534).
+	const extensionsForModelResolution = resourceLoader.getExtensions();
+	for (const { name, config } of extensionsForModelResolution.runtime.pendingProviderRegistrations) {
+		modelRegistry.registerProvider(name, config);
+	}
+	// Clear the queue so bindCore() doesn't re-register the same providers.
+	extensionsForModelResolution.runtime.pendingProviderRegistrations = [];
+
 	// If still no model, use findInitialModel (checks settings default, then provider defaults)
 	if (!model) {
 		const result = await findInitialModel({

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.63.0",
+  "version": "2.64.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/cmux/index.ts

@@ -1,12 +1,9 @@
-import { execFile, execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { promisify } from "node:util";
 import type { GSDPreferences } from "../gsd/preferences.js";
 import type { GSDState, Phase } from "../gsd/types.js";
-
-const execFileAsync = promisify(execFile);
 const DEFAULT_SOCKET_PATH = "/tmp/cmux.sock";
 const STATUS_KEY = "gsd";
 const lastSidebarSnapshots = new Map<string, string>();
@@ -200,6 +197,7 @@ export class CmuxClient {
       return execFileSync("cmux", args, {
         encoding: "utf-8",
         timeout: 3000,
+        stdio: ["ignore", "pipe", "pipe"],
         env: process.env,
       });
     } catch {
@@ -209,16 +207,24 @@ export class CmuxClient {
 
   private async runAsync(args: string[]): Promise<string | null> {
     if (!this.canRun()) return null;
-    try {
-      const result = await execFileAsync("cmux", args, {
-        encoding: "utf-8",
-        timeout: 5000,
+    return new Promise<string | null>((resolve) => {
+      const child = spawn("cmux", args, {
+        stdio: ["ignore", "pipe", "pipe"],
         env: process.env,
       });
-      return result.stdout;
-    } catch {
-      return null;
-    }
+      const chunks: Buffer[] = [];
+      let settled = false;
+      const done = (result: string | null) => {
+        if (!settled) { settled = true; resolve(result); }
+      };
+      const timer = setTimeout(() => { child.kill(); done(null); }, 5000);
+      child.stdout!.on("data", (chunk: Buffer) => chunks.push(chunk));
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        done(code === 0 ? Buffer.concat(chunks).toString("utf-8") : null);
+      });
+      child.on("error", () => { clearTimeout(timer); done(null); });
+    });
   }
 
   getCapabilities(): unknown | null {

package/src/resources/extensions/gsd/auto/detect-stuck.ts

@@ -6,6 +6,13 @@
 
 import type { WindowEntry } from "./types.js";
 
+/**
+ * Pattern matching ENOENT errors with a file path.
+ * Matches: "ENOENT: no such file or directory, access '/path/to/file'"
+ * and similar Node.js filesystem error messages.
+ */
+const ENOENT_PATH_RE = /ENOENT[^']*'([^']+)'/;
+
 /**
  * Analyze a sliding window of recent unit dispatches for stuck patterns.
  * Returns a signal with reason if stuck, null otherwise.
@@ -13,6 +20,8 @@ import type { WindowEntry } from "./types.js";
  * Rule 1: Same error string twice in a row → stuck immediately.
  * Rule 2: Same unit key 3+ consecutive times → stuck (preserves prior behavior).
  * Rule 3: Oscillation A→B→A→B in last 4 entries → stuck.
+ * Rule 4: Same ENOENT path in any 2 entries within the window → stuck (#3575).
+ *         Missing files don't self-heal between retries — retrying wastes budget.
  */
 export function detectStuck(
   window: readonly WindowEntry[],
@@ -56,5 +65,23 @@ export function detectStuck(
     }
   }
 
+  // Rule 4: Same ENOENT path seen twice in window (#3575)
+  // Missing files don't appear between retries — stop immediately.
+  const enoentPaths = new Map<string, number>();
+  for (const entry of window) {
+    if (!entry.error) continue;
+    const match = ENOENT_PATH_RE.exec(entry.error);
+    if (!match) continue;
+    const filePath = match[1];
+    const count = (enoentPaths.get(filePath) ?? 0) + 1;
+    if (count >= 2) {
+      return {
+        stuck: true,
+        reason: `Missing file referenced twice: ${filePath} (ENOENT)`,
+      };
+    }
+    enoentPaths.set(filePath, count);
+  }
+
   return null;
 }

package/src/resources/extensions/gsd/auto/finalize-timeout.ts

@@ -0,0 +1,46 @@
+/**
+ * auto/finalize-timeout.ts — Timeout guard for post-unit finalization.
+ *
+ * Prevents the auto-loop from hanging indefinitely when
+ * postUnitPostVerification() never resolves (#2344).
+ *
+ * Leaf module — no imports from auto/ to avoid circular dependencies.
+ */
+
+/** Timeout for postUnitPostVerification in runFinalize (ms). */
+export const FINALIZE_POST_TIMEOUT_MS = 60_000;
+
+/**
+ * Race a promise against a timeout. Returns an object indicating whether
+ * the timeout fired and the resolved value (if any).
+ *
+ * Unlike Promise.race with a rejection, this returns a discriminated
+ * result so callers can handle timeouts as a recoverable condition
+ * rather than an exception.
+ *
+ * The timeout timer is always cleaned up, whether the promise resolves
+ * or the timeout fires.
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  label: string,
+): Promise<{ value: T; timedOut: false } | { value: undefined; timedOut: true }> {
+  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+
+  const timeoutPromise = new Promise<{ value: undefined; timedOut: true }>((resolve) => {
+    timeoutHandle = setTimeout(() => {
+      resolve({ value: undefined, timedOut: true });
+    }, timeoutMs);
+  });
+
+  try {
+    const result = await Promise.race([
+      promise.then((value) => ({ value, timedOut: false as const })),
+      timeoutPromise,
+    ]);
+    return result;
+  } finally {
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+  }
+}

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

@@ -259,6 +259,11 @@ export async function autoLoop(
       // ── Blanket catch: absorb unexpected exceptions, apply graduated recovery ──
       const msg = loopErr instanceof Error ? loopErr.message : String(loopErr);
 
+      // Always emit iteration-end on error so the journal records iteration
+      // completion even on failure (#2344). Without this, errors in
+      // runFinalize leave the journal incomplete, making diagnosis harder.
+      deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration, error: msg } });
+
       // ── Infrastructure errors: immediate stop, no retry ──
       // These are unrecoverable (disk full, OOM, etc.). Retrying just burns
       // LLM budget on guaranteed failures.