@kinqs/brainrouter-cli 0.3.5 → 0.3.6

package/dist/cli/spinner.d.ts

@@ -0,0 +1,34 @@
+import { type Options, type Ora } from 'ora';
+/**
+ * Project-wide spinner factory. **Never** use `ora()` directly — always go
+ * through this.
+ *
+ * `ora`'s default is `discardStdin: true`, which on every `.start()` invokes
+ * the `stdin-discarder` dep (`process.stdin.setRawMode(true)` + add a noop
+ * `data` listener + `process.stdin.resume()`), and on every `.stop()` /
+ * `.succeed()` / `.fail()` does the inverse (`off` listener +
+ * `process.stdin.pause()` + `process.stdin.setRawMode(false)`).
+ *
+ * The pause + raw-mode-false on stop is the load-bearing problem: the
+ * brainrouter REPL's readline interface inherits that state, so after a
+ * slash command that used a spinner (`/working`, `/handover`, `/explain`,
+ * `/diagnostics`, `/forget`, `/persona`, `/skill-hints`, etc.) the prompt
+ * looks alive but stdin is paused + cooked. Symptoms: Backspace echoes
+ * `^?`, arrow keys echo `^[[A`, ENTER doesn't submit. Same class of bug
+ * as the latent setRawMode(false) PR #30 removed at REPL startup, just
+ * triggered per-spinner-stop instead of per-process-start.
+ *
+ * The agent turn (`runAgentTurn`) hides the symptom for most paths because
+ * it brackets the whole turn in `rl.pause()` / `rl.resume()` — `rl.resume()`
+ * re-engages raw mode via readline's internal `input._setRawMode(true)`.
+ * Slash commands run outside that bracket, so the breakage surfaces there.
+ * `ask_user_choice` pickers also show it after the picker cleanup hands
+ * back to subsequent ora events that pause stdin again before the parent
+ * turn's resume runs.
+ *
+ * `discardStdin: false` skips the entire stdin-discarder dance. The spinner
+ * still renders identically; only the side effects are gone. No readline
+ * plumbing changes, no `rl.pause()` / `rl.resume()` bracket needed at the
+ * call sites — this is the right place to fix it.
+ */
+export declare function spinner(text: string, options?: Omit<Options, 'text' | 'discardStdin'>): Ora;

package/dist/cli/spinner.js

@@ -0,0 +1,36 @@
+import ora from 'ora';
+/**
+ * Project-wide spinner factory. **Never** use `ora()` directly — always go
+ * through this.
+ *
+ * `ora`'s default is `discardStdin: true`, which on every `.start()` invokes
+ * the `stdin-discarder` dep (`process.stdin.setRawMode(true)` + add a noop
+ * `data` listener + `process.stdin.resume()`), and on every `.stop()` /
+ * `.succeed()` / `.fail()` does the inverse (`off` listener +
+ * `process.stdin.pause()` + `process.stdin.setRawMode(false)`).
+ *
+ * The pause + raw-mode-false on stop is the load-bearing problem: the
+ * brainrouter REPL's readline interface inherits that state, so after a
+ * slash command that used a spinner (`/working`, `/handover`, `/explain`,
+ * `/diagnostics`, `/forget`, `/persona`, `/skill-hints`, etc.) the prompt
+ * looks alive but stdin is paused + cooked. Symptoms: Backspace echoes
+ * `^?`, arrow keys echo `^[[A`, ENTER doesn't submit. Same class of bug
+ * as the latent setRawMode(false) PR #30 removed at REPL startup, just
+ * triggered per-spinner-stop instead of per-process-start.
+ *
+ * The agent turn (`runAgentTurn`) hides the symptom for most paths because
+ * it brackets the whole turn in `rl.pause()` / `rl.resume()` — `rl.resume()`
+ * re-engages raw mode via readline's internal `input._setRawMode(true)`.
+ * Slash commands run outside that bracket, so the breakage surfaces there.
+ * `ask_user_choice` pickers also show it after the picker cleanup hands
+ * back to subsequent ora events that pause stdin again before the parent
+ * turn's resume runs.
+ *
+ * `discardStdin: false` skips the entire stdin-discarder dance. The spinner
+ * still renders identically; only the side effects are gone. No readline
+ * plumbing changes, no `rl.pause()` / `rl.resume()` bracket needed at the
+ * call sites — this is the right place to fix it.
+ */
+export function spinner(text, options = {}) {
+    return ora({ ...options, text, discardStdin: false });
+}

