@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/dist/cli-model-override.d.ts

@@ -0,0 +1,15 @@
+import type { ModelRegistry as ModelRegistryInstance } from '@gsd/pi-coding-agent';
+/**
+ * Apply the --model CLI flag override to the active session.
+ * Searches available models by exact id or provider/id pattern and warns
+ * on stderr when the requested model is not found in the registry.
+ *
+ * The setModel call is intentionally fire-and-forget: provider readiness
+ * checks run later in startup so --model does not block session creation.
+ */
+export declare function applyModelOverride(session: {
+    setModel(model: {
+        provider: string;
+        id: string;
+    }): unknown | Promise<unknown>;
+}, modelRegistry: ModelRegistryInstance, modelFlag: string | undefined): void;

package/dist/cli-model-override.js

@@ -0,0 +1,21 @@
+/**
+ * Apply the --model CLI flag override to the active session.
+ * Searches available models by exact id or provider/id pattern and warns
+ * on stderr when the requested model is not found in the registry.
+ *
+ * The setModel call is intentionally fire-and-forget: provider readiness
+ * checks run later in startup so --model does not block session creation.
+ */
+export function applyModelOverride(session, modelRegistry, modelFlag) {
+    if (!modelFlag)
+        return;
+    const available = modelRegistry.getAvailable();
+    const match = available.find((m) => m.id === modelFlag) ||
+        available.find((m) => `${m.provider}/${m.id}` === modelFlag);
+    if (match) {
+        void session.setModel(match);
+    }
+    else {
+        process.stderr.write(`[gsd] Warning: Model "${modelFlag}" not found. Using configured default.\n`);
+    }
+}

package/dist/cli.js

@@ -13,7 +13,8 @@ import { shouldRedirectAutoToHeadless } from './cli-auto-routing.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 import { applySecurityOverrides } from './security-overrides.js';
 import { validateConfiguredModel } from './startup-model-validation.js';
-import { migrateAnthropicDefaultToClaudeCode } from './provider-migrations.js';
+import { migrateAnthropicDefaultToClaudeCode, migrateGeminiCliDefaultToAntigravity } from './provider-migrations.js';
+import { applyModelOverride } from './cli-model-override.js';
 import { buildHeadlessAutoArgs, parseCliArgs, runWebCliBranch, migrateLegacyFlatSessions, } from './cli-web-branch.js';
 import { stopWebMode } from './web-mode.js';
 import { getProjectSessionsDir } from './project-sessions.js';
@@ -122,24 +123,6 @@ async function reapplyValidatedModelOnFallback(session, modelRegistry, settingsM
         // Provider not ready — leave session on its current model
     }
 }
-/**
- * Apply the --model CLI flag override to the active session.
- * Searches available models by exact id or provider/id pattern and warns
- * on stderr when the requested model is not found in the registry.
- */
-function applyModelOverride(session, modelRegistry, modelFlag) {
-    if (!modelFlag)
-        return;
-    const available = modelRegistry.getAvailable();
-    const match = available.find((m) => m.id === modelFlag) ||
-        available.find((m) => `${m.provider}/${m.id}` === modelFlag);
-    if (match) {
-        void session.setModel(match);
-    }
-    else {
-        process.stderr.write(`[gsd] Warning: Model "${modelFlag}" not found. Using configured default.\n`);
-    }
-}
 const cliFlags = parseCliArgs(process.argv);
 const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
 // `gsd [subcommand] --help` / `-h` — print help before any subcommand runs.
@@ -629,6 +612,12 @@ if (isPrintMode) {
         settingsManager,
         modelRegistry,
     });
