1. 回顾完成的工作：

   • 实现的功能
   • 修复的错误
   • 做出的决策
   • 发现的收获

2. 追加到每日日志：

   python scripts/daily_log.py
   --workspace ~/.openclaw/workspace
   --entry "修复了支付处理中的竞态条件 - 添加了互斥锁"

3. 为重要工作添加结构化条目：

   关键活动

- [14:30] 使用 GraphQL 实现了用户个人资料仪表板

- [16:00] 修复了 UserContext 中的无限重新渲染 - 对 provider 值进行了记忆化

## 做出的决策

- 选择 Apollo Client 而非 React Query - 更好的缓存 + 类型生成
- 决定在 httpOnly cookies 中使用 JWT 而非 localStorage

## 收获

- Apollo 需要 `__typename` 字段进行缓存规范化
- React.memo 无法防止因上下文变化导致的重新渲染

参见： patterns.md 了解不同场景下应记录的内容

切换上下文前：保存会话

时机： 运行 /new、/reset 或结束对话之前

步骤：

1. 提取会话摘要：

   从系统提示或 openclaw 状态获取当前会话 ID

python scripts/extract_session.py \

  --session ~/.openclaw/agents/<agent-id>/sessions/<session-id>.jsonl \
  --output ~/session-summary.md

2. 审阅摘要并编辑关键收获部分

1. 保存到每日日志：

   将关键点追加到今日日志

cat ~/session-summary.md >> ~/.openclaw/workspace/memory/$(date +%Y-%m-%d).md

1. 如有需要，提取关键上下文到 MEMORY.md：

   • 非显而易见的解决方案
   • 重要决策
   • 值得记住的模式

每周回顾：提取知识

时机： 周末（周五/周日）或每月

步骤：

1. 搜索近期日志中的模式：

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

2. 寻找提取信号：

   • 重复出现的问题（出现 3 次以上）
   • 高成本收获（花费 >1 小时解决）
   • 非显而易见的解决方案
   • 值得复用的成功模式

3. 提取到 MEMORY.md：

   • 添加新章节或更新现有章节
   • 使用问题-解决方案格式
   • 包含代码示例
   • 添加上下文说明何时使用

4. 清理 MEMORY.md：

   • 移除过时信息
   • 合并重复条目
   • 更新代码示例
   • 如有需要，改进组织结构

参见： extraction.md 了解详细的提取模式

每日：快速记录

用于在工作期间快速捕获上下文：

# 快速笔记
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "今日学习：DataLoader 将请求批处理为单个查询"

# 决策
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "使用 Zustand 管理客户端状态 - 比 Redux 更简单" \
  --category "做出的决策"

# 已解决的问题
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "CORS + cookies：在客户端和服务器启用凭据，Allow-Origin 不能为 *"

记忆结构

每日日志 (memory/YYYY-MM-DD.md)

目的： 按时间顺序跟踪活动

内容：

• 完成的工作（带时间戳）
• 做出的决策
• 解决的问题
• 发现的收获

保留策略： 保持近期日志可访问，可选择归档超过 90 天的日志

何时使用：

• "我在 [日期] 做了什么？"
• "我何时实现了 X？"
• 会话历史
• 活动跟踪

MEMORY.md

目的： 精心策划的长期知识

内容：

• 模式和最佳实践
• 常见解决方案
• 需要避免的错误
• 有用的参考资料

组织方式： 基于主题，而非时间顺序

何时使用：

• "如何解决 X？"
• "Y 的模式是什么？"
• 最佳实践
• 可复用的解决方案

参见： organization.md 了解结构模式

记忆记录模式

记录什么

始终记录：

• 关键实现决策（为什么选择方法 X 而非 Y）
• 非显而易见的解决方案
• 错误的根本原因
• 架构决策及其理由
• 发现的模式
• 错误及其修复方式

不要记录：

• 每个更改的文件（git 已记录）
• 显而易见的实现细节
• 常规提交
• 项目特定的临时方案

参见： patterns.md 获取全面的记录指导

何时记录

工作期间：

• 使用 daily_log.py --entry 快速记录
• 决策做出时立即捕获
• 问题解决时立即记录

每日结束时：

• 回顾完成的工作
• 结构化重要条目
• 为明天添加上下文

每周结束时：

• 将模式提取到 MEMORY.md
• 整合收获
• 清理过时信息

知识提取

提取标准

当出现以下情况时提取到 MEMORY.md：

• 模式出现 3 次以上
• 解决方案花费 >1 小时找到
• 解决方案非显而易见
• 未来将节省大量时间
• 适用于多个项目
• 错误调试成本高昂

不要提取：

• 一次性修复
• 项目特定的临时方案
• 显而易见的解决方案
• 快速变化的 API

提取格式

问题-解决方案结构：

## [技术/领域]

### [问题标题]

**问题：** [清晰描述]
**原因：** [根本原因]
**解决方案：** [如何修复]

