cc-simple-memory (STRML) — Summary

cc-simple-memory is a minimalist Claude Code plugin (Shell + Node.js) for extracting learnings from session transcripts into per-project and global MEMORY.md files. It uses three hooks (SessionStart, Stop, PreCompact) and a dedicated claude-memory CLI binary that wraps the extraction logic. The model tiering is distinctive: Sonnet for per-session extraction (Stop, max 1/hour per project), Opus for garbage collection (every 10 extractions), and Haiku for condensation pre-passes on long sessions. It creates two persistence scopes — per-project (~/.claude/projects/<encoded>/memory/MEMORY.md) and global cross-project (~/.claude/rules/global-memory.md) — so learnings can propagate across sessions and projects. Installation requires a post-install setup script to create the ~/bin/claude-memory symlink and grant permissions. The framework is ultra-lightweight (3 shell scripts, 1 Node.js CLI) with no database, no MCP server, and no dashboard. Compared to seeds, it is closest to agent-os in prioritizing minimal footprint, but adds automatic AI-powered extraction at session boundaries.

cc-simple-memory (STRML) — Overview

Origin

Created by STRML (Samuel Reed). Published as a simple, practical alternative to complex memory systems. 0 GitHub stars but well-architected and in active development (last push 2026-04-09).

Philosophy

Simplicity first: "Session → Claude writes MEMORY.md proactively (instructed via SessionStart hook). Stop → extract-learnings.sh → claude-memory extract → background Sonnet writes MEMORY.md. /clear → capture-learnings.sh → background Sonnet writes project CLAUDE.md. Every 10th extraction → gc-memory.sh → Opus consolidates + archives stale entries."

The key insight: extraction runs in the background (the script doesn't block Claude). Cost awareness is built in with explicit cost estimates per operation.

Cost Transparency

Opt-Out Mechanisms

• Per-session: add SKIP_MEMORY_EXTRACTION on its own line in session
• Global: set CLAUDE_SKIP_SESSION_LEARNINGS=1 before starting

Notable: Two Memory Scopes

Unlike most memory systems that are project-scoped only, cc-simple-memory has:

1. Per-project: ~/.claude/projects/<encoded>/memory/MEMORY.md — auto-loaded
2. Global: ~/.claude/rules/global-memory.md — loaded everywhere

cc-simple-memory (STRML) — Architecture

Distribution

Claude Code plugin. Install via marketplace.

Install

/plugin marketplace add STRML/cc-simple-memory
/plugin install cc-simple-memory
# Restart Claude Code

# Then run setup in terminal (NOT inside Claude):
PLUGIN_DIR=$(ls -dt ~/.claude/plugins/cache/*/cc-simple-memory 2>/dev/null | head -1)
bash "${PLUGIN_DIR}/bin/setup.sh"
# Restart Claude Code again

The setup script: adds 9 permission entries to ~/.claude/settings.json, creates ~/bin/claude-memory (or ~/.local/bin/) symlink.

Directory Structure

plugin/
├── .claude-plugin/
│   ├── plugin.json
│   └── marketplace.json
├── hooks/
│   ├── hooks.json          # 3 lifecycle hooks
│   ├── session-start.sh    # Loads per-project + global MEMORY.md
│   ├── extract-learnings.sh # Calls claude-memory extract (background)
│   ├── gc-memory.sh        # Every 10 extractions: Opus GC
│   └── capture-learnings.sh # On /clear: writes project CLAUDE.md
├── commands/
│   └── memory-setup.md     # /memory-setup slash command
├── bin/
│   └── ... (claude-memory CLI)
└── skills/
    └── (empty or minimal)

State Storage

Path encoding: Claude Code replaces both / and . with - in project paths.

Required Runtime

• Node.js (for claude-memory CLI)
• Claude Code with marketplace plugin support

Target AI Tools

Claude Code exclusively.

cc-simple-memory (STRML) — Components

Lifecycle Hooks (3)

CLI: claude-memory

Installed to ~/bin/claude-memory or ~/.local/bin/claude-memory.

Commands (1)

Skills

Minimal or none (not visible in repo structure).

GC (Garbage Collection)

Every 10th extraction triggers gc-memory.sh which uses Opus to:

• Consolidate duplicate/redundant memories
• Archive stale entries to ARCHIVE.md
• Reduce MEMORY.md size

Scripts

cc-simple-memory (STRML) — Uniqueness

Differs From Seeds

Closest to ccmemory (seed) in using lifecycle hooks (SessionStart, Stop, PreCompact) for automatic memory management. But architecture is radically simpler: file-based Markdown rather than Neo4j graph, shell scripts rather than Python/MCP server. Similar to agent-os (seed) in minimalism — both value lean installation. Unlike most memory systems that are project-scoped, cc-simple-memory has a two-tier scope (per-project MEMORY.md + global global-memory.md) that enables cross-project learning propagation.

Distinctive Features

1. Three-tier model routing: Haiku (condensation pre-pass) → Sonnet (extraction) → Opus (GC). Explicit quality/cost assignment per task.
2. GC with Opus: Periodic garbage collection with the most capable model ensures cold storage stays clean. No other file-based system in this batch has GC.
3. Global + per-project scopes: global-memory.md in ~/.claude/rules/ is auto-loaded everywhere, enabling cross-project learning. The only file-based system in this batch with this.
4. Rate limiting: Max 1 extraction/hour per project prevents runaway costs. Transparent about costs per operation.
5. Memory outside the project: Files live in ~/.claude/projects/ rather than project directory — not committed to VCS by default.

Observable Failure Modes

1. Two-restart setup: Required two-restart process creates friction and potential misconfiguration.
2. No search from agent: The claude-memory search CLI is for humans, not agents. No MCP tools.
3. Rate-limited extraction: 1/hr limit means rapid iteration sessions don't capture all learnings.
4. Markdown-only storage: No structured schema, no deduplication, no relationship tracking.
5. Global memory pollution: global-memory.md loaded everywhere may inject irrelevant context.