Hermes Agent 是如何越用越聪明的

~/.hermes/memories/
├── MEMORY.md   ← Agent 的笔记（环境事实、项目约定、踩过的坑）
└── USER.md     ← 关于你的画像（偏好、工作风格、沟通习惯）

# 记住用户偏好
memory(action="add", target="user",
       content="用户喜欢简洁的终端风格回答，不需要 markdown 格式")

# 记住项目事实
memory(action="add", target="memory",
       content="这个项目的 CI 用 GitHub Actions，不是 Jenkins")

# 修正过时信息
memory(action="replace", target="memory",
       old_text="数据库在 us-east-1",
       content="数据库已迁移到 ap-southeast-1")

class MemoryStore:
    def __init__(self, memory_char_limit=2200, user_char_limit=1375):
        self.memory_entries: List[str] = []
        self.user_entries: List[str] = []
        # 关键：冻结快照
        self._system_prompt_snapshot: Dict[str, str] = {"memory": "", "user": ""}

    def load_from_disk(self):
        self.memory_entries = self._read_file(mem_dir / "MEMORY.md")
        self.user_entries = self._read_file(mem_dir / "USER.md")
        # 拍一张快照，整个会话期间不变
        self._system_prompt_snapshot = {
            "memory": self._render_block("memory", self.memory_entries),
            "user": self._render_block("user", self.user_entries),
        }

_MEMORY_THREAT_PATTERNS = [
    (r'ignore\s+(previous|all|above|prior)\s+instructions', "prompt_injection"),
    (r'you\s+are\s+now\s+', "role_hijack"),
    (r'do\s+not\s+tell\s+the\s+user', "deception_hide"),
    (r'curl\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET)', "exfil_curl"),
    (r'authorized_keys', "ssh_backdoor"),
]

~/.hermes/skills/
├── deploy-to-aws/
│   ├── SKILL.md              # 主文档：操作步骤
│   ├── references/           # 参考文档
│   │   └── aws-cli-cheat-sheet.md
│   └── templates/            # 输出模板
│       └── cloudformation.yaml
└── debug-docker-network/
    └── SKILL.md

---
name: deploy-to-aws
description: 将 Next.js 项目部署到 AWS ECS
version: 1.0.0
platforms: [macos, linux]
prerequisites:
  commands: [aws, docker]
---

# Deploy to AWS

1. 构建 Docker 镜像...
2. 推送到 ECR...
3. 更新 ECS 服务...

skills_list()                    # 列出所有技能标题和摘要
skill_view("deploy-to-aws")     # 读取某个技能的完整内容
skill_manage(action="create",    # 创建新技能
             name="xxx",
             content="...")

## Skills (mandatory)
Before replying, scan the skills below. If a skill matches...

  deployment:
    - deploy-to-aws: 将 Next.js 项目部署到 AWS ECS
    - deploy-to-vercel: 一键部署到 Vercel
  debugging:
    - debug-docker-network: 排查 Docker 容器网络问题

# 第一层：进程内 LRU 缓存（进程存活期间有效）
_SKILLS_PROMPT_CACHE = OrderedDict()  # 最多 100 条

# 第二层：磁盘快照（进程重启后仍有效）
# .skills_prompt_snapshot.json — 存储解析后的元数据
# 通过 mtime/size manifest 校验是否过期

# 第三层：完整文件系统扫描（两层缓存都 miss 时才触发）

-- 全文搜索虚拟表
CREATE VIRTUAL TABLE messages_fts USING fts5(
    content,
    content=messages,
    content_rowid=id
);

-- 自动同步：消息写入时自动更新索引
CREATE TRIGGER messages_fts_insert AFTER INSERT ON messages BEGIN
    INSERT INTO messages_fts(rowid, content) VALUES (new.id, new.content);
END;

session_search(query="上次我们怎么修复的那个 docker 网络问题")