**代码：**
```js
// 示例实现

预防： [如何避免] 上下文： [何时适用]

**参见：** [extraction.md](references/extraction.md) 了解详细的提取工作流

## 脚本参考

### daily_log.py

创建或追加到今日的每日日志。

```bash
# 追加条目
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --entry "您的日志条目" \
  [--category "章节名称"]

# 从模板创建
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --template

# 显示今日日志
python scripts/daily_log.py \
  --workspace ~/.openclaw/workspace \
  --show

extract_session.py

从会话 JSONL 中提取摘要。

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

输出：

• 用户请求摘要
• 使用的工具
• 触及的文件
• 关键收获的模板

search_memory.py

在所有记忆文件中搜索。

# 使用查询搜索
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --query "搜索词" \
  [--days 30]

# 显示近期日志
python scripts/search_memory.py \
  --workspace ~/.openclaw/workspace \
  --recent 5

最佳实践

日常纪律

1. 每日开始： 回顾昨日日志，计划今日工作
2. 工作期间： 为决策和收获快速记录
3. 每日结束： 结构化重要条目，添加上下文
4. 每周结束： 提取模式，清理 MEMORY.md

上下文保存

在/new 或 /reset 之前：

1. 提取会话摘要
2. 添加到每日日志
3. 在 MEMORY.md 中保存关键上下文

在主要工作之后：

1. 记录完成的工作
2. 注明关键收获
3. 记录后续步骤

知识组织

1. 基于主题的结构 - 按领域而非日期分组
2. 问题优先的标题 - 以要解决的问题开头
3. 可搜索的语言 - 使用具体、可查找的术语
4. 扁平层级 - 最多 2 层深度
5. 代码示例 - 包含可工作的示例

参见： organization.md 获取详细的结构指导

故障排除

找不到过去的决策

1. 首先搜索每日日志：

   python scripts/search_memory.py --workspace ~/.openclaw/workspace --query "决策关键词"

2. 搜索 MEMORY.md：

   grep -i "关键词" ~/.openclaw/workspace/MEMORY.md

3. 搜索会话日志：

   rg "关键词" ~/.openclaw/agents/<id>/sessions/*.jsonl

记忆文件变得太大

1. 归档旧的每日日志（>90 天）：

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

2. 如果 >1000 行，按领域拆分 MEMORY.md：

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

3. 从主 MEMORY.md 链接：

   领域知识

- [React 模式](memory/domains/react.md)

- [GraphQL 模式](memory/domains/graphql.md)

不确定记录什么

参见： patterns.md 获取全面的记录模式

快速规则： 如果你花费了 >15 分钟在其上或学到了非显而易见的东西，就记录它。

模板

每日日志模板

位于：assets/templates/daily-log.md

结构：

• 关键活动
• 做出的决策
• 收获
• 挑战与解决方案
• 明日上下文
• 参考资料

MEMORY.md 模板

位于：assets/templates/MEMORY-template.md

结构：

• 模式与最佳实践
• 常见解决方案
• 收获
• 需要避免的错误
• 有用的参考资料

提示

1. 保持一致性 - 每日记录，每周提取
2. 保持简洁 - 未来的你需要事实，而非故事
3. 保持具体 - "Apollo 缓存规范化" > "缓存问题"
4. 使用代码 - 示例 > 解释
5. 先搜索 - 提问前，先搜索你的记忆
6. 无情提取 - 如果重复出现 3 次，就提取它
7. 定期清理 - 每月移除过时信息
8. 版本控制 - 对 MEMORY.md 的更改进行 Git 提交

与 OpenClaw 集成

使用钩子自动记录

创建钩子以自动记录主要事件：

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

会话保存

添加到 AGENTS.md：

## 在 /new 或 /reset 之前

始终保存上下文：
1. 提取会话摘要
2. 添加到每日日志
3. 将关键决策保存到 MEMORY.md

每周回顾定时任务

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

每周安装次数

111

仓库

irangareddy/ope…sentials

首次出现

2026年2月16日

安全审计

Gen Agent Trust HubPassSocketPassSnykPass

安装于

openclaw108

codex107

opencode107

cursor107

gemini-cli106

github-copilot106

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:

   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:

   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:

   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

1. Save to daily log:

   Append key points to today's log

cat ~/session-summary.md >> ~/.openclaw/workspace/memory/$(date +%Y-%m-%d).md

1. 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:

   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:

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

2. Search MEMORY.md:

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

3. Search session logs:

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

Memory files getting too large

1. Archive old daily logs (>90 days):

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

2. Split MEMORY.md by domain if >1000 lines:

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

3. Link from main MEMORY.md:

   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"

Weekly Installs

111

Repository

irangareddy/ope…sentials

First Seen

Feb 16, 2026

Security Audits

Gen Agent Trust HubPassSocketPassSnykPass

Installed on

openclaw108

codex107

opencode107

cursor107

gemini-cli106

github-copilot106