@opengsd/gsd-pi 1.0.2-dev.235ebf3 → 1.0.2-dev.29398d2

package/README.md

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

package/dist/onboarding.js

@@ -15,6 +15,7 @@ import { dirname, join } from 'node:path';
 import { renderGsdPiLogo, GSD_PI_BRAND, GSD_WEBSITE } from './logo.js';
 import { agentDir } from './app-paths.js';
 import { isClaudeCliReady } from './claude-cli-check.js';
+import { isAntigravityCliReady, isGeminiCliReady } from './resources/extensions/google-cli/readiness.js';
 import { markOnboardingComplete, markStepCompleted, markStepSkipped, isOnboardingComplete, } from './resources/extensions/gsd/onboarding-state.js';
 import { getLlmProviderIds } from './resources/extensions/gsd/setup-catalog.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -358,7 +359,13 @@ export async function runLlmStep(p, pc, authStorage) {
     if (isClaudeCliReady()) {
         authOptions.push({ value: 'claude-cli', label: 'Use Claude Code CLI', hint: 'recommended — uses your existing Claude subscription' });
     }
-    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'GitHub Copilot, ChatGPT, Google, etc.' }, { 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' });
+    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: '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({
         message: existingAuth ? `LLM provider: ${existingAuth} — change it?` : 'How do you want to sign in?',
         options: authOptions,
@@ -377,6 +384,20 @@ export async function runLlmStep(p, pc, authStorage) {
         persistDefaultProvider('claude-code');
         return true;
     }
+    if (method === 'gemini-cli') {
+        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' });
+        persistDefaultProvider('google-gemini-cli');
+        return true;
+    }
+    if (method === 'antigravity-cli') {
+        p.log.success('Antigravity CLI detected — routing through local CLI');
+        p.log.info('Your Antigravity session will be used for inference. No API key needed.');
+        authStorage.set('google-antigravity', { type: 'api_key', key: 'cli' });
+        persistDefaultProvider('google-antigravity');
+        return true;
+    }
     // ── Step 2: Which provider? ──────────────────────────────────────────────
     if (method === 'browser') {
         // Anthropic OAuth is removed from browser auth — it violates Anthropic TOS for
@@ -387,8 +408,6 @@ export async function runLlmStep(p, pc, authStorage) {
             options: [
                 { value: 'github-copilot', label: 'GitHub Copilot' },
                 { value: 'openai-codex', label: 'ChatGPT Plus/Pro (Codex)' },
-                { value: 'google-gemini-cli', label: 'Google Gemini CLI' },
-                { value: 'google-antigravity', label: 'Antigravity (Gemini 3, Claude, GPT-OSS)' },
             ],
         });
         if (p.isCancel(provider))

package/dist/resource-loader.d.ts

@@ -33,6 +33,11 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  * 4. Makes the result writable for the next upgrade cycle.
  */
 export declare function syncResourceDir(srcDir: string, destDir: string): void;
+export declare function resolvePackageNodeModulesLayout(root: string): {
+    internalNodeModules: string;
+    hoistedNodeModules: string | null;
+};
+export declare function findNearestNodeModulesAncestor(startPath: string): string | null;
 /** Check if any GSD workspace scopes exist in internal but not in hoisted node_modules */
 export declare function hasMissingWorkspaceScopes(hoisted: string, internal: string): boolean;
 /**
@@ -47,6 +52,7 @@ export declare function mergedFingerprint(hoisted: string, internal: string): st
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
  * - 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-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
@@ -60,6 +66,7 @@ export declare function mergedFingerprint(hoisted: string, internal: string): st
  */
 export declare function initResources(agentDir: string, skillsDir?: string): void;
 export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string, sourceDir?: string): boolean;
+export declare function hasMissingBundledResourceFiles(destDir: string, sourceDir: string): boolean;
 interface BuildResourceLoaderOptions {
     additionalExtensionPaths?: string[];
 }

package/dist/resource-loader.js

