Plan, execute, track, and resume - without losing state.
MissionCache keeps a living memory for every project - the plan, the decisions, the gotchas, what is left. It updates as you work, gets a snapshot before every compaction, and reloads with one command - the next session picks up exactly where this one stopped.
Not another memory plugin: task lists, time tracking, a local dashboard, and autonomous runs.
uvx missioncache-install
No uvx on your machine? It comes with uv - run pip install uv once, or see Install for other options.
Open source and MIT licensed. Everything runs on your machine, and nothing is sent anywhere - not even to us.
Start in one tool, pick it up in another - the whole project follows, with one MissionCache underneath connecting them all. Full workbench on Claude Code; project state + all 36 MCP tools everywhere.
36 tools your agent calls directly: create and load projects, save state, update tasks, log runs, record time.
wired: they write the same project files the dashboard and statusline read
Lifecycle hooks that act without being asked. The PreCompact hook snapshots your project state right before the context window compacts; session hooks track activity in the background.
wired: what the hooks save is exactly what /missioncache:load restores
Eight lifecycle slash commands, plus /whats-new installed alongside them.
wired: each command reads and writes the same three project files
A second project that shares the first one's memory. Fork a project and the parent's context file becomes the memory every lane reads. Any session can update it, and the others are told when it changed. Each fork keeps its own plan and its own tasks.
wired: memory is shared, tasks are not - nothing is copied between a parent and its forks
Usage limits with reset times, live Claude health, compact warnings, and your project's progress - one glance above the prompt.
wired: configured from the dashboard Settings, deep-links back into it
Projects, progress, per-repo time, and run history - local, at localhost:8787.
wired: fed by the hooks' heartbeats and Claude's own session logs
missioncache-auto runs a project's tasks in parallel with dependency-aware DAG scheduling.
wired: streams live into the dashboard; progress lands in the same tasks file
The context window compacts. The session ends. Tomorrow your agent greets you like a stranger, and you rebuild the whole mental model - the plan, the decisions, what is left - from scratch. Every time.
A CLAUDE.md file holds static rules. This is living project state - the plan, the decisions, the gotchas, and what is left - that updates as you work and reloads on command.
MissionCache gives each project a durable home. Watch the loop on the right: state saved before compaction, restored the next morning.
Taskmaster manages tasks. claude-mem remembers. GSD executes. No single tool does all three - MissionCache is built as the integration. And because a project is just files any MCP tool reads and writes, it is not chained to one agent:
Project state and all 36 MCP tools work in every tool. The dashboard, statusline, and autonomous runs are Claude Code today.
Not a static rules file. Every project is three human-editable files - plan, context, tasks - under ~/.missioncache/active/ that update as you work and survive session end and context compaction. /missioncache:load reloads the full state, so you pick up exactly where you left off.
MissionCache tracks heartbeats as you work and rolls them into per-project, per-repo, per-day and per-week views on a local dashboard. It even merges Claude Code's own session logs, so you always know which projects are eating your cycles.
MissionCache Auto runs a project's tasks in parallel with dependency-aware DAG scheduling, logs every attempt, and streams the whole run to the dashboard. Watch it live or walk away and read the iteration log after.
Every tool in this space does one thing. Here is the whole picture, checks and misses included.
| Capability | MissionCache | Taskmaster AI | claude-mem | GSD | Agent Teams |
|---|---|---|---|---|---|
| Project state that survives compaction | ✓ | ~ | ~ | ~ | ~task list only |
| Shared memory across parallel projects | ✓ | ~tags isolate lanes | ~global memory | – | – |
| Task checklists + dependency DAG | ✓ | ✓ | – | ~ | ~flat list |
| Per-project time tracking | ✓ | – | – | ~cost only | – |
| Local analytics dashboard | ✓ | – | ~ | – | – |
| Autonomous execution | ✓ | – | – | ✓ | ✓ |
| Whole project moves between tools | ✓plan + tasks + progress | ~tasks only, 13 IDEs | ~memory only, 7+ agents | – | – |
Full tables, with where each tool beats us, in the README. Claude Code gets the full workbench; Codex, OpenCode, and Copilot get the project state and all 36 MCP tools.
MissionCache is the only tool with per-project time tracking, a local analytics dashboard, and autonomous execution in the same place. And the only one where the whole project moves with you between tools. That is the whole point.
Five steps. Your state is safe between every one of them.
Claude walks a clarifying conversation, proposes a plan, and drops the plan / context / tasks files once you approve.
Your project files update as you work, and time is tracked in the background. The PreCompact hook auto-saves your state before the window compacts.
Reloads the plan, your decisions, the gotchas you flagged, progress, and where you left off. No reconstruction.
Optional. Hand the decomposed tasks to parallel workers and watch the DAG run on the dashboard.
Archives the project and records final time and progress stats. That is the full loop.
A live mission readout above your prompt: usage limits, Claude health, version, context, project progress - linked into the dashboard, and fully yours to shape. It even warns you before the context window forces a compaction, so you save state on your terms, not the window's.
// the actual layout, rendered as text - yours draws above the prompt
Claude session and weekly usage as percentages, each with its reset time. Opus tracked separately, Codex gets its own line when installed, and open incidents from status.claude.com surface right in the line.
Context usage with tiered warnings: "Compact recommended" at 65%, "Compact now!" at 80% - so you save state on your terms, not the window's.
Project progress as [5/12], git branch, model, tokens, a version watch with an upgrade arrow. Toggle every field from the dashboard Settings, and add your own cells.
The installer also sets up /whats-new: it reads what changed in Claude Code since you last checked and proposes tailored upgrades to your own setup, with before/after diffs.
The dashboard opens here. Work you owe, what you are waiting on from other people, and every project with something outstanding. Nothing on this page is a separate list you have to maintain - it is your project files and your action items, read together.
Action items assigned to you, plus rows in any project's Waiting on table whose Who column names you. The second kind is easy to lose: it sits in a file under someone else's heading. Marking one done writes straight back to the project file.
People are grouped by the age of what they owe you: asked this week, one to two weeks, two to four, over a month. Someone who owes you two things of different ages shows up in both groups, so a fresh ask is never hidden behind an old one.
A project earns a row by having something outstanding: an open item on you, an ask out with someone, or a due date. Each carries what is next, checklist progress, what is on you, and how long since you touched it. Filter by category, or search what you last did.
A FastAPI and vanilla-JS single-page app at localhost:8787. Active and completed projects, per-repo breakdowns, hourly heatmaps, a weekly activity view, and untracked Claude sessions shown alongside the tracked ones.
A standalone CLI that runs a project's tasks to completion in parallel. DAG scheduling respects dependencies so dependent work waits for its prerequisites. Default eight workers, or go sequential.
Building several things on the same base? A data pipeline plus a test layer for each product it feeds. A backend plus its clients. They share the setup, the access details, the gotchas you already hit - but each needs its own task list.
/missioncache:fork creates a real second project that reads the parent's context file as its shared memory. Write the shared facts once, in the parent, and every fork knows them. When one session updates the shared memory, the others are told, so nobody keeps working from a stale picture.
Pick the full workbench, or just the plugin core. Either way it is about three minutes to first value, and the machine part is under 30 seconds - measured, not promised. One session to feel it: run /missioncache:new, and your plan survives the first compaction.
uvx missioncache-installpipx run missioncache-install# or, if you prefer pipxThe interactive wizard asks which components to install (default is all): the plugin, the dashboard as a background service, the missioncache-auto CLI, the statusline, and the rule files. For a hands-off run, use --all --yes.
Requires Python 3.11+ and the Claude Code CLI. The uvx command is part of uv - if you don't have it yet, install it once:
pip install uv# or: curl -LsSf https://astral.sh/uv/install.sh | shNo Python either? Use the curl command above - it needs nothing pre-installed. And pipx works in place of uvx if you already have it.
plugin marketplace add missioncache/missioncacheplugin install missioncache@missioncacheRun these inside Claude Code, then restart the session. You get the plan / context / tasks files, /missioncache:load resume, heartbeat time tracking, and all 36 MCP tools.
CLAUDE.md is a static rules file you maintain by hand. MissionCache keeps living project state - the plan, your decisions, the gotchas you flagged, and progress - that updates as you work and reloads with one command. It complements CLAUDE.md, it does not replace it.
First, what a fork is here: a project fork, not a Claude conversation fork. It creates a real second project that shares the parent's memory (its context file) while keeping its own tasks. Fork when two efforts share one base and still need their own task lists. A data pipeline with a separate test layer per product is the normal shape. Architecture, access patterns, environment facts, the gotchas you already hit - they live once in the parent, and every fork reads them. Tasks are never copied. Start a fresh project instead when the two efforts have nothing real in common.
On your machine. Project files are plain markdown under ~/.missioncache/, and the dashboard runs locally at localhost:8787. Nothing is sent anywhere. The whole thing is local-first and self-hosted.
No. The MCP server plus the database is the minimum, and everything else is opt-in. The wizard lets you deselect the dashboard, auto, or statusline, and each package can be used on its own.
Claude Code gets the full experience. Codex, OpenCode, and VSCode Copilot Chat get the project state, the slash commands, and the 36-tool MCP suite today, with hooks, statusline, and auto tracked as a follow-up. The key part: the whole project - plan, tasks, progress, decisions - is one shared set of files, not recalled snippets, so you start in Claude Code and pick it up in Codex or OpenCode exactly where you left off.
claude-mem and similar tools recall memories into whatever agent you are in - useful, but it is context injection. MissionCache moves the whole project: the plan you approved, the task checklist with its progress, the decisions and gotchas you logged - all as human-editable files any MCP agent reads and writes. Check off a task in Codex and Claude Code sees it. It is shared project state, not recalled memory. And if you want pure long-lived cross-project memory, claude-mem is genuinely good at that - we say so in the comparison.
Yes. MissionCache is open source under the MIT license. Read the code, change it, build on it.
Partially, today. The MCP server, project files, and missioncache-auto install and run fine. The lifecycle hooks - including the compaction snapshot and session tracking - do not run on Windows yet, and dashboard service registration prints manual steps instead of automating. A Windows port is on the roadmap.
Uninstall the packages and delete ~/.missioncache. Your project files are plain markdown, so anything you want to keep, you keep. Nothing is locked in.
One command, and you never rebuild your mental model from scratch again.
uvx missioncache-install