@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/utils/export-manager.d.ts

@@ -94,6 +94,15 @@ export declare class ExportManager extends EventEmitter {
         filePath?: string;
         error?: string;
     }>;
+    /**
+     * Export an in-memory conversation (e.g. the live CLI transcript) to a file,
+     * with the same redaction and formatting as session exports.
+     */
+    exportConversationData(data: ConversationExport, format: ExportFormat, options?: Partial<ExportOptions>, prefix?: string): Promise<{
+        success: boolean;
+        filePath?: string;
+        error?: string;
+    }>;
     /**
      * Export session to string
      */

package/dist/utils/export-manager.js

@@ -511,6 +511,25 @@ export class ExportManager extends EventEmitter {
             return { success: false, error: errorMsg };
         }
     }
+    /**
+     * Export an in-memory conversation (e.g. the live CLI transcript) to a file,
+     * with the same redaction and formatting as session exports.
+     */
+    async exportConversationData(data, format, options = {}, prefix = 'conversation') {
+        try {
+            const content = this.formatExport(data, format, options);
+            const filePath = path.join(this.outputDir, this.generateFilename(prefix, format));
+            await this.ensureOutputDir();
+            await fs.writeFile(filePath, content, 'utf-8');
+            this.emit('conversation:exported', { filePath, format });
+            return { success: true, filePath };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            this.emit('error', error);
+            return { success: false, error: errorMsg };
+        }
+    }
     /**
      * Export session to string
      */

package/dist/utils/first-use-hints.d.ts

@@ -0,0 +1,25 @@
+/**
+ * First-use hints (comparatif plan P4, optional part).
+ *
+ * A short contextual tip shown ONCE per profile, the first time the user meets
+ * a surprising behaviour: a command unavailable on this surface, a message
+ * queued behind a running turn, a tool output shortened for the model (exact
+ * output recoverable through restore_context).
+ *
+ * Persistence: one marker file per hint under ~/.codebuddy/hints/ created with
+ * O_EXCL, so concurrent processes (CLI + Cowork) show a hint at most once.
+ * `CODEBUDDY_HINTS=off` disables every hint. Never throws: an unwritable
+ * profile means no hint rather than a repeated one.
+ */
+export type FirstUseHintId = 'surface_unavailable' | 'message_queued' | 'restore_context';
+export declare const FIRST_USE_HINTS: Readonly<Record<FirstUseHintId, {
+    en: string;
+    fr: string;
+}>>;
+export declare function firstUseHintsDir(): string;
+/**
+ * Return the hint text the first time `id` is requested in this profile, then
+ * null forever. The marker is created before the text is returned.
+ */
+export declare function takeFirstUseHint(id: FirstUseHintId, lang?: 'en' | 'fr', dir?: string): string | null;
+export declare function resetFirstUseHints(dir?: string): void;

package/dist/utils/first-use-hints.js

@@ -0,0 +1,58 @@
+/**
+ * First-use hints (comparatif plan P4, optional part).
+ *
+ * A short contextual tip shown ONCE per profile, the first time the user meets
+ * a surprising behaviour: a command unavailable on this surface, a message
+ * queued behind a running turn, a tool output shortened for the model (exact
+ * output recoverable through restore_context).
+ *
+ * Persistence: one marker file per hint under ~/.codebuddy/hints/ created with
+ * O_EXCL, so concurrent processes (CLI + Cowork) show a hint at most once.
+ * `CODEBUDDY_HINTS=off` disables every hint. Never throws: an unwritable
+ * profile means no hint rather than a repeated one.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const FIRST_USE_HINTS = Object.freeze({
+    surface_unavailable: {
+        en: 'Tip: greyed-out commands are not available on this surface yet; run them in the terminal with `buddy`.',
+        fr: 'Astuce : les commandes grisées ne sont pas encore pilotables ici ; lance-les dans un terminal avec `buddy`.',
+    },
+    message_queued: {
+        en: 'Tip: this message was queued while Buddy was busy and runs now; messages sent during a turn always run in order.',
+        fr: 'Astuce : un message envoyé pendant un tour est mis en file et partira à la fin du tour en cours.',
+    },
+    restore_context: {
+        en: 'Tip: long tool outputs are shortened for the model; the exact output stays recoverable with restore_context.',
+        fr: 'Astuce : les longues sorties d’outils sont raccourcies pour le modèle ; la sortie exacte reste récupérable avec restore_context.',
+    },
+});
+export function firstUseHintsDir() {
+    return process.env.CODEBUDDY_HINTS_DIR || path.join(os.homedir(), '.codebuddy', 'hints');
+}
+/**
+ * Return the hint text the first time `id` is requested in this profile, then
+ * null forever. The marker is created before the text is returned.
+ */
+export function takeFirstUseHint(id, lang = 'en', dir = firstUseHintsDir()) {
+    if ((process.env.CODEBUDDY_HINTS ?? '').toLowerCase() === 'off')
+        return null;
+    const hint = FIRST_USE_HINTS[id];
+    if (!hint)
+        return null;
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(path.join(dir, id), `${new Date().toISOString()}\n`, { flag: 'wx', mode: 0o600 });
+        return hint[lang];
+    }
+    catch {
+        return null;
+    }
+}
+export function resetFirstUseHints(dir = firstUseHintsDir()) {
+    for (const id of Object.keys(FIRST_USE_HINTS)) {
+        fs.rmSync(path.join(dir, id), { force: true });
+    }
+}
+//# sourceMappingURL=first-use-hints.js.map