@@ -311,16 +311,15 @@ function copyDirRecursive(src, dest) {
  * them without requiring every call site to use jiti.
  *
  * Layout differences by install method:
- * - Source/monorepo: packageRoot/node_modules has everything → simple symlink
- * - Global install (npm/bun/pnpm): merge hoisted dirname(packageRoot)/node_modules with
- *   packageRoot/node_modules so package-local deps like @sinclair/typebox resolve (#3529, #3564)
+ * - Source/monorepo: packageRoot/node_modules has everything -> simple symlink
+ * - Global install (npm/bun/pnpm): merge the nearest ancestor node_modules
+ *   with packageRoot/node_modules so both hoisted deps like yaml and
+ *   package-local deps like @sinclair/typebox resolve (#3529, #3564).
  */
 function ensureNodeModulesSymlink(agentDir) {
     const agentNodeModules = join(agentDir, 'node_modules');
-    const internalNodeModules = join(packageRoot, 'node_modules');
-    const hoistedNodeModules = dirname(packageRoot);
-    const isGlobalInstall = basename(hoistedNodeModules) === 'node_modules';
-    if (!isGlobalInstall) {
+    const { internalNodeModules, hoistedNodeModules } = resolvePackageNodeModulesLayout(packageRoot);
+    if (!hoistedNodeModules) {
         // Source/monorepo: internal node_modules has everything
         reconcileSymlink(agentNodeModules, internalNodeModules);
         return;
@@ -330,6 +329,23 @@ function ensureNodeModulesSymlink(agentDir) {
     // @gsd/* scopes are hoisted — a hoisted-only symlink breaks extension imports.
     reconcileMergedNodeModules(agentNodeModules, hoistedNodeModules, internalNodeModules);
 }
+export function resolvePackageNodeModulesLayout(root) {
+    return {
+        internalNodeModules: join(root, 'node_modules'),
+        hoistedNodeModules: findNearestNodeModulesAncestor(root),
+    };
+}
+export function findNearestNodeModulesAncestor(startPath) {
+    let current = resolve(startPath);
+    while (true) {
+        if (basename(current) === 'node_modules')
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
 /** Check if any GSD workspace scopes exist in internal but not in hoisted node_modules */
 export function hasMissingWorkspaceScopes(hoisted, internal) {
     if (!existsSync(internal))
@@ -544,6 +560,7 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
  * - 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-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
@@ -584,12 +601,17 @@ export function initResources(agentDir, skillsDir = join(agentDir, 'skills')) {
         // Version matches — check content fingerprint for same-version staleness.
         const currentHash = getCurrentResourceFingerprint();
         const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(extensionsDir, bundledExtensionsDir);
-        if (manifest.contentHash && manifest.contentHash === currentHash && !hasStaleExtensionFiles) {
+        const hasMissingSharedFiles = hasMissingBundledResourceFiles(join(agentDir, 'shared'), join(resourcesDir, 'shared'));
+        if (manifest.contentHash &&
+            manifest.contentHash === currentHash &&
+            !hasStaleExtensionFiles &&
+            !hasMissingSharedFiles) {
             return;
         }
     }
     // Sync bundled resources — overwrite so updates land on next launch.
     syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
+    syncResourceDir(join(resourcesDir, 'shared'), join(agentDir, 'shared'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
     syncResourceDir(join(resourcesDir, 'skills'), skillsDir);
     // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
@@ -627,7 +649,7 @@ function cleanupBundledSkillsFromEcosystemDir() {
                 makeTreeWritable(targetPath);
                 rmSync(targetPath, { recursive: true, force: true });
             }
-            else {
+            else if (process.env.GSD_RESOURCE_LOADER_DEBUG === '1') {
                 console.warn(`[GSD] Leaving ambiguous skill collision in ${targetPath}; ` +
                     `the bundled copy will be used from ~/.gsd/agent/skills/${entry.name}.`);
             }
@@ -675,6 +697,17 @@ export function hasStaleCompiledExtensionSiblings(extensionsDir, sourceDir = bun
     }
     return false;
 }
+export function hasMissingBundledResourceFiles(destDir, sourceDir) {
+    const sourceFiles = collectRelativeFiles(sourceDir);
+    if (sourceFiles.size === 0)
+        return false;
+    const installedFiles = collectRelativeFiles(destDir);
+    for (const relPath of sourceFiles) {
+        if (!installedFiles.has(relPath))
+            return true;
+    }
+    return false;
+}
 function collectRelativeFiles(rootDir) {
     const files = new Set();
     if (!existsSync(rootDir))

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

@@ -1 +1 @@
-f796c99ee5d78c73
+d0f48798d4a50d1f

package/dist/resources/extensions/context7/index.js

@@ -92,6 +92,16 @@ function formatLibraryList(libs, query) {
     lines.push("\nUse the ID (e.g. /websites/react_dev) with get_library_docs to fetch documentation.");
     return lines.join("\n");
 }
+function getFirstTextContent(result) {
+    const content = result.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const textBlock = content.find((block) => typeof block === "object" &&
+        block !== null &&
+        block.type === "text" &&
+        typeof block.text === "string");
+    return textBlock?.text.trim() || undefined;
+}
 // ─── Extension ───────────────────────────────────────────────────────────────
 export default function (pi) {
     // ── resolve_library ──────────────────────────────────────────────────────
@@ -164,7 +174,7 @@ export default function (pi) {
             if (isPartial)
                 return new Text(theme.fg("warning", "Searching Context7..."), 0, 0);
             if (result.isError || d?.error) {
-                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+                return new Text(theme.fg("error", `Error: ${d?.error ?? getFirstTextContent(result) ?? "unknown"}`), 0, 0);
             }
             let text = theme.fg("success", `${d?.resultCount ?? 0} ${d?.resultCount === 1 ? "library" : "libraries"} found`);
             if (d?.cached)
@@ -303,7 +313,7 @@ export default function (pi) {
             if (isPartial)
                 return new Text(theme.fg("warning", "Fetching documentation..."), 0, 0);
             if (result.isError || d?.error) {
-                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+                return new Text(theme.fg("error", `Error: ${d?.error ?? getFirstTextContent(result) ?? "unknown"}`), 0, 0);
             }
             let text = theme.fg("success", `${(d?.charCount ?? 0).toLocaleString()} chars`);
             text += theme.fg("dim", ` · ${d?.tokens ?? 5000} token budget`);

package/dist/resources/extensions/google-cli/index.js

@@ -0,0 +1,30 @@
+/**
+ * Google local CLI providers.
+ *
+ * These deliberately use authMode "externalCli": GSD never owns the browser
+ * OAuth flow or cached tokens. Users authenticate with the official CLI, then
+ * /login activates the provider once the local binary is available.
+ */
+import { GOOGLE_ANTIGRAVITY_MODELS, GOOGLE_GEMINI_CLI_MODELS } from "./models.js";
+import { isAntigravityCliReady, isGeminiCliReady } from "./readiness.js";
+import { streamViaGoogleCli } from "./stream-adapter.js";
+export default function googleCli(pi) {
+    pi.registerProvider("google-gemini-cli", {
+        name: "Google Gemini CLI",
+        authMode: "externalCli",
+        api: "google-gemini-cli",
+        baseUrl: "local://google-gemini-cli",
+        isReady: isGeminiCliReady,
+        streamSimple: streamViaGoogleCli,
+        models: GOOGLE_GEMINI_CLI_MODELS,
+    });
+    pi.registerProvider("google-antigravity", {
+        name: "Google Antigravity",
+        authMode: "externalCli",
+        api: "google-antigravity",
+        baseUrl: "local://google-antigravity",
+        isReady: isAntigravityCliReady,
+        streamSimple: streamViaGoogleCli,
+        models: GOOGLE_ANTIGRAVITY_MODELS,
+    });
+}

package/dist/resources/extensions/google-cli/models.js

@@ -0,0 +1,55 @@
+const ZERO_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+export const GOOGLE_GEMINI_CLI_MODELS = [
+    {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "gemini-3-flash-preview",
+        name: "Gemini 3 Flash Preview",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "gemini-3.1-pro-preview",
+        name: "Gemini 3.1 Pro Preview",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+];
+export const GOOGLE_ANTIGRAVITY_MODELS = [
+    {
+        id: "default",
+        name: "Antigravity Default",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+];

package/dist/resources/extensions/google-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/google-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.js"
+    ]
+  }
+}

package/dist/resources/extensions/google-cli/readiness.js

@@ -0,0 +1,12 @@
+import { spawnSync } from "node:child_process";
+function isCommandInPath(command) {
+    const resolver = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(resolver, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+export function isGeminiCliReady() {
+    return isCommandInPath("gemini");
+}
+export function isAntigravityCliReady() {
+    return isCommandInPath("agy");
+}

package/dist/resources/extensions/google-cli/stream-adapter.js

@@ -0,0 +1,191 @@
+import { spawn } from "node:child_process";
+import { createAssistantMessageEventStream } from "@gsd/pi-ai";
+const ZERO_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function textBlocks(content) {
+    return content
+        .map((block) => block.type === "text" ? block.text : `[${block.type} omitted]`)
+        .join("\n");
+}
+function messageToText(message) {
+    if (message.role === "user") {
+        const content = typeof message.content === "string" ? message.content : textBlocks(message.content);
+        return `User:\n${content}`;
+    }
+    if (message.role === "assistant") {
+        const text = message.content
+            .map((block) => {
+            if (block.type === "text")
+                return block.text;
+            if (block.type === "thinking")
+                return `[thinking omitted]`;
+            if (block.type === "toolCall")
+                return `[tool call: ${block.name}]`;
+            if (block.type === "serverToolUse")
+                return `[server tool: ${block.name}]`;
+            if (block.type === "webSearchResult")
+                return `[web search result omitted]`;
+            return `[${block.type} omitted]`;
+        })
+            .join("\n");
+        return `Assistant:\n${text}`;
+    }
+    return `Tool result (${message.toolName}):\n${textBlocks(message.content)}`;
+}
+export function buildGoogleCliPrompt(context) {
+    const parts = [];
+    if (context.systemPrompt?.trim()) {
+        parts.push(`System instructions:\n${context.systemPrompt.trim()}`);
+    }
+    if (context.messages.length > 0) {
+        parts.push(context.messages.map(messageToText).join("\n\n"));
+    }
+    if (context.tools?.length) {
+        const names = context.tools.map((tool) => tool.name).join(", ");
+        parts.push(`Available local GSD tools were not forwarded to this external CLI bridge. ` +
+            `If you need to act, use the CLI's own tools or ask the user to switch to a provider with native tool-call support. ` +
+            `Requested GSD tools: ${names}`);
+    }
+    return parts.join("\n\n").trim();
+}
+function buildAssistantMessage(model, text, stopReason = "stop", errorMessage) {
+    return {
+        role: "assistant",
+        content: text ? [{ type: "text", text }] : [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: { ...ZERO_USAGE, cost: { ...ZERO_USAGE.cost } },
+        stopReason,
+        ...(errorMessage ? { errorMessage } : {}),
+        timestamp: Date.now(),
+    };
+}
+function extractGeminiJsonResponse(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    try {
+        const parsed = JSON.parse(trimmed);
+        for (const key of ["response", "text", "content", "message"]) {
+            const value = parsed[key];
+            if (typeof value === "string")
+                return value;
+        }
+        return JSON.stringify(parsed, null, 2);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function commandForProvider(provider) {
+    return provider === "google-gemini-cli" ? "gemini" : "agy";
+}
+function argsForProvider(provider, model, prompt) {
+    if (provider === "google-gemini-cli") {
+        const args = ["-p", prompt, "--output-format", "json"];
+        if (model.id !== "default")
+            args.unshift("-m", model.id);
+        return args;
+    }
+    const args = ["-p", prompt];
+    if (model.id !== "default")
+        args.unshift("-m", model.id);
+    return args;
+}
+export function buildGoogleCliSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", command, ...args] };
+    }
+    return { command, args };
+}
+function runCli(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const invocation = buildGoogleCliSpawnInvocation(command, args);
+        const child = spawn(invocation.command, invocation.args, {
+            cwd: options?.cwd || process.cwd(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            options?.signal?.removeEventListener("abort", onAbort);
+            fn();
+        };
+        const onAbort = () => {
+            child.kill("SIGTERM");
+            settle(() => reject(new Error("Request was aborted")));
+        };
+        if (options?.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        options?.signal?.addEventListener("abort", onAbort);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            settle(() => reject(error));
+        });
+        child.on("close", (code, signal) => {
+            settle(() => resolve({ stdout, stderr, code, signal }));
+        });
+    });
+}
+function emitText(stream, message, text) {
+    stream.push({ type: "start", partial: { ...message, content: [] } });
+    if (text) {
+        stream.push({ type: "text_start", contentIndex: 0, partial: message });
+        stream.push({ type: "text_delta", contentIndex: 0, delta: text, partial: message });
+        stream.push({ type: "text_end", contentIndex: 0, content: text, partial: message });
+    }
+    stream.push({ type: "done", reason: "stop", message });
+    stream.end(message);
+}
+function emitError(stream, model, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const output = buildAssistantMessage(model, "", "error", message);
+    stream.push({ type: "error", reason: "error", error: output });
+    stream.end(output);
+}
+export function streamViaGoogleCli(model, context, options) {
+    const stream = createAssistantMessageEventStream();
+    const provider = model.provider;
+    queueMicrotask(async () => {
+        try {
+            const prompt = buildGoogleCliPrompt(context);
+            const command = commandForProvider(provider);
+            const args = argsForProvider(provider, model, prompt);
+            const result = await runCli(command, args, options);
+            if (result.code !== 0) {
+                const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();
+                throw new Error(detail);
+            }
+            const text = provider === "google-gemini-cli"
+                ? extractGeminiJsonResponse(result.stdout)
+                : result.stdout.trim();
+            const message = buildAssistantMessage(model, text);
+            emitText(stream, message, text);
+        }
+        catch (error) {
+            emitError(stream, model, error);
+        }
+    });
+    return stream;
+}