# Claude Mission Control

> Local-first MCP workspace for Claude Desktop — structured project tools plus a truthful low-poly robot-office visualization. Built end-to-end by Claude.

- **Type:** MCP server
- **Install:** `agentstack add mcp-wyzd0m-claude-mission-control`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [wyzd0m](https://agentstack.voostack.com/s/wyzd0m)
- **Installs:** 0
- **Category:** [Databases](https://agentstack.voostack.com/c/databases)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [wyzd0m](https://github.com/wyzd0m)
- **Source:** https://github.com/wyzd0m/claude-mission-control

## Install

```sh
agentstack add mcp-wyzd0m-claude-mission-control
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Claude Mission Control

A local-first project workspace for Claude Desktop. Claude gets structured tools for projects,
tasks, decisions, checkpoints, and handoffs; you get a dashboard with a low-poly isometric
office where a fleet of three named robots — OTTO, PIP, and HEX — truthfully acts out every
Mission Control operation.

> **Status:** Version 0.2.0. All ten build phases complete plus the full post-v1 polish round;
> installed and verified on Claude Desktop (Windows 11). Independent portfolio project — not
> affiliated with or endorsed by Anthropic.

https://github.com/user-attachments/assets/78a83311-fa42-4546-b5b3-c91fc70cfac8

- **One-click install** — a single `.mcpb` file. No API key, no Node/Python, no config editing.
- **Local-first** — everything lives in a SQLite database in your user profile. No cloud, no
  telemetry, no network access.
- **Truthful by construction** — the visualization renders only persisted tool events and saved
  project state. It never claims to show Claude's reasoning, and unknown progress stays unknown.

## What it does

Ask Claude things like:

> "Create a project called Demo with the goal of shipping v1, and plan the first tasks."
> "Record the decision to use SQLite, with the alternatives we discussed."
> "Save a checkpoint so we can continue tomorrow." — then, in a new conversation:
> "Get the latest checkpoint and prepare the project context."

Claude uses 29 Mission Control tools; every call becomes a persisted activity event. The
dashboard (opened with _"open Mission Control"_) shows the project header and stage bar, an exact
activity panel, an event timeline, task/decision/checkpoint views — and the facility, where
robots dispatch from the Command Core, roll to the department that matches the operation,
perform its work gesture (filing a cartridge, stamping a review, packing an export…), and hold
at the Security Gate whenever a bulk or destructive change needs your approval — which you can
grant right on the waiting card.

Try the layout in a plain browser: `npm run build:dashboard`, then
`node poc/scripts/serve-dashboard.mjs` and open `http://localhost:5181/?demo` (clearly labeled
sample data). Open `/?test` instead for animation test mode: continuous synthetic events keep
the robot fleet travelling, working, and holding at the gate so every animation can be
inspected. A ready-to-import example project lives in
[`examples/demo-project.json`](examples/demo-project.json).

## Monitor window

Want Mission Control visible the whole time Claude works, outside the chat?

**Easiest (Windows):** double-click **`start-monitor.cmd`** in this folder, or create a desktop
shortcut to it (the first run installs dependencies and builds the dashboard, then every run just
opens the window). Keep the black console window open while you want the monitor running; close it
to stop.

**From a terminal (any platform):**

```bash
npm run monitor
```

Either way, a **read-only monitor window** opens in your browser at `http://127.0.0.1:8642/?monitor`
(loopback only). It reads the shared local database directly and live-updates as Claude uses
Mission Control tools — independent of Claude Desktop's conversation lifecycle, so it stays up
across restarts and new chats. Changes are made in the conversation; the monitor is a pure
observer.

Keep it on a second screen and add a line like _"keep Mission Control updated as you work"_ to your
projects' instructions so the facility reflects progress continuously. (`CMC_MONITOR_PORT` changes
the port; `--no-open` skips launching the browser.)

## Install

See [`docs/INSTALL.md`](docs/INSTALL.md). Short version: build with `npm run release`, then in
Claude Desktop go to Settings → Extensions → Advanced settings → Install Extension and pick
`dist/claude-mission-control.mcpb`.

## Architecture

```mermaid
flowchart TD
    A[Claude Desktop host] -->|"MCP (stdio)"| B[MCP adapter\n29 tools, thin]
    B --> C[Application services\nprojects · tasks · records · context · import/export]
    C --> D[Domain core\nrules + Zod schemas\nframework-free]
    C --> E[(SQLite\nnode:sqlite, migrations,\npre-upgrade backups)]
    B --> F[Activity event service\nqueued → working → terminal\napproval waits · projections]
    F --> E
    B --> G[UI state projection\nDashboardState read model]
    G --> H[React dashboard\nMCP App, single HTML file]
    H --> I[Facility renderer\npure SceneState + animator\nThree.js / R3F]
```

- **Domain core** (`packages/domain`) — records, rules, and the event state machine. Imports no
  framework; ESLint fails the build if it tries.
- **Server** (`packages/server`) — application services, SQLite storage, the activity/event
  layer, and the MCP adapter. Every tool validates input and returns a stable
  `{ ok, error: { code, message, recovery } }` contract.
- **UI** (`packages/ui`) — the dashboard and the 3D facility. It receives a read-only projection
  and animates a pure, unit-tested scene state; ambient motion is never presented as work.

Key architectural decisions are recorded in [`docs/DECISION_LOG.md`](docs/DECISION_LOG.md)
(D-001 through D-033). The eight end-to-end workflows are documented in
[`docs/WORKFLOWS.md`](docs/WORKFLOWS.md).

