You spend 20 minutes rebuilding context every time you open a new Claude Code or Cursor session. The architecture decision from last week? Gone. The task you were halfway through? Lost. The rationale behind that weird except: pass you left as a TODO? Your future self will curse past you.

I built nodestone — a project context memory engine that lives alongside your repo. It remembers decisions, tasks, and architecture drift across AI sessions, regardless of which agent you're using. One command, and your agent picks up exactly where it left off.

How it works in practice

Install:

pip install nodestone

Start a session:

nodestone start "Refactor auth middleware to use JWT"

nodestone creates a compressed context pack (~500 tokens) that captures: active tasks, recent decisions, detected drift between plan and code, and milestone status. Your agent receives this as system context on the next session. Full files stay on disk — only the signal travels.

Concrete example: the drift detector

Say you planned a three-phase refactor but your teammate hotfixed a core module mid-stream. You won't notice until CI breaks. nodestone's drift detection compares actual file changes against your plan:

nodestone plan check
# Output: DRIFT DETECTED: src/auth/jwt.py modified outside planned scope
#         Expected: src/auth/middleware.py, tests/test_auth.py
#         Actual:   src/auth/jwt.py (unplanned), src/auth/middleware.py

It flags the mismatch before you waste hours debugging.

Features you can use today

• Decision journal — records not just what changed, but why. Every agent sees the rationale.
• Task tracking — dependencies, PERT durations, critical path analysis. Know which task is blocking everything.
• OR-Tools CP-SAT scheduler — optimal task ordering with resource constraints. This isn't a toy todo list.
• Fingerprint handoff — zero-loss context transfer between Claude Code, Cursor, Gemini, or any AI tool that reads from stdin or a file.
• Trigger system — auto-actions on state changes: webhooks, CLI commands, MCP tool calls.
• Keystone/milestone model — break projects into mini-phases with clear completion criteria.

Where it falls short (honest trade-offs)

• Single-user today. Multi-user shared context is on the roadmap but not here yet.
• Git-centric. It reads git state and file hashes. Non-git projects won't benefit from drift detection.
• Requires buy-in. Your agent needs to read the context pack. If you switch between agents, you need the same nodestone context command in your session starter.
• No IDE plugin yet. CLI and MCP tool only for now. Cursor and VS Code extensions are planned.

Why not just use git commit messages?

Git tells you what changed. nodestone tells you why you changed it, what you were about to do next, and whether reality matches the plan. They complement each other — commit messages record history, nodestone maintains forward context.

Why not just use ChatGPT memory?

ChatGPT memory is per-chatbot. nodestone is per-project. It works across Claude, Cursor, Gemini, and any future agent. Your context follows the repo, not the chat window.

nodestone is free and open-source. pip install nodestone — check it out at deepstrain.dev or the GitHub repo.

I'd love to hear what's missing for your workflow. What would make context persistence actually work for your team?