MCP Continuation Notes
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Continuation Notes Write a continuation note for the ai-assistant project."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Continuation Notes
MCP server for managing continuation notes with automatic session handoff capabilities.
π― Purpose
This MCP server implements the Continuation Note Protocol as code, providing:
Project-specific continuation notes stored in project directories
Session handoff mechanism through a standard location
Built-in protocol enforcement ensuring consistent note structure
Historical browsing of project continuation notes
Related MCP server: ai-cortex
ποΈ Architecture
Two-Location System
Project Storage:
{project}/continuation-notes/continuation-{timestamp}.mdHandoff Location:
/Users/bard/Code/claude-brain/data/continuation-note-latest.md
Workflow
Write: Save to project + copy to handoff location
Read: Startup reads from handoff location
Cleanup: Delete from handoff (original stays in project)
Browse: View project history anytime
π οΈ Tools
continuation_write
Creates a continuation note following the built-in protocol structure.
Required Parameters:
project: Project nameproject_path: Full path to project directoryphase: Current project phasestatus: Current statuscontext_bridge: Context for next session
Optional Parameters:
completion_percentage: 0-100major_achievements: Array of achievementsnext_actions: Array of next actionscritical_factors: Array of success factorstesting_criteria: Array of validation criteriaadditional_content: Extra content
continuation_read_and_cleanup
Reads the handoff note and deletes it (for startup processing).
continuation_check_handoff
Checks if a handoff note exists without reading it.
continuation_list_for_project
Lists all continuation notes for a specific project.
continuation_read_project_note
Reads a specific continuation note from project directory.
π¨ Protocol Implementation
The server automatically generates notes with this structure:
# π Continuation Note - {project} - {date}
## π― Session Status Dashboard
**Project**: {project}
**Phase**: {phase}
**Status**: {status}
**Completion**: {percentage}%
### β
Major Achievements This Session
- Achievement 1
- Achievement 2
## π Context Bridge for Next Session
{context_bridge}
## π Next Actions
- Action 1
- Action 2
### Critical Success Factors
- Factor 1
- Factor 2
## π― Session Continuity
Expected behavior on restart...π§ Installation
Add to your MCP client configuration:
{
"mcpServers": {
"mcp-continuation-notes": {
"command": "node",
"args": ["/Users/bard/Code/mcp-continuation-notes/src/index.js"],
"disabled": false
}
}
}π Usage Example
// Write a continuation note
continuation_write({
project: "brain-system-protocol-execution-integration",
project_path: "/Users/bard/Code/claude-brain",
phase: "Phase 9 - Testing Enhanced Startup",
status: "Ready for validation",
completion_percentage: 85,
major_achievements: [
"Built MCP continuation notes server",
"Implemented protocol as code",
"Created two-location architecture"
],
context_bridge: "MCP server built and ready for testing. Next session should validate the handoff mechanism.",
next_actions: [
"Test continuation_read_and_cleanup",
"Validate project storage",
"Add to Claude Desktop config"
],
critical_factors: [
"Handoff note should be automatically processed",
"Project notes should remain for browsing",
"Protocol structure should be enforced"
]
})
// Check for handoff note (at startup)
continuation_check_handoff()
// Read and process handoff note (at startup)
continuation_read_and_cleanup()
// Browse project history
continuation_list_for_project({
project_path: "/Users/bard/Code/claude-brain"
})π Benefits
β Protocol as Code: No separate protocol document to maintain
β Consistent Structure: Every note follows the same format
β Project History: All notes archived per-project
β Clean Handoffs: Single location for session transitions
β Self-Documenting: Tool parameters define the protocol
π Integration
This server is designed to integrate with:
Brain System: Enhanced startup protocol
Project Management: Brain Manager project context
Session Continuity: Seamless session transitions
Status: Ready for testing and integration
Available Tools
7 toolscontinuation_check_handoffB
Check if a continuation note exists at handoff location with staleness info
Inputs: stale_threshold_hours.
continuation_cleanup_oldA
Delete an old continuation note. READ IT FIRST -- this is destructive and the note is the only copy. Normally you do not need this at all: continuation_write replaces the note, and continuation_read_and_cleanup does the read-then-delete in the right order.
Inputs: no named parameters.
continuation_list_for_projectA
List the continuation notes that exist for one project. Use it when you are not sure a note exists -- a note that is ABSENT and a note that is STALE look the same from the outside, and acting on a stale one has repeatedly caused work to be planned around bugs that were already fixed.
Inputs: project_path (required), limit.
continuation_read_and_cleanupA
Read continuation note from handoff location and delete it (deprecated - use continuation_read_with_staleness)
Inputs: no named parameters.
continuation_read_project_noteA
Read one continuation note without deleting it. CHECK ITS DATE AGAINST THE ACTUAL REPO before trusting it: a note is a claim ABOUT the code, not the code. Notes here have been hours to days out of date and described files that no longer existed. Prefer continuation_read_with_staleness, which tells you how old it is.
Inputs: filename (required), project_path (required).
continuation_read_with_stalenessA
Read continuation note with staleness detection (does not delete until new note written)
Inputs: stale_threshold_hours.
continuation_writeA
Write the handoff note for the NEXT session, in this project. Write it BEFORE context runs out, not when you notice it is running out -- the note is the only thing that survives, and a session that dies mid-thought leaves nothing. project_path is REQUIRED and a missing one is the usual reason a write fails silently. Record what is UNFINISHED and what was learned the hard way; a note that only lists accomplishments is the one that gets a future session to redo work or act on a wrong assumption.
Inputs: phase (required), status (required), project (required), project_path (required), +7 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogβ¦
TDQS
Scored across 7 tools
Tools are mostly distinct: write, read (three variants), delete, check, list. The three read tools overlap slightly, but their intended use cases are clearly described (read-and-cleanup, read-with-staleness, read-without-staleness) and one is deprecated, reducing ambiguity.
All tool names follow a consistent pattern: continuation_ prefix plus a verb phrase (write, read_and_cleanup, read_with_staleness, cleanup_old, check_handoff, list_for_project, read_project_note). The naming is perfectly uniform and predictable.
With 7 tools, the server is well-scoped for the single purpose of managing continuation notes. Each tool serves a clear lifecycle function (write, read, check, list, delete) without bloat or redundancy.
The tool set covers the full continuationβnote lifecycle: creation (write), retrieval (read variants), existence checking, listing for a project, and deletion. No obvious gaps exist; the write tool replaces previous notes, so an explicit update is unnecessary.
Maintenance
Related MCP Connectors
Pick up where you left off: your project's progress, decisions and notes, kept in your own storage.
Persistent memory layer that saves and recalls your project context and preferences.
A notebook your coding agents write to: notes that track the code's commit, and handoffs.
Project memory, documentation and controlled secret access for AI coding agents.
Related MCP Servers
- AlicenseAqualityNot gradedmaintenanceProvides centralized knowledge management for projects, allowing users to store, search, and maintain project-specific knowledge that persists across sessions.2714 npm1-
- AlicenseNot gradedqualityBmaintenanceProvides durable project context for coding agents, including project maps, session history, and explicit memories, all stored locally.143 npm7MIT
- AlicenseAqualityCmaintenanceEnables AI coding agents to hand off in-progress work across sessions and different MCP clients by persisting shared state and handoff notes in a project folder.6MIT
- AlicenseNot gradedqualityBmaintenanceEnables agent sessions to persist and reload project-scoped handoffs and todos across sessions, preserving context and tracking next steps.MIT