@opengsd/gsd-pi 1.0.2-dev.d456457 → 1.0.2-dev.dbfb371

package/README.md

@@ -13,6 +13,28 @@ GSD Pi is a local-first coding agent for planning, implementing, verifying, and
 
 It combines a terminal agent, project workflow tools, worktree-aware Git automation, and optional UI integrations so a project can move from idea to reviewed implementation with less manual coordination.
 
+## Screenshots
+
+GSD runs as a terminal-first TUI with optional browser dashboard controls.
+
+![GSD TUI running an agent workflow](./docs/assets/screenshots/gsd-tui-agent-run.png)
+
+![GSD TUI progress dashboard](./docs/assets/screenshots/gsd-tui-progress-dashboard.png)
+
+![GSD TUI metrics dashboard](./docs/assets/screenshots/gsd-tui-metrics-dashboard.png)
+
+## Feature Roll-Up
+
+- **Guided terminal agent** — Start with `gsd`, configure providers, and run planned or quick coding sessions from your shell.
+- **Autonomous project workflow** — Break work into milestones, slices, and tasks, then let auto mode plan, implement, verify, and advance.
+- **Worktree-aware Git automation** — Keep implementation work isolated while preserving a reviewable main checkout.
+- **Local project memory** — Store project requirements, decisions, runtime notes, generated plans, summaries, and validation evidence under `.gsd/`.
+- **Multi-provider model routing** — Use the provider your team already has, with configurable defaults and per-phase model preferences.
+- **Extension surface** — Add project-specific commands, tools, skills, and UI integrations through bundled or community extensions.
+- **Terminal and web surfaces** — Use the TUI by default, or launch `gsd --web` when a visual control plane fits the work better than a terminal.
+
+See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Release History](./docs/archive/legacy-release-history.md) for archived history before the `open-gsd/gsd-pi` baseline.
+
 ## Status
 
 This repository is starting a new development baseline at version `1.0.0` under the `open-gsd/gsd-pi` project.
@@ -27,41 +49,63 @@ Recommended — guided installer:
 npx @opengsd/gsd-pi@latest
 ```
 
-Alternative — direct global install:
+For CI or scripted installs:
+
+```bash
+npx @opengsd/gsd-pi@latest --yes
+```
+
+Alternative — direct npm global install:
 
 ```bash
 npm install -g @opengsd/gsd-pi@latest
 ```
 
-For CI or scripted installs:
+If you want pnpm to own the global install, use pnpm's runner:
 
 ```bash
-npx @opengsd/gsd-pi@latest --yes
+pnpm setup
+exec $SHELL -l
+pnpm dlx @opengsd/gsd-pi@latest
 ```
 
 Source: [`open-gsd/gsd-pi`](https://github.com/open-gsd/gsd-pi).
 
 ## Migrate From Older Installs
 
-GSD Pi now installs from the scoped npm package `@opengsd/gsd-pi`. If you previously installed the older unscoped `gsd-pi` package, remove it first so the old global binary does not shadow the new package.
+GSD Pi now installs from the scoped package `@opengsd/gsd-pi`. If you previously installed the older unscoped `gsd-pi` package, remove it first so the old global binary does not shadow the new package.
 
-macOS / Linux:
+Recommended migration with the guided `npx` installer:
 
 ```bash
-npm uninstall -g gsd-pi
+npm uninstall -g gsd-pi @opengsd/gsd-pi
 rm -f ~/.gsd/.update-check ~/.gsd/agent/managed-resources.json