def search_messages(self, query: str, ...):
    query = self._sanitize_fts5_query(query)
    # 先尝试 FTS5 MATCH
    # 如果 CJK 检测到且结果为空，降级到 LIKE

_WRITE_MAX_RETRIES = 15
_WRITE_RETRY_MIN_S = 0.020   # 20ms
_WRITE_RETRY_MAX_S = 0.150   # 150ms

for attempt in range(self._WRITE_MAX_RETRIES):
    try:
        self._conn.execute("BEGIN IMMEDIATE")
        result = fn(self._conn)
        self._conn.commit()
        return result
    except sqlite3.OperationalError as exc:
        if "locked" in str(exc).lower():
            jitter = random.uniform(
                self._WRITE_RETRY_MIN_S,
                self._WRITE_RETRY_MAX_S
            )
            time.sleep(jitter)

# Memory 复盘：基于用户消息轮次（默认每 10 轮）
self._turns_since_memory += 1
if self._turns_since_memory >= self._memory_nudge_interval:  # 默认 10
    _should_review_memory = True
    self._turns_since_memory = 0

# Skills 复盘：基于工具调用迭代次数（默认每 10 次）
if self._iters_since_skill >= self._skill_nudge_interval:  # 默认 10
    _should_review_skills = True
    self._iters_since_skill = 0

对话进行中
  │
  │  每10轮  ──→  后台线程启动
  │                  │
  │                  ↓ 创建新的 AIAgent 实例（同模型、同工具）
  │                  ↓ 把当前对话历史复制给它
  │                  ↓ 追加一条复盘提示词
  │                  ↓ 子 Agent 自主判断、自主调用工具
  │                  │
  │                  ├── 值得记？→ memory("add") → 写入磁盘
  │                  ├── 可复用？→ skill_manage("create") → 写入技能
  │                  └── 没什么特别的 → "Nothing to save."
  │
  └──→ 主对话不受影响
       用户看到一行 "💾 Memory updated"

_MEMORY_REVIEW_PROMPT = (
    "Review the conversation above and consider saving to memory "
    "if appropriate.\n\n"
    "Focus on:\n"
    "1. Has the user revealed things about themselves — their persona, "
    "desires, preferences, or personal details worth remembering?\n"
    "2. Has the user expressed expectations about how you should behave, "
    "their work style, or ways they want you to operate?\n\n"
    "If something stands out, save it using the memory tool. "
    "If nothing is worth saving, just say 'Nothing to save.' and stop."
)

_SKILL_REVIEW_PROMPT = (
    "Review the conversation above and consider saving or updating a "
    "skill if appropriate.\n\n"
    "Focus on: was a non-trivial approach used to complete a task that "
    "required trial and error, or changing course due to experiential "
    "findings along the way, or did the user expect or desire a different "
    "method or outcome?\n\n"
    "If a relevant skill already exists, update it with what you learned. "
    "Otherwise, create a new skill if the approach is reusable.\n"
    "If nothing is worth saving, just say 'Nothing to save.' and stop."
)

def _spawn_background_review(self, messages_snapshot, review_memory, review_skills):
    def _run_review():
        review_agent = AIAgent(
            model=self.model,
            max_iterations=8,      # 限制迭代次数，轻量复盘
            quiet_mode=True,       # 静默运行
        )
        # 共享 Memory/Skills 存储（写入同一个磁盘文件）
        review_agent._memory_store = self._memory_store
        # 禁用复盘触发器（防止递归：复盘 Agent 又触发复盘）
        review_agent._memory_nudge_interval = 0
        review_agent._skill_nudge_interval = 0

        review_agent.run_conversation(
            user_message=prompt,
            conversation_history=messages_snapshot,
        )

        # 提取成功的写入操作，展示给用户
        if actions:
            self._safe_print(f"  💾 {summary}")

    t = threading.Thread(target=_run_review, daemon=True, name="bg-review")
    t.start()