package/dist/cli/statusline.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Status-line segment renderers. Each segment is a pure-ish function from
+ * (Inputs) → string|undefined; the prompt builder joins the non-empty
+ * results with " · " and wraps them in the access-mode color.
+ *
+ * Why split this out from repl.ts? The 0.3.6 redesign adds workflow / goal /
+ * plan / pr segments, so the inline switch in repl.ts was about to grow
+ * past readable. Putting one function per segment keeps each rule small
+ * AND makes the segment set unit-testable without booting a REPL.
+ *
+ * Segments deliberately stay narrow:
+ *   - `mode`     — access mode (read/write/shell)
+ *   - `exec`     — execution mode (fast); hidden when planning (the default)
+ *   - `effort`   — reasoning depth (low / high); hidden when medium (the default)
+ *   - `model`    — chat-LLM model name
+ *   - `tokens`   — last turn's input/output tokens, only when calls > 0
+ *   - `session`  — first ~22 chars of the sessionKey
+ *   - `branch`   — git branch, only when in a git repo
+ *   - `dirty`    — `*` when the working tree has uncommitted changes
+ *   - `pr`       — github PR identifier (cached upstream of this helper)
+ *   - `workflow` — current workflow slug if any
+ *   - `goal`     — goal status + budget usage if any
+ *   - `plan`     — completed/total plan items if a plan exists
+ *
+ * Note on segment naming: `mode` is the existing access-mode segment
+ * (read/write/shell), kept under that name so user preference files like
+ * `statusline: "mode,model"` keep working. The new execution-mode segment
+ * is `exec` (fast / hidden-when-planning) to avoid colliding with `mode`
+ * — `/mode` the command and `mode` the segment are deliberately decoupled.
+ */
+export declare const SEGMENT_NAMES: readonly ["mode", "exec", "effort", "model", "tokens", "session", "branch", "dirty", "pr", "workflow", "goal", "plan", "brain"];
+export type SegmentName = typeof SEGMENT_NAMES[number];
+export interface SegmentInputs {
+    workspaceRoot: string;
+    sessionKey: string;
+    accessMode: string;
+    model: string;
+    lastTurnUsage: {
+        calls: number;
+        promptTokens: number;
+        completionTokens: number;
+    };
+    /** Optional GitHub PR identifier (e.g. "#42"). REPL caches the gh shell-out, so this is precomputed. */
+    prDetector?: () => string | null;
+    /**
+     * 10c: brain-status detector (renders `brain` segment). REPL wires this
+     * up by closing over the live `mcpClient.isConnected()` +
+     * `mcpClient.getIdentity()` calls. Returns `'online'` / `'offline'` /
+     * `'degraded'` when the active MCP is the BrainRouter brain, and
+     * `undefined` otherwise so the segment hides for third-party MCPs.
+     */
+    brainStatus?: () => 'online' | 'offline' | 'degraded' | undefined;
+}
+export declare function isKnownSegment(name: string): name is SegmentName;
+/**
+ * Render a single segment. Returns undefined when the segment has nothing
+ * worth showing (e.g. `tokens` before the first turn, `branch` outside a
+ * git repo, `goal` with no goal set). Callers should filter undefined out
+ * before joining with separators.
+ */
+export declare function renderSegment(name: SegmentName, inputs: SegmentInputs): string | undefined;
+/**
+ * Render an ordered list of segments, dropping the ones that have nothing
+ * to show. Returns a flat array of strings the caller joins with its own
+ * separator + color treatment.
+ */
+export declare function renderSegments(names: readonly SegmentName[], inputs: SegmentInputs): string[];

package/dist/cli/statusline.js