-npm install -g @opengsd/gsd-pi@latest
-which gsd
+npx @opengsd/gsd-pi@latest
+command -v gsd
 gsd --version
 ```
 
-Windows PowerShell:
+If the old package was installed with `sudo npm install -g`, use `sudo npm uninstall -g gsd-pi` for the old package removal.
+
+To migrate from old npm globals to a pnpm-owned global install:
+
+```bash
+npm uninstall -g gsd-pi @opengsd/gsd-pi
+rm -f ~/.gsd/.update-check ~/.gsd/agent/managed-resources.json
+pnpm setup
+exec $SHELL -l
+pnpm dlx @opengsd/gsd-pi@latest
+command -v gsd
+gsd --version
+```
+
+Windows PowerShell with the guided `npx` installer:
 
 ```powershell
-npm uninstall -g gsd-pi
+npm uninstall -g gsd-pi @opengsd/gsd-pi
 Remove-Item "$env:USERPROFILE\.gsd\.update-check" -Force -ErrorAction SilentlyContinue
 Remove-Item "$env:USERPROFILE\.gsd\agent\managed-resources.json" -Force -ErrorAction SilentlyContinue
-npm install -g @opengsd/gsd-pi@latest
+npx @opengsd/gsd-pi@latest
 where.exe gsd
 gsd --version
 ```
@@ -85,6 +129,14 @@ npm uninstall -g @opengsd/gsd-pi gsd-pi
 rm -rf ~/.gsd
 ```
 
