@kinqs/brainrouter-cli 0.3.5 → 0.3.6

package/dist/cli/whereView.js

@@ -0,0 +1,245 @@
+import path from 'node:path';
+import { formatBudget, readGoal } from '../state/goalStore.js';
+import { readPlan } from '../state/taskStore.js';
+import { getCurrentWorkflow, listWorkflows } from '../state/workflowArtifacts.js';
+import { listSessions } from '../orchestration/orchestrator.js';
+import { readPreferences, resolveEffort } from '../state/preferencesStore.js';
+import { BOX } from './theme.js';
+const RECALL_LIMIT = 5;
+const PLAN_LIMIT = 8;
+const CHILDREN_LIMIT = 6;
+function indent(line, depth = 2) {
+    return ' '.repeat(depth) + line;
+}
+function renderHeader(title, theme) {
+    return theme.heading(`${BOX.midLeft}${BOX.horizontal} ${title}`);
+}
+function renderWorkspace(inputs, theme) {
+    const base = path.basename(inputs.workspaceRoot) || inputs.workspaceRoot;
+    const dim = theme.muted;
+    // /where is the "tell me everything" surface, so we show the effort level
+    // regardless of whether it's at default — unlike the statusline, which
+    // hides medium to keep the prompt quiet. Tag the source in parens when
+    // env beat the preference so users can see why the value differs from
+    // what they set with /effort.
+    const effortLine = inputs.effortSource === 'env'
+        ? `effort  ${inputs.effort}  ${dim('(env)')}`
+        : `effort  ${inputs.effort}`;
+    const lines = [
+        renderHeader('Workspace', theme),
+        indent(theme.plain(`${base}  ${dim('(' + inputs.workspaceRoot + ')')}`)),
+        indent(dim(`session ${inputs.sessionKey.slice(0, 8)}  ·  model ${inputs.model}  ·  mode ${inputs.accessMode}`)),
+        indent(dim(`exec    ${inputs.executionMode}  ·  review ${inputs.reviewPolicy}  ·  ${effortLine}`)),
+        indent(dim(`mcp     ${inputs.mcpProfile}  ·  ${inputs.mcpTransport}  ·  ${inputs.mcpOnline ? 'online' : 'offline'}`)),
+    ];
+    // 10c: distinct `brain` line for the BrainRouter cloud brain. Shown
+    // unconditionally regardless of state when identity is brainrouter (vs.
+    // the statusline which hides online to stay quiet). Third-party MCPs
+    // skip the line entirely; `unknown` is pre-detection so we wait.
+    if (inputs.mcpIdentity === 'brainrouter') {
+        const brainState = inputs.mcpOnline ? '🟢 online' : '🔴 offline · cloud unreachable';
+        lines.push(indent(dim(`brain   ${brainState}`)));
+    }
+    return lines;
+}
+function renderWorkflow(inputs, theme) {
+    if (!inputs.workflowSlug)
+        return [];
+    const meta = inputs.workflowMeta;
+    const dim = theme.muted;
+    const lines = [renderHeader('Workflow', theme)];
+    lines.push(indent(theme.info(inputs.workflowSlug) + (meta ? '  ' + dim(`(${meta.kind} · ${meta.status})`) : '')));
+    if (meta)
+        lines.push(indent(dim(`title: ${meta.title}`)));
+    return lines;
+}
+function renderGoal(inputs, theme) {
+    const goal = inputs.goal;
+    if (!goal)
+        return [];
+    const dim = theme.muted;
+    const cap = formatBudget(goal.budget.maxIterations);
+    const used = goal.budget.iterationsUsed;
+    const statusColor = goal.status === 'complete' ? theme.success :
+        goal.status === 'blocked' ? theme.danger :
+            goal.status === 'usage_limited' ? theme.warning :
+                goal.status === 'paused' ? theme.warning :
+                    theme.info;
+    const lines = [renderHeader('Goal', theme)];
+    lines.push(indent(statusColor(goal.status.toUpperCase().replace('_', ' '))));
+    // Wrap the goal text at a sensible width so long objectives don't
+    // produce one giant unreadable line.
+    lines.push(indent(theme.plain(wrapText(goal.text, 76))));
+    const tokenLine = goal.budget.maxTokens
+        ? `  ·  tokens ${(goal.budget.tokensUsed ?? 0).toLocaleString()}/${goal.budget.maxTokens.toLocaleString()}`
+        : '';
+    lines.push(indent(dim(`iterations ${used}/${cap}${tokenLine}`)));
+    if (goal.blockedReason)
+        lines.push(indent(dim(`reason: ${goal.blockedReason}`)));
+    return lines;
+}
+function renderPlan(inputs, theme) {
+    if (!inputs.plan.items.length)
+        return [];
+    const dim = theme.muted;
+    const lines = [renderHeader('Plan', theme)];
+    if (inputs.plan.explanation) {
+        lines.push(indent(dim(inputs.plan.explanation)));
+    }
+    for (const item of inputs.plan.items.slice(0, PLAN_LIMIT)) {
+        const mark = item.status === 'completed' ? theme.success('✓') :
+            item.status === 'in_progress' ? theme.warning('⏳') :
+                dim('☐');
+        const text = item.status === 'completed' ? dim(item.step) : theme.plain(item.step);
+        lines.push(indent(`${mark} ${text}`));
+    }
+    if (inputs.plan.items.length > PLAN_LIMIT) {
+        lines.push(indent(dim(`…and ${inputs.plan.items.length - PLAN_LIMIT} more`)));
+    }
+    return lines;
+}
+function renderRecall(inputs, theme) {
+    if (!inputs.recalledRecords.length && !inputs.briefingSources.length)
+        return [];
+    const dim = theme.muted;
+    const lines = [renderHeader('Recent recall', theme)];
+    if (inputs.briefingSources.length) {
+        lines.push(indent(dim(`sources: ${inputs.briefingSources.join(', ')}`)));
+    }
+    for (const rec of inputs.recalledRecords.slice(0, RECALL_LIMIT)) {
+        const typeTag = rec.type ? theme.secondary(`[${rec.type}] `) : '';
+        const score = typeof rec.priority === 'number' ? dim(` (p=${rec.priority.toFixed(2)})`) : '';
+        const snippet = (rec.content ?? '').replace(/\s+/g, ' ').trim().slice(0, 100);
+        lines.push(indent(`${typeTag}${theme.plain(snippet || rec.recordId)}${score}`));
+    }
+    if (inputs.recalledRecords.length > RECALL_LIMIT) {
+        lines.push(indent(dim(`…and ${inputs.recalledRecords.length - RECALL_LIMIT} more`)));
+    }
+    return lines;
+}
+function renderChildren(inputs, theme) {
+    // Live children = anything currently pending or running. Stale/completed
+    // are visible in /agents; /where stays focused on what's blocking attention.
+    const live = inputs.childSessions.filter((s) => s.status === 'pending' || s.status === 'running');
+    if (!live.length)
+        return [];
+    const dim = theme.muted;
+    const lines = [renderHeader(`Active children (${live.length})`, theme)];
+    for (const s of live.slice(0, CHILDREN_LIMIT)) {
+        const statusColor = s.status === 'running' ? theme.success : theme.warning;
+        const role = theme.secondary(s.role);
+        const id = theme.info(s.id);
+        const promptPreview = s.prompt
+            ? '  ' + dim(s.prompt.replace(/\s+/g, ' ').slice(0, 80))
+            : '';
+        lines.push(indent(`${statusColor(s.status)}  ${id}  ${role}${promptPreview}`));
+    }
+    if (live.length > CHILDREN_LIMIT) {
+        lines.push(indent(dim(`…and ${live.length - CHILDREN_LIMIT} more`)));
+    }
+    return lines;
+}
+function wrapText(text, width) {
+    if (text.length <= width)
+        return text;
+    const words = text.split(/\s+/);
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if (!current) {
+            current = word;
+            continue;
+        }
+        if (current.length + 1 + word.length > width) {
+            lines.push(current);
+            current = word;
+        }
+        else {
+            current += ' ' + word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.join('\n' + ' '.repeat(2));
+}
+/**
+ * Render the full /where block. Sections are dropped when empty; a fresh
+ * workspace with no goal / plan / children renders just WORKSPACE.
+ */
+export function renderWhere(inputs, theme) {
+    const sections = [];
+    sections.push(renderWorkspace(inputs, theme));
+    const workflow = renderWorkflow(inputs, theme);
+    if (workflow.length)
+        sections.push(workflow);
+    const goal = renderGoal(inputs, theme);
+    if (goal.length)
+        sections.push(goal);
+    const plan = renderPlan(inputs, theme);
+    if (plan.length)
+        sections.push(plan);
+    const recall = renderRecall(inputs, theme);
+    if (recall.length)
+        sections.push(recall);
+    const children = renderChildren(inputs, theme);
+    if (children.length)
+        sections.push(children);
+    return sections.map((lines) => lines.join('\n')).join('\n\n');
+}
+/**
+ * Gather the snapshot the renderer needs. Single function so the command
+ * handler is two lines (gather + render + print).
+ */
+export function gatherWhereInputs(args) {
+    const workflowSlug = (() => {
+        // 9d-bugfix: session-scoped binding so a fresh CLI shows no workflow
+        // even when an earlier session in the same workspace had one bound.
+        try {
+            return getCurrentWorkflow(args.workspaceRoot, args.sessionKey);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const workflowMeta = workflowSlug
+        ? listWorkflows(args.workspaceRoot).find((w) => w.slug === workflowSlug)
+        : undefined;
+    const goal = (() => {
+        try {
+            return readGoal(args.workspaceRoot, args.sessionKey) ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const plan = (() => {
+        try {
+            return readPlan(args.workspaceRoot, args.sessionKey);
+        }
+        catch {
+            return { items: [], updatedAt: '' };
+        }
+    })();
+    const childSessions = (() => {
+        try {
+            return listSessions(args.workspaceRoot);
+        }
+        catch {
+            return [];
+        }
+    })();
+    const prefs = readPreferences(args.workspaceRoot);
+    const resolvedEffort = resolveEffort(args.workspaceRoot);
+    return {
+        ...args,
+        executionMode: prefs.executionMode,
+        reviewPolicy: prefs.reviewPolicy,
+        effort: resolvedEffort.effort,
+        effortSource: resolvedEffort.source,
+        workflowSlug,
+        workflowMeta,
+        goal,
+        plan,
+        childSessions,
+    };
+}

package/dist/config/config.d.ts

@@ -5,6 +5,25 @@ export interface ServerConfig {
     env?: Record<string, string>;
     url?: string;
     apiKey?: string;
+    /**
+     * 0.3.6 item 10a: identity tag for distinguishing the BrainRouter cloud
+     * brain ("our MCP") from third-party MCPs the user might attach (GitHub,
+     * filesystem, Slack, etc.). Drives status surfaces (banner / statusline /
+     * `/where`) and the offline-mode prompt swap: when "the brain" is down
+     * the user gets a clear signal, not a generic "MCP offline" message.
+     *
+     * Detection priority when this field is unset:
+     *   1. Server profile name starts with `brainrouter` (case-insensitive).
+     *   2. URL hostname matches `*.brainrouter.cloud` or `*.brainrouter.dev`.
+     *   3. (Run-time fallback) first successful `listTools()` includes
+     *      both `memory_recall` AND `list_skills` — the BrainRouter signature
+     *      pair. See `detectMcpIdentity` in `runtime/mcpClient.ts`.
+     *
+     * Explicit values always win — if the user marks a third-party MCP as
+     * `identity: 'brainrouter'`, that's their call (e.g. they're running a
+     * local fork that exposes the same tool surface).
+     */
+    identity?: 'brainrouter' | 'third-party';
 }
 export interface LLMConfig {
     provider: 'openai';
@@ -18,5 +37,26 @@ export interface Config {
     llm?: LLMConfig;
 }
 export declare function getConfigPath(): string;
+/**
+ * Read the existing config.json or exit with a clear error. The CLI owns
+ * READS of this file — writes are the user's job (via `brainrouter login`,
+ * `brainrouter config`, or direct edit). Auto-fabricating a default config
+ * was a holdover from the monorepo dev story; it only ever produced a
+ * broken stdio profile pointing at a sibling `brainrouter/` package that
+ * doesn't exist outside the monorepo, so npm-installed users got a config
+ * file they had to fix anyway.
+ *
+ * Setup commands (login / config) that need to BUILD a fresh config from
+ * scratch should call `loadOrInitConfig` instead — it returns an empty
+ * skeleton when no file exists rather than exiting.
+ */
 export declare function loadConfig(): Config;
+/**
+ * Setup-wizard variant of `loadConfig`. Returns the existing config when
+ * one is on disk, or an empty skeleton when none exists yet. Used by
+ * `brainrouter login` and `brainrouter config` so a first-run user can
+ * BUILD their config interactively without hitting the strict
+ * "no config — run setup" error from `loadConfig`.
+ */
+export declare function loadOrInitConfig(): Config;
 export declare function saveConfig(config: Config): void;

package/dist/config/config.js

@@ -1,46 +1,68 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { DatabaseSync } from 'node:sqlite';
 const CONFIG_DIR = path.join(os.homedir(), '.config', 'brainrouter');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 export function getConfigPath() {
     return CONFIG_FILE;
 }
+/**
+ * Read the existing config.json or exit with a clear error. The CLI owns
+ * READS of this file — writes are the user's job (via `brainrouter login`,
+ * `brainrouter config`, or direct edit). Auto-fabricating a default config
+ * was a holdover from the monorepo dev story; it only ever produced a
+ * broken stdio profile pointing at a sibling `brainrouter/` package that
+ * doesn't exist outside the monorepo, so npm-installed users got a config
+ * file they had to fix anyway.
+ *
+ * Setup commands (login / config) that need to BUILD a fresh config from
+ * scratch should call `loadOrInitConfig` instead — it returns an empty
+ * skeleton when no file exists rather than exiting.
+ */
 export function loadConfig() {
-    let config;
     if (!fs.existsSync(CONFIG_FILE)) {
-        config = createDefaultConfig();
+        console.error(`No BrainRouter config found at ${CONFIG_FILE}.`);
+        console.error(`Run \`brainrouter login\` to connect to a hosted MCP server, or \`brainrouter config\` to set one up.`);
+        process.exit(1);
     }
-    else {
-        try {
-            const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
-            const parsed = JSON.parse(raw);
-            // Backfill standard properties if missing
-            if (!parsed.servers)
-                parsed.servers = {};
-            if (!parsed.activeServer)
-                parsed.activeServer = 'default';
-            config = parsed;
-        }
-        catch (error) {
-            console.error(`Warning: Failed to parse config file at ${CONFIG_FILE}. Using default config.`);
-            config = createDefaultConfig();
-        }
+    let parsed;
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+        parsed = JSON.parse(raw);
     }
-    // Auto-resolve placeholder API keys if possible
-    resolveDefaultApiKey(config);
+    catch (error) {
+        console.error(`Error: Failed to parse config file at ${CONFIG_FILE}: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`Fix the file by hand, or delete it and run \`brainrouter config\` to recreate.`);
+        process.exit(1);
+    }
+    if (!parsed.servers)
+        parsed.servers = {};
+    if (!parsed.activeServer)
+        parsed.activeServer = '';
     // The default config writes `llm.apiKey: ''` so it never appears as a
     // secret in the committed file. Backfill from the standard env vars at
     // load time so every downstream consumer (callOpenAI, mcpClient env
     // propagation, the cognitive extractor LLM runner) sees a real value
     // instead of the empty string.
-    if (config.llm && !config.llm.apiKey.trim()) {
+    if (parsed.llm && !parsed.llm.apiKey.trim()) {
         const envKey = process.env.OPENAI_API_KEY || process.env.BRAINROUTER_LLM_API_KEY;
         if (envKey)
-            config.llm.apiKey = envKey;
+            parsed.llm.apiKey = envKey;
     }
-    return config;
+    return parsed;
+}
+/**
+ * Setup-wizard variant of `loadConfig`. Returns the existing config when
+ * one is on disk, or an empty skeleton when none exists yet. Used by
+ * `brainrouter login` and `brainrouter config` so a first-run user can
+ * BUILD their config interactively without hitting the strict
+ * "no config — run setup" error from `loadConfig`.
+ */
+export function loadOrInitConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return { activeServer: '', servers: {} };
+    }
+    return loadConfig();
 }
 export function saveConfig(config) {
     try {
@@ -53,53 +75,3 @@ export function saveConfig(config) {
         console.error(`Error: Failed to save config to ${CONFIG_FILE}:`, error instanceof Error ? error.message : error);
     }
 }
-function createDefaultConfig() {
-    // Derive path to the default local MCP server dist relative to this module.
-    // After build: brainrouter-cli/dist/config/config.js → walk three levels up
-    // to the monorepo root, then into the sibling `brainrouter/` package
-    // (formerly `mcp/`) which is the MCP server.
-    const defaultMcpPath = path.resolve(import.meta.dirname, '..', '..', '..', 'brainrouter', 'dist', 'index.js');
-    const config = {
-        activeServer: 'default',
-        servers: {
-            default: {
-                type: 'stdio',
-                command: 'node',
-                args: [defaultMcpPath, '--root', './'],
-                env: {
-                    BRAINROUTER_API_KEY: 'br_admin_key_placeholder'
-                }
-            }
-        },
-        llm: {
-            provider: 'openai',
-            apiKey: '',
-            model: 'gpt-4o-mini',
-            endpoint: 'https://api.openai.com/v1'
-        }
-    };
-    saveConfig(config);
-    return config;
-}
-function resolveDefaultApiKey(config) {
-    const defaultServer = config.servers.default;
-    if (defaultServer &&
-        defaultServer.type === 'stdio' &&
-        defaultServer.env &&
-        defaultServer.env.BRAINROUTER_API_KEY === 'br_admin_key_placeholder') {
-        const dbPath = process.env.BRAINROUTER_MEMORY_DB || path.join(os.homedir(), '.brainrouter', 'memory.db');
-        if (fs.existsSync(dbPath)) {
-            try {
-                const db = new DatabaseSync(dbPath);
-                const row = db.prepare("SELECT api_key FROM users WHERE is_admin = 1 LIMIT 1").get();
-                if (row && row.api_key) {
-                    defaultServer.env.BRAINROUTER_API_KEY = row.api_key;
-                    saveConfig(config);
-                }
-            }
-            catch (error) {
-                // ignore errors
-            }
-        }
-    }
-}

package/dist/index.js

@@ -1,11 +1,62 @@
 #!/usr/bin/env node
+/**
+ * Filter out Node.js platform warnings that the user has no way to act on
+ * and that scroll real CLI banner content off-screen on short terminals.
+ *
+ *   - `ExperimentalWarning: SQLite is an experimental feature` — emitted by
+ *     `node:sqlite`. The CLI itself no longer imports sqlite, but the
+ *     stdio MCP child process does, and its warnings surface on the parent's
+ *     stderr. Stable in Node 22+ in practice; the warning is correct but
+ *     uninformative.
+ *   - `DeprecationWarning: ... dotenv ...` — dotenv@16 prints a teaser for
+ *     its hosted product on every load on newer Node releases.
+ *
+ * BrainRouter's own warnings flow through unchanged. `NODE_NO_WARNINGS=1`
+ * would silence those too, so we intercept selectively instead.
+ *
+ * Two interception points: (1) remove Node's built-in `warning` listener
+ * and add our own filtered one — this catches warnings emitted from
+ * subprocesses or transitive imports during ESM resolution; (2) replace
+ * `process.emitWarning` so future direct callers also get the filter.
+ * Both are needed because ESM hoists imports above any code in this file,
+ * so an emitWarning override alone misses import-time warnings.
+ */
+function isSuppressibleWarning(message, type) {
+    const looksExperimental = type === 'ExperimentalWarning' ||
+        /experimental feature|SQLite is an experimental/i.test(message);
+    const looksDotenvNoise = /dotenv@\d|dotenvx|dotenv\.org/i.test(message);
+    return looksExperimental || looksDotenvNoise;
+}
+// Detach Node's default warning printer and replace with a filtered one.
+// process.listeners returns each Function attached; the default one is a
+// single internal listener that does the stderr printing.
+for (const listener of process.listeners('warning')) {
+    process.removeListener('warning', listener);
+}
+process.on('warning', (warning) => {
+    if (isSuppressibleWarning(warning?.message ?? '', warning?.name ?? ''))
+        return;
+    // Mirror Node's default formatting for everything else so users see the
+    // familiar "(node:PID) <Name>: <message>" shape.
+    process.stderr.write(`(node:${process.pid}) ${warning?.name ?? 'Warning'}: ${warning?.message ?? warning}\n`);
+});
+const originalEmitWarning = process.emitWarning.bind(process);
+process.emitWarning = ((warning, ...rest) => {
+    const message = typeof warning === 'string' ? warning : warning?.message ?? '';
+    const type = typeof rest[0] === 'string' ? rest[0]
+        : (rest[0] && typeof rest[0] === 'object' && 'type' in rest[0]) ? rest[0].type
+            : (warning instanceof Error ? warning.name : '');
+    if (isSuppressibleWarning(message, type))
+        return;
+    return originalEmitWarning(warning, ...rest);
+});
 import fs from 'node:fs';
 import path from 'node:path';
 import url from 'node:url';
 import { Command } from 'commander';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { loadConfig, saveConfig } from './config/config.js';
+import { loadConfig, loadOrInitConfig, saveConfig } from './config/config.js';
 import { McpClientWrapper } from './runtime/mcpClient.js';
 import { Agent } from './agent/agent.js';
 import { startREPL } from './cli/repl.js';
@@ -174,13 +225,23 @@ program
     .option('-m, --model <name>', 'LLM model override')
     .option('-w, --workspace <path>', 'Workspace root for files, commands, memory session, and MCP --root')
     .option('--strict-mcp', 'Exit if the MCP server is unreachable (default: continue in offline mode with local tools only)')
+    .option('--quiet', 'Suppress recall tables, briefing dumps, and tool-completion previews (model prose only). Toggle in-session with /quiet.')
     .action(async (options) => {
     if (options.workspace) {
         process.env.BRAINROUTER_WORKSPACE = options.workspace;
     }
+    if (options.quiet) {
+        // Quiet mode is durable in preferences, but `--quiet` should turn it
+        // on for THIS session without permanently flipping the user's saved
+        // setting. Set a process env that the REPL preference-merger checks.
+        process.env.BRAINROUTER_QUIET = '1';
+    }
     const workspace = findWorkspaceRoot();
     applyWorkspaceRoot(workspace.workspaceRoot);
-    console.log(chalk.gray(`Workspace: ${workspace.workspaceRoot} (${workspace.reason})`));
+    // Workspace path + detection reason intentionally NOT printed here — the
+    // boxed startup banner shows the workspace row, and `/workspace` exposes
+    // the launch CWD + detection reason on demand. Keeping a duplicate
+    // stale-chrome line above the banner undermines the banner-first design.
     const config = loadConfig();
     const profileName = options.profile || config.activeServer;
     const configuredServer = config.servers[profileName];
@@ -206,10 +267,14 @@ program
         llm.model = options.model;
     }
     const mcpClient = new McpClientWrapper();
-    console.log(chalk.gray(`Connecting to MCP server profile "${profileName}"...`));
+    // "Connecting..." / "Successfully connected!" status lines intentionally
+    // dropped — they printed for the ~1-2s of connect AND scrolled the
+    // banner up. On success the banner's `mcp ... online` row IS the
+    // success signal; on failure the catch-block error + the post-banner
+    // OFFLINE MODE warning in startREPL together cover both diagnosis and
+    // remediation.
     try {
-        await mcpClient.connect(serverConfig, llm);
-        console.log(chalk.green('Successfully connected to BrainRouter MCP Server!'));
+        await mcpClient.connect(serverConfig, llm, profileName);
     }
     catch (err) {
         // Degraded "offline mode": the MCP server is the cognitive memory layer
@@ -224,9 +289,8 @@ program
             console.error(chalk.gray('--strict-mcp set; exiting.'));
             process.exit(1);
         }
-        console.warn(chalk.yellow('⚠️  Continuing in OFFLINE MODE — memory recall, skills, and capture are disabled.\n' +
-            '    Local tools (file edits, shell, web fetch, spawn_agent) remain available.\n' +
-            '    Start the MCP server and restart the CLI to restore full functionality.\n'));
+        // The banner-adjacent OFFLINE MODE warning in startREPL covers the
+        // remediation hint. No second warning here.
     }
     const agent = new Agent(mcpClient, llm, {
         workspaceRoot: workspace.workspaceRoot,
@@ -302,7 +366,7 @@ program
         llm.model = options.model;
     const mcpClient = new McpClientWrapper();
     try {
-        await mcpClient.connect(serverConfig, llm);
+        await mcpClient.connect(serverConfig, llm, profileName);
     }
     catch (err) {
         console.error(`MCP connect failed: ${err.message}`);
@@ -395,10 +459,11 @@ program
             type: 'http',
             url: answers.url,
             apiKey: answers.apiKey || undefined
-        });
+        }, undefined, answers.profileName);
         await mcpClient.close();
-        // Save to config
-        const config = loadConfig();
+        // Save to config — `loadOrInitConfig` lets first-run users build a
+        // fresh config.json instead of hitting the strict no-config error.
+        const config = loadOrInitConfig();
         config.servers[answers.profileName] = {
             type: 'http',
             url: answers.url,
@@ -419,7 +484,9 @@ program
     .command('config')
     .description('Interactively configure your LLM provider and MCP servers')
     .action(async () => {
-    const config = loadConfig();
+    // `loadOrInitConfig` because this command IS the first-run setup
+    // wizard — it must work even when no config.json exists yet.
+    const config = loadOrInitConfig();
     const menu = await inquirer.prompt([
         {
             type: 'list',

package/dist/memory/briefing.d.ts

@@ -10,6 +10,16 @@ export interface BriefingInputs {
     activeSkill?: string;
     /** Cap on injected briefing content per source — guards against runaway payloads eating the context window. */
     maxCharsPerSource?: number;
+    /**
+     * Set by the caller when a `goal-anchor` system message is already
+     * carrying the current objective. The briefing skips `memory_task_state`
+     * in that case to avoid double-injecting the "what we're doing right
+     * now" context — the goal-anchor is the authoritative owner. When
+     * there is no active goal (pre-goal exploration, after `/goal pause`,
+     * silent child agents) the task-state surface still fires so handover
+     * notes and prior blockers stay visible. Part of 0.3.6 item 9d.
+     */
+    hasActiveGoal?: boolean;
 }
 export interface RecalledRecord {
     recordId: string;