Hermes Holographic 记忆部署指南：分层存储 + 全自动轮换

USER.md / MEMORY.md 负责少量高优先级记忆，
Holographic 负责更多可检索、可维护、可打分的长期事实。

sudo su - hermesuser

hermes profile list
hermes config path
hermes config env-path

CFG="$(hermes config path)"
cp "$CFG" "$CFG.bak.$(date +%Y%m%d-%H%M%S)"

hermes memory setup

holographic

hermes config set memory.provider holographic

hermes memory status

hermes config show

memory:
  provider: holographic

plugins:
  hermes-memory-store:

$HERMES_HOME/memory_store.db

~/.hermes/memory_store.db

~/.hermes/profiles/<profile>/memory_store.db

把“这个 Matrix 机器人日常使用 smart 审批，群聊默认需要 mention”保存为长期事实。

查一下你关于这个 Hermes Matrix 机器人的长期记忆，列出和 memory provider、审批、Matrix 入口限制有关的事实。

如果你发现关于这台机器人的 Holographic 记忆里有过期 facts，请先列出来，不要直接删除，等我确认。

写入长期记忆前，先说明准备保存的事实；只保存长期偏好、稳定环境事实和可复用工作习惯，不保存一次性错误、未经确认的猜测、token、密码或临时任务状态。

plugins:
  hermes-memory-store:
    auto_extract: false

plugins:
  hermes-memory-store:
    auto_extract: true
    default_trust: 0.5

列出最近写入的 Holographic facts，按主题分组，并标出你认为可能过期或不应长期保存的内容。

hermes memory status

hermes config show | sed -n '/^memory:/,/^[^ ]/p'
hermes config show | sed -n '/^plugins:/,/^[^ ]/p'

find ~/.hermes -name 'memory_store.db' -print

请把这条保存到 Holographic 长期事实：我的新机器人装完后，默认先做 smart 审批、入口限制、Holographic 本地记忆和备份检查。

查一下你的 Holographic 长期事实：新机器人装完后，我默认先做哪些优化？

hermes profile list
hermes config path
hermes config env-path

请列出 Holographic 里和 Hermes、Matrix、服务器运维有关的长期 facts，标出重复、过期、可能错误和建议合并的项。先不要修改，等我确认。

#!/usr/bin/env python3
"""
Memory auto-rotation script for Hermes Agent.
Automatically archives old entries to fact_store when memory exceeds threshold.
No user confirmation needed — fully automatic.

Usage: python3 memory_rotate.py [--threshold 0.85] [--dry-run]
"""

import json
import re
import sqlite3
import sys
from datetime import datetime
from pathlib import Path

# Paths — 多 profile 环境改成对应 profile 的路径
HERMES_HOME = Path.home() / ".hermes"
MEMORY_MD = HERMES_HOME / "memories" / "MEMORY.md"
USER_MD = HERMES_HOME / "memories" / "USER.md"
FACT_DB = HERMES_HOME / "memory_store.db"

# Limits (from hermes config，可用 hermes config show 查看实际值)
MEMORY_LIMIT = 5000
USER_LIMIT = 3000

def get_memory_entries():
    """Read current memory entries from MEMORY.md (§-separated)."""
    entries = []
    if MEMORY_MD.exists():
        with open(MEMORY_MD) as f:
            for raw in f.read().split("§"):
                raw = raw.strip()
                if raw:
                    entries.append(raw)
    return entries

def get_user_entries():
    """Read current user profile entries from USER.md."""
    entries = []
    if USER_MD.exists():
        with open(USER_MD) as f:
            for raw in f.read().split("§"):
                raw = raw.strip()
                if raw:
                    entries.append(raw)
    return entries

def write_memory_entries(entries):
    content = "\n§\n".join(entries)
    if content:
        content += "\n"
    MEMORY_MD.write_text(content, encoding="utf-8")

def write_user_entries(entries):
    content = "\n§\n".join(entries)
    if content:
        content += "\n"
    USER_MD.write_text(content, encoding="utf-8")

def add_to_fact_store(content, category="general", tags=""):
    """Add entry to holographic fact_store (SQLite)."""
    conn = sqlite3.connect(FACT_DB)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS facts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            content TEXT NOT NULL,
            category TEXT DEFAULT 'general',
            tags TEXT DEFAULT '',
            trust_score REAL DEFAULT 0.5,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    # 去重
    cursor.execute("SELECT id FROM facts WHERE content = ?", (content,))
    if cursor.fetchone():
        conn.close()
        return False
    cursor.execute("""
        INSERT INTO facts (content, category, tags, trust_score)
        VALUES (?, ?, ?, ?)
    """, (content, category, tags, 0.5))
    conn.commit()
    conn.close()
    return True

