@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/orchestration/agentRegistry.d.ts

@@ -0,0 +1,36 @@
+export type Tier = 'chat' | 'reasoning' | 'worker';
+export type AccessMode = 'read' | 'write' | 'shell';
+export interface AgentDefinition {
+    id: string;
+    displayName: string;
+    whenToUse: string;
+    prompt: string;
+    model: string | null;
+    effort: string | null;
+    defaultAccess: AccessMode;
+    toolScope: {
+        local: string[];
+        mcp: string[];
+    };
+    disallowedTools: string[];
+    maxIterations: number;
+    timeoutMs: number;
+    maxResultChars: number;
+    subagents: string[];
+    delegateName: string;
+    tier: Tier;
+    outputContract: unknown;
+}
+export type DefinitionSource = 'builtin' | 'user' | 'workspace';
+export interface LoadedDefinition {
+    def: AgentDefinition;
+    source: DefinitionSource;
+    filePath: string;
+}
+/**
+ * Load all agent definitions from three tiers (builtin → user-global → workspace).
+ * Same `id` from a higher-priority source wins; distinct ids coexist.
+ */
+export declare function loadRegistry(workspaceRoot?: string): LoadedDefinition[];
+export declare function findById(id: string, workspaceRoot?: string): LoadedDefinition | undefined;
+export declare function listAll(workspaceRoot?: string): LoadedDefinition[];

package/dist/orchestration/agentRegistry.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+// Resolved at import time from dist/orchestration/agentRegistry.js → ../../agents
+const BUILTIN_AGENTS_DIR = fileURLToPath(new URL('../../agents', import.meta.url));
+function getUserAgentsDir() {
+    const home = process.env.BRAINROUTER_HOME ?? path.join(os.homedir(), '.config', 'brainrouter');
+    return path.join(home, 'agents');
+}
+function getWorkspaceAgentsDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.brainrouter', 'agents');
+}
+function loadFromDir(dir, source) {
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir).filter((f) => f.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        const filePath = path.join(dir, entry);
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const def = JSON.parse(raw);
+            if (!def.id || typeof def.id !== 'string') {
+                console.error(`[agentRegistry] Skipping ${filePath}: missing or invalid "id" field.`);
+                continue;
+            }
+            results.push({ def, source, filePath });
+        }
+        catch (err) {
+            console.error(`[agentRegistry] Skipping ${filePath}: ${err.message}`);
+        }
+    }
+    return results;
+}
+/**
+ * Load all agent definitions from three tiers (builtin → user-global → workspace).
+ * Same `id` from a higher-priority source wins; distinct ids coexist.
+ */
+export function loadRegistry(workspaceRoot) {
+    const builtin = loadFromDir(BUILTIN_AGENTS_DIR, 'builtin');
+    const user = loadFromDir(getUserAgentsDir(), 'user');
+    const workspace = workspaceRoot
+        ? loadFromDir(getWorkspaceAgentsDir(workspaceRoot), 'workspace')
+        : [];
+    // Precedence: builtin first (lowest), workspace last (highest).
+    const merged = new Map();
+    for (const loaded of [...builtin, ...user, ...workspace]) {
+        merged.set(loaded.def.id, loaded);
+    }
+    return Array.from(merged.values());
+}
+export function findById(id, workspaceRoot) {
+    return loadRegistry(workspaceRoot).find((l) => l.def.id === id);
+}
+export function listAll(workspaceRoot) {
+    return loadRegistry(workspaceRoot);
+}

package/dist/orchestration/orchestrator.d.ts

@@ -1,4 +1,5 @@
 import { type AccessMode } from './roles.js';
