Mission Control MCP

🚀 Mission Control MCP Server

A domain-agnostic task automation and validation system for Claude Code, enabling autonomous task execution with self-verification capabilities.

🚀 Quick Start

Mission Control is a Model Context Protocol (MCP) server for Claude Code. It's designed to automate tasks with built - in validation loops, allowing Claude to execute tasks autonomously, verify results, iterate until success, and provide detailed feedback.

✨ Features

• ✅ Zero External Dependencies: All validation runs locally.
• 🔒 Privacy-Focused: No data leaves your machine.
• ⚡ Fast: No network latency for validations.
• 🎯 Domain-Agnostic: Works across software development, DevOps, data science, and more.
• 📊 Self-Validating: Automated success/failure detection.
• 🔄 Iterative: Automatic retry with feedback.

🏗️ Architecture

Core Components

1. Mission Definer: Locks in task parameters and validation criteria.
2. Attempt Counter: Prevents infinite loops with configurable limits.
3. Dynamic Feedback Engine: Generates actionable improvement suggestions.
4. Validation Strategies: NUMERIC, EXIT_CODE, and KEYWORD validators.
5. State Manager: Tracks mission progress and history.

Workflow

┌─────────────────────────────────────────┐
│ 1. Define Mission                       │
│    - Goal description                   │
│    - Validation strategy                │
│    - Success criteria                   │
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│ 2. Execution Loop                       │
│    ┌─────────────────────────────────┐  │
│    │ Claude executes task            │  │
│    └─────────────────────────────────┘  │
│              ↓                          │
│    ┌─────────────────────────────────┐  │
│    │ Submit attempt for validation   │  │
│    └─────────────────────────────────┘  │
│              ↓                          │
│    ┌─────────────────────────────────┐  │
│    │ System validates result         │  │
│    └─────────────────────────────────┘  │
│              ↓                          │
│        Pass? ─No→ Retry with feedback   │
│          │                              │
│         Yes                             │
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│ 3. Mission Complete                     │
│    - Success report                     │
│    - Attempt history                    │
└─────────────────────────────────────────┘

📦 Installation

Prerequisites

• Node.js >= 18.0.0
• npm or yarn
• Claude Code CLI

Option 1: NPM Installation (Recommended)

Install globally via npm:

npm install -g mission-control-mcp

Then add to Claude Code:

claude mcp add mission-control mission-control-mcp

Or configure manually: Configuration file location:

• macOS/Linux: ~/.config/claude-code/mcp.json
• Windows: %USERPROFILE%\.claude-code\mcp.json

{
  "mcpServers": {
    "mission-control": {
      "command": "mission-control-mcp",
      "env": {
        "MCP_ENABLE_PERSISTENCE": "true"
      }
    }
  }
}

Option 2: Using npx (No Installation)

claude mcp add mission-control --transport stdio -- npx -y mission-control-mcp

Option 3: From Source (Development)

# Clone the repository
git clone https://github.com/ufo23005/mission-control-mcp.git
cd mission-control-mcp

# Install dependencies
npm install

# Build the project
npm run build

Configure Claude Code: Configuration file location:

• macOS/Linux: ~/.config/claude-code/mcp.json
• Windows: %USERPROFILE%\.claude-code\mcp.json

{
  "mcpServers": {
    "mission-control": {
      "command": "node",
      "args": ["<path-to-installation>/mission-control-mcp/dist/index.js"],
      "env": {
        "MCP_STATE_DIR": "<path-to-installation>/mission-control-mcp/.state",
        "MCP_ENABLE_PERSISTENCE": "true"
      }
    }
  }
}

Verify Installation

claude mcp list
# Should show mission-control in the list with ✓ Connected status

💻 Usage Examples

Validation Strategies

1. NUMERIC - Number Comparison

For tasks with measurable numeric goals (performance metrics, coverage, scores).

Example: Test Coverage

// Define mission
{
  "goal": "Increase test coverage to 80%",
  "strategy": "NUMERIC",
  "criteria": {
    "operator": ">=",
    "threshold": 80.0,
    "metricName": "coverage_percentage"
  },
  "maxAttempts": 10
}

// Submit attempt
{
  "missionId": "<mission-id>",
  "output": "Coverage: 82.5%",
  "value": 82.5
}

Operators: >, <, >=, <=, ==, !=

2. EXIT_CODE - Command Status

For tasks validated by command execution success.

Example: Linting

// Define mission
{
  "goal": "Fix all ESLint errors",
  "strategy": "EXIT_CODE",
  "criteria": {
    "expectedCode": 0,
    "command": "npm run lint"
  },
  "maxAttempts": 8
}

// Submit attempt
{
  "missionId": "<mission-id>",
  "output": "Linting complete",
  "value": 0  // exit code
}

