@kinqs/brainrouter-cli 0.3.6 → 0.3.8

package/dist/cli/ink/runChat.js

@@ -0,0 +1,682 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EventEmitter } from 'node:events';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { resolveTheme } from '../theme.js';
+import { buildBannerInputs, renderBanner } from '../banner.js';
+import { isKnownSegment, renderSegments } from '../statusline.js';
+import { readPreferences } from '../../state/preferencesStore.js';
+import { listSessions } from '../../orchestration/orchestrator.js';
+import { expandMentions } from '../../memory/mentions.js';
+import { addGoalTokens, buildGoalContinuationPrompt, formatBudget, goalHasBudgetLeft, readGoal, tickGoalIteration, usageLimitGoal, } from '../../state/goalStore.js';
+import { setActiveReadline } from '../cliPrompt.js';
+import { ChatApp } from './ChatApp.js';
+import { handleSlashCommand, lookupSlashDescription, SLASH_COMMANDS } from '../repl.js';
+import { startScheduleTicker } from '../../runtime/scheduleTicker.js';
+import { formatToolCall } from './toolFormat.js';
+import { setAmbientChat } from './ambientChat.js';
+import { captureConsoleOutput } from './consoleCapture.js';
+import { renderWithResizeClear } from './renderWithResizeClear.js';
+export async function runChat(opts) {
+    const { agent, mcpClient, config } = opts;
+    const theme = resolveTheme(agent.workspaceRoot);
+    const banner = renderBanner(buildBannerInputs(config, agent, mcpClient), theme);
+    const offlineWarning = mcpClient.isConnected()
+        ? undefined
+        : theme.warning('  ⚠️  OFFLINE MODE — MCP server unreachable. Memory recall, skills, and capture are disabled.')
+            + '\n' + theme.muted('       Local tools (file edits, shell, web fetch, spawn_agent) still work.')
+            + '\n' + theme.muted('       Start the MCP server and restart the CLI to restore full functionality.');
+    const hint = theme.muted('  Type ') + theme.info('/help')
+        + theme.muted(' for commands · ') + theme.info('/where')
+        + theme.muted(' for current state · just start typing your prompt.');
+    // Build the slash command catalog from the registry in repl.ts so the
+    // inline palette suggestions match the readline REPL's autocomplete list.
+    const slashCatalog = SLASH_COMMANDS.map((cmd) => ({
+        cmd,
+        description: lookupSlashDescription(cmd),
+    }));
+    // Closure-shared state — equivalent to the readline REPL's local closures
+    // in startREPL. Captured into `onSubmit` / shim listeners so the orchestrator
+    // remains a single owner of the turn lifecycle.
+    let isProcessing = false;
+    let pendingContinuation = false;
+    let idleHintFired = false;
+    let idleHintTimer;
+    let controller;
+    let exited = false;
+    const isQuiet = () => {
+        if (process.env.BRAINROUTER_QUIET === '1')
+            return true;
+        try {
+            return readPreferences(agent.workspaceRoot).quiet === true;
+        }
+        catch {
+            return false;
+        }
+    };
+    // Idle help hint — port of the readline REPL's 30s discoverability nudge.
+    // Single-fire per session; user input cancels.
+    const armIdleHint = () => {
+        if (idleHintFired || !process.stdout.isTTY)
+            return;
+        if (idleHintTimer)
+            clearTimeout(idleHintTimer);
+        idleHintTimer = setTimeout(() => {
+            if (idleHintFired || isProcessing || pendingContinuation || exited)
+                return;
+            idleHintFired = true;
+            controller?.push.notice(`Tip: press ? or /help for commands, /where for current state.`);
+        }, 30_000);
+        if (typeof idleHintTimer.unref === 'function') {
+            idleHintTimer.unref();
+        }
+    };
+    const clearIdleHint = () => {
+        if (idleHintTimer) {
+            clearTimeout(idleHintTimer);
+            idleHintTimer = undefined;
+        }
+    };
+    // Footer refresh — derives model · session · branch from current agent
+    // state and prefs. Re-run after each turn so the bar reflects post-turn
+    // model swaps, branch changes, etc.
+    const refreshFooter = () => {
+        if (!controller)
+            return;
+        const prefs = readPreferences(agent.workspaceRoot);
+        const requested = prefs.statusline.split(',').map((s) => s.trim()).filter(Boolean);
+        const segments = requested.filter(isKnownSegment).filter((segment) => segment !== 'effort');
+        const rendered = renderSegments(segments, {
+            workspaceRoot: agent.workspaceRoot,
+            sessionKey: agent.sessionKey,
+            accessMode: agent.getAccessMode(),
+            model: agent.getModel(),
+            lastTurnUsage: agent.lastTurnUsage,
+            prDetector: () => detectGitHubPR(agent.workspaceRoot),
+        });
+        let branch;
+        try {
+            branch = execSync('git rev-parse --abbrev-ref HEAD', {
+                cwd: agent.workspaceRoot,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).toString().trim();
+        }
+        catch { /* not a git repo */ }
+        controller.setFooter({
+            model: agent.getModel(),
+            session: agent.sessionKey,
+            branch,
+            effort: prefs.effort,
+            accessMode: agent.getAccessMode(),
+            rightExtra: rendered.length > 0 ? rendered.join(' · ') : undefined,
+        });
+        refreshTerminalTitle();
+    };
+    const refreshTerminalTitle = () => {
+        try {
+            const prefs = readPreferences(agent.workspaceRoot);
+            const cfg = prefs.terminalTitle ?? 'model,session';
+            if (cfg.toLowerCase() === 'off')
+                return;
+            const segs = cfg.split(',').map((s) => s.trim()).filter(Boolean);
+            const parts = [];
+            for (const seg of segs) {
+                if (seg === 'model')
+                    parts.push(agent.getModel());
+                else if (seg === 'session')
+                    parts.push(agent.sessionKey.slice(0, 24));
+                else if (seg === 'mode')
+                    parts.push(agent.getAccessMode());
+                else if (seg === 'branch') {
+                    try {
+                        parts.push(execSync('git rev-parse --abbrev-ref HEAD', {
+                            cwd: agent.workspaceRoot,
+                            stdio: ['ignore', 'pipe', 'ignore'],
+                        }).toString().trim());
+                    }
+                    catch { /* not a git repo */ }
+                }
+            }
+            if (parts.length === 0)
+                return;
+            const awaitingCount = (pendingContinuation ? 1 : 0) + getRunningChildCount();
+            const prefix = awaitingCount > 0 ? `(${awaitingCount}) ` : '';
+            process.stdout.write(`\x1b]0;${prefix}brainrouter · ${parts.join(' · ')}\x07`);
+        }
+        catch { /* terminal doesn't support OSC titles */ }
+    };
+    const getRunningChildCount = () => {
+        try {
+            const sessions = listSessions(agent.workspaceRoot);
+            return sessions.filter((s) => s.status === 'pending' || s.status === 'running').length;
+        }
+        catch {
+            return 0;
+        }
+    };
+    // gh-PR detector cache — same 30s TTL as the readline REPL so the
+    // statusline doesn't pay 300ms per prompt redraw.
+    let prCache = null;
+    const PR_CACHE_TTL_MS = 30_000;
+    function detectGitHubPR(cwd) {
+        const now = Date.now();
+        if (prCache && now - prCache.cachedAt < PR_CACHE_TTL_MS)
+            return prCache.value;
+        let value = null;
+        try {
+            const out = execSync('gh pr view --json number,title 2>/dev/null', {
+                cwd,
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 1500,
+            }).toString().trim();
+            if (out) {
+                const parsed = JSON.parse(out);
+                if (typeof parsed.number === 'number')
+                    value = `#${parsed.number}`;
+            }
+        }
+        catch { /* gh missing or no PR */ }
+        prCache = { value, cachedAt: now };
+        return value;
+    }
+    // Shim readline.Interface — satisfies the type required by
+    // `handleSlashCommand` so existing slash handlers (extracted into
+    // cli/commands/*) work unchanged under the Ink REPL. The shim is an
+    // EventEmitter (because readline.Interface extends it) and stubs the
+    // prompt/write/pause/resume surface as no-ops. `close()` exits Ink
+    // gracefully — used by /quit and /exit.
+    //
+    // Limits to be aware of:
+    //   - `question(q, cb)` is implemented but ROUTES through the
+    //     composer-as-input pattern: it temporarily replaces the submit
+    //     handler so the next line submission is delivered to `cb`. Used
+    //     by askYesNo. NOT a replacement for the ask_user_choice mid-turn
+    //     picker — that path will degrade to NoTTYError until we wire a
+    //     dedicated Ink picker into the chat tree (follow-up).
+    //   - `write(text)` injects into the composer (mirrors readline.write).
+    const shim = createReadlineShim({
+        closeChat: () => { exited = true; controller?.exit(); },
+        onWriteToComposer: (text) => controller?.setComposer(text),
+        waitForLine: (cb) => {
+            questionCallback = cb;
+        },
+    });
+    let questionCallback;
+    // Goal continuation. After each turn ends successfully, schedule the
+    // next continuation iff the goal is still active and made progress.
+    // The user's next keystroke cancels the queued continuation.
+    const scheduleGoalContinuation = (afterPrompt, afterAnswer) => {
+        let goalAfter = readGoal(agent.workspaceRoot, agent.sessionKey);
+        if (goalAfter && goalAfter.budget.maxTokens) {
+            const delta = (agent.lastTurnUsage?.promptTokens ?? 0) + (agent.lastTurnUsage?.completionTokens ?? 0);
+            if (delta > 0) {
+                const updated = addGoalTokens(agent.workspaceRoot, agent.sessionKey, delta);
+                if (updated)
+                    goalAfter = updated;
+            }
+            if (goalAfter &&
+                goalAfter.status === 'active' &&
+                typeof goalAfter.budget.maxTokens === 'number' &&
+                (goalAfter.budget.tokensUsed ?? 0) >= goalAfter.budget.maxTokens) {
+                const limited = usageLimitGoal(agent.workspaceRoot, agent.sessionKey, `Token budget reached: ${(goalAfter.budget.tokensUsed ?? 0).toLocaleString()} of ${goalAfter.budget.maxTokens.toLocaleString()} used.`);
+                if (limited)
+                    goalAfter = limited;
+            }
+        }
+        const shouldContinue = !!goalAfter &&
+            goalAfter.status === 'active' &&
+            goalHasBudgetLeft(goalAfter) &&
+            agent.lastTurnToolCalls > 0 &&
+            agent.lastGoalTransition === undefined;
+        if (goalAfter && goalAfter.status === 'complete') {
+            controller?.push.notice(`🎯 Goal achieved — ${goalAfter.blockedReason ?? 'evidence on record.'}`, 'info');
+        }
+        else if (goalAfter && goalAfter.status === 'blocked') {
+            controller?.push.notice(`🚧 Goal blocked: ${goalAfter.blockedReason ?? '(no reason)'}`, 'warn');
+            controller?.push.notice(`Resolve the blocker, then /goal resume to continue.`, 'info');
+        }
+        else if (goalAfter && goalAfter.status === 'usage_limited') {
+            controller?.push.notice(`⏸ Goal hit usage limit: ${goalAfter.blockedReason ?? 'budget exhausted'}.`, 'warn');
+            controller?.push.notice(`Raise the cap with /goal budget <n> or /goal tokens <n>, then /goal resume.`, 'info');
+        }
+        else if (goalAfter && goalAfter.status === 'active' && !goalHasBudgetLeft(goalAfter)) {
+            const reason = `Iteration budget exhausted (${goalAfter.budget.iterationsUsed}/${formatBudget(goalAfter.budget.maxIterations)}).`;
+            const limited = usageLimitGoal(agent.workspaceRoot, agent.sessionKey, reason);
+            controller?.push.notice(`⏸ ${reason} Extend with /goal budget <n> and /goal resume, mark /goal complete, or /goal clear.`, 'warn');
+            if (limited)
+                goalAfter = limited;
+        }
+        else if (goalAfter && goalAfter.status === 'active' && agent.lastTurnToolCalls === 0) {
+            controller?.push.notice(`(goal continuation suppressed: last turn made no tool calls — anti-spin)`, 'info');
+        }
+        if (shouldContinue && goalAfter) {
+            pendingContinuation = true;
+            const next = goalAfter.budget.iterationsUsed + 1;
+            controller?.push.notice(`(goal continuation queued — iteration ${next}/${formatBudget(goalAfter.budget.maxIterations)}; type anything to cancel)`, 'info');
+            const followUp = buildGoalContinuationPrompt(goalAfter, afterPrompt, afterAnswer);
+            setImmediate(() => {
+                if (!pendingContinuation || isProcessing)
+                    return;
+                pendingContinuation = false;
+                tickGoalIteration(agent.workspaceRoot, agent.sessionKey);
+                void runChatTurn(followUp);
+            });
+        }
+    };
+    // Run a single agent turn through the Ink chat REPL. Mirrors
+    // cli/repl.ts:runAgentTurn but pushes events through the Ink
+    // scrollback controller instead of console.log + ora spinner.
+    const runChatTurn = async (rawInput) => {
+        if (!controller)
+            return;
+        if (isProcessing) {
+            controller.push.notice('A previous turn is still running.');
+            return;
+        }
+        isProcessing = true;
+        clearIdleHint();
+        const { expanded, mentions } = expandMentions(rawInput, agent.workspaceRoot);
+        if (mentions.length > 0 && !isQuiet()) {
+            controller.push.notice(`📎 Attached ${mentions.length} file${mentions.length === 1 ? '' : 's'}: ${mentions.map((m) => m.token).join(', ')}`);
+        }
+        const startedAt = Date.now();
+        controller.push.setPhase('turn-running');
+        controller.push.setStatus('Agent starting...');
+        let parentDone = false;
+        const tickStatus = (status) => {
+            if (parentDone)
+                return;
+            const elapsed = Math.floor((Date.now() - startedAt) / 1000);
+            const u = agent.lastTurnUsage;
+            const tokens = u.calls > 0 ? `  ${u.promptTokens.toLocaleString()}↑ ${u.completionTokens.toLocaleString()}↓` : '';
+            // When children are alive — typically because the parent is in a
+            // wait_agent / wait_agents / R1 guardrail auto-drain — append a
+            // compact "running children" row so the parent never looks frozen.
+            const childrenRow = runningChildren.size > 0 ? `  · ${formatRunningChildrenRow()}` : '';
+            controller.push.setStatus(`${status}  ${elapsed}s${tokens}${childrenRow}`);
+        };
+        // Per-tool start time + args — agent.runTurn fires onToolStart with
+        // full args but onToolEnd only sees name + result, so we stash the
+        // args here so the end-of-call scrollback row can render the
+        // formatted call (`Read(src/foo.ts)`) instead of just the bare name.
+        // The map key is the tool name; we treat parallel same-name calls
+        // as overlapping which is fine for the duration display (the older
+        // start time wins, slightly under-counting concurrent invocations).
+        const toolStartTimes = new Map();
+        const toolArgsSnapshot = new Map();
+        // Stash child tool args between onChildToolStart and onChildToolEnd so the
+        // end row can render `Read(foo.ts)` instead of just `read_file`. Keyed by
+        // `${childId}:${tool}` so two children running the same tool don't collide.
+        const childToolArgs = new Map();
+        // Currently-running children for the compact "running children" status row.
+        // Maintained from onChildToolStart / onChildComplete (the only signals the
+        // REPL gets about child lifecycle that don't require re-reading sessions).
+        const runningChildren = new Map();
+        const formatRunningChildrenRow = () => {
+            if (runningChildren.size === 0)
+                return '';
+            const parts = [];
+            for (const [id, info] of runningChildren) {
+                const idShort = id.slice(0, 8);
+                const tail = info.tool ? ` ${info.tool}` : '';
+                parts.push(`${id.startsWith('agent-') ? id.slice(0, 14) : 'agent-' + idShort} (${info.role}${tail})`);
+            }
+            return `running children: ${parts.join(', ')}`;
+        };
+        try {
+            const answer = await agent.runTurn(expanded, {
+                onStatusUpdate: tickStatus,
+                onToolStart: (name, args) => {
+                    // Surface the in-flight tool via the spinner status line — the
+                    // scrollback entry is pushed at onToolEnd so each tool call is
+                    // a single block (header + result), not two rows.
+                    toolStartTimes.set(name, Date.now());
+                    toolArgsSnapshot.set(name, args ?? {});
+                    if (!isQuiet()) {
+                        controller.push.setStatus(formatToolCall(name, args));
+                    }
+                },
+                onToolEnd: (name, result) => {
+                    // Quiet mode hides successes (the prose response covers them).
+                    if (isQuiet() && result.success) {
+                        tickStatus('Thinking');
+                        return;
+                    }
+                    const startedAt = toolStartTimes.get(name);
+                    const args = toolArgsSnapshot.get(name);
+                    toolStartTimes.delete(name);
+                    toolArgsSnapshot.delete(name);
+                    const durationMs = startedAt ? Date.now() - startedAt : undefined;
+                    const header = formatToolCall(name, args);
+                    controller.push.tool(header, result.success, {
+                        preview: !isQuiet() ? result.preview : undefined,
+                        durationMs,
+                    });
+                    tickStatus('Thinking');
+                },
+                onPlanUpdate: (items, explanation) => {
+                    // Explanation rides on the plan entry itself (renders as a dim-italic
+                    // line above the checklist) rather than as a separate memory event,
+                    // so the explanation visually anchors to the plan it describes.
+                    controller.push.plan(items, explanation);
+                    tickStatus('Thinking');
+                },
+                onChildToolStart: (event) => {
+                    const key = `${event.childId}:${event.tool}`;
+                    childToolArgs.set(key, event.args ?? {});
+                    const prior = runningChildren.get(event.childId);
+                    runningChildren.set(event.childId, { role: event.role, tool: event.tool });
+                    // Live status row so the user sees WHICH children are alive while
+                    // the parent is waiting. Quiet-mode rule: still surface long-running
+                    // child state — it's the user's only signal that the parent isn't stuck.
+                    const row = formatRunningChildrenRow();
+                    if (row)
+                        controller.push.setStatus(row);
+                    // First-tool notice: emit a one-line "child started" row so the
+                    // scrollback shows the child began before any tool finishes. Quiet
+                    // mode suppresses this; the paired end row below is enough.
+                    if (!prior && !isQuiet()) {
+                        const idShort = event.childId.slice(0, 8);
+                        const idLabel = event.childId.startsWith('agent-') ? event.childId.slice(0, 14) : 'agent-' + idShort;
+                        controller.push.notice(`▶ ${idLabel} (${event.role}) running...`, 'info');
+                    }
+                },
+                onChildToolEnd: (event) => {
+                    const key = `${event.childId}:${event.tool}`;
+                    const args = childToolArgs.get(key);
+                    childToolArgs.delete(key);
+                    // Tool finished — null out the tool field so the running-children
+                    // status row stops showing a stale tool name.
+                    const cur = runningChildren.get(event.childId);
+                    if (cur)
+                        runningChildren.set(event.childId, { role: cur.role, tool: undefined });
+                    const idShort = event.childId.slice(0, 8);
+                    const idLabel = event.childId.startsWith('agent-') ? event.childId.slice(0, 14) : 'agent-' + idShort;
+                    const inner = formatToolCall(event.tool, args);
+                    const header = `[${idLabel} ${event.role}] ${inner}`;
+                    // Quiet-mode rule (carried from R1): hide noisy success previews,
+                    // but still print the paired row so the user has a visible signal
+                    // that the child made progress.
+                    controller.push.tool(header, event.ok, {
+                        preview: !isQuiet() ? event.preview : undefined,
+                        durationMs: event.durationMs,
+                    });
+                    tickStatus('Thinking');
+                },
+                onChildComplete: (event) => {
+                    runningChildren.delete(event.childId);
+                    const ok = event.status === 'completed';
+                    const head = ok
+                        ? `🏁 Agent ${event.childId} (${event.role}) completed`
+                        : `💥 Agent ${event.childId} (${event.role}) failed`;
+                    const tail = ok && event.preview
+                        ? ` — ${event.preview}`
+                        : event.error ? ` — ${event.error}` : '';
+                    controller.push.notice(head + tail, ok ? 'info' : 'error');
+                    tickStatus('Thinking');
+                },
+                onMemoryEvent: (event) => {
+                    if (isQuiet() && event.kind !== 'contradiction')
+                        return;
+                    let line;
+                    let level = 'info';
+                    if (event.kind === 'briefing') {
+                        const src = event.sources.length > 0 ? event.sources.join(', ') : '(none)';
+                        line = `🧠 Briefing: ${event.recordCount} record${event.recordCount === 1 ? '' : 's'} from ${src}`;
+                    }
+                    else if (event.kind === 'capture') {
+                        const sensory = event.sensoryRecorded ?? event.messageCount;
+                        const extracted = event.extractedCount;
+                        const triggered = event.extractionTriggered;
+                        const sk = event.sessionKey.slice(0, 12);
+                        if (event.extractionWarning) {
+                            line = `💾 Captured ${sensory} sensory msg(s) in ${sk}… — ⚠️ ${event.extractionWarning}`;
+                            level = 'warn';
+                        }
+                        else if (triggered && typeof extracted === 'number') {
+                            line = extracted > 0
+                                ? `💾 Captured ${sensory} msg(s) → ${extracted} cognitive record(s) extracted (${sk}…)`
+                                : `💾 Captured ${sensory} msg(s) → no new memories worth promoting (${sk}…)`;
+                        }
+                        else if (triggered === false) {
+                            line = `💾 Captured ${sensory} msg(s) → sensory buffer (${sk}…)`;
+                        }
+                        else {
+                            line = `💾 Captured ${sensory} msg(s) → memory (${sk}…)`;
+                        }
+                    }
+                    else if (event.kind === 'citation' && event.recordIds.length > 0) {
+                        line = `📌 Reinforced ${event.recordIds.length} record${event.recordIds.length === 1 ? '' : 's'}: ${event.recordIds.slice(0, 3).join(', ')}${event.recordIds.length > 3 ? '…' : ''}`;
+                    }
+                    else if (event.kind === 'contradiction') {
+                        line = `⚠️ Memory contradiction: ${event.warning.slice(0, 140)}`;
+                        level = 'warn';
+                    }
+                    if (line)
+                        controller.push.memory(level, line);
+                    tickStatus('Thinking');
+                },
+            });
+            parentDone = true;
+            const elapsed = Date.now() - startedAt;
+            const u = agent.lastTurnUsage;
+            // Pass the raw answer to ChatApp; ChatApp's ScrollbackRow renders
+            // it through marked-terminal unless `raw: true` is set. Honors the
+            // user's rawScrollback preference exactly like the readline path.
+            const prefsForRender = readPreferences(agent.workspaceRoot);
+            controller.push.assistant(answer, {
+                raw: prefsForRender.rawScrollback === true,
+                durationMs: elapsed,
+                tokensIn: u.promptTokens,
+                tokensOut: u.completionTokens,
+                calls: u.calls,
+            });
+            const warning = agent.takeContradictionWarning();
+            if (warning) {
+                controller.push.memory('warn', `Memory: ${warning}`);
+                controller.push.memory('info', `Use /memory or /briefing to investigate, /forget <id> to archive obsolete records.`);
+            }
+            // Goal continuation lives at the bottom of the success path so a
+            // failed turn doesn't trigger it (we don't want auto-retry loops).
+            scheduleGoalContinuation(rawInput, answer);
+        }
+        catch (err) {
+            parentDone = true;
+            controller.push.notice(`✗ Execution failed: ${err?.message ?? err}`, 'error');
+        }
+        finally {
+            isProcessing = false;
+            controller.push.setPhase('idle');
+            controller.push.setStatus('');
+            agent.activeSkill = undefined;
+            agent.refreshSystemPrompt();
+            refreshFooter();
+            armIdleHint();
+        }
+    };
+    // Background `/schedule` ticker. Single in-process timer; fires due
+    // cron/one-shot jobs by re-injecting their slash command through the
+    // same dispatcher the user uses. Filtered by sessionKey so a tick
+    // only fires jobs owned by THIS REPL — schedules registered in a
+    // different session sit idle until that session is open. Stops in
+    // the `waitUntilExit` handlers below so /exit and ^C clean up.
+    let scheduleTicker = null;
+    const startTicker = () => {
+        if (scheduleTicker)
+            return;
+        scheduleTicker = startScheduleTicker({
+            workspaceRoot: agent.workspaceRoot,
+            sessionKey: agent.sessionKey,
+            fire: (command, sched) => {
+                if (!controller)
+                    return;
+                if (isProcessing) {
+                    // Catch-up rule: only fire ONCE per missed window. The ticker
+                    // has already advanced nextRun past `now`, so silently
+                    // dropping a busy-session fire is correct — it won't refire
+                    // for the same minute.
+                    controller.push.notice(`(schedule ${sched.id} fired while a turn was in flight — skipped)`, 'warn');
+                    return;
+                }
+                const parts = command.trim().split(/\s+/);
+                const cmd = parts[0].toLowerCase();
+                const args = parts.slice(1);
+                controller.push.notice(`⏰ Schedule ${sched.id} → ${command}`, 'info');
+                void dispatchSlash(cmd, args, shim);
+            },
+            onError: (msg) => controller?.push.notice(`[schedule] ${msg}`, 'warn'),
+        });
+    };
+    // Mount Ink. We DON'T set `patchConsole: false` — Ink's default
+    // (patchConsole enabled) is exactly what we want: legacy slash
+    // commands that still write via chalk + console.log have their
+    // output promoted ABOVE Ink's redraw region instead of clobbering it.
+    return new Promise((resolve) => {
+        const { instance, cleanupResizeClear } = renderWithResizeClear(_jsx(ChatApp, { initialBanner: '\n' + banner, initialOfflineWarning: offlineWarning, initialHint: hint, slashCommands: slashCatalog, promptLabel: `brainrouter[${agent.getAccessMode()}]`, initialAccessMode: agent.getAccessMode(), initialFooter: {
+                model: agent.getModel(),
+                session: agent.sessionKey,
+                effort: readPreferences(agent.workspaceRoot).effort,
+            }, onReady: (ctrl) => {
+                controller = ctrl;
+                // Publish the shim so cliPrompt's askYesNo can find an "active
+                // readline" while the Ink REPL owns stdin. Without this, every
+                // mid-turn yes/no prompt returns its default silently.
+                setActiveReadline(shim);
+                // Publish the controller so runPicker / runTextField route their
+                // UI through the chat's overlay slot instead of mounting a
+                // second Ink instance (which would race for stdin + terminal
+                // state). See ambientChat.ts for the rationale.
+                setAmbientChat({
+                    showOverlay: ctrl.showOverlay,
+                    clearOverlay: ctrl.clearOverlay,
+                });
+                refreshFooter();
+                armIdleHint();
+                startTicker();
+            }, onAccessModeCycle: () => {
+                const cycle = ['read', 'write', 'shell'];
+                const current = agent.getAccessMode();
+                const next = cycle[(cycle.indexOf(current) + 1) % cycle.length];
+                agent.setAccessMode(next);
+                refreshFooter();
+                return next;
+            }, onSubmit: async (text, push) => {
+                // Any in-flight goal continuation is cancelled by user input,
+                // regardless of whether the input is a slash or a prompt.
+                if (pendingContinuation) {
+                    pendingContinuation = false;
+                    push.notice('(goal continuation cancelled by user input)');
+                }
+                clearIdleHint();
+                // If a slash command's handler had called `rl.question(cb)`,
+                // the very next submission belongs to `cb` — not the dispatcher.
+                if (questionCallback) {
+                    const cb = questionCallback;
+                    questionCallback = undefined;
+                    cb(text);
+                    return;
+                }
+                // Bare `?` → help (mirrors the readline REPL — the idle hint
+                // advertises it, so make it actually work).
+                if (text === '?') {
+                    await dispatchSlash('/help', [], shim);
+                    return;
+                }
+                if (text.startsWith('/')) {
+                    const parts = text.trim().split(/\s+/);
+                    const command = parts[0].toLowerCase();
+                    const args = parts.slice(1);
+                    await dispatchSlash(command, args, shim);
+                    return;
+                }
+                if (isProcessing) {
+                    push.notice('A previous turn is still running. Wait for the prompt before sending another message.');
+                    return;
+                }
+                await runChatTurn(text);
+            } }), { exitOnCtrlC: true, patchConsole: true });
+        instance.waitUntilExit().then(async () => {
+            exited = true;
+            setActiveReadline(undefined);
+            setAmbientChat(undefined);
+            cleanupResizeClear();
+            clearIdleHint();
+            try {
+                scheduleTicker?.stop();
+            }
+            catch { /* noop */ }
+            scheduleTicker = null;
+            try {
+                await mcpClient.close();
+            }
+            catch { /* already closed */ }
+            // Goodbye line is intentionally printed AFTER Ink unmounts so it
+            // doesn't get caught inside the redraw region.
+            process.stdout.write(chalk.bold.hex('#CC9166')('Goodbye!\n'));
+            resolve();
+        }).catch(async () => {
+            exited = true;
+            setActiveReadline(undefined);
+            setAmbientChat(undefined);
+            cleanupResizeClear();
+            clearIdleHint();
+            try {
+                scheduleTicker?.stop();
+            }
+            catch { /* noop */ }
+            scheduleTicker = null;
+            try {
+                await mcpClient.close();
+            }
+            catch { /* already closed */ }
+            resolve();
+        });
+    });
+    async function dispatchSlash(command, args, rl) {
+        if (!controller)
+            return;
+        try {
+            const captured = await captureConsoleOutput(() => handleSlashCommand(command, args, agent, mcpClient, config, rl, {
+                refreshPromptForMode: refreshFooter,
+                replaceBanner: (text) => controller?.replaceBanner(text),
+                isProcessing: () => isProcessing,
+                runAgentTurn: (prompt) => { void runChatTurn(prompt); },
+                runAgentTurnAsync: (prompt) => runChatTurn(prompt),
+            }));
+            const output = captured.output.trimEnd();
+            if (output) {
+                controller.push.raw(output);
+            }
+        }
+        catch (err) {
+            controller.push.notice(`Slash command "${command}" failed: ${err?.message ?? err}`, 'error');
+        }
+        finally {
+            // Pull any preferences / model / branch / effort changes the
+            // command made (e.g. /effort, /model, /theme, /statusline) so
+            // the footer reflects them immediately rather than waiting for
+            // the next chat turn to refresh.
+            refreshFooter();
+        }
+    }
+}
+function createReadlineShim(hooks) {
+    const emitter = new EventEmitter();
+    const shim = emitter;
+    shim.close = () => { hooks.closeChat(); };
+    shim.prompt = (_preserveCursor) => { };
+    shim.pause = () => shim;
+    shim.resume = () => shim;
+    shim.write = (text) => { hooks.onWriteToComposer(text); };
+    shim.setPrompt = (_text) => { };
+    // Promise-shaped `question` for askYesNo: print the prompt text via
+    // console.log (Ink's patchConsole bubbles it above the redraw region)
+    // and stash the callback for the next submission.
+    shim.question = (q, cb) => {
+        process.stdout.write(q);
+        hooks.waitForLine(cb);
+    };
+    shim.line = '';
+    shim.cursor = 0;
+    return shim;
+}