@mclean-capital/neura 3.1.0 → 3.3.0

package/dist/commands/install.js

@@ -1,5 +1,4 @@
-import { input, password, confirm } from '@inquirer/prompts';
-import chalk from 'chalk';
+import * as p from '@clack/prompts';
 import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { ensureNeuraHome, loadConfig, saveConfig, getNeuraHome, generateAuthToken, } from '../config.js';
@@ -8,24 +7,13 @@ import { getPlatformLabel } from '../service/detect.js';
 import { checkHealth, waitForHealthy } from '../health.js';
 import { hasCoreBinary, getBundledModelsDir } from '../download.js';
 import { findFreePort } from '../port.js';
-/**
- * Copy any ONNX wake-word models shipped inside the CLI package into
- * `$NEURA_HOME/models/`, but NEVER overwrite files that already exist.
- *
- * Why "never overwrite": users who train their own classifiers with
- * `tools/wake-word/scripts/train.sh` deploy them to the same directory
- * via `deploy.sh`. Overwriting on every `neura install` would clobber
- * their trained models on each upgrade. First-write-wins means the
- * bundled defaults only fill in gaps — once a user has their own
- * `jarvis.onnx` in place, the bundled one stops being used.
- *
- * Returns the list of files actually copied so the caller can print a
- * one-line summary to the user.
- */
+import { PROVIDER_PRESETS, buildRoutingFromFeatures, getVoiceOptions, } from '../providers.js';
+import { validateProviderKey } from '../validate-key.js';
+// ─── Bundled Model Installer ───────────────────────────────────
 function installBundledModels(neuraHome) {
     const src = getBundledModelsDir();
     if (!existsSync(src))
-        return []; // Running from dev / unusual layout
+        return [];
     const dest = join(neuraHome, 'models');
     mkdirSync(dest, { recursive: true });
     const copied = [];
@@ -35,241 +23,577 @@ function installBundledModels(neuraHome) {
                 continue;
             const destPath = join(dest, entry);
             if (existsSync(destPath))
-                continue; // Keep user-trained models
+                continue;
             copyFileSync(join(src, entry), destPath);
             copied.push(entry);
         }
     }
     catch {
-        // Non-fatal: failing to seed the bundled models shouldn't block the
-        // whole install. The core will print a clear warning at connection
-        // time if models are missing, and the user can copy them manually.
+        // Non-fatal — core warns if models are missing.
     }
     return copied;
 }
