bernard-agent 0.8.0 → 0.9.0

package/dist/repl.js

@@ -43,10 +43,15 @@ const os = __importStar(require("node:os"));
 const paths_js_1 = require("./paths.js");
 const agent_js_1 = require("./agent.js");
 const memory_js_1 = require("./memory.js");
+const reference_resolver_js_1 = require("./reference-resolver.js");
+const reference_tool_lookup_js_1 = require("./reference-tool-lookup.js");
+const web_js_1 = require("./tools/web.js");
+const web_search_js_1 = require("./tools/web-search.js");
 const rag_js_1 = require("./rag.js");
 const mcp_js_1 = require("./mcp.js");
 const output_js_1 = require("./output.js");
 const config_js_1 = require("./config.js");
+const custom_providers_js_1 = require("./custom-providers.js");
 const theme_js_1 = require("./theme.js");
 const update_js_1 = require("./update.js");
 const store_js_1 = require("./cron/store.js");
@@ -54,17 +59,22 @@ const client_js_1 = require("./cron/client.js");
 const history_js_1 = require("./history.js");
 const ai_1 = require("ai");
 const index_js_1 = require("./providers/index.js");
+const prompt_rewriter_js_1 = require("./prompt-rewriter.js");
 const context_js_1 = require("./context.js");
 const domains_js_1 = require("./domains.js");
 const routines_js_1 = require("./routines.js");
 const specialists_js_1 = require("./specialists.js");
+const correction_js_1 = require("./correction.js");
 const specialist_candidates_js_1 = require("./specialist-candidates.js");
+const candidate_bootstrap_js_1 = require("./candidate-bootstrap.js");
 const specialist_detector_js_1 = require("./specialist-detector.js");
 const task_js_1 = require("./tools/task.js");
 const index_js_2 = require("./tools/index.js");
 const output_js_2 = require("./output.js");
 const memory_context_js_1 = require("./memory-context.js");
 const logger_js_1 = require("./logger.js");
