@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

package/dist/hermes-integration-install.js

@@ -0,0 +1,199 @@
+import { existsSync, mkdirSync, rmSync, cpSync, writeFileSync, readFileSync } from 'node:fs';
+import { dirname, resolve, join, isAbsolute } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+const PLUGIN_NAME = 'open-gsd-hermes';
+export async function runHermesIntegrationCommand(argv) {
+    const hermesIndex = argv.indexOf('hermes', 2);
+    if (hermesIndex === -1) {
+        printHermesHelp();
+        return 0;
+    }
+    const sub = argv[hermesIndex + 1];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        printHermesHelp();
+        return 0;
+    }
+    if (sub !== 'install') {
+        process.stderr.write(`[gsd] Unknown hermes command: ${sub}\n`);
+        printHermesHelp(process.stderr);
+        return 1;
+    }
+    let options;
+    try {
+        options = parseHermesInstallArgs(argv.slice(hermesIndex + 2));
+    }
+    catch (err) {
+        process.stderr.write(`[gsd] hermes install: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    try {
+        const result = installHermesPlugin(options);
+        for (const action of result.actions)
+            process.stdout.write(`✓ ${action}\n`);
+        for (const warning of result.warnings)
+            process.stderr.write(`[gsd] Warning: ${warning}\n`);
+        process.stdout.write(`\nHermes plugin installed at: ${result.pluginTarget}\n`);
+        process.stdout.write(`Config path: ${result.configPath}\n`);
+        process.stdout.write('Next: restart Hermes/gateway, then run `hermes plugins list` and `/gsd status`.\n');
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`[gsd] hermes install failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+}
+export function parseHermesInstallArgs(args) {
+    let hermesHome = process.env.HERMES_HOME || join(homedir(), '.hermes');
+    let pluginSource = process.env.GSD_HERMES_PLUGIN_SOURCE || findBundledHermesPluginSource();
+    let project;
+    let dryRun = false;
+    let skipPip = false;
+    let skipEnable = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const next = () => {
+            const value = args[++i];
+            if (!value)
+                throw new Error(`${arg} requires a value`);
+            return value;
+        };
+        if (arg === '--hermes-home')
+            hermesHome = next();
+        else if (arg === '--plugin-source')
+            pluginSource = next();
+        else if (arg === '--project')
+            project = next();
+        else if (arg === '--dry-run')
+            dryRun = true;
+        else if (arg === '--skip-pip')
+            skipPip = true;
+        else if (arg === '--skip-enable')
+            skipEnable = true;
+        else
+            throw new Error(`unknown option: ${arg}`);
+    }
+    return {
+        hermesHome: expandHome(hermesHome),
+        pluginSource: expandHome(pluginSource),
+        project: project ? resolve(expandHome(project)) : undefined,
+        dryRun,
+        skipPip,
+        skipEnable,
+    };
+}
+export function installHermesPlugin(options) {
+    const source = resolve(options.pluginSource);
+    if (!existsSync(join(source, 'plugin.yaml'))) {
+        throw new Error(`plugin source does not contain plugin.yaml: ${source}`);
+    }
+    const hermesHome = resolve(options.hermesHome);
+    const pluginRoot = join(hermesHome, 'plugins');
+    const pluginTarget = join(pluginRoot, PLUGIN_NAME);
+    const configPath = join(hermesHome, 'gsd.yaml');
+    const actions = [];
+    const warnings = [];
+    if (!options.dryRun) {
+        mkdirSync(pluginRoot, { recursive: true });
+        if (existsSync(pluginTarget)) {
+            rmSync(pluginTarget, { recursive: true, force: true });
+        }
+        cpSync(source, pluginTarget, {
+            recursive: true,
+            filter: (src) => !src.includes('__pycache__') && !src.includes('.pytest_cache'),
+        });
+    }
+    actions.push(`${options.dryRun ? 'Would copy' : 'Copied'} ${PLUGIN_NAME} into Hermes plugin directory`);
+    const config = renderGsdYaml(options.project);
+    if (!existsSync(configPath)) {
+        if (!options.dryRun)
+            writeFileSync(configPath, config, 'utf8');
+        actions.push(`${options.dryRun ? 'Would create' : 'Created'} ${configPath}`);
+    }
+    else if (!readFileSync(configPath, 'utf8').includes('gsd:')) {
+        warnings.push(`${configPath} exists but does not contain a gsd: section; merge the sample config from ${pluginTarget}/docs/setup.md`);
+    }
+    else {
+        actions.push(`Left existing ${configPath} unchanged`);
+    }
+    if (!options.skipPip) {
+        const python = findHermesPython(hermesHome);
+        const pipArgs = ['-m', 'pip', 'install', '-e', pluginTarget];
+        if (options.dryRun) {
+            actions.push(`Would run ${python} ${pipArgs.join(' ')}`);
+        }
+        else {
+            const pip = spawnSync(python, pipArgs, { stdio: 'pipe', encoding: 'utf8' });
+            if (pip.status !== 0) {
+                warnings.push(`Python package install failed with ${python}; Hermes may not import the plugin until you run: ${python} ${pipArgs.join(' ')}`);
+                if (pip.stderr.trim())
+                    warnings.push(pip.stderr.trim().split('\n').slice(-3).join(' | '));
+            }
+            else {
+                actions.push('Installed Python package into Hermes environment');
+            }
+        }
+    }
+    if (!options.skipEnable) {
+        if (options.dryRun) {
+            actions.push(`Would run HERMES_HOME=${hermesHome} hermes plugins enable ${PLUGIN_NAME}`);
+        }
+        else {
+            const enable = spawnSync('hermes', ['plugins', 'enable', PLUGIN_NAME], {
+                stdio: 'pipe',
+                encoding: 'utf8',
+                env: { ...process.env, HERMES_HOME: hermesHome },
+            });
+            if (enable.status !== 0) {
+                warnings.push(`Could not auto-enable plugin; run manually: HERMES_HOME=${hermesHome} hermes plugins enable ${PLUGIN_NAME}`);
+            }
+            else {
+                actions.push('Enabled plugin in Hermes');
+            }
+        }
+    }
+    return { pluginTarget, configPath, actions, warnings };
+}
+function quoteYamlScalar(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function renderGsdYaml(project) {
+    const defaultProject = project ?? '~/code/myapp';
+    return `# open-gsd-hermes configuration. Edit paths for your machine.\ngsd:\n  cli_path: gsd\n  mcp_server_path: gsd-mcp-server\n  credential_source: gsd\n  default_project: ${quoteYamlScalar(defaultProject)}\n  poll_interval_seconds: 12\n  cache_ttl_seconds: 45\n  notification_level: normal\n  bindings: {}\n`;
+}
+function findHermesPython(hermesHome) {
+    const suffix = process.platform === 'win32' ? join('Scripts', 'python.exe') : join('bin', 'python');
+    const bundled = join(hermesHome, 'hermes-agent', 'venv', suffix);
+    if (existsSync(bundled))
+        return bundled;
+    return process.env.PYTHON || 'python3';
+}
+function findBundledHermesPluginSource() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(process.cwd(), 'integrations/hermes'),
+        resolve(here, '../integrations/hermes'),
+        resolve(here, '../../integrations/hermes'),
+    ];
+    const found = candidates.find((candidate) => existsSync(join(candidate, 'plugin.yaml')));
+    return found ?? candidates[0];
+}
+function expandHome(value) {
+    if (value === '~')
+        return homedir();
+    if (value.startsWith('~/'))
+        return join(homedir(), value.slice(2));
+    return isAbsolute(value) ? value : resolve(value);
+}
+function printHermesHelp(stream = process.stdout) {
+    stream.write('Usage: gsd hermes install [options]\n');
+    stream.write('\nInstall the bundled open-gsd-hermes plugin into a Hermes Agent home.\n\n');
+    stream.write('Options:\n');
+    stream.write('  --hermes-home <path>    Hermes home (default: $HERMES_HOME or ~/.hermes)\n');
+    stream.write('  --project <path>        Default GSD project to write into gsd.yaml\n');
+    stream.write('  --plugin-source <path>  Override bundled integrations/hermes source\n');
+    stream.write('  --skip-pip             Copy plugin only; do not pip install editable package\n');
+    stream.write('  --skip-enable          Do not run hermes plugins enable\n');
+    stream.write('  --dry-run              Print intended actions without writing\n');
+}

