gsd-pi 2.73.0 → 2.73.1-dev.088d28f

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -6,6 +6,7 @@ import { debugTime } from "../debug-logger.js";
 import { loadPrompt, getTemplatesDir } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
 import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
@@ -147,7 +148,11 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     // Re-inject forensics context on follow-up turns (#2941)
     const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd(), event.prompt) : null;
     const worktreeBlock = buildWorktreeContextBlock();
-    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
+    const subagentModelConfig = resolveModelWithFallbacksForUnit("subagent");
+    const subagentModelBlock = subagentModelConfig
+        ? `\n\n## Subagent Model\n\nWhen spawning subagents via the \`subagent\` tool, always pass \`model: "${subagentModelConfig.primary}"\` in the tool call parameters. Never omit this — always specify it explicitly.`
+        : "";
+    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
     stopContextTimer({
         systemPromptSize: fullSystem.length,
         injectionSize: injection?.length ?? forensicsInjection?.length ?? 0,

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

@@ -17,6 +17,11 @@ 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;
+function resolveInstallCommand(pkg) {
+    if ('bun' in process.versions)
+        return `bun add -g ${pkg}`;
+    return `npm install -g ${pkg}`;
+}
 async function fetchLatestVersionForCommand() {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
@@ -344,13 +349,14 @@ export async function handleUpdate(ctx) {
         return;
     }
     ctx.ui.notify(`Updating: v${current} → v${latest}...`, "info");
+    const installCmd = resolveInstallCommand(`${NPM_PACKAGE}@latest`);
     try {
-        execSync(`npm install -g ${NPM_PACKAGE}@latest`, {
+        execSync(installCmd, {
             stdio: ["ignore", "pipe", "ignore"],
         });
         ctx.ui.notify(`Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
     }
     catch {
-        ctx.ui.notify(`Update failed. Try manually: npm install -g ${NPM_PACKAGE}@latest`, "error");
+        ctx.ui.notify(`Update failed. Try manually: ${installCmd}`, "error");
     }
 }

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -14,6 +14,7 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
+import { emitJournalEvent, queryJournal } from "./journal.js";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
 }
@@ -110,3 +111,53 @@ export function formatCrashInfo(lock) {
     }
     return lines.join("\n");
 }
+/**
+ * Emit a synthetic unit-end event for a unit that crashed without emitting its own.
+ *
+ * Queries the journal to find the most recent unit-start for the crashed unit.
+ * If a matching unit-end already exists (e.g. the hard timeout fired), this is a
+ * no-op. Called during crash recovery, before clearing the stale lock.
+ *
+ * Addresses the gap reported in #3348 where `unit-start` was emitted but no
+ * `unit-end` followed — side effects landed but the worker died before closeout.
+ */
+export function emitCrashRecoveredUnitEnd(basePath, lock) {
+    // Skip bootstrap / starting pseudo-units — they have no meaningful unit-start event.
+    if (!lock.unitType || !lock.unitId || lock.unitType === "starting")
+        return;
+    try {
+        const all = queryJournal(basePath);
+        // Find the most recent unit-start for this unitId
+        const starts = all.filter((e) => e.eventType === "unit-start" && e.data?.unitId === lock.unitId);
+        if (starts.length === 0)
+            return;
+        const lastStart = starts[starts.length - 1];
+        // Check if a unit-end was already emitted (e.g. hard timeout fired after the crash)
+        const alreadyClosed = all.some((e) => e.eventType === "unit-end" &&
+            e.data?.unitId === lock.unitId &&
+            e.causedBy?.flowId === lastStart.flowId &&
+            e.causedBy?.seq === lastStart.seq);
+        if (alreadyClosed)
+            return;
+        // Find the highest seq in this flow for monotonic ordering
+        const maxSeq = all
+            .filter((e) => e.flowId === lastStart.flowId)
+            .reduce((max, e) => Math.max(max, e.seq), lastStart.seq);
+        emitJournalEvent(basePath, {
+            ts: new Date().toISOString(),
+            flowId: lastStart.flowId,
+            seq: maxSeq + 1,
+            eventType: "unit-end",
+            data: {
+                unitType: lock.unitType,
+                unitId: lock.unitId,
+                status: "crash-recovered",
+                artifactVerified: false,
+            },
+            causedBy: { flowId: lastStart.flowId, seq: lastStart.seq },
+        });
+    }
+    catch {
+        // Never throw from crash recovery path — journal failure must not block recovery
+    }
+}

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -157,7 +157,7 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `phases`: fine-grained control over which phases run. Usually set by `token_profile`, but can be overridden. Keys:
   - `skip_research`: boolean — skip milestone-level research. Default: `false`.
-  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `false`.
+  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `true`.
   - `skip_reassess`: boolean — force-disable roadmap reassessment even if `reassess_after_slice` is enabled. Default: `false`.
   - `skip_slice_research`: boolean — skip per-slice research. Default: `false`.
 

package/dist/resources/extensions/gsd/gsd-db.js

@@ -1352,6 +1352,25 @@ export function setSliceSummaryMd(milestoneId, sliceId, summaryMd, uatMd) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId, ":summary_md": summaryMd, ":uat_md": uatMd });
 }
+function parseTaskArrayColumn(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.map((value) => String(value));
+        if (parsed === null || parsed === undefined || parsed === "")
+            return [];
+        return [String(parsed)];
+    }
+    catch {
+        // Older/corrupt rows may contain comma-separated strings instead of JSON.
+        return raw
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+    }
+}
 function rowToTask(row) {
     const parseTaskArray = (value) => {
         if (Array.isArray(value)) {
@@ -1390,8 +1409,8 @@ function rowToTask(row) {
         blocker_discovered: row["blocker_discovered"] === 1,
         deviations: row["deviations"],
         known_issues: row["known_issues"],
-        key_files: JSON.parse(row["key_files"] || "[]"),
-        key_decisions: JSON.parse(row["key_decisions"] || "[]"),
+        key_files: parseTaskArrayColumn(row["key_files"]),
+        key_decisions: parseTaskArrayColumn(row["key_decisions"]),
         full_summary_md: row["full_summary_md"],
         description: row["description"] ?? "",
         estimate: row["estimate"] ?? "",
@@ -1855,6 +1874,21 @@ export function deleteSlice(milestoneId, sliceId) {
         currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
     });
 }
+export function deleteMilestone(milestoneId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    transaction(() => {
+        currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM quality_gates WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM slice_dependencies WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM replan_history WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM assessments WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM artifacts WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM milestones WHERE id = :mid`).run({ ":mid": milestoneId });
+    });
+}
 export function updateSliceFields(milestoneId, sliceId, fields) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -15,7 +15,8 @@ import { join } from "node:path";
 import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
-import { getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
@@ -99,12 +100,29 @@ export function discardMilestone(basePath, milestoneId) {
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
+    try {
+        removeWorktree(basePath, milestoneId, {
+            branch: `milestone/${milestoneId}`,
+            deleteBranch: true,
+        });
+    }
+    catch (err) {
+        logWarning("engine", `discardMilestone worktree cleanup failed for ${milestoneId}: ${err.message}`);
+    }
     rmSync(mDir, { recursive: true, force: true });
     // Prune from queue order if present
     const order = loadQueueOrder(basePath);
     if (order && order.includes(milestoneId)) {
         saveQueueOrder(basePath, order.filter(id => id !== milestoneId));
     }
+    if (isDbAvailable()) {
+        try {
+            deleteMilestone(milestoneId);
+        }
+        catch (err) {
+            logWarning("engine", `discardMilestone DB cleanup failed for ${milestoneId}: ${err.message}`);
+        }
+    }
     invalidateAllCaches();
     return true;
 }

package/dist/resources/extensions/gsd/notification-widget.js

@@ -1,6 +1,6 @@
 // GSD Extension — Notification Widget
 // Always-on ambient widget rendered belowEditor showing unread count and
-// the most recent notification message. Refreshes every 5 seconds.
+// the most recent notification message. Refreshes every 30 seconds.
 // Widget key: "gsd-notifications", placement: "belowEditor"
 import { getUnreadCount, onNotificationStoreChange } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
@@ -12,7 +12,7 @@ export function buildNotificationWidgetLines() {
     return [`  🔔 Notifications: ${unread} unread  (${formattedShortcutPair("notifications")})`];
 }
 // ─── Widget init ────────────────────────────────────────────────────────
-const REFRESH_INTERVAL_MS = 5_000;
+const REFRESH_INTERVAL_MS = 30_000;
 /**
  * Initialize the always-on notification widget (belowEditor).
  * Call once from session_start after the notification store is initialized.

package/dist/resources/extensions/gsd/preferences-models.js

@@ -6,6 +6,8 @@
  * and dynamic routing configuration.
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { defaultRoutingConfig } from "./model-router.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 /**
@@ -161,6 +163,47 @@ export function resolveDefaultSessionModel(sessionProvider) {
     }
     return undefined;
 }
+/**
+ * Returns true if `provider` is defined as a custom provider in the user's
+ * `~/.gsd/agent/models.json` (Ollama, vLLM, LM Studio, OpenAI-compatible
+ * proxies, etc.).
+ *
+ * Used by auto-mode bootstrap to decide whether the session model
+ * (set via `/gsd model`) should override `PREFERENCES.md`.  Custom providers
+ * are never reachable from `PREFERENCES.md` (which only knows built-in
+ * providers), so when the user has explicitly selected one, it must take
+ * priority — otherwise auto-mode tries to start the built-in provider from
+ * PREFERENCES.md and fails with "Not logged in · Please run /login" (#4122).
+ *
+ * Reads models.json directly with a lightweight JSON parse to avoid
+ * pulling in the full model-registry at this call site.  Falls back to
+ * `~/.pi/agent/models.json` for parity with `resolveModelsJsonPath()`.
+ * Any read or parse error yields `false` (treat as not-custom) so a
+ * malformed models.json never breaks the session bootstrap.
+ */
+export function isCustomProvider(provider) {
+    if (!provider)
+        return false;
+    const candidates = [
+        join(homedir(), ".gsd", "agent", "models.json"),
+        join(homedir(), ".pi", "agent", "models.json"),
+    ];
+    for (const path of candidates) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed?.providers && Object.prototype.hasOwnProperty.call(parsed.providers, provider)) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore — malformed models.json must not break bootstrap.
+        }
+    }
+    return false;
+}
 /**
  * Determines the next fallback model to try when the current model fails.
  * If the current model is not in the configured list, returns the primary model.

package/dist/resources/extensions/gsd/preferences-types.js

@@ -83,6 +83,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_preparation",
     "discuss_web_research",
     "discuss_depth",
+    "flat_rate_providers",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -155,6 +155,28 @@ export function validatePreferences(preferences) {
             errors.push(`search_provider must be one of: brave, tavily, ollama, native, auto`);
         }
     }
+    // ─── Flat-rate Providers ────────────────────────────────────────────
+    // User-declared flat-rate providers for dynamic routing suppression.
+    // Built-in providers (github-copilot, copilot, claude-code) and any
+    // externalCli provider are already auto-detected; this list layers on
+    // top for private subscription proxies and custom CLI wrappers.
+    if (preferences.flat_rate_providers !== undefined) {
+        if (Array.isArray(preferences.flat_rate_providers)) {
+            const allStrings = preferences.flat_rate_providers.every((item) => typeof item === "string");
+            if (allStrings) {
+                // Strip empty/whitespace-only entries to avoid false matches.
+                validated.flat_rate_providers = preferences.flat_rate_providers
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0);
+            }
+            else {
+                errors.push("flat_rate_providers must be an array of strings");
+            }
+        }
+        else {
+            errors.push("flat_rate_providers must be an array of strings");
+        }
+    }
     // ─── Phase Skip Preferences ─────────────────────────────────────────
     if (preferences.phases !== undefined) {
         if (typeof preferences.phases === "object" && preferences.phases !== null) {

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

@@ -516,6 +516,9 @@ function resolveSliceDependencies(activeMilestoneSlices) {
             return { activeSlice: null, activeSliceRow: null };
         }
     }
+    // First pass: find a slice with ALL dependencies satisfied (strict)
+    let bestFallback = null;
+    let bestFallbackSatisfied = -1;
     for (const s of activeMilestoneSlices) {
         if (isStatusDone(s.status))
             continue;
@@ -524,6 +527,23 @@ function resolveSliceDependencies(activeMilestoneSlices) {
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
         }
+        // Track the slice with the most satisfied dependencies as fallback
+        const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+        if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
+            bestFallback = s;
+            bestFallbackSatisfied = satisfied;
+        }
+    }
+    // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
+    // slices, pick the one with the most deps satisfied. This prevents hard-blocking
+    // when dependency metadata is stale (e.g. after reassessment added/removed slices)
+    // or when deps reference slices from previous milestones.
+    if (bestFallback) {
+        const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
+        logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
+            `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
+            `unmet: ${unmet.join(", ")})`, { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id });
+        return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
     }
     return { activeSlice: null, activeSliceRow: null };
 }
@@ -1269,6 +1289,8 @@ export async function _deriveStateImpl(basePath) {
         }
     }
     else {
+        let bestFallbackLegacy = null;
+        let bestFallbackLegacySatisfied = -1;
         for (const s of activeRoadmap.slices) {
             if (s.done)
                 continue;
@@ -1276,6 +1298,20 @@ export async function _deriveStateImpl(basePath) {
                 activeSlice = { id: s.id, title: s.title };
                 break;
             }
+            // Track best fallback
+            const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+            if (satisfied > bestFallbackLegacySatisfied) {
+                bestFallbackLegacy = s;
+                bestFallbackLegacySatisfied = satisfied;
+            }
+        }
+        // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
+        if (!activeSlice && bestFallbackLegacy) {
+            const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
+            logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
+                `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
+                `unmet: ${unmet.join(", ")})`);
+            activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
         }
     }
     if (!activeSlice) {

package/dist/startup-model-validation.js

@@ -34,15 +34,18 @@ export function validateConfiguredModel(modelRegistry, settingsManager) {
     if (!configuredModel || !configuredExists) {
         // Model not configured at all, or removed from registry — pick a fallback.
         // Only fires when the model is genuinely unknown (not just temporarily unavailable).
+        //
+        // Model-agnostic selection order:
+        //   1. Pi migration default (preserves migration from ~/.pi install)
+        //   2. Any model from the user's previously-chosen provider (provider stickiness)
+        //   3. First available model in registry order (user-controlled via models.json)
         const piDefault = getPiDefaultModelAndProvider();
         const preferred = (piDefault
             ? availableModels.find((m) => m.provider === piDefault.provider && m.id === piDefault.model)
             : undefined) ||
-            availableModels.find((m) => m.provider === 'openai' && m.id === 'gpt-5.4') ||
-            availableModels.find((m) => m.provider === 'openai') ||
-            availableModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
-            availableModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
-            availableModels.find((m) => m.provider === 'anthropic') ||
+            (configuredProvider
+                ? availableModels.find((m) => m.provider === configuredProvider)
+                : undefined) ||
             availableModels[0];
         if (preferred) {
             settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);

package/dist/update-check.d.ts

@@ -9,6 +9,7 @@ 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 declare function resolveInstallCommand(pkg: string): string;
 export interface UpdateCheckOptions {
     currentVersion?: string;
     cachePath?: string;

package/dist/update-check.js

@@ -66,9 +66,16 @@ export async function fetchLatestVersionFromRegistry(registryUrl = DEFAULT_REGIS
         clearTimeout(timeout);
     }
 }
+export function resolveInstallCommand(pkg) {
+    if ('bun' in process.versions) {
+        return `bun add -g ${pkg}`;
+    }
+    return `npm install -g ${pkg}`;
+}
 function printUpdateBanner(current, latest) {
+    const installCmd = resolveInstallCommand('gsd-pi');
     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`);
+        `  ${chalk.dim('Run')} ${installCmd} ${chalk.dim('or')} /gsd update ${chalk.dim('to upgrade')}\n\n`);
 }
 /**
  * Non-blocking update check. Queries npm registry at most once per 24h,
@@ -152,7 +159,7 @@ export async function checkAndPromptForUpdates(options = {}) {
     const readline = await import('node:readline');
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
     const choice = await new Promise((resolve) => {
-        process.stderr.write(`  ${chalk.bold('[1]')} Update now   ${chalk.dim(`npm install -g ${NPM_PACKAGE_NAME}@latest`)}\n` +
+        process.stderr.write(`  ${chalk.bold('[1]')} Update now   ${chalk.dim(resolveInstallCommand(`${NPM_PACKAGE_NAME}@latest`))}\n` +
             `  ${chalk.bold('[2]')} Skip\n\n`);
         // Default to skip if the user doesn't respond within PROMPT_TIMEOUT_MS
         const timer = setTimeout(() => {
@@ -173,14 +180,15 @@ export async function checkAndPromptForUpdates(options = {}) {
         process.stdin.setRawMode(false);
     process.stdin.pause();
     if (choice === '1') {
-        process.stderr.write(`\n  ${chalk.dim('Running:')} npm install -g ${NPM_PACKAGE_NAME}@latest\n\n`);
+        const installCmd = resolveInstallCommand(`${NPM_PACKAGE_NAME}@latest`);
+        process.stderr.write(`\n  ${chalk.dim('Running:')} ${installCmd}\n\n`);
         try {
-            execSync(`npm install -g ${NPM_PACKAGE_NAME}@latest`, { stdio: 'inherit' });
+            execSync(installCmd, { stdio: 'inherit' });
             process.stderr.write(`\n  ${chalk.green.bold(`✓ Updated to v${latestVersion}`)}\n\n`);
             return true;
         }
         catch {
-            process.stderr.write(`\n  ${chalk.yellow(`Update failed. You can run: npm install -g ${NPM_PACKAGE_NAME}@latest`)}\n\n`);
+            process.stderr.write(`\n  ${chalk.yellow(`Update failed. You can run: ${installCmd}`)}\n\n`);
         }
     }
     else {

package/dist/update-cmd.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { compareSemver, fetchLatestVersionFromRegistry } from './update-check.js';
+import { compareSemver, fetchLatestVersionFromRegistry, resolveInstallCommand } from './update-check.js';
 const NPM_PACKAGE = 'gsd-pi';
 export async function runUpdate() {
     const current = process.env.GSD_VERSION || '0.0.0';
@@ -21,14 +21,15 @@ export async function runUpdate() {
         return;
     }
     process.stdout.write(`${dim}Updating:${reset} v${current} → ${bold}v${latest}${reset}\n`);
+    const installCmd = resolveInstallCommand(`${NPM_PACKAGE}@latest`);
     try {
-        execSync(`npm install -g ${NPM_PACKAGE}@latest`, {
+        execSync(installCmd, {
             stdio: 'inherit',
         });
         process.stdout.write(`\n${green}${bold}Updated to v${latest}${reset}\n`);
     }
     catch {
-        process.stderr.write(`\n${yellow}Update failed. Try manually: npm install -g ${NPM_PACKAGE}@latest${reset}\n`);
+        process.stderr.write(`\n${yellow}Update failed. Try manually: ${installCmd}${reset}\n`);
         process.exit(1);
     }
 }

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

@@ -1 +1 @@
-KSZ2dcC3p4z6lOmUpPpzr
+nwYTvJZ1-hZIfw98d9Wfg

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

@@ -1,46 +1,46 @@
 {
   "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
-  "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
-  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/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/dev-mode/route": "/api/dev-mode",
-  "/api/cleanup/route": "/api/cleanup",
   "/api/doctor/route": "/api/doctor",
   "/api/captures/route": "/api/captures",
+  "/api/cleanup/route": "/api/cleanup",
   "/api/export-data/route": "/api/export-data",
   "/api/forensics/route": "/api/forensics",
   "/api/browse-directories/route": "/api/browse-directories",
   "/api/git/route": "/api/git",
-  "/api/hooks/route": "/api/hooks",
   "/api/history/route": "/api/history",
+  "/api/hooks/route": "/api/hooks",
   "/api/inspect/route": "/api/inspect",
   "/api/knowledge/route": "/api/knowledge",
-  "/api/notifications/route": "/api/notifications",
   "/api/live-state/route": "/api/live-state",
-  "/api/preferences/route": "/api/preferences",
+  "/api/notifications/route": "/api/notifications",
   "/api/experimental/route": "/api/experimental",
-  "/api/onboarding/route": "/api/onboarding",
+  "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
   "/api/projects/route": "/api/projects",
+  "/api/onboarding/route": "/api/onboarding",
   "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
-  "/api/session/manage/route": "/api/session/manage",
-  "/api/settings-data/route": "/api/settings-data",
   "/api/session/events/route": "/api/session/events",
+  "/api/settings-data/route": "/api/settings-data",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/shutdown/route": "/api/shutdown",
   "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
-  "/api/files/route": "/api/files",
   "/api/terminal/input/route": "/api/terminal/input",
   "/api/terminal/resize/route": "/api/terminal/resize",
-  "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/switch-root/route": "/api/switch-root",
+  "/api/terminal/sessions/route": "/api/terminal/sessions",
+  "/api/files/route": "/api/files",
   "/api/terminal/stream/route": "/api/terminal/stream",
+  "/api/undo/route": "/api/undo",
   "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/visualizer/route": "/api/visualizer",
-  "/api/undo/route": "/api/undo",
   "/api/update/route": "/api/update",
   "/api/remote-questions/route": "/api/remote-questions",
   "/page": "/"

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

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/KSZ2dcC3p4z6lOmUpPpzr/_buildManifest.js",
-    "static/KSZ2dcC3p4z6lOmUpPpzr/_ssgManifest.js"
+    "static/nwYTvJZ1-hZIfw98d9Wfg/_buildManifest.js",
+    "static/nwYTvJZ1-hZIfw98d9Wfg/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-b868033a5834586d.js",
     "static/chunks/4bd1b696-e356ca5ba0218e27.js",
     "static/chunks/3794-42fdce068d44fa4f.js",
-    "static/chunks/main-app-d3d4c336195465f9.js"
+    "static/chunks/main-app-fdab67f7802d7832.js"
   ],
   "rootMainFilesTree": {},
   "pages": {

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

@@ -78,8 +78,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "a5b55541bc3e0fa2f07c4087828bfdb9",
-    "previewModeSigningKey": "1d263a5202d738e962bd891f42fec4583353ecdb77162ca3b09f7da49aa38e9c",
-    "previewModeEncryptionKey": "82afb9b7e120d168495c89adfe9fcfe9feb930812ef95d0fe02a2f0d3c075948"
+    "previewModeId": "0d74a2aa6b006dd14811b9bbf32d42fa",
+    "previewModeSigningKey": "fa0cfda94f65f8fe26fd9b9bf19d6ae1cdbda72e6b17afe5827bf8861b070f06",
+    "previewModeEncryptionKey": "4458972e6433066063f0a25222104d24b8524438fd03f72cc9ea192774799ae5"
   }
 }

package/dist/web/standalone/.next/required-server-files.json

@@ -104,7 +104,7 @@
         "transform": "lodash/{{member}}"
       }
     },
-    "outputFileTracingRoot": "/home/runner/_work/gsd-2/gsd-2",
+    "outputFileTracingRoot": "/__w/gsd-2/gsd-2",
     "cacheComponents": false,
     "cacheLife": {
       "default": {
@@ -308,11 +308,11 @@
       "node-pty"
     ],
     "turbopack": {
-      "root": "/home/runner/_work/gsd-2/gsd-2"
+      "root": "/__w/gsd-2/gsd-2"
     },
     "distDirRoot": ".next"
   },
-  "appDir": "/home/runner/_work/gsd-2/gsd-2/web",
+  "appDir": "/__w/gsd-2/gsd-2/web",
   "relativeAppDir": "web",
   "files": [
     ".next/routes-manifest.json",