+const image_js_1 = require("./image.js");
+const menu_js_1 = require("./menu.js");
 /**
  * Launch the interactive REPL, wiring up readline, MCP servers, memory stores, and the agent loop.
  * @param config - Resolved runtime configuration (provider, model, tokens, etc.).
@@ -72,6 +82,7 @@ const logger_js_1 = require("./logger.js");
  * @param resume - When true, reload the previous conversation from disk and continue it.
  */
 async function startRepl(config, alertContext, resume) {
+    (0, output_js_2.setToolDetailsVisible)(config.toolDetails);
     const SLASH_COMMANDS = [
         { command: '/help', description: 'Show this help' },
         { command: '/clear', description: 'Clear conversation (--save/-s to summarize first)' },
@@ -97,9 +108,11 @@ async function startRepl(config, alertContext, resume) {
         { command: '/specialists', description: 'List specialist agents' },
         { command: '/create-specialist', description: 'Create a specialist with guided AI assistance' },
         { command: '/candidates', description: 'Review specialist suggestions' },
-        { command: '/critic', description: 'Toggle critic mode for response verification' },
-        { command: '/agent-options', description: 'Configure auto-creation for specialist agents' },
-        { command: '/debug', description: 'Print diagnostic report for troubleshooting' },
+        {
+            command: '/agent-options',
+            description: 'Configure agent behavior (toggles, thresholds, saved assets)',
+        },
+        { command: '/image', description: 'Attach an image: /image <path> [prompt]' },
         { command: '/exit', description: 'Quit Bernard' },
     ];
     const routineStore = new routines_js_1.RoutineStore();
@@ -139,7 +152,8 @@ async function startRepl(config, alertContext, resume) {
     function getPromptStr() {
         const { ansi } = (0, theme_js_1.getTheme)();
         const criticLabel = config.criticMode ? `${ansi.warning}\u25C6${ansi.reset} ` : '';
-        return `${criticLabel}${ansi.prompt}bernard>${ansi.reset} `;
+        const reactLabel = config.reactMode ? `${ansi.prompt}\u25B7${ansi.reset} ` : '';
+        return `${criticLabel}${reactLabel}${ansi.prompt}bernard>${ansi.reset} `;
     }
     if (process.stdin.isTTY) {
         process.stdout.write('\x1b[?2004h'); // enable bracket paste mode
@@ -176,9 +190,382 @@ async function startRepl(config, alertContext, resume) {
     let processing = false;
     let interrupted = false;
     let taskAbortController = null;
+    let menuAbortController = null;
+    function createMenuSignal() {
+        menuAbortController = new AbortController();
+        return menuAbortController.signal;
+    }
+    function clearMenuSignal() {
+        menuAbortController = null;
+    }
+    async function toggleBooleanPref(key, label, onMsg, offMsg, onToggle) {
+        const entries = [
+            { label: 'On', active: config[key] === true },
+            { label: 'Off', active: config[key] === false },
+        ];
+        const signal = createMenuSignal();
+        try {
+            const result = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: `${label}: ${config[key] ? 'ON' : 'OFF'}` }, signal);
+            if (!result.cancelled) {
+                config[key] = result.index === 0;
+                (0, config_js_1.savePreferences)({
+                    ...(0, config_js_1.loadPreferences)(),
+                    provider: config.provider,
+                    model: config.model,
+                    [key]: config[key],
+                });
+                onToggle?.(config[key]);
+                (0, output_js_1.printInfo)(config[key] ? onMsg : offMsg);
+            }
+        }
+        finally {
+            clearMenuSignal();
+        }
+        console.log();
+    }
+    function printSpecialistsList() {
+        const specialists = specialistStore.list();
+        if (specialists.length === 0) {
+            (0, output_js_1.printInfo)('No specialist agents defined yet. Ask me to create one or use /create-specialist.');
+            return;
+        }
+        const builtinIds = (0, specialists_js_1.getBuiltinSpecialistIds)();
+        const bundled = specialists.filter((s) => builtinIds.has(s.id));
+        const user = specialists.filter((s) => !builtinIds.has(s.id));
+        const t = (0, theme_js_1.getTheme)();
+        (0, output_js_1.printInfo)(`\n  Specialists (${specialists.length}):`);
+        if (bundled.length > 0) {
+            console.log(t.muted('\n    Bundled:'));
+            for (const s of bundled) {
+                (0, output_js_1.printInfo)(`      ${s.id} — ${s.name}: ${s.description}`);
+            }
+        }
+        if (user.length > 0) {
+            console.log(t.muted('\n    Yours:'));
+            for (const s of user) {
+                (0, output_js_1.printInfo)(`      ${s.id} — ${s.name}: ${s.description}`);
+            }
+        }
+        console.log();
+    }
+    function printRoutinesList(kind) {
+        const all = routineStore.list();
+        const match = all.filter((r) => kind === 'tasks' ? r.id.startsWith('task-') : !r.id.startsWith('task-'));
+        if (match.length === 0) {
+            if (kind === 'tasks') {
+                (0, output_js_1.printInfo)('No tasks saved. Use /create-task to define one.');
+            }
+            else {
+                (0, output_js_1.printInfo)('No routines saved. Teach me a workflow and I can save it as a routine.');
+            }
+            return;
+        }
+        const heading = kind === 'tasks'
+            ? `\n  Tasks (${match.length}) — single-step, structured output:`
+            : `\n  Routines (${match.length}) — multi-step workflows:`;
+        (0, output_js_1.printInfo)(heading);
+        const t = (0, theme_js_1.getTheme)();
+        for (const r of match) {
+            console.log(`    ${t.accent(`/${r.id}`)} ${t.muted(`— ${r.name}: ${r.description}`)}`);
+        }
+        console.log();
+    }
+    function printDebugReport() {
+        const t = (0, theme_js_1.getTheme)();
+        console.log(t.accent('\n  Bernard Diagnostic Report'));
+        console.log(t.accent('  ' + '─'.repeat(40)));
+        console.log(t.text('\n  Runtime:'));
+        console.log(t.muted(`    Bernard version: ${(0, update_js_1.getLocalVersion)()}`));
+        console.log(t.muted(`    Node.js version: ${process.version}`));
+        console.log(t.muted(`    OS: ${process.platform} ${process.arch} (${os.release()})`));
+        console.log(t.text('\n  LLM:'));
+        console.log(t.muted(`    Provider: ${config.provider}`));
+        console.log(t.muted(`    Model: ${config.model}`));
+        console.log(t.muted(`    maxTokens: ${config.maxTokens}`));
+        console.log(t.muted(`    shellTimeout: ${config.shellTimeout}ms`));
+        console.log(t.muted(`    tokenWindow: ${config.tokenWindow || 'auto-detect'}`));
+        console.log(t.text('\n  API Keys:'));
+        for (const { provider, hasKey } of (0, config_js_1.getProviderKeyStatus)()) {
+            console.log(t.muted(`    ${provider}: ${hasKey ? 'configured' : 'not set'}`));
+        }
+        const debugStatuses = mcpManager.getServerStatuses();
+        console.log(t.text('\n  MCP Servers:'));
+        if (debugStatuses.length === 0) {
+            console.log(t.muted('    (none configured)'));
+        }
+        else {
+            for (const s of debugStatuses) {
+                if (s.connected) {
+                    console.log(t.muted(`    ${s.name}: connected (${s.toolCount} tools)`));
+                }
+                else {
+                    console.log(t.muted(`    ${s.name}: failed — ${s.error}`));
+                }
+            }
+        }
+        console.log(t.text('\n  RAG:'));
+        console.log(t.muted(`    Enabled: ${config.ragEnabled}`));
+        if (ragStore) {
+            console.log(t.muted(`    Facts: ${ragStore.count()}`));
+        }
+        console.log(t.text('\n  Memory:'));
+        console.log(t.muted(`    Persistent memories: ${memoryStore.listMemory().length}`));
+        console.log(t.text('\n  Cron:'));
+        console.log(t.muted(`    Daemon: ${(0, client_js_1.isDaemonRunning)() ? 'running' : 'stopped'}`));
+        let debugJobCount = 0;
+        try {
+            const raw = fs.readFileSync(paths_js_1.CRON_JOBS_FILE, 'utf-8');
+            debugJobCount = JSON.parse(raw).length;
+        }
+        catch {
+            // jobs.json doesn't exist yet — that's fine
+        }
+        console.log(t.muted(`    Jobs: ${debugJobCount}`));
+        console.log(t.text('\n  Conversation:'));
+        console.log(t.muted(`    Messages: ${agent.getHistory().length}`));
+        console.log(t.text('\n  Settings:'));
+        console.log(t.muted(`    Theme: ${(0, theme_js_1.getActiveThemeKey)()}`));
+        console.log(t.muted(`    Critic mode: ${config.criticMode ? 'on' : 'off'}`));
+        console.log(t.muted(`    Coordinator mode: ${config.reactMode ? 'on' : 'off'}`));
+        console.log(t.muted(`    Tool details: ${config.toolDetails ? 'on' : 'off'}`));
+        console.log(t.muted(`    Prompt rewriter: ${config.promptRewriter ? 'on' : 'off'}`));
+        const debugEnabled = process.env.BERNARD_DEBUG === 'true' || process.env.BERNARD_DEBUG === '1';
+        console.log(t.muted(`    Debug mode: ${debugEnabled ? 'on' : 'off'}`));
+        console.log(t.text('\n  Paths:'));
+        if (process.env.BERNARD_HOME) {
+            console.log(t.muted(`    BERNARD_HOME: ${process.env.BERNARD_HOME}`));
+        }
+        console.log(t.muted(`    Config: ${paths_js_1.CONFIG_DIR}`));
+        console.log(t.muted(`    Data: ${paths_js_1.DATA_DIR}`));
+        console.log(t.muted(`    Cache: ${paths_js_1.CACHE_DIR}`));
+        console.log(t.muted(`    State: ${paths_js_1.STATE_DIR}`));
+        console.log();
+    }
+    async function promptDisambiguation(reference, candidates) {
+        const entries = [];
+        for (const c of candidates) {
+            entries.push({ label: c.label, description: c.preview });
+        }
+        entries.push({ label: 'Pass as-is (do not resolve)' });
+        for (const c of candidates) {
+            entries.push({ label: `Remember: "${reference}" → ${c.label}` });
+        }
+        const signal = createMenuSignal();
+        try {
+            const result = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: `Ambiguous reference: "${reference}"`, promptLabel: 'Resolve to' }, signal);
+            if (result.cancelled)
+                return { cancelled: true };
+            const idx = result.index;
+            if (idx < candidates.length) {
+                const chosen = candidates[idx];
+                return {
+                    cancelled: false,
+                    passAsIs: false,
+                    entry: {
+                        phrase: reference,
+                        resolvedTo: chosen.label,
+                        sourceKey: chosen.sourceKey,
+                    },
+                    remember: false,
+                };
+            }
+            if (idx === candidates.length) {
+                return { cancelled: false, passAsIs: true };
+            }
+            const rememberIdx = idx - candidates.length - 1;
+            const chosen = candidates[rememberIdx];
+            return {
+                cancelled: false,
+                passAsIs: false,
+                entry: {
+                    phrase: reference,
+                    resolvedTo: chosen.label,
+                    sourceKey: chosen.sourceKey,
+                },
+                remember: true,
+            };
+        }
+        finally {
+            clearMenuSignal();
+        }
+    }
+    function persistReference(reference, value, store) {
+        const baseKey = (0, reference_resolver_js_1.deriveKeyFromReference)(reference) || 'entity';
+        const existing = new Set(store.listMemory());
+        let key = baseKey;
+        let suffix = 2;
+        while (existing.has(key)) {
+            key = `${baseKey}-${suffix++}`;
+        }
+        store.writeMemory(key, value);
+        (0, output_js_1.printInfo)(`  Saved as memory: ${key}`);
+        return { phrase: reference, resolvedTo: value, sourceKey: key };
+    }
+    async function promptUnknownReference(reference, store) {
+        (0, output_js_1.printInfo)(`\n  I don't have memory for "${reference}". Tell me about them and I'll remember.\n  (Enter or Esc skips — the agent will run without this resolved.)`);
+        console.log();
+        const signal = createMenuSignal();
+        try {
+            const result = await (0, menu_js_1.promptValue)(rl, { label: `"${reference}" is` }, signal);
+            if (result.cancelled)
+                return { entry: null };
+            if (!result.raw.trim())
+                return { entry: null };
+            return { entry: persistReference(reference, result.raw, store) };
+        }
+        finally {
+            clearMenuSignal();
+        }
+    }
+    // User confirmation is mandatory — the resolver lookup is a hint, not a fact,
+    // and may have matched the wrong person.
+    async function promptToolLookupConfirmation(reference, resolvedTo, toolName, store) {
+        (0, output_js_1.printInfo)(`\n  Lookup via ${toolName} found a possible match for "${reference}":\n  → ${resolvedTo}`);
+        console.log();
+        const SAVE = 0;
+        const EDIT = 1;
+        const SKIP = 2;
+        const entries = [
+            { label: 'Save as memory', description: resolvedTo },
+            { label: 'Edit before saving' },
+            { label: 'Skip (do not resolve)' },
+        ];
+        const signal = createMenuSignal();
+        try {
+            const result = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: `Save lookup result for "${reference}"?`, promptLabel: 'Choose' }, signal);
+            if (result.cancelled || result.index === SKIP)
+                return { entry: null };
+            let value = resolvedTo;
+            if (result.index === EDIT) {
+                const edited = await (0, menu_js_1.promptValue)(rl, { label: `"${reference}" is` }, signal);
+                if (edited.cancelled || !edited.raw.trim())
+                    return { entry: null };
+                value = edited.raw;
+            }
+            else if (result.index !== SAVE) {
+                return { entry: null };
+            }
+            return { entry: persistReference(reference, value, store) };
+        }
+        finally {
+            clearMenuSignal();
+        }
+    }
+    async function runReferenceResolver(trimmed) {
+        // Strip image-attachment paths and tool-resolvable tokens (URLs, PR/issue refs, file
+        // paths, commit hashes) so the resolver's LLM doesn't mistake them for unresolved
+        // entities. The main agent fetches those directly via shell/gh/web_read.
+        const resolverInput = (0, reference_resolver_js_1.stripToolResolvableTokens)((0, image_js_1.stripImagePaths)(trimmed));
+        if ((0, reference_resolver_js_1.shouldSkipResolver)(resolverInput) || resolverInput.length === 0)
+            return [];
+        try {
+            const hints = (0, memory_js_1.loadRewriterHints)(memoryStore);
+            const resolveSignal = createMenuSignal();
+            let resolveResult;
+            (0, output_js_1.startSpinner)();
+            try {
+                resolveResult = await (0, reference_resolver_js_1.resolveReferences)(resolverInput, memoryStore, config, hints, resolveSignal, ragStore, agent.getHistory());
+            }
+            finally {
+                (0, output_js_1.stopSpinner)();
+                clearMenuSignal();
+            }
+            let entries = [];
+            if (resolveResult.status === 'resolved') {
+                entries = resolveResult.entries;
+            }
+            else if (resolveResult.status === 'ambiguous') {
+                const outcome = await promptDisambiguation(resolveResult.reference, resolveResult.candidates);
+                // Esc/Enter is treated as "pass as-is" — the agent still runs with the original
+                // prompt, consistent with the unknown-reference skip behavior.
+                if (!outcome.cancelled && !outcome.passAsIs) {
+                    entries = [outcome.entry];
+                    if (outcome.remember) {
+                        (0, memory_js_1.saveRewriterHint)(memoryStore, outcome.entry.phrase, outcome.entry.sourceKey);
+                        (0, output_js_1.printInfo)(`  Remembered: "${outcome.entry.phrase}" → ${outcome.entry.sourceKey}`);
+                    }
+                }
+            }
+            else if (resolveResult.status === 'unknown') {
+                // Try a read-only tool lookup before falling back to asking the user.
+                // Fail-open at every layer: any error or `none` drops through to the
+                // existing free-form prompt.
+                let lookupHandled = false;
+                if (config.referenceLookup) {
+                    const lookupSignal = createMenuSignal();
+                    (0, output_js_1.startSpinner)();
+                    let lookup;
+                    try {
+                        lookup = await (0, reference_tool_lookup_js_1.runReferenceLookup)(resolveResult.reference, lookupTools, config, lookupSignal);
+                    }
+                    finally {
+                        (0, output_js_1.stopSpinner)();
+                        clearMenuSignal();
+                    }
+                    if (lookup.status === 'found') {
+                        const outcome = await promptToolLookupConfirmation(resolveResult.reference, lookup.resolvedTo, lookup.toolName, memoryStore);
+                        if (outcome.entry)
+                            entries = [outcome.entry];
+                        lookupHandled = true;
+                    }
+                }
+                if (!lookupHandled) {
+                    const outcome = await promptUnknownReference(resolveResult.reference, memoryStore);
+                    if (outcome.entry)
+                        entries = [outcome.entry];
+                }
+            }
+            if (entries.length > 0) {
+                (0, logger_js_1.debugLog)('repl:resolved-references', {
+                    prompt: trimmed,
+                    entries,
+                    injectedBlock: (0, reference_resolver_js_1.renderResolvedBlock)(entries),
+                });
+            }
+            return entries;
+        }
+        catch (err) {
+            (0, logger_js_1.debugLog)('repl:resolve-references', err instanceof Error ? err.message : String(err));
+            return [];
+        }
+    }
+    async function runPromptRewriter(trimmed, resolvedEntries) {
+        if (!config.promptRewriter)
+            return null;
+        try {
+            const profile = (0, index_js_1.getModelProfile)(config.provider, config.model, config.customProviders?.[config.provider]?.sdk);
+            const rewriteSignal = createMenuSignal();
+            let result;
+            (0, output_js_1.startSpinner)();
+            try {
+                result = await (0, prompt_rewriter_js_1.rewritePrompt)(trimmed, profile, resolvedEntries, config, rewriteSignal);
+            }
+            finally {
+                (0, output_js_1.stopSpinner)();
+                clearMenuSignal();
+            }
+            if (result.status === 'rewritten') {
+                (0, logger_js_1.debugLog)('repl:prompt-rewritten', {
+                    original: trimmed,
+                    rewritten: result.text,
+                    family: profile.family,
+                });
+                return result.text;
+            }
+            return null;
+        }
+        catch (err) {
+            (0, logger_js_1.debugLog)('repl:prompt-rewriter', err instanceof Error ? err.message : String(err));
+            return null;
+        }
+    }
     process.stdin.on('keypress', (_str, key) => {
         if (!key)
             return;
+        if (key.name === 'escape' && menuAbortController) {
+            menuAbortController.abort();
+            return;
+        }
         if (key.name === 'escape' && processing) {
             if (taskAbortController) {
                 taskAbortController.abort();
@@ -267,17 +654,80 @@ async function startRepl(config, alertContext, resume) {
     }
     const mcpTools = mcpManager.getTools();
     const mcpServerNames = mcpManager.getConnectedServerNames();
-    const confirmFn = (command) => {
-        return new Promise((resolve) => {
-            const { ansi } = (0, theme_js_1.getTheme)();
-            rl.question(`${ansi.warning}  ⚠ Dangerous command: ${command}\n  Allow? (y/N): ${ansi.reset}`, (answer) => {
-                resolve(answer.trim().toLowerCase() === 'y');
-            });
-        });
+    // Tool registry exposed to the resolver's pre-fallback lookup pass. Limited
+    // to read-only network tools + MCP tools so a slow or write-side tool can't
+    // be selected. The lookup module further filters via `isAllowedLookupTool`.
+    const lookupTools = {
+        web_search: (0, web_search_js_1.createWebSearchTool)(),
+        web_read: (0, web_js_1.createWebReadTool)(),
+        ...mcpTools,
+    };
+    // The thinking-spinner repaints stdout every 80 ms and would blank any
+    // interactive prompt, so callers that need to talk to the user must run
+    // through this helper to stop the spinner first and restart it after.
+    const withPausedSpinner = async (signal, fn) => {
+        (0, output_js_1.stopSpinner)();
+        try {
+            return await fn();
+        }
+        finally {
+            // Skip restart when the turn is over or aborted — nothing left to think about.
+            if (processing && !signal?.aborted) {
+                resumeSpinner();
+            }
+        }
+    };
+    const confirmFn = (command, signal) => withPausedSpinner(signal, async () => {
+        const result = await (0, menu_js_1.selectFromMenu)(rl, [{ label: 'Allow once' }, { label: 'Cancel' }], { title: `⚠ Dangerous command: ${command}` }, signal);
+        return !result.cancelled && result.index === 0;
+    });
+    const renderTabStrip = (currentIndex, total) => {
+        const theme = (0, theme_js_1.getTheme)();
+        const tabs = [];
+        for (let i = 0; i < total; i++) {
+            const num = String(i + 1);
+            if (i < currentIndex)
+                tabs.push(theme.success(`${num} ✓`));
+            else if (i === currentIndex)
+                tabs.push(theme.accentBold(`▸${num}◂`));
+            else
+                tabs.push(theme.dim(num));
+        }
+        return '  ' + tabs.join('   ');
+    };
+    const askSingleQuestion = async (q, headerLines, signal) => {
+        if (!q.choices || q.choices.length === 0) {
+            const r = await (0, menu_js_1.promptValue)(rl, { label: q.question, headerLines }, signal);
+            return r.cancelled ? null : r.raw;
+        }
+        const entries = q.choices.map((label) => ({ label }));
+        if (q.allowOther)
+            entries.push({ label: q.otherLabel ?? 'Other (type a custom answer)' });
+        const r = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: q.question, headerLines }, signal);
+        if (r.cancelled)
+            return null;
+        if (q.allowOther && r.index === q.choices.length) {
+            const free = await (0, menu_js_1.promptValue)(rl, { label: q.question, headerLines }, signal);
+            return free.cancelled ? null : free.raw;
+        }
+        return q.choices[r.index];
     };
+    const askUserFn = (questions, signal) => withPausedSpinner(signal, async () => {
+        const answered = [];
+        const showTabs = questions.length > 1;
+        for (let i = 0; i < questions.length; i++) {
+            const headerLines = showTabs ? [renderTabStrip(i, questions.length)] : undefined;
+            const answer = await askSingleQuestion(questions[i], headerLines, signal);
+            if (answer === null)
+                return { cancelled: true, answered };
+            answered.push(answer);
+        }
+        return { answers: answered };
+    });
     const toolOptions = {
         shellTimeout: config.shellTimeout,
         confirmDangerous: confirmFn,
+        askUser: askUserFn,
     };
     const historyStore = new history_js_1.HistoryStore();
     let initialHistory;
@@ -304,14 +754,10 @@ async function startRepl(config, alertContext, resume) {
             (0, output_js_1.printInfo)('No previous conversation found — starting fresh.');
         }
     }
-    // Surface pending specialist candidates at session start
-    candidateStore.pruneOld();
-    candidateStore.reconcileSaved(specialistStore.list());
-    const pendingCandidates = candidateStore.listPending();
-    if (pendingCandidates.length > 0) {
+    const { pending: pendingCandidates, contextBlock } = (0, candidate_bootstrap_js_1.bootstrapPendingCandidates)(candidateStore, specialistStore, config);
+    if (contextBlock) {
         (0, output_js_1.printInfo)(`  ${pendingCandidates.length} specialist suggestion(s) pending. Use /candidates to review.`);
-        const candidateContext = `## Specialist Suggestions\n\nBernard detected patterns in previous sessions that might benefit from saved specialists. Mention these when relevant.\n\n${pendingCandidates.map((c) => `- "${c.name}" (${c.draftId}): ${c.description}`).join('\n')}`;
-        alertContext = alertContext ? alertContext + '\n\n' + candidateContext : candidateContext;
+        alertContext = alertContext ? alertContext + '\n\n' + contextBlock : contextBlock;
     }
     const agent = new agent_js_1.Agent(config, toolOptions, memoryStore, mcpTools, mcpServerNames, alertContext, initialHistory, ragStore, routineStore, specialistStore, candidateStore);
     let cleanedUp = false;
@@ -348,22 +794,66 @@ async function startRepl(config, alertContext, resume) {
         catch {
             // Silent failure — don't block exit
         }
+        // Run the correction agent over any tool-wrapper failures queued this
+        // session. Best-effort; never block shutdown on errors.
+        if (config.correctionEnabled) {
+            try {
+                const correctionStore = agent.getCorrectionStore();
+                const pending = correctionStore.listPending();
+                if (pending.length > 0) {
+                    (0, output_js_1.printInfo)(`Reviewing ${pending.length} tool-wrapper failure(s) for learning...`);
+                    const result = await (0, correction_js_1.runCorrectionAgent)({
+                        config,
+                        toolOptions,
+                        memoryStore,
+                        specialistStore: agent.getSpecialistStore(),
+                        correctionStore,
+                        ragStore,
+                        routineStore,
+                        candidateStore,
+                        mcpTools,
+                    }, pending);
+                    if (result.applied > 0) {
+                        (0, output_js_1.printInfo)(`  Learned from ${result.applied}/${result.processed} failure(s); examples updated.`);
+                    }
+                }
+            }
+            catch (err) {
+                (0, logger_js_1.debugLog)('correction:error', err instanceof Error ? err.message : String(err));
+            }
+        }
         await mcpManager.close();
     };
+    // Tracks the SpinnerStats for the in-flight turn so resumeSpinner() can
+    // re-attach the spinner after a pause (e.g. an ask_user prompt) without
+    // resetting startTime or the running token totals.
+    let activeSpinnerStats = null;
+    function initSpinner() {
+        const spinnerStats = {
+            startTime: Date.now(),
+            totalPromptTokens: 0,
+            totalCompletionTokens: 0,
+            latestPromptTokens: 0,
+            model: config.model,
+            contextWindowOverride: config.tokenWindow || undefined,
+        };
+        activeSpinnerStats = spinnerStats;
+        agent.setSpinnerStats(spinnerStats);
+        (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
+    }
+    function resumeSpinner() {
+        const stats = activeSpinnerStats;
+        if (!stats) {
+            initSpinner();
+            return;
+        }
+        (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(stats));
+    }
     async function runGuidedCreation(message) {
         processing = true;
         interrupted = false;
         try {
-            const spinnerStats = {
-                startTime: Date.now(),
-                totalPromptTokens: 0,
-                totalCompletionTokens: 0,
-                latestPromptTokens: 0,
-                model: config.model,
-                contextWindowOverride: config.tokenWindow || undefined,
-            };
-            agent.setSpinnerStats(spinnerStats);
-            (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
+            initSpinner();
             await agent.processInput(message);
             historyStore.save(agent.getHistory());
         }
@@ -384,10 +874,7 @@ async function startRepl(config, alertContext, resume) {
         console.log();
         void prompt();
     }
-    /**
-     * Execute a task in single-step mode (maxSteps: 2) with structured JSON output.
-     * Used by both /task <description> and /task-{id} saved task invocations.
-     */
+    /** Execute a task with structured JSON output. Used by /task and /task-{id}. */
     async function executeTask(description, context) {
         processing = true;
         interrupted = false;
@@ -420,14 +907,17 @@ async function startRepl(config, alertContext, resume) {
             if (context) {
                 userMessage += `\n\nAdditional context: ${context}`;
             }
+            const taskMaxSteps = (0, task_js_1.getTaskMaxSteps)(config);
             const result = await (0, ai_1.generateText)({
-                model: (0, index_js_1.getModel)(config.provider, config.model),
+                model: (0, index_js_1.getModelForConfig)(config, config.provider, config.model),
+                providerOptions: (0, index_js_1.getProviderOptionsForConfig)(config, config.provider),
                 tools: baseTools,
-                maxSteps: 2,
+                maxSteps: taskMaxSteps,
                 maxTokens: config.maxTokens,
                 system: systemPrompt,
                 messages: [{ role: 'user', content: userMessage }],
                 abortSignal: taskAbortController.signal,
+                experimental_prepareStep: (0, task_js_1.makeLastStepTextOnly)(taskMaxSteps),
                 onStepFinish: ({ text, toolCalls, toolResults }) => {
                     for (const tc of toolCalls) {
                         (0, output_js_2.printToolCall)(tc.toolName, tc.args);
@@ -528,7 +1018,8 @@ async function startRepl(config, alertContext, resume) {
                             const serialized = (0, context_js_1.serializeMessages)(history);
                             const [summaryResult, domainFacts, candidateResult] = await Promise.all([
                                 (0, ai_1.generateText)({
-                                    model: (0, index_js_1.getModel)(config.provider, config.model),
+                                    model: (0, index_js_1.getModelForConfig)(config, config.provider, config.model),
+                                    providerOptions: (0, index_js_1.getProviderOptionsForConfig)(config, config.provider),
                                     maxTokens: 2048,
                                     system: context_js_1.SUMMARIZATION_PROMPT,
                                     messages: [
@@ -568,12 +1059,16 @@ async function startRepl(config, alertContext, resume) {
                                         const created = candidateStore.create(candidateResult.candidate, 'clear-save');
                                         if (config.autoCreateSpecialists &&
                                             candidateResult.candidate.confidence >= config.autoCreateThreshold) {
-                                            // Auto-create the specialist
-                                            specialistStore.create(candidateResult.candidate.draftId, candidateResult.candidate.name, candidateResult.candidate.description, candidateResult.candidate.systemPrompt, candidateResult.candidate.guidelines);
-                                            candidateStore.updateStatus(created.id, 'accepted');
-                                            (0, output_js_1.printInfo)(`Specialist auto-created: "${candidateResult.candidate.name}" (confidence: ${Math.round(candidateResult.candidate.confidence * 100)}%). Use /specialists to view.`);
+                                            (0, candidate_bootstrap_js_1.promoteCandidate)({ ...candidateResult.candidate, id: created.id }, specialistStore, candidateStore, config.autoCreateThreshold);
                                         }
                                         else {
+                                            (0, logger_js_1.debugLog)('repl:auto-create', {
+                                                action: 'skipped',
+                                                candidate: candidateResult.candidate.name,
+                                                confidence: candidateResult.candidate.confidence,
+                                                threshold: config.autoCreateThreshold,
+                                                autoCreateEnabled: config.autoCreateSpecialists,
+                                            });
                                             (0, output_js_1.printInfo)(`Specialist suggestion detected: "${candidateResult.candidate.name}". Use /candidates to review.`);
                                         }
                                     }
@@ -599,7 +1094,7 @@ async function startRepl(config, alertContext, resume) {
                 agent.clearHistory();
                 historyStore.clear();
                 console.clear();
-                (0, output_js_1.printWelcome)(config.provider, config.model, (0, update_js_1.getLocalVersion)());
+                (0, output_js_1.printWelcome)(config.provider, config.model, (0, update_js_1.getLocalVersion)(), config.customProviders?.[config.provider]?.baseURL);
                 (0, output_js_1.printInfo)('Conversation history and scratch notes cleared.');
                 void prompt();
                 return;
@@ -785,73 +1280,131 @@ async function startRepl(config, alertContext, resume) {
             }
             if (trimmed === '/provider') {
                 const available = (0, config_js_1.getAvailableProviders)(config);
-                if (available.length === 0) {
-                    (0, output_js_1.printError)('No providers have API keys configured.');
-                    void prompt();
-                    return;
-                }
-                (0, output_js_1.printInfo)(`\n  Current: ${config.provider} (${config.model})\n`);
-                (0, output_js_1.printInfo)('  Available providers:');
-                for (let i = 0; i < available.length; i++) {
-                    (0, output_js_1.printInfo)(`    ${i + 1}. ${available[i]}`);
-                }
-                console.log();
-                rl.question(`  Select [1-${available.length}]: `, (answer) => {
-                    const num = parseInt(answer.trim(), 10);
-                    if (num >= 1 && num <= available.length) {
-                        config.provider = available[num - 1];
-                        config.model = (0, config_js_1.getDefaultModel)(config.provider);
-                        (0, config_js_1.savePreferences)({
-                            provider: config.provider,
-                            model: config.model,
-                            maxTokens: config.maxTokens,
-                            shellTimeout: config.shellTimeout,
-                            tokenWindow: config.tokenWindow,
-                            theme: config.theme,
+                const customProviders = config.customProviders ?? {};
+                const builtinAvailable = available.filter((p) => !customProviders[p]);
+                const customAvailable = available.filter((p) => customProviders[p]);
+                const entries = [];
+                for (const p of builtinAvailable)
+                    entries.push({ label: p, value: p });
+                if (customAvailable.length > 0) {
+                    entries.push({ type: 'section', title: 'Custom:' });
+                    for (const p of customAvailable) {
+                        const entry = customProviders[p];
+                        entries.push({
+                            label: p,
+                            annotation: `(${entry.sdk} → ${entry.baseURL})`,
+                            value: p,
                         });
-                        (0, output_js_1.printInfo)(`  Switched to ${config.provider} (${config.model})`);
                     }
-                    else {
-                        (0, output_js_1.printInfo)('  Cancelled.');
+                }
+                if (builtinAvailable.length === 0 && customAvailable.length === 0) {
+                    (0, output_js_1.printInfo)('No providers have API keys configured yet — add one below.');
+                }
+                entries.push({ type: 'section', title: '' });
+                entries.push({ label: '+ Add custom provider…', value: '__add__' });
+                const signal = createMenuSignal();
+                try {
+                    const result = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: `Providers — current: ${config.provider} (${config.model})` }, signal);
+                    if (!result.cancelled) {
+                        const value = result.item.value;
+                        if (value === '__add__') {
+                            const added = await runAddProviderWizard(rl, createMenuSignal, clearMenuSignal);
+                            if (added) {
+                                config.customProviders = {
+                                    ...customProviders,
+                                    [added.entry.name]: added.entry,
+                                };
+                                config.apiKeys = { ...(config.apiKeys ?? {}), [added.entry.name]: added.apiKey };
+                                config.provider = added.entry.name;
+                                config.model = added.entry.defaultModel;
+                                (0, config_js_1.savePreferences)({
+                                    provider: config.provider,
+                                    model: config.model,
+                                    maxTokens: config.maxTokens,
+                                    shellTimeout: config.shellTimeout,
+                                    tokenWindow: config.tokenWindow,
+                                    theme: config.theme,
+                                });
+                                (0, output_js_1.printInfo)(`  Added and switched to ${added.entry.name} (${added.entry.defaultModel})`);
+                            }
+                        }
+                        else {
+                            config.provider = value;
+                            config.model = (0, config_js_1.getDefaultModel)(config.provider, customProviders);
+                            (0, config_js_1.savePreferences)({
+                                provider: config.provider,
+                                model: config.model,
+                                maxTokens: config.maxTokens,
+                                shellTimeout: config.shellTimeout,
+                                tokenWindow: config.tokenWindow,
+                                theme: config.theme,
+                            });
+                            (0, output_js_1.printInfo)(`  Switched to ${config.provider} (${config.model})`);
+                        }
                     }
-                    console.log();
-                    void prompt();
-                });
+                }
+                finally {
+                    clearMenuSignal();
+                }
+                console.log();
+                void prompt();
                 return;
             }
             if (trimmed === '/model') {
-                const models = config_js_1.PROVIDER_MODELS[config.provider];
+                const customProviders = config.customProviders ?? {};
+                const customEntry = customProviders[config.provider];
+                const models = customEntry ? customEntry.models : config_js_1.PROVIDER_MODELS[config.provider];
                 if (!models || models.length === 0) {
                     (0, output_js_1.printError)(`No models listed for provider "${config.provider}".`);
                     void prompt();
                     return;
                 }
-                (0, output_js_1.printInfo)(`\n  Current: ${config.provider} / ${config.model}\n`);
-                (0, output_js_1.printInfo)('  Available models:');
-                for (let i = 0; i < models.length; i++) {
-                    (0, output_js_1.printInfo)(`    ${i + 1}. ${models[i]}`);
+                const entries = models.map((m) => ({ label: m, value: m }));
+                if (customEntry) {
+                    entries.push({ type: 'section', title: '' });
+                    entries.push({ label: '+ Type a new model name…', value: '__free__' });
                 }
-                console.log();
-                rl.question(`  Select [1-${models.length}]: `, (answer) => {
-                    const num = parseInt(answer.trim(), 10);
-                    if (num >= 1 && num <= models.length) {
-                        config.model = models[num - 1];
-                        (0, config_js_1.savePreferences)({
-                            provider: config.provider,
-                            model: config.model,
-                            maxTokens: config.maxTokens,
-                            shellTimeout: config.shellTimeout,
-                            tokenWindow: config.tokenWindow,
-                            theme: config.theme,
-                        });
-                        (0, output_js_1.printInfo)(`  Switched to ${config.model}`);
-                    }
-                    else {
-                        (0, output_js_1.printInfo)('  Cancelled.');
+                const signal = createMenuSignal();
+                try {
+                    const result = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: `Models — current: ${config.provider} / ${config.model}` }, signal);
+                    if (!result.cancelled) {
+                        const value = result.item.value;
+                        let chosenModel = null;
+                        if (value === '__free__' && customEntry) {
+                            const valueResult = await (0, menu_js_1.promptValue)(rl, { label: 'Model name' }, createMenuSignal());
+                            clearMenuSignal();
+                            if (!valueResult.cancelled) {
+                                const newModel = valueResult.raw.trim();
+                                if (newModel) {
+                                    (0, custom_providers_js_1.rememberCustomModel)(config.provider, newModel);
+                                    // Refresh local copy
+                                    config.customProviders = (0, custom_providers_js_1.loadCustomProviders)();
+                                    chosenModel = newModel;
+                                }
+                            }
+                        }
+                        else {
+                            chosenModel = value;
+                        }
+                        if (chosenModel) {
+                            config.model = chosenModel;
+                            (0, config_js_1.savePreferences)({
+                                provider: config.provider,
+                                model: config.model,
+                                maxTokens: config.maxTokens,
+                                shellTimeout: config.shellTimeout,
+                                tokenWindow: config.tokenWindow,
+                                theme: config.theme,
+                            });
+                            (0, output_js_1.printInfo)(`  Switched to ${config.model}`);
+                        }
                     }
-                    console.log();
-                    void prompt();
-                });
+                }
+                finally {
+                    clearMenuSignal();
+                }
+                console.log();
+                void prompt();
                 return;
             }
             if (trimmed === '/theme') {
@@ -859,26 +1412,24 @@ async function startRepl(config, alertContext, resume) {
                 const currentKey = (0, theme_js_1.getActiveThemeKey)();
                 const regularKeys = allKeys.filter((k) => k !== 'high-contrast' && k !== 'colorblind');
                 const a11yKeys = allKeys.filter((k) => k === 'high-contrast' || k === 'colorblind');
-                (0, output_js_1.printInfo)(`\n  Current theme: ${theme_js_1.THEMES[currentKey].name}\n`);
-                (0, output_js_1.printInfo)('  Themes:');
-                let idx = 1;
-                for (const k of regularKeys) {
-                    const marker = k === currentKey ? ' (active)' : '';
-                    (0, output_js_1.printInfo)(`    ${idx}. ${theme_js_1.THEMES[k].name}${marker}`);
-                    idx++;
-                }
-                (0, output_js_1.printInfo)('\n  Accessibility:');
-                for (const k of a11yKeys) {
-                    const marker = k === currentKey ? ' (active)' : '';
-                    (0, output_js_1.printInfo)(`    ${idx}. ${theme_js_1.THEMES[k].name}${marker}`);
-                    idx++;
-                }
-                console.log();
-                const ordered = [...regularKeys, ...a11yKeys];
-                rl.question(`  Select [1-${ordered.length}]: `, (answer) => {
-                    const num = parseInt(answer.trim(), 10);
-                    if (num >= 1 && num <= ordered.length) {
-                        const chosen = ordered[num - 1];
+                const entries = [
+                    ...regularKeys.map((k) => ({
+                        label: theme_js_1.THEMES[k].name,
+                        active: k === currentKey,
+                        value: k,
+                    })),
+                    { type: 'section', title: 'Accessibility:' },
+                    ...a11yKeys.map((k) => ({
+                        label: theme_js_1.THEMES[k].name,
+                        active: k === currentKey,
+                        value: k,
+                    })),
+                ];
+                const signal = createMenuSignal();
+                try {
+                    const result = await (0, menu_js_1.selectFromMenu)(rl, entries, { title: `Themes — current: ${theme_js_1.THEMES[currentKey].name}` }, signal);
+                    if (!result.cancelled) {
+                        const chosen = result.item.value;
                         (0, theme_js_1.setTheme)(chosen);
                         config.theme = chosen;
                         (0, config_js_1.savePreferences)({
@@ -891,60 +1442,74 @@ async function startRepl(config, alertContext, resume) {
                         });
                         (0, output_js_1.printInfo)(`  Switched to ${theme_js_1.THEMES[chosen].name} theme.`);
                     }
-                    else {
-                        (0, output_js_1.printInfo)('  Cancelled.');
-                    }
-                    console.log();
-                    void prompt();
-                });
+                }
+                finally {
+                    clearMenuSignal();
+                }
+                console.log();
+                void prompt();
                 return;
             }
             if (trimmed === '/options') {
-                const entries = Object.entries(config_js_1.OPTIONS_REGISTRY);
-                (0, output_js_1.printInfo)('\n  Options:');
-                for (let i = 0; i < entries.length; i++) {
-                    const [name, opt] = entries[i];
-                    const current = config[opt.configKey];
-                    const isDefault = current === opt.default;
-                    const label = isDefault ? '(default)' : '(custom)';
-                    (0, output_js_1.printInfo)(`    ${i + 1}. ${name} = ${current} ${label}`);
-                    (0, output_js_1.printInfo)(`       ${opt.description}`);
+                const optEntries = Object.entries(config_js_1.OPTIONS_REGISTRY);
+                const menuEntries = [
+                    ...optEntries.map(([name, opt]) => {
+                        const current = config[opt.configKey];
+                        const tag = current === opt.default ? '(default)' : '(custom)';
+                        return {
+                            label: name,
+                            annotation: `= ${current} ${tag}`,
+                            description: opt.description,
+                        };
+                    }),
+                    { type: 'section', title: 'Info' },
+                    { label: 'Debug report', description: 'Print a diagnostic report for troubleshooting' },
+                ];
+                const signal1 = createMenuSignal();
+                let optResult;
+                try {
+                    optResult = await (0, menu_js_1.selectFromMenu)(rl, menuEntries, { title: 'Options', promptLabel: 'Select option' }, signal1);
                 }
-                console.log();
-                rl.question(`  Select option [1-${entries.length}] (Enter to cancel): `, (answer) => {
-                    const num = parseInt(answer.trim(), 10);
-                    if (num >= 1 && num <= entries.length) {
-                        const [name, opt] = entries[num - 1];
-                        rl.question(`  New value for ${name} (Enter to cancel): `, (valAnswer) => {
-                            const val = parseInt(valAnswer.trim(), 10);
-                            const minVal = opt.default === 0 ? 0 : 1;
-                            if (!isNaN(val) && val >= minVal) {
-                                (0, config_js_1.saveOption)(name, val);
-                                config[opt.configKey] = val;
-                                (0, output_js_1.printInfo)(`  ${name} set to ${val}`);
-                                if (name === 'token-window') {
-                                    const modelWindow = (0, context_js_1.getContextWindow)(config.model);
-                                    if (val > modelWindow) {
-                                        (0, output_js_1.printInfo)(`  Warning: ${val} exceeds ${config.model}'s context window (${modelWindow})`);
-                                    }
+                finally {
+                    clearMenuSignal();
+                }
+                if (!optResult.cancelled) {
+                    if (optResult.index >= optEntries.length) {
+                        // Debug report is the only non-editable entry beyond the option rows.
+                        printDebugReport();
+                        void prompt();
+                        return;
+                    }
+                    const [name, opt] = optEntries[optResult.index];
+                    const signal2 = createMenuSignal();
+                    let valResult;
+                    try {
+                        valResult = await (0, menu_js_1.promptValue)(rl, { label: `New value for ${name}` }, signal2);
+                    }
+                    finally {
+                        clearMenuSignal();
+                    }
+                    if (!valResult.cancelled) {
+                        const val = parseInt(valResult.raw, 10);
+                        const minVal = opt.default === 0 ? 0 : 1;
+                        if (!isNaN(val) && val >= minVal) {
+                            (0, config_js_1.saveOption)(name, val);
+                            config[opt.configKey] = val;
+                            (0, output_js_1.printInfo)(`  ${name} set to ${val}`);
+                            if (name === 'token-window') {
+                                const modelWindow = (0, context_js_1.getContextWindow)(config.model);
+                                if (val > modelWindow) {
+                                    (0, output_js_1.printInfo)(`  Warning: ${val} exceeds ${config.model}'s context window (${modelWindow})`);
                                 }
                             }
-                            else if (valAnswer.trim() === '') {
-                                (0, output_js_1.printInfo)('  Cancelled.');
-                            }
-                            else {
-                                (0, output_js_1.printError)(`  Invalid value. Must be ${minVal === 0 ? 'a non-negative integer' : 'a positive integer'}.`);
-                            }
-                            console.log();
-                            void prompt();
-                        });
-                    }
-                    else {
-                        (0, output_js_1.printInfo)('  Cancelled.');
-                        console.log();
-                        void prompt();
+                        }
+                        else {
+                            (0, output_js_1.printError)(`  Invalid value. Must be ${minVal === 0 ? 'a non-negative integer' : 'a positive integer'}.`);
+                        }
                     }
-                });
+                }
+                console.log();
+                void prompt();
                 return;
             }
             if (trimmed === '/update') {
@@ -958,21 +1523,12 @@ async function startRepl(config, alertContext, resume) {
                     (0, output_js_1.printInfo)('No routines saved. Teach me a workflow and I can save it as a routine.');
                 }
                 else {
-                    const tasks = allRoutines.filter((r) => r.id.startsWith('task-'));
-                    const routines = allRoutines.filter((r) => !r.id.startsWith('task-'));
-                    if (tasks.length > 0) {
-                        (0, output_js_1.printInfo)(`\n  Tasks (${tasks.length}) — single-step, structured output:`);
-                        for (const r of tasks) {
-                            (0, output_js_1.printInfo)(`    /${r.id} — ${r.name}: ${r.description}`);
-                        }
-                    }
-                    if (routines.length > 0) {
-                        (0, output_js_1.printInfo)(`\n  Routines (${routines.length}) — multi-step workflows:`);
-                        for (const r of routines) {
-                            (0, output_js_1.printInfo)(`    /${r.id} — ${r.name}: ${r.description}`);
-                        }
-                    }
-                    console.log();
+                    const hasTasks = allRoutines.some((r) => r.id.startsWith('task-'));
+                    const hasRoutines = allRoutines.some((r) => !r.id.startsWith('task-'));
+                    if (hasTasks)
+                        printRoutinesList('tasks');
+                    if (hasRoutines)
+                        printRoutinesList('routines');
                 }
                 void prompt();
                 return;
@@ -1019,17 +1575,7 @@ Remember: task content should describe a single atomic operation with clear succ
                 return;
             }
             if (trimmed === '/specialists') {
-                const specialists = specialistStore.list();
-                if (specialists.length === 0) {
-                    (0, output_js_1.printInfo)('No specialist agents defined yet. Ask me to create one or use /create-specialist.');
-                }
-                else {
-                    (0, output_js_1.printInfo)(`\n  Specialists (${specialists.length}):`);
-                    for (const s of specialists) {
-                        (0, output_js_1.printInfo)(`    ${s.id} — ${s.name}: ${s.description}`);
-                    }
-                    console.log();
-                }
+                printSpecialistsList();
                 void prompt();
                 return;
             }
@@ -1074,161 +1620,154 @@ Remember: the systemPrompt should read like a persona definition — who this sp
                     (0, output_js_1.printInfo)('  To accept or reject, tell Bernard conversationally (e.g., "accept the code-review candidate").');
                     (0, output_js_1.printInfo)('  The agent can create the specialist via the specialist tool, then update candidate status.\n');
                     // Inject candidate context so the agent knows about them for the rest of the session
-                    const candidateContext = `## Specialist Suggestions\n\nBernard detected patterns in previous sessions that might benefit from saved specialists. Mention these when relevant.\n\n${pending.map((c) => `- "${c.name}" (${c.draftId}): ${c.description}`).join('\n')}`;
-                    agent.setAlertContext(candidateContext);
+                    agent.setAlertContext((0, candidate_bootstrap_js_1.buildCandidateContextBlock)(pending));
                 }
                 void prompt();
                 return;
             }
-            if (trimmed === '/critic' || trimmed.startsWith('/critic ')) {
-                const arg = trimmed.slice('/critic'.length).trim().toLowerCase();
-                if (arg === 'on') {
-                    config.criticMode = true;
-                    (0, config_js_1.savePreferences)({
-                        provider: config.provider,
-                        model: config.model,
-                        maxTokens: config.maxTokens,
-                        shellTimeout: config.shellTimeout,
-                        tokenWindow: config.tokenWindow,
-                        theme: config.theme,
-                        criticMode: true,
-                    });
-                    (0, output_js_1.printInfo)('[CRITIC:ON] Responses will be planned and verified.');
-                }
-                else if (arg === 'off') {
-                    config.criticMode = false;
-                    (0, config_js_1.savePreferences)({
-                        provider: config.provider,
-                        model: config.model,
-                        maxTokens: config.maxTokens,
-                        shellTimeout: config.shellTimeout,
-                        tokenWindow: config.tokenWindow,
-                        theme: config.theme,
-                        criticMode: false,
-                    });
-                    (0, output_js_1.printInfo)('[CRITIC:OFF] Critic mode disabled.');
-                }
-                else {
-                    (0, output_js_1.printInfo)(`Critic mode: ${config.criticMode ? 'ON' : 'OFF'}. Usage: /critic on|off`);
-                }
+            // Backwards-compat shims: the standalone toggles (/critic, /react, /tool-details, /debug)
+            // were consolidated into /agent-options and /options. Print a short pointer so users typing
+            // the old command aren't silently dropped into the prompt.
+            const legacyToggle = {
+                '/critic': 'Critic mode → /agent-options',
+                '/react': 'Coordinator (ReAct) mode → /agent-options',
+                '/tool-details': 'Tool-call details → /agent-options',
+                '/debug': 'Debug logging → /options',
+            }[trimmed];
+            if (legacyToggle) {
+                (0, output_js_1.printInfo)(`  This command moved. ${legacyToggle}`);
                 void prompt();
                 return;
             }
-            if (trimmed === '/agent-options' || trimmed.startsWith('/agent-options ')) {
-                const args = trimmed.slice('/agent-options'.length).trim();
-                if (!args) {
-                    // Display current settings
-                    (0, output_js_1.printInfo)(`Auto-create specialists: ${config.autoCreateSpecialists ? 'on' : 'off'}`);
-                    (0, output_js_1.printInfo)(`Auto-create threshold: ${config.autoCreateThreshold}`);
-                }
-                else if (args === 'auto-create on') {
-                    config.autoCreateSpecialists = true;
-                    (0, config_js_1.savePreferences)({
-                        ...(0, config_js_1.loadPreferences)(),
-                        autoCreateSpecialists: true,
-                        provider: config.provider,
-                        model: config.model,
-                    });
-                    (0, output_js_1.printInfo)('Auto-create specialists: on');
-                }
-                else if (args === 'auto-create off') {
-                    config.autoCreateSpecialists = false;
-                    (0, config_js_1.savePreferences)({
-                        ...(0, config_js_1.loadPreferences)(),
-                        autoCreateSpecialists: false,
-                        provider: config.provider,
-                        model: config.model,
-                    });
-                    (0, output_js_1.printInfo)('Auto-create specialists: off');
-                }
-                else if (args.startsWith('threshold ')) {
-                    const val = parseFloat(args.slice('threshold '.length));
-                    if (isNaN(val) || val < 0 || val > 1) {
-                        (0, output_js_1.printError)('Threshold must be a number between 0 and 1');
-                    }
-                    else {
-                        config.autoCreateThreshold = val;
+            if (trimmed === '/agent-options') {
+                const systemBools = [
+                    {
+                        key: 'autoCreateSpecialists',
+                        label: 'Auto-create specialists',
+                        description: 'Auto-promote pending specialist candidates whose score exceeds the threshold.',
+                        onMsg: '  Auto-create specialists: on',
+                        offMsg: '  Auto-create specialists: off',
+                        onToggle: (value) => {
+                            if (value) {
+                                (0, candidate_bootstrap_js_1.promotePendingCandidates)(candidateStore, specialistStore, config.autoCreateThreshold);
+                            }
+                        },
+                    },
+                    {
+                        key: 'criticMode',
+                        label: 'Critic mode',
+                        description: 'Plan the response, verify it with a critic pass, and retry on failure before replying.',
+                        onMsg: '  [CRITIC:ON] Responses will be planned and verified.',
+                        offMsg: '  [CRITIC:OFF] Critic mode disabled.',
+                    },
+                    {
+                        key: 'reactMode',
+                        label: 'Coordinator (ReAct) mode',
+                        description: 'Iterate think → act → evaluate; delegate subtasks to subagents for complex work.',
+                        onMsg: '  [REACT:ON] Operating as coordinator with iterative reasoning and delegation.',
+                        offMsg: '  [REACT:OFF] Coordinator mode disabled.',
+                    },
+                    {
+                        key: 'promptRewriter',
+                        label: 'Prompt rewriter',
+                        description: 'Restructure your prompt for the active model family before each turn.',
+                        onMsg: '  [REWRITER:ON] User prompts will be restructured for the active model before execution.',
+                        offMsg: '  [REWRITER:OFF] Prompts will be sent to the model verbatim.',
+                    },
+                    {
+                        key: 'toolDetails',
+                        label: 'Tool details',
+                        description: 'Show full tool call args and results in the transcript.',
+                        onMsg: '  [TOOL-DETAILS:ON] Full tool call args and results will be shown.',
+                        offMsg: '  [TOOL-DETAILS:OFF] Only tool names shown; args and results hidden.',
+                        onToggle: output_js_2.setToolDetailsVisible,
+                    },
+                ];
+                async function runThresholdPrompt() {
+                    const signal = createMenuSignal();
+                    try {
+                        const val = await (0, menu_js_1.promptValue)(rl, { label: 'New threshold (0-100)' }, signal);
+                        if (val.cancelled)
+                            return;
+                        const parsed = parseFloat(val.raw);
+                        if (isNaN(parsed) || parsed < 0 || parsed > 100) {
+                            (0, output_js_1.printError)('Threshold must be a number between 0 and 100 (e.g. 0.8 or 80)');
+                            return;
+                        }
+                        const normalized = (0, config_js_1.normalizeThreshold)(parsed);
+                        config.autoCreateThreshold = normalized;
                         (0, config_js_1.savePreferences)({
                             ...(0, config_js_1.loadPreferences)(),
-                            autoCreateThreshold: val,
+                            autoCreateThreshold: normalized,
                             provider: config.provider,
                             model: config.model,
                         });
-                        (0, output_js_1.printInfo)(`Auto-create threshold: ${val}`);
+                        (0, output_js_1.printInfo)(`  Auto-create threshold: ${normalized} (${Math.round(normalized * 100)}%)`);
+                        if (config.autoCreateSpecialists) {
+                            (0, candidate_bootstrap_js_1.promotePendingCandidates)(candidateStore, specialistStore, config.autoCreateThreshold);
+                        }
+                    }
+                    finally {
+                        clearMenuSignal();
                     }
                 }
-                else {
-                    (0, output_js_1.printError)('Usage: /agent-options auto-create on|off  OR  /agent-options threshold <0-1>');
-                }
-                void prompt();
-                return;
-            }
-            if (trimmed === '/debug') {
-                const t = (0, theme_js_1.getTheme)();
-                console.log(t.accent('\n  Bernard Diagnostic Report'));
-                console.log(t.accent('  ' + '─'.repeat(40)));
-                console.log(t.text('\n  Runtime:'));
-                console.log(t.muted(`    Bernard version: ${(0, update_js_1.getLocalVersion)()}`));
-                console.log(t.muted(`    Node.js version: ${process.version}`));
-                console.log(t.muted(`    OS: ${process.platform} ${process.arch} (${os.release()})`));
-                console.log(t.text('\n  LLM:'));
-                console.log(t.muted(`    Provider: ${config.provider}`));
-                console.log(t.muted(`    Model: ${config.model}`));
-                console.log(t.muted(`    maxTokens: ${config.maxTokens}`));
-                console.log(t.muted(`    shellTimeout: ${config.shellTimeout}ms`));
-                console.log(t.muted(`    tokenWindow: ${config.tokenWindow || 'auto-detect'}`));
-                console.log(t.text('\n  API Keys:'));
-                for (const { provider, hasKey } of (0, config_js_1.getProviderKeyStatus)()) {
-                    console.log(t.muted(`    ${provider}: ${hasKey ? 'configured' : 'not set'}`));
-                }
-                const debugStatuses = mcpManager.getServerStatuses();
-                console.log(t.text('\n  MCP Servers:'));
-                if (debugStatuses.length === 0) {
-                    console.log(t.muted('    (none configured)'));
+                const toggleRow = (opt) => ({
+                    kind: 'item',
+                    item: {
+                        label: opt.label,
+                        annotation: `= ${config[opt.key] ? 'on' : 'off'}`,
+                        description: opt.description,
+                    },
+                    action: () => toggleBooleanPref(opt.key, opt.label, opt.onMsg, opt.offMsg, opt.onToggle),
+                });
+                const rows = [
+                    { kind: 'section', title: 'System' },
+                    toggleRow(systemBools[0]),
+                    {
+                        kind: 'item',
+                        item: {
+                            label: 'Auto-create threshold',
+                            annotation: `= ${config.autoCreateThreshold} (${Math.round(config.autoCreateThreshold * 100)}%)`,
+                            description: 'Minimum score (0-1) a pending specialist needs before auto-promotion.',
+                        },
+                        action: runThresholdPrompt,
+                    },
+                    ...systemBools.slice(1).map(toggleRow),
+                    { kind: 'section', title: 'User-created' },
+                    {
+                        kind: 'item',
+                        item: {
+                            label: 'Specialists',
+                            description: 'List bundled and user-created specialists.',
+                        },
+                        action: () => printSpecialistsList(),
+                    },
+                    {
+                        kind: 'item',
+                        item: { label: 'Tasks', description: 'List saved single-step tasks.' },
+                        action: () => printRoutinesList('tasks'),
+                    },
+                    {
+                        kind: 'item',
+                        item: { label: 'Routines', description: 'List saved multi-step routines.' },
+                        action: () => printRoutinesList('routines'),
+                    },
+                ];
+                const topEntries = rows.map((r) => r.kind === 'section' ? { type: 'section', title: r.title } : r.item);
+                const itemActions = rows.flatMap((r) => (r.kind === 'item' ? [r.action] : []));
+                const signal1 = createMenuSignal();
+                let topResult;
+                try {
+                    topResult = await (0, menu_js_1.selectFromMenu)(rl, topEntries, { title: 'Agent Options' }, signal1);
                 }
-                else {
-                    for (const s of debugStatuses) {
-                        if (s.connected) {
-                            console.log(t.muted(`    ${s.name}: connected (${s.toolCount} tools)`));
-                        }
-                        else {
-                            console.log(t.muted(`    ${s.name}: failed — ${s.error}`));
-                        }
-                    }
+                finally {
+                    clearMenuSignal();
                 }
-                console.log(t.text('\n  RAG:'));
-                console.log(t.muted(`    Enabled: ${config.ragEnabled}`));
-                if (ragStore) {
-                    console.log(t.muted(`    Facts: ${ragStore.count()}`));
+                if (!topResult.cancelled) {
+                    const action = itemActions[topResult.index];
+                    if (action)
+                        await action();
                 }
-                console.log(t.text('\n  Memory:'));
-                console.log(t.muted(`    Persistent memories: ${memoryStore.listMemory().length}`));
-                console.log(t.text('\n  Cron:'));
-                console.log(t.muted(`    Daemon: ${(0, client_js_1.isDaemonRunning)() ? 'running' : 'stopped'}`));
-                let debugJobCount = 0;
-                try {
-                    const raw = fs.readFileSync(paths_js_1.CRON_JOBS_FILE, 'utf-8');
-                    debugJobCount = JSON.parse(raw).length;
-                }
-                catch {
-                    // jobs.json doesn't exist yet — that's fine
-                }
-                console.log(t.muted(`    Jobs: ${debugJobCount}`));
-                console.log(t.text('\n  Conversation:'));
-                console.log(t.muted(`    Messages: ${agent.getHistory().length}`));
-                console.log(t.text('\n  Settings:'));
-                console.log(t.muted(`    Theme: ${(0, theme_js_1.getActiveThemeKey)()}`));
-                console.log(t.muted(`    Critic mode: ${config.criticMode ? 'on' : 'off'}`));
-                const debugEnabled = process.env.BERNARD_DEBUG === 'true' || process.env.BERNARD_DEBUG === '1';
-                console.log(t.muted(`    Debug mode: ${debugEnabled ? 'on' : 'off'}`));
-                console.log(t.text('\n  Paths:'));
-                if (process.env.BERNARD_HOME) {
-                    console.log(t.muted(`    BERNARD_HOME: ${process.env.BERNARD_HOME}`));
-                }
-                console.log(t.muted(`    Config: ${paths_js_1.CONFIG_DIR}`));
-                console.log(t.muted(`    Data: ${paths_js_1.DATA_DIR}`));
-                console.log(t.muted(`    Cache: ${paths_js_1.CACHE_DIR}`));
-                console.log(t.muted(`    State: ${paths_js_1.STATE_DIR}`));
                 console.log();
                 void prompt();
                 return;
@@ -1246,6 +1785,70 @@ Remember: the systemPrompt should read like a persona definition — who this sp
                 void prompt();
                 return;
             }
+            if (trimmed === '/image' || trimmed.startsWith('/image ')) {
+                const args = trimmed.slice('/image'.length).trim();
+                if (!args) {
+                    (0, output_js_1.printError)('Usage: /image <path> [prompt]');
+                    (0, output_js_1.printInfo)('  Example: /image ~/screenshot.png What is on the screen?');
+                    (0, output_js_1.printInfo)('  Tip: you can also paste image paths inline, e.g. "describe ~/screenshot.png"');
+                    void prompt();
+                    return;
+                }
+                let imagePath;
+                let userText;
+                const quoteMatch = args.match(/^(["'])(.+?)\1(?:\s+(.*))?$/);
+                if (quoteMatch) {
+                    imagePath = quoteMatch[2];
+                    userText = quoteMatch[3]?.trim() || 'Describe this image.';
+                }
+                else {
+                    const spaceIdx = args.indexOf(' ');
+                    imagePath = spaceIdx === -1 ? args : args.slice(0, spaceIdx);
+                    userText =
+                        spaceIdx === -1
+                            ? 'Describe this image.'
+                            : args.slice(spaceIdx + 1).trim() || 'Describe this image.';
+                }
+                if (!(0, image_js_1.isVisionCapableModel)(config.provider, config.model)) {
+                    (0, output_js_1.printError)(`Model "${config.model}" does not support image input. Switch to a vision-capable model with /model.`);
+                    void prompt();
+                    return;
+                }
+                let attachment;
+                try {
+                    attachment = (0, image_js_1.loadImage)(imagePath);
+                }
+                catch (err) {
+                    (0, output_js_1.printError)(err instanceof Error ? err.message : String(err));
+                    void prompt();
+                    return;
+                }
+                (0, output_js_1.printInfo)(`  Attaching image: ${attachment.path}`);
+                (0, output_js_1.printInfo)(`  Image will be sent to ${config.provider}/${config.model}`);
+                processing = true;
+                interrupted = false;
+                try {
+                    initSpinner();
+                    await agent.processInput(userText, [attachment]);
+                    historyStore.save(agent.getHistory());
+                }
+                catch (err) {
+                    if (!interrupted) {
+                        (0, output_js_1.printError)(err instanceof Error ? err.message : String(err));
+                    }
+                }
+                finally {
+                    processing = false;
+                    (0, output_js_1.stopSpinner)();
+                }
+                if (interrupted) {
+                    (0, output_js_1.printInfo)('Interrupted.');
+                    interrupted = false;
+                }
+                console.log();
+                void prompt();
+                return;
+            }
             // Dynamic routine invocation: /{routine-id} [args...]
             {
                 const parts = trimmed.slice(1).split(/\s+/);
@@ -1270,16 +1873,7 @@ Remember: the systemPrompt should read like a persona definition — who this sp
                     processing = true;
                     interrupted = false;
                     try {
-                        const spinnerStats = {
-                            startTime: Date.now(),
-                            totalPromptTokens: 0,
-                            totalCompletionTokens: 0,
-                            latestPromptTokens: 0,
-                            model: config.model,
-                            contextWindowOverride: config.tokenWindow || undefined,
-                        };
-                        agent.setSpinnerStats(spinnerStats);
-                        (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
+                        initSpinner();
                         await agent.processInput(message);
                         historyStore.save(agent.getHistory());
                     }
@@ -1303,20 +1897,35 @@ Remember: the systemPrompt should read like a persona definition — who this sp
                 }
             }
         } // end slash command handling
+        let inlineImages;
+        const candidatePaths = (0, image_js_1.extractImagePaths)(trimmed);
+        if (candidatePaths.length > 0) {
+            if ((0, image_js_1.isVisionCapableModel)(config.provider, config.model)) {
+                const loaded = [];
+                for (const p of candidatePaths) {
+                    const img = (0, image_js_1.tryLoadImage)(p);
+                    if (img)
+                        loaded.push(img);
+                }
+                if (loaded.length > 0) {
+                    for (const img of loaded) {
+                        (0, output_js_1.printInfo)(`  Attaching image: ${img.path}`);
+                    }
+                    inlineImages = loaded;
+                }
+            }
+            else {
+                (0, output_js_2.printWarning)(`Image(s) detected but model "${config.model}" does not support vision. Sending as text only.`);
+            }
+        }
+        const resolvedEntries = await runReferenceResolver(trimmed);
+        const rewritten = await runPromptRewriter(trimmed, resolvedEntries);
+        const agentInput = rewritten ?? trimmed;
         processing = true;
         interrupted = false;
         try {
-            const spinnerStats = {
-                startTime: Date.now(),
-                totalPromptTokens: 0,
-                totalCompletionTokens: 0,
-                latestPromptTokens: 0,
-                model: config.model,
-                contextWindowOverride: config.tokenWindow || undefined,
-            };
-            agent.setSpinnerStats(spinnerStats);
-            (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
-            await agent.processInput(trimmed);
+            initSpinner();
+            await agent.processInput(agentInput, inlineImages, resolvedEntries);
             historyStore.save(agent.getHistory());
         }
         catch (err) {
@@ -1360,4 +1969,102 @@ Remember: the systemPrompt should read like a persona definition — who this sp
     });
     void prompt();
 }
+/**
+ * Interactive wizard for adding a custom provider from `/provider`.
+ * Returns the saved entry plus the freshly entered API key on success
+ * (so the caller can update the live `config.apiKeys` map without
+ * re-reading from disk), or `null` on cancel/error.
+ */
+async function runAddProviderWizard(rl, createMenuSignal, clearMenuSignal) {
+    (0, output_js_1.printInfo)('\nAdd custom provider — follows the same SDK contract as built-ins.');
+    // 1. SDK choice
+    const sdkEntries = custom_providers_js_1.SUPPORTED_SDKS.map((s) => ({ label: s, value: s }));
+    let sdkResult;
+    let sig = createMenuSignal();
+    try {
+        sdkResult = await (0, menu_js_1.selectFromMenu)(rl, sdkEntries, { title: 'Which SDK to use?' }, sig);
+    }
+    finally {
+        clearMenuSignal();
+    }
+    if (sdkResult.cancelled)
+        return null;
+    const sdk = sdkResult.item.value;
+    // 2. Name
+    sig = createMenuSignal();
+    let nameResult;
+    try {
+        nameResult = await (0, menu_js_1.promptValue)(rl, { label: 'Provider name (lowercase, e.g. "ollama")' }, sig);
+    }
+    finally {
+        clearMenuSignal();
+    }
+    if (nameResult.cancelled)
+        return null;
+    const name = nameResult.raw.trim();
+    const nameErr = (0, custom_providers_js_1.validateProviderName)(name);
+    if (nameErr) {
+        (0, output_js_1.printError)(nameErr);
+        return null;
+    }
+    // 3. Base URL
+    sig = createMenuSignal();
+    let urlResult;
+    try {
+        urlResult = await (0, menu_js_1.promptValue)(rl, { label: 'Base URL (e.g. http://localhost:11434/v1)' }, sig);
+    }
+    finally {
+        clearMenuSignal();
+    }
+    if (urlResult.cancelled)
+        return null;
+    const baseURL = urlResult.raw.trim();
+    const urlErr = (0, custom_providers_js_1.validateBaseURL)(baseURL);
+    if (urlErr) {
+        (0, output_js_1.printError)(urlErr);
+        return null;
+    }
+    // 4. Default model
+    sig = createMenuSignal();
+    let modelResult;
+    try {
+        modelResult = await (0, menu_js_1.promptValue)(rl, { label: 'Default model name' }, sig);
+    }
+    finally {
+        clearMenuSignal();
+    }
+    if (modelResult.cancelled)
+        return null;
+    const defaultModel = modelResult.raw.trim();
+    if (!defaultModel) {
+        (0, output_js_1.printError)('Default model cannot be empty.');
+        return null;
+    }
+    // 5. API key
+    sig = createMenuSignal();
+    let keyResult;
+    try {
+        keyResult = await (0, menu_js_1.promptValue)(rl, { label: 'API key (any non-empty token; some local servers ignore the value)' }, sig);
+    }
+    finally {
+        clearMenuSignal();
+    }
+    if (keyResult.cancelled)
+        return null;
+    const apiKey = keyResult.raw.trim();
+    if (!apiKey) {
+        (0, output_js_1.printError)('API key cannot be empty.');
+        return null;
+    }
+    try {
+        const entry = (0, custom_providers_js_1.saveCustomProvider)({ name, sdk, baseURL, defaultModel });
+        (0, config_js_1.saveProviderKey)(name, apiKey);
+        return { entry, apiKey };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(message);
+        return null;
+    }
+}
 //# sourceMappingURL=repl.js.map