+import type { Tier } from './agentRegistry.js';
 export type ChildStatus = 'pending' | 'running' | 'completed' | 'failed' | 'stale' | 'closed';
 export interface ChildSessionRecord {
     id: string;
@@ -14,6 +15,10 @@ export interface ChildSessionRecord {
     pid: number;
     finalOutput?: string;
     error?: string;
+    /** Agent tier from the definition (reasoning | worker). Undefined for legacy records. */
+    tier?: Tier;
+    /** Nesting depth in the spawn chain; 0 = direct child of the chat root. */
+    depth?: number;
     /** LLM usage attributable to this child (filled when the child completes). */
     usage?: {
         promptTokens: number;
@@ -30,6 +35,8 @@ export declare function createSession(workspaceRoot: string, input: {
     parentSessionKey: string;
     access?: AccessMode;
     label?: string;
+    tier?: Tier;
+    depth?: number;
 }): ChildSessionRecord;
 export declare function updateSession(workspaceRoot: string, id: string, patch: Partial<ChildSessionRecord>): ChildSessionRecord;
 export declare function reconcileStale(workspaceRoot: string): number;

package/dist/orchestration/orchestrator.js

@@ -28,6 +28,8 @@ export function createSession(workspaceRoot, input) {
         startedAt: now,
         updatedAt: now,
         pid: process.pid,
+        tier: input.tier,
+        depth: input.depth,
     };
     const data = readFile(workspaceRoot);
     data.sessions.push(record);

package/dist/orchestration/tools.d.ts

@@ -1,6 +1,7 @@
-import type { McpClientWrapper } from '../runtime/mcpClient.js';
+import type { McpClientPool as McpClientWrapper } from '../runtime/mcpPool.js';
 import type { LLMConfig } from '../config/config.js';
 import { type AccessMode } from './roles.js';
+import { type Tier } from './agentRegistry.js';
 export interface OrchestrationContext {
     workspaceRoot: string;
     parentSessionKey: string;
@@ -21,6 +22,10 @@ export interface OrchestrationContext {
     parentSpanId?: string;
     /** Parent agent_id so children can be grouped via attribute even without trace links. */
     parentAgentId?: string;
+    /** Parent agent tier — used for hierarchy checks (worker cannot spawn; reasoning can only spawn workers). */
+    parentTier?: Tier;
+    /** Current spawn-chain depth (0 = direct child of chat root). */
+    depth?: number;
     mcpClient: McpClientWrapper;
     llmConfig: LLMConfig;
     launchCwd: string;
@@ -76,6 +81,10 @@ export declare function createSpawnAgentTool(): {
                 type: string;
                 description: string;
             };
+            agentId: {
+                type: string;
+                description: string;
+            };
             prompt: {
                 type: string;
                 description: string;

package/dist/orchestration/tools.js

@@ -1,6 +1,7 @@
 import { Agent } from '../agent/agent.js';
 import { createSession, formatSessionSummary, getSession, listSessions, updateSession, } from './orchestrator.js';
 import { buildRolePrompt, resolveRole } from './roles.js';
+import { findById, listAll } from './agentRegistry.js';
 import { buildSystemPrompt, loadWorkspaceInstructionSummary } from '../prompt/systemPrompt.js';
 import { readTranscriptEntries } from '../state/sessionStore.js';
 import { callMcpTool, childSessionKey } from '../runtime/mcpUtils.js';
@@ -100,11 +101,12 @@ export function trackedPromiseFor(id) {
 export function createSpawnAgentTool() {
     return {
         name: 'spawn_agent',
-        description: 'Spawn a child agent with a specific role (explorer, architect, reviewer, worker, verifier) and a bounded prompt. Returns the child agent id immediately; the child runs in the background.',
+        description: 'Spawn a child agent and a bounded prompt. Returns the child agent id immediately; the child runs in the background. Specify the agent via `role` (legacy: explorer/architect/reviewer/worker/verifier) or `agentId` (registry id, e.g. a custom workspace definition).',
         inputSchema: {
             type: 'object',
             properties: {
-                role: { type: 'string', description: 'One of: explorer, architect, reviewer, worker, verifier.' },
+                role: { type: 'string', description: 'One of: explorer, architect, reviewer, worker, verifier. Prefer agentId for custom definitions.' },
+                agentId: { type: 'string', description: 'Registry id of the agent definition. Takes precedence over role when both are provided.' },
                 prompt: { type: 'string', description: 'The bounded task prompt for the child agent.' },
                 label: { type: 'string', description: 'Optional short label for the child run.' },
                 access: { type: 'string', enum: ['read', 'write', 'shell'], description: 'Override the role default access mode. Default: role default.' },
@@ -116,7 +118,7 @@ export function createSpawnAgentTool() {
                     description: 'Optional BrainRouter memory record IDs that the parent already recalled. The child agent is told to build on these instead of re-discovering them.',
                 },
             },
-            required: ['role', 'prompt'],
+            required: ['prompt'],
         },
     };
 }
@@ -297,10 +299,47 @@ function explainRoute(task, role) {
     }
 }
 async function handleSpawn(args, ctx) {
-    const role = resolveRole(String(args.role));
+    // Resolve agent definition via agentId (registry) or role (legacy).
+    let role;
+    let childTier;
+    if (typeof args.agentId === 'string' && args.agentId.trim()) {
+        const loaded = findById(args.agentId.trim(), ctx.workspaceRoot);
+        if (!loaded) {
+            const known = listAll(ctx.workspaceRoot).map((l) => l.def.id).join(', ');
+            throw new Error(`Unknown agentId "${args.agentId}". Known agents: ${known}.`);
+        }
+        role = {
+            name: loaded.def.id,
+            description: loaded.def.whenToUse,
+            defaultAccess: loaded.def.defaultAccess,
+            promptOverlay: loaded.def.prompt,
+        };
+        childTier = loaded.def.tier;
+    }
+    else {
+        const roleName = String(args.role ?? '');
+        if (!roleName.trim())
+            throw new Error('spawn_agent requires either "agentId" or "role".');
+        role = resolveRole(roleName);
+        childTier = findById(role.name, ctx.workspaceRoot)?.def.tier;
+    }
     const prompt = String(args.prompt ?? '');
     if (!prompt.trim())
         throw new Error('spawn_agent requires a non-empty prompt.');
+    // P1.2 — spawn hierarchy checks.
+    const rawMaxDepth = parseInt(process.env.BRAINROUTER_MAX_SPAWN_DEPTH ?? '3', 10);
+    const maxDepth = Number.isFinite(rawMaxDepth) && rawMaxDepth > 0 ? rawMaxDepth : 3;
+    const currentDepth = ctx.depth ?? 0;
+    const parentTier = ctx.parentTier;
+    if (parentTier === 'worker') {
+        throw new Error('Tier "worker" cannot delegate — ask the parent agent to spawn instead.');
+    }
+    if (parentTier === 'reasoning' && childTier && (childTier === 'chat' || childTier === 'reasoning')) {
+        throw new Error(`Tier "reasoning" cannot spawn a "${childTier}" agent — only "worker" children are allowed.`);
+    }
+    if (currentDepth >= maxDepth) {
+        throw new Error(`Spawn depth cap reached (${currentDepth}/${maxDepth}). Reduce agent nesting or raise BRAINROUTER_MAX_SPAWN_DEPTH.`);
+    }
     const requested = args.access ?? role.defaultAccess;
     const access = clampAccess(ctx.parentAccessMode ?? 'shell', requested);
     const record = createSession(ctx.workspaceRoot, {
@@ -309,6 +348,8 @@ async function handleSpawn(args, ctx) {
         parentSessionKey: ctx.parentSessionKey,
         access,
         label: typeof args.label === 'string' ? args.label : undefined,
+        tier: childTier,
+        depth: currentDepth + 1,
     });
     const childKey = childSessionKey(ctx.parentSessionKey, record.id);
     const seededIds = Array.isArray(args.seedRecordIds)
@@ -346,6 +387,9 @@ async function handleSpawn(args, ctx) {
         // dispatching spawn_agent tool span instead of starting a fresh tree.
         parentTraceId: ctx.parentTraceId,
         parentSpanId: ctx.parentSpanId,
+        // Propagate tier and depth so grandchildren can enforce hierarchy caps.
+        tier: childTier,
+        agentDepth: currentDepth + 1,
     });
     if (ctx.parentAgentId)
         childAgent.setParentAgentId(ctx.parentAgentId);

package/dist/prompt/breadthHint.d.ts

@@ -36,9 +36,14 @@ export declare function detectBreadthIntent(prompt: string): BreadthIntent;
  *    turn that should have been parallel.
  */
 export declare const BREADTH_FAN_OUT_THRESHOLD = 1.5;
+export declare function detectFanOutVeto(prompt: string): {
+    vetoed: boolean;
+    pattern?: string;
+};
 export declare function shouldSuggestFanOut(prompt: string): {
     suggest: boolean;
     intent: BreadthIntent;
+    veto?: string;
 };
 /**
  * The system message we inject to nudge the agent toward spawn_agents. It

package/dist/prompt/breadthHint.js

@@ -64,8 +64,52 @@ export function detectBreadthIntent(prompt) {
  *    turn that should have been parallel.
  */
 export const BREADTH_FAN_OUT_THRESHOLD = 1.5;
+/**
+ * Negation hints — explicit signals from the user that they DO NOT want
+ * fan-out for this prompt. Honored as a hard veto: even a high breadth
+ * score won't trigger the hint if any of these match.
+ *
+ * Common cases we want to honor:
+ *  - "(no spawn_agent, no fan-out, files are small)"  — explicit opt-out
+ *  - "do this in one turn"                            — wants serial
+ *  - "directly with read_file, no fan-out"            — explicit tool
+ *  - "yourself, don't spawn agents"                   — explicit self
+ *
+ * Without this veto, a prompt like
+ *   "audit every file (no spawn_agent, files are small)"
+ * still scores high on `verb-object-broad` + `every` and the model gets
+ * told "fan out!" — directly contradicting the user's instruction.
+ */
+const NEGATION_PATTERNS = [
+    /\bno\s+(spawn[_-]?agents?|fan[- ]?out|children?|sub[- ]?agents?|orchestration)\b/i,
+    /\b(don'?t|do not)\s+(spawn|fan[- ]?out|delegate|orchestrate)\b/i,
+    /\b(in\s+one\s+turn|single\s+turn|sequentially|one[- ]by[- ]one|in[- ]process)\b/i,
+    /\bdirectly\s+(with|using|via)\b/i,
+    /\b(yourself|by\s+yourself|on\s+your\s+own)\b/i,
+];
+export function detectFanOutVeto(prompt) {
+    const text = (prompt ?? '').toString();
+    for (const re of NEGATION_PATTERNS) {
+        const match = text.match(re);
+        if (match)
+            return { vetoed: true, pattern: match[0] };
+    }
+    return { vetoed: false };
+}
 export function shouldSuggestFanOut(prompt) {
     const intent = detectBreadthIntent(prompt);
+    const veto = detectFanOutVeto(prompt);
+    if (veto.vetoed) {
+        // Reflect the veto in the intent's signals so onToolEnd's surfacing
+        // shows the user why we didn't fan out, even though the breadth
+        // score was high. The score itself isn't zeroed — it's still useful
+        // signal for other heuristics.
+        return {
+            suggest: false,
+            intent: { ...intent, signals: [...intent.signals, `vetoed:${veto.pattern}`] },
+            veto: veto.pattern,
+        };
+    }
     return { suggest: intent.score >= BREADTH_FAN_OUT_THRESHOLD, intent };
 }
 /**

package/dist/prompt/skillCatalog.d.ts

@@ -0,0 +1,11 @@
+export interface SkillListItem {
+    name: string;
+    scope?: string;
+    category?: string;
+    description?: string;
+    source?: 'mcp' | 'filesystem';
+}
+export declare function listFilesystemSkills(workspaceRoot: string): SkillListItem[];
+export declare function mergeSkillLists(primary: SkillListItem[], fallback: SkillListItem[]): SkillListItem[];
+export declare function sortSkills(a: SkillListItem, b: SkillListItem): number;
+export declare function skillSearchRoots(workspaceRoot: string): string[];

package/dist/prompt/skillCatalog.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+const requireFromHere = createRequire(import.meta.url);
+const WORKSPACE_SKILL_ROOTS = ['skills', '.brainrouter/skills'];
+export function listFilesystemSkills(workspaceRoot) {
+    const seen = new Map();
+    for (const root of skillSearchRoots(workspaceRoot)) {
+        if (!fs.existsSync(root))
+            continue;
+        const scope = inferRootScope(root, workspaceRoot);
+        for (const filePath of findSkillFiles(root)) {
+            const parsed = parseSkillFile(filePath);
+            if (!parsed)
+                continue;
+            const rel = path.relative(root, filePath);
+            const category = rel.split(path.sep)[0] || 'uncategorized';
+            if (!seen.has(parsed.name)) {
+                seen.set(parsed.name, {
+                    name: parsed.name,
+                    category,
+                    description: parsed.description,
+                    scope,
+                    source: 'filesystem',
+                });
+            }
+        }
+    }
+    return Array.from(seen.values()).sort(sortSkills);
+}
+export function mergeSkillLists(primary, fallback) {
+    const merged = new Map();
+    for (const skill of primary) {
+        merged.set(skill.name, { ...skill, source: skill.source ?? 'mcp' });
+    }
+    for (const skill of fallback) {
+        if (!merged.has(skill.name))
+            merged.set(skill.name, skill);
+    }
+    return Array.from(merged.values()).sort(sortSkills);
+}
+export function sortSkills(a, b) {
+    return (a.category ?? '').localeCompare(b.category ?? '') || a.name.localeCompare(b.name);
+}
+export function skillSearchRoots(workspaceRoot) {
+    const roots = [];
+    for (const sub of WORKSPACE_SKILL_ROOTS)
+        roots.push(path.join(workspaceRoot, sub));
+    const mcpPkgDir = resolveInstalledMcpPackageDir();
+    if (mcpPkgDir) {
+        roots.push(path.join(mcpPkgDir, 'skills'));
+        const monorepoRoot = path.dirname(mcpPkgDir);
+        roots.push(path.join(monorepoRoot, 'skills'));
+    }
+    return [...new Set(roots.map((root) => path.resolve(root)))];
+}
+function resolveInstalledMcpPackageDir() {
+    try {
+        const pkgJsonPath = requireFromHere.resolve('@kinqs/brainrouter-mcp-server/package.json');
+        return path.dirname(pkgJsonPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function inferRootScope(root, workspaceRoot) {
+    const resolvedWorkspace = path.resolve(workspaceRoot);
+    const resolvedRoot = path.resolve(root);
+    if (resolvedRoot.startsWith(path.join(resolvedWorkspace, '.brainrouter')))
+        return 'local';
+    if (isBrainRouterRepoRoot(path.dirname(resolvedRoot)))
+        return 'global';
+    return resolvedRoot.startsWith(resolvedWorkspace) ? 'local' : 'global';
+}
+function isBrainRouterRepoRoot(root) {
+    return (fs.existsSync(path.join(root, 'brainrouter', 'package.json')) &&
+        fs.existsSync(path.join(root, 'brainrouter-cli', 'package.json')) &&
+        fs.existsSync(path.join(root, 'skills')));
+}
+function findSkillFiles(root) {
+    const results = [];
+    function walk(current, depth) {
+        if (depth < 0)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory())
+                walk(full, depth - 1);
+            else if (entry.isFile() && entry.name === 'SKILL.md')
+                results.push(full);
+        }
+    }
+    walk(root, 5);
+    return results;
+}
+function parseSkillFile(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const frontmatter = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const block = frontmatter?.[1] ?? '';
+    const name = readYamlScalar(block, 'name') ?? path.basename(path.dirname(filePath));
+    const description = readYamlScalar(block, 'description') ?? firstParagraph(raw);
+    if (!name)
+        return undefined;
+    return { name, description };
+}
+function readYamlScalar(block, key) {
+    const match = block.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+    if (!match?.[1])
+        return undefined;
+    return match[1].trim().replace(/^['"]|['"]$/g, '');
+}
+function firstParagraph(raw) {
+    const withoutFrontmatter = raw.replace(/^---\r?\n[\s\S]*?\r?\n---/, '').trim();
+    const line = withoutFrontmatter
+        .split(/\r?\n/)
+        .map((part) => part.trim())
+        .find((part) => part && !part.startsWith('#'));
+    return line;
+}

package/dist/prompt/skillRunner.d.ts

@@ -1,4 +1,4 @@
-import type { McpClientWrapper } from '../runtime/mcpClient.js';
+import type { McpClient } from '../runtime/mcpUtils.js';
 export interface SkillResolution {
     name: string;
     body: string;
@@ -24,7 +24,7 @@ export declare const SLASH_TO_SKILL: Record<string, string>;
  * server has loaded, including their own private skills), falls back to a
  * local filesystem scan of `skills/` for when the MCP tool is unavailable.
  */
-export declare function resolveSkill(mcpClient: McpClientWrapper, name: string, workspaceRoot: string, section?: RunSkillOptions['section']): Promise<SkillResolution>;
+export declare function resolveSkill(mcpClient: McpClient, name: string, workspaceRoot: string, section?: RunSkillOptions['section']): Promise<SkillResolution>;
 /**
  * Build the user prompt that asks the agent to execute a skill. The skill
  * body is embedded so the agent does not need to round-trip through

package/dist/prompt/skillRunner.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { createRequire } from 'node:module';
-const requireFromHere = createRequire(import.meta.url);
+import { skillSearchRoots } from './skillCatalog.js';
 /**
  * Slash-command → skill mapping. Each entry names the skill catalogued in
  * the BrainRouter skills/ folder (and exposed by the MCP server) that the
@@ -21,7 +20,6 @@ export const SLASH_TO_SKILL = {
     '/refactor': 'code-simplification',
     '/test': 'testing-skill',
 };
-const WORKSPACE_SKILL_ROOTS = ['skills', '.brainrouter/skills'];
 /**
  * Resolve a skill by name. Prefers the MCP server (so users get whatever the
  * server has loaded, including their own private skills), falls back to a
@@ -61,34 +59,7 @@ function readSkillFromFilesystem(workspaceRoot, name) {
     }
     return undefined;
 }
-/**
- * Roots to search for SKILL.md when the MCP server is unavailable. Includes:
- *  - the user's workspace (so per-project skills win locally)
- *  - the installed @kinqs/brainrouter-mcp-server package directory (so the canonical
- *    BrainRouter catalogue is found even when MCP is down, because prepack
- *    bundles `skills/` into the published package)
- *  - the monorepo root (when running from source during development)
- */
-function skillSearchRoots(workspaceRoot) {
-    const roots = [];
-    for (const sub of WORKSPACE_SKILL_ROOTS) {
-        roots.push(path.join(workspaceRoot, sub));
-    }
-    const mcpPkgDir = resolveInstalledMcpPackageDir();
-    if (mcpPkgDir)
-        roots.push(path.join(mcpPkgDir, 'skills'));
-    return roots;
-}
-function resolveInstalledMcpPackageDir() {
-    try {
-        const pkgJsonPath = requireFromHere.resolve('@kinqs/brainrouter-mcp-server/package.json');
-        return path.dirname(pkgJsonPath);
-    }
-    catch {
-        return undefined;
-    }
-}
-function findSkillDir(rootDir, skillName, depth = 3) {
+function findSkillDir(rootDir, skillName, depth = 5) {
     if (depth < 0)
         return undefined;
     let entries;

package/dist/prompt/systemPrompt.d.ts

@@ -5,6 +5,40 @@ export interface SystemPromptContext {
     instructionSummary?: string;
     /** Communication style overlay set by /personality. */
     personality?: 'concise' | 'standard' | 'detailed' | 'pair-programmer';
+    /**
+     * Name of the active BrainRouter skill latched by a slash command (e.g.
+     * `/spec`, `/feature-dev`, `/grill-me`). Most skills are workflow
+     * directives the model loads via `get_skill` and don't change the system
+     * prompt — `grill-me` is the exception: it appends a CLARIFY-mode block
+     * here so the model asks questions instead of jumping to edits.
+     */
+    activeSkill?: string;
+    /**
+     * Execution-mode overlay set by `/mode`. Only `fast` produces an overlay
+     * — `planning` is the unchanged default behaviour and adding prose for it
+     * would just dilute the rest of the prompt.
+     */
+    executionMode?: 'planning' | 'fast';
+    /**
+     * Review-policy overlay set by `/review-policy`. Only `proceed` produces
+     * an overlay; `request` is the default behaviour.
+     */
+    reviewPolicy?: 'request' | 'proceed';
+    /**
+     * Reasoning-depth overlay set by `/effort` (or `BRAINROUTER_EFFORT`).
+     * `medium` is the default and emits no overlay — adding prose for it
+     * would silently change behaviour for every existing user on upgrade.
+     */
+    effort?: 'low' | 'medium' | 'high';
+    /**
+     * 0.3.6 item 10b: the set of MCP tool names actually connected this turn.
+     * When this list lacks `memory_recall` (i.e. the BrainRouter cloud brain
+     * is offline), the prompt omits the "BrainRouter MCP Tools" / "Memory-
+     * First" sections so the model doesn't try to call tools that don't
+     * exist. Undefined = "assume the BrainRouter MCP is online" (pre-10b
+     * back-compat for callers that don't pass the inventory).
+     */
+    connectedMcpTools?: string[];
 }
 export declare function buildSystemPrompt(context: SystemPromptContext): string;
 export declare function loadWorkspaceInstructionSummary(workspaceRoot: string): string | undefined;