package/dist/jiti-workspace-aliases.d.ts

@@ -1,2 +1,11 @@
-/** jiti alias map for @gsd/* workspace packages (CJS require cannot load ESM file:// URLs). */
-export declare function getJitiWorkspaceAliases(importUrl: string): Record<string, string>;
+export type FileExists = (path: string) => boolean;
+/**
+ * jiti alias map for @gsd/* workspace packages (CJS require cannot load ESM file:// URLs).
+ *
+ * In the monorepo the canonical entry points are raw TypeScript under `packages/<name>/src/`,
+ * which jiti loads directly. The published tarball ships only the compiled `packages/<name>/dist/`
+ * (see each package's `files` field) — `src/` is absent. Resolve each alias to the `src/*.ts`
+ * entry when present, otherwise fall back to the compiled `dist/*.js`, so the merge CLI loads in
+ * both layouts instead of crashing with MODULE_NOT_FOUND on the missing source path.
+ */
+export declare function getJitiWorkspaceAliases(importUrl: string, fileExists?: FileExists): Record<string, string>;

package/dist/jiti-workspace-aliases.js

@@ -1,9 +1,25 @@
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { resolvePackageRoot } from "./bundled-resource-path.js";
-/** jiti alias map for @gsd/* workspace packages (CJS require cannot load ESM file:// URLs). */
-export function getJitiWorkspaceAliases(importUrl) {
+/**
+ * jiti alias map for @gsd/* workspace packages (CJS require cannot load ESM file:// URLs).
+ *
+ * In the monorepo the canonical entry points are raw TypeScript under `packages/<name>/src/`,
+ * which jiti loads directly. The published tarball ships only the compiled `packages/<name>/dist/`
+ * (see each package's `files` field) — `src/` is absent. Resolve each alias to the `src/*.ts`
+ * entry when present, otherwise fall back to the compiled `dist/*.js`, so the merge CLI loads in
+ * both layouts instead of crashing with MODULE_NOT_FOUND on the missing source path.
+ */
+export function getJitiWorkspaceAliases(importUrl, fileExists = existsSync) {
     const root = resolvePackageRoot(importUrl);
-    const pkg = (dir, ...segments) => join(root, "packages", dir, "src", ...segments);
+    // Prefer the source `.ts` entry (monorepo); fall back to the compiled `.js` (published tarball).
+    const pkg = (dir, ...segments) => {
+        const srcEntry = join(root, "packages", dir, "src", ...segments);
+        if (fileExists(srcEntry))
+            return srcEntry;
+        const distSegments = segments.map((s) => s.replace(/\.ts$/, ".js"));
+        return join(root, "packages", dir, "dist", ...distSegments);
+    };
     const piAi = pkg("pi-ai", "index.ts");
     const piAiOauth = pkg("pi-ai", "utils", "oauth", "index.ts");
     const piAgentCore = pkg("pi-agent-core", "index.ts");

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/mcp-server.js

@@ -29,6 +29,7 @@ function isPlainObject(value) {
 // built via a template string so TypeScript's NodeNext resolver treats them as
 // `any` and skips static checking.
 const MCP_PKG = '@modelcontextprotocol/sdk';
+import { sanitizeSchemaForMoonshot } from '@gsd/pi-ai';
 export function mcpSdkSpecifier(subpath) {
     return `${MCP_PKG}/${subpath}.js`;
 }
@@ -65,7 +66,7 @@ export async function startMcpServer(options) {
         tools: tools.map((t) => ({
             name: t.name,
             description: t.description,
-            inputSchema: t.parameters,
+            inputSchema: sanitizeSchemaForMoonshot(t.parameters),
         })),
     }));
     // tools/call — execute the requested tool and return content blocks.

package/dist/models-resolver.d.ts

@@ -1,20 +1,10 @@
 /**
- * Models.json resolution with fallback to ~/.pi/agent/models.json
+ * Models.json resolution for GSD.
  *
- * GSD uses ~/.gsd/agent/models.json, but for a smooth migration/development
- * experience, this module provides resolution logic that:
- *
- * 1. Reads ~/.gsd/agent/models.json if it exists
- * 2. Falls back to ~/.pi/agent/models.json if GSD file doesn't exist
- * 3. Merges both files if both exist (GSD takes precedence)
+ * Uses ~/.gsd/agent/models.json exclusively.
  */
 /**
- * Resolve the path to models.json with fallback logic.
- *
- * Priority:
- * 1. ~/.gsd/agent/models.json (exists) → return this path
- * 2. ~/.pi/agent/models.json (exists) → return this path (fallback)
- * 3. Neither exists → return GSD path (will be created)
+ * Resolve the path to models.json.
  *
  * @returns The path to use for models.json
  */

package/dist/models-resolver.js

@@ -1,35 +1,16 @@
 /**
- * Models.json resolution with fallback to ~/.pi/agent/models.json
+ * Models.json resolution for GSD.
  *
- * GSD uses ~/.gsd/agent/models.json, but for a smooth migration/development
- * experience, this module provides resolution logic that:
- *
- * 1. Reads ~/.gsd/agent/models.json if it exists
- * 2. Falls back to ~/.pi/agent/models.json if GSD file doesn't exist
- * 3. Merges both files if both exist (GSD takes precedence)
+ * Uses ~/.gsd/agent/models.json exclusively.
  */
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { agentDir } from './app-paths.js';
 const GSD_MODELS_PATH = join(agentDir, 'models.json');
-const PI_MODELS_PATH = join(homedir(), '.pi', 'agent', 'models.json');
 /**
- * Resolve the path to models.json with fallback logic.
- *
- * Priority:
- * 1. ~/.gsd/agent/models.json (exists) → return this path
- * 2. ~/.pi/agent/models.json (exists) → return this path (fallback)
- * 3. Neither exists → return GSD path (will be created)
+ * Resolve the path to models.json.
  *
  * @returns The path to use for models.json
  */
 export function resolveModelsJsonPath() {
-    if (existsSync(GSD_MODELS_PATH)) {
-        return GSD_MODELS_PATH;
-    }
-    if (existsSync(PI_MODELS_PATH)) {
-        return PI_MODELS_PATH;
-    }
     return GSD_MODELS_PATH;
 }

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/read-cli.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `gsd read` — JSON read seam for integrations (Hermes 6c).
+ *
+ *   gsd read progress --json --project /path
+ *   gsd read roadmap --json --project /path [--milestone M001]
+ *   gsd read memory --json --project /path --query "auth"
+ */
+export declare const INTEGRATION_VERSION = 1;
+export type ReadKind = 'progress' | 'roadmap' | 'memory';
+export interface ReadEnvelope<T = unknown> {
+    integration_version: number;
+    kind: ReadKind;
+    projectDir: string;
+    data: T;
+}
+export interface ReadCliOptions {
+    kind: ReadKind;
+    project: string;
+    milestone?: string;
+    query?: string;
+    json: boolean;
+}
+export declare function runReadCli(argv: string[]): Promise<number>;

package/dist/read-cli.js

@@ -0,0 +1,90 @@
+/**
+ * `gsd read` — JSON read seam for integrations (Hermes 6c).
+ *
+ *   gsd read progress --json --project /path
+ *   gsd read roadmap --json --project /path [--milestone M001]
+ *   gsd read memory --json --project /path --query "auth"
+ */
+import { resolve } from 'node:path';
+import { graphQuery } from '@opengsd/mcp-server/readers/graph';
+import { resolveGsdRoot } from '@opengsd/mcp-server/readers/paths';
+import { readRoadmap } from '@opengsd/mcp-server/readers/roadmap';
+import { readProgress } from '@opengsd/mcp-server/readers/state';
+export const INTEGRATION_VERSION = 1;
+function parseReadArgs(argv) {
+    const readIndex = argv.indexOf('read', 2);
+    if (readIndex === -1)
+        return null;
+    const args = argv.slice(readIndex + 1);
+    if (args.length < 1)
+        return null;
+    const kind = args[0];
+    if (!['progress', 'roadmap', 'memory'].includes(kind))
+        return null;
+    let project;
+    let milestone;
+    let query;
+    let json = false;
+    for (let i = 1; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--json')
+            json = true;
+        else if (a === '--project' && i + 1 < args.length)
+            project = args[++i];
+        else if (a === '--milestone' && i + 1 < args.length)
+            milestone = args[++i];
+        else if (a === '--query' && i + 1 < args.length)
+            query = args[++i];
+    }
+    if (!project)
+        return null;
+    return { kind, project, milestone, query, json };
+}
+export async function runReadCli(argv) {
+    const opts = parseReadArgs(argv);
+    if (!opts) {
+        process.stderr.write('Usage: gsd read <progress|roadmap|memory> --json --project <path> [--milestone M001] [--query text]\n');
+        return 1;
+    }
+    const projectDir = resolve(opts.project);
+    try {
+        resolveGsdRoot(projectDir);
+    }
+    catch (err) {
+        process.stderr.write(`[gsd read] ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    let data;
+    switch (opts.kind) {
+        case 'progress':
+            data = readProgress(projectDir);
+            break;
+        case 'roadmap':
+            data = readRoadmap(projectDir, opts.milestone);
+            break;
+        case 'memory': {
+            const term = opts.query?.trim() || '';
+            if (term.length < 2) {
+                process.stderr.write('[gsd read] memory requires --query with at least 2 characters\n');
+                return 1;
+            }
+            data = await graphQuery(projectDir, term);
+            break;
+        }
+        default:
+            return 1;
+    }
+    const envelope = {
+        integration_version: INTEGRATION_VERSION,
+        kind: opts.kind,
+        projectDir,
+        data,
+    };
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(envelope, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write(JSON.stringify(envelope.data, null, 2) + '\n');
+    }
+    return 0;
+}

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 when the managed-resources.json version and content
+ * fingerprint 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/`
  */