┌──────────────── 会话 N ────────────────┐
│                                         │
│  用户: "部署到 AWS 时 ECS 任务定义      │
│         的内存参数要设多少？"            │
│          ↓                              │
│  Agent: 调用工具、查文档、试错           │
│          ↓                              │
│  用户: "对，就用 512MB，另外记住        │
│         我们所有服务都跑在 ap-southeast-1"│
│          ↓                              │
│  Agent: 主动调用 memory("add") 保存     │
│         → 写入 MEMORY.md（立即持久化）  │
│         → 当前 system prompt 不变       │
│          ↓                              │
│  ... 继续对话 ...                       │
│          ↓                              │
│  [第 10 轮] 后台复盘触发               │
│     → 子 Agent 回顾对话                │
│     → 发现部署流程值得记录             │
│     → skill_manage("create",           │
│         name="ecs-deploy",             │
│         content="...")                  │
│     → 写入 skills/ecs-deploy/SKILL.md  │
│     → 用户看到 "💾 Skill created"      │
│                                         │
│  会话结束，完整对话存入 SQLite           │
└─────────────────────────────────────────┘
           ↓ 时间流逝 ↓
┌──────────────── 会话 N+1 ──────────────┐
│                                         │
│  启动时：                               │
│  ├─ MEMORY.md 重新加载 → 新快照注入     │
│  │  system prompt（含 ap-southeast-1）  │
│  ├─ Skills 索引重建 → 包含 ecs-deploy   │
│  └─ session_search 工具随时可用         │
│                                         │
│  用户: "帮我把新服务也部署一下"         │
│          ↓                              │
│  Agent: 看到 Skills 索引有 ecs-deploy   │
│     → skill_view("ecs-deploy") 读全文   │
│     → 按照之前的步骤操作               │
│     → 自动使用 ap-southeast-1 区域      │
│     → 如果细节不够，session_search      │
│        检索上次的完整对话               │
│                                         │
└─────────────────────────────────────────┘

┌─────────────────────────────────────┐
│ 1. Agent 身份                       │
│    "You are Claude, made by..."     │
├─────────────────────────────────────┤
│ 2. Memory 冻结快照                  │
│    ══════════════════════           │
│    MEMORY (your personal notes)     │
│    ══════════════════════           │
│    - 项目用 pnpm                    │
│    - 数据库在 ap-southeast-1        │
│                                     │
│    USER PROFILE                     │
│    - 用户喜欢简洁回答               │
│    - 后端工程师，前端经验少         │
├─────────────────────────────────────┤
│ 3. Skills 索引                      │
│    ## Skills (mandatory)            │
│      deployment:                    │
│        - ecs-deploy: 部署到 ECS     │
│      debugging:                     │
│        - debug-docker: 排查网络     │
├─────────────────────────────────────┤
│ 4. 平台特定指令                     │
│    (CLI / Telegram / Discord)       │
├─────────────────────────────────────┤
│ 5. 工具使用指南                     │
├─────────────────────────────────────┤
│ 6. Memory/Skills 使用指南           │
│    "当发现值得记录的内容时..."      │
├─────────────────────────────────────┤
│ 7. Session Search 使用指南          │
│    "你可以搜索历史会话..."          │
├─────────────────────────────────────┤
│ 8. 上下文文件                       │
│    (SOUL.md, AGENTS.md 等)          │
├─────────────────────────────────────┤
│ 9. 环境信息                         │
│    (OS, Shell, 已安装工具等)        │
└─────────────────────────────────────┘

def build_memory_context_block(memory_store, user_profile_enabled=True):
    """用冻结快照构建 memory 上下文块"""
    blocks = []
    # 使用快照而非实时状态
    memory_block = memory_store.format_for_system_prompt("memory")
    if memory_block:
        blocks.append(memory_block)
    if user_profile_enabled:
        user_block = memory_store.format_for_system_prompt("user")
        if user_block:
            blocks.append(user_block)
    return "\n\n".join(blocks) if blocks else None

LLM 的理解能力 + 文件持久化 = 跨会话的记忆积累