@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

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

@@ -2,6 +2,7 @@ import { execSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "./tool-presentation-plan.js";
 /** Session cwd may be a milestone worktree; MCP config and server discovery use the project root. */
 export function resolveWorkflowMcpProjectRoot(sessionCwd) {
     let resolved;
@@ -77,6 +78,8 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "gsd_task_complete",
     "gsd_task_reopen",
     "gsd_update_requirement",
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
     "gsd_validate_milestone",
 ]);
 /** Workflow MCP tools are validated by transport compatibility, not pi tool-compat profiles. */
@@ -397,8 +400,9 @@ export function getRequiredWorkflowToolsForAutoUnit(unitType) {
             ];
         case "research-milestone":
         case "research-slice":
-        case "run-uat":
             return ["gsd_summary_save"];
+        case "run-uat":
+            return [...RUN_UAT_WORKFLOW_TOOL_NAMES];
         case "plan-milestone":
             return ["gsd_plan_milestone"];
         case "plan-slice":

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

@@ -34,6 +34,8 @@ import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain, } fr
 import { loadEffectiveGSDPreferences, getIsolationMode } from "./preferences.js";
 import { invalidateAllCaches } from "./cache.js";
 import { resolveMilestoneFile } from "./paths.js";
+import { getMilestone, insertMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 // ADR-016 phase 2 / C1 (#5624): file-system + git-CLI leaf primitives
 // inlined as direct imports rather than injected through `WorktreeLifecycleDeps`.
@@ -55,6 +57,26 @@ const MERGE_FAILURE_DEDUPE_MS = 60_000;
 export function resetRecentWorktreeMergeFailuresForTest() {
     recentWorktreeMergeFailures.clear();
 }
+function markMilestoneClosedAfterMerge(milestoneId, completedAt) {
+    if (!isDbAvailable())
+        return;
+    try {
+        const existing = getMilestone(milestoneId);
+        if (!existing) {
+            insertMilestone({ id: milestoneId, title: milestoneId, status: "complete" });
+            updateMilestoneStatus(milestoneId, "complete", completedAt);
+            invalidateAllCaches();
+            return;
+        }
+        if (!isClosedStatus(existing.status)) {
+            updateMilestoneStatus(milestoneId, "complete", completedAt);
+            invalidateAllCaches();
+        }
+    }
+    catch (err) {
+        logWarning("worktree", `Merged ${milestoneId} but failed to mark milestone complete in DB: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Internal sentinel — thrown by `_mergeBranchMode` when it has already
  * emitted a user-visible error. The outer `mergeAndExit` catches the type
@@ -1195,6 +1217,8 @@ export class WorktreeLifecycle {
         }
         // #4764 — record merge completion. Only reaches here when an actual
         // merge ran; failure paths throw out before this point.
+        const mergeCompletedAt = new Date().toISOString();
+        markMilestoneClosedAfterMerge(milestoneId, mergeCompletedAt);
         try {
             emitWorktreeMerged(this.s.originalBasePath || this.s.basePath, milestoneId, {
                 reason: "milestone-complete",

package/dist/resources/extensions/mcp-client/manager.js

@@ -29,6 +29,7 @@ const CHILD_ENV_ALLOWLIST = new Set([
     "XDG_CONFIG_HOME",
     "XDG_CACHE_HOME",
 ]);
+const MCP_STDERR_MAX_BYTES = 4096;
 let cachedStatus = null;
 let cachedStatusKey = "";
 export function clearMcpConfigCache() {
@@ -126,6 +127,33 @@ export function resolveMcpEnv(env) {
 export function resolveMcpString(value) {
     return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => process.env[varName] ?? "");
 }
+function captureTransportStderr(transport) {
+    const chunks = [];
+    let totalBytes = 0;
+    const stderr = transport.stderr;
+    stderr?.on("data", (chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        totalBytes += buffer.byteLength;
+        chunks.push(buffer);
+        while (chunks.reduce((sum, entry) => sum + entry.byteLength, 0) > MCP_STDERR_MAX_BYTES) {
+            chunks.shift();
+        }
+    });
+    return () => {
+        const captured = Buffer.concat(chunks).toString("utf-8").trim();
+        if (!captured)
+            return "";
+        return totalBytes > MCP_STDERR_MAX_BYTES
+            ? `[stderr truncated to last ${MCP_STDERR_MAX_BYTES} bytes]\n${captured}`
+            : captured;
+    };
+}
+function formatConnectionError(error, stderr) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!stderr)
+        return message;
+    return `${message}\nStderr:\n${stderr}`;
+}
 export function upsertProjectLocalMcpServer(input, options = {}) {
     const projectDir = options.projectDir ?? process.cwd();
     const nextName = input.name.trim();
@@ -224,6 +252,7 @@ export async function testMcpServerConnection(nameOrConfig, options = {}) {
     }
     const client = new Client({ name: "gsd", version: "1.0.0" });
     let transport;
+    let readCapturedStderr;
     const timeout = options.timeoutMs ?? 30_000;
     try {
         if (config.transport === "stdio") {
@@ -234,6 +263,7 @@ export async function testMcpServerConnection(nameOrConfig, options = {}) {
                 cwd: config.cwd,
                 stderr: "pipe",
             });
+            readCapturedStderr = captureTransportStderr(transport);
         }
         else {
             const resolvedUrl = resolveMcpString(config.url ?? "");
@@ -259,7 +289,7 @@ export async function testMcpServerConnection(nameOrConfig, options = {}) {
             toolCount: 0,
             tools: [],
             warnings: config.envWarnings,
-            error: error instanceof Error ? error.message : String(error),
+            error: formatConnectionError(error, readCapturedStderr?.() ?? ""),
         };
     }
     finally {

package/dist/resources/extensions/shared/gsd-browser-cli.js

@@ -0,0 +1,145 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const GSD_BROWSER_MCP_SERVER_NAME = "gsd-browser";
+function parseJsonEnv(env, name) {
+    const raw = env[name];
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${name}`);
+    }
+}
+function sanitizeSessionSegment(value) {
+    return value
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+}
+function compareSemverLocal(a, b) {
+    const left = a.split(".").map(Number);
+    const right = b.split(".").map(Number);
+    for (let index = 0; index < Math.max(left.length, right.length); index++) {
+        const leftValue = left[index] || 0;
+        const rightValue = right[index] || 0;
+        if (leftValue > rightValue)
+            return 1;
+        if (leftValue < rightValue)
+            return -1;
+    }
+    return 0;
+}
+function parseGsdBrowserVersion(output) {
+    return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+}
+function resolveBundledGsdBrowserPackageVersion() {
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return typeof pkg.version === "string" ? parseGsdBrowserVersion(pkg.version) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePathGsdBrowserVersion(env) {
+    const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+    if (explicit)
+        return parseGsdBrowserVersion(explicit);
+    try {
+        return parseGsdBrowserVersion(execFileSync("gsd-browser", ["--version"], {
+            encoding: "utf-8",
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+function shouldPreferPathGsdBrowser(env) {
+    const pathVersion = resolvePathGsdBrowserVersion(env);
+    if (!pathVersion)
+        return false;
+    const bundledVersion = resolveBundledGsdBrowserPackageVersion();
+    return !bundledVersion || compareSemverLocal(pathVersion, bundledVersion) > 0;
+}
+export function resolveBundledGsdBrowserCliPath(env = process.env) {
+    const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+    if (explicit)
+        return explicit;
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
+        const candidate = resolve(packageJsonPath, "..", "bin", "gsd-browser");
+        if (existsSync(candidate))
+            return candidate;
+    }
+    catch {
+        // Fall through to path candidates for source/dist layouts.
+    }
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../node_modules/@opengsd/gsd-browser/bin/gsd-browser", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../node_modules/.bin/gsd-browser", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function buildGsdBrowserSessionName(projectRoot, suffix) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const base = sanitizeSessionSegment(basename(resolvedProjectRoot)) || "project";
+    const hash = createHash("sha1").update(resolvedProjectRoot).digest("hex").slice(0, 8);
+    const cleanSuffix = suffix ? sanitizeSessionSegment(suffix) : "";
+    return cleanSuffix ? `gsd-${base}-${hash}-${cleanSuffix}` : `gsd-${base}-${hash}`;
+}
+export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env, options = {}) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
+    const explicitArgs = parseJsonEnv(env, "GSD_BROWSER_MCP_ARGS");
+    const explicitEnv = parseJsonEnv(env, "GSD_BROWSER_MCP_ENV");
+    const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+    const explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+    const preferPathCli = !explicitCommand && !explicitCliPath && shouldPreferPathGsdBrowser(env);
+    const bundledCliPath = !explicitCommand && !explicitCliPath && !preferPathCli
+        ? resolveBundledGsdBrowserCliPath(env)
+        : null;
+    const sessionName = options.sessionName?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot, options.sessionSuffix);
+    const command = explicitCommand
+        || explicitCliPath
+        || (preferPathCli ? "gsd-browser" : undefined)
+        || (bundledCliPath ? process.execPath : undefined)
+        || "gsd-browser";
+    const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
+        ? explicitArgs.map(String)
+        : [
+            ...(bundledCliPath ? [bundledCliPath] : []),
+            "mcp",
+            "--session",
+            sessionName,
+            "--identity-scope",
+            "project",
+            "--identity-project",
+            resolvedProjectRoot,
+        ];
+    const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
+    return {
+        serverName,
+        command,
+        args,
+        cwd,
+        ...(explicitEnv ? { env: explicitEnv } : {}),
+        projectRoot: resolvedProjectRoot,
+        sessionName,
+    };
+}

package/dist/rtk.d.ts

@@ -40,6 +40,12 @@ export interface ValidateRtkBinaryOptions {
     spawnSyncImpl?: typeof spawnSync;
     env?: NodeJS.ProcessEnv;
 }
-export declare function validateRtkBinary(binaryPath: string, options?: ValidateRtkBinaryOptions): boolean;
+export type ValidateRtkBinaryResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: string;
+};
+export declare function validateRtkBinary(binaryPath: string, options?: ValidateRtkBinaryOptions): ValidateRtkBinaryResult;
 export declare function ensureRtkAvailable(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;
 export declare function bootstrapRtk(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;

package/dist/rtk.js

@@ -162,19 +162,28 @@ export function rewriteCommandWithRtk(command, options = {}) {
     const rewritten = (result.stdout ?? "").trimEnd();
     return rewritten || command;
 }
+function trimSpawnOutput(output) {
+    return output?.toString().trim() ?? "";
+}
 export function validateRtkBinary(binaryPath, options = {}) {
     const run = options.spawnSyncImpl ?? spawnSync;
     const result = run(binaryPath, ["rewrite", "git status"], {
         encoding: "utf-8",
         env: buildRtkEnv(options.env ?? process.env),
-        stdio: ["ignore", "pipe", "ignore"],
+        stdio: ["ignore", "pipe", "pipe"],
         timeout: RTK_REWRITE_TIMEOUT_MS,
     });
     if (result.error)
-        return false;
-    if (result.status !== 0)
-        return false;
-    return (result.stdout ?? "").trim() === "rtk git status";
+        return { valid: false, error: result.error.message };
+    if (result.status !== 0) {
+        const stderr = trimSpawnOutput(result.stderr);
+        return { valid: false, error: stderr || `exit code ${result.status ?? "unknown"}` };
+    }
+    const stdout = trimSpawnOutput(result.stdout);
+    if (stdout !== "rtk git status") {
+        return { valid: false, error: stdout ? `unexpected output: ${stdout}` : "unexpected empty output" };
+    }
+    return { valid: true };
 }
 export async function ensureRtkAvailable(options = {}) {
     const env = options.env ?? process.env;
@@ -190,12 +199,18 @@ export async function ensureRtkAvailable(options = {}) {
     }
     const targetDir = options.targetDir ?? getManagedRtkDir(env);
     const managedPath = getManagedRtkPath(process.platform, targetDir);
-    if (existsSync(managedPath) && validateRtkBinary(managedPath, { env })) {
-        return { enabled: true, supported: true, available: true, source: "managed", binaryPath: managedPath };
+    if (existsSync(managedPath)) {
+        const managedValidation = validateRtkBinary(managedPath, { env });
+        if (managedValidation.valid) {
+            return { enabled: true, supported: true, available: true, source: "managed", binaryPath: managedPath };
+        }
     }
     const systemPath = resolveSystemRtkPath(options.pathValue ?? getPathValue(env));
-    if (systemPath && validateRtkBinary(systemPath, { env })) {
-        return { enabled: true, supported: true, available: true, source: "system", binaryPath: systemPath };
+    if (systemPath) {
+        const systemValidation = validateRtkBinary(systemPath, { env });
+        if (systemValidation.valid) {
+            return { enabled: true, supported: true, available: true, source: "system", binaryPath: systemPath };
+        }
     }
     const version = options.releaseVersion ?? RTK_VERSION;
     const assetName = resolveRtkAssetName(process.platform, osArch(), version);
@@ -241,9 +256,10 @@ export async function ensureRtkAvailable(options = {}) {
         if (process.platform !== "win32") {
             chmodSync(managedPath, 0o755);
         }
-        if (!validateRtkBinary(managedPath, { env })) {
+        const downloadedValidation = validateRtkBinary(managedPath, { env });
+        if (!downloadedValidation.valid) {
             rmSync(managedPath, { force: true });
-            throw new Error("downloaded RTK binary failed validation");
+            throw new Error(`downloaded RTK binary failed validation: ${downloadedValidation.error}`);
         }
         options.log?.(`installed RTK ${version} to ${managedPath}`);
         return { enabled: true, supported: true, available: true, source: "downloaded", binaryPath: managedPath };

package/dist/update-check.d.ts

@@ -1,5 +1,9 @@
 import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
 export { isPnpmInstall };
+export declare const GSD_PI_PACKAGE_NAME = "@opengsd/gsd-pi";
+export declare const GSD_BROWSER_PACKAGE_NAME = "@opengsd/gsd-browser";
+export declare const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
+export declare const GSD_BROWSER_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-browser/latest";
 interface UpdateCheckCache {
     lastCheck: number;
     latestVersion: string;
@@ -13,6 +17,14 @@ export declare function readUpdateCache(cachePath?: string, packageName?: string
 export declare function writeUpdateCache(cache: Omit<UpdateCheckCache, 'packageName'> & {
     packageName?: string;
 }, cachePath?: string, packageName?: string): void;
+export declare function resolveInstalledPackageVersion(packageName: string): string | null;
+/**
+ * Resolves the gsd-browser version from PATH (via `gsd-browser --version`).
+ * Respects GSD_BROWSER_PATH_VERSION env override for testing.
+ * Returns null if gsd-browser is not on PATH or times out.
+ */
+export declare function resolveGsdBrowserPathVersion(env?: NodeJS.ProcessEnv): string | null;
+export declare function pickHigherVersion(a: string | null, b: string | null): string | null;
 export declare function fetchLatestVersionFromRegistry(registryUrl?: string, fetchTimeoutMs?: number): Promise<string | null>;
 /**
  * Detects whether the currently-running gsd binary was installed via `bun add -g`.
@@ -29,18 +41,20 @@ export declare function resolveInstallCommand(pkg: string, options?: {
     env?: NodeJS.ProcessEnv;
 }): string;
 export interface UpdateCheckOptions {
+    packageName?: string;
     currentVersion?: string;
     cachePath?: string;
     registryUrl?: string;
     checkIntervalMs?: number;
     fetchTimeoutMs?: number;
-    onUpdate?: (current: string, latest: string) => void;
+    onUpdate?: (current: string, latest: string, packageName: string) => void;
 }
 /**
  * Non-blocking update check. Queries npm registry at most once per 24h,
  * caches the result, and prints a banner if a newer version is available.
  */
 export declare function checkForUpdates(options?: UpdateCheckOptions): Promise<void>;
+export declare function checkForGsdBrowserUpdates(options?: UpdateCheckOptions): Promise<void>;
 /**
  * Interactive update prompt shown at startup when a newer version is available.
  * Fetches the latest version (with cache), then asks the user whether to

package/dist/update-check.js

@@ -1,16 +1,21 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+import { execSync, execFileSync } from 'node:child_process';
 import { dirname, join, resolve as resolvePath, sep } from 'node:path';
 import { homedir } from 'node:os';
+import { createRequire } from 'node:module';
 import chalk from 'chalk';
 import { appRoot } from './app-paths.js';
 import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
 export { isPnpmInstall };
+export const GSD_PI_PACKAGE_NAME = '@opengsd/gsd-pi';
+export const GSD_BROWSER_PACKAGE_NAME = '@opengsd/gsd-browser';
 const CACHE_FILE = join(appRoot, '.update-check');
-const NPM_PACKAGE_NAME = '@opengsd/gsd-pi';
+const GSD_BROWSER_CACHE_FILE = join(appRoot, '.update-check-gsd-browser');
+const NPM_PACKAGE_NAME = GSD_PI_PACKAGE_NAME;
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const FETCH_TIMEOUT_MS = 5000;
-const DEFAULT_REGISTRY_URL = `https://registry.npmjs.org/@opengsd%2fgsd-pi/latest`;
+export const DEFAULT_REGISTRY_URL = `https://registry.npmjs.org/@opengsd%2fgsd-pi/latest`;
+export const GSD_BROWSER_REGISTRY_URL = `https://registry.npmjs.org/@opengsd%2fgsd-browser/latest`;
 /**
  * Compares two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
  */
@@ -55,6 +60,46 @@ function normalizeLatestVersion(version) {
     const trimmed = version.trim().replace(/^v/, '');
     return trimmed.length > 0 ? trimmed : null;
 }
+export function resolveInstalledPackageVersion(packageName) {
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return normalizeLatestVersion(pkg.version);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolves the gsd-browser version from PATH (via `gsd-browser --version`).
+ * Respects GSD_BROWSER_PATH_VERSION env override for testing.
+ * Returns null if gsd-browser is not on PATH or times out.
+ */
+export function resolveGsdBrowserPathVersion(env = process.env) {
+    const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+    if (explicit)
+        return explicit.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    try {
+        const out = execFileSync('gsd-browser', ['--version'], {
+            encoding: 'utf-8',
+            env,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 2000,
+        });
+        return out.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function pickHigherVersion(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return compareSemver(a, b) >= 0 ? a : b;
+}
 export async function fetchLatestVersionFromRegistry(registryUrl = DEFAULT_REGISTRY_URL, fetchTimeoutMs = FETCH_TIMEOUT_MS) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
@@ -100,27 +145,51 @@ export function resolveInstallCommand(pkg, options = {}) {
         return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
-function printUpdateBanner(current, latest) {
-    const installCmd = resolveInstallCommand('@opengsd/gsd-pi@latest');
+function printUpdateBanner(current, latest, packageName = GSD_PI_PACKAGE_NAME) {
+    if (packageName === GSD_BROWSER_PACKAGE_NAME) {
+        process.stderr.write(`  ${chalk.yellow('gsd-browser update available:')} ${chalk.dim(`v${current}`)} → ${chalk.bold(`v${latest}`)}\n` +
+            `  ${chalk.dim('Run')} gsd update browser ${chalk.dim('to upgrade browser automation')}\n\n`);
+        return;
+    }
+    const installCmd = resolveInstallCommand(`${GSD_PI_PACKAGE_NAME}@latest`);
     process.stderr.write(`  ${chalk.yellow('Update available:')} ${chalk.dim(`v${current}`)} → ${chalk.bold(`v${latest}`)}\n` +
         `  ${chalk.dim('Run')} ${installCmd} ${chalk.dim('or')} /gsd upgrade ${chalk.dim('to upgrade')}\n\n`);
 }
+function defaultCurrentVersion(packageName) {
+    if (packageName === GSD_PI_PACKAGE_NAME) {
+        return process.env.GSD_VERSION || '0.0.0';
+    }
+    const bundled = resolveInstalledPackageVersion(packageName);
+    if (packageName === GSD_BROWSER_PACKAGE_NAME) {
+        return pickHigherVersion(bundled, resolveGsdBrowserPathVersion());
+    }
+    return bundled;
+}
+function defaultCachePath(packageName) {
+    return packageName === GSD_BROWSER_PACKAGE_NAME ? GSD_BROWSER_CACHE_FILE : CACHE_FILE;
+}
+function defaultRegistryUrl(packageName) {
+    return packageName === GSD_BROWSER_PACKAGE_NAME ? GSD_BROWSER_REGISTRY_URL : DEFAULT_REGISTRY_URL;
+}
 /**
  * Non-blocking update check. Queries npm registry at most once per 24h,
  * caches the result, and prints a banner if a newer version is available.
  */
 export async function checkForUpdates(options = {}) {
-    const currentVersion = options.currentVersion || process.env.GSD_VERSION || '0.0.0';
-    const cachePath = options.cachePath || CACHE_FILE;
-    const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
+    const packageName = options.packageName || GSD_PI_PACKAGE_NAME;
+    const currentVersion = options.currentVersion || defaultCurrentVersion(packageName);
+    if (!currentVersion)
+        return;
+    const cachePath = options.cachePath || defaultCachePath(packageName);
+    const registryUrl = options.registryUrl || defaultRegistryUrl(packageName);
     const checkIntervalMs = options.checkIntervalMs ?? CHECK_INTERVAL_MS;
     const fetchTimeoutMs = options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
     const onUpdate = options.onUpdate || printUpdateBanner;
     // Check cache — skip network if checked recently
-    const cache = readUpdateCache(cachePath);
+    const cache = readUpdateCache(cachePath, packageName);
     if (cache && Date.now() - cache.lastCheck < checkIntervalMs) {
         if (compareSemver(cache.latestVersion, currentVersion) > 0) {
-            onUpdate(currentVersion, cache.latestVersion);
+            onUpdate(currentVersion, cache.latestVersion, packageName);
         }
         return;
     }
@@ -128,15 +197,21 @@ export async function checkForUpdates(options = {}) {
         const latestVersion = await fetchLatestVersionFromRegistry(registryUrl, fetchTimeoutMs);
         if (!latestVersion)
             return;
-        writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath);
+        writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath, packageName);
         if (compareSemver(latestVersion, currentVersion) > 0) {
-            onUpdate(currentVersion, latestVersion);
+            onUpdate(currentVersion, latestVersion, packageName);
         }
     }
     catch {
         // Network error or timeout — silently ignore, don't block startup
     }
 }
+export async function checkForGsdBrowserUpdates(options = {}) {
+    await checkForUpdates({
+        ...options,
+        packageName: GSD_BROWSER_PACKAGE_NAME,
+    });
+}
 const PROMPT_TIMEOUT_MS = 30_000;
 /**
  * Interactive update prompt shown at startup when a newer version is available.

package/dist/update-cmd.d.ts

@@ -1,6 +1,7 @@
 interface RunUpdateOptions {
     agentDir?: string;
     skillsDir?: string;
+    target?: string;
 }
 export declare function runUpdate(options?: RunUpdateOptions): Promise<void>;
 export {};

package/dist/update-cmd.js

@@ -1,9 +1,60 @@
 import { execSync } from 'node:child_process';
 import { agentDir as defaultAgentDir } from './app-paths.js';
 import { initResources } from './resource-loader.js';
-import { compareSemver, fetchLatestVersionFromRegistry, resolveInstallCommand } from './update-check.js';
-const NPM_PACKAGE = '@opengsd/gsd-pi';
+import { compareSemver, fetchLatestVersionFromRegistry, GSD_BROWSER_PACKAGE_NAME, GSD_BROWSER_REGISTRY_URL, GSD_PI_PACKAGE_NAME, pickHigherVersion, resolveGsdBrowserPathVersion, resolveInstallCommand, resolveInstalledPackageVersion, } from './update-check.js';
+const NPM_PACKAGE = GSD_PI_PACKAGE_NAME;
+function formatCurrentVersion(version) {
+    return version ? `v${version}` : 'unknown';
+}
+async function runBrowserUpdate() {
+    const bundled = resolveInstalledPackageVersion(GSD_BROWSER_PACKAGE_NAME);
+    const current = pickHigherVersion(bundled, resolveGsdBrowserPathVersion());
+    const bold = '\x1b[1m';
+    const dim = '\x1b[2m';
+    const green = '\x1b[32m';
+    const yellow = '\x1b[33m';
+    const reset = '\x1b[0m';
+    process.stdout.write(`${dim}Current gsd-browser version:${reset} ${formatCurrentVersion(current)}\n`);
+    process.stdout.write(`${dim}Checking npm registry...${reset}\n`);
+    const latest = await fetchLatestVersionFromRegistry(GSD_BROWSER_REGISTRY_URL);
+    if (!latest) {
+        process.stderr.write(`${yellow}Failed to reach npm registry.${reset}\n`);
+        process.exit(1);
+    }
+    process.stdout.write(`${dim}Latest gsd-browser version:${reset}  v${latest}\n`);
+    if (current && compareSemver(latest, current) <= 0) {
+        process.stdout.write(`${green}gsd-browser is already up to date.${reset}\n`);
+        return;
+    }
+    process.stdout.write(`${dim}Updating gsd-browser:${reset} ${formatCurrentVersion(current)} → ${bold}v${latest}${reset}\n`);
+    const installCmd = resolveInstallCommand(`${GSD_BROWSER_PACKAGE_NAME}@latest`);
+    try {
+        execSync(installCmd, {
+            stdio: 'inherit',
+        });
+        process.stdout.write(`\n${green}${bold}Updated gsd-browser to v${latest}${reset}\n`);
+        // Verify the new version is reachable via PATH (MCP prefers PATH binary when newer)
+        const newPathVersion = resolveGsdBrowserPathVersion();
+        if (!newPathVersion || compareSemver(newPathVersion, latest) < 0) {
+            process.stdout.write(`${yellow}Note:${reset} ${dim}Ensure the npm global bin directory is on your PATH` +
+                ` so MCP automation uses the updated binary.${reset}\n`);
+        }
+    }
+    catch {
+        process.stderr.write(`\n${yellow}gsd-browser update failed. Try manually: ${installCmd}${reset}\n`);
+        process.exit(1);
+    }
+}
 export async function runUpdate(options = {}) {
+    if (options.target === 'browser' || options.target === 'gsd-browser') {
+        await runBrowserUpdate();
+        return;
+    }
+    if (options.target) {
+        process.stderr.write(`Unknown update target: ${options.target}\n`);
+        process.stderr.write('Usage: gsd update [browser]\n');
+        process.exit(1);
+    }
     const current = process.env.GSD_VERSION || '0.0.0';
     const bold = '\x1b[1m';
     const dim = '\x1b[2m';

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

@@ -1 +1 @@
-L9N5SPFi7f-Ne4u2uXzCe
+jBtwT9v1u2lUA3UEOy_ZH