package/dist/utils/graceful-shutdown.d.ts

@@ -11,6 +11,14 @@
  * Intercepts signals: SIGINT (Ctrl+C), SIGTERM (kill), SIGHUP (terminal closed)
  */
 import { type Disposable } from './disposable.js';
+/**
+ * Exit code after a shutdown signal. Only an explicit headless run (`-p`, loop,
+ * try: CODEBUDDY_HEADLESS=true) reports SIGINT as 130 (USER_CANCELLED), so a
+ * script can tell an interruption from success. Servers and daemons whose stdout
+ * is merely not a TTY (systemd) keep exit 0: a normal SIGTERM stop must not be
+ * reported as a failure and trigger Restart=on-failure.
+ */
+export declare function signalExitCode(signal: string, env?: NodeJS.ProcessEnv): number;
 export interface ShutdownOptions {
     /** Maximum time to wait for shutdown in milliseconds (default: 30000) */
     timeoutMs: number;

package/dist/utils/graceful-shutdown.js

@@ -12,6 +12,22 @@
  */
 import { logger, getLogger } from './logger.js';
 import { DisposableManager, registerDisposable } from './disposable.js';
+import { EXIT_CODES } from './exit-codes.js';
+/**
+ * Exit code after a shutdown signal. Only an explicit headless run (`-p`, loop,
+ * try: CODEBUDDY_HEADLESS=true) reports SIGINT as 130 (USER_CANCELLED), so a
+ * script can tell an interruption from success. Servers and daemons whose stdout
+ * is merely not a TTY (systemd) keep exit 0: a normal SIGTERM stop must not be
+ * reported as a failure and trigger Restart=on-failure.
+ */
+export function signalExitCode(signal, env = process.env) {
+    if (env.CODEBUDDY_HEADLESS !== 'true')
+        return 0;
+    return signal === 'SIGINT' ? EXIT_CODES.USER_CANCELLED : 0;
+}
+function shutdownProgressStream() {
+    return process.stdout.isTTY ? process.stdout : process.stderr;
+}
 const DEFAULT_OPTIONS = {
     timeoutMs: 30000, // 30 seconds max before force exit
     forceExitOnTimeout: true,
@@ -69,7 +85,7 @@ export class GracefulShutdownManager {
         // Show user-friendly message
         logger.info(`Received ${signal}. Shutting down gracefully...`);
         try {
-            await this.shutdown({ exitCode: 0 });
+            await this.shutdown({ exitCode: signalExitCode(signal) });
         }
         catch (error) {
             logger.error('Error during shutdown', error instanceof Error ? error : new Error(String(error)));
@@ -232,7 +248,7 @@ export class GracefulShutdownManager {
         for (const handler of this.handlers) {
             try {
                 if (showProgress) {
-                    process.stdout.write(`  [shutdown] ${handler.name}...`);
+                    shutdownProgressStream().write(`  [shutdown] ${handler.name}...`);
                 }
                 logger.debug(`Running shutdown handler: ${handler.name}`);
                 const result = handler.handler();
@@ -241,14 +257,14 @@ export class GracefulShutdownManager {
                 }
                 this.completedHandlers.add(handler.name);
                 if (showProgress) {
-                    process.stdout.write(' done\n');
+                    shutdownProgressStream().write(' done\n');
                 }
                 logger.debug(`Completed shutdown handler: ${handler.name}`);
             }
             catch (error) {
                 this.completedHandlers.add(handler.name); // Mark as completed even on error
                 if (showProgress) {
-                    process.stdout.write(' failed\n');
+                    shutdownProgressStream().write(' failed\n');
                 }
                 logger.error(`Error in shutdown handler ${handler.name}:`, error instanceof Error ? error : new Error(String(error)));
                 // Continue with other handlers even if one fails
@@ -257,18 +273,18 @@ export class GracefulShutdownManager {
         // Then, dispose all registered disposables
         try {
             if (showProgress) {
-                process.stdout.write('  [shutdown] disposing resources...');
+                shutdownProgressStream().write('  [shutdown] disposing resources...');
             }
             logger.debug('Disposing all registered resources...');
             await DisposableManager.getInstance().disposeAll();
             if (showProgress) {
-                process.stdout.write(' done\n');
+                shutdownProgressStream().write(' done\n');
             }
             logger.debug('All resources disposed');
         }
         catch (error) {
             if (showProgress) {
-                process.stdout.write(' failed\n');
+                shutdownProgressStream().write(' failed\n');
             }
             logger.error('Error disposing resources:', error instanceof Error ? error : new Error(String(error)));
         }

package/dist/utils/history-manager.js

@@ -29,7 +29,7 @@ export class HistoryManager {
     };
     static DEFAULT_CONFIG = {
         maxEntries: 1000, // Increased default limit
-        historyFile: path.join(os.homedir(), '.codebuddy', 'history.json'),
+        get historyFile() { return path.join(os.homedir(), '.codebuddy', 'history.json'); },
         excludePrefixes: [], // Include all commands by default
         includeSlashCommands: true, // Include slash commands
     };

package/dist/utils/update-notifier.js

@@ -3,7 +3,7 @@
  *
  * Checks for new versions and notifies users (mistral-vibe style).
  */
-import { existsSync, readFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import https from 'https';
@@ -24,27 +24,17 @@ const DEFAULT_CONFIG = {
  */
 function getCurrentVersion() {
     try {
-        // Try to find package.json from various locations
-        // Works in both local dev and npm global install
-        const possiblePaths = [
-            // Local development or npx
-            join(process.cwd(), 'package.json'),
-            // npm global install (node_modules/@phuetz/code-buddy/package.json)
-            join(process.execPath, '..', '..', 'lib', 'node_modules', '@phuetz', 'code-buddy', 'package.json'),
-        ];
-        for (const pkgPath of possiblePaths) {
-            if (existsSync(pkgPath)) {
-                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-                if (pkg.name?.includes('code-buddy')) {
-                    return pkg.version || '0.0.0';
-                }
-            }
+        // Resolve our own manifest in both src/utils and dist/utils. The caller's
+        // working directory and Node executable do not identify a global npm install.
+        const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+        if (pkg.name === '@phuetz/code-buddy' && typeof pkg.version === 'string' && pkg.version.trim()) {
+            return pkg.version;
         }
-        return '0.0.0';
     }
     catch {
-        return '0.0.0';
+        // An unknown installed version must never produce a fictitious upgrade.
     }
+    return null;
 }
 /**
  * Fetch latest version from npm registry
@@ -147,6 +137,10 @@ export class UpdateNotifier {
             return null;
         }
         const currentVersion = getCurrentVersion();
+        if (!currentVersion) {
+            this.updateInfo = null;
+            return null;
+        }
         // Check cache first
         const cache = loadCache();
         if (cache && !shouldCheckForUpdates(this.config)) {
@@ -184,6 +178,10 @@ export class UpdateNotifier {
      */
     async forceCheck() {
         const currentVersion = getCurrentVersion();
+        if (!currentVersion) {
+            this.updateInfo = null;
+            return null;
+        }
         const latestVersion = await fetchLatestVersion(this.config.packageName, this.config.registryUrl);
         if (!latestVersion) {
             return null;

package/dist/wizard/environment-detection.d.ts

@@ -54,6 +54,8 @@ export declare function detectOllama(): Promise<DetectedCapability>;
 export declare function detectLmStudio(): Promise<DetectedCapability>;
 /** Check the ChatGPT (Codex) OAuth credential file. */
 export declare function detectChatGptOAuth(): Promise<DetectedCapability>;
+/** Offline variant: credential presence only, never refreshes tokens. */
+export declare function detectChatGptOAuthOffline(): Promise<DetectedCapability>;
 /** Check the xAI (Grok) OAuth credential file. */
 export declare function detectXaiOAuth(): Promise<DetectedCapability>;
 /** Report API keys present in the environment (not billed to us, so free:false). */
@@ -62,6 +64,8 @@ export declare function detectApiKeys(): DetectedCapability[];
  * One call to learn everything the setup surfaces need. Free local/OAuth probes
  * run in parallel; the API-key scan is synchronous.
  */
-export declare function detectEnvironment(): Promise<EnvironmentSnapshot>;
+export declare function detectEnvironment(options?: {
+    offline?: boolean;
+}): Promise<EnvironmentSnapshot>;
 /** Compact human summary of what was detected — used by wizard + doctor. */
 export declare function renderDetectionSummary(snapshot: EnvironmentSnapshot): string;

package/dist/wizard/environment-detection.js

@@ -121,6 +121,40 @@ export async function detectChatGptOAuth() {
         return base;
     }
 }
+/** Offline variant: credential presence only, never refreshes tokens. */
+export async function detectChatGptOAuthOffline() {
+    const base = {
+        id: 'chatgpt',
+        label: 'ChatGPT subscription (OAuth, $0)',
+        kind: 'oauth',
+        free: true,
+        available: false,
+        detail: 'not signed in',
+        setupCommand: 'buddy login',
+    };
+    try {
+        const { hasCodexCredentials } = await import('../providers/codex-oauth.js');
+        if (!hasCodexCredentials())
+            return base;
+        return { ...base, available: true, detail: 'credentials present (not verified offline)', setupCommand: undefined };
+    }
+    catch {
+        return base;
+    }
+}
+function notProbedLocalRuntime(id, label, rawHost, setupCommand) {
+    const host = normalizeHost(rawHost);
+    return Promise.resolve({
+        id,
+        label,
+        kind: 'local',
+        free: true,
+        available: false,
+        detail: 'not probed (--offline)',
+        baseURL: `${host}/v1`,
+        setupCommand,
+    });
+}
 /** Check the xAI (Grok) OAuth credential file. */
 export async function detectXaiOAuth() {
     const base = {
@@ -167,13 +201,21 @@ export function detectApiKeys() {
  * One call to learn everything the setup surfaces need. Free local/OAuth probes
  * run in parallel; the API-key scan is synchronous.
  */
-export async function detectEnvironment() {
-    const [ollama, lmstudio, chatgpt, xai] = await Promise.all([
-        detectOllama(),
-        detectLmStudio(),
-        detectChatGptOAuth(),
-        detectXaiOAuth(),
-    ]);
+export async function detectEnvironment(options = {}) {
+    // Offline: no HTTP probe and no OAuth refresh — only local credential files are read.
+    const [ollama, lmstudio, chatgpt, xai] = await Promise.all(options.offline
+        ? [
+            notProbedLocalRuntime('ollama', 'Ollama (local, $0)', process.env.OLLAMA_HOST || OLLAMA_DEFAULT_HOST, 'ollama serve'),
+            notProbedLocalRuntime('lmstudio', 'LM Studio (local, $0)', process.env.LMSTUDIO_HOST || LMSTUDIO_DEFAULT_HOST, 'Start the LM Studio local server'),
+            detectChatGptOAuthOffline(),
+            detectXaiOAuth(),
+        ]
+        : [
+            detectOllama(),
+            detectLmStudio(),
+            detectChatGptOAuth(),
+            detectXaiOAuth(),
+        ]);
     const apiKeys = detectApiKeys();
     const capabilities = [ollama, lmstudio, chatgpt, xai, ...apiKeys];
     // Free path priority: a local Ollama that actually has a model → ChatGPT

package/dist/wizard/onboarding.d.ts

@@ -1,3 +1,4 @@
+import * as readline from 'readline';
 import { type EnvironmentSnapshot } from './environment-detection.js';
 export interface OnboardingResult {
     provider: string;
@@ -47,7 +48,7 @@ export declare const ONBOARDING_PHASES: OnboardingPhase[];
  *   - an entered API key → encrypted credential store (never plaintext in settings),
  *     plus `process.env[envVar]` so the current process resolves immediately.
  *   - ollama → default `OLLAMA_HOST` so auto-detection picks it up.
- * All writes are best-effort; the wizard summary still prints on failure.
+ * Persistence errors propagate so the wizard cannot report a false success.
  */
 export declare function persistProviderSelection(guide: OnboardingProviderGuide, model: string, apiKey: string): Promise<void>;
 export declare const PROJECT_FOLDER_QUESTION = "Which project folder should Code Buddy use?";
@@ -67,4 +68,7 @@ export declare function renderCapabilitiesFooter(): string;
  *  recommended free path at index 0. Availability annotations are appended to
  *  the label so the newcomer sees "(detected)" without extra prose. */
 export declare function orderGuidesByDetection(snapshot: EnvironmentSnapshot): OnboardingProviderGuide[];
+/** Offer to run the isolated 60-second demo right after setup — ending the
+ *  wizard on proof (a green test), not prose. */
+export declare function offerOnboardingDemo(rl: readline.Interface, result: OnboardingResult): Promise<void>;
 export declare function runOnboarding(): Promise<OnboardingResult | null>;

package/dist/wizard/onboarding.js

@@ -1,6 +1,7 @@
 import * as readline from 'readline';
 import { spawn } from 'child_process';
-import { mkdirSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, mkdirSync } from 'fs';
+import { writeJsonAtomicSync } from '../utils/atomic-write.js';
 import { isAbsolute, join, resolve } from 'path';
 import { getValidationConfigForGuide, validateProviderKey, } from './provider-onboarding.js';
 import { detectEnvironment, renderDetectionSummary, } from './environment-detection.js';
@@ -165,31 +166,39 @@ export const ONBOARDING_PHASES = [
         successCheck: 'the selected layer has a doctor/status command or a focused smoke prompt.',
     },
 ];
-const TTS_PROVIDERS = ['pocket', 'elevenlabs', 'piper'];
+const TTS_PROVIDERS = ['piper', 'espeak', 'say', 'audioreader'];
+class OnboardingCancelled extends Error {
+}
 function ask(rl, question, defaultValue) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+        const onClose = () => reject(new OnboardingCancelled('Setup cancelled.'));
+        rl.once('close', onClose);
         const suffix = defaultValue ? ` [${defaultValue}]` : '';
         rl.question(`  ${question}${suffix}: `, (answer) => {
+            rl.removeListener('close', onClose);
             resolve(answer.trim() || defaultValue || '');
         });
     });
 }
-function askChoice(rl, question, choices, defaultIdx) {
-    return new Promise((resolve) => {
-        console.log(`\n  ${question}`);
-        choices.forEach((c, i) => console.log(`    ${i + 1}. ${c}${i === defaultIdx ? ' (default)' : ''}`));
-        rl.question(`  Choice [${defaultIdx + 1}]: `, (answer) => {
-            const idx = parseInt(answer) - 1;
-            const selectedIdx = idx >= 0 && idx < choices.length ? idx : defaultIdx;
-            resolve(choices[selectedIdx] ?? choices[0] ?? '');
-        });
-    });
+async function askChoice(rl, question, choices, defaultIdx) {
+    console.log(`\n  ${question}`);
+    choices.forEach((c, i) => console.log(`    ${i + 1}. ${c}${i === defaultIdx ? ' (default)' : ''}`));
+    while (true) {
+        const answer = await ask(rl, 'Choice', String(defaultIdx + 1));
+        const idx = Number(answer) - 1;
+        if (/^\d+$/.test(answer) && Number.isInteger(idx) && idx >= 0 && idx < choices.length) {
+            return choices[idx];
+        }
+        console.log(`  Please enter a number from 1 to ${choices.length}.`);
+    }
 }
 /** Read a secret without echoing it (masks keystrokes with '*'). The captured
  *  value is always correct regardless of echo; masking is cosmetic, and falls
  *  back to a visible prompt if the terminal doesn't support muting. */
 function askSecret(rl, question) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+        const onClose = () => reject(new OnboardingCancelled('Setup cancelled.'));
+        rl.once('close', onClose);
         const rlAny = rl;
         const original = rlAny._writeToOutput?.bind(rl);
         let muted = false;
@@ -202,6 +211,7 @@ function askSecret(rl, question) {
             };
         }
         rl.question(`  ${question}: `, (answer) => {
+            rl.removeListener('close', onClose);
             if (typeof original === 'function')
                 rlAny._writeToOutput = original;
             resolve(answer.trim());
@@ -216,10 +226,10 @@ function askSecret(rl, question) {
  *   - an entered API key → encrypted credential store (never plaintext in settings),
  *     plus `process.env[envVar]` so the current process resolves immediately.
  *   - ollama → default `OLLAMA_HOST` so auto-detection picks it up.
- * All writes are best-effort; the wizard summary still prints on failure.
+ * Persistence errors propagate so the wizard cannot report a false success.
  */
 export async function persistProviderSelection(guide, model, apiKey) {
-    try {
+    {
         const { getSettingsManager } = await import('../utils/settings-manager.js');
         getSettingsManager().saveUserSettings({
             provider: guide.id,
@@ -229,13 +239,11 @@ export async function persistProviderSelection(guide, model, apiKey) {
             ...(guide.baseURL ? { baseURL: guide.baseURL } : {}),
         });
     }
-    catch { /* non-fatal */ }
     if (guide.authMode === 'api-key' && apiKey) {
-        try {
+        {
             const { getCredentialManager } = await import('../security/credential-manager.js');
             getCredentialManager().setApiKey(apiKey);
         }
-        catch { /* non-fatal */ }
         if (guide.envVar)
             process.env[guide.envVar] = apiKey;
     }
@@ -255,7 +263,13 @@ export function writeConfig(configDir, result) {
     mkdirSync(configDir, { recursive: true });
     const authMode = result.authMode ?? getProviderGuide(result.provider).authMode;
     const recommendedNextCommands = result.recommendedNextCommands ?? buildRecommendedNextCommands(result);
+    const configPath = join(configDir, 'config.json');
+    const previous = existsSync(configPath) ? JSON.parse(readFileSync(configPath, 'utf8')) : {};
+    if (!previous || typeof previous !== 'object' || Array.isArray(previous)) {
+        throw new Error('Existing project config must be a JSON object; it was not overwritten.');
+    }
     const config = {
+        ...previous,
         provider: result.provider,
         model: result.model,
         authMode,
@@ -269,7 +283,9 @@ export function writeConfig(configDir, result) {
     if (result.ttsProvider) {
         config.ttsProvider = result.ttsProvider;
     }
-    writeFileSync(join(configDir, 'config.json'), JSON.stringify(config, null, 2) + '\n');
+    if (!result.ttsEnabled)
+        delete config.ttsProvider;
+    writeJsonAtomicSync(configPath, config);
 }
 export function getProviderGuide(provider) {
     return (PROVIDER_GUIDES.find((guide) => guide.id === provider)
@@ -460,7 +476,7 @@ async function runQuickStart(rl, snapshot, projectDir) {
     const free = snapshot.recommendedFree;
     const ollama = snapshot.capabilities.find((c) => c.id === 'ollama');
     // Case A: a ready free path exists — offer it directly.
-    if (free) {
+    if (free && PROVIDER_GUIDES.some((guide) => guide.id === free.id)) {
         const answer = (await ask(rl, `Start now on ${free.label} — free, no API key needed? (Y/n)`, 'y')).toLowerCase();
         if (answer === 'y' || answer === 'yes' || answer === '') {
             const guide = getProviderGuide(free.id);
@@ -514,17 +530,40 @@ function finishQuickStart(provider, model, baseURL, projectDir) {
 }
 /** Offer to run the isolated 60-second demo right after setup — ending the
  *  wizard on proof (a green test), not prose. */
-async function offerTry(rl) {
+export async function offerOnboardingDemo(rl, result) {
+    if (!['chatgpt', 'ollama', 'lmstudio'].includes(result.provider)) {
+        console.log('  Verify this provider with the first-chat command below.');
+        return;
+    }
     const answer = (await ask(rl, 'Run the 60-second demo now to confirm it works? (Y/n)', 'y')).toLowerCase();
     if (answer === 'y' || answer === 'yes' || answer === '') {
         try {
             const { runTryDemo } = await import('../commands/try.js');
             rl.pause();
-            await runTryDemo();
-            rl.resume();
+            const { getSettingsManager } = await import('../utils/settings-manager.js');
+            const code = await runTryDemo({
+                verbose: false,
+                resolveProvider: async () => ({
+                    kind: result.provider === 'chatgpt' ? 'chatgpt' : 'ollama',
+                    label: `${result.provider} (${result.model})`,
+                    apiKey: result.provider === 'chatgpt' ? 'oauth-chatgpt' : 'local',
+                    baseURL: result.provider === 'chatgpt'
+                        ? 'https://chatgpt.com/backend-api/codex'
+                        : getSettingsManager().getBaseURL(),
+                    model: result.model,
+                }),
+            });
+            if (code !== 0) {
+                process.exitCode = code;
+                console.log('  Setup saved, but the demo failed. First chat is not verified.');
+            }
         }
         catch {
-            console.log('\n  Run it yourself anytime with:  buddy try\n');
+            process.exitCode = 1;
+            console.log('\n  The demo failed. First chat is not verified.\n');
+        }
+        finally {
+            rl.resume();
         }
     }
     else {
@@ -562,7 +601,7 @@ export async function runOnboarding() {
         if (quick) {
             console.log(renderCapabilitiesFooter());
             console.log('');
-            await offerTry(rl);
+            await offerOnboardingDemo(rl, quick);
             return quick;
         }
         console.log(renderOnboardingRoadmap());
@@ -571,8 +610,15 @@ export async function runOnboarding() {
         //    default lands on the recommended free path when there is one.
         const orderedGuides = orderGuidesByDetection(snapshot);
         const provider = await askChoice(rl, 'Which AI provider do you want to use?', orderedGuides.map((guide) => `${guide.id} — ${guide.label}`), 0).then((choice) => choice.split(/\s+—\s+/)[0] ?? choice);
-        const guide = getProviderGuide(provider);
-        const validationConfig = getValidationConfigForGuide(provider);
+        const selectedGuide = getProviderGuide(provider);
+        const detected = snapshot.capabilities.find((capability) => capability.id === provider);
+        const guide = selectedGuide.authMode === 'local' && detected?.baseURL
+            ? { ...selectedGuide, baseURL: detected.baseURL }
+            : selectedGuide;
+        const defaultValidation = getValidationConfigForGuide(provider);
+        const validationConfig = guide.authMode === 'local' && guide.baseURL && defaultValidation
+            ? { ...defaultValidation, baseUrl: guide.baseURL.replace(/\/v1\/?$/, '') }
+            : defaultValidation;
         // 2. Authentication — captured AND verified inline so you leave the wizard
         //    ready to chat. A rejected key never gets persisted; a successful probe
         //    also hands us the provider's real model list for step 3.
@@ -651,10 +697,18 @@ export async function runOnboarding() {
             recommendedNextCommands: buildRecommendedNextCommands({ provider, apiKey, model }),
             ...(ttsProvider ? { ttsProvider } : {}),
         };
+        {
+            const { getTTSManager } = await import('../input/text-to-speech.js');
+            getTTSManager().updateConfig({
+                enabled: ttsEnabled,
+                autoSpeak: ttsEnabled,
+                ...(ttsProvider ? { provider: ttsProvider } : {}),
+            });
+        }
         // 6. Write project config into the folder the user chose
         applyOnboardingProjectConfig(projectDir, result);
         // 7. Summary
-        const ready = verified || (guide.authMode === 'api-key' && Boolean(apiKey));
+        const ready = verified;
         console.log('');
         console.log(`  ${ready ? 'Setup complete — you\'re ready to go!' : 'Setup saved.'}`);
         console.log('');
@@ -688,10 +742,16 @@ export async function runOnboarding() {
         console.log('');
         // Close with a real, runnable test so the wizard ends on proof, not prose.
         if (ready) {
-            await offerTry(rl);
+            await offerOnboardingDemo(rl, result);
         }
         return result;
     }
+    catch (error) {
+        if (!(error instanceof OnboardingCancelled))
+            throw error;
+        console.log('\n  Setup cancelled.');
+        return null;
+    }
     finally {
         rl.close();
     }