## Honesty model

The facility is an interface for verified events, not an AI mind reader
([`docs/MCP_OBSERVABILITY_MODEL.md`](docs/MCP_OBSERVABILITY_MODEL.md)):

- Rooms activate only for persisted Mission Control events; idle says
  _"Waiting for the next observable Mission Control activity."_
- Progress appears only when an operation explicitly reports countable steps, or as
  _project_ progress computed from saved task data.
- Failures stay visible with their exact stable error code; cancellation is distinct from
  success and failure.
- A preview is never shown as completed work — it waits, amber, at the Security Gate.

## Polish goals (planned, tracked in Mission Control itself)

- macOS hardware verification.

## Known limitations

- **Host compatibility moves fast.** MCP Apps support in Claude Desktop is new; re-verify after
  app updates (an earlier host version did not surface extension tools in chat — documented in
  [`poc/README.md`](poc/README.md)).
- The monitor window reacts in well under a second (SSE push, D-032); the in-chat widget polls
  every 2.5 seconds because MCP hosts expose no push channel. Fast consecutive operations are
  replayed sequentially by the robot fleet (queue capped; the timeline is always authoritative).
- Approve/Reject buttons live in the in-chat dashboard. The monitor stays read-only by
  construction (D-025), so it shows pending approvals but points at the conversation or widget.
- macOS is expected to work (no native dependencies) but has not been tested on hardware.

## Development

```bash
npm install
npm run verify     # typecheck + lint + format + 181 tests
npm run release    # build bundle + stdio smoke test + pack .mcpb
npm run monitor    # standalone read-only monitor window
npm run mcp:inspect  # interactive tool testing with MCP Inspector
```

Full guide: [`docs/DEVELOPMENT.md`](docs/DEVELOPMENT.md). CI runs the whole pipeline — including
a smoke test that drives the packed bundle exactly the way Claude Desktop launches it — on
Windows and Linux.

## Project documentation

| Document                                                             | Purpose                         |
| -------------------------------------------------------------------- | ------------------------------- |
| [`docs/PROJECT_BRIEF.md`](docs/PROJECT_BRIEF.md)                     | Approved product brief          |
| [`docs/PRODUCT_REQUIREMENTS.md`](docs/PRODUCT_REQUIREMENTS.md)       | Version 1 scope                 |
| [`docs/SYSTEM_ARCHITECTURE.md`](docs/SYSTEM_ARCHITECTURE.md)         | Modules and data flow           |
| [`docs/VISUAL_DESIGN.md`](docs/VISUAL_DESIGN.md)                     | Facility and UI design          |
| [`docs/MCP_OBSERVABILITY_MODEL.md`](docs/MCP_OBSERVABILITY_MODEL.md) | What may be displayed           |
| [`docs/TOOL_AND_EVENT_MODEL.md`](docs/TOOL_AND_EVENT_MODEL.md)       | Tool and event contracts        |
| [`docs/WORKFLOWS.md`](docs/WORKFLOWS.md)                             | End-to-end scenarios            |
| [`docs/INSTALL.md`](docs/INSTALL.md)                                 | Install, update, uninstall      |
| [`docs/DEVELOPMENT.md`](docs/DEVELOPMENT.md)                         | Developer guide                 |
| [`docs/DECISION_LOG.md`](docs/DECISION_LOG.md)                       | Architectural decisions         |
| [`docs/IMPLEMENTATION_ROADMAP.md`](docs/IMPLEMENTATION_ROADMAP.md)   | The ten build phases            |
| [`docs/PORTFOLIO_NOTES.md`](docs/PORTFOLIO_NOTES.md)                 | Resume bullets, interview notes |
| [`CHANGELOG.md`](CHANGELOG.md)                                       | Release notes                   |

## How this was built

The entire codebase — domain model, MCP server, procedural 3D scene, tests, CI, packaging —
was written end-to-end by Claude, working under the engineering contract in
[`CLAUDE.md`](CLAUDE.md) and a ten-phase roadmap with a human review stop at every phase
boundary. The repository doubles as a record of that collaboration:

- [`CLAUDE.md`](CLAUDE.md) — the standing contract: truthfulness rules, engineering standards,
  scope exclusions, and the phased method.
- [`docs/DECISION_LOG.md`](docs/DECISION_LOG.md) — all 33 architectural decisions with
  rationale and rejected alternatives, written as the decisions were made.
- [`docs/IMPLEMENTATION_ROADMAP.md`](docs/IMPLEMENTATION_ROADMAP.md) — the phases, from a
  disposable platform proof ([`poc/`](poc/README.md), which caught a real host limitation
  before any product code existed) through packaging and polish.
- Mission Control was used to manage its own development: the polish goals lived as tasks in a
  Mission Control project, and the robots animated their own feature work as it shipped.

Each phase ended with tests green, CI green (Windows + Linux), and a review stop. Details for
reviewers: [`docs/PORTFOLIO_NOTES.md`](docs/PORTFOLIO_NOTES.md).

## License

[MIT](LICENSE)

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [wyzd0m](https://github.com/wyzd0m)
- **Source:** [wyzd0m/claude-mission-control](https://github.com/wyzd0m/claude-mission-control)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-wyzd0m-claude-mission-control
- Seller: https://agentstack.voostack.com/s/wyzd0m
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.