@kinqs/brainrouter-cli 0.3.7 → 0.3.8

package/dist/cli/commands/releaseNotes.js

@@ -0,0 +1,109 @@
+/**
+ * `/release-notes` slash command — show the changelog for the running CLI version.
+ *
+ *   /release-notes            → current version's notes
+ *   /release-notes <version>  → specific version
+ *   /release-notes list       → every shipped version, sorted descending
+ *
+ * Changelog files ship inside the published package at `changelog/<version>.md`.
+ * The repo-root `brainrouter-changelog/` is copied into `brainrouter-cli/changelog/`
+ * by `prepublishOnly` so users who install via npm see them.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+const MAX_LINES = 200;
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+export async function tryHandleReleaseNotesCommand(ctx, deps = {}) {
+    if (ctx.command !== '/release-notes')
+        return false;
+    const out = runReleaseNotes(ctx.args, deps);
+    console.log(out);
+    return true;
+}
+/**
+ * Pure handler — returns the rendered string. Split from `tryHandle*` so unit
+ * tests can assert on the output without capturing stdout.
+ */
+export function runReleaseNotes(args, deps = {}) {
+    const dir = deps.changelogDir ?? defaultChangelogDir();
+    const sub = (args[0] ?? '').toLowerCase();
+    if (sub === 'list')
+        return renderList(dir);
+    let version;
+    if (sub) {
+        if (!SEMVER_RE.test(sub)) {
+            return chalk.red(`Not a valid semver: "${args[0]}". Try /release-notes list.`);
+        }
+        version = sub;
+    }
+    else {
+        const v = deps.currentVersion ?? readCurrentVersion();
+        if (!v)
+            return chalk.red('Could not determine current CLI version.');
+        version = v;
+    }
+    const filePath = path.join(dir, `${version}.md`);
+    let body;
+    try {
+        body = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return chalk.yellow(`no notes shipped for ${version}`);
+    }
+    return truncate(body, version);
+}
+function renderList(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return chalk.yellow('No bundled changelog directory found.');
+    }
+    const versions = entries
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => f.slice(0, -3))
+        .filter((v) => SEMVER_RE.test(v))
+        .sort(compareSemverDesc);
+    if (versions.length === 0)
+        return chalk.yellow('No changelog versions bundled.');
+    return versions.join('\n');
+}
+function truncate(body, version) {
+    const lines = body.split('\n');
+    if (lines.length <= MAX_LINES)
+        return body;
+    const head = lines.slice(0, MAX_LINES).join('\n');
+    return `${head}\n\n…truncated at ${MAX_LINES} lines. Run \`/release-notes ${version}\` on its own to scroll the full file in a fresh paginator.`;
+}
+function compareSemverDesc(a, b) {
+    const pa = a.split(/[-+]/)[0].split('.').map(Number);
+    const pb = b.split(/[-+]/)[0].split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] !== pb[i])
+            return pb[i] - pa[i];
+    }
+    // Identical core → keep pre-release sort stable by string compare (descending).
+    return b.localeCompare(a);
+}
+// --- Package-root resolution -------------------------------------------------
+/**
+ * `brainrouter-cli/changelog/` — relative to this compiled file. The dist
+ * layout mirrors src, so both `src/cli/commands/releaseNotes.ts` (dev/tsx)
+ * and `dist/cli/commands/releaseNotes.js` (built) resolve to the same root.
+ */
+function defaultChangelogDir() {
+    return fileURLToPath(new URL('../../../changelog', import.meta.url));
+}
+function readCurrentVersion() {
+    try {
+        const pkgPath = fileURLToPath(new URL('../../../package.json', import.meta.url));
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * `/schedule` slash command — recurring cron + one-shot dispatch.
+ *
+ * Recurring  : /schedule cron "*\/15 * * * *" /ci-status
+ * One-shot   : /schedule in 30s /agents
+ *              /schedule at 14:30 /agents
+ * Management : /schedule list
+ *              /schedule remove  <id>
+ *              /schedule disable <id>
+ *              /schedule enable  <id>
+ *
+ * The dispatched command runs in the SAME session that registered the
+ * schedule (we use `agent.sessionKey` as the owner). The ticker filters
+ * by owner — if a different REPL is open against the same workspace,
+ * it won't fire someone else's jobs.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleScheduleCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/schedule.js

@@ -0,0 +1,189 @@
+/**
+ * `/schedule` slash command — recurring cron + one-shot dispatch.
+ *
+ * Recurring  : /schedule cron "*\/15 * * * *" /ci-status
+ * One-shot   : /schedule in 30s /agents
+ *              /schedule at 14:30 /agents
+ * Management : /schedule list
+ *              /schedule remove  <id>
+ *              /schedule disable <id>
+ *              /schedule enable  <id>
+ *
+ * The dispatched command runs in the SAME session that registered the
+ * schedule (we use `agent.sessionKey` as the owner). The ticker filters
+ * by owner — if a different REPL is open against the same workspace,
+ * it won't fire someone else's jobs.
+ */
+import chalk from 'chalk';
+import { parseInterval } from '../../runtime/loopRunner.js';
+import { parseCron, nextCronFire } from '../../runtime/cronParser.js';
+import { addSchedule, loadSchedules, removeSchedule, setScheduleEnabled, } from '../../state/scheduleStore.js';
+export async function tryHandleScheduleCommand(ctx) {
+    if (ctx.command !== '/schedule')
+        return false;
+    const { args, agent } = ctx;
+    const sub = (args[0] ?? '').toLowerCase();
+    if (!sub || sub === 'list') {
+        renderList(agent.workspaceRoot, agent.sessionKey);
+        return true;
+    }
+    if (sub === 'remove' || sub === 'rm') {
+        const id = args[1];
+        if (!id) {
+            console.log(chalk.red('\nUsage: /schedule remove <id>\n'));
+            return true;
+        }
+        const ok = removeSchedule(agent.workspaceRoot, id);
+        console.log(ok
+            ? chalk.green(`\n✓ Removed ${id}.\n`)
+            : chalk.yellow(`\nNo schedule with id ${id}.\n`));
+        return true;
+    }
+    if (sub === 'disable' || sub === 'enable') {
+        const id = args[1];
+        if (!id) {
+            console.log(chalk.red(`\nUsage: /schedule ${sub} <id>\n`));
+            return true;
+        }
+        const ok = setScheduleEnabled(agent.workspaceRoot, id, sub === 'enable');
+        console.log(ok
+            ? chalk.green(`\n✓ ${sub === 'enable' ? 'Enabled' : 'Disabled'} ${id}.\n`)
+            : chalk.yellow(`\nNo schedule with id ${id}.\n`));
+        return true;
+    }
+    if (sub === 'cron') {
+        // Need to re-join because the splitter cracked the quoted cron expr
+        // across tokens. Re-join args after the leading "cron".
+        const rest = args.slice(1).join(' ').trim();
+        const m = /^"([^"]+)"\s+(\/\S.*)$/.exec(rest);
+        if (!m) {
+            console.log(chalk.red('\nUsage: /schedule cron "<expr>" /command'));
+            console.log(chalk.gray('  e.g. /schedule cron "*/15 * * * *" /ci-status\n'));
+            return true;
+        }
+        const expr = m[1];
+        const command = m[2].trim();
+        if (!command.startsWith('/')) {
+            console.log(chalk.red('\nSchedule only dispatches slash commands (must start with `/`).\n'));
+            return true;
+        }
+        const cron = parseCron(expr);
+        if (!cron) {
+            console.log(chalk.red(`\nInvalid cron expression: "${expr}"`));
+            console.log(chalk.gray('  Expected 5 fields: minute hour dom month dow\n'));
+            return true;
+        }
+        const nextRun = nextCronFire(cron, new Date());
+        const rec = addSchedule(agent.workspaceRoot, {
+            kind: 'cron',
+            expr,
+            command,
+            owner: agent.sessionKey,
+            nextRun: nextRun.toISOString(),
+        });
+        console.log(chalk.green(`\n✓ Registered ${rec.id}: cron "${expr}" → ${command}`));
+        console.log(chalk.gray(`  Next fire: ${formatWhen(nextRun)}\n`));
+        return true;
+    }
+    if (sub === 'in') {
+        const ms = parseInterval(args[1] ?? '');
+        const command = args.slice(2).join(' ').trim();
+        if (!ms || !command) {
+            console.log(chalk.red('\nUsage: /schedule in <duration> /command'));
+            console.log(chalk.gray('  e.g. /schedule in 5m /ci-status\n'));
+            return true;
+        }
+        if (!command.startsWith('/')) {
+            console.log(chalk.red('\nSchedule only dispatches slash commands.\n'));
+            return true;
+        }
+        const nextRun = new Date(Date.now() + ms);
+        const rec = addSchedule(agent.workspaceRoot, {
+            kind: 'once',
+            expr: nextRun.toISOString(),
+            command,
+            owner: agent.sessionKey,
+            nextRun: nextRun.toISOString(),
+        });
+        console.log(chalk.green(`\n✓ Registered ${rec.id}: one-shot in ${args[1]} → ${command}`));
+        console.log(chalk.gray(`  Fires at: ${formatWhen(nextRun)}\n`));
+        return true;
+    }
+    if (sub === 'at') {
+        const time = args[1] ?? '';
+        const command = args.slice(2).join(' ').trim();
+        const tm = /^(\d{1,2}):(\d{2})$/.exec(time);
+        if (!tm || !command) {
+            console.log(chalk.red('\nUsage: /schedule at HH:MM /command'));
+            console.log(chalk.gray('  e.g. /schedule at 14:30 /agents\n'));
+            return true;
+        }
+        if (!command.startsWith('/')) {
+            console.log(chalk.red('\nSchedule only dispatches slash commands.\n'));
+            return true;
+        }
+        const h = Number(tm[1]);
+        const min = Number(tm[2]);
+        if (h > 23 || min > 59) {
+            console.log(chalk.red('\nInvalid time. Hours 0-23, minutes 0-59.\n'));
+            return true;
+        }
+        const now = new Date();
+        const target = new Date(now);
+        target.setHours(h, min, 0, 0);
+        if (target.getTime() <= now.getTime())
+            target.setDate(target.getDate() + 1);
+        const rec = addSchedule(agent.workspaceRoot, {
+            kind: 'once',
+            expr: target.toISOString(),
+            command,
+            owner: agent.sessionKey,
+            nextRun: target.toISOString(),
+        });
+        console.log(chalk.green(`\n✓ Registered ${rec.id}: one-shot at ${time} → ${command}`));
+        console.log(chalk.gray(`  Fires at: ${formatWhen(target)}\n`));
+        return true;
+    }
+    console.log(chalk.red(`\nUnknown subcommand: /schedule ${sub}`));
+    console.log(chalk.gray('  Try: list | cron "<expr>" /cmd | in <dur> /cmd | at HH:MM /cmd | remove <id> | disable <id> | enable <id>\n'));
+    return true;
+}
+function renderList(workspaceRoot, sessionKey) {
+    const all = loadSchedules(workspaceRoot);
+    const mine = all.filter((s) => s.owner === sessionKey);
+    if (mine.length === 0) {
+        console.log(chalk.yellow('\nNo schedules registered for this session.'));
+        console.log(chalk.gray('  Add one with /schedule cron "<expr>" /command or /schedule in 5m /command\n'));
+        return;
+    }
+    console.log(chalk.bold('\nSchedules'));
+    for (const s of mine) {
+        const status = s.enabled ? chalk.green('●') : chalk.gray('○');
+        const kind = s.kind === 'cron' ? `cron "${s.expr}"` : `once`;
+        console.log(`  ${status} ${chalk.cyan(s.id)}  ${chalk.gray(kind.padEnd(28))} → ${s.command}`);
+        console.log(`      ${chalk.gray(`next: ${formatWhen(new Date(s.nextRun))}${s.lastRun ? `  ·  last: ${formatWhen(new Date(s.lastRun))}` : ''}`)}`);
+    }
+    console.log();
+}
+function formatWhen(d) {
+    if (!Number.isFinite(d.getTime()))
+        return '(invalid)';
+    const now = Date.now();
+    const delta = d.getTime() - now;
+    const abs = Math.abs(delta);
+    const human = humanDelta(abs);
+    const rel = delta >= 0 ? `in ${human}` : `${human} ago`;
+    return `${d.toISOString().replace('T', ' ').slice(0, 16)} (${rel})`;
+}
+function humanDelta(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h}h`;
+    return `${Math.round(h / 24)}d`;
+}

package/dist/cli/commands/ui.js

@@ -8,7 +8,7 @@ import { execSync } from 'node:child_process';
 import chalk from 'chalk';
 import { spinner as makeSpinner } from '../spinner.js';
 import { LOCAL_TOOLS } from '../../agent/agent.js';
-import { callMcpTool } from '../../runtime/mcpUtils.js';
+import { callMcpTool, hasMcpTool } from '../../runtime/mcpUtils.js';
 import { listSessions, reconcileStale } from '../../orchestration/orchestrator.js';
 import { readPreferences, resolveEffort, writePreferences } from '../../state/preferencesStore.js';
 import { readPlan } from '../../state/taskStore.js';
@@ -116,7 +116,7 @@ export async function tryHandleUiCommand(ctx) {
                     const toolNames = new Set((res.tools || []).map((tool) => tool.name));
                     const memoryTools = ['memory_recall', 'memory_capture_turn', 'memory_working_offload'];
                     for (const name of memoryTools) {
-                        const hasTool = toolNames.has(name);
+                        const hasTool = hasMcpTool(toolNames, name);
                         console.log(`  ${name}: ${hasTool ? chalk.green('available') : chalk.yellow('not exposed')}`);
                     }
                 }

package/dist/cli/ink/Picker.d.ts

@@ -33,6 +33,7 @@ export interface PickerProps {
     footer?: string;
     rows: PickerRow[];
     initialCursor?: number;
+    multiSelect?: boolean;
     allowOther?: boolean;
     otherLabel?: string;
     otherDescription?: string;
@@ -56,6 +57,11 @@ export interface PickerProps {
 export type PickerResult = {
     kind: 'pick';
     id: string;
+} | {
+    kind: 'multi';
+    id: string;
+    ids: string[];
+    otherText?: string;
 } | {
     kind: 'other';
     text: string;

package/dist/cli/ink/Picker.js

@@ -27,6 +27,7 @@ export function Picker(props) {
         ];
     }, [props.rows, props.allowOther, props.otherLabel, props.otherDescription]);
     const [cursor, setCursor] = useState(() => Math.max(0, Math.min(props.initialCursor ?? 0, augmentedRows.length - 1)));
+    const [selected, setSelected] = useState(() => new Set());
     const [phase, setPhase] = useState(props.prefilledOther !== undefined ? 'other' : 'pick');
     const [otherText, setOtherText] = useState(props.prefilledOther ?? '');
     const [preview, setPreview] = useState(undefined);
@@ -100,6 +101,17 @@ export function Picker(props) {
         }
         if (key.return) {
             const row = augmentedRows[cursor];
+            if (props.multiSelect) {
+                if (selected.size === 0)
+                    return;
+                if (selected.has(OTHER_ID)) {
+                    setPhase('other');
+                    return;
+                }
+                const ids = augmentedRows.filter((r) => selected.has(r.id)).map((r) => r.id);
+                finish({ kind: 'multi', id: ids[0] ?? '', ids });
+                return;
+            }
             if (row.id === OTHER_ID) {
                 setPhase('other');
                 return;
@@ -107,6 +119,18 @@ export function Picker(props) {
             finish({ kind: 'pick', id: row.id });
             return;
         }
+        if (input === ' ' && props.multiSelect) {
+            const row = augmentedRows[cursor];
+            setSelected((prev) => {
+                const next = new Set(prev);
+                if (next.has(row.id))
+                    next.delete(row.id);
+                else
+                    next.add(row.id);
+                return next;
+            });
+            return;
+        }
         if (key.escape || input === 'q') {
             finish({ kind: 'cancelled' });
             return;
@@ -114,20 +138,31 @@ export function Picker(props) {
     });
     const footer = props.footer ?? (phase === 'other'
         ? '↵ accept  ·  esc back  ·  ⌫ erase'
-        : '↑/↓ navigate  ·  ↵ confirm  ·  esc / q cancel');
+        : props.multiSelect
+            ? '↑/↓ navigate  ·  space toggle  ·  ↵ confirm  ·  esc / q cancel'
+            : '↑/↓ navigate  ·  ↵ confirm  ·  esc / q cancel');
     const accent = props.accentColor ?? themeToAccent(props.theme?.mode) ?? '#CC9166';
-    return (_jsxs(Frame, { title: props.title, subtitle: props.subtitle, badge: props.badge, footer: footer, accentColor: accent, children: [phase === 'pick' ? (_jsx(PickerRows, { rows: augmentedRows, cursor: cursor, accentColor: accent })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: accent, children: "\u203A Type your answer" }), _jsx(Text, { color: "gray", dimColor: true, children: props.otherDescription ?? 'Press ENTER to accept' }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "\u203A " }), _jsx(TextInput, { value: otherText, onChange: setOtherText, onSubmit: (value) => {
+    return (_jsxs(Frame, { title: props.title, subtitle: props.subtitle, badge: props.badge, footer: footer, accentColor: accent, children: [phase === 'pick' ? (_jsx(PickerRows, { rows: augmentedRows, cursor: cursor, accentColor: accent, multiSelect: !!props.multiSelect, selected: selected })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: accent, children: "\u203A Type your answer" }), _jsx(Text, { color: "gray", dimColor: true, children: props.otherDescription ?? 'Press ENTER to accept' }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "\u203A " }), _jsx(TextInput, { value: otherText, onChange: setOtherText, onSubmit: (value) => {
                                     const trimmed = value.trim();
                                     if (!trimmed)
                                         return;
+                                    if (props.multiSelect) {
+                                        finish({
+                                            kind: 'multi',
+                                            id: augmentedRows.find((r) => selected.has(r.id) && r.id !== OTHER_ID)?.id ?? '',
+                                            ids: augmentedRows.filter((r) => selected.has(r.id) && r.id !== OTHER_ID).map((r) => r.id),
+                                            otherText: trimmed,
+                                        });
+                                        return;
+                                    }
                                     finish({ kind: 'other', text: trimmed });
                                 } })] })] })), preview && preview.length > 0 ? (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", borderTop: true, borderLeft: false, borderRight: false, borderBottom: false, children: preview.map((line, i) => _jsx(Text, { children: line }, i)) })) : null] }));
 }
-function PickerRows({ rows, cursor, accentColor }) {
-    return (_jsx(Box, { flexDirection: "column", children: rows.map((row, i) => (_jsx(PickerRowView, { row: row, selected: i === cursor, accentColor: accentColor }, row.id))) }));
+function PickerRows({ rows, cursor, accentColor, multiSelect, selected }) {
+    return (_jsx(Box, { flexDirection: "column", children: rows.map((row, i) => (_jsx(PickerRowView, { row: row, selected: i === cursor, accentColor: accentColor, multiSelect: multiSelect, checked: selected.has(row.id) }, row.id))) }));
 }
-function PickerRowView({ row, selected, accentColor }) {
+function PickerRowView({ row, selected, accentColor, multiSelect, checked }) {
     // Selected glyph + bold label + right-aligned value, lifted from
     // openSrc/grok-cli/src/ui/components/SuggestionOverlay.tsx
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: accentColor, children: selected ? ' › ' : '   ' }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { bold: selected, color: selected ? accentColor : undefined, children: row.label }) }), row.value ? _jsx(Text, { color: "gray", children: row.value }) : null] }), row.description ? (_jsx(Box, { paddingLeft: 5, children: _jsx(Text, { color: "gray", dimColor: true, children: row.description }) })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: accentColor, children: selected ? ' › ' : '   ' }), multiSelect ? _jsx(Text, { color: checked ? accentColor : 'gray', children: checked ? '[x] ' : '[ ] ' }) : null, _jsx(Box, { flexGrow: 1, children: _jsx(Text, { bold: selected, color: selected ? accentColor : undefined, children: row.label }) }), row.value ? _jsx(Text, { color: "gray", children: row.value }) : null] }), row.description ? (_jsx(Box, { paddingLeft: 5, children: _jsx(Text, { color: "gray", dimColor: true, children: row.description }) })) : null] }));
 }

package/dist/cli/ink/runChat.js

@@ -12,6 +12,7 @@ import { addGoalTokens, buildGoalContinuationPrompt, formatBudget, goalHasBudget
 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';
@@ -288,7 +289,11 @@ export async function runChat(opts) {
             const elapsed = Math.floor((Date.now() - startedAt) / 1000);
             const u = agent.lastTurnUsage;
             const tokens = u.calls > 0 ? `  ${u.promptTokens.toLocaleString()}↑ ${u.completionTokens.toLocaleString()}↓` : '';
-            controller.push.setStatus(`${status}  ${elapsed}s${tokens}`);
+            // 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
@@ -299,6 +304,25 @@ export async function runChat(opts) {
         // 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,
@@ -337,7 +361,50 @@ export async function runChat(opts) {
                     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`
