Persistent memory system for Claude Code - context compression across sessions

version
9.0.12

Install

/plugin install claude-mem@thedotmack

Run it inside Claude Code after adding the marketplace with /plugin marketplace add StevieClear/claude-mem-privacy-fork.

Contents

Discovered from source

Commands 3

# Recent Activity

Oct 25, 2025

IDTimeTTitleRead
#24374:32 PM🟣Slash Command Files Created for Quick Settings Toggling~478

Jan 10, 2026

IDTimeTTitleRead
#390523: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:

  1. Execute the implementation as specified
  2. COPY patterns from documentation, don't invent
  3. Cite documentation sources in code comments when using unfamiliar APIs
  4. If an API seems missing, STOP and verify - don't assume it exists

After Each Phase:

Deploy subagents for each post-phase responsibility:

  1. Run verification checklist - Deploy a "Verification" subagent to prove the phase worked
  2. Anti-pattern check - Deploy an "Anti-pattern" subagent to grep for known bad patterns from the plan
  3. Code quality review - Deploy a "Code Quality" subagent to review changes
  4. 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:
    1. Sources consulted (files/URLs) and what was read
    2. Concrete findings (exact API names/signatures; exact file paths/locations)
    3. Copy-ready snippet locations (example files/sections to copy)
    4. "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:

  1. Search for and read relevant documentation, examples, and existing patterns
  2. Identify the actual APIs, methods, and signatures available (not assumed)
  3. Create a brief "Allowed APIs" list citing specific documentation sources
  4. 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:

  1. 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"
  2. Documentation references - Cite specific files/lines for patterns to follow
  3. Verification checklist - How to prove this phase worked (tests, grep checks)
  4. 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

  1. Verify all implementations match documentation
  2. Check for anti-patterns (grep for known bad patterns)
  3. 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