gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/README.md

@@ -7,7 +7,7 @@
 [![npm version](https://img.shields.io/npm/v/gsd-pi?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/gsd-pi)
 [![npm downloads](https://img.shields.io/npm/dm/gsd-pi?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/gsd-pi)
 [![GitHub stars](https://img.shields.io/github/stars/gsd-build/GSD-2?style=for-the-badge&logo=github&color=181717)](https://github.com/gsd-build/GSD-2)
-[![Discord](https://img.shields.io/badge/Discord-Join%20us-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/gsd)
+[![Discord](https://img.shields.io/badge/Discord-Join%20us-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.com/invite/nKXTsAcmbT)
 [![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
 [![$GSD Token](https://img.shields.io/badge/$GSD-Dexscreener-1C1C1C?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIgZmlsbD0iIzAwRkYwMCIvPjwvc3ZnPg==&logoColor=00FF00)](https://dexscreener.com/solana/dwudwjvan7bzkw9zwlbyv6kspdlvhwzrqy6ebk8xzxkv)
 

package/dist/cli.js

@@ -5,7 +5,8 @@ import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
 import { initResources, buildResourceLoader, getNewerManagedResourceVersion } from './resource-loader.js';
 import { ensureManagedTools } from './tool-bootstrap.js';
 import { loadStoredEnvKeys } from './wizard.js';
-import { getPiDefaultModelAndProvider, migratePiCredentials } from './pi-migration.js';
+import { migratePiCredentials } from './pi-migration.js';
+import { validateConfiguredModel } from './startup-model-validation.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
@@ -136,6 +137,7 @@ const hasSubcommand = cliFlags.messages.length > 0;
 if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
     process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
     process.stderr.write('[gsd] Non-interactive alternatives:\n');
+    process.stderr.write('[gsd]   gsd auto                       Auto-mode (pipeable, no TUI)\n');
     process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
     process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
     process.stderr.write('[gsd]   gsd --mode mcp                 MCP server over stdin/stdout\n');
@@ -248,6 +250,22 @@ if (cliFlags.messages[0] === 'headless') {
     await runHeadless(parseHeadlessArgs(process.argv));
     process.exit(0);
 }
+// `gsd auto [args...]` — shorthand for `gsd headless auto [args...]` (#2732)
+// Without this, `gsd auto` falls through to the interactive TUI which hangs
+// when stdin/stdout are piped (non-TTY environments).
+if (cliFlags.messages[0] === 'auto') {
+    await ensureRtkBootstrap();
+    const { runHeadless, parseHeadlessArgs } = await import('./headless.js');
+    // Rewrite argv so parseHeadlessArgs sees: [node, gsd, headless, auto, ...rest]
+    const rewrittenArgv = [
+        process.argv[0],
+        process.argv[1],
+        'headless',
+        ...cliFlags.messages, // ['auto', ...extra args]
+    ];
+    await runHeadless(parseHeadlessArgs(rewrittenArgv));
+    process.exit(0);
+}
 // Pi's tool bootstrap can mis-detect already-installed fd/rg on some systems
 // because spawnSync(..., ["--version"]) returns EPERM despite a zero exit code.
 // Provision local managed binaries first so Pi sees them without probing PATH.
@@ -328,38 +346,6 @@ if (cliFlags.listModels !== undefined) {
     }
     process.exit(0);
 }
-// Validate configured model on startup — catches stale settings from prior installs
-// (e.g. grok-2 which no longer exists) and fresh installs with no settings.
-// Only resets the default when the configured model no longer exists in the registry;
-// never overwrites a valid user choice.
-const configuredProvider = settingsManager.getDefaultProvider();
-const configuredModel = settingsManager.getDefaultModel();
-const allModels = modelRegistry.getAll();
-const availableModels = modelRegistry.getAvailable();
-const configuredExists = configuredProvider && configuredModel &&
-    allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
-const configuredAvailable = configuredProvider && configuredModel &&
-    availableModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
-if (!configuredModel || !configuredExists) {
-    // Model not configured at all, or removed from registry — pick a fallback.
-    // Only fires when the model is genuinely unknown (not just temporarily unavailable).
-    const piDefault = getPiDefaultModelAndProvider();
-    const preferred = (piDefault
-        ? availableModels.find((m) => m.provider === piDefault.provider && m.id === piDefault.model)
-        : undefined) ||
-        availableModels.find((m) => m.provider === 'openai' && m.id === 'gpt-5.4') ||
-        availableModels.find((m) => m.provider === 'openai') ||
-        availableModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
-        availableModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
-        availableModels.find((m) => m.provider === 'anthropic') ||
-        availableModels[0];
-    if (preferred) {
-        settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);
-    }
-}
-if (settingsManager.getDefaultThinkingLevel() !== 'off' && !configuredExists) {
-    settingsManager.setDefaultThinkingLevel('off');
-}
 // GSD always uses quiet startup — the gsd extension renders its own branded header
 if (!settingsManager.getQuietStartup()) {
     settingsManager.setQuietStartup(true);
@@ -405,6 +391,10 @@ if (isPrintMode) {
         resourceLoader,
     });
     markStartup('createAgentSession');
+    // Validate configured model AFTER extensions have registered their models (#2626).
+    // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
+    // registry, causing the user's valid choice to be silently overwritten.
+    validateConfiguredModel(modelRegistry, settingsManager);
     if (extensionsResult.errors.length > 0) {
         for (const err of extensionsResult.errors) {
             // Downgrade conflicts with built-in tools to warnings (#1347)
@@ -488,6 +478,19 @@ if (!cliFlags.worktree && !isPrintMode) {
     catch { /* non-fatal */ }
 }
 // ---------------------------------------------------------------------------
+// Auto-redirect: `gsd auto` with piped stdout → headless mode (#2732)
+// When stdout is not a TTY (e.g. `gsd auto | cat`, `gsd auto > file`),
+// the TUI cannot render and the process hangs. Redirect to headless mode
+// which handles non-interactive output gracefully.
+// ---------------------------------------------------------------------------
+if (cliFlags.messages[0] === 'auto' && !process.stdout.isTTY) {
+    await ensureRtkBootstrap();
+    const { runHeadless, parseHeadlessArgs } = await import('./headless.js');
+    process.stderr.write('[gsd] stdout is not a terminal — running auto-mode in headless mode.\n');
+    await runHeadless(parseHeadlessArgs(['node', 'gsd', 'headless', ...cliFlags.messages.slice(1)]));
+    process.exit(0);
+}
+// ---------------------------------------------------------------------------
 // Interactive mode — normal TTY session
 // ---------------------------------------------------------------------------
 await ensureRtkBootstrap();
@@ -524,6 +527,10 @@ const { session, extensionsResult } = await createAgentSession({
     resourceLoader,
 });
 markStartup('createAgentSession');
+// Validate configured model AFTER extensions have registered their models (#2626).
+// Before this, extension-provided models (e.g. claude-code/*) were not yet in the
+// registry, causing the user's valid choice to be silently overwritten.
+validateConfiguredModel(modelRegistry, settingsManager);
 if (extensionsResult.errors.length > 0) {
     for (const err of extensionsResult.errors) {
         const isSuperseded = err.error.includes("supersedes");
@@ -572,14 +579,21 @@ if (enabledModelPatterns && enabledModelPatterns.length > 0) {
         session.setScopedModels(scopedModels);
     }
 }
-if (!process.stdin.isTTY) {
-    process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
+if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const missing = !process.stdin.isTTY && !process.stdout.isTTY
+        ? 'stdin and stdout are'
+        : !process.stdin.isTTY
+            ? 'stdin is'
+            : 'stdout is';
+    process.stderr.write(`[gsd] Error: Interactive mode requires a terminal (TTY) but ${missing} not a TTY.\n`);
     process.stderr.write('[gsd] Non-interactive alternatives:\n');
+    process.stderr.write('[gsd]   gsd auto                       Auto-mode (pipeable, no TUI)\n');
     process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
     process.stderr.write('[gsd]   gsd --web [path]               Browser-only web mode\n');
     process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
     process.stderr.write('[gsd]   gsd --mode mcp                 MCP server over stdin/stdout\n');
     process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
+    process.stderr.write('[gsd]   gsd headless                   Auto-mode without TUI\n');
     process.exit(1);
 }
 // Welcome screen — shown on every fresh interactive session before TUI takes over.

package/dist/headless-ui.d.ts

@@ -40,8 +40,25 @@ export declare function handleExtensionUIRequest(event: ExtensionUIRequest, clie
 export declare function formatProgress(event: Record<string, unknown>, ctx: ProgressContext): string | null;
 /**
  * Format a thinking preview line from accumulated LLM text deltas.
+ * Used as a fallback when streaming is not enabled — shows a truncated one-liner.
  */
 export declare function formatThinkingLine(text: string): string;
+/**
+ * Format a text_start marker — printed once when the assistant begins a text block.
+ */
+export declare function formatTextStart(): string;
+/**
+ * Format a text_end marker — printed after the last text_delta.
+ */
+export declare function formatTextEnd(): string;
+/**
+ * Format a thinking_start marker.
+ */
+export declare function formatThinkingStart(): string;
+/**
+ * Format a thinking_end marker.
+ */
+export declare function formatThinkingEnd(): string;
 /**
  * Format a cost line (used for periodic cost updates in verbose mode).
  */

package/dist/headless-ui.js

@@ -40,24 +40,45 @@ const c = colorsDisabled ? noColor() : _c;
 export function summarizeToolArgs(toolName, toolInput) {
     const name = String(toolName ?? '');
     const input = (toolInput && typeof toolInput === 'object') ? toolInput : {};
+    // Helper: extract file path from either 'path' or 'file_path' (tools use both)
+    const filePath = () => shortPath(input.path ?? input.file_path) || '';
     switch (name) {
         case 'Read':
         case 'read':
-            return shortPath(input.file_path) || '';
+            return filePath();
         case 'Write':
         case 'write':
-            return shortPath(input.file_path) || '';
+            return filePath();
         case 'Edit':
         case 'edit':
-            return shortPath(input.file_path) || '';
+            return filePath();
+        case 'hashline_edit':
+            return filePath();
         case 'Bash':
         case 'bash': {
             const cmd = String(input.command ?? '');
             return cmd.length > 80 ? cmd.slice(0, 77) + '...' : cmd;
         }
+        case 'async_bash': {
+            const cmd = String(input.command ?? '');
+            return cmd.length > 80 ? cmd.slice(0, 77) + '...' : cmd;
+        }
+        case 'await_job': {
+            const jobs = input.jobs;
+            if (Array.isArray(jobs) && jobs.length > 0)
+                return jobs.join(', ');
+            return '';
+        }
+        case 'cancel_job':
+            return String(input.job_id ?? '');
         case 'Glob':
         case 'glob':
             return String(input.pattern ?? '');
+        case 'find': {
+            const pat = String(input.pattern ?? '');
+            const p = shortPath(input.path);
+            return p ? `${pat} in ${p}` : pat;
+        }
         case 'Grep':
         case 'grep':
         case 'Search':
@@ -66,12 +87,32 @@ export function summarizeToolArgs(toolName, toolInput) {
             const g = input.glob ? ` ${input.glob}` : '';
             return `${pat}${g}`;
         }
+        case 'ls':
+            return shortPath(input.path) || '';
+        case 'lsp': {
+            const action = String(input.action ?? '');
+            const file = shortPath(input.file);
+            const sym = input.symbol ? ` ${input.symbol}` : '';
+            return file ? `${action} ${file}${sym}` : action;
+        }
         case 'Task':
         case 'task': {
             const desc = String(input.description ?? input.prompt ?? '');
             return desc.length > 60 ? desc.slice(0, 57) + '...' : desc;
         }
+        case 'subagent': {
+            const agent = String(input.agent ?? '');
+            const t = String(input.task ?? '');
+            const summary = t.length > 50 ? t.slice(0, 47) + '...' : t;
+            return agent ? `${agent}: ${summary}` : summary;
+        }
+        case 'browser_navigate':
+            return String(input.url ?? '');
         default: {
+            // GSD tools: show milestone/slice/task IDs when present
+            if (name.startsWith('gsd_')) {
+                return summarizeGsdTool(name, input);
+            }
             // Fallback: show first string-valued key up to 60 chars
             for (const v of Object.values(input)) {
                 if (typeof v === 'string' && v.length > 0) {
@@ -82,6 +123,31 @@ export function summarizeToolArgs(toolName, toolInput) {
         }
     }
 }
+/** Summarize GSD extension tool args into a compact identifier string. */
+function summarizeGsdTool(name, input) {
+    const parts = [];
+    if (input.milestoneId)
+        parts.push(String(input.milestoneId));
+    if (input.sliceId)
+        parts.push(String(input.sliceId));
+    if (input.taskId)
+        parts.push(String(input.taskId));
+    if (parts.length > 0) {
+        const id = parts.join('/');
+        // For completion tools, add the one-liner if present
+        if (name.includes('complete') && typeof input.oneLiner === 'string') {
+            const ol = input.oneLiner.length > 50 ? input.oneLiner.slice(0, 47) + '...' : input.oneLiner;
+            return `${id} ${ol}`;
+        }
+        return id;
+    }
+    // Fallback for GSD tools without IDs (e.g. gsd_decision_save)
+    if (input.decision) {
+        const d = String(input.decision);
+        return d.length > 60 ? d.slice(0, 57) + '...' : d;
+    }
+    return '';
+}
 function shortPath(p) {
     if (typeof p !== 'string')
         return '';
@@ -220,12 +286,40 @@ export function formatProgress(event, ctx) {
 }
 /**
  * Format a thinking preview line from accumulated LLM text deltas.
+ * Used as a fallback when streaming is not enabled — shows a truncated one-liner.
  */
 export function formatThinkingLine(text) {
     const trimmed = text.replace(/\s+/g, ' ').trim();
     const truncated = trimmed.length > 120 ? trimmed.slice(0, 117) + '...' : trimmed;
     return `${c.dim}${c.italic}[thinking] ${truncated}${c.reset}`;
 }
+// ---------------------------------------------------------------------------
+// Streaming Text / Thinking Formatters
+// ---------------------------------------------------------------------------
+/**
+ * Format a text_start marker — printed once when the assistant begins a text block.
+ */
+export function formatTextStart() {
+    return `${c.dim}[text]${c.reset}`;
+}
+/**
+ * Format a text_end marker — printed after the last text_delta.
+ */
+export function formatTextEnd() {
+    return ''; // empty — newline handled by caller
+}
+/**
+ * Format a thinking_start marker.
+ */
+export function formatThinkingStart() {
+    return `${c.dim}${c.italic}[thinking]${c.reset}`;
+}
+/**
+ * Format a thinking_end marker.
+ */
+export function formatThinkingEnd() {
+    return ''; // empty — newline handled by caller
+}
 /**
  * Format a cost line (used for periodic cost updates in verbose mode).
  */

package/dist/headless.js

@@ -19,7 +19,7 @@ import { getProjectSessionsDir } from './project-sessions.js';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
 import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
 import { VALID_OUTPUT_FORMATS } from './headless-types.js';
-import { handleExtensionUIRequest, formatProgress, formatThinkingLine, startSupervisedStdinReader, } from './headless-ui.js';
+import { handleExtensionUIRequest, formatProgress, formatThinkingLine, formatTextStart, formatTextEnd, formatThinkingStart, formatThinkingEnd, startSupervisedStdinReader, } from './headless-ui.js';
 import { loadContext, bootstrapGsdProject, } from './headless-context.js';
 /**
  * Resolve a session prefix to a single session.
@@ -291,6 +291,9 @@ async function runHeadlessOnce(options, restartCount) {
     const toolStartTimes = new Map();
     let lastCostData;
     let thinkingBuffer = '';
+    // Streaming state: tracks whether we're inside a text or thinking block
+    let inTextBlock = false;
+    let inThinkingBlock = false;
     // Emit HeadlessJsonResult to stdout for --output-format json batch mode
     function emitBatchJsonResult() {
         if (options.outputFormat !== 'json')
@@ -430,11 +433,58 @@ async function runHeadlessOnce(options, restartCount) {
                     };
                 }
             }
-            // Accumulate thinking text from message_update text_delta events
+            // Stream assistant text and thinking deltas in verbose mode
             if (eventType === 'message_update') {
                 const ame = eventObj.assistantMessageEvent;
-                if (ame?.type === 'text_delta') {
-                    thinkingBuffer += String(ame.text ?? '');
+                if (ame && options.verbose) {
+                    const ameType = String(ame.type ?? '');
+                    // --- Text streaming ---
+                    if (ameType === 'text_start') {
+                        inTextBlock = true;
+                        process.stderr.write(formatTextStart());
+                    }
+                    else if (ameType === 'text_delta') {
+                        const delta = String(ame.delta ?? ame.text ?? '');
+                        if (delta) {
+                            if (!inTextBlock) {
+                                // Edge case: delta without start
+                                inTextBlock = true;
+                                process.stderr.write(formatTextStart());
+                            }
+                            process.stderr.write(delta);
+                        }
+                    }
+                    else if (ameType === 'text_end') {
+                        if (inTextBlock) {
+                            process.stderr.write(formatTextEnd() + '\n');
+                            inTextBlock = false;
+                        }
+                    }
+                    // --- Thinking streaming ---
+                    else if (ameType === 'thinking_start') {
+                        inThinkingBlock = true;
+                        process.stderr.write(formatThinkingStart());
+                    }
+                    else if (ameType === 'thinking_delta') {
+                        const delta = String(ame.delta ?? ame.text ?? '');
+                        if (delta) {
+                            if (!inThinkingBlock) {
+                                inThinkingBlock = true;
+                                process.stderr.write(formatThinkingStart());
+                            }
+                            process.stderr.write(delta);
+                        }
+                    }
+                    else if (ameType === 'thinking_end') {
+                        if (inThinkingBlock) {
+                            process.stderr.write(formatThinkingEnd() + '\n');
+                            inThinkingBlock = false;
+                        }
+                    }
+                }
+                // Non-verbose: accumulate text_delta for truncated one-liner
+                else if (ame?.type === 'text_delta') {
+                    thinkingBuffer += String(ame.delta ?? ame.text ?? '');
                 }
             }
             // Track tool execution start timestamps
@@ -443,8 +493,19 @@ async function runHeadlessOnce(options, restartCount) {
                 if (toolCallId)
                     toolStartTimes.set(toolCallId, Date.now());
             }
-            // Flush thinking buffer before tool calls or message end
-            if (options.verbose && thinkingBuffer.trim() &&
+            // Close any open streaming blocks before tool calls or message end
+            if (options.verbose && (eventType === 'tool_execution_start' || eventType === 'message_end')) {
+                if (inTextBlock) {
+                    process.stderr.write('\n');
+                    inTextBlock = false;
+                }
+                if (inThinkingBlock) {
+                    process.stderr.write('\n');
+                    inThinkingBlock = false;
+                }
+            }
+            // Non-verbose: flush accumulated buffer as truncated one-liner
+            else if (!options.verbose && thinkingBuffer.trim() &&
                 (eventType === 'tool_execution_start' || eventType === 'message_end')) {
                 process.stderr.write(formatThinkingLine(thinkingBuffer) + '\n');
                 thinkingBuffer = '';

package/dist/help-text.js

@@ -160,6 +160,7 @@ export function printHelp(version) {
     process.stdout.write('  update                   Update GSD to the latest version\n');
     process.stdout.write('  sessions                 List and resume a past session\n');
     process.stdout.write('  worktree <cmd>           Manage worktrees (list, merge, clean, remove)\n');
+    process.stdout.write('  auto [args]              Run auto-mode without TUI (pipeable)\n');
     process.stdout.write('  headless [cmd] [args]    Run /gsd commands without TUI (default: auto)\n');
     process.stdout.write('\nRun gsd <subcommand> --help for subcommand-specific help.\n');
 }

package/dist/onboarding.js

@@ -49,6 +49,7 @@ const LLM_PROVIDER_IDS = [
     'xai',
     'openrouter',
     'mistral',
+    'ollama',
     'ollama-cloud',
     'custom-openai',
 ];
@@ -63,6 +64,7 @@ const OTHER_PROVIDERS = [
     { value: 'xai', label: 'xAI (Grok)' },
     { value: 'openrouter', label: 'OpenRouter' },
     { value: 'mistral', label: 'Mistral' },
+    { value: 'ollama', label: 'Ollama (Local)' },
     { value: 'ollama-cloud', label: 'Ollama Cloud' },
     { value: 'custom-openai', label: 'Custom (OpenAI-compatible)' },
 ];
@@ -293,6 +295,9 @@ async function runLlmStep(p, pc, authStorage) {
         if (provider === 'custom-openai') {
             return await runCustomOpenAIFlow(p, pc, authStorage);
         }
+        if (provider === 'ollama') {
+            return await runOllamaLocalFlow(p, pc, authStorage);
+        }
         const label = provider === 'anthropic' ? 'Anthropic'
             : provider === 'openai' ? 'OpenAI'
                 : OTHER_PROVIDERS.find(op => op.value === provider)?.label ?? String(provider);
@@ -382,6 +387,45 @@ async function runApiKeyFlow(p, pc, authStorage, providerId, providerLabel) {
     p.log.success(`API key saved for ${pc.green(providerLabel)}`);
     return true;
 }
+// ─── Ollama Local Flow ───────────────────────────────────────────────────────
+async function runOllamaLocalFlow(p, pc, authStorage) {
+    const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
+    const s = p.spinner();
+    s.start(`Checking Ollama at ${host}...`);
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const response = await fetch(host, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (response.ok) {
+            s.stop(`Ollama is running at ${pc.green(host)}`);
+            // Store a placeholder so the provider is recognized as authenticated
+            authStorage.set('ollama', { type: 'api_key', key: 'ollama' });
+            p.log.success(`${pc.green('Ollama (Local)')} configured — no API key needed`);
+            p.log.info(pc.dim('Models are discovered automatically from your local Ollama instance.'));
+            return true;
+        }
+        else {
+            s.stop('Ollama check failed');
+            p.log.warn(`Ollama responded with status ${response.status} at ${host}`);
+        }
+    }
+    catch {
+        s.stop('Ollama not detected');
+        p.log.warn(`Could not reach Ollama at ${host}`);
+        p.log.info(pc.dim('Install Ollama from https://ollama.com and run "ollama serve"'));
+        p.log.info(pc.dim('Set OLLAMA_HOST if using a non-default address.'));
+    }
+    // Even if not reachable now, save the config — the extension will detect it at runtime
+    const proceed = await p.confirm({
+        message: 'Save Ollama as your provider anyway? (it will auto-detect when running)',
+    });
+    if (p.isCancel(proceed) || !proceed)
+        return false;
+    authStorage.set('ollama', { type: 'api_key', key: 'ollama' });
+    p.log.success(`${pc.green('Ollama (Local)')} saved — models will appear when Ollama is running`);
+    return true;
+}
 // ─── Custom OpenAI-compatible Flow ────────────────────────────────────────────
 async function runCustomOpenAIFlow(p, pc, authStorage) {
     // Prompt for base URL

package/dist/resource-loader.js

@@ -1,4 +1,4 @@
-import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
+import { DefaultResourceLoader, sortExtensionPaths } from '@gsd/pi-coding-agent';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, openSync, closeSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -584,5 +584,20 @@ export function buildResourceLoader(agentDir) {
         agentDir,
         additionalExtensionPaths: piExtensionPaths,
         bundledExtensionNames: bundledKeys,
+        extensionPathsTransform: (paths) => {
+            // 1. Filter community extensions through the GSD registry
+            const filteredPaths = paths.filter((entryPath) => {
+                const manifest = readManifestFromEntryPath(entryPath);
+                if (!manifest)
+                    return true; // no manifest = always load
+                return isExtensionEnabled(registry, manifest.id);
+            });
+            // 2. Sort in topological dependency order
+            const { sortedPaths, warnings } = sortExtensionPaths(filteredPaths);
+            return {
+                paths: sortedPaths,
+                diagnostics: warnings.map((w) => w.message),
+            };
+        },
     });
 }

package/dist/resources/agents/researcher.md

@@ -1,7 +1,7 @@
 ---
 name: researcher
 description: Web researcher that finds and synthesizes current information using Brave Search
-tools: web_search, bash
+tools: search-the-web, bash
 ---
 
 You are a web researcher. You find current, accurate information using web search and synthesize it into a clear, well-structured report.

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

@@ -104,9 +104,22 @@ export default function AskUserQuestions(pi) {
                     if (selected === undefined) {
                         return errorResult("ask_user_questions was cancelled", params.questions);
                     }
-                    answers[q.id] = {
-                        answers: Array.isArray(selected) ? selected : [selected],
-                    };
+                    // When the user picks "None of the above" on a single-select
+                    // question, prompt for a free-text explanation so they are not
+                    // trapped in a re-asking loop (bug #2715).
+                    let freeTextNote = "";
+                    const selectedStr = Array.isArray(selected) ? selected[0] : selected;
+                    if (!q.allowMultiple && selectedStr === OTHER_OPTION_LABEL) {
+                        const note = await ctx.ui.input(`${q.header}: Please explain in your own words`, "Type your answer here…");
+                        if (note) {
+                            freeTextNote = note;
+                        }
+                    }
+                    const answerList = Array.isArray(selected) ? selected : [selected];
+                    if (freeTextNote) {
+                        answerList.push(`user_note: ${freeTextNote}`);
+                    }
+                    answers[q.id] = { answers: answerList };
                 }
                 const roundResult = {
                     endInterview: false,

package/dist/resources/extensions/async-jobs/extension-manifest.json

@@ -8,6 +8,6 @@
   "provides": {
     "tools": ["async_bash", "await_job", "cancel_job"],
     "commands": ["jobs"],
-    "hooks": ["session_start"]
+    "hooks": ["session_start", "session_before_switch", "session_shutdown"]
   }
 }

package/dist/resources/extensions/bg-shell/extension-manifest.json

@@ -8,7 +8,7 @@
   "provides": {
     "tools": ["bg_shell"],
     "commands": ["bg"],
-    "hooks": ["session_shutdown"],
+    "hooks": ["session_shutdown", "session_compact", "session_tree", "session_switch", "before_agent_start", "session_start", "turn_end", "agent_end", "tool_execution_end"],
     "shortcuts": ["Ctrl+Alt+B"]
   }
 }

package/dist/resources/extensions/browser-tools/extension-manifest.json

@@ -29,7 +29,7 @@
       "browser_visual_diff", "browser_zoom_region",
       "browser_generate_test", "browser_action_cache", "browser_check_injection"
     ],
-    "hooks": ["session_shutdown"]
+    "hooks": ["session_start", "session_shutdown"]
   },
   "dependencies": {
     "runtime": ["playwright"]

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -4,6 +4,7 @@
  * Translates the Claude Agent SDK's `BetaRawMessageStreamEvent` sequence
  * into GSD's `AssistantMessageEvent` deltas for incremental TUI rendering.
  */
+import { repairToolJson } from "@gsd/pi-ai";
 // ---------------------------------------------------------------------------
 // Content-block mapping helpers
 // ---------------------------------------------------------------------------
@@ -210,12 +211,19 @@ export class PartialMessageBuilder {
                         block.arguments = JSON.parse(jsonStr);
                     }
                     catch {
-                        // Stream was truncated mid-tool-call — JSON is garbage.
-                        // Preserve the raw string for diagnostics but signal the
-                        // malformation explicitly so downstream consumers can
-                        // distinguish this from a healthy tool completion (#2574).
-                        block.arguments = { _raw: jsonStr };
-                        return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial, malformedArguments: true };
+                        // JSON.parse failed — attempt repair for YAML-style bullet
+                        // lists that LLMs copy from template formatting (#2660).
+                        try {
+                            block.arguments = JSON.parse(repairToolJson(jsonStr));
+                        }
+                        catch {
+                            // Repair also failed — stream was truncated or garbage.
+                            // Preserve the raw string for diagnostics but signal the
+                            // malformation explicitly so downstream consumers can
+                            // distinguish this from a healthy tool completion (#2574).
+                            block.arguments = { _raw: jsonStr };
+                            return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial, malformedArguments: true };
+                        }
                     }
                     return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial };
                 }