+    migrateGeminiCliDefaultToAntigravity({
+        authStorage,
+        isAntigravityReady: () => modelRegistry.isProviderRequestReady('google-antigravity'),
+        settingsManager,
+        modelRegistry,
+    });
     const { session, extensionsResult, modelFallbackMessage } = await createAgentSession({
         authStorage,
         modelRegistry,
@@ -733,6 +722,12 @@ migrateAnthropicDefaultToClaudeCode({
     settingsManager,
     modelRegistry,
 });
+migrateGeminiCliDefaultToAntigravity({
+    authStorage,
+    isAntigravityReady: () => modelRegistry.isProviderRequestReady('google-antigravity'),
+    settingsManager,
+    modelRegistry,
+});
 markStartup('providerMigrations');
 const { session, extensionsResult, modelFallbackMessage: interactiveFallbackMsg } = await createAgentSession({
     authStorage,

package/dist/headless-events.d.ts

@@ -53,7 +53,22 @@ export declare function isTerminalNotification(event: Record<string, unknown>):
 export declare function isBlockedNotification(event: Record<string, unknown>): boolean;
 export declare function isMilestoneReadyNotification(event: Record<string, unknown>): boolean;
 export declare function isInteractiveHeadlessTool(toolName: string | undefined): boolean;
-export declare function shouldArmHeadlessIdleTimeout(toolCallCount: number, interactiveToolCount: number): boolean;
+/**
+ * Decide whether to arm the headless idle-completion timer.
+ *
+ * Arms once at least one tool call has started (and no interactive tool —
+ * ask_user_questions / secure_env_collect — is still awaiting a human answer),
+ * so a multi-step command that pauses between tool calls still resolves.
+ *
+ * Also arms for *quick commands* that are handled entirely in the extension
+ * layer (e.g. `/gsd status`, `/gsd history`, `/gsd help`). These never enter
+ * the LLM agent loop, so they emit no `agent_end` / `execution_complete` and
+ * make zero tool calls. Without this branch the idle timer never arms, the
+ * completion promise never resolves, and the process exits with a spurious
+ * "cancelled" (11) code once the event loop drains. See live-regression
+ * scenario `headless status exits 0 on a seeded project`.
+ */
+export declare function shouldArmHeadlessIdleTimeout(toolCallCount: number, interactiveToolCount: number, isQuickCommand?: boolean): boolean;
 export interface HeadlessTrackedEventLike {
     type: string;
     detail?: string;

package/dist/headless-events.js

@@ -125,8 +125,25 @@ export function isMilestoneReadyNotification(event) {
 export function isInteractiveHeadlessTool(toolName) {
     return INTERACTIVE_HEADLESS_TOOLS.has(canonicalHeadlessToolName(toolName));
 }
-export function shouldArmHeadlessIdleTimeout(toolCallCount, interactiveToolCount) {
-    return toolCallCount > 0 && interactiveToolCount === 0;
+/**
+ * Decide whether to arm the headless idle-completion timer.
+ *
+ * Arms once at least one tool call has started (and no interactive tool —
+ * ask_user_questions / secure_env_collect — is still awaiting a human answer),
+ * so a multi-step command that pauses between tool calls still resolves.
+ *
+ * Also arms for *quick commands* that are handled entirely in the extension
+ * layer (e.g. `/gsd status`, `/gsd history`, `/gsd help`). These never enter
+ * the LLM agent loop, so they emit no `agent_end` / `execution_complete` and
+ * make zero tool calls. Without this branch the idle timer never arms, the
+ * completion promise never resolves, and the process exits with a spurious
+ * "cancelled" (11) code once the event loop drains. See live-regression
+ * scenario `headless status exits 0 on a seeded project`.
+ */
+export function shouldArmHeadlessIdleTimeout(toolCallCount, interactiveToolCount, isQuickCommand = false) {
+    if (interactiveToolCount > 0)
+        return false;
+    return toolCallCount > 0 || isQuickCommand;
 }
 function hasCancelledDetail(detail) {
     return /\bcancelled\b/i.test(String(detail ?? ''));

package/dist/headless.js

@@ -434,6 +434,13 @@ async function runHeadlessOnce(options, restartCount) {
     });
     // Idle timeout — fallback completion detection
     let idleTimer = null;
+    // Quick commands (status, history, help, …) are short extension-layer
+    // operations that never enter the LLM agent loop, so they emit no
+    // execution_complete and make no tool calls. The idle timer is what
+    // resolves them; without arming it for zero-tool quick commands the run
+    // hangs and exits with a spurious "cancelled" (11). See
+    // shouldArmHeadlessIdleTimeout.
+    const isQuickCmd = isQuickCommand(options.command, options.commandArgs);
     let effectiveIdleTimeout = isNewMilestone
         ? NEW_MILESTONE_IDLE_TIMEOUT_MS
         : isAutoMode
@@ -443,7 +450,7 @@ async function runHeadlessOnce(options, restartCount) {
         if (idleTimer)
             clearTimeout(idleTimer);
         if (effectiveIdleTimeout > 0 &&
-            shouldArmHeadlessIdleTimeout(toolCallCount, interactiveToolCallIds.size)) {
+            shouldArmHeadlessIdleTimeout(toolCallCount, interactiveToolCallIds.size, isQuickCmd)) {
             idleTimer = setTimeout(() => {
                 completed = true;
                 resolveCompletion();

package/dist/loader.js

@@ -31,7 +31,7 @@ if (firstArg === '--help' || firstArg === '-h') {
 // package.json (already parsed above) and verifies git is available.
 // ---------------------------------------------------------------------------
 {
-    const { MIN_NODE_MAJOR, checkNodeVersion, requireGit } = await import('./runtime-checks.js');
+    const { MIN_NODE_MAJOR, checkNodeVersion, gitAvailableOnPath } = await import('./runtime-checks.js');
     const red = '\x1b[31m';
     const bold = '\x1b[1m';
     const dim = '\x1b[2m';
@@ -48,8 +48,10 @@ if (firstArg === '--help' || firstArg === '-h') {
         process.exit(1);
     }
     // -- git --
-    const { execFileSync } = await import('child_process');
-    const gitOk = requireGit((cmd, args) => execFileSync(cmd, args, { stdio: 'ignore' }));
+    // Presence-check git via a $PATH scan rather than spawning `git --version`:
+    // the subprocess cost ~15ms on every cold start (~5% of startup CPU) just to
+    // confirm git is installed.
+    const gitOk = gitAvailableOnPath();
     if (!gitOk) {
         process.stderr.write(`\n${red}${bold}Error:${reset} GSD requires git but it was not found on PATH.\n\n` +
             `${dim}Install git:${reset}\n` +
@@ -230,6 +232,6 @@ if (missingPackages.length > 0) {
 }
 // Register GSD agent packages for extension imports before CLI loads.
 const { registerAgentBundles } = await import('./register-agent-bundles.js');
-registerAgentBundles();
+await registerAgentBundles();
 // Dynamic import defers ESM evaluation — config.js will see PI_PACKAGE_DIR above
 await import('./cli.js');

package/dist/onboarding.js

@@ -359,11 +359,15 @@ export async function runLlmStep(p, pc, authStorage) {
     if (isClaudeCliReady()) {
         authOptions.push({ value: 'claude-cli', label: 'Use Claude Code CLI', hint: 'uses your existing Claude subscription' });
     }
-    if (isGeminiCliReady()) {
-        authOptions.push({ value: 'gemini-cli', label: 'Use Google Gemini CLI', hint: 'uses your existing Gemini CLI session' });
-    }
     if (isAntigravityCliReady()) {
-        authOptions.push({ value: 'antigravity-cli', label: 'Use Antigravity CLI', hint: 'uses your existing Antigravity session' });
+        authOptions.push({ value: 'antigravity-cli', label: 'Use Antigravity CLI', hint: 'recommended — replaces Gemini CLI for individuals' });
+    }
+    else if (isGeminiCliReady()) {
+        authOptions.push({
+            value: 'gemini-cli',
+            label: 'Use Google Gemini CLI (deprecated)',
+            hint: 'individual tier no longer supported — install Antigravity from https://antigravity.google',
+        });
     }
     authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'GitHub Copilot or ChatGPT/Codex' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
     const method = await p.select({
@@ -385,6 +389,7 @@ export async function runLlmStep(p, pc, authStorage) {
         return true;
     }
     if (method === 'gemini-cli') {
+        p.log.warn('Google Gemini CLI is deprecated for individual users — install Antigravity: https://antigravity.google');
         p.log.success('Google Gemini CLI detected — routing through local CLI');
         p.log.info('Your Gemini CLI session will be used for inference. No API key needed.');
         authStorage.set('google-gemini-cli', { type: 'api_key', key: 'cli' });

package/dist/provider-migrations.d.ts

@@ -25,4 +25,27 @@ type AnthropicDefaultMigrationDeps = {
 export declare function hasDirectAnthropicApiKey(authStorage: Pick<AuthStorage, "getCredentialsForProvider">, env?: NodeJS.ProcessEnv): boolean;
 export declare function shouldMigrateAnthropicToClaudeCode({ authStorage, isClaudeCodeReady, defaultProvider, env, }: AnthropicMigrationDeps): boolean;
 export declare function migrateAnthropicDefaultToClaudeCode({ authStorage, isClaudeCodeReady, settingsManager, modelRegistry, env, }: AnthropicDefaultMigrationDeps): boolean;
+type GeminiCliMigrationDeps = {
+    authStorage: Pick<AuthStorage, "getCredentialsForProvider">;
+    isAntigravityReady: boolean | (() => boolean);
+    defaultProvider: string | undefined;
+    env?: NodeJS.ProcessEnv;
+};
+type GeminiCliDefaultMigrationDeps = {
+    authStorage: Pick<AuthStorage, "getCredentialsForProvider" | "set">;
+    isAntigravityReady: boolean | (() => boolean);
+    settingsManager: {
+        getDefaultProvider(): string | undefined;
+        getDefaultModel(): string | undefined;
+        setDefaultModelAndProvider(provider: string, modelId: string): void;
+    };
+    modelRegistry: {
+        getAvailable(): MigrationModel[];
+    };
+    env?: NodeJS.ProcessEnv;
+};
+export declare function hasGeminiCliExternalAuth(authStorage: Pick<AuthStorage, "getCredentialsForProvider">): boolean;
+export declare function hasDirectGoogleApiKey(authStorage: Pick<AuthStorage, "getCredentialsForProvider">, env?: NodeJS.ProcessEnv): boolean;
+export declare function shouldMigrateGeminiCliToAntigravity({ authStorage, isAntigravityReady, defaultProvider, env, }: GeminiCliMigrationDeps): boolean;
+export declare function migrateGeminiCliDefaultToAntigravity({ authStorage, isAntigravityReady, settingsManager, modelRegistry, env, }: GeminiCliDefaultMigrationDeps): boolean;
 export {};

package/dist/provider-migrations.js

@@ -27,3 +27,44 @@ export function migrateAnthropicDefaultToClaudeCode({ authStorage, isClaudeCodeR
     settingsManager.setDefaultModelAndProvider(target.provider, target.id);
     return true;
 }
+export function hasGeminiCliExternalAuth(authStorage) {
+    return authStorage.getCredentialsForProvider("google-gemini-cli").some((credential) => credential?.type === "api_key" && credential?.key === "cli");
+}
+export function hasDirectGoogleApiKey(authStorage, env = process.env) {
+    if ((env.GEMINI_API_KEY ?? env.GOOGLE_API_KEY ?? "").trim()) {
+        return true;
+    }
+    return authStorage.getCredentialsForProvider("google").some((credential) => credential?.type === "api_key" && typeof credential?.key === "string" && credential.key.trim().length > 0);
+}
+export function shouldMigrateGeminiCliToAntigravity({ authStorage, isAntigravityReady, defaultProvider, env = process.env, }) {
+    if (defaultProvider !== "google-gemini-cli") {
+        return false;
+    }
+    if (!hasGeminiCliExternalAuth(authStorage)) {
+        return false;
+    }
+    if (hasDirectGoogleApiKey(authStorage, env)) {
+        return false;
+    }
+    return typeof isAntigravityReady === "function" ? isAntigravityReady() : isAntigravityReady;
+}
+export function migrateGeminiCliDefaultToAntigravity({ authStorage, isAntigravityReady, settingsManager, modelRegistry, env = process.env, }) {
+    const defaultProvider = settingsManager.getDefaultProvider();
+    if (!shouldMigrateGeminiCliToAntigravity({ authStorage, isAntigravityReady, defaultProvider, env })) {
+        return false;
+    }
+    const defaultModel = settingsManager.getDefaultModel();
+    const antigravityModels = modelRegistry.getAvailable().filter((model) => model.provider === "google-antigravity");
+    const target = (defaultModel
+        ? antigravityModels.find((model) => model.id === defaultModel)
+        : undefined) ||
+        antigravityModels.find((model) => model.id === "default") ||
+        antigravityModels[0];
+    if (!target) {
+        return false;
+    }
+    authStorage.set("google-antigravity", { type: "api_key", key: "cli" });
+    settingsManager.setDefaultModelAndProvider(target.provider, target.id);
+    process.stderr.write("[gsd] Migrated default provider google-gemini-cli → google-antigravity (Gemini CLI no longer supported for individuals)\n");
+    return true;
+}

package/dist/register-agent-bundles.d.ts

@@ -1,2 +1,11 @@
-/** Register GSD agent packages for extension virtual module resolution. */
-export declare function registerAgentBundles(): void;
+/**
+ * Register GSD agent packages for extension virtual module resolution.
+ *
+ * The eager `@gsd/agent-core` and `@gsd/agent-modes` barrels are only consumed
+ * by the Bun-binary extension loader (which has no filesystem and resolves
+ * bundled packages through `virtualModules`). On the Node/dev path the loader
+ * resolves those same specifiers by file path via `getAliases()`, so importing
+ * the full barrels at startup there is ~400ms of wasted module loading.
+ * Load them only when actually needed (Bun), keeping Node startup lean.
+ */
+export declare function registerAgentBundles(): Promise<void>;

package/dist/register-agent-bundles.js

@@ -1,12 +1,26 @@
-import * as agentCore from '@gsd/agent-core';
-import * as agentModes from '@gsd/agent-modes';
+import { isBunBinary } from '@gsd/pi-coding-agent/config.js';
 import { registerExtensionBundledModules } from '@gsd/pi-coding-agent/core/extensions/loader.js';
 let registered = false;
-/** Register GSD agent packages for extension virtual module resolution. */
-export function registerAgentBundles() {
+/**
+ * Register GSD agent packages for extension virtual module resolution.
+ *
+ * The eager `@gsd/agent-core` and `@gsd/agent-modes` barrels are only consumed
+ * by the Bun-binary extension loader (which has no filesystem and resolves
+ * bundled packages through `virtualModules`). On the Node/dev path the loader
+ * resolves those same specifiers by file path via `getAliases()`, so importing
+ * the full barrels at startup there is ~400ms of wasted module loading.
+ * Load them only when actually needed (Bun), keeping Node startup lean.
+ */
+export async function registerAgentBundles() {
     if (registered)
         return;
     registered = true;
+    if (!isBunBinary)
+        return;
+    const [agentCore, agentModes] = await Promise.all([
+        import('@gsd/agent-core'),
+        import('@gsd/agent-modes'),
+    ]);
     registerExtensionBundledModules({
         '@gsd/agent-core': agentCore,
         '@gsd/agent-modes': agentModes,

package/dist/resource-loader.d.ts

@@ -22,6 +22,9 @@ export declare function readManagedResourceVersion(agentDir: string): string | n
  * directory (e.g. pre-install verification).
  */
 export declare function computeResourceFingerprint(rootDir?: string): string;
+export declare function setGsdBrowserPackageSkillPathForTests(skillPath: string | null | undefined): void;
+export declare function collectGsdBrowserPackageSkillReferences(content: string): string[];
+export declare function hasStaleGsdBrowserPackageSkill(skillsDir: string): boolean;
 export declare function getNewerManagedResourceVersion(agentDir: string, currentVersion: string): string | null;
 /**
  * Syncs a single bundled resource directory into the agent directory.
@@ -49,18 +52,20 @@ export declare function reconcileMergedNodeModules(agentNodeModules: string, hoi
 /** Build a cache fingerprint from packageRoot + sorted entry names of both directories */
 export declare function mergedFingerprint(hoisted: string, internal: string): string;
 /**
- * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
+ * Initializes managed resources under agentDir (~/.gsd/agent/).
  *
  * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
  * - shared/     → ~/.gsd/agent/shared/       (overwrite when version changes)
  * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
  * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
+ * - gsd-browser skill → ~/.gsd/agent/skills/gsd-browser/ from @opengsd/gsd-browser
  * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
  *
- * Skips the copy when the managed-resources.json version matches the current
- * GSD version, avoiding ~128ms of synchronous cpSync on every startup.
- * After `npm update -g @glittercowboy/gsd`, versions will differ and the
- * copy runs once to land the new resources.
+ * Skips the full copy only when the managed-resources.json version, content
+ * fingerprint, and package-owned gsd-browser skill all match the current
+ * install, avoiding ~128ms of synchronous cpSync on steady-state startup.
+ * After `npm update -g @opengsd/gsd-pi`, versions will differ and the copy
+ * runs once to land the new resources.
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */

package/dist/resource-loader.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, readdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
@@ -24,6 +25,10 @@ const resourcesDir = resolveBundledResourcesDirFromPackageRoot(packageRoot);
 const bundledExtensionsDir = join(resourcesDir, 'extensions');
 const resourceVersionManifestName = 'managed-resources.json';
 const resourceFingerprintFileName = '.managed-resources-content-hash';
+const gsdBrowserSkillName = 'gsd-browser';
+const requireFromResourceLoader = createRequire(import.meta.url);
+const gsdBrowserSkillReferenceDirs = ['docs', 'scripts', 'gsd-browser-skill'];
+let gsdBrowserPackageSkillPathForTests;
 export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export function getExtensionKey(entryPath, extensionsDir) {
     const relPath = relative(extensionsDir, entryPath);
@@ -153,6 +158,111 @@ function getCurrentResourceFingerprint() {
     }
     return computeResourceFingerprint();
 }
+function resolveGsdBrowserPackageSkillPath() {
+    if (gsdBrowserPackageSkillPathForTests !== undefined) {
+        return gsdBrowserPackageSkillPathForTests;
+    }
+    try {
+        return requireFromResourceLoader.resolve('@opengsd/gsd-browser/SKILL.md');
+    }
+    catch {
+        return null;
+    }
+}
+export function setGsdBrowserPackageSkillPathForTests(skillPath) {
+    gsdBrowserPackageSkillPathForTests = skillPath;
+}
+export function collectGsdBrowserPackageSkillReferences(content) {
+    const refs = new Set();
+    const referencePattern = /`((?:\.\/)?(?:docs|scripts|gsd-browser-skill)\/[^`\s]+)`/g;
+    for (const match of content.matchAll(referencePattern)) {
+        const ref = normalizeGsdBrowserPackageSkillReference(match[1]);
+        if (ref)
+            refs.add(ref);
+    }
+    return [...refs].sort();
+}
+function normalizeGsdBrowserPackageSkillReference(ref) {
+    if (!ref)
+        return null;
+    const normalized = ref
+        .replace(/^\.\//, '')
+        .replace(/[),.;:]+$/, '');
+    if (normalized.includes('..') || normalized.startsWith('/'))
+        return null;
+    if (!gsdBrowserSkillReferenceDirs.some(dir => normalized === dir || normalized.startsWith(`${dir}/`))) {
+        return null;
+    }
+    return normalized;
+}
+function readGsdBrowserPackageSkillBundle(sourceSkillPath) {
+    const skillContent = readFileSync(sourceSkillPath);
+    const files = new Map([['SKILL.md', skillContent]]);
+    const supportRefs = collectGsdBrowserPackageSkillReferences(skillContent.toString('utf-8'));
+    const sourceDir = dirname(sourceSkillPath);
+    for (const relPath of supportRefs) {
+        const sourcePath = join(sourceDir, relPath);
+        if (existsSync(sourcePath)) {
+            files.set(relPath, readFileSync(sourcePath));
+        }
+    }
+    return files;
+}
+export function hasStaleGsdBrowserPackageSkill(skillsDir) {
+    const targetDir = join(skillsDir, gsdBrowserSkillName);
+    const sourceSkillPath = resolveGsdBrowserPackageSkillPath();
+    // Package unresolvable. syncGsdBrowserPackageSkill is a no-op in this case
+    // (it preserves any existing managed skill), so reporting "stale" here
+    // would drive a full resource resync on every launch that the sync cannot
+    // actually satisfy. Keep the existing managed skill in place until the
+    // package becomes resolvable again or the manifest fingerprint changes.
+    if (!sourceSkillPath)
+        return false;
+    try {
+        const sourceDir = dirname(sourceSkillPath);
+        const skillContent = readFileSync(sourceSkillPath, 'utf-8');
+        for (const [relPath, content] of readGsdBrowserPackageSkillBundle(sourceSkillPath)) {
+            const targetPath = join(targetDir, relPath);
+            if (!existsSync(targetPath) || !readFileSync(targetPath).equals(content)) {
+                return true;
+            }
+        }
+        // Only flag SKILL.md references when sync can actually correct them.
+        // The bundle loop above already covers "source has it, target missing".
+        // A reference the package itself does not ship (source missing) is only
+        // worth a resync if the target still has a stale copy that sync should
+        // clean up; missing on both sides is the steady state when upstream
+        // omits files referenced from SKILL.md and is not actionable here.
+        for (const relPath of collectGsdBrowserPackageSkillReferences(skillContent)) {
+            const sourcePath = join(sourceDir, relPath);
+            const targetPath = join(targetDir, relPath);
+            if (!existsSync(sourcePath) && existsSync(targetPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function syncGsdBrowserPackageSkill(skillsDir) {
+    const targetDir = join(skillsDir, gsdBrowserSkillName);
+    const sourceSkillPath = resolveGsdBrowserPackageSkillPath();
+    if (!sourceSkillPath)
+        return;
+    makeTreeWritable(targetDir);
+    rmSync(targetDir, { recursive: true, force: true });
+    for (const [relPath, content] of readGsdBrowserPackageSkillBundle(sourceSkillPath)) {
+        const targetPath = join(targetDir, relPath);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        writeFileSync(targetPath, content);
+        if (relPath.startsWith('scripts/') && relPath.endsWith('.sh')) {
+            chmodSync(targetPath, 0o755);
+        }
+    }
+    makeTreeWritable(targetDir);
+}
 function collectFileEntries(dir, root, out) {
     if (!existsSync(dir))
         return;
@@ -557,18 +667,20 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
     removeFileIfStale('env-utils.js');
 }
 /**
- * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
+ * Initializes managed resources under agentDir (~/.gsd/agent/).
  *
  * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
  * - shared/     → ~/.gsd/agent/shared/       (overwrite when version changes)
  * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
  * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
+ * - gsd-browser skill → ~/.gsd/agent/skills/gsd-browser/ from @opengsd/gsd-browser
  * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
  *
- * Skips the copy when the managed-resources.json version matches the current
- * GSD version, avoiding ~128ms of synchronous cpSync on every startup.
- * After `npm update -g @glittercowboy/gsd`, versions will differ and the
- * copy runs once to land the new resources.
+ * Skips the full copy only when the managed-resources.json version, content
+ * fingerprint, and package-owned gsd-browser skill all match the current
+ * install, avoiding ~128ms of synchronous cpSync on steady-state startup.
+ * After `npm update -g @opengsd/gsd-pi`, versions will differ and the copy
+ * runs once to land the new resources.
  *
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
@@ -603,11 +715,13 @@ export function initResources(agentDir, skillsDir = join(agentDir, 'skills')) {
         const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(extensionsDir, bundledExtensionsDir);
         const hasMissingSharedFiles = hasMissingBundledResourceFiles(join(agentDir, 'shared'), join(resourcesDir, 'shared'));
         const hasMissingSkillFiles = hasMissingBundledResourceFiles(skillsDir, join(resourcesDir, 'skills'));
+        const hasStaleGsdBrowserSkill = hasStaleGsdBrowserPackageSkill(skillsDir);
         if (manifest.contentHash &&
             manifest.contentHash === currentHash &&
             !hasStaleExtensionFiles &&
             !hasMissingSharedFiles &&
-            !hasMissingSkillFiles) {
+            !hasMissingSkillFiles &&
+            !hasStaleGsdBrowserSkill) {
             return;
         }
     }
@@ -616,6 +730,7 @@ export function initResources(agentDir, skillsDir = join(agentDir, 'skills')) {
     syncResourceDir(join(resourcesDir, 'shared'), join(agentDir, 'shared'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
     syncResourceDir(join(resourcesDir, 'skills'), skillsDir);
+    syncGsdBrowserPackageSkill(skillsDir);
     // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
     // env var is not set (e.g. fork/dev builds, alternative entry points).
     const workflowSrc = join(resourcesDir, 'GSD-WORKFLOW.md');

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

@@ -1 +1 @@
-9afebd3db70730bd
+173573359f5af483

package/dist/resources/extensions/ask-user-questions.js

@@ -187,10 +187,11 @@ function formatForLLM(result) {
     }
     return JSON.stringify({ answers });
 }
-async function playQuestionBell() {
+/** @internal Exported for testing only. */
+export async function playQuestionBell(preferences, stream) {
     try {
         const { playNotificationBell } = await import("./gsd/notifications.js");
-        playNotificationBell("question");
+        playNotificationBell("question", preferences, stream);
     }
     catch {
         // Best-effort: question rendering must never depend on alert delivery.