Show HN: Active Memory Plugin in Claude Code

Intelligent development tracking and context management using memory store

A comprehensive Claude Code plugin that automatically tracks your development flow, captures session context, analyzes git commits, syncs CLAUDE.md files, and maintains team knowledge across projects.

• Session-level context: Every development session is tracked with complete context
• File change monitoring: Real-time tracking of Write/Edit operations
• Background processing: Hooks run asynchronously without interrupting workflow
• Smart storage: Only relevant context is captured and stored

• Commit analysis: Automatic analysis of commit patterns, types, and impact
• Branching strategy: Tracks and documents team branching workflows
• Historical context: Preserves the "why" behind code changes
• Breaking change detection: Automatically flags significant changes

• Anchor comment tracking: Monitors and syncs anchor comments across files
• Cross-team consistency: Ensures all team members have latest documentation
• Pattern documentation: Captures and shares coding patterns
• Convention enforcement: Helps maintain consistent standards

• Auto-context awareness: Claude automatically retrieves relevant past work
• Pattern suggestions: Suggests following established patterns
• Decision history: Provides reasoning behind past technical choices
• Team knowledge: Surfaces insights from other team members

• /memory-sync - Manually synchronize project state to memory
• /memory-status - View current tracking status and statistics
• /memory-context - Retrieve relevant context for current work
• /memory-overview - Generate comprehensive project overview
• /checkpoint - Trigger progress validation checkpoint
• /correct "explanation" - Correct Claude's mistakes with high-priority learning
• /session-feedback - View current session quality rating
• /validate-changes - Pre-commit validation with security checks

• Memory Tracker Agent: Deep project analysis and pattern documentation
• Cross-repo context: Analyzes relationships between multiple repositories
• Workflow documentation: Captures team development processes
• Business logic mapping: Documents core workflows and rules

• Memory Context Retrieval Skill: Auto-invoked for contextual awareness
• Pattern matching: Detects when similar work has been done before
• Deviation warnings: Alerts when current approach differs from patterns
• Proactive suggestions: Recommends best practices automatically

• Progress Checkpoints: Auto-validates after every 10 file changes
• Pre-commit Validation: Reviews changes before commits with security checks
• Correction System: Record mistakes with /correct for high-priority learning
• Session Quality Tracking: Automatic feedback based on corrections needed
• Security Scanning: Detects potential secrets, tokens, and debug code
• Semantic Commit Reminders: Encourages proper commit message conventions

The easiest way to install is via the Claude Code plugin marketplace:

That's it! See MARKETPLACE.md for detailed marketplace installation guide.

After installation, configure your memory store token:

1. Get your token from memory.store
2. Set it in your environment or local config (never commit tokens!)

For development or custom setups:

Test the plugin:

You should see session tracking information!

The plugin works automatically in the background:

• Session Start: Captures project state when you start Claude Code
• File Changes: Tracks every file you create or modify
• Git Commits: Analyzes commits you make during the session
• Session End: Summarizes and stores session learnings

You don't need to do anything - it just works!

Shows what's being tracked in your current session:

• Files modified
• Commits analyzed
• Context stored
• Memory store statistics

Retrieves relevant context about authentication from past work:

• Similar implementations
• Team decisions
• Established patterns
• Related documentation

Manually synchronizes current project state:

• Captures file structure
• Analyzes git history
• Syncs CLAUDE.md files
• Updates project overview

Generates comprehensive project overview:

• Architecture documentation
• Business logic workflows
• Team conventions
• Development patterns
• Knowledge gaps

The plugin automatically syncs your CLAUDE.md files and anchor comments:

When you reference anchor comments in code or documentation, the plugin maintains these relationships in memory, making it easy for team members to find relevant context.

Claude will automatically use stored context to provide better responses:

Example 1: Following Patterns

Example 2: Decision History

You can add support for Linear, Jam.dev, or other MCP servers:

1. Copy .mcp-extensions.json.example to .mcp-extensions.json
2. Add your API keys
3. Restart Claude Code

Example with Linear integration:

The plugin will automatically integrate Linear issues into memory context!

Edit hooks/hooks.json to customize when hooks fire:

1. SessionStart Hook

   • Initializes session tracking
   • Loads relevant context
   • Captures project snapshot

2. PostToolUse Hooks

   • Track file changes (Write/Edit)
   • Analyze commits (git commands)
   • Sync CLAUDE.md files

3. PreCompact Hook

   • Saves important context before compression
   • Preserves decisions and reasoning

4. SessionEnd Hook

   • Summarizes session
   • Stores key learnings
   • Updates project overview

The plugin stores:

• Development patterns: How features are implemented
• Team conventions: Coding standards and practices
• Decision history: Why certain approaches were chosen
• Business logic: Core workflows and rules
• Git context: Commit patterns and branching strategies
• Documentation: CLAUDE.md files and anchor comments

Each developer runs the plugin locally:

• Personal context is captured
• Stored to shared memory store
• Available to all team members

The plugin enables powerful knowledge sharing:

• New developers can query past decisions
• Code reviews reference established patterns
• Architecture discussions are preserved
• Business logic is documented automatically

If your team works on multiple related projects:

1. Install the plugin in each project
2. Use the same memory store token
3. The Memory Tracker Agent can analyze cross-repo relationships

The plugin analyzes commit messages - use conventional commits:

Keep your CLAUDE.md files up to date:

• Document patterns as you establish them
• Use anchor comments for important sections
• Reference anchors in code and discussions

Run /memory-sync after:

• Major feature completions
• Architectural decisions
• Before team meetings
• When onboarding new members

Use /memory-context when starting new work:

• Check for similar implementations
• Review past decisions
• Understand team conventions

Run /memory-overview to:

• Create onboarding documentation
• Prepare for stakeholder updates
• Audit knowledge gaps
• Plan technical debt work

1. Check plugin structure:

2. Verify plugin.json is valid:

3. Check Claude Code debug output:

1. Ensure scripts are executable:

2. Check hook configuration:

3. Test scripts manually:

1. Verify your token is correct in .claude-plugin/plugin.json
2. Check network connectivity
3. Test MCP server directly:

1. Make changes to plugin files
2. Restart Claude Code
3. Test with /memory-status

1. Create script in scripts/
2. Make it executable: chmod +x scripts/your-script.sh
3. Add to hooks/hooks.json
4. Test the hook

1. Create markdown file in commands/
2. Add frontmatter with description
3. Document usage and examples
4. Restart Claude Code

See the examples/ directory for:

• Sample CLAUDE.md files
• Example memory queries
• Hook customization examples
• Team workflow templates

Contributions welcome! Please:

1. Fork the repository
2. Create a feature branch
3. Add tests if applicable
4. Submit a pull request

MIT License - see LICENSE file for details

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: [email protected]

See CHANGELOG.md for version history.

Built by the Autotelic team with ❤️ for the Claude Code community.

Special thanks to:

• The Claude Code team at Anthropic
• The memory.store team
• All contributors and users