Memory Curator

Systematic memory management for agents through daily logging, session preservation, and knowledge extraction.

Quick Start

Log Today's Work

# Append to today's log
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "Implemented user authentication with JWT" \
  --category "Key Activities"

# Show today's log
python scripts/daily_log.py --workspace ~/.openclaw/workspace --show

Search Memory

# Search all memory files
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "GraphQL"

# Search recent logs only (last 7 days)
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "authentication" \
  --days 7

# Show recent logs
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --recent 5

Extract Session Summary

# Generate summary from current session
python scripts/extract_session.py \
  --session ~/.openclaw/agents/<agent-id>/sessions/<session-id>.jsonl \
  --output session-summary.md

Core Workflows

End of Day: Log Activities

When: Before ending work session or switching contexts

Steps:

1. •

   Review what was accomplished:

   • •Features implemented
   • •Bugs fixed
   • •Decisions made
   • •Learnings discovered
2. •

   Append to daily log:

   bash

   python scripts/daily_log.py \
     --workspace ~/.openclaw/workspace \
     --entry "Fixed race condition in payment processing - added mutex lock"
   

3. •

   Add structured entries for important work:

   markdown

   ## Key Activities
   
   - [14:30] Implemented user profile dashboard with GraphQL
   - [16:00] Fixed infinite re-render in UserContext - memoized provider value
   
   ## Decisions Made
   
   - Chose Apollo Client over React Query - better caching + type generation
   - Decided to use JWT in httpOnly cookies instead of localStorage
   
   ## Learnings
   
   - Apollo requires `__typename` field for cache normalization
   - React.memo doesn't prevent re-renders from context changes
   

See: patterns.md for what to log in different scenarios

Before Context Switch: Preserve Session

When: Before running /new, /reset, or ending conversation

Steps:

1. •

   Extract session summary:

   bash

   # Get current session ID from system prompt or openclaw status
   python scripts/extract_session.py \
     --session ~/.openclaw/agents/<agent-id>/sessions/<session-id>.jsonl \
     --output ~/session-summary.md
   

2. •

   Review summary and edit Key Learnings section

3. •

   Save to daily log:

   bash

   # Append key points to today's log
   cat ~/session-summary.md >> ~/.openclaw/workspace/memory/$(date +%Y-%m-%d).md
   

4. •

   Extract critical context to MEMORY.md if needed:

   • •Non-obvious solutions
   • •Important decisions
   • •Patterns worth remembering

Weekly Review: Extract Knowledge

When: End of week (Friday/Sunday) or monthly

Steps:

1. •

   Search for patterns in recent logs:

   bash

   python scripts/search_memory.py \
     --workspace ~/.openclaw/workspace \
     --recent 7
   

2. •

   Look for extraction signals:

   • •Repeated issues (3+ occurrences)
   • •High-cost learnings (>1 hour to solve)
   • •Non-obvious solutions
   • •Successful patterns worth reusing
3. •

   Extract to MEMORY.md:

   • •Add new sections or update existing ones
   • •Use problem-solution format
   • •Include code examples
   • •Add context for when to use
4. •

   Clean up MEMORY.md:

   • •Remove outdated information
   • •Consolidate duplicate entries
   • •Update code examples
   • •Improve organization if needed

See: extraction.md for detailed extraction patterns

Daily: Quick Logging

For rapid context capture during work:

# Quick note
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "TIL: DataLoader batches requests into single query"

# Decision
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "Using Zustand for client state - simpler than Redux" \
  --category "Decisions Made"

# Problem solved
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "CORS + cookies: Enable credentials on client + server, Allow-Origin can't be *"

Memory Structure

Daily Logs (memory/YYYY-MM-DD.md)

Purpose: Chronological activity tracking

Content:

• •What was done (timestamped)
• •Decisions made
• •Problems solved
• •Learnings discovered

Retention: Keep recent logs accessible, optionally archive logs >90 days

When to use:

• •"What did I do on [date]?"
• •"When did I implement X?"
• •Session history
• •Activity tracking

MEMORY.md

Purpose: Curated long-term knowledge

Content:

• •Patterns and best practices
• •Common solutions
• •Mistakes to avoid
• •Useful references

Organization: Topic-based, not chronological

When to use:

• •"How do I solve X?"
• •"What's the pattern for Y?"
• •Best practices
• •Reusable solutions

See: organization.md for structure patterns

Memory Logging Patterns

What to Log

Always log:

• •Key implementation decisions (why approach X over Y)
• •Non-obvious solutions
• •Root causes of bugs
• •Architecture decisions with rationale
• •Patterns discovered
• •Mistakes and how they were fixed

Don't log:

• •Every file changed (git has this)
• •Obvious implementation details
• •Routine commits
• •Project-specific hacks

See: patterns.md for comprehensive logging guidance

When to Log

During work:

• •Quick notes with daily_log.py --entry
• •Capture decisions as made
• •Log problems when solved

End of day:

• •Review what was accomplished
• •Structure important entries
• •Add context for tomorrow

End of week:

• •Extract patterns to MEMORY.md
• •Consolidate learnings
• •Clean up outdated info