3. KEYWORD - Text Matching

For tasks validated by output content.

Example: Build Success

// Define mission
{
  "goal": "Successful production build",
  "strategy": "KEYWORD",
  "criteria": {
    "keyword": "Build completed successfully",
    "mustContain": true,
    "caseSensitive": false
  }
}

// Submit attempt
{
  "missionId": "<mission-id>",
  "output": "Build completed successfully. Output: dist/"
}

📚 Documentation

MCP Tools

define_mission

Define a new automation task with validation criteria. Parameters:

• goal (string): Natural language task description.
• strategy (enum): NUMERIC | EXIT_CODE | KEYWORD.
• criteria (object): Strategy - specific validation parameters.
• maxAttempts (number, optional): Maximum retry limit (default: 10).
• enableCheckpoints (boolean, optional): Enable recovery checkpoints.
• checkpointFrequency (number, optional): Checkpoint every N attempts. Returns: Mission ID and configuration.

submit_attempt

Submit a task execution result for validation. Parameters:

• missionId (string): Mission identifier.
• output (string): Command/process output.
• value (number|string, optional): Extracted validation value. Returns: Validation result with feedback and next steps.

get_mission_status

Query current mission progress and history. Parameters:

• missionId (string): Mission identifier. Returns: Status, attempt count, and history.

abort_mission

Manually stop a running mission. Parameters:

• missionId (string): Mission identifier.
• reason (string, optional): Abort reason. Returns: Confirmation and final status.

Examples

Example 1: Fix ESLint Errors

$ claude "Fix all ESLint errors. Use define_mission with EXIT_CODE strategy, then iterate until npm run lint returns 0."

Claude will:

1. Call define_mission with EXIT_CODE criteria (expectedCode: 0).
2. Analyze code and fix errors.
3. Run npm run lint.
4. Call submit_attempt with exit code.
5. Repeat until successful or max attempts.

Example 2: Optimize Performance

$ claude "Reduce API response time below 100ms. Validate with local benchmark tests."

Claude will:

1. Define mission with NUMERIC strategy (< 100).
2. Make optimizations.
3. Run benchmark tests.
4. Submit results.
5. Iterate based on feedback.

Example 3: Documentation Compliance

$ claude "Ensure all public functions have JSDoc comments. Check with custom validator."

Claude will:

1. Define mission with KEYWORD or custom validation.
2. Add missing documentation.
3. Run documentation checker.
4. Verify completeness.

🔧 Technical Details

Configuration

State Management

The orchestrator maintains state in .state/ directory:

.state/
├── missions/       # Active and completed missions
└── checkpoints/    # Recovery checkpoints

Retention Policies

• Completed missions: 30 days (configurable).
• Failed missions: 90 days (for analysis).
• Active missions: Retained until completion.

Resource Limits

Default limits (configurable in code):

• Max attempts: 10.
• Checkpoint frequency: Every 5 attempts.
• Attempt timeout: None (per - mission configurable).

Project Structure

src/
├── index.ts              # MCP server entry point
├── types/                # TypeScript type definitions
│   ├── mission.ts        # Mission and attempt types
│   ├── validation.ts     # Validation strategy types
│   └── state.ts          # State management types
├── core/                 # Core components
│   ├── MissionDefiner.ts # Mission configuration
│   ├── AttemptCounter.ts # Retry management
│   └── FeedbackEngine.ts # Feedback generation
├── validators/           # Validation strategies
│   ├── BaseValidator.ts
│   ├── NumericValidator.ts
│   ├── ExitCodeValidator.ts
│   └── KeywordValidator.ts
├── state/                # State management
│   └── StateManager.ts   # Mission state tracking
├── tools/                # MCP tool implementations
│   ├── defineMission.ts
│   ├── submitAttempt.ts
│   ├── getMissionStatus.ts
│   └── abortMission.ts
└── utils/                # Utilities
    ├── logger.ts         # Logging system
    └── errors.ts         # Error types

Use Cases

🔒 Privacy & Security

• No external APIs: All validation runs locally.
• No data transmission: Everything stays on your machine.
• No network required: Works completely offline.
• Audit logging: Complete attempt history.
• Configurable limits: Prevent resource exhaustion.

🚧 Limitations

Suitable For

• Objectively measurable outcomes.
• Repeatable operations.
• Automatable verification.
• Local command - line tools.

Not Suitable For

• Subjective quality judgments.
• One - time irreversible operations.
• Tasks requiring human creativity.
• Real - time interactive processes.

🤝 Contributing

Contributions welcome! Please ensure:

• All TypeScript types are defined.
• Code follows existing patterns.
• Tests pass (when implemented).
• Documentation updated.

📄 License

MIT

📚 References

• Model Context Protocol - MCP specification
• Claude Code MCP - Claude Code MCP documentation