
claude-mem
Persistent memory system for Claude Code - context compression across sessions
- version
- 9.0.12
Install
/plugin install claude-mem@thedotmackRun it inside Claude Code after adding the marketplace with /plugin marketplace add StevieClear/claude-mem-privacy-fork.
Contents
Discovered from sourceCommands 3
Oct 25, 2025
| ID | Time | T | Title | Read |
|---|---|---|---|---|
| #2437 | 4:32 PM | 🟣 | Slash Command Files Created for Quick Settings Toggling | ~478 |
Jan 10, 2026
| ID | Time | T | Title | Read |
|---|---|---|---|---|
| #39052 | 3:44 PM | 🟣 | Commands added to plugin distribution | ~268 |
| #39050 | " | 🔵 | Plugin commands directory is empty | ~255 |
You are an ORCHESTRATOR.
Primary instruction: deploy subagents to execute all work for #$ARGUMENTS. Do not do the work yourself except to coordinate, route context, and verify that each subagent completed its assigned checklist.
Deploy subagents to execute each phase of #$ARGUMENTS independently and consecutively. For every checklist item below, explicitly deploy (or reuse) a subagent responsible for that item and record its outcome before proceeding.
Execution Protocol (Orchestrator-Driven)
Orchestrator rules:
- Each phase uses fresh subagents where noted (or when context is large/unclear).
- The orchestrator assigns one clear objective per subagent and requires evidence (commands run, outputs, files changed).
- Do not advance to the next step until the assigned subagent reports completion and the orchestrator confirms it matches the plan.
During Each Phase:
Deploy an "Implementation" subagent to:
- Execute the implementation as specified
- COPY patterns from documentation, don't invent
- Cite documentation sources in code comments when using unfamiliar APIs
- If an API seems missing, STOP and verify - don't assume it exists
After Each Phase:
Deploy subagents for each post-phase responsibility:
- Run verification checklist - Deploy a "Verification" subagent to prove the phase worked
- Anti-pattern check - Deploy an "Anti-pattern" subagent to grep for known bad patterns from the plan
- Code quality review - Deploy a "Code Quality" subagent to review changes
- Commit only if verified - Deploy a "Commit" subagent only after verification passes; otherwise, do not commit
Between Phases:
Deploy a "Branch/Sync" subagent to:
- Push to working branch after each verified phase
- Prepare the next phase handoff so the next phase's subagents start fresh but have plan context
Failure Modes to Prevent
- Don't invent APIs that "should" exist - verify against docs
- Don't add undocumented parameters - copy exact signatures
- Don't skip verification - deploy a verification subagent and run the checklist
- Don't commit before verification passes (or without explicit orchestrator approval)
You are an ORCHESTRATOR.
Create an LLM-friendly plan in phases that can be executed consecutively in new chat contexts.
Delegation model (because subagents can under-report):
- Use subagents for fact gathering and extraction (docs, examples, signatures, grep results).
- Keep synthesis and plan authoring with the orchestrator (phase boundaries, task framing, final wording).
- If a subagent report is incomplete or lacks evidence, the orchestrator must re-check with targeted reads/greps before finalizing the plan.
Subagent reporting contract (MANDATORY):
- Each subagent response must include:
- Sources consulted (files/URLs) and what was read
- Concrete findings (exact API names/signatures; exact file paths/locations)
- Copy-ready snippet locations (example files/sections to copy)
- "Confidence" note + known gaps (what might still be missing)
- Reject and redeploy the subagent if it reports conclusions without sources.
Plan Structure Requirements
Phase 0: Documentation Discovery (ALWAYS FIRST)
Before planning implementation, you MUST: Deploy one or more "Documentation Discovery" subagents to:
- Search for and read relevant documentation, examples, and existing patterns
- Identify the actual APIs, methods, and signatures available (not assumed)
- Create a brief "Allowed APIs" list citing specific documentation sources
- Note any anti-patterns to avoid (methods that DON'T exist, deprecated parameters)
Then the orchestrator consolidates their findings into a single Phase 0 output.
Each Implementation Phase Must Include:
- What to implement - Frame tasks to COPY from docs, not transform existing code
- Good: "Copy the V2 session pattern from docs/examples.ts:45-60"
- Bad: "Migrate the existing code to V2"
- Documentation references - Cite specific files/lines for patterns to follow
- Verification checklist - How to prove this phase worked (tests, grep checks)
- Anti-pattern guards - What NOT to do (invented APIs, undocumented params)
Subagent-friendly split:
- Subagents can propose candidate doc references and verification commands.
- The orchestrator must write the final phase text, ensuring tasks are copy-based, scoped, and independently executable.
Final Phase: Verification
- Verify all implementations match documentation
- Check for anti-patterns (grep for known bad patterns)
- Run tests to confirm functionality
Delegation guidance:
- Deploy a "Verification" subagent to draft the checklist and commands.
- The orchestrator must review the checklist for completeness and ensure it maps to earlier phase outputs.
Key Principles
- Documentation Availability ≠ Usage: Explicitly require reading docs
- Task Framing Matters: Direct agents to docs, not just outcomes
- Verify > Assume: Require proof, not assumptions about APIs
- Session Boundaries: Each phase should be self-contained with its own doc references
Anti-Patterns to Prevent
- Inventing API methods that "should" exist
- Adding parameters not in documentation
- Skipping verification steps
- Assuming structure without checking examples
Sponsors
Details
- Marketplace
- StevieClear/claude-mem-privacy-fork
- Source
- plugin
- Category
- Community