Knowledge Extraction

Extraction Criteria

Extract to MEMORY.md when:

• •Pattern appears 3+ times
• •Solution took >1 hour to find
• •Solution is non-obvious
• •Will save significant time in future
• •Applies across multiple projects
• •Mistake was costly to debug

Don't extract:

• •One-off fixes
• •Project-specific hacks
• •Obvious solutions
• •Rapidly changing APIs

Extraction Format

Problem-Solution Structure:

## [Technology/Domain]

### [Problem Title]

**Problem:** [Clear description]
**Cause:** [Root cause]
**Solution:** [How to fix]

**Code:**
```js
// Example implementation

Prevention: [How to avoid] Context: [When this applies]

**See:** [extraction.md](references/extraction.md) for detailed extraction workflow

## Scripts Reference

### daily_log.py

Create or append to today's daily log.

```bash
# Append entry
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "Your log entry" \
  [--category "Section Name"]

# Create from template
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --template

# Show today's log
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --show

extract_session.py

Extract summary from session JSONL.

python scripts/extract_session.py \
  --session ~/.openclaw/agents/<id>/sessions/<session>.jsonl \
  [--output summary.md]

Outputs:

• •User requests summary
• •Tools used
• •Files touched
• •Template for key learnings

search_memory.py

Search across all memory files.

# Search with query
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "search term" \
  [--days 30]

# Show recent logs
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --recent 5

Best Practices

Daily Discipline

1. •Start of day: Review yesterday's log, plan today
2. •During work: Quick notes for decisions and learnings
3. •End of day: Structure important entries, add context
4. •End of week: Extract patterns, clean up MEMORY.md

Context Preservation

Before /new or /reset:

1. •Extract session summary
2. •Add to daily log
3. •Preserve critical context in MEMORY.md

After major work:

1. •Document what was accomplished
2. •Note key learnings
3. •Record next steps

Knowledge Organization

1. •Topic-based structure - Group by domain, not date
2. •Problem-first titles - Lead with the problem being solved
3. •Searchable language - Use specific, findable terms
4. •Flat hierarchy - Maximum 2 levels deep
5. •Code examples - Include working examples

See: organization.md for detailed structure guidance

Troubleshooting

Can't find past decision

1. •

   Search daily logs first:

   bash

   python scripts/search_memory.py --workspace ~/.openclaw/workspace --query "decision keyword"
   

2. •

   Search MEMORY.md:

   bash

   grep -i "keyword" ~/.openclaw/workspace/MEMORY.md
   

3. •

   Search session logs:

   bash

   rg "keyword" ~/.openclaw/agents/<id>/sessions/*.jsonl
   

Memory files getting too large

1. •

   Archive old daily logs (>90 days):

   bash

   mkdir -p memory/archive/2025-Q1
   mv memory/2025-01-*.md memory/archive/2025-Q1/
   

2. •

   Split MEMORY.md by domain if >1000 lines:

   code

   memory/domains/
   ├── react.md
   ├── graphql.md
   └── database.md
   

3. •

   Link from main MEMORY.md:

   markdown

   ## Domain Knowledge
   - [React Patterns](memory/domains/react.md)
   - [GraphQL Patterns](memory/domains/graphql.md)
   

Not sure what to log

See: patterns.md for comprehensive logging patterns

Quick rule: If you spent >15 minutes on it or learned something non-obvious, log it.

Templates

Daily Log Template

Located at: assets/templates/daily-log.md

Structure:

• •Key Activities
• •Decisions Made
• •Learnings
• •Challenges & Solutions
• •Context for Tomorrow
• •References

MEMORY.md Template

Located at: assets/templates/MEMORY-template.md

Structure:

• •Patterns & Best Practices
• •Common Solutions
• •Learnings
• •Mistakes to Avoid
• •Useful References

Tips

1. •Be consistent - Log every day, extract every week
2. •Be concise - Future you needs facts, not stories
3. •Be specific - "Apollo cache normalization" > "cache issue"
4. •Use code - Examples > explanations
5. •Search first - Before asking, search your memory
6. •Extract ruthlessly - If it repeats 3x, extract it
7. •Clean regularly - Remove outdated info monthly
8. •Version control - Git commit MEMORY.md changes

Integration with OpenClaw

Auto-logging with Hooks

Create a hook to auto-log major events:

// ~/.openclaw/hooks/memory-logger/index.js
export default {
  name: 'memory-logger',
  async onToolCall({ tool, agent }) {
    if (tool === 'write' || tool === 'edit') {
      // Log file modifications
      await exec(`python scripts/daily_log.py --workspace ${agent.workspace} --entry "Modified ${tool.input.file_path}"`)
    }
  }
}

Session Preservation

Add to AGENTS.md:

## Before /new or /reset

Always preserve context:
1. Extract session summary
2. Add to daily log
3. Save critical decisions to MEMORY.md

Weekly Review Cron

openclaw cron add \
  --name "weekly-memory-review" \
  --at "Sunday 18:00" \
  --system-event "Time for weekly memory review and knowledge extraction"