@kinqs/brainrouter-cli 0.3.5 → 0.3.6

package/dist/cli/commands/_helpers.js

@@ -8,7 +8,7 @@
  * wrapper.
  */
 import chalk from 'chalk';
-import ora from 'ora';
+import { spinner } from '../spinner.js';
 import { callMcpTool } from '../../runtime/mcpUtils.js';
 import { clampPayload, extractMemories, renderMemoryCards } from '../../memory/formatters.js';
 import { buildSkillPrompt, resolveSkill, SLASH_TO_SKILL } from '../../prompt/skillRunner.js';
@@ -19,9 +19,9 @@ import { buildSkillPrompt, resolveSkill, SLASH_TO_SKILL } from '../../prompt/ski
  * raw output only when no records can be parsed.
  */
 export async function printMemoryCards(mcpClient, toolName, args, heading) {
-    const spinner = ora(chalk.gray(`${toolName}…`)).start();
+    const s = spinner(chalk.gray(`${toolName}…`)).start();
     const res = await callMcpTool(mcpClient, toolName, args);
-    spinner.stop();
+    s.stop();
     console.log();
     if (res.isError) {
         console.log(chalk.red(`${heading}: tool error — ${res.text || '(no message)'}`));
@@ -44,9 +44,9 @@ export async function printMemoryCards(mcpClient, toolName, args, heading) {
  * the tool's text output under a heading.
  */
 export async function printMcpCall(mcpClient, toolName, args, heading) {
-    const spinner = ora(chalk.gray(`${toolName}…`)).start();
+    const s = spinner(chalk.gray(`${toolName}…`)).start();
     const res = await callMcpTool(mcpClient, toolName, args);
-    spinner.stop();
+    s.stop();
     console.log(chalk.bold(`\n${heading}`));
     if (res.isError) {
         console.log(chalk.red(`  Tool error: ${res.text || '(no message)'}`));
@@ -113,7 +113,7 @@ export async function runSkillCommand(agent, mcpClient, slashCommand, userInput,
     await runSkillByName(agent, mcpClient, skillName, userInput, orchestration, runTurn);
 }
 export async function runSkillByName(agent, mcpClient, skillName, userInput, orchestration, runTurn) {
-    const loader = ora(chalk.gray(`Loading skill: ${skillName}...`)).start();
+    const loader = spinner(chalk.gray(`Loading skill: ${skillName}...`)).start();
     let prompt;
     try {
         const skill = await resolveSkill(mcpClient, skillName, agent.workspaceRoot, 'full');

package/dist/cli/commands/guard.js

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
-import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
+import { applyYoloOff, applyYoloOn, readPreferences, writePreferences } from '../../state/preferencesStore.js';
 import { addHook, readHooks, removeHook, setHookEnabled } from '../../state/hooksStore.js';
 import { createHookifyRule, deleteHookifyRule, listHookifyRules, toggleHookifyRule } from '../../state/hookifyStore.js';
 export async function tryHandleGuardCommand(ctx) {
@@ -79,26 +79,91 @@ export async function tryHandleGuardCommand(ctx) {
                 console.log(chalk.red('\nUsage: /hooks [list | add <event> <cmd> | remove <id> | enable <id> | disable <id>]\n'));
                 return true;
             }
-        case '/yolo':
+        case '/mode':
+            {
+                const prefs = readPreferences(agent.workspaceRoot);
+                const arg = (args[0] ?? '').toLowerCase();
+                if (!arg) {
+                    console.log(chalk.bold(`\nExecution mode: ${chalk.cyan(prefs.executionMode)}`));
+                    console.log(chalk.gray('  planning  — run_command asks before executing; agent leans toward clarify-before-act. (default)'));
+                    console.log(chalk.gray('  fast      — run_command auto-approves safe commands (dangerous ones still ask); agent jumps to implementation.'));
+                    console.log(chalk.gray('  Toggle with: /mode planning  |  /mode fast\n'));
+                    return true;
+                }
+                if (arg !== 'planning' && arg !== 'fast') {
+                    console.log(chalk.red(`\nUnknown mode "${arg}". Choose: planning | fast\n`));
+                    return true;
+                }
+                writePreferences(agent.workspaceRoot, { executionMode: arg });
+                agent.refreshSystemPrompt();
+                ctx.repl.refreshPromptForMode();
+                if (arg === 'fast') {
+                    console.log(chalk.yellow(`\n✓ /mode fast — run_command auto-approves safe commands.`));
+                    console.log(chalk.gray('   Dangerous commands (rm -rf, sudo, force-push, …) still prompt for confirmation.'));
+                    console.log(chalk.gray('   Pair with /permissions write (no shell) or BRAINROUTER_SANDBOX=on for tighter guardrails.\n'));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ /mode planning — run_command asks before each shell call.\n`));
+                }
+                return true;
+            }
+        case '/review-policy':
             {
                 const prefs = readPreferences(agent.workspaceRoot);
                 const arg = (args[0] ?? '').toLowerCase();
                 if (!arg) {
-                    console.log(chalk.bold(`\nAuto-approve shell: ${prefs.autoApproveShell ? chalk.red('ON') : chalk.green('off')}`));
-                    console.log(chalk.gray('  When ON, run_command skips the per-call confirmation prompt and executes immediately.'));
-                    console.log(chalk.gray('  Pair with BRAINROUTER_SANDBOX=on if you still want a safety net.'));
+                    console.log(chalk.bold(`\nReview policy: ${chalk.cyan(prefs.reviewPolicy)}`));
+                    console.log(chalk.gray('  request  — at workflow/multi-file gates, agent surfaces the plan and waits for /approve. (default)'));
+                    console.log(chalk.gray('  proceed  — agent applies the plan and reports after; use /approve manually for explicit gates.'));
+                    console.log(chalk.gray('  Toggle with: /review-policy request  |  /review-policy proceed\n'));
+                    return true;
+                }
+                if (arg !== 'request' && arg !== 'proceed') {
+                    console.log(chalk.red(`\nUnknown policy "${arg}". Choose: request | proceed\n`));
+                    return true;
+                }
+                writePreferences(agent.workspaceRoot, { reviewPolicy: arg });
+                agent.refreshSystemPrompt();
+                if (arg === 'proceed') {
+                    console.log(chalk.yellow(`\n✓ /review-policy proceed — agent will apply plans without halting for prose approval.`));
+                    console.log(chalk.gray('   /approve still works as an explicit gesture for workflows that need one.\n'));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ /review-policy request — agent will summarize and ask before applying multi-file changes.\n`));
+                }
+                return true;
+            }
+        case '/yolo':
+            {
+                // /yolo is a one-release alias for `/mode fast` + `/review-policy proceed`.
+                // We keep it because the muscle memory is established; new docs point to
+                // the two split commands for finer control.
+                const arg = (args[0] ?? '').toLowerCase();
+                if (!arg) {
+                    const prefs = readPreferences(agent.workspaceRoot);
+                    const yoloOn = prefs.executionMode === 'fast' && prefs.reviewPolicy === 'proceed';
+                    console.log(chalk.bold(`\nYolo (alias): ${yoloOn ? chalk.red('ON') : chalk.green('off')}`));
+                    console.log(chalk.gray('  Shorthand for `/mode fast` + `/review-policy proceed` — flip both axes at once.'));
+                    console.log(chalk.gray(`  Current state: mode=${prefs.executionMode}, review-policy=${prefs.reviewPolicy}`));
+                    console.log(chalk.gray('  Use /mode and /review-policy directly for finer control.'));
                     console.log(chalk.gray('  Toggle with: /yolo on  |  /yolo off\n'));
                     return true;
                 }
                 const next = arg === 'on' || arg === 'true' || arg === '1';
-                writePreferences(agent.workspaceRoot, { autoApproveShell: next });
                 if (next) {
-                    console.log(chalk.red('\n⚠  /yolo ON — run_command will now execute without asking.'));
-                    console.log(chalk.gray('   You are in access mode "shell" so the agent CAN call shell commands.'));
-                    console.log(chalk.gray('   Lower the risk with /permissions write (no shell), or set BRAINROUTER_SANDBOX=on.\n'));
+                    applyYoloOn(agent.workspaceRoot);
+                    agent.refreshSystemPrompt();
+                    ctx.repl.refreshPromptForMode();
+                    console.log(chalk.red('\n⚠  /yolo ON — shorthand for `/mode fast` + `/review-policy proceed`.'));
+                    console.log(chalk.gray('   run_command will auto-approve safe commands; dangerous ones still prompt.'));
+                    console.log(chalk.gray('   Agent will apply multi-file plans without the prose "ready?" pause.'));
+                    console.log(chalk.gray('   Use /mode and /review-policy for finer control next time.\n'));
                 }
                 else {
-                    console.log(chalk.green('\n✓ /yolo off — run_command will prompt for confirmation again.\n'));
+                    applyYoloOff(agent.workspaceRoot);
+                    agent.refreshSystemPrompt();
+                    ctx.repl.refreshPromptForMode();
+                    console.log(chalk.green('\n✓ /yolo off — restored /mode planning + /review-policy request.\n'));
                 }
                 return true;
             }

package/dist/cli/commands/mcp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 0.3.6 item 11: `/mcp` slash-command surface. Scope-limited foundation —
+ * the full multi-MCP federation (parallel cross-MCP tool calls, MCP
+ * marketplace, capability tiers) is deferred to 0.4.0. What ships here:
+ *
+ *   /mcp           — show status of the active MCP (alias for /mcp list)
+ *   /mcp list      — list every configured profile with identity + status
+ *   /mcp reconnect — reconnect the currently-active profile
+ *   /mcp tools     — list MCP tools grouped by namespace (pre-Item-11
+ *                    `/mcp` no-arg behaviour, moved here verbatim)
+ *
+ * The reconnect path leans on `mcpClient.close()` + `mcpClient.connect()`
+ * with the same config the CLI launched against — no plumbing required
+ * for the user beyond typing the command.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleMcpCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/mcp.js

@@ -0,0 +1,121 @@
+/**
+ * 0.3.6 item 11: `/mcp` slash-command surface. Scope-limited foundation —
+ * the full multi-MCP federation (parallel cross-MCP tool calls, MCP
+ * marketplace, capability tiers) is deferred to 0.4.0. What ships here:
+ *
+ *   /mcp           — show status of the active MCP (alias for /mcp list)
+ *   /mcp list      — list every configured profile with identity + status
+ *   /mcp reconnect — reconnect the currently-active profile
+ *   /mcp tools     — list MCP tools grouped by namespace (pre-Item-11
+ *                    `/mcp` no-arg behaviour, moved here verbatim)
+ *
+ * The reconnect path leans on `mcpClient.close()` + `mcpClient.connect()`
+ * with the same config the CLI launched against — no plumbing required
+ * for the user beyond typing the command.
+ */
+import chalk from 'chalk';
+import { spinner as makeSpinner } from '../spinner.js';
+export async function tryHandleMcpCommand(ctx) {
+    const { command, args, mcpClient, config } = ctx;
+    if (command !== '/mcp')
+        return false;
+    const sub = (args[0] ?? 'list').toLowerCase();
+    if (sub === 'tools') {
+        // Pre-Item-11 `/mcp` no-arg behaviour: namespace-grouped tool listing.
+        // Kept verbatim under a subcommand so the muscle memory survives.
+        const profileName = config.activeServer;
+        const server = config.servers[profileName];
+        console.log(chalk.bold('\nMCP server'));
+        console.log(`  Profile: ${chalk.green(profileName)} (${chalk.cyan(server?.type ?? 'unknown')})`);
+        if (server?.type === 'http') {
+            console.log(`  URL:     ${chalk.blue(server.url ?? '')}`);
+        }
+        else if (server?.type === 'stdio') {
+            console.log(`  Cmd:     ${chalk.blue(server.command ?? '')} ${server.args?.join(' ') || ''}`);
+        }
+        const spinner = makeSpinner(chalk.gray('Fetching MCP tool surface...')).start();
+        try {
+            const res = await mcpClient.listTools();
+            const tools = res.tools || [];
+            spinner.succeed(chalk.green(`${tools.length} MCP tools available`));
+            const namespaces = {};
+            for (const t of tools) {
+                const parts = (t.name || '').split('_');
+                const ns = parts.length > 1 ? parts[0] : 'misc';
+                (namespaces[ns] ||= []).push(t.name);
+            }
+            for (const ns of Object.keys(namespaces).sort()) {
+                console.log(`\n  ${chalk.bold.cyan(ns)} (${namespaces[ns].length})`);
+                for (const name of namespaces[ns].sort()) {
+                    console.log(`    ${chalk.gray('•')} ${name}`);
+                }
+            }
+        }
+        catch (err) {
+            spinner.fail(chalk.red(`Failed: ${err.message}`));
+        }
+        console.log();
+        return true;
+    }
+    if (sub === 'list') {
+        const activeName = config.activeServer;
+        const profiles = Object.keys(config.servers ?? {});
+        if (profiles.length === 0) {
+            console.log(chalk.yellow('\nNo MCP profiles configured. Run `brainrouter login` or `brainrouter config` to set one up.\n'));
+            return true;
+        }
+        console.log(chalk.bold('\nConfigured MCP profiles'));
+        for (const name of profiles) {
+            const profile = config.servers[name];
+            const isActive = name === activeName;
+            // Identity: explicit config field > live wrapper > 'unknown'.
+            let identity = profile.identity ?? 'unknown';
+            if (isActive && typeof mcpClient.getIdentity === 'function') {
+                identity = mcpClient.getIdentity();
+            }
+            const onlineLabel = isActive
+                ? (mcpClient.isConnected() ? chalk.green('online') : chalk.red('offline'))
+                : chalk.gray('idle');
+            const idLabel = identity === 'brainrouter'
+                ? chalk.cyan('brainrouter')
+                : identity === 'third-party'
+                    ? chalk.yellow('third-party')
+                    : chalk.gray('unknown');
+            const marker = isActive ? chalk.bold('★ ') : '  ';
+            const transport = profile.type;
+            const target = profile.type === 'http' ? profile.url ?? '<no url>' : profile.command ?? '<no command>';
+            console.log(`${marker}${chalk.bold(name)}  ${idLabel}  ${transport}  ${onlineLabel}  ${chalk.gray(target)}`);
+        }
+        console.log(chalk.gray('\n★ = active profile.  /mcp reconnect to refresh the active connection.\n'));
+        return true;
+    }
+    if (sub === 'reconnect') {
+        const activeName = config.activeServer;
+        const profile = config.servers?.[activeName];
+        if (!profile) {
+            console.log(chalk.red(`\nNo active MCP profile to reconnect (\`activeServer\` = ${JSON.stringify(activeName)}).\n`));
+            return true;
+        }
+        console.log(chalk.gray(`Reconnecting "${activeName}"…`));
+        try {
+            try {
+                await mcpClient.close();
+            }
+            catch { /* idempotent */ }
+            await mcpClient.connect(profile, config.llm, activeName);
+            // Re-probe tools so identity tagging and the prompt's tool list refresh.
+            try {
+                await mcpClient.listTools();
+            }
+            catch { /* tool-list failure is non-fatal */ }
+            console.log(chalk.green(`✓ Reconnected to "${activeName}" (${profile.type}).\n`));
+        }
+        catch (err) {
+            console.log(chalk.red(`✗ Reconnect failed: ${err?.message ?? err}\n`));
+            console.log(chalk.gray('The CLI stays in offline mode. Check the MCP server, then try `/mcp reconnect` again.\n'));
+        }
+        return true;
+    }
+    console.log(chalk.red(`\nUnknown /mcp subcommand "${sub}". Usage: /mcp list | /mcp reconnect | /mcp tools\n`));
+    return true;
+}

package/dist/cli/commands/memory.js

@@ -11,7 +11,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
-import ora from 'ora';
+import { spinner as makeSpinner } from '../spinner.js';
 import { callMcpTool } from '../../runtime/mcpUtils.js';
 import { extractMemories, renderMemoryCards } from '../../memory/formatters.js';
 import { consolidateMemories } from '../../memory/consolidation.js';
@@ -237,7 +237,7 @@ export async function tryHandleMemoryCommand(ctx) {
                 return true;
             }
             if (sub === 'consolidate') {
-                const spinner = ora(chalk.gray('Consolidating memories from MCP into filesystem artifacts...')).start();
+                const spinner = makeSpinner(chalk.gray('Consolidating memories from MCP into filesystem artifacts...')).start();
                 try {
                     const result = await consolidateMemories(mcpClient, agent.workspaceRoot, { sessionKey: agent.sessionKey });
                     spinner.succeed(chalk.green(`Consolidated ${result.totalRecords} records.`));

package/dist/cli/commands/obs.js

@@ -98,21 +98,23 @@ export async function tryHandleObsCommand(ctx) {
             {
                 const session = agent.sessionUsage;
                 const metrics = agent.memoryMetrics;
-                const children = listSessions(agent.workspaceRoot).filter((s) => s.usage);
+                // Scope to the live parent: sessions.json is workspace-wide and
+                // persists across CLI restarts, so an unfiltered list mixes in every
+                // child spawned by every prior CLI process. Filtering by
+                // parentSessionKey limits the row to children spawned by THIS parent.
+                const children = listSessions(agent.workspaceRoot).filter((s) => s.usage && s.parentSessionKey === agent.sessionKey);
                 const childPrompt = children.reduce((acc, c) => acc + (c.usage?.promptTokens ?? 0), 0);
                 const childCompletion = children.reduce((acc, c) => acc + (c.usage?.completionTokens ?? 0), 0);
                 const childCalls = children.reduce((acc, c) => acc + (c.usage?.calls ?? 0), 0);
-                // Memory savings estimate:
-                // - Each recalled record (avg ~200 chars ≈ 50 tokens) supplies cross-
-                //   session context that would otherwise require either a manual
-                //   user explanation, a re-read of files, or skill re-discovery.
-                //   Conservative multiplier of 5× to account for the "without memory
-                //   you would have read 3-5 files" replacement cost.
-                // - Offloaded child output bytes are subtracted from what the parent
-                //   would otherwise have had to carry in context.
-                const recallSavings = metrics.briefingTokensInjected * 5;
-                const offloadSavings = Math.round(metrics.offloadCharsAvoided / 4);
-                const totalSaved = recallSavings + offloadSavings;
+                // What we can actually measure:
+                //   - offload: bytes of child output that did NOT land in the parent's
+                //     context. These are real tokens not spent on the parent. We
+                //     subtract the preview that DID land (OFFLOAD_PREVIEW_CHARS is
+                //     already netted out in tools.ts before recordOffload fires).
+                //   - briefing tokens: cost, not savings. They're already counted in
+                //     session.promptTokens. We report them so the user can see how
+                //     much of the prompt budget memory is consuming.
+                const offloadSavedTokens = Math.round(metrics.offloadCharsAvoided / 4);
                 const totalSpent = session.promptTokens + session.completionTokens + childPrompt + childCompletion;
                 console.log(chalk.bold('\nToken usage — this session'));
                 console.log(`  Parent: ${chalk.cyan(session.promptTokens.toLocaleString())}↑  ${chalk.cyan(session.completionTokens.toLocaleString())}↓  ${chalk.gray(`(${session.turns} turn${session.turns === 1 ? '' : 's'}, ${session.calls} LLM call${session.calls === 1 ? '' : 's'})`)}`);
@@ -126,17 +128,15 @@ export async function tryHandleObsCommand(ctx) {
                         console.log(chalk.gray(`    …and ${children.length - 5} more (see /agents)`));
                 }
                 console.log(`  Total this session: ${chalk.bold.cyan(totalSpent.toLocaleString())} tokens`);
-                console.log(chalk.bold('\nMemory savings (estimated)'));
-                console.log(`  Briefing tokens injected:  ${chalk.gray(metrics.briefingTokensInjected.toLocaleString())}  (${metrics.recallRecordsConsulted} records consulted)`);
-                console.log(`  Cross-session recall value: ~${chalk.green(recallSavings.toLocaleString())} tokens you'd otherwise spend re-reading files / re-explaining context`);
-                console.log(`  Offload bytes avoided:     ${chalk.gray(metrics.offloadCharsAvoided.toLocaleString())} chars (large child outputs that stayed out of parent context)`);
-                console.log(`  → Offload value:           ~${chalk.green(offloadSavings.toLocaleString())} tokens`);
-                console.log(`  ${chalk.bold('Total estimated savings:')}  ${chalk.bold.green('~' + totalSaved.toLocaleString())} tokens`);
-                if (totalSpent > 0) {
-                    const ratio = totalSaved / totalSpent;
-                    console.log(chalk.gray(`  Ratio: for every 1 token spent, memory saved ~${ratio.toFixed(2)} tokens of context.`));
+                console.log(chalk.bold('\nMemory'));
+                console.log(`  Briefing tokens injected: ${chalk.gray(metrics.briefingTokensInjected.toLocaleString())}  ${chalk.gray(`(${metrics.recallRecordsConsulted} records consulted — already included in parent ↑)`)}`);
+                console.log(`  Child output offloaded:   ${chalk.gray(metrics.offloadCharsAvoided.toLocaleString())} chars  ${chalk.gray(`(≈${offloadSavedTokens.toLocaleString()} parent tokens not spent)`)}`);
+                if (offloadSavedTokens > 0 && totalSpent > 0) {
+                    const ratio = offloadSavedTokens / totalSpent;
+                    const display = ratio >= 0.01 ? ratio.toFixed(2) : '<0.01';
+                    console.log(chalk.gray(`  Offload ratio: ~${display} saved per token spent.`));
                 }
-                console.log(chalk.gray('\n  (Estimates use a 5× multiplier on briefing tokens — a heuristic for "you would have needed to re-derive this from files/prompts otherwise". Treat as directional, not exact.)\n'));
+                console.log(chalk.gray('\n  (Offload is measured; briefing tokens are an information-gain stat, not a savings number.)\n'));
                 return true;
             }
         case '/feedback':

package/dist/cli/commands/session.js

@@ -4,7 +4,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import chalk from 'chalk';
-import ora from 'ora';
+import { spinner as makeSpinner } from '../spinner.js';
 import { marked } from 'marked';
 import { listTranscripts, loadTranscript } from '../../state/sessionStore.js';
 import { readGoal, resumeGoal } from '../../state/goalStore.js';
@@ -51,6 +51,11 @@ export async function tryHandleSessionCommand(ctx) {
                     return true;
                 }
                 agent.sessionKey = sessionKey;
+                // The persisted transcript doesn't record per-call token usage, so
+                // we can't reconstruct counters for the resumed session — start
+                // counting from this point forward instead of carrying over the
+                // pre-resume parent counts (which were for a different session).
+                agent.resetSessionCounters();
                 const loaded = agent.loadHistory(entries);
                 console.log(chalk.green(`\n✓ Resumed session ${chalk.cyan(sessionKey)} with ${loaded} prior messages.`));
                 // If the resumed session has a goal that was suspended (paused,
@@ -73,9 +78,12 @@ export async function tryHandleSessionCommand(ctx) {
                         // before/after. Just unpause and kick off the next iteration.
                         const reactivated = resumeGoal(agent.workspaceRoot, sessionKey);
                         if (reactivated) {
-                            // Same rationale as /goal resume — drop any stale wrap-up
-                            // steering left over from the budget-trigger that paused us.
-                            agent.removeTaggedSystemMessage('goal-budget-steering');
+                            // 9d: pre-9d this branch had to drop a `goal-budget-steering`
+                            // tagged system message left over from a budget-trigger pause.
+                            // That message no longer exists — the wrap-up directive is
+                            // folded into the goal-anchor and the anchor is re-rendered
+                            // by the next runTurn. `refreshSystemPrompt` is still useful
+                            // here to rebuild any overlays that depend on the active goal.
                             agent.refreshSystemPrompt();
                             console.log(chalk.green(`\n▶  Goal resumed (${reactivated.budget.iterationsUsed}/${reactivated.budget.maxIterations} used). Starting next iteration…\n`));
                             ctx.repl.runAgentTurn(buildGoalKickoffPrompt(reactivated, 'resume'));
@@ -123,7 +131,7 @@ export async function tryHandleSessionCommand(ctx) {
             }
         case '/compact':
             {
-                const spinner = ora(chalk.gray('Summarizing conversation for compaction...')).start();
+                const spinner = makeSpinner(chalk.gray('Summarizing conversation for compaction...')).start();
                 try {
                     const result = await agent.compactHistory();
                     if (!result) {

package/dist/cli/commands/ui.js

@@ -6,11 +6,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 import chalk from 'chalk';
-import ora from 'ora';
+import { spinner as makeSpinner } from '../spinner.js';
 import { LOCAL_TOOLS } from '../../agent/agent.js';
 import { callMcpTool } from '../../runtime/mcpUtils.js';
 import { listSessions, reconcileStale } from '../../orchestration/orchestrator.js';
-import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
+import { readPreferences, resolveEffort, writePreferences } from '../../state/preferencesStore.js';
 import { readPlan } from '../../state/taskStore.js';
 import { getConfigPath } from '../../config/config.js';
 import { copyToClipboard } from '../../runtime/clipboard.js';
@@ -41,7 +41,7 @@ export async function tryHandleUiCommand(ctx) {
                         console.log(`  LLM Endpoint:  ${chalk.blue(llm.endpoint)}`);
                     }
                 }
-                const spinner = ora(chalk.gray('Querying diagnostics & testing latency...')).start();
+                const spinner = makeSpinner(chalk.gray('Querying diagnostics & testing latency...')).start();
                 try {
                     const start = Date.now();
                     const testRes = await mcpClient.callTool('list_skills', { scope: 'local' });
@@ -116,7 +116,7 @@ export async function tryHandleUiCommand(ctx) {
                 else {
                     console.log(`  Endpoint: ${chalk.blue(server.url)}`);
                 }
-                const spinner = ora(chalk.gray('Checking MCP tool surface...')).start();
+                const spinner = makeSpinner(chalk.gray('Checking MCP tool surface...')).start();
                 try {
                     const startedAt = Date.now();
                     const res = await mcpClient.listTools();
@@ -204,42 +204,10 @@ export async function tryHandleUiCommand(ctx) {
                 console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(newModel)}\n`));
                 return true;
             }
-        case '/mcp':
-            {
-                const profileName = config.activeServer;
-                const server = config.servers[profileName];
-                console.log(chalk.bold('\nMCP server'));
-                console.log(`  Profile: ${chalk.green(profileName)} (${chalk.cyan(server?.type ?? 'unknown')})`);
-                if (server?.type === 'http') {
-                    console.log(`  URL:     ${chalk.blue(server.url)}`);
-                }
-                else if (server?.type === 'stdio') {
-                    console.log(`  Cmd:     ${chalk.blue(server.command)} ${server.args?.join(' ') || ''}`);
-                }
-                const spinner = ora(chalk.gray('Fetching MCP tool surface...')).start();
-                try {
-                    const res = await mcpClient.listTools();
-                    const tools = res.tools || [];
-                    spinner.succeed(chalk.green(`${tools.length} MCP tools available`));
-                    const namespaces = {};
-                    for (const t of tools) {
-                        const parts = (t.name || '').split('_');
-                        const ns = parts.length > 1 ? parts[0] : 'misc';
-                        (namespaces[ns] ||= []).push(t.name);
-                    }
-                    for (const ns of Object.keys(namespaces).sort()) {
-                        console.log(`\n  ${chalk.bold.cyan(ns)} (${namespaces[ns].length})`);
-                        for (const name of namespaces[ns].sort()) {
-                            console.log(`    ${chalk.gray('•')} ${name}`);
-                        }
-                    }
-                }
-                catch (err) {
-                    spinner.fail(chalk.red(`Failed: ${err.message}`));
-                }
-                console.log();
-                return true;
-            }
+        // /mcp moved to its own command file (commands/mcp.ts) as part of 0.3.6
+        // Item 11. The new dispatcher supports `/mcp list`, `/mcp reconnect`,
+        // and the original no-arg "show tools by namespace" behaviour is now
+        // covered by `/mcp tools` (handled in commands/mcp.ts).
         case '/copy':
             {
                 if (!agent.lastAnswer) {
@@ -267,18 +235,18 @@ export async function tryHandleUiCommand(ctx) {
             {
                 const prefs = readPreferences(agent.workspaceRoot);
                 const arg = args.join(' ').trim();
+                const { SEGMENT_NAMES, isKnownSegment } = await import('../statusline.js');
                 if (!arg) {
                     console.log(chalk.bold('\nStatusline'));
                     console.log(`  Current: ${chalk.cyan(prefs.statusline)}`);
-                    console.log(chalk.gray('  Available segments: mode, branch, dirty, model, tokens, session'));
-                    console.log(chalk.gray('  Example: /statusline mode,branch,dirty,tokens\n'));
+                    console.log(chalk.gray(`  Available segments: ${SEGMENT_NAMES.join(', ')}`));
+                    console.log(chalk.gray('  Example: /statusline mode,workflow,goal,model,session,plan\n'));
                     return true;
                 }
-                const valid = new Set(['mode', 'branch', 'dirty', 'model', 'tokens', 'session']);
                 const requested = arg.split(',').map((s) => s.trim()).filter(Boolean);
-                const unknown = requested.filter((s) => !valid.has(s));
+                const unknown = requested.filter((s) => !isKnownSegment(s));
                 if (unknown.length > 0) {
-                    console.log(chalk.red(`\nUnknown segment(s): ${unknown.join(', ')}. Valid: ${Array.from(valid).join(', ')}\n`));
+                    console.log(chalk.red(`\nUnknown segment(s): ${unknown.join(', ')}. Valid: ${SEGMENT_NAMES.join(', ')}\n`));
                     return true;
                 }
                 writePreferences(agent.workspaceRoot, { statusline: requested.join(',') });
@@ -373,6 +341,63 @@ export async function tryHandleUiCommand(ctx) {
                 console.log(chalk.green(`\n✓ Raw scrollback ${next ? 'enabled' : 'disabled'}. Markdown rendering ${next ? 'OFF' : 'ON'} for next turn.\n`));
                 return true;
             }
+        case '/effort':
+            {
+                const arg = (args[0] ?? '').toLowerCase();
+                const valid = ['low', 'medium', 'high'];
+                if (!arg) {
+                    const resolved = resolveEffort(agent.workspaceRoot);
+                    const sourceTag = resolved.source === 'env' ? chalk.gray(' (env: BRAINROUTER_EFFORT)') :
+                        resolved.source === 'preference' ? chalk.gray(' (preference)') :
+                            chalk.gray(' (default)');
+                    console.log(chalk.bold(`\nReasoning depth: ${chalk.cyan(resolved.effort)}${sourceTag}`));
+                    console.log(chalk.gray('  low     — terse, one-paragraph answers; minimal ceremony.'));
+                    console.log(chalk.gray('  medium  — current default; no overlay, no provider reasoning slot. (default)'));
+                    console.log(chalk.gray('  high    — step-by-step reasoning; audits evidence before each tool call.'));
+                    console.log(chalk.gray('  When the model supports it (gpt-5, o-series, gpt-oss, DeepSeek R1/V3+, Qwen3,'));
+                    console.log(chalk.gray('  Magistral, *-reasoning, *-thinking — works on OpenAI, DeepSeek, OpenRouter,'));
+                    console.log(chalk.gray('  LM Studio 0.3.29+, Ollama), the level is also forwarded as `reasoning_effort`.'));
+                    console.log(chalk.gray('  Toggle with: /effort low | /effort medium | /effort high'));
+                    console.log(chalk.gray('  Env override (one-shot): BRAINROUTER_EFFORT=high brainrouter\n'));
+                    return true;
+                }
+                if (!valid.includes(arg)) {
+                    console.log(chalk.red(`\nUnknown level "${arg}". Choose: ${valid.join(' | ')}\n`));
+                    return true;
+                }
+                writePreferences(agent.workspaceRoot, { effort: arg });
+                agent.refreshSystemPrompt();
+                const after = resolveEffort(agent.workspaceRoot);
+                // Surface a friendly nudge when the env var would still shadow the new
+                // preference on the next process boot.
+                if (process.env.BRAINROUTER_EFFORT && after.source === 'env') {
+                    console.log(chalk.yellow(`\n✓ Preference saved as ${arg}, but BRAINROUTER_EFFORT=${process.env.BRAINROUTER_EFFORT} is still active this process — env wins.\n`));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ Reasoning depth → ${arg}. Applies on the next turn.\n`));
+                }
+                return true;
+            }
+        case '/quiet':
+            {
+                const prefs = readPreferences(agent.workspaceRoot);
+                const arg = (args[0] ?? '').toLowerCase();
+                const next = arg ? (arg === 'on' || arg === 'true' || arg === '1') : !prefs.quiet;
+                writePreferences(agent.workspaceRoot, { quiet: next });
+                // `--quiet` set a one-shot env override at startup; once the user
+                // explicitly toggles in-session their choice wins from now on.
+                if (next) {
+                    process.env.BRAINROUTER_QUIET = '1';
+                }
+                else {
+                    delete process.env.BRAINROUTER_QUIET;
+                }
+                const detail = next
+                    ? 'recall tables, briefing dumps, and tool-completion previews are now hidden.'
+                    : 'full chrome restored — recall tables, previews, and briefings will print again.';
+                console.log(chalk.green(`\n✓ Quiet mode ${next ? 'enabled' : 'disabled'}: ${detail}\n`));
+                return true;
+            }
         case '/apps':
         case '/plugins':
             {
@@ -468,6 +493,33 @@ export async function tryHandleUiCommand(ctx) {
                 console.log(chalk.gray('  Tip: configure IDE to launch brainrouter with -w <workspace> so paths match.\n'));
                 return true;
             }
+        case '/where':
+            {
+                const { gatherWhereInputs, renderWhere } = await import('../whereView.js');
+                const { resolveTheme } = await import('../theme.js');
+                const theme = resolveTheme(agent.workspaceRoot);
+                const profileName = config.activeServer;
+                const server = config.servers[profileName];
+                const briefing = agent.getLastBriefing();
+                const inputs = gatherWhereInputs({
+                    workspaceRoot: agent.workspaceRoot,
+                    sessionKey: agent.sessionKey,
+                    model: agent.getModel(),
+                    mcpProfile: profileName,
+                    mcpTransport: server?.type ?? 'unknown',
+                    mcpOnline: mcpClient.isConnected(),
+                    // 10c: identity flows from the live wrapper; falls back to the
+                    // config field when present, otherwise 'unknown'.
+                    mcpIdentity: typeof mcpClient.getIdentity === 'function'
+                        ? mcpClient.getIdentity()
+                        : (server?.identity ?? 'unknown'),
+                    accessMode: agent.getAccessMode(),
+                    recalledRecords: agent.getRecalledRecords(),
+                    briefingSources: briefing.sources,
+                });
+                console.log('\n' + renderWhere(inputs, theme) + '\n');
+                return true;
+            }
         case '/help': {
             renderHelp(args[0]?.toLowerCase());
             return true;