def calculate_usage():
    memory_size = MEMORY_MD.stat().st_size if MEMORY_MD.exists() else 0
    user_size = USER_MD.stat().st_size if USER_MD.exists() else 0
    return {
        "memory": {"size": memory_size, "limit": MEMORY_LIMIT, "usage": memory_size / MEMORY_LIMIT},
        "user":   {"size": user_size,   "limit": USER_LIMIT,   "usage": user_size / USER_LIMIT}
    }

def score_entry_for_archival(entry):
    """Higher score = more likely to be archived."""
    score = 0
    # 长度：长 = 详细配置，适合归档；短 = 高价值指针，保留
    if len(entry) > 200:
        score += 3
    elif len(entry) > 100:
        score += 2
    elif len(entry) < 50:
        score -= 2
    # 过期关键词
    stale_keywords = [
        "已删除", "不再维护", "旧版", "deprecated", "backup", "迁移",
        "2024", "2025", "旧", "previous", "archived", "历史"
    ]
    for kw in stale_keywords:
        if kw in entry:
            score += 5
            break
    # 具体路径
    if "/home/" in entry or "~/" in entry:
        score += 1
    # IP 地址
    if re.search(r'\d+\.\d+\.\d+\.\d+', entry):
        score += 2
    # 版本号
    if re.search(r'v?\d+\.\d+', entry):
        score += 1
    return score

def auto_rotate(entries, limit, entry_type="memory", dry_run=False):
    """Archive entries to fact_store until usage drops below 70%."""
    current_size = sum(len(e) for e in entries) + len(entries) * 2
    target_size = limit * 0.70
    if current_size <= target_size:
        return entries, []

    scored = [(e, score_entry_for_archival(e)) for e in entries]
    scored.sort(key=lambda x: x[1], reverse=True)  # 高分先归档

    archived, remaining = [], []
    new_size = current_size
    for entry, score in scored:
        if new_size <= target_size:
            remaining.append(entry)
            continue
        if not dry_run:
            category = "user_pref" if entry_type == "user" else "archived"
            add_to_fact_store(entry, category=category, tags="auto-rotated")
        archived.append(entry)
        new_size -= len(entry) + 2

    return remaining, archived

def main():
    dry_run = "--dry-run" in sys.argv
    threshold = 0.85
    for i, arg in enumerate(sys.argv):
        if arg == "--threshold" and i + 1 < len(sys.argv):
            threshold = float(sys.argv[i + 1])

    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print(f"[{timestamp}] Memory Auto-Rotation")
    print("=" * 50)

    usage = calculate_usage()
    print(f"MEMORY.md: {usage['memory']['size']} / {usage['memory']['limit']} chars ({usage['memory']['usage']:.1%})")
    print(f"USER.md:   {usage['user']['size']} / {usage['user']['limit']} chars ({usage['user']['usage']:.1%})")
    print()

    total_archived = 0
    for name, get_fn, write_fn, limit, etype in [
        ("MEMORY.md", get_memory_entries, write_memory_entries, MEMORY_LIMIT, "memory"),
        ("USER.md",   get_user_entries,   write_user_entries,   USER_LIMIT,   "user"),
    ]:
        u = usage["memory" if etype == "memory" else "user"]
        if u["usage"] >= threshold:
            entries = get_fn()
            remaining, archived = auto_rotate(entries, limit, etype, dry_run)
            if archived:
                print(f"{name}: Archiving {len(archived)} entries")
                for e in archived:
                    print(f"  - {e[:60]}...")
                if not dry_run:
                    write_fn(remaining)
                    print(f"  ✅ Wrote {len(remaining)} remaining entries")
                total_archived += len(archived)
            else:
                print(f"{name}: No suitable entries to archive")
        else:
            print(f"{name}: ✅ Below threshold")
        print()

    print("=" * 50)
    if total_archived > 0:
        print(f"✅ Auto-rotation complete: {total_archived} entries archived to fact_store")
        if dry_run:
            print("   (dry run — no actual changes made)")
    else:
        print("✅ No rotation needed")

if __name__ == "__main__":
    main()

# 每周日 9:00 执行，全 profile 可用 HERMES_HOME 环境变量切换
0 9 * * 0 /usr/bin/python3 ~/.hermes/scripts/memory_rotate.py >> ~/.hermes/logs/memory_rotate.log 2>&1

python3 ~/.hermes/scripts/memory_rotate.py --dry-run

# 修改前默认值
hermes config set memory.memory_char_limit 2200   # 默认
hermes config set memory.user_char_limit 1375     # 默认

# 修改后当前值
hermes config set memory.memory_char_limit 5000   # 当前
hermes config set memory.user_char_limit 3000     # 当前

fact_store add --content "..." --category user_pref --tags hugo,workflow

hermes profile list
hermes config path