+If you installed GSD with pnpm, use pnpm for the pnpm-owned package. If pnpm reports that its global bin directory is not on `PATH`, run `pnpm setup`, restart your shell, then retry.
+
+```bash
+pnpm remove -g @opengsd/gsd-pi
+npm uninstall -g gsd-pi
+rm -rf ~/.gsd
+```
+
 Windows PowerShell:
 
 ```powershell
@@ -139,7 +191,6 @@ Then use slash commands inside the GSD session:
 | `native/` | Native engine packaging and platform binaries |
 | `studio/` | Desktop studio app |
 | `web/` | Web UI and API surface |
-| `vscode-extension/` | VS Code integration |
 | `docs/` | User and developer documentation |
 | `scripts/` | Build, release, migration, and maintenance scripts |
 

package/dist/resource-loader.d.ts

@@ -33,6 +33,11 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  * 4. Makes the result writable for the next upgrade cycle.
  */
 export declare function syncResourceDir(srcDir: string, destDir: string): void;
+export declare function resolvePackageNodeModulesLayout(root: string): {
+    internalNodeModules: string;
+    hoistedNodeModules: string | null;
+};
+export declare function findNearestNodeModulesAncestor(startPath: string): string | null;
 /** Check if any GSD workspace scopes exist in internal but not in hoisted node_modules */
 export declare function hasMissingWorkspaceScopes(hoisted: string, internal: string): boolean;
 /**

package/dist/resource-loader.js

@@ -311,16 +311,15 @@ function copyDirRecursive(src, dest) {
  * them without requiring every call site to use jiti.
  *
  * Layout differences by install method:
- * - Source/monorepo: packageRoot/node_modules has everything → simple symlink
- * - Global install (npm/bun/pnpm): merge hoisted dirname(packageRoot)/node_modules with
- *   packageRoot/node_modules so package-local deps like @sinclair/typebox resolve (#3529, #3564)
+ * - Source/monorepo: packageRoot/node_modules has everything -> simple symlink
+ * - Global install (npm/bun/pnpm): merge the nearest ancestor node_modules
+ *   with packageRoot/node_modules so both hoisted deps like yaml and
+ *   package-local deps like @sinclair/typebox resolve (#3529, #3564).
  */
 function ensureNodeModulesSymlink(agentDir) {
     const agentNodeModules = join(agentDir, 'node_modules');
-    const internalNodeModules = join(packageRoot, 'node_modules');
-    const hoistedNodeModules = dirname(packageRoot);
-    const isGlobalInstall = basename(hoistedNodeModules) === 'node_modules';
-    if (!isGlobalInstall) {
+    const { internalNodeModules, hoistedNodeModules } = resolvePackageNodeModulesLayout(packageRoot);
+    if (!hoistedNodeModules) {
         // Source/monorepo: internal node_modules has everything
         reconcileSymlink(agentNodeModules, internalNodeModules);
         return;
@@ -330,6 +329,23 @@ function ensureNodeModulesSymlink(agentDir) {
     // @gsd/* scopes are hoisted — a hoisted-only symlink breaks extension imports.
     reconcileMergedNodeModules(agentNodeModules, hoistedNodeModules, internalNodeModules);
 }
+export function resolvePackageNodeModulesLayout(root) {
+    return {
+        internalNodeModules: join(root, 'node_modules'),
+        hoistedNodeModules: findNearestNodeModulesAncestor(root),
+    };
+}
+export function findNearestNodeModulesAncestor(startPath) {
+    let current = resolve(startPath);
+    while (true) {
+        if (basename(current) === 'node_modules')
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
 /** Check if any GSD workspace scopes exist in internal but not in hoisted node_modules */
 export function hasMissingWorkspaceScopes(hoisted, internal) {
     if (!existsSync(internal))
@@ -627,7 +643,7 @@ function cleanupBundledSkillsFromEcosystemDir() {
                 makeTreeWritable(targetPath);
                 rmSync(targetPath, { recursive: true, force: true });
             }
-            else {
+            else if (process.env.GSD_RESOURCE_LOADER_DEBUG === '1') {
                 console.warn(`[GSD] Leaving ambiguous skill collision in ${targetPath}; ` +
                     `the bundled copy will be used from ~/.gsd/agent/skills/${entry.name}.`);
             }

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-f796c99ee5d78c73
+9d6ff59a3cc348a6

package/dist/resources/extensions/gsd/auto/loop.js

@@ -50,6 +50,7 @@ import { handleCustomEngineVerifyPause, handleCustomEngineVerifyRetryOutcome, }
 import { handleCustomEngineReconcile } from "./workflow-custom-engine-reconcile.js";
 import { handleCustomEngineReconcileOutcome } from "./workflow-custom-engine-reconcile-outcome.js";
 import { formatLeaseConflictNotice } from "./lease-conflict-notice.js";
+import { setAutoOutcomeWidget, unitVerb } from "../auto-dashboard.js";
 /**
  * Returns true if workerId is an active worker in this project whose OS
  * process no longer exists. Used to detect dead lease holders before
@@ -690,6 +691,24 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 });
                 if (reconcileFlow.action === "break")
                     break;
+                if (s.stepMode) {
+                    if (ctx.hasUI) {
+                        ctx.ui.setWidget?.("gsd-progress", undefined);
+                        setAutoOutcomeWidget(ctx, {
+                            status: "step",
+                            title: "Step complete",
+                            detail: `Completed ${unitVerb(iterData.unitType)} ${iterData.unitId}.`,
+                            unitLabel: `${unitVerb(iterData.unitType)} ${iterData.unitId}`,
+                            nextAction: "Advance one step, or resume automatic mode.",
+                            commands: ["/gsd next", "/gsd auto", "/gsd status for overview"],
+                            startedAt: s.autoStartTime,
+                        });
+                    }
+                    ctx.ui.setStatus("gsd-auto", "next");
+                    ctx.ui.notify(`Step complete: ${unitVerb(iterData.unitType)} ${iterData.unitId}. Run /gsd next for the next step, or /gsd auto to continue automatically.`, "info");
+                    s.preserveStepSurfaceAfterLoopExit = true;
+                    break;
+                }
                 continue;
             }
             if (!sidecarItem) {

package/dist/resources/extensions/gsd/auto/phases.js

@@ -1568,7 +1568,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const dispatchKey = `${unitType}/${unitId}`;
     const nextDispatchCount = (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1;
     // Status bar (widget + preconditions deferred until after model selection — see #2899)
-    ctx.ui.setStatus("gsd-auto", "auto");
+    ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
     if (mid)
         deps.updateSliceProgressCache(s.basePath, mid, state.activeSlice?.id);
     // ── Safety harness: reset evidence + create checkpoint ──

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -23,6 +23,7 @@ import { debugLog } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, nativeWorktreeList, nativeLsFiles, } from "./native-git-bridge.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace } from "./workspace.js";
@@ -796,60 +797,7 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
 export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
     return _finalizeProjectionForMergeImpl(mainBasePath, worktreePath, milestoneId);
 }
-// ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
-/**
- * Run the user-configured post-create hook script after worktree creation.
- * The script receives SOURCE_DIR and WORKTREE_DIR as environment variables.
- * Failure is non-fatal — returns the error message or null on success.
- *
- * Reads the hook path from git.worktree_post_create in preferences.
- * Pass hookPath directly to bypass preference loading (useful for testing).
- */
-export function runWorktreePostCreateHook(sourceDir, worktreeDir, hookPath) {
-    if (hookPath === undefined) {
-        const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
-        hookPath = prefs?.worktree_post_create;
-    }
-    if (!hookPath)
-        return null;
-    // Resolve relative paths against the source project root.
-    // On Windows, convert 8.3 short paths (e.g. RUNNER~1) to long paths
-    // so execFileSync can locate the file correctly.
-    let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
-    if (!existsSync(resolved)) {
-        return `Worktree post-create hook not found: ${resolved}`;
-    }
-    if (process.platform === "win32") {
-        try {
-            resolved = realpathSync.native(resolved);
-        }
-        catch (err) { /* keep original */
-            logWarning("worktree", `realpath failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    try {
-        // .bat/.cmd files on Windows require shell mode — execFileSync cannot
-        // spawn them directly (EINVAL).
-        const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
-        execFileSync(resolved, [], {
-            cwd: worktreeDir,
-            env: {
-                ...process.env,
-                SOURCE_DIR: sourceDir,
-                WORKTREE_DIR: worktreeDir,
-            },
-            stdio: ["ignore", "pipe", "pipe"],
-            encoding: "utf-8",
-            timeout: 30_000, // 30 second timeout
-            shell: needsShell,
-        });
-        return null;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return `Worktree post-create hook failed: ${msg}`;
-    }
-}
+export { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 // ─── Auto-Worktree Branch Naming ───────────────────────────────────────────
 /** Returns the git branch name for a milestone worktree (`milestone/<MID>`). */
 export function autoWorktreeBranch(milestoneId) {

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

@@ -418,6 +418,17 @@ function initSessionNotifications(ctx) {
     installNotifyInterceptor(ctx);
     initNotificationWidget(ctx);
 }
+async function prepareWorkflowMcpForHookContext(ctx, basePath) {
+    // Skip MCP auto-prep when running inside an auto-worktree. The worktree
+    // already has .mcp.json from createAutoWorktree, and re-running the writer
+    // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
+    // CLI path resolution), dirtying the tree and breaking the milestone merge.
+    const { isInAutoWorktree } = await import("../auto-worktree.js");
+    if (isInAutoWorktree(basePath))
+        return;
+    const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+    prepareWorkflowMcpForProject(ctx, basePath);
+}
 export function registerHooks(pi, ecosystemHandlers) {
     // ADR-005 Phase 3b: surface pi-ai ProviderSwitchReport via audit, notification, and counter.
     // Idempotent — only the first registerHooks call installs.
@@ -438,12 +449,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
         await applyCompactionThresholdOverride(ctx);
-        // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
-        const { isInAutoWorktree } = await import("../auto-worktree.js");
-        if (!isInAutoWorktree(basePath)) {
-            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-            prepareWorkflowMcpForProject(ctx, basePath);
-        }
+        await prepareWorkflowMcpForHookContext(ctx, basePath);
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -468,15 +474,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
         await applyCompactionThresholdOverride(ctx);
-        // Skip MCP auto-prep when running inside an auto-worktree. The worktree
-        // already has .mcp.json from createAutoWorktree, and re-running the writer
-        // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
-        // CLI path resolution), dirtying the tree and breaking the milestone merge.
-        const { isInAutoWorktree } = await import("../auto-worktree.js");
-        if (!isInAutoWorktree(basePath)) {
-            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-            prepareWorkflowMcpForProject(ctx, basePath);
-        }
+        await prepareWorkflowMcpForHookContext(ctx, basePath);
         await loadToolApiKeysForSession();
         if (!isAutoActive()) {
             ctx.ui.setWidget("gsd-progress", undefined);
@@ -511,6 +509,10 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         clearDeferredApprovalGate(beforeAgentBasePath);
+        // session_start can fire before the active provider has settled. By
+        // before_agent_start, Claude Code CLI sessions should get the same
+        // project MCP config that /gsd mcp init would write.
+        await prepareWorkflowMcpForHookContext(ctx, beforeAgentBasePath);
         // GSD's own context injection (existing behavior — unchanged).
         const { buildBeforeAgentStartResult } = await import("./system-context.js");
         const gsdResult = await buildBeforeAgentStartResult(event, ctx);

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

@@ -17,6 +17,7 @@ import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import { buildDoctorHealIssuePayload, buildDoctorHealSummary, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
 import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
@@ -42,6 +43,8 @@ function isBunInstall(argv1 = process.argv[1]) {
 function resolveInstallCommand(pkg) {
     if (isBunInstall())
         return `bun add -g ${pkg}`;
+    if (isPnpmInstall())
+        return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
 async function fetchLatestVersionForCommand() {

package/dist/resources/extensions/gsd/worktree-post-create-hook.js

@@ -0,0 +1,117 @@
+// Project/App: gsd-pi
+// File Purpose: Lightweight worktree post-create hook runner.
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { gsdHome } from "./gsd-home.js";
+import { gsdRoot } from "./paths.js";
+function readPreferencesObject(path) {
+    if (!existsSync(path))
+        return null;
+    const content = readFileSync(path, "utf-8");
+    try {
+        const startMarker = content.startsWith("---\r\n") ? "---\r\n" : "---\n";
+        if (content.startsWith(startMarker)) {
+            const searchStart = startMarker.length;
+            const endIdx = content.indexOf("\n---", searchStart);
+            if (endIdx === -1)
+                return null;
+            const parsed = parseYaml(content.slice(searchStart, endIdx).replace(/\r/g, ""));
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        }
+        const gitLines = [];
+        let inGitSection = false;
+        for (const rawLine of content.split("\n")) {
+            const line = rawLine.replace(/\r$/, "");
+            const heading = line.match(/^##\s+(.+)$/);
+            if (heading) {
+                inGitSection = heading[1].trim().toLowerCase().replace(/\s+/g, "_") === "git";
+                continue;
+            }
+            if (inGitSection && line.trim() && !line.trimStart().startsWith("#")) {
+                gitLines.push(line.replace(/^\s*-\s*/, ""));
+            }
+        }
+        if (gitLines.length === 0)
+            return null;
+        const parsed = parseYaml(gitLines.join("\n"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? { git: parsed }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractHookPath(preferences) {
+    const git = preferences?.git;
+    if (!git || typeof git !== "object" || Array.isArray(git))
+        return null;
+    const hookPath = git.worktree_post_create;
+    return typeof hookPath === "string" && hookPath.trim() ? hookPath : null;
+}
+function resolveConfiguredHookPath(sourceDir) {
+    const paths = [
+        join(homedir(), ".pi", "agent", "gsd-preferences.md"),
+        join(gsdHome(), "preferences.md"),
+        join(gsdHome(), "PREFERENCES.md"),
+        join(gsdRoot(sourceDir), "preferences.md"),
+        join(gsdRoot(sourceDir), "PREFERENCES.md"),
+    ];
+    let hookPath = null;
+    for (const path of paths) {
+        hookPath = extractHookPath(readPreferencesObject(path)) ?? hookPath;
+    }
+    return hookPath;
+}
+/**
+ * Run the user-configured post-create hook script after worktree creation.
+ * The script receives SOURCE_DIR and WORKTREE_DIR as environment variables.
+ * Failure is non-fatal -- returns the error message or null on success.
+ *
+ * Reads git.worktree_post_create from effective global/project preferences
+ * unless hookPath is provided directly.
+ */
+export function runWorktreePostCreateHook(sourceDir, worktreeDir, hookPath) {
+    if (hookPath === undefined) {
+        hookPath = resolveConfiguredHookPath(sourceDir) ?? undefined;
+    }
+    if (!hookPath)
+        return null;
+    let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
+    if (!existsSync(resolved)) {
+        return `Worktree post-create hook not found: ${resolved}`;
+    }
+    if (process.platform === "win32") {
+        try {
+            resolved = realpathSync.native(resolved);
+        }
+        catch {
+            // Keep the original path; the exec error below will include the failure.
+        }
+    }
+    try {
+        const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
+        execFileSync(resolved, [], {
+            cwd: worktreeDir,
+            env: {
+                ...process.env,
+                SOURCE_DIR: sourceDir,
+                WORKTREE_DIR: worktreeDir,
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            timeout: 30_000,
+            shell: needsShell,
+        });
+        return null;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `Worktree post-create hook failed: ${msg}`;
+    }
+}

package/dist/resources/shared/package-manager-detection.js

@@ -0,0 +1,36 @@
+import { homedir } from 'node:os';
+import { join, resolve as resolvePath, sep } from 'node:path';
+function hasPnpmPath(value) {
+    if (!value)
+        return false;
+    const normalized = value.replace(/\\/g, '/').toLowerCase();
+    return (normalized.includes('/.pnpm/') ||
+        normalized.endsWith('/pnpm') ||
+        normalized.endsWith('/pnpm.cjs') ||
+        normalized.endsWith('/pnpm.js'));
+}
+function pathStartsWith(pathValue, dir) {
+    if (!pathValue)
+        return false;
+    const resolvedPath = resolvePath(pathValue);
+    const resolvedDir = resolvePath(dir);
+    return resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + sep);
+}
+// Shared by update-check.ts and gsd command handlers. The JS installer keeps a
+// parallel copy because it runs before TypeScript output exists.
+export function isPnpmInstall(argv1 = process.argv[1], env = process.env) {
+    if (env.npm_config_user_agent?.startsWith('pnpm/'))
+        return true;
+    if (hasPnpmPath(env.npm_execpath))
+        return true;
+    if (hasPnpmPath(argv1))
+        return true;
+    if (!argv1)
+        return false;
+    const pnpmBinDirs = [];
+    if (env.PNPM_HOME)
+        pnpmBinDirs.push(env.PNPM_HOME);
+    pnpmBinDirs.push(join(homedir(), 'Library', 'pnpm'));
+    pnpmBinDirs.push(join(homedir(), '.local', 'share', 'pnpm'));
+    return pnpmBinDirs.some((dir) => pathStartsWith(argv1, dir) || pathStartsWith(env.npm_execpath, dir));
+}

package/dist/update-check.d.ts

@@ -1,3 +1,5 @@
+import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
+export { isPnpmInstall };
 interface UpdateCheckCache {
     lastCheck: number;
     latestVersion: string;
@@ -22,7 +24,10 @@ export declare function fetchLatestVersionFromRegistry(registryUrl?: string, fet
  * (PR #4147) misses this path. Inspect the unresolved invocation path instead.
  */
 export declare function isBunInstall(argv1?: string | undefined): boolean;
-export declare function resolveInstallCommand(pkg: string): string;
+export declare function resolveInstallCommand(pkg: string, options?: {
+    argv1?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
 export interface UpdateCheckOptions {
     currentVersion?: string;
     cachePath?: string;
@@ -45,4 +50,3 @@ export declare function checkForUpdates(options?: UpdateCheckOptions): Promise<v
  * Returns true if an update was performed, false otherwise.
  */
 export declare function checkAndPromptForUpdates(options?: UpdateCheckOptions): Promise<boolean>;
-export {};

package/dist/update-check.js

@@ -1,9 +1,11 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { dirname, join, resolve as resolvePath, sep } from 'node:path';
 import { homedir } from 'node:os';
 import chalk from 'chalk';
 import { appRoot } from './app-paths.js';
-import { execSync } from 'node:child_process';
+import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
+export { isPnpmInstall };
 const CACHE_FILE = join(appRoot, '.update-check');
 const NPM_PACKAGE_NAME = '@opengsd/gsd-pi';
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -91,9 +93,11 @@ export function isBunInstall(argv1 = process.argv[1]) {
     const resolved = resolvePath(argv1);
     return bunBinDirs.some((dir) => resolved.startsWith(resolvePath(dir) + sep));
 }
-export function resolveInstallCommand(pkg) {
-    if (isBunInstall())
+export function resolveInstallCommand(pkg, options = {}) {
+    if (isBunInstall(options.argv1))
         return `bun add -g ${pkg}`;
+    if (isPnpmInstall(options.argv1, options.env))
+        return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
 function printUpdateBanner(current, latest) {

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

@@ -1 +1 @@
-4NVKiVx4C-8FUT9A7DZdq
+BVrLsL82ynrLee5zxeihC

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -2,13 +2,13 @@
   "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
   "/api/boot/route": "/api/boot",
+  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
+  "/api/browse-directories/route": "/api/browse-directories",
+  "/api/dev-mode/route": "/api/dev-mode",
   "/api/cleanup/route": "/api/cleanup",
   "/api/captures/route": "/api/captures",
-  "/api/dev-mode/route": "/api/dev-mode",
-  "/api/browse-directories/route": "/api/browse-directories",
-  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/doctor/route": "/api/doctor",
   "/api/export-data/route": "/api/export-data",
   "/api/experimental/route": "/api/experimental",
@@ -18,23 +18,23 @@
   "/api/hooks/route": "/api/hooks",
   "/api/inspect/route": "/api/inspect",
   "/api/knowledge/route": "/api/knowledge",
+  "/api/files/route": "/api/files",
   "/api/live-state/route": "/api/live-state",
   "/api/mcp-connections/route": "/api/mcp-connections",
   "/api/notifications/route": "/api/notifications",
-  "/api/files/route": "/api/files",
-  "/api/preferences/route": "/api/preferences",
   "/api/onboarding/route": "/api/onboarding",
+  "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
   "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
   "/api/session/events/route": "/api/session/events",
-  "/api/settings-data/route": "/api/settings-data",
   "/api/session/manage/route": "/api/session/manage",
+  "/api/settings-data/route": "/api/settings-data",
   "/api/shutdown/route": "/api/shutdown",
-  "/api/remote-questions/route": "/api/remote-questions",
   "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
+  "/api/remote-questions/route": "/api/remote-questions",
   "/api/terminal/input/route": "/api/terminal/input",
   "/api/switch-root/route": "/api/switch-root",
   "/api/terminal/resize/route": "/api/terminal/resize",

package/dist/web/standalone/.next/build-manifest.json

@@ -4,8 +4,8 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/4NVKiVx4C-8FUT9A7DZdq/_buildManifest.js",
-    "static/4NVKiVx4C-8FUT9A7DZdq/_ssgManifest.js"
+    "static/BVrLsL82ynrLee5zxeihC/_buildManifest.js",
+    "static/BVrLsL82ynrLee5zxeihC/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-41a6d3c17ba63b62.js",