+// ─── Helpers ───────────────────────────────────────────────────
+function cancelled() {
+    p.outro('Setup cancelled.');
+    process.exit(0);
+}
+/** Restore stdin raw mode on Windows after spinner stops (clack #408). */
+function fixWindowsStdin() {
+    if (process.platform === 'win32' && process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+    }
+}
+function describeExistingFeatures(config) {
+    const features = [];
+    if (config.routing?.voice) {
+        const mode = config.routing.voice.mode === 'realtime' ? 'realtime' : 'pipeline';
+        features.push(`Voice (${mode})`);
+    }
+    if (config.routing?.vision) {
+        features.push(`Vision (${config.routing.vision.mode})`);
+    }
+    if (config.routing?.text) {
+        features.push(`Brain (${config.routing.text.provider})`);
+    }
+    if (config.routing?.embedding) {
+        features.push(`Memory (${config.routing.embedding.provider})`);
+    }
+    if (config.routing?.worker) {
+        features.push(`Agents (${config.routing.worker.provider})`);
+    }
+    return features;
+}
+// ─── Main Install Command ──────────────────────────────────────
 export async function installCommand(opts = {}) {
     const nonInteractive = !!opts.yes;
     const home = getNeuraHome();
-    console.log();
-    console.log(chalk.bold('  Neura Core — Setup'));
-    console.log();
-    console.log(`  Platform:  ${getPlatformLabel()}`);
-    console.log(`  Home:      ${home}`);
-    console.log();
-    // Check if already installed (skip if port not yet assigned)
-    const currentConfig = loadConfig();
-    const existing = (currentConfig.port ?? 0) > 0 ? await checkHealth(currentConfig.port ?? 0) : null;
+    // ── Intro ────────────────────────────────────────────────────
+    p.intro('Neura Setup');
+    // Discover wake words
+    ensureNeuraHome();
+    const config = loadConfig();
+    const seededModels = installBundledModels(home);
+    const modelsDir = join(home, 'models');
+    const infra = new Set(['melspectrogram', 'embedding_model']);
+    let wakeWords = [];
+    try {
+        wakeWords = readdirSync(modelsDir)
+            .filter((f) => f.endsWith('.onnx'))
+            .map((f) => f.replace('.onnx', ''))
+            .filter((name) => !infra.has(name));
+    }
+    catch {
+        // models dir might not exist
+    }
+    const platformInfo = `Platform: ${getPlatformLabel()} · Home: ${home}`;
+    const wakeInfo = wakeWords.length > 0
+        ? `Wake words: ${wakeWords.join(', ')} (active: ${config.assistantName ?? 'jarvis'})`
+        : '';
+    const seedInfo = seededModels.length > 0 ? `Installed ${seededModels.length} wake-word model(s)` : '';
+    p.log.info([platformInfo, wakeInfo, seedInfo].filter(Boolean).join('\n'));
+    // ── Check if already running ─────────────────────────────────
+    const existing = (config.port ?? 0) > 0 ? await checkHealth(config.port ?? 0) : null;
     if (existing) {
-        console.log(chalk.green('  Core is already running on port ' + existing.port));
+        p.log.success(`Core is already running on port ${existing.port}`);
         if (!nonInteractive) {
-            const reinstall = await confirm({
-                message: 'Reinstall?',
-                default: false,
+            const reinstall = await p.confirm({ message: 'Reinstall?', initialValue: false });
+            if (p.isCancel(reinstall) || !reinstall)
+                cancelled();
+        }
+    }
+    // ── Non-interactive mode: skip wizard, go to service registration ──
+    if (nonInteractive) {
+        await registerServiceAndFinish(config);
+        return;
+    }
+    // ── Existing config detection ────────────────────────────────
+    const existingProviders = Object.keys(config.providers ?? {});
+    let keepExisting = false;
+    if (existingProviders.length > 0) {
+        const features = describeExistingFeatures(config);
+        if (features.length > 0) {
+            p.log.info(`Existing features: ${features.join(', ')}`);
+        }
+        const keep = await p.confirm({
+            message: "Re-use existing API keys? (you'll still pick features)",
+            initialValue: true,
+        });
+        if (p.isCancel(keep))
+            cancelled();
+        keepExisting = keep;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // PHASE 1 — Feature Selection
+    // ═══════════════════════════════════════════════════════════════
+    p.log.step("Let's configure your features.");
+    // ── Voice ────────────────────────────────────────────────────
+    const voiceChoice = await p.select({
+        message: 'Voice — How Neura speaks and listens',
+        options: [
+            {
+                value: 'realtime',
+                label: 'Realtime',
+                hint: 'natural, low-latency conversation (xAI Grok)',
+            },
+            {
+                value: 'pipeline',
+                label: 'Pipeline',
+                hint: 'mix-and-match speech providers (STT → LLM → TTS)',
+            },
+            { value: 'skip', label: 'Skip', hint: 'no voice, text-only mode' },
+        ],
+    });
+    if (p.isCancel(voiceChoice))
+        cancelled();
+    const voiceMode = voiceChoice;
+    let sttProvider;
+    let ttsProvider;
+    if (voiceMode === 'pipeline') {
+        const stt = await p.select({
+            message: 'Speech-to-Text provider',
+            options: [{ value: 'deepgram', label: 'Deepgram', hint: 'recommended' }],
+        });
+        if (p.isCancel(stt))
+            cancelled();
+        sttProvider = stt;
+        const tts = await p.select({
+            message: 'Text-to-Speech provider',
+            options: [
+                { value: 'elevenlabs', label: 'ElevenLabs', hint: 'recommended' },
+                { value: 'openai', label: 'OpenAI' },
+            ],
+        });
+        if (p.isCancel(tts))
+            cancelled();
+        ttsProvider = tts;
+    }
+    // ── Vision ───────────────────────────────────────────────────
+    const visionChoice = await p.select({
+        message: 'Vision — How Neura sees your screen and camera',
+        options: [
+            {
+                value: 'streaming',
+                label: 'Streaming',
+                hint: 'continuous awareness, ~0.5 FPS (Google Gemini)',
+            },
+            {
+                value: 'snapshot',
+                label: 'Snapshot',
+                hint: 'on-demand "what am I looking at?" (OpenAI, Anthropic)',
+            },
+            { value: 'skip', label: 'Skip', hint: 'no visual awareness' },
+        ],
+    });
+    if (p.isCancel(visionChoice))
+        cancelled();
+    const visionMode = visionChoice;
+    let snapshotProvider;
+    if (visionMode === 'snapshot') {
+        const snap = await p.select({
+            message: 'Snapshot vision provider',
+            options: [
+                { value: 'openai', label: 'OpenAI', hint: 'GPT-4.1' },
+                { value: 'anthropic', label: 'Anthropic', hint: 'Claude' },
+            ],
+        });
+        if (p.isCancel(snap))
+            cancelled();
+        snapshotProvider = snap;
+    }
+    // ── Brain (required) ─────────────────────────────────────────
+    const brainChoice = await p.select({
+        message: 'Brain — The core AI that powers thinking, tools, and conversation (required)',
+        options: [
+            { value: 'google', label: 'Google Gemini', hint: 'recommended' },
+            { value: 'openai', label: 'OpenAI' },
+            { value: 'anthropic', label: 'Anthropic (Claude)' },
+            { value: 'xai', label: 'xAI (Grok)' },
+            { value: 'openrouter', label: 'OpenRouter', hint: 'gateway to many models' },
+            { value: 'custom', label: 'Custom', hint: 'any OpenAI-compatible endpoint' },
+        ],
+    });
+    if (p.isCancel(brainChoice))
+        cancelled();
+    const brainProvider = brainChoice;
+    let customProvider;
+    if (brainProvider === 'custom') {
+        const name = await p.text({
+            message: 'Provider name (e.g. together, groq):',
+            validate: (v) => (!v || v.length === 0 ? 'Required' : undefined),
+        });
+        if (p.isCancel(name))
+            cancelled();
+        const baseUrl = await p.text({
+            message: 'Base URL (e.g. https://api.together.xyz/v1):',
+            validate: (v) => {
+                if (!v || v.length === 0)
+                    return 'Required';
+                if (!v.startsWith('http'))
+                    return 'Must start with http:// or https://';
+                return undefined;
+            },
+        });
+        if (p.isCancel(baseUrl))
+            cancelled();
+        const model = await p.text({
+            message: 'Default model (e.g. meta-llama/Llama-4-Scout-17B-16E):',
+            validate: (v) => (!v || v.length === 0 ? 'Required' : undefined),
+        });
+        if (p.isCancel(model))
+            cancelled();
+        customProvider = { name: name, baseUrl: baseUrl, model: model };
+    }
+    // ── Memory ───────────────────────────────────────────────────
+    const memoryChoice = await p.select({
+        message: 'Memory — Remember things across conversations',
+        options: [
+            {
+                value: 'google',
+                label: 'Google Gemini Embedding',
+                hint: 'recommended, best recall quality',
+            },
+            { value: 'openai', label: 'OpenAI Embedding' },
+            { value: 'skip', label: 'Skip', hint: 'keyword search only, no semantic recall' },
+        ],
+    });
+    if (p.isCancel(memoryChoice))
+        cancelled();
+    const memoryProvider = memoryChoice;
+    // ── Agents ───────────────────────────────────────────────────
+    const wantAgents = await p.confirm({
+        message: 'Agents — Delegate complex work to AI that operates independently and reports back',
+        initialValue: true,
+    });
+    if (p.isCancel(wantAgents))
+        cancelled();
+    let agentProvider = 'skip';
+    if (wantAgents) {
+        // Collect all text-capable providers the user has already selected
+        const textProviders = new Set();
+        if (voiceMode === 'realtime')
+            textProviders.add('xai');
+        if (brainProvider !== 'custom')
+            textProviders.add(brainProvider);
+        if (customProvider)
+            textProviders.add(customProvider.name);
+        // If vision streaming selected, google is available too
+        if (visionMode === 'streaming')
+            textProviders.add('google');
+        const providerOptions = [...textProviders]
+            .filter((id) => PROVIDER_PRESETS[id]?.capabilities.includes('worker') || id === customProvider?.name)
+            .map((id) => ({
+            value: id,
+            label: PROVIDER_PRESETS[id]?.label ?? id,
+        }));
+        if (providerOptions.length > 1) {
+            const agent = await p.select({
+                message: 'Agent provider',
+                options: providerOptions,
             });
-            if (!reinstall)
-                return;
+            if (p.isCancel(agent))
+                cancelled();
+            agentProvider = agent;
+        }
+        else if (providerOptions.length === 1) {
+            agentProvider = providerOptions[0].value;
+        }
+        else {
+            agentProvider =
+                brainProvider === 'custom' && customProvider ? customProvider.name : brainProvider;
         }
-        // --yes: proceed without asking (this is exactly the post-update path)
     }
-    // Ensure directory structure
-    ensureNeuraHome();
-    const config = loadConfig();
-    // Seed the wake-word models if they aren't already installed. This
-    // runs every `neura install` but is a no-op after the first one —
-    // existing files are never overwritten, so user-trained classifiers
-    // take priority. Prints a one-line summary if anything was copied
-    // along with the list of available wake words.
-    const seededModels = installBundledModels(home);
-    {
-        const modelsDir = join(home, 'models');
-        const infra = new Set(['melspectrogram', 'embedding_model']);
-        let available = [];
-        try {
-            available = readdirSync(modelsDir)
-                .filter((f) => f.endsWith('.onnx'))
-                .map((f) => f.replace('.onnx', ''))
-                .filter((name) => !infra.has(name));
+    // ═══════════════════════════════════════════════════════════════
+    // Build routing from feature selections
+    // ═══════════════════════════════════════════════════════════════
+    const selections = {
+        voice: voiceMode,
+        sttProvider,
+        ttsProvider,
+        vision: visionMode,
+        snapshotProvider,
+        brainProvider,
+        memoryProvider,
+        agentProvider,
+        customProvider,
+    };
+    const result = buildRoutingFromFeatures(selections);
+    // ═══════════════════════════════════════════════════════════════
+    // PHASE 2 — API Key Collection
+    // ═══════════════════════════════════════════════════════════════
+    const keyLines = [];
+    for (const [providerId, features] of result.requiredProviders) {
+        const preset = PROVIDER_PRESETS[providerId];
+        const label = preset?.label ?? providerId;
+        const url = preset?.consoleUrl ?? '';
+        keyLines.push(`${label}  →  ${features.join(', ')}${url ? `\n  ${url}` : ''}`);
+    }
+    p.note(keyLines.join('\n\n'), `You need ${result.requiredProviders.size} API key(s)`);
+    // Collect keys
+    const collectedKeys = {};
+    // Carry over existing keys if keeping config
+    if (keepExisting && config.providers) {
+        for (const [id, creds] of Object.entries(config.providers)) {
+            collectedKeys[id] = { ...creds };
         }
-        catch {
-            // models dir might not exist yet on a completely bare install
+    }
+    for (const [providerId] of result.requiredProviders) {
+        const preset = PROVIDER_PRESETS[providerId];
+        const label = preset?.label ?? providerId;
+        const existingKey = collectedKeys[providerId]?.apiKey;
+        // Custom provider — use the user-provided baseUrl
+        const isCustom = !preset && providerId === customProvider?.name;
+        const baseUrl = isCustom ? customProvider.baseUrl : undefined;
+        const hint = existingKey ? ' (press Enter to keep existing)' : '';
+        const key = await p.password({
+            message: `${label} API Key${hint}:`,
+            mask: '*',
+        });
+        if (p.isCancel(key))
+            cancelled();
+        let finalKey = key || existingKey || '';
+        if (!finalKey) {
+            p.log.warn(`No key provided for ${label} — features using this provider will be unavailable.`);
+            continue;
         }
-        if (seededModels.length > 0 || available.length > 0) {
-            console.log();
-            console.log(chalk.dim('  Wake word models'));
-            if (seededModels.length > 0) {
-                console.log(chalk.green(`  ✓ Installed ${seededModels.length} model(s) to ${home}/models/`));
+        // Validate
+        const s = p.spinner();
+        s.start(`Validating ${label} key...`);
+        const vr = await validateProviderKey(providerId, finalKey, baseUrl);
+        fixWindowsStdin();
+        let validated = false;
+        if (vr.valid) {
+            s.stop(`${label}: Valid`);
+            validated = true;
+        }
+        else {
+            s.stop(`${label}: ${vr.error ?? 'Invalid key'}`);
+            fixWindowsStdin();
+            p.log.warn(`Validation failed: ${vr.error ?? 'Invalid key'}`);
+            const retry = await p.confirm({
+                message: `Try a different ${label} key?`,
+                initialValue: true,
+            });
+            if (p.isCancel(retry))
+                cancelled();
+            if (retry) {
+                const retryKey = await p.password({
+                    message: `${label} API Key:`,
+                    mask: '*',
+                });
+                if (p.isCancel(retryKey))
+                    cancelled();
+                if (retryKey) {
+                    const vr2 = await validateProviderKey(providerId, retryKey, baseUrl);
+                    fixWindowsStdin();
+                    if (vr2.valid) {
+                        finalKey = retryKey;
+                        p.log.success(`${label}: Valid`);
+                        validated = true;
+                    }
+                    else {
+                        p.log.warn(`Retry failed: ${vr2.error ?? 'Invalid key'}`);
+                    }
+                }
             }
-            if (available.length > 0) {
-                console.log(chalk.dim(`  Available wake words: ${available.join(', ')}`));
-                console.log(chalk.dim(`  Active: ${config.assistantName ?? 'jarvis'} (set via: neura config set assistantName <name>)`));
+            if (!validated) {
+                const continueAnyway = await p.confirm({
+                    message: `Continue without a valid ${label} key?`,
+                    initialValue: false,
+                });
+                if (p.isCancel(continueAnyway))
+                    cancelled();
+                if (!continueAnyway)
+                    cancelled();
             }
         }
+        if (validated) {
+            collectedKeys[providerId] = { apiKey: finalKey, baseUrl };
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // PHASE 3 — Final Config
+    // ═══════════════════════════════════════════════════════════════
+    // Show configuration summary
+    const summaryLines = [];
+    const r = result.routing;
+    if (r.voice) {
+        if (r.voice.mode === 'realtime') {
+            summaryLines.push(`✓ Voice:   Realtime (${r.voice.provider} / ${r.voice.model})`);
+        }
+        else {
+            summaryLines.push(`✓ Voice:   Pipeline (STT: ${r.voice.stt.provider}, LLM: ${r.voice.llm.provider}, TTS: ${r.voice.tts.provider})`);
+        }
+    }
+    else {
+        summaryLines.push('✗ Voice:   Skipped');
+    }
+    if (r.vision) {
+        summaryLines.push(`✓ Vision:  ${r.vision.mode === 'streaming' ? 'Streaming' : 'Snapshot'} (${r.vision.provider} / ${r.vision.model})`);
+    }
+    else {
+        summaryLines.push('✗ Vision:  Skipped');
+    }
+    if (r.text) {
+        summaryLines.push(`✓ Brain:   ${r.text.provider} / ${r.text.model}`);
+    }
+    if (r.embedding) {
+        summaryLines.push(`✓ Memory:  ${r.embedding.provider} / ${r.embedding.model} (${r.embedding.dimensions}d)`);
+    }
+    else {
+        summaryLines.push('✗ Memory:  Skipped');
+    }
+    if (r.worker) {
+        summaryLines.push(`✓ Agents:  ${r.worker.provider} / ${r.worker.model}`);
+    }
+    else {
+        summaryLines.push('✗ Agents:  Skipped');
+    }
+    if (result.warnings.length > 0) {
+        summaryLines.push('');
+        for (const w of result.warnings) {
+            summaryLines.push(`⚠ ${w}`);
+        }
     }
-    // API keys — in --yes mode, reuse whatever is already in config.json.
-    // The user already entered these on a previous install; the update
-    // flow should not re-prompt for them.
-    let xaiKey = config.providers?.xai?.apiKey ?? '';
-    let googleKey = config.providers?.google?.apiKey ?? '';
-    if (!nonInteractive) {
-        console.log(chalk.dim('  API Keys'));
-        xaiKey =
-            (await password({
-                message: `XAI_API_KEY${xaiKey ? ' (press Enter to keep existing)' : ''}:`,
-                mask: '*',
-            })) || xaiKey;
-        googleKey =
-            (await password({
-                message: `GOOGLE_API_KEY${googleKey ? ' (press Enter to keep existing)' : ''}:`,
-                mask: '*',
-            })) || googleKey;
-    }
-    // Port — auto-assign unless user already has one configured
-    console.log();
-    console.log(chalk.dim('  Port'));
+    p.note(summaryLines.join('\n'), 'Configuration Summary');
+    // ── Port ─────────────────────────────────────────────────────
     let port;
+    let portSource;
     if ((config.port ?? 0) > 0) {
-        // User has a previously configured port — keep it
         port = config.port;
-        console.log(`  Using configured port: ${port}`);
+        portSource = 'configured';
     }
     else {
-        // Auto-assign a free port in the 18000-19000 range
         port = await findFreePort();
-        console.log(chalk.green(`  ✓ Auto-assigned: ${port}`));
+        portSource = 'auto-assigned';
     }
-    if (!nonInteractive) {
-        const customPort = await input({
-            message: 'Custom port? (leave blank to keep):',
-            default: '',
-            validate: (v) => {
-                if (v === '')
-                    return true;
-                if (!/^\d+$/.test(v))
-                    return 'Must be a number';
-                const n = parseInt(v, 10);
-                if (n < 1 || n > 65535)
-                    return 'Must be 1-65535';
-                return true;
-            },
+    const customPort = await p.text({
+        message: `Port: ${port} (${portSource})`,
+        placeholder: 'press Enter to accept, or type a custom port',
+        defaultValue: String(port),
+        validate: (v) => {
+            if (!v || v === '' || v === String(port))
+                return undefined;
+            if (!/^\d+$/.test(v))
+                return 'Must be a number';
+            const n = parseInt(v, 10);
+            if (n < 1 || n > 65535)
+                return 'Must be 1-65535';
+            return undefined;
+        },
+    });
+    if (p.isCancel(customPort))
+        cancelled();
+    port = parseInt(customPort, 10);
+    // ── Voice selection ──────────────────────────────────────────
+    let voice;
+    const voiceOpts = getVoiceOptions(selections);
+    if (voiceOpts) {
+        const voiceSelect = await p.select({
+            message: 'Voice',
+            options: voiceOpts.voices,
+            initialValue: voiceOpts.defaultVoice,
         });
-        if (customPort) {
-            port = parseInt(customPort, 10);
-        }
+        if (p.isCancel(voiceSelect))
+            cancelled();
+        voice = voiceSelect;
     }
-    // Voice
-    const currentVoice = config.routing?.voice?.mode === 'realtime'
-        ? (config.routing.voice.voice ?? 'eve')
-        : 'eve';
-    const voice = nonInteractive
-        ? currentVoice
-        : await input({
-            message: 'Voice:',
-            default: currentVoice,
-        });
-    // Generate auth token if not already set
+    // ── Assemble and save config ─────────────────────────────────
     if (!config.authToken) {
         config.authToken = generateAuthToken();
     }
-    // Save config in v3 format
-    if (!config.providers)
-        config.providers = {};
-    if (xaiKey)
-        config.providers.xai = { apiKey: xaiKey };
-    if (googleKey)
-        config.providers.google = { apiKey: googleKey };
-    config.port = port;
-    if (config.routing?.voice?.mode === 'realtime') {
-        config.routing.voice.voice = voice;
+    // Merge collected keys into providers
+    config.providers = { ...(keepExisting ? config.providers : {}), ...collectedKeys };
+    // Set routing
+    config.routing = result.routing;
+    // Apply voice to the route
+    if (voice && config.routing.voice) {
+        if (config.routing.voice.mode === 'realtime') {
+            config.routing.voice.voice = voice;
+        }
+        else {
+            config.routing.voice.tts.voice = voice;
+        }
     }
+    config.port = port;
     saveConfig(config);
-    console.log();
-    console.log(chalk.dim('  Config saved to ' + home + '/config.json'));
-    console.log(chalk.dim('  Auth token: ' + chalk.bold('generated')));
-    // Sanity check — core is bundled inside this npm package since v1.11.0,
-    // so it should always be present. If it isn't, the user's CLI install is
-    // corrupted and the only fix is reinstalling from npm.
+    p.log.info(`Config saved to ${home}/config.json`);
+    // ── Service registration & health check ──────────────────────
+    await registerServiceAndFinish(config);
+}
+// ─── Service Registration (shared by interactive and --yes) ────
+async function registerServiceAndFinish(config) {
+    // Sanity check — core is bundled inside this npm package
     if (!hasCoreBinary()) {
-        console.log();
-        console.log(chalk.red('  ✗ Core bundle not found inside this CLI install.\n' +
-            '    This indicates a broken installation. Fix with:\n' +
-            '      npm install -g @mclean-capital/neura@latest'));
-        console.log();
+        p.log.error('Core bundle not found inside this CLI install.\n' +
+            'This indicates a broken installation. Fix with:\n' +
+            '  npm install -g @mclean-capital/neura@latest');
         return;
     }
-    // Register service
-    console.log();
-    console.log(chalk.dim('  Registering service...'));
+    const s = p.spinner();
+    s.start('Registering service...');
     let serviceRegistered = false;
     try {
         const svc = await getServiceManager();
         const wasInstalled = svc.isInstalled();
-        // Always (re)write the service definition. If we only restarted when the
-        // service was already registered, an upgrade that fixes the service file
-        // (e.g. macOS plist ProgramArguments, systemd ExecStart) would never take
-        // effect — the on-disk file would stay stale. Stop the old service first
-        // so the new file gets cleanly loaded.
         if (wasInstalled) {
             try {
                 svc.stop();
             }
             catch {
-                // Service may not be running — that's fine.
+                // Service may not be running
             }
         }
         await svc.install();
-        console.log(chalk.green(`  ✓ Service ${wasInstalled ? 're-registered' : 'registered'} (${getPlatformLabel()})`));
-        // Windows has two install paths (Scheduled Task → preferred, or
-        // Startup folder shim → fallback). Tell the user which one was
-        // used so they understand what to expect — e.g. Task Scheduler
-        // manageability vs. runs-on-next-login. Empty import on non-Windows.
+        s.stop(`Service ${wasInstalled ? 're-registered' : 'registered'} (${getPlatformLabel()})`);
+        fixWindowsStdin();
+        // Windows install mode info
         if (process.platform === 'win32') {
             const win = await import('../service/windows.js');
             const mode = win.getLastInstallMode();
             if (mode === 'startup-shim') {
-                console.log(chalk.dim('  (Using Startup folder shim — schtasks.exe refused to register\n' +
-                    '   the Scheduled Task on this machine, likely due to Windows\n' +
-                    '   policy or corporate restrictions. The core will still run\n' +
-                    '   at each user login. It can be removed from\n' +
-                    '   %APPDATA%\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\.)'));
+                p.log.info('Using Startup folder shim — Scheduled Task registration was not available.\n' +
+                    'Core will still run at each user login.');
             }
             else if (mode === 'scheduled-task') {
-                console.log(chalk.dim('  (Registered in Task Scheduler under name "neura-core")'));
+                p.log.info('Registered in Task Scheduler under name "neura-core"');
             }
         }
         svc.start();
         serviceRegistered = true;
     }
     catch (err) {
-        console.log(chalk.yellow('  Service registration skipped:'));
-        console.log(chalk.yellow('  ' + (err instanceof Error ? err.message : String(err))));
-        console.log(chalk.dim('  Config was saved. Try again after resolving the issue.'));
+        s.stop('Service registration skipped');
+        fixWindowsStdin();
+        p.log.warn(err instanceof Error ? err.message : String(err));
+        p.log.info('Config was saved. Try again after resolving the issue.');
     }
-    // Wait for health (only if service was started)
+    // Wait for health
     if (serviceRegistered) {
-        console.log(chalk.dim('  Starting core...'));
+        const hs = p.spinner();
+        hs.start('Waiting for core...');
         const health = await waitForHealthy(config.port ?? 0);
         if (health) {
-            console.log(chalk.green(`  ✓ Core running on ws://localhost:${health.port}`));
-            console.log(chalk.green('  ✓ Health check: ok'));
+            hs.stop(`Core healthy on port ${health.port}`);
+            fixWindowsStdin();
         }
         else {
-            console.log(chalk.yellow('  Core did not respond within 15s. Check logs: neura logs'));
+            hs.stop('Core did not respond within 15s');
+            fixWindowsStdin();
+            p.log.warn('Check logs: neura logs');
         }
     }
-    console.log();
+    // ── Done ─────────────────────────────────────────────────────
     if (serviceRegistered) {
-        console.log(chalk.bold('  Done!') + ' Connect with any client:');
-        console.log('    Desktop:  Open the Neura desktop app');
-        console.log('    Web:      neura open');
-        console.log('    Status:   neura status');
-        console.log('    Logs:     neura logs');
+        p.note('Desktop:  Open the Neura desktop app\n' +
+            'Web:      neura open\n' +
+            'Status:   neura status\n' +
+            'Logs:     neura logs', 'Ready!');
     }
     else {
-        console.log(chalk.bold('  Config saved.') + ' Service not yet running.');
-        console.log('    neura start    Start the service');
-        console.log('    neura status   Check service state');
+        p.note('neura start    Start the service\n' + 'neura status   Check service state', 'Config saved. Service not yet running.');
     }
-    console.log();
+    p.outro('Setup complete.');
 }
 // Exported for tests only.
 export const __test__ = {