WAKE Protocol

WAKE MCP Server

Will-Aware Knowledge Execution - A post-mortem protocol for AI agents.

23 tools · SQLite + AES-256-GCM encryption · Token auth

Quick Start

# From source
pnpm install && pnpm run build
pnpm start              # stdio + dashboard on :3000
pnpm run start:http     # dashboard only (no stdio)
pnpm test               # 69 tests

# npx (no install needed)
npx wake-mcp-server
npx wake-mcp-server --http

# Global install
npm i -g wake-mcp-server
wake-mcp-server
wake-mcp-server --http

# Docker
docker build -t wake-mcp-server .
docker run -p 3000:3000 -v wake-data:/app/data wake-mcp-server

Connect Your Agent

Warp / Claude Desktop / Cursor — same config, different file locations:

Client	Config file
Warp	Settings → MCP
Claude Desktop	claude_desktop_config.json (under mcpServers)
Cursor	.cursor/mcp.json (under mcpServers)

Using npx (recommended):

{
  "wake-protocol": {
    "command": "npx",
    "args": ["wake-mcp-server"]
  }
}

Or with a local build:

{
  "wake-protocol": {
    "command": "node",
    "args": ["<path>/wake-mcp-server/build/index.js"]
  }
}

Any MCP client over HTTP:

http://localhost:<port>/mcp

Default port is 3000. If taken, auto-increments. Set WAKE_PORT to override. Check the console output for the actual URL.

Agent Skill

SKILL.md — platform-agnostic instructions that teach any agent how to use WAKE:

• Owner — auto-heartbeat, conversational will setup, proactive knowledge contribution
• Verifier — death confirmation handling
• Beneficiary — tier-scoped access, final messages, handoff packages
• Executor — EULOGY management, legal export, terminal state, data purge

Point your agent at SKILL.md or include it in your system prompt.

Protocol

ACTIVE → VIGIL → EULOGY → REST

• ACTIVE — Owner alive. Agent calls heartbeat each interaction.
• VIGIL — Inactivity threshold exceeded. Awaiting verifier confirmation.
• EULOGY — Succession executing. Tiered access, Black Box, final messages.
• REST — Terminal state (archive/distill/delete). Protocol complete.

Authentication

Tokens generated once during configure_will. Three types:

• Master — owner operations (heartbeat, configure, vigil)
• Verifier — death confirmation only
• Beneficiary — per-person, scoped by tier (executor/beneficiary/memorial)

Tokens stored as SHA-256 hashes. State encrypted with AES-256-GCM (server key).

Tools

Will Management

Tool	Auth	Phase	Description
configure_will	none	any	Create will, generate all tokens
update_will	master	ACTIVE	Modify will fields
heartbeat	master	ACTIVE	Signal owner is alive
get_status	optional	any	Protocol status (detailed with token)

Protocol Progression

Tool	Auth	Phase	Description
trigger_vigil	master	ACTIVE	Manually force VIGIL
verify_death	verifier	VIGIL	Confirm death event
execute_terminal_state	executor	EULOGY	Execute archive/distill/delete

Data Access

Tool	Auth	Phase	Description
get_access_tier	any token	any	Check token holder's tier
get_final_message	any token	EULOGY/REST	Retrieve final message (time-lock aware)
get_black_box	any token	EULOGY/REST	Compiled knowledge, tier-scoped
get_audit_log	executor	any	Full audit trail

Knowledge

Tool	Auth	Phase	Description
contribute_knowledge	master	ACTIVE	Add knowledge entry (category, summary, details)
list_knowledge	master	ACTIVE	List entries, optional category filter
delete_knowledge	master	ACTIVE	Remove an entry

Inter-Agent Handoff

Tool	Auth	Phase	Description
initiate_handoff	executor	EULOGY/REST	Generate handoff package for a beneficiary
get_handoff_package	any token	EULOGY/REST	Self-serve handoff (wake-handoff-v1 JSON)

Backup & Recovery

Tool	Auth	Phase	Description
export_will	executor	any	Export encrypted state blob
import_will	none	any	Import from exported blob
list_backups	executor	any	List auto-backup snapshots
restore_backup	executor	any	Restore from backup

Legal & Compliance

Tool	Auth	Phase	Description
export_legal_will	executor	any	RUFADAA-compatible legal document
purge_owner_data	executor	REST	Permanently delete all data (right to be forgotten)
get_deletion_certificate	none	any	Retrieve deletion certificate after purge

Key Features

• Multi-user — ownerId param on every tool, independent state per owner
• Auto-backup — previous state saved on every write, last 5 kept
• Background monitor — checks heartbeat staleness every 5 min, auto-triggers VIGIL
• Dead man's switch — auto-escalates VIGIL → EULOGY if verifier doesn't respond
• Webhooks — fire on vigil.triggered, eulogy.started, eulogy.message, rest.executed, timelock.released
• Time-locks — releaseAfter on messages and knowledge entries, sealed until date
• Redaction filtering — entries matching redaction categories hidden from all tiers
• Tier-scoped Black Box — executor sees all, beneficiary sees finances/contacts/documents, memorial sees curated entries only
• No-resurrection directive — enforceable flag propagated to handoffs and certificates
• Jurisdiction mapping — legal export maps to applicable laws (RUFADAA, GDPR, ELVIS Act, etc.)
• Deletion certificate — SHA-256 attested record, sole survivor of data purge

Dashboard

Web UI at http://localhost:3000. Role-based views:

• Login — paste any token, auto-detects role
• Owner — status, knowledge CRUD, heartbeat, VIGIL trigger, legal export
• Verifier — status, death confirmation
• Executor — Black Box, messages, audit, terminal state, handoff, purge
• Beneficiary/Memorial — tier-scoped Black Box, messages

Set WAKE_PORT=8080 to change the port.

Data

SQLite database at data/wake.db. Server encryption key at data/.server-key. Deletion certificates at data/deletion-certificate-*.json.

Delete the data/ directory to reset everything.

Deploy

One-click:

CLI:

# Railway
railway init && railway up

# Fly.io
fly launch       # creates app + volume
fly deploy

# Docker
docker build -t wake-mcp-server .
docker run -p 3000:3000 -v wake-data:/app/data wake-mcp-server

Docker Compose:

services:
  wake:
    build: .
    ports: ["3000:3000"]
    volumes: ["wake-data:/app/data"]
volumes:
  wake-data:

Config files included: railway.toml, fly.toml, vercel.json, Dockerfile.

Note: Vercel is serverless — SQLite won't persist. Use Railway or Fly for production.