@@ -0,0 +1,204 @@
+import { execSync } from 'node:child_process';
+import { formatBudget, readGoal } from '../state/goalStore.js';
+import { readPlan } from '../state/taskStore.js';
+import { getCurrentWorkflow } from '../state/workflowArtifacts.js';
+import { readPreferences, resolveEffort } from '../state/preferencesStore.js';
+/**
+ * Status-line segment renderers. Each segment is a pure-ish function from
+ * (Inputs) → string|undefined; the prompt builder joins the non-empty
+ * results with " · " and wraps them in the access-mode color.
+ *
+ * Why split this out from repl.ts? The 0.3.6 redesign adds workflow / goal /
+ * plan / pr segments, so the inline switch in repl.ts was about to grow
+ * past readable. Putting one function per segment keeps each rule small
+ * AND makes the segment set unit-testable without booting a REPL.
+ *
+ * Segments deliberately stay narrow:
+ *   - `mode`     — access mode (read/write/shell)
+ *   - `exec`     — execution mode (fast); hidden when planning (the default)
+ *   - `effort`   — reasoning depth (low / high); hidden when medium (the default)
+ *   - `model`    — chat-LLM model name
+ *   - `tokens`   — last turn's input/output tokens, only when calls > 0
+ *   - `session`  — first ~22 chars of the sessionKey
+ *   - `branch`   — git branch, only when in a git repo
+ *   - `dirty`    — `*` when the working tree has uncommitted changes
+ *   - `pr`       — github PR identifier (cached upstream of this helper)
+ *   - `workflow` — current workflow slug if any
+ *   - `goal`     — goal status + budget usage if any
+ *   - `plan`     — completed/total plan items if a plan exists
+ *
+ * Note on segment naming: `mode` is the existing access-mode segment
+ * (read/write/shell), kept under that name so user preference files like
+ * `statusline: "mode,model"` keep working. The new execution-mode segment
+ * is `exec` (fast / hidden-when-planning) to avoid colliding with `mode`
+ * — `/mode` the command and `mode` the segment are deliberately decoupled.
+ */
+export const SEGMENT_NAMES = [
+    'mode',
+    'exec',
+    'effort',
+    'model',
+    'tokens',
+    'session',
+    'branch',
+    'dirty',
+    'pr',
+    'workflow',
+    'goal',
+    'plan',
+    'brain',
+];
+export function isKnownSegment(name) {
+    return SEGMENT_NAMES.includes(name);
+}
+/**
+ * Render a single segment. Returns undefined when the segment has nothing
+ * worth showing (e.g. `tokens` before the first turn, `branch` outside a
+ * git repo, `goal` with no goal set). Callers should filter undefined out
+ * before joining with separators.
+ */
+export function renderSegment(name, inputs) {
+    switch (name) {
+        case 'mode':
+            return inputs.accessMode;
+        case 'exec': {
+            // Show `fast` only — `planning` is the default, and surfacing it would
+            // add chrome on every prompt for users who never touched /mode.
+            try {
+                const { executionMode } = readPreferences(inputs.workspaceRoot);
+                return executionMode === 'fast' ? 'fast' : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'effort': {
+            // Mirror the `exec` "show only when non-default" rule. `medium` is the
+            // default and would just add chrome on every prompt for users who never
+            // touched /effort.
+            try {
+                const resolved = resolveEffort(inputs.workspaceRoot);
+                if (resolved.effort === 'medium')
+                    return undefined;
+                return `effort:${resolved.effort}`;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'model':
+            return inputs.model;
+        case 'tokens': {
+            const u = inputs.lastTurnUsage;
+            if (u.calls <= 0)
+                return undefined;
+            return `${u.promptTokens}↑${u.completionTokens}↓`;
+        }
+        case 'session': {
+            const k = inputs.sessionKey;
+            return k.length > 22 ? `${k.slice(0, 22)}…` : k;
+        }
+        case 'branch':
+        case 'dirty': {
+            try {
+                const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+                    cwd: inputs.workspaceRoot,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }).toString().trim();
+                if (name === 'branch')
+                    return branch;
+                // dirty: only emit "*" when changes are present; quiet otherwise.
+                const dirty = execSync('git status --porcelain', {
+                    cwd: inputs.workspaceRoot,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }).toString().trim() !== '';
+                return dirty ? '*' : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'pr':
+            return inputs.prDetector?.() ?? undefined;
+        case 'workflow': {
+            // The workflow segment is a pure navigation indicator: "which
+            // workflow folder is this session writing artifacts to right now?"
+            // Post-goal/workflow-decoupling (0.3.6) it does NOT carry a goal
+            // status suffix — goals live at session scope (the `goal` segment),
+            // workflows live at folder scope. Two orthogonal concerns.
+            try {
+                const slug = getCurrentWorkflow(inputs.workspaceRoot, inputs.sessionKey);
+                if (!slug)
+                    return undefined;
+                return `wf:${slug}`;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'goal': {
+            try {
+                const goal = readGoal(inputs.workspaceRoot, inputs.sessionKey);
+                if (!goal)
+                    return undefined;
+                const cap = formatBudget(goal.budget.maxIterations);
+                const used = goal.budget.iterationsUsed;
+                const statusLabel = goal.status === 'usage_limited' ? 'limited' : goal.status;
+                // Active goals get the iteration ratio; terminal states stay terse.
+                if (goal.status === 'active')
+                    return `goal:${statusLabel} ${used}/${cap}`;
+                return `goal:${statusLabel}`;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'plan': {
+            try {
+                const plan = readPlan(inputs.workspaceRoot, inputs.sessionKey);
+                if (!plan.items.length)
+                    return undefined;
+                const done = plan.items.filter((i) => i.status === 'completed').length;
+                return `plan:${done}/${plan.items.length}`;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'brain': {
+            // 10c: only render when the active MCP is identified as BrainRouter
+            // AND its state is non-default. The `brainStatus` detector returns
+            // `undefined` for third-party MCPs (no brain to surface) and for
+            // BrainRouter-online (default state — hide-when-default mirrors the
+            // `exec` + `effort` pattern). Visible states: `offline` (red signal),
+            // `degraded` (yellow signal — 10d local-only fallback).
+            try {
+                const state = inputs.brainStatus?.();
+                if (!state || state === 'online')
+                    return undefined;
+                if (state === 'offline')
+                    return 'brain:🔴';
+                if (state === 'degraded')
+                    return 'brain:🟡';
+                return undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+    }
+}
+/**
+ * Render an ordered list of segments, dropping the ones that have nothing
+ * to show. Returns a flat array of strings the caller joins with its own
+ * separator + color treatment.
+ */
+export function renderSegments(names, inputs) {
+    const out = [];
+    for (const name of names) {
+        const rendered = renderSegment(name, inputs);
+        if (rendered)
+            out.push(rendered);
+    }
+    return out;
+}

package/dist/cli/theme.d.ts

@@ -0,0 +1,79 @@
+import { type ChalkInstance } from 'chalk';
+/**
+ * Consolidated terminal theme tokens.
+ *
+ * Before this module, chalk hex/named colors were sprinkled across every
+ * command file — `chalk.hex('#CC9166')` here, `chalk.green` there. Two
+ * problems with that: (1) the orange that worked beautifully on a black
+ * terminal washed out on a light terminal so users on solarized-light
+ * couldn't read the prompt at all; (2) any "let's tone down the chrome"
+ * pass required grepping the entire CLI for chalk calls.
+ *
+ * The fix is a single source of truth. Every visible surface that needs
+ * color reaches for a SEMANTIC token (primary, success, danger, …) instead
+ * of a raw chalk call. Three palettes ship in-tree:
+ *
+ *   - `dark`  — original Midnight Ledger / Obsidian Surface (matches what
+ *               the CLI has rendered since 0.3.x). Default.
+ *   - `light` — darker accents + bolder weights so the palette stays
+ *               legible on white terminals (solarized-light, GitHub light,
+ *               Apple Terminal "Basic").
+ *   - `mono`  — pure identity functions; no ANSI color, just text. For
+ *               screenshot grabs, CI logs, and pipe-to-less.
+ *
+ * Selection order: `BRAINROUTER_THEME` env var > workspace preferences
+ * (`preferences.theme`) > `dark`. `auto` falls back to `dark` for now —
+ * autodetecting light terminals from TTY hints is unreliable enough that
+ * we leave it to the user to be explicit.
+ *
+ * Inspired by DeepSeek-TUI's `palette.rs` (see openSrc/DeepSeek-TUI/crates/tui/src/palette.rs),
+ * which centralizes its terminal color tokens for the same reason.
+ */
+export type ThemeMode = 'dark' | 'light' | 'mono';
+export interface Theme {
+    readonly mode: ThemeMode;
+    /** Brand accent — used for the banner header, "brainrouter>" prompt, key callouts. */
+    readonly primary: ChalkInstance;
+    /** Secondary accent — supporting brand color (e.g. agent role tags). */
+    readonly secondary: ChalkInstance;
+    /** Successful operation (✓ tool completed, ✔ saved). */
+    readonly success: ChalkInstance;
+    /** Recoverable warning (offline mode, missing config). */
+    readonly warning: ChalkInstance;
+    /** Failure or destructive action (✗ tool failed, dangerous shell). */
+    readonly danger: ChalkInstance;
+    /** Neutral informational hint (cyan-ish in the dark palette). */
+    readonly info: ChalkInstance;
+    /** De-emphasized body text — most chrome lives here. */
+    readonly muted: ChalkInstance;
+    /** Maximally de-emphasized — borders, separators, "less important than muted". */
+    readonly dim: ChalkInstance;
+    /** Bold heading text (banner title, /help category headers). */
+    readonly heading: ChalkInstance;
+    /** Identity — no styling. Used for verbatim payloads where ANSI would corrupt copy/paste. */
+    readonly plain: ChalkInstance;
+}
+export declare function buildTheme(mode: ThemeMode): Theme;
+/**
+ * Resolve the active theme using env-var > preference > default precedence.
+ * Pass `workspaceRoot` to honor a per-workspace `/theme` setting; omit to
+ * resolve from env only (useful in test helpers where preferences storage
+ * might not be initialized).
+ */
+export declare function resolveTheme(workspaceRoot?: string): Theme;
+/**
+ * Box-drawing characters for the startup banner and /where view. Centralized
+ * so a future ASCII-only fallback (for terminals that mangle UTF-8 box chars)
+ * is one switch instead of a sweep through render code.
+ */
+export declare const BOX: {
+    readonly topLeft: "╭";
+    readonly topRight: "╮";
+    readonly bottomLeft: "╰";
+    readonly bottomRight: "╯";
+    readonly horizontal: "─";
+    readonly vertical: "│";
+    readonly midLeft: "├";
+    readonly midRight: "┤";
+    readonly cross: "┼";
+};

package/dist/cli/theme.js

@@ -0,0 +1,106 @@
+import chalk from 'chalk';
+import { readPreferences } from '../state/preferencesStore.js';
+const identity = ((s) => s);
+function buildDark() {
+    return {
+        mode: 'dark',
+        primary: chalk.hex('#CC9166'),
+        secondary: chalk.magenta,
+        success: chalk.green,
+        warning: chalk.yellow,
+        danger: chalk.red,
+        info: chalk.cyan,
+        muted: chalk.gray,
+        dim: chalk.hex('#666666'),
+        heading: chalk.bold.hex('#CC9166'),
+        plain: identity,
+    };
+}
+function buildLight() {
+    return {
+        mode: 'light',
+        // Saturated orange-brown — still readable on white because chalk emits
+        // a TrueColor sequence the terminal renders as-is.
+        primary: chalk.hex('#A24E1F'),
+        secondary: chalk.hex('#7B2CBF'),
+        success: chalk.hex('#0F7B3E'),
+        warning: chalk.hex('#8A6300'),
+        danger: chalk.hex('#A4161A'),
+        info: chalk.hex('#005F8C'),
+        muted: chalk.hex('#4A4A4A'),
+        dim: chalk.hex('#7A7A7A'),
+        heading: chalk.bold.hex('#A24E1F'),
+        plain: identity,
+    };
+}
+function buildMono() {
+    return {
+        mode: 'mono',
+        primary: identity,
+        secondary: identity,
+        success: identity,
+        warning: identity,
+        danger: identity,
+        info: identity,
+        muted: identity,
+        dim: identity,
+        heading: chalk.bold,
+        plain: identity,
+    };
+}
+function normalizeMode(raw) {
+    if (!raw)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === 'dark' || v === 'light' || v === 'mono')
+        return v;
+    if (v === 'auto')
+        return 'dark';
+    return undefined;
+}
+export function buildTheme(mode) {
+    if (mode === 'light')
+        return buildLight();
+    if (mode === 'mono')
+        return buildMono();
+    return buildDark();
+}
+/**
+ * Resolve the active theme using env-var > preference > default precedence.
+ * Pass `workspaceRoot` to honor a per-workspace `/theme` setting; omit to
+ * resolve from env only (useful in test helpers where preferences storage
+ * might not be initialized).
+ */
+export function resolveTheme(workspaceRoot) {
+    const envMode = normalizeMode(process.env.BRAINROUTER_THEME);
+    if (envMode)
+        return buildTheme(envMode);
+    if (workspaceRoot) {
+        try {
+            const prefs = readPreferences(workspaceRoot);
+            const prefMode = normalizeMode(prefs.theme);
+            if (prefMode)
+                return buildTheme(prefMode);
+        }
+        catch {
+            // preferences file unreadable — fall through to default.
+        }
+    }
+    return buildTheme('dark');
+}
+/**
+ * Box-drawing characters for the startup banner and /where view. Centralized
+ * so a future ASCII-only fallback (for terminals that mangle UTF-8 box chars)
+ * is one switch instead of a sweep through render code.
+ */
+export const BOX = {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+    midLeft: '├',
+    midRight: '┤',
+    cross: '┼',
+};

package/dist/cli/whereView.d.ts

@@ -0,0 +1,81 @@
+import type { Goal } from '../state/goalStore.js';
+import { type PlanState } from '../state/taskStore.js';
+import { type WorkflowMeta } from '../state/workflowArtifacts.js';
+import { type ChildSessionRecord } from '../orchestration/orchestrator.js';
+import type { RecalledRecord } from '../memory/briefing.js';
+import { type EffortLevel, type ExecutionMode, type ReviewPolicy } from '../state/preferencesStore.js';
+import { type Theme } from './theme.js';
+/**
+ * `/where` — single-screen "where am I right now" answer.
+ *
+ * Pre-0.3.6 the user had to chain `/workspace`, `/goal status`, `/plan`,
+ * `/workflows`, `/agents`, `/briefing` to reconstruct the same picture. That
+ * was four screen-fuls of output, half of which restated info already in
+ * the others. The `/where` view collapses it into one block, ordered by
+ * "what's most likely to be in your head as a question right now":
+ *
+ *   1. WORKSPACE  — where am I writing files?
+ *   2. WORKFLOW   — which durable folder is bound?
+ *   3. GOAL       — what's the agent contractually trying to do?
+ *   4. PLAN       — what are the in-flight steps?
+ *   5. RECALL     — what memory rows did the briefing surface last turn?
+ *   6. AGENTS     — any spawned children still alive?
+ *
+ * Sections are individually optional — a fresh workspace with no goal, no
+ * plan, no children renders only the WORKSPACE block instead of five empty
+ * boxes. That keeps the view useful at every stage of a session, not just
+ * after you've built up state.
+ *
+ * Pure renderer: input is a snapshot, output is a string. The wrapper in
+ * commands/ui.ts gathers the snapshot at call time. Tests assert against
+ * the rendered output directly.
+ */
+export interface WhereInputs {
+    workspaceRoot: string;
+    sessionKey: string;
+    model: string;
+    mcpProfile: string;
+    mcpTransport: string;
+    mcpOnline: boolean;
+    /**
+     * 10c: identity of the currently-active MCP. When `'brainrouter'`, /where
+     * adds a distinct `brain` line ("brain    🟢 online · cloud") under the
+     * mcp row. When `'third-party'` the line is omitted. `'unknown'` (pre-
+     * detection) is also omitted so we don't show stale state.
+     */
+    mcpIdentity?: 'brainrouter' | 'third-party' | 'unknown';
+    accessMode: string;
+    executionMode: ExecutionMode;
+    reviewPolicy: ReviewPolicy;
+    effort: EffortLevel;
+    effortSource: 'env' | 'preference' | 'default';
+    workflowSlug?: string;
+    workflowMeta?: WorkflowMeta;
+    goal?: Goal;
+    plan: PlanState;
+    recalledRecords: RecalledRecord[];
+    briefingSources: string[];
+    childSessions: ChildSessionRecord[];
+}
+/**
+ * Render the full /where block. Sections are dropped when empty; a fresh
+ * workspace with no goal / plan / children renders just WORKSPACE.
+ */
+export declare function renderWhere(inputs: WhereInputs, theme: Theme): string;
+/**
+ * Gather the snapshot the renderer needs. Single function so the command
+ * handler is two lines (gather + render + print).
+ */
+export declare function gatherWhereInputs(args: {
+    workspaceRoot: string;
+    sessionKey: string;
+    model: string;
+    mcpProfile: string;
+    mcpTransport: string;
+    mcpOnline: boolean;
+    /** 10c: pass through from `mcpClient.getIdentity()` when available. */
+    mcpIdentity?: 'brainrouter' | 'third-party' | 'unknown';
+    accessMode: string;
+    recalledRecords: RecalledRecord[];
+    briefingSources: string[];
+}): WhereInputs;