@@ -427,6 +494,39 @@ export async function runChat(opts) {
             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
@@ -452,6 +552,7 @@ export async function runChat(opts) {
                 });
                 refreshFooter();
                 armIdleHint();
+                startTicker();
             }, onAccessModeCycle: () => {
                 const cycle = ['read', 'write', 'shell'];
                 const current = agent.getAccessMode();
@@ -500,6 +601,11 @@ export async function runChat(opts) {
             setAmbientChat(undefined);
             cleanupResizeClear();
             clearIdleHint();
+            try {
+                scheduleTicker?.stop();
+            }
+            catch { /* noop */ }
+            scheduleTicker = null;
             try {
                 await mcpClient.close();
             }
@@ -514,6 +620,11 @@ export async function runChat(opts) {
             setAmbientChat(undefined);
             cleanupResizeClear();
             clearIdleHint();
+            try {
+                scheduleTicker?.stop();
+            }
+            catch { /* noop */ }
+            scheduleTicker = null;
             try {
                 await mcpClient.close();
             }

package/dist/cli/ink/toolFormat.d.ts

@@ -11,7 +11,7 @@
  *
  * — one-line, identity-revealing, no JSON. These helpers do the same
  * mapping for our built-in LOCAL_TOOLS (cli/../agent/agent.ts) + MCP
- * tool names (which carry an `mcp__<server>__` namespace prefix that
+ * tool names (which carry an `mcp_<server>_` namespace prefix that
  * the user doesn't care about).
  *
  * Reference for the convention: claude-code transcripts (see
@@ -28,20 +28,22 @@
  *     → "Bash(npm test)"
  *   formatToolCall('grep_search', { query: 'authenticate', path: '.' })
  *     → 'Grep("authenticate")'
- *   formatToolCall('mcp__brainrouter__memory_search', { q: 'auth' })
+ *   formatToolCall('mcp_brainrouter_memory_search', { q: 'auth' })
  *     → 'MemorySearch("auth")'
  *   formatToolCall('spawn_agent', { role: 'researcher', prompt: '...' })
  *     → 'Spawn(researcher, "...")'
+ *   formatToolCall('task_agent', { role: 'reviewer', prompt: '...' })
+ *     → 'Task(reviewer, "...")'
  */
 export declare function formatToolCall(name: string, args: Record<string, any> | undefined): string;
+export declare function setKnownMcpServerIds(ids: ReadonlyArray<string>): void;
 /**
- * Strip the `mcp__<server>__` or `mcp_<server>_` namespace prefix from MCP tool
- * names. Server ids may contain underscores (e.g. `my_server`), so the
- * double-underscore form uses a lazy match. Both prefix conventions are in use
- * across the multi-MCP codepaths until naming is unified.
- *   `mcp__brainrouter__memory_search` → `memory_search`
- *   `mcp__my_server__memory_search`    → `memory_search`
- *   `mcp_brainrouter_memory_search`    → `memory_search`
+ * Strip the `mcp_<server>_` namespace prefix from MCP tool names. As of
+ * 0.3.8-R5 the pool normalises to single-underscore at the boundary, so
+ * downstream call-sites only ever see this shape.
+ *   `mcp_brainrouter_memory_search` → `memory_search`
+ *   `mcp_my_server_memory_search`   → `memory_search` (when `my_server`
+ *                                     is registered via `setKnownMcpServerIds`)
  */
 export declare function stripMcpPrefix(name: string): string;
 /**