aia 1.1.1 → 2.0.0.0.pre.alpha

data/docs/mcp-integration.md

@@ -1,3 +1,43 @@
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+- [MCP Integration](#mcp-integration)
+  - [Understanding MCP](#understanding-mcp)
+    - [What is MCP?](#what-is-mcp)
+    - [MCP vs RubyLLM Tools](#mcp-vs-rubyllm-tools)
+  - [Enabling MCP Support](#enabling-mcp-support)
+    - [Configuration](#configuration)
+    - [Command Line Usage](#command-line-usage)
+  - [Available MCP Clients](#available-mcp-clients)
+    - [GitHub Integration](#github-integration)
+    - [File System Access](#file-system-access)
+    - [Database Integration](#database-integration)
+  - [Using MCP Clients in Prompts](#using-mcp-clients-in-prompts)
+    - [GitHub Analysis](#github-analysis)
+    - [File System Operations](#file-system-operations)
+    - [Database Schema Analysis](#database-schema-analysis)
+  - [Advanced MCP Integration](#advanced-mcp-integration)
+    - [Multi-Client Workflows](#multi-client-workflows)
+    - [Conditional MCP Usage](#conditional-mcp-usage)
+  - [Custom MCP Client Development](#custom-mcp-client-development)
+    - [Basic MCP Server Structure](#basic-mcp-server-structure)
+    - [Node.js MCP Server](#nodejs-mcp-server)
+  - [MCP Security and Best Practices](#mcp-security-and-best-practices)
+    - [Access Control](#access-control)
+    - [Server Configuration Security](#server-configuration-security)
+    - [Parallel Connections](#parallel-connections)
+  - [Troubleshooting MCP](#troubleshooting-mcp)
+    - [Common Issues](#common-issues)
+      - [Client Connection Failures](#client-connection-failures)
+      - [Protocol Errors](#protocol-errors)
+  - [MCP Examples Repository](#mcp-examples-repository)
+    - [GitHub Repository Analysis](#github-repository-analysis)
+    - [File System Audit](#file-system-audit)
+  - [Related Documentation](#related-documentation)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
 # MCP Integration
 
 AIA supports Model Context Protocol (MCP) clients, enabling AI models to interact with external services, databases, and applications through standardized interfaces.

data/docs/prompt_management.md

@@ -1,3 +1,70 @@
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+- [Prompt Management](#prompt-management)
+  - [Directory Structure](#directory-structure)
+    - [Default Structure](#default-structure)
+    - [Custom Structure](#custom-structure)
+  - [Prompt File Formats](#prompt-file-formats)
+    - [Basic Text Prompts](#basic-text-prompts)
+    - [Available Directives](#available-directives)
+    - [Prompts with Directives](#prompts-with-directives)
+    - [ERB Template Prompts](#erb-template-prompts)
+    - [Executable Prompts](#executable-prompts)
+  - [Prompt Discovery and Search](#prompt-discovery-and-search)
+    - [Basic Search](#basic-search)
+    - [Fuzzy Search (with fzf)](#fuzzy-search-with-fzf)
+    - [Advanced Search](#advanced-search)
+  - [Prompt Organization Strategies](#prompt-organization-strategies)
+    - [By Domain/Category](#by-domaincategory)
+    - [By Complexity](#by-complexity)
+    - [By Model Type](#by-model-type)
+    - [By Workflow Stage](#by-workflow-stage)
+  - [Parameterized Prompts](#parameterized-prompts)
+    - [ERB Variables](#erb-variables)
+    - [Usage with Parameters](#usage-with-parameters)
+    - [Parameter Extraction](#parameter-extraction)
+  - [Roles and Context](#roles-and-context)
+    - [Role Definitions](#role-definitions)
+    - [Using Roles](#using-roles)
+    - [Context Layering](#context-layering)
+  - [Chat Session Checkpoints](#chat-session-checkpoints)
+  - [Prompt Workflows and Pipelines](#prompt-workflows-and-pipelines)
+    - [Simple Workflows](#simple-workflows)
+    - [Complex Pipelines](#complex-pipelines)
+    - [Conditional Workflows](#conditional-workflows)
+  - [Version Control for Prompts](#version-control-for-prompts)
+    - [Git Integration](#git-integration)
+    - [Backup and Sync](#backup-and-sync)
+    - [Versioned Prompts](#versioned-prompts)
+  - [Prompt Sharing and Collaboration](#prompt-sharing-and-collaboration)
+    - [Team Prompt Libraries](#team-prompt-libraries)
+    - [Prompt Documentation](#prompt-documentation)
+    - [Prompt Standards](#prompt-standards)
+  - [Performance and Optimization](#performance-and-optimization)
+    - [Prompt Efficiency](#prompt-efficiency)
+    - [Caching Strategies](#caching-strategies)
+    - [Batch Processing](#batch-processing)
+  - [Troubleshooting Prompts](#troubleshooting-prompts)
+    - [Debugging Tools](#debugging-tools)
+    - [Common Issues](#common-issues)
+      - [Missing Parameters](#missing-parameters)
+      - [File Not Found](#file-not-found)
+      - [Permission Errors](#permission-errors)
+  - [Advanced Prompt Techniques](#advanced-prompt-techniques)
+    - [Dynamic Prompt Generation](#dynamic-prompt-generation)
+    - [Prompt Composition](#prompt-composition)
+    - [Adaptive Prompts](#adaptive-prompts)
+  - [Best Practices](#best-practices)
+    - [Prompt Design](#prompt-design)
+    - [Organization](#organization)
+      - [Recommended Directory Structure](#recommended-directory-structure)
+    - [Performance](#performance)
+  - [Related Documentation](#related-documentation)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
 # Prompt Management
 
 AIA provides sophisticated prompt management capabilities through the PM gem, enabling you to organize, version, and efficiently use large collections of prompts.
@@ -8,15 +75,10 @@ AIA provides sophisticated prompt management capabilities through the PM gem, en
 ```
 ~/.prompts/
 ├── README.md                    # Documentation for your prompt collection
-├── roles/                       # Role definitions (LLM personality/persona)
+├── roles/                       # Role-based prompts for context setting
 │   ├── assistant.md
 │   ├── code_expert.md
 │   └── teacher.md
-├── skills/                      # Skill definitions (task instructions)
-│   ├── code-review/
-│   │   └── SKILL.md             # YAML front matter + instruction body
-│   └── summarizer/
-│       └── SKILL.md
 ├── development/                 # Development-related prompts
 │   ├── code_review.md
 │   ├── debug_help.md
@@ -57,6 +119,21 @@ Please answer this question clearly and concisely:
 Provide examples where helpful.
 ```
 
+### Available Directives
+
+Key directives available in prompt files:
+
+- `/config key value` — Set a configuration value for this prompt run
+- `/include path` — Insert the contents of a file at this point
+- `/shell command` — Execute a shell command and insert its output (prompt_manager feature, processed at load time)
+- `/ruby code` — Execute a Ruby one-liner and insert its output
+- `/next prompt_id` — Set the next prompt to run in sequence
+- `/pipeline id1,id2,...` — Define a multi-step prompt pipeline
+- `/paste` — Insert the current system clipboard contents at this point in the conversation
+- `/skill name` — Include a Claude Code skill file by name prefix match
+
+See the [Directives Reference](directives-reference.md) for the full list.
+
 ### Prompts with Directives
 ```markdown
 # ~/.prompts/code_analysis.md
@@ -297,87 +374,9 @@ Current Task:
 Please provide guidance consistent with the project architecture and your role as <%= role %>.
 ```
 
-## Skills
-
-### Roles vs Skills
-
-These two concepts work together but serve distinct purposes:
-
-| Concept | Defines | Loaded from | Injected as |
-|---------|---------|-------------|-------------|
-| **Role** | LLM *personality* — who the model is | `~/.prompts/roles/<id>.md` | First, before skills and prompt |
-| **Skill** | Task *instructions* — how to approach the work | `~/.prompts/skills/<name>/SKILL.md` | After role, before user prompt |
-
-A **role** sets the persona: "You are a senior Ruby developer with deep expertise in performance optimization."
-
-A **skill** provides procedural guidance for that persona to follow when executing the user's request: "When reviewing code, always check for: N+1 queries, missing indexes, memory leaks, and security vulnerabilities. Present findings as a prioritized list."
-
-The assembled prompt order is:
-
-```
-1. Role content        ← WHO the LLM is (personality)
-2. Skill content(s)    ← HOW to approach the task (instructions)
-3. User prompt         ← WHAT to do (request)
-4. Context files       ← supporting material
-```
-
-### Skill File Format
-
-Each skill lives in its own subdirectory under `~/.prompts/skills/`. The subdirectory must contain a `SKILL.md` file with YAML front matter followed by the skill instruction body:
-
-```markdown
----
-name: code-review
-description: Thorough code review focusing on correctness, security, and maintainability.
-user-invocable: true
-argument-hint: ["file or topic to review"]
----
-
-When reviewing code, systematically check:
-
-1. **Correctness** — Does the logic match the stated intent? Are edge cases handled?
-2. **Security** — Are there injection risks, unsafe deserialization, or exposed secrets?
-3. **Performance** — Are there N+1 queries, unbounded loops, or unnecessary allocations?
-4. **Maintainability** — Is the code readable? Are names clear? Is complexity justified?
-
-Present findings as a prioritized list with file:line references where applicable.
-Always suggest a concrete fix, not just identification of the problem.
-```
-
-The YAML front matter is metadata only. Only the body (everything after the closing `---`) is injected into the prompt.
-
-### Using Skills
-
-```bash
-# Prepend a skill before the user prompt
-aia --skill code-review review_prompt my_code.rb
-
-# Combine role + skill for maximum context
-aia --role ruby_expert --skill code-review review_prompt my_code.rb
-
-# Multiple skills (applied in order)
-aia --skill code-review --skill security-audit review_prompt my_code.rb
-aia -s code-review,security-audit review_prompt my_code.rb
-
-# List available skills
-aia --list-skills
-
-# Use a skill from within a chat session
-/skill code-review
-```
-
-### Skills in Chat Mode
-
-In chat mode, use the `/skill` directive to inject a skill at any point in the conversation:
-
-```
-> /skill summarizer
-[Skill "summarizer" instructions are injected into the next message context]
-
-> Please summarize the discussion so far.
-```
+## Chat Session Checkpoints
 
-The `/skill` directive injects only the body content of `SKILL.md` — the YAML front matter is never sent to the LLM.
+In interactive chat sessions, use `/checkpoint [name]` to save the current conversation state, `/restore [name]` to return to it, and `/checkpoints` to list all saved checkpoints. `/clear` resets the conversation entirely.
 
 ## Prompt Workflows and Pipelines
 

data/docs/security.md

@@ -1,3 +1,46 @@
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+- [Security Best Practices](#security-best-practices)
+  - [API Key Security](#api-key-security)
+    - [Storage and Management](#storage-and-management)
+    - [Key Permissions and Scope](#key-permissions-and-scope)
+    - [Key Validation and Testing](#key-validation-and-testing)
+  - [Code Execution Directives](#code-execution-directives)
+    - [/ruby Directive](#ruby-directive)
+    - [/shell Directive](#shell-directive)
+    - [ERB Processing](#erb-processing)
+  - [Prompt Security](#prompt-security)
+    - [Input Sanitization](#input-sanitization)
+    - [Prompt Injection Prevention](#prompt-injection-prevention)
+    - [Content Filtering](#content-filtering)
+  - [File System Security](#file-system-security)
+    - [Safe File Operations](#safe-file-operations)
+    - [Directory Traversal Prevention](#directory-traversal-prevention)
+  - [Network Security](#network-security)
+    - [HTTP Request Validation](#http-request-validation)
+    - [Request Rate Limiting](#request-rate-limiting)
+  - [Shell Command Security](#shell-command-security)
+    - [Command Sanitization](#command-sanitization)
+    - [Environment Variable Sanitization](#environment-variable-sanitization)
+  - [Tool and MCP Security](#tool-and-mcp-security)
+    - [Tool Access Control](#tool-access-control)
+    - [MCP Server Configuration Security](#mcp-server-configuration-security)
+    - [Environment-Specific Tips](#environment-specific-tips)
+  - [Monitoring and Auditing](#monitoring-and-auditing)
+    - [Security Logging](#security-logging)
+    - [Usage Monitoring](#usage-monitoring)
+  - [Incident Response](#incident-response)
+    - [Security Incident Detection](#security-incident-detection)
+    - [Automated Response](#automated-response)
+  - [Security Checklist](#security-checklist)
+    - [Pre-deployment Security Review](#pre-deployment-security-review)
+    - [Regular Security Maintenance](#regular-security-maintenance)
+  - [Related Documentation](#related-documentation)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
 # Security Best Practices
 
 Security considerations and best practices for using AIA safely in various environments.
@@ -72,6 +115,8 @@ The `/shell` directive executes system commands with your user permissions:
 /shell cat /path/to/file
 ```
 
+**Note**: `/shell` is a `prompt_manager` feature processed during prompt file loading, not a chat-time directive. In prompt files it executes shell commands via `//shell`. In interactive chat, use `/ruby` with backtick syntax for shell execution.
+
 **Mitigations**:
 - Same precautions as `/ruby` — only use with trusted prompts
 - Consider the implications of any shell command before running it
@@ -85,6 +130,8 @@ The current user is: <%= `whoami`.strip %>
 Today's date is: <%= Date.today %>
 ```
 
+**Note**: ERB templates are always evaluated for `.md` prompt files and cannot be disabled per-prompt. The ERB evaluation context has full access to `ENV`, Ruby's standard library, and backtick shell execution — review prompts from untrusted sources carefully.
+
 **Mitigations**:
 - Review prompt files before running them, especially from untrusted sources
 - ERB processing is always enabled and cannot be disabled per-prompt

data/docs/special_projects_guide.md

@@ -0,0 +1,386 @@
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+- [Special Projects Guide](#special-projects-guide)
+  - [Table of Contents](#table-of-contents)
+  - [Dynamic Model Switching](#dynamic-model-switching)
+    - [@mention Routing](#mention-routing)
+    - [Supported Phrases](#supported-phrases)
+    - [How It Works](#how-it-works)
+    - [Model Aliases](#model-aliases)
+    - [Custom Aliases](#custom-aliases)
+    - [Conversation History on Switch](#conversation-history-on-switch)
+  - [MCP Server Concurrency](#mcp-server-concurrency)
+    - [Configuration](#configuration)
+    - [Three Ways to Trigger](#three-ways-to-trigger)
+    - [Server Grouping](#server-grouping)
+  - [TrakFlow Integration](#trakflow-integration)
+    - [Setup](#setup)
+    - [Chat Directives](#chat-directives)
+    - [Pipeline Tracking](#pipeline-tracking)
+    - [Session Continuity](#session-continuity)
+  - [Expert Routing](#expert-routing)
+    - [Enable](#enable)
+    - [How It Works](#how-it-works-1)
+    - [Example Flow](#example-flow)
+  - [Verification Networks](#verification-networks)
+    - [Usage](#usage)
+    - [How It Works](#how-it-works-2)
+  - [Prompt Decomposition](#prompt-decomposition)
+    - [Usage](#usage-1)
+    - [How It Works](#how-it-works-3)
+  - [Session Tracking and Learning](#session-tracking-and-learning)
+    - [What's Tracked](#whats-tracked)
+    - [Learning Rules](#learning-rules)
+  - [Configuration Reference](#configuration-reference)
+    - [New Config Sections](#new-config-sections)
+    - [MCP Server Metadata Fields](#mcp-server-metadata-fields)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
+# Special Projects Guide
+
+This guide documents the advanced features implemented from the Special Projects roadmap. Each feature builds on AIA v2's architecture of RobotFactory, ChatLoop, and the directive system.
+
+## Table of Contents
+
+1. [Dynamic Model Switching](#dynamic-model-switching)
+2. [MCP Server Concurrency](#mcp-server-concurrency)
+3. [TrakFlow Integration](#trakflow-integration)
+4. [Expert Routing](#expert-routing)
+5. [Verification Networks](#verification-networks)
+6. [Prompt Decomposition](#prompt-decomposition)
+7. [Session Tracking and Learning](#session-tracking-and-learning)
+8. [Configuration Reference](#configuration-reference)
+
+---
+
+## Dynamic Model Switching
+
+Switch models mid-chat using natural language instead of the formal `/model` directive.
+
+### @mention Routing
+In a multi-model network, route a message to a specific robot by prefixing its registered name with `@`:
+```
+@tobor Explain your reasoning step by step.
+```
+Use `/robots` to see the active crew and their `@mention` handles. The mention router scans the input for `@name` tokens, matches them against robot names, and routes the prompt only to the mentioned robots.
+
+### Supported Phrases
+
+- **Switch**: "switch to claude", "use GPT-4o", "try gemini"
+- **Compare**: "compare claude and gemini", "hear from both models"
+- **Capability**: "use something cheaper", "switch to the best model"
+
+### How It Works
+
+1. The classification KB detects model-change intent
+2. `ModelSwitchHandler` extracts model names from the text
+3. Names are resolved through `ModelAliasRegistry`
+4. User is asked to confirm before switching
+5. Robot is rebuilt with the new model(s)
+
+### Model Aliases
+
+Short names, provider names, and capability descriptors all resolve to model IDs:
+
+| Alias | Resolves To |
+|-------|------------|
+| claude, sonnet | claude-sonnet-4-20250514 |
+| opus | claude-opus-4-20250514 |
+| haiku, fast | claude-haiku-4-5-20251001 |
+| gpt4, gpt4o | gpt-4o |
+| cheap, gpt4mini | gpt-4o-mini |
+| best | claude-opus-4-20250514 |
+| gemini, flash | gemini-2.0-flash |
+| llama | llama-3.1-70b |
+| anthropic | claude-sonnet-4-20250514 |
+| openai | gpt-4o |
+| google | gemini-2.0-flash |
+| meta | llama-3.1-70b |
+| coding | claude-sonnet-4-20250514 |
+| vision | gpt-4o |
+
+### Custom Aliases
+
+Add custom aliases in your config:
+
+```yaml
+# ~/.config/aia/aia.yml
+model_aliases:
+  mymodel: my-custom-model-id
+  team: our-fine-tuned-model
+```
+
+### Conversation History on Switch
+
+Control what happens to conversation history when switching models:
+
+```yaml
+model_switch_history: clean      # fresh start (default)
+model_switch_history: replay     # replay all messages to new model
+model_switch_history: summarize  # summarize and inject context
+```
+
+---
+
+## MCP Server Concurrency
+
+When a prompt needs multiple independent MCP servers, AIA can fan out to a robot-per-server and merge results.
+
+### Configuration
+
+Add `topics` to your MCP server configs for domain-driven routing:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"],
+      "topics": ["files", "code", "directory"]
+    },
+    "database": {
+      "command": "python",
+      "args": ["-m", "mcp_server_sqlite"],
+      "topics": ["data", "sql", "records"]
+    }
+  }
+}
+```
+
+### Three Ways to Trigger
+
+1. **Directive**: `/concurrent` before your prompt
+2. **Auto-detection**: Set `concurrency.auto: true` in config
+3. **Config-driven**: List independent servers in config
+
+```yaml
+# ~/.config/aia/aia.yml
+concurrency:
+  auto: true
+  independent_servers: [filesystem, database, web_search]
+  threshold: 2   # minimum independent servers to trigger
+```
+
+### Server Grouping
+
+Servers can be grouped for sequential access:
+
+```json
+{
+  "mcpServers": {
+    "db_reader": {
+      "command": "...",
+      "group": "database"
+    },
+    "db_writer": {
+      "command": "...",
+      "group": "database"
+    }
+  }
+}
+```
+
+Grouped servers run sequentially within their group; different groups run concurrently.
+
+---
+
+## TrakFlow Integration
+
+TrakFlow is a distributed task tracking system for AI agents. AIA connects to it as an MCP server.
+
+### Setup
+
+```bash
+# Add TrakFlow MCP to your AIA config
+aia --mcp mcp_servers/trak_flow.json --chat
+```
+
+### Chat Directives
+
+| Directive | Description |
+|-----------|-------------|
+| `/tasks` | Show ready tasks |
+| `/tasks summary` | Show project summary |
+| `/tf` | Alias for `/tasks` |
+| `/plan <description>` | Create a TrakFlow plan |
+| `/task <title>` | Create a single task |
+
+### Pipeline Tracking
+
+Enable automatic pipeline tracking in TrakFlow:
+
+```yaml
+flags:
+  track_pipeline: true
+```
+
+When enabled, AIA creates a TrakFlow Plan for each pipeline and updates task status as steps complete:
+
+```
+Pipeline: summarize → analyze → recommend
+
+TrakFlow Plan:
+  Step 1: summarize  → started → completed ✓
+  Step 2: analyze    → started → completed ✓
+  Step 3: recommend  → started → in_progress...
+```
+
+### Session Continuity
+
+When TrakFlow is connected and you start a chat session, AIA checks for open tasks from previous sessions:
+
+```
+Open tasks from previous sessions found:
+  - Step 4: Review auth module (blocked - needs user input)
+  - Task: Update documentation (ready)
+```
+
+---
+
+## Expert Routing
+
+Route different prompt types to specialist robots with different models and MCP servers.
+
+### Enable
+
+```yaml
+flags:
+  expert_routing: true
+```
+
+### How It Works
+
+1. The prompt is categorized by domain (code, data, image, planning)
+2. The best model for that domain is selected
+3. Relevant MCP servers are activated
+4. `ExpertRouter` builds a specialist robot with those specifics
+5. The specialist handles the prompt instead of the default robot
+
+### Example Flow
+
+```
+User: "Refactor the auth module"
+  → Classification: domain=code
+  → Model Selection: claude-sonnet (code task)
+  → MCP Routing: filesystem server activated
+  → Expert robot built with claude-sonnet + filesystem MCP
+  → Specialist handles the prompt
+```
+
+---
+
+## Verification Networks
+
+Use consensus for quality — two robots independently answer, then a third reconciles.
+
+### Usage
+
+```
+/verify
+How does quantum entanglement work?
+```
+
+### How It Works
+
+1. Two verifier robots independently answer the question
+2. A reconciler compares both answers
+3. The reconciler produces a final, verified answer noting agreements and uncertainties
+
+---
+
+## Prompt Decomposition
+
+For complex prompts, a coordinator breaks them into independent sub-tasks, executes them in parallel, then synthesizes.
+
+### Usage
+
+```
+/decompose
+Research current AI safety approaches, compare them with historical precedents,
+and recommend a framework for our team.
+```
+
+### How It Works
+
+1. The robot analyzes the prompt and identifies 2-5 independent sub-tasks
+2. Each sub-task runs separately
+3. Results are synthesized into a coherent response
+
+If the prompt cannot be meaningfully decomposed, it falls back to normal execution.
+
+---
+
+## Session Tracking and Learning
+
+AIA tracks session metrics for the post-response learning loop.
+
+### What's Tracked
+
+Per turn:
+- Model used
+- Input length
+- Token counts
+- Cost estimate
+- Routing decisions
+- Timestamp
+
+Session-wide:
+- Total turns
+- Total cost
+- Total tokens
+- Model switch events
+- User feedback signals
+
+### Learning Rules
+
+The post-response learning step fires after each response:
+
+| Rule | Signal | Meaning |
+|------|--------|---------|
+| `track_model_switch` | model_dissatisfaction | User switched models after a response |
+| `track_success` | model_success | User accepted the response |
+| `cost_tracking` | cost_update | Running cost total |
+
+These signals are currently informational. Future versions can use them to automatically adjust routing rules.
+
+---
+
+## Configuration Reference
+
+### New Config Sections
+
+```yaml
+# ~/.config/aia/aia.yml
+
+# Model aliases (custom overrides)
+model_aliases:
+  mymodel: my-custom-model-id
+
+# History mode on model switch
+model_switch_history: clean  # clean | replay | summarize
+
+# MCP concurrency
+concurrency:
+  auto: false
+  independent_servers: []
+  threshold: 2
+
+# New flags
+flags:
+  track_pipeline: false   # Track pipelines in TrakFlow
+  expert_routing: false   # Per-turn expert routing
+```
+
+### MCP Server Metadata Fields
+
+```json
+{
+  "topics": ["code", "files"],
+  "independent": true,
+  "group": "database"
+}
+```
+