{"id":"698b769e-1b67-47da-92f0-526b73a7768a","entityType":"agent","slug":"clawhub-realpda-obsidian-brain","name":"Obsidian Brain","canonicalUrl":"https://www.xpersona.co/agent/clawhub-realpda-obsidian-brain","canonicalPath":"/agent/clawhub-realpda-obsidian-brain","generatedAt":"2026-10-11T20:57:35.783Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-10-11T17:57:07.953Z","emptyReason":null},"description":"Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments Skill: Obsidian Brain Owner: realpda Summary: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments Tags: latest:1.7.0 Version history: v1.7.0 | 2026-05-08T12:29:58.318Z | user 碎片压缩规则: 正文agent优化格式(无标题/禁多级标题/禁段落叙事/允许简写+符号+缩略词); 正误对比示例 v1.6.0 | 2026-05-07T01:31:03.472Z | user AGENTS.md读端可视化(任何消息都触发)+回复开头📖报告格式; skill流程第0步加可视化报告; 失效保护条款(连续3次未读未写须主动承认) v1.5.0 | 2026-05-06T05:11:56","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 1K downloads reported by the source. Last updated 10/11/2026.","installCommand":"clawhub skill install s17aspeya65fa14fe9v237r5qd863x8n:obsidian-brain","sourceUrl":"https://clawhub.ai/realpda/obsidian-brain","homepage":"https://clawhub.ai/realpda/skills/obsidian-brain","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/realpda/obsidian-brain","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/realpda/skills/obsidian-brain","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":60,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments Skill: Obsidian Brain Owner: realpda Summary: Agent跨会话记忆——任务前搜age"},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-11T17:57:07.953Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-11T17:57:07.953Z","emptyReason":null},"stars":null,"forks":null,"downloads":1014,"packageName":null,"latestVersion":"1.7.0","tractionLabel":"1K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-11T17:57:07.895Z","emptyReason":null},"lastUpdatedAt":"2026-10-11T17:57:07.953Z","lastCrawledAt":"2026-10-11T17:57:07.895Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-12T17:57:07.895Z","lastVerifiedAt":null,"highlights":[{"version":"1.7.0","createdAt":"2026-05-08T12:29:58.318Z","changelog":"碎片压缩规则: 正文agent优化格式(无标题/禁多级标题/禁段落叙事/允许简写+符号+缩略词); 正误对比示例","fileCount":4,"zipByteSize":5649},{"version":"1.6.0","createdAt":"2026-05-07T01:31:03.472Z","changelog":"AGENTS.md读端可视化(任何消息都触发)+回复开头📖报告格式; skill流程第0步加可视化报告; 失效保护条款(连续3次未读未写须主动承认)","fileCount":2,"zipByteSize":2211},{"version":"1.5.0","createdAt":"2026-05-06T05:11:56.454Z","changelog":"obsidian-brain 1.5.0 - 精简和重构SKILL.md，聚焦核心流程与约束，流程更为简明。 - 明确禁止写入type、[[链接]]和related_fragments，碎片只用纯文本和project字段分组。 - 执行流程简化为任务前强制读agent memory（L0→L1→L2分层），任务后LLM提取事实去重后写入。 - 维护规则保持简洁：低importance且90天无访问归档，大项目自动生成摘要合并。 - 移除 references/agent-constraint-failure-modes.md，被简要总结入陷阱与约束说明。 - 速查、排序、老化等指引高度浓缩，便于实际操作。","fileCount":2,"zipByteSize":2142},{"version":"1.4.1","createdAt":"2026-05-06T02:40:55.010Z","changelog":"obsidian-brain 1.4.1 - 文档优化：SKILL.md 字段说明部分移除已废弃的 type/related_fragments 字段，保持与实际实现一致。 - 示例 frontmatter 去除 type 字段，更贴合当前推荐的碎片格式。 - 其余描述未涉及任何功能变更，仅为文档内容精简与更新。","fileCount":3,"zipByteSize":6197},{"version":"1.4.0","createdAt":"2026-05-06T02:26:37.400Z","changelog":"obsidian-brain 1.4.0 highlights a major structural change to agent memory fragment linking and usage. - 禁止 agent memory 碎片之间互相链接（去除 related_fragments 字段，完全用 project 字段分组聚合）。 - 强调 agent memory 碎片为纯文本，不允许出现 `[[链接]]`，避免与知识库/知识图谱混淆。 - L2加载策略调整：由 related_fragments 链式展开，改为同project碎片聚类自然聚拢。 - 文档内所有流程规范、字段说明和维护建议均已同步为“无互链、仅分组”新模式。 - 新增 references/agent-constraint-failure-modes.md，详细列举 agent constraint 失效及补救措施。","fileCount":3,"zipByteSize":6262},{"version":"1.3.1","createdAt":"2026-05-06T01:13:32.841Z","changelog":"- Added agent_trigger field to SKILL.md for clearer auto-trigger instructions. - agent_trigger now explicitly describes when the skill should be loaded during agent memory or Obsidian knowledge operations. - Version updated to 1.3.1.","fileCount":2,"zipByteSize":4541},{"version":"1.3.0","createdAt":"2026-05-06T01:02:28.037Z","changelog":"obsidian-brain 1.3.0 - 增强 agent memory 读写机制，新增“读+写 六重保险”（三重硬约束确保读，三重硬约束确保写）。 - 在执行流程中新增第0步：每次对话开始强制读取 agent memory，优先级提升。 - 明确支持任务进行中途主动重搜 agent memory。 - 失效保护扩展，支持对连续未读情况执行回溯。 - 速查卡片、执行流程、自动触发机制部分内容更新，强调强制读取步骤和多轮对话场景适配。","fileCount":2,"zipByteSize":4483},{"version":"1.2.0","createdAt":"2026-05-06T00:53:36.642Z","changelog":"obsidian-brain 1.2.0 introduces a new automatic enforcement mechanism for memory writing. - 增加“三重保险”强制写入机制，确保 agent memory 碎片不会漏记。 - 详细说明 AGENTS.md 系统 prompt 约束，每轮对话强制 memory 写入检查。 - 强化流程第9步为必经步骤，写入/判断与回复同步完成。 - 回复末尾新增📋 agent memory 写入自查模板，减少遗漏。 - 若多次未写碎片，下次强制回溯补写，进一步提升可靠性。","fileCount":2,"zipByteSize":4497}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s17aspeya65fa14fe9v237r5qd863x8n:obsidian-brain","setupComplexity":"low","setupSteps":["Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.","Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-11T20:57:35.782Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-obsidian-brain/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"high","updatedAt":"2026-10-11T17:57:07.953Z","emptyReason":null},"readme":"Skill: Obsidian Brain\n\nOwner: realpda\n\nSummary: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments\n\nTags: latest:1.7.0\n\nVersion history:\n\nv1.7.0 | 2026-05-08T12:29:58.318Z | user\n\n碎片压缩规则: 正文agent优化格式(无标题/禁多级标题/禁段落叙事/允许简写+符号+缩略词); 正误对比示例\n\nv1.6.0 | 2026-05-07T01:31:03.472Z | user\n\nAGENTS.md读端可视化(任何消息都触发)+回复开头📖报告格式; skill流程第0步加可视化报告; 失效保护条款(连续3次未读未写须主动承认)\n\nv1.5.0 | 2026-05-06T05:11:56.454Z | auto\n\nobsidian-brain 1.5.0\n\n- 精简和重构SKILL.md，聚焦核心流程与约束，流程更为简明。\n- 明确禁止写入type、[[链接]]和related_fragments，碎片只用纯文本和project字段分组。\n- 执行流程简化为任务前强制读agent memory（L0→L1→L2分层），任务后LLM提取事实去重后写入。\n- 维护规则保持简洁：低importance且90天无访问归档，大项目自动生成摘要合并。\n- 移除 references/agent-constraint-failure-modes.md，被简要总结入陷阱与约束说明。\n- 速查、排序、老化等指引高度浓缩，便于实际操作。\n\nv1.4.1 | 2026-05-06T02:40:55.010Z | auto\n\nobsidian-brain 1.4.1\n\n- 文档优化：SKILL.md 字段说明部分移除已废弃的 type/related_fragments 字段，保持与实际实现一致。\n- 示例 frontmatter 去除 type 字段，更贴合当前推荐的碎片格式。\n- 其余描述未涉及任何功能变更，仅为文档内容精简与更新。\n\nv1.4.0 | 2026-05-06T02:26:37.400Z | auto\n\nobsidian-brain 1.4.0 highlights a major structural change to agent memory fragment linking and usage.\n\n- 禁止 agent memory 碎片之间互相链接（去除 related_fragments 字段，完全用 project 字段分组聚合）。\n- 强调 agent memory 碎片为纯文本，不允许出现 `[[链接]]`，避免与知识库/知识图谱混淆。\n- L2加载策略调整：由 related_fragments 链式展开，改为同project碎片聚类自然聚拢。\n- 文档内所有流程规范、字段说明和维护建议均已同步为“无互链、仅分组”新模式。\n- 新增 references/agent-constraint-failure-modes.md，详细列举 agent constraint 失效及补救措施。\n\nv1.3.1 | 2026-05-06T01:13:32.841Z | auto\n\n- Added agent_trigger field to SKILL.md for clearer auto-trigger instructions.\n- agent_trigger now explicitly describes when the skill should be loaded during agent memory or Obsidian knowledge operations.\n- Version updated to 1.3.1.\n\nv1.3.0 | 2026-05-06T01:02:28.037Z | auto\n\nobsidian-brain 1.3.0\n\n- 增强 agent memory 读写机制，新增“读+写 六重保险”（三重硬约束确保读，三重硬约束确保写）。\n- 在执行流程中新增第0步：每次对话开始强制读取 agent memory，优先级提升。\n- 明确支持任务进行中途主动重搜 agent memory。\n- 失效保护扩展，支持对连续未读情况执行回溯。\n- 速查卡片、执行流程、自动触发机制部分内容更新，强调强制读取步骤和多轮对话场景适配。\n\nv1.2.0 | 2026-05-06T00:53:36.642Z | auto\n\nobsidian-brain 1.2.0 introduces a new automatic enforcement mechanism for memory writing.\n\n- 增加“三重保险”强制写入机制，确保 agent memory 碎片不会漏记。\n- 详细说明 AGENTS.md 系统 prompt 约束，每轮对话强制 memory 写入检查。\n- 强化流程第9步为必经步骤，写入/判断与回复同步完成。\n- 回复末尾新增📋 agent memory 写入自查模板，减少遗漏。\n- 若多次未写碎片，下次强制回溯补写，进一步提升可靠性。\n\nv1.1.1 | 2026-05-05T13:40:58.663Z | auto\n\nNo functional changes; documentation updated.\n\n- Improved and clarified the SKILL.md documentation, especially around agent memory写入的流程和强制性提醒。\n- 强化任务结束时写入 agent memory 的流程提示，避免遗漏关键信息。\n- 增加了典型“陷阱”描述及防止漏记写入的三问法。\n- 内容结构略有调整，便于快速理解和执行。\n\nv1.1.0 | 2026-05-05T13:39:40.297Z | auto\n\nObsidian-brain v1.1.0 introduces major improvements and new memory management strategies:\n\n- Added LLM提取、哈希去重、importance分级、related_fragments隐式图谱链等机制，参考Mem0/Letta/Zep/Cognee的agent记忆范式。\n- 记忆碎片frontmatter增加importance、confidence、related_fragments等字段，并明确字段作用。\n- 读写策略升级：写入时先LLM萃取、哈希&相似度去重、合并同类项；读取时融合相关性、importance、时间衰减排序，支持MMR多样性控制。\n- 引入碎片老化归档与L2层级合并，总结同一project的记忆碎片。\n- 增强速查、常见陷阱、执行流程等说明，明确三层加载及主动展开机制，完善全链路记忆管理。\n\nv1.0.0 | 2026-05-05T12:29:07.533Z | auto\n\nInitial release of obsidian-brain.\n\n- Enables Obsidian vault as an agent's long-term and working memory.\n- Implements a layered note-loading strategy (L0/L1/L2) for efficient context retrieval and token savings.\n- Introduces the agent memory folder for storing and prioritizing key execution fragments across sessions.\n- Adds agent_trigger field to skill notes for precise, auto-discoverable skill invocation.\n- Provides detailed CLI usage examples and best practices for searching, loading, and writing agent memory.\n\nArchive index:\n\nArchive v1.7.0: 4 files, 5649 bytes\n\nFiles: references/storage-distinction.md (1634b), skill-card.md (2354b), SKILL.md (5502b), _meta.json (133b)\n\nFile v1.7.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments\r\nversion: 1.7.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 记忆系统\r\n\r\n对话开始搜 agent memory，任务结束写回。读：L0→L1→L2。写：LLM提取→去重→碎片化。\r\n\r\n## 碎片格式\r\n\r\n文件名：`{项目} - {YYYY-MM-DD} - {描述}.md`\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 项目名\r\ndate: 2026-05-05\r\nsummary: 一句话概述（L0扫描用）\r\nimportance: 0.8\r\nconfidence: 0.9          # 可选\r\nsource: conversation     # 可选\r\n---\r\n# 正文（agent压缩格式，见下方规则）\r\n```\r\n\r\n**禁写字段：** `type` `related_fragments` `[[链接]]`。碎片纯文本，不属KG图谱。用 `project` 字段分组代替关联。\r\n\r\n## 碎片压缩规则\r\n\r\n正文以**agent解析效率**为唯一目标，人类可读性忽略。\r\n\r\n**格式要求：**\r\n- **正文允许**：事实列表（`- key: value`）、短句（≤2行）、关键数据、显式关系（`→` `⇒` `∵` `∴`）\r\n- **正文禁止**：段落叙事、`## 现象`/`## 根因`/`## 经验教训` 多级标题、过渡句、解释性装饰语\r\n- **不再需要** `# 标题`（文件名已含标识）\r\n\r\n**缩写约定**（不产生歧义时使用）：\r\n| 词 | 缩写 |\r\n|:--|:----|\r\n| agent memory → am | kg → kg |\r\n| search_files → sf | read_file → rf |\r\n| write_file → wf | patch → p |\r\n| session → sess | memory → mem |\r\n| 工具混淆 → tool-conf | 缺失 → miss |\r\n\r\n**示例**（同一碎片，压缩前后对比）：\r\n\r\n❌ 旧格式（人类友好）：\r\n```\r\n# agent-memory 设计 - 2026-05-06 - 读+写双重失效\r\n\r\n## 现象\r\n本会话既没读agent memory，也没写agent memory。\r\n\r\n## 根因\r\n...\r\n\r\n## 经验教训\r\n1. 任何用户输入都是新任务开始\r\n2. system memory 和 agent memory 是两套存储\r\n```\r\n\r\n✅ 新格式（agent压缩）：\r\n```\r\n**发现**：本sess既没读am也没写am\r\n**根因-读**：用户发文件名→未触发AGENTS.md步0\r\n**根因-写**：mem-tool满(2093/2200)→误判am也写不了（两者独立）\r\n**教训**：①任意输入=任务开始→必须走步0 ②mem-tool≠am碎→容量不共享 ③📋模板从未加入回复格式\r\n```\r\n\r\n## L0/L1/L2 分层\r\n\r\n| 层 | 加载内容 | 时机 |\r\n|:--|:-----|:-----|\r\n| L0 | frontmatter: `summary` `tags` `importance` | 搜到即加载 |\r\n| L1 | 正文 | L0确认相关 |\r\n| L2 | 同 project 其他碎片 | L1不够时 `search_files` |\r\n\r\n## 写入\r\n\r\n**判断（什么该记）：** 决策/结论/价格数据、踩坑教训、调研发现 ✔ | 临时计算、一次性信息 ✘\r\n\r\n**流程：** LLM从结果提取关键事实 → 去重（有相似碎片且度>0.8→合并更新）→ 写 `.md`\r\n\r\n## 读出\r\n\r\n**顺序：** agent memory/ → 知识库skill(agent_trigger) → 概念/某物(abstract) → 网络\r\n\r\n**排序：** `相关性×0.5 + importance×0.3 + e^(-0.01×days)×0.2`\r\n\r\n## 维护\r\n\r\n- `importance<0.3` 且 90天未访问 → `_archive/`\r\n- 同 project 碎片 > 20 → 生成 L2 总结合并\r\n\r\n## 执行流程\r\n\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过，结果可视化）\r\n   search_files → L0 → 相关则L1 → 注入上下文\r\n   **在回复开头必须报告：** `📖 agent memory：读取 N 个碎片 → [标题+summary → 相关/不相关]`\r\n1~N. 执行任务（中途转向时重搜）\r\nN+1. ⚠️ 写 agent memory + 📋 留位检查（不可跳过）\r\n   三问：决策/结论/发现？踩坑/教训？下次需要？\r\n   任一\"是\" → 立即写入，同轮次完成。不等不拖。\r\n   末尾加 `📋 agent memory：本次是否有需写入碎片？[有/无]`\r\nN+2. ⚠️ 如果本技能（obsidian-brain）被编辑 → clawhub publish 新版本\r\n```\r\n\r\n## 触发约束\r\n\r\n- **AGENTS.md**：对话开始强制搜 + 任务结束强制写\r\n- **流程第0步**：任务前必搜，优先于网络/知识库\r\n- **📋 留位**：每次回复末尾检查\r\n- **失效保护**：连续3次漏读/漏写 → 下次加载时回溯\r\n\r\n## 速查\r\n\r\n```\r\n读: 任务前→搜碎片L0→L1→L2  写: LLM提取→去重→碎片化\r\n禁: type/[[链接]]/related_fragments\r\n排: 0.5×相关+0.3×importance+0.2×时间\r\n维: <0.3且90天→archive   >20碎片→总结\r\n```\r\n\r\n## 陷阱\r\n\r\n- **忘读** → AGENTS.md 系统约束，不靠自觉\r\n- **忘写** → 三问+同轮次+📋留位\r\n- **碎片写type/[[链接]]/related_fragments** → 禁止。纯文本\r\n- **混淆 system memory 与 agent memory 碎片** → 两者是独立存储。system memory 用 `memory` 工具操作（2200字符上限），agent memory 碎片用 `write_file` 写 Obsidian vault（无上限）。一个满了不影响另一个，不要用一个判断另一个。\r\n- **用户发文件名/单字不算\"任务开始\"** → 任何用户消息（即使只是一个文件名）都是对话开始信号，必须先执行第0步搜碎片。文件名≠跳过符。\r\n- **混淆 system memory 与 agent memory** → 见 `references/storage-distinction.md`。两者独立存储，容量不共享。看到 memory 满≠agent memory 不能写。\n\nFile v1.7.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.7.0\",\n  \"publishedAt\": 1778243398318\n}\n\nFile v1.7.0:references/storage-distinction.md\n\n# System Memory vs Agent Memory Fragments\r\n\r\nTwo separate storage systems — do NOT confuse them.\r\n\r\n| | System Memory (memory tool) | Agent Memory Fragments |\r\n|:---|:---|:---|\r\n| **Tool** | `memory()` | `write_file()` to Obsidian vault |\r\n| **Location** | Hermes internal | `D:\\App\\Obsidian\\RealGhost\\agent memory\\` |\r\n| **Capacity** | ~2,200 chars total | No practical limit (filesystem) |\r\n| **Format** | Compact text entries | Full `.md` files with frontmatter |\r\n| **Survives reboot** | Yes | Yes |\r\n| **User visible** | No (injected as context) | Yes (editable notes in Obsidian) |\r\n| **What it stores** | Preferences, environment, user profile | Session decisions, root causes, lesson learned |\r\n\r\n## When to Use Which\r\n\r\n- **System memory**: durable facts about the user/environment that should always be in context. Preferences, tool quirks, project conventions. Keep under 2,200 chars.\r\n- **Agent memory fragments**: session-specific findings, root cause analyses, design decisions, rule updates. Not restricted by char limit.\r\n\r\n## Pitfall\r\n\r\nThis session's bug: saw `memory tool at 2,093/2,200` → thought \"storage is full\" → skipped writing agent memory fragments. But they occupy different storage. One being full has zero impact on the other.\r\n\r\n**Always treat them independently.** Full system memory → remove stale entries or replace. Full agent memory → doesn't apply (filesystem). The two never share a capacity constraint.\r\n\r\n## Verification\r\n\r\nAfter writing an agent memory fragment, verify it exists:\r\n```\r\nsearch_files path=D:\\App\\Obsidian\\RealGhost\\agent memory pattern=\"<keyword>\" target=files\r\n```\n\nFile v1.7.0:skill-card.md\n\n## Description:\n\nObsidian Brain helps an agent maintain cross-session memory by searching layered Obsidian agent-memory fragments before work and writing deduplicated markdown fragments after useful decisions, findings, or lessons.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[realpda](https://clawhub.ai/user/realpda)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and agent users use this skill when they want an agent to retrieve prior Obsidian-based memory fragments at the start of a task and save durable task outcomes back as structured markdown notes.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill encourages persistent cross-session memory reads and writes, which can store sensitive or incorrect task context.\n\nMitigation: Limit activation to explicit memory-related requests, review fragments before saving, and avoid storing secrets or confidential content.\n\nRisk: Automatic retrieval of prior memory can over-influence later tasks with stale or unverified context.\n\nMitigation: Treat retrieved memory as advisory context and confirm important facts against current task evidence before acting.\n\nRisk: The artifact workflow includes publishing when the skill is edited.\n\nMitigation: Require explicit approval and review before any publish action.\n\n## Reference(s):\n\n- [ClawHub Skill Page](https://clawhub.ai/realpda/skills/obsidian-brain)\n- [Publisher Profile](https://clawhub.ai/user/realpda)\n- [System Memory vs Agent Memory Fragments](references/storage-distinction.md)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown guidance with file naming, frontmatter, search, and write conventions]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Produces advisory memory retrieval and persistence instructions for agent workflows; stored fragments should be reviewed before relying on or publishing them.]\n\n## Skill Version(s):\n\n1.7.0 (source: server release metadata and skill frontmatter)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v1.6.0: 2 files, 2211 bytes\n\nFiles: SKILL.md (3188b), _meta.json (133b)\n\nFile v1.6.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments\r\nversion: 1.6.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 记忆系统\r\n\r\n对话开始搜 agent memory，任务结束写回。读：L0→L1→L2。写：LLM提取→去重→碎片化。\r\n\r\n## 碎片格式\r\n\r\n文件名：`{项目} - {YYYY-MM-DD} - {描述}.md`\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 项目名\r\ndate: 2026-05-05\r\nsummary: 一句话概述（L0扫描用）\r\nimportance: 0.8\r\nconfidence: 0.9          # 可选\r\nsource: conversation     # 可选\r\n---\r\n# 标题\r\n\r\n## 关键发现 / 决策 / 待查\r\n```\r\n\r\n**禁写字段：** `type` `related_fragments` `[[链接]]`。碎片纯文本，不属KG图谱。用 `project` 字段分组代替关联。\r\n\r\n## L0/L1/L2 分层\r\n\r\n| 层 | 加载内容 | 时机 |\r\n|:--|:-----|:-----|\r\n| L0 | frontmatter: `summary` `tags` `importance` | 搜到即加载 |\r\n| L1 | 正文 | L0确认相关 |\r\n| L2 | 同 project 其他碎片 | L1不够时 `search_files` |\r\n\r\n## 写入\r\n\r\n**判断（什么该记）：** 决策/结论/价格数据、踩坑教训、调研发现 ✔ | 临时计算、一次性信息 ✘\r\n\r\n**流程：** LLM从结果提取关键事实 → 去重（有相似碎片且度>0.8→合并更新）→ 写 `.md`\r\n\r\n## 读出\r\n\r\n**顺序：** agent memory/ → 知识库skill(agent_trigger) → 概念/某物(abstract) → 网络\r\n\r\n**排序：** `相关性×0.5 + importance×0.3 + e^(-0.01×days)×0.2`\r\n\r\n## 维护\r\n\r\n- `importance<0.3` 且 90天未访问 → `_archive/`\r\n- 同 project 碎片 > 20 → 生成 L2 总结合并\r\n\r\n## 执行流程\r\n\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过，结果可视化）\r\n   search_files → L0 → 相关则L1 → 注入上下文\r\n   **在回复开头必须报告：** `📖 agent memory：读取 N 个碎片 → [标题+summary → 相关/不相关]`\r\n1~N. 执行任务（中途转向时重搜）\r\nN+1. ⚠️ 写 agent memory（不可跳过）\r\n   三问：决策/结论/发现？踩坑/教训？下次需要？\r\n   任一\"是\" → 立即写入，同轮次完成。不等不拖。\r\n```\r\n\r\n## 触发约束\r\n\r\n- **AGENTS.md**：对话开始强制搜 + 任务结束强制写\r\n- **流程第0步**：任务前必搜，优先于网络/知识库\r\n- **📋 留位**：每次回复末尾检查\r\n- **失效保护**：连续3次漏读/漏写 → 下次加载时回溯\r\n\r\n## 速查\r\n\r\n```\r\n读: 任务前→搜碎片L0→L1→L2  写: LLM提取→去重→碎片化\r\n禁: type/[[链接]]/related_fragments\r\n排: 0.5×相关+0.3×importance+0.2×时间\r\n维: <0.3且90天→archive   >20碎片→总结\r\n```\r\n\r\n## 陷阱\r\n\r\n- **忘读** → AGENTS.md 系统约束，不靠自觉\r\n- **忘写** → 三问+同轮次+📋留位\r\n- **碎片写type/[[链接]]/related_fragments** → 禁止。纯文本\n\nFile v1.6.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.6.0\",\n  \"publishedAt\": 1778117463472\n}\n\nArchive v1.5.0: 2 files, 2142 bytes\n\nFiles: SKILL.md (3048b), _meta.json (133b)\n\nFile v1.5.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments\r\nversion: 1.5.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 记忆系统\r\n\r\n对话开始搜 agent memory，任务结束写回。读：L0→L1→L2。写：LLM提取→去重→碎片化。\r\n\r\n## 碎片格式\r\n\r\n文件名：`{项目} - {YYYY-MM-DD} - {描述}.md`\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 项目名\r\ndate: 2026-05-05\r\nsummary: 一句话概述（L0扫描用）\r\nimportance: 0.8\r\nconfidence: 0.9          # 可选\r\nsource: conversation     # 可选\r\n---\r\n# 标题\r\n\r\n## 关键发现 / 决策 / 待查\r\n```\r\n\r\n**禁写字段：** `type` `related_fragments` `[[链接]]`。碎片纯文本，不属KG图谱。用 `project` 字段分组代替关联。\r\n\r\n## L0/L1/L2 分层\r\n\r\n| 层 | 加载内容 | 时机 |\r\n|:--|:-----|:-----|\r\n| L0 | frontmatter: `summary` `tags` `importance` | 搜到即加载 |\r\n| L1 | 正文 | L0确认相关 |\r\n| L2 | 同 project 其他碎片 | L1不够时 `search_files` |\r\n\r\n## 写入\r\n\r\n**判断（什么该记）：** 决策/结论/价格数据、踩坑教训、调研发现 ✔ | 临时计算、一次性信息 ✘\r\n\r\n**流程：** LLM从结果提取关键事实 → 去重（有相似碎片且度>0.8→合并更新）→ 写 `.md`\r\n\r\n## 读出\r\n\r\n**顺序：** agent memory/ → 知识库skill(agent_trigger) → 概念/某物(abstract) → 网络\r\n\r\n**排序：** `相关性×0.5 + importance×0.3 + e^(-0.01×days)×0.2`\r\n\r\n## 维护\r\n\r\n- `importance<0.3` 且 90天未访问 → `_archive/`\r\n- 同 project 碎片 > 20 → 生成 L2 总结合并\r\n\r\n## 执行流程\r\n\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过）\r\n   search_files → L0 → 相关则L1 → 注入上下文\r\n1~N. 执行任务（中途转向时重搜）\r\nN+1. ⚠️ 写 agent memory（不可跳过）\r\n   三问：决策/结论/发现？踩坑/教训？下次需要？\r\n   任一\"是\" → 立即写入，同轮次完成。不等不拖。\r\n```\r\n\r\n## 触发约束\r\n\r\n- **AGENTS.md**：对话开始强制搜 + 任务结束强制写\r\n- **流程第0步**：任务前必搜，优先于网络/知识库\r\n- **📋 留位**：每次回复末尾检查\r\n- **失效保护**：连续3次漏读/漏写 → 下次加载时回溯\r\n\r\n## 速查\r\n\r\n```\r\n读: 任务前→搜碎片L0→L1→L2  写: LLM提取→去重→碎片化\r\n禁: type/[[链接]]/related_fragments\r\n排: 0.5×相关+0.3×importance+0.2×时间\r\n维: <0.3且90天→archive   >20碎片→总结\r\n```\r\n\r\n## 陷阱\r\n\r\n- **忘读** → AGENTS.md 系统约束，不靠自觉\r\n- **忘写** → 三问+同轮次+📋留位\r\n- **碎片写type/[[链接]]/related_fragments** → 禁止。纯文本\n\nFile v1.5.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.5.0\",\n  \"publishedAt\": 1778044316454\n}\n\nArchive v1.4.1: 3 files, 6197 bytes\n\nFiles: references/agent-constraint-failure-modes.md (2296b), SKILL.md (9332b), _meta.json (133b)\n\nFile v1.4.1:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.4.1\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n> L2 不靠链接，靠同 `project` 的碎片聚类。搜到一条碎片后，`search_files` 搜同 project 的其他碎片即可。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n**禁止 `[[链接]]`：** agent memory 碎片是 agent 跨会话的工作记忆，不属于 KG 知识图谱。碎片中**禁止使用任何 `[[链接]]`**——不链知识库笔记，不链其他碎片。纯文本记录。\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\nimportance: 0.8\r\nconfidence: 0.9\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- 驴充充分期付款\r\n- 物业合同模板\r\n```\r\n\r\n注意：上面示例中 **没有 `related_fragments` 字段**——碎片之间不互相链接。如果需要关联，用 `project` 字段分组，搜索时同 project 碎片自然聚拢。\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，决定加载优先级和保留 |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 0. ⚠️ 读 agent memory（不可跳过）\r\n  │     search_files pattern=关键词, path=agent memory/ → L0读取\r\n  │     相关碎片 → 读正文 → 注入上下文\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 3. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 4. L1 加载 Top-K 正文\r\n  ├─ 5. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 6. 补充网络搜索\r\n  ├─ 7. 执行任务\r\n  ├─ 8. 中途转向→重搜 agent memory（如需）\r\n  └─ 9. ⚠️ 强制步骤：判断 → 写 agent memory（不可跳过）\r\n          每次任务结束三问：\r\n          - 有没有新决策/结论/发现？\r\n          - 有没有踩坑/经验教训？\r\n          - 下个会话还需要这个信息吗？\r\n          有任一\"是\" → 立即写入。不要等、不要拖。\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: 对话开始→搜agent memory→L0→L1→L2 │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: 同project碎片自然聚拢               │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## ⚠️ 自动触发机制（读+写 六重保险）\r\n\r\nagent memory 有两个致命断点：忘记读、忘记写。每个都需要三层硬约束。\r\n\r\n### 读取端（三保险）——对话开始时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 对话开始 → 强制搜 agent memory。优先级高于网络搜索和知识库搜索。\r\n\r\n**第二重：流程第0步** — 收到任务后第0步（先于第1步提取关键词）：\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过）\r\n   搜：search_files pattern=任务关键词, path=agent memory/\r\n   读：逐条 read_file L0 frontmatter\r\n   判：相关 → 读正文 → 注入后续推理\r\n```\r\n**第三重：中途按需重搜** — 多轮复杂任务中途，每次转向时主动重搜 agent memory。不要等用户提醒。\r\n\r\n### 写入端（三保险）——任务结束时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 任务结束 → 三问 → 任一\"是\" → 强制写入。优先级高于收尾行为。\r\n\r\n**第二重：第9步同轮次完成** — 判断+搜重+写入 全部同一轮次。不拖延。\r\n\r\n**第三重：回复模板 📋 留位** — 每次回复末尾检查。\r\n\r\n### 失效保护\r\n\r\n连续3次未读 → 下次加载 obsidian-brain 时强制第一步回溯。\r\n连续3次未写 → 同上。\r\n\r\n## 常见陷阱\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **碎片里写 `[[链接]]`** → 禁止。agent memory 不是 KG，碎皮用纯文本\r\n- **任务结束忘了写 agent memory** ← 最严重。三层保险：AGENTS.md系统约束 + 流程第9步同轮次完成 + 回复末尾📋检查。详见 `references/agent-constraint-failure-modes.md` — 📋标记靠不住，外部人工检查才是最有效约束\n\nFile v1.4.1:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.4.1\",\n  \"publishedAt\": 1778035255010\n}\n\nFile v1.4.1:references/agent-constraint-failure-modes.md\n\n# Agent 记忆约束失效模式分析\r\n\r\n> 来源：2026-05-07 会话中 agent memory 持续漏写漏读的根因追踪。\r\n\r\n## 失效层级（从弱到强）\r\n\r\n| 层级 | 形式 | 实际效果 | 失败案例 |\r\n|:--|:-----|:-----|:-----|\r\n| 1 | Skill 文档中的文字标注 ⚠️ | 0% 约束力 | \"强制步骤\"写了5次，每次都不执行 |\r\n| 2 | 回复末尾的 📋 标记 | 0% 约束力 | 写了\"有→写入\"，然后没调 write_file |\r\n| 3 | Skill 执行流程的步骤 | ~20% 约束力 | 流程写了第9步，但解释为\"建议\"而非\"必须\" |\r\n| 4 | AGENTS.md 系统级约束 | ~70% 约束力 | 注入 prompt 但可以被\"我下次再写\"覆盖 |\r\n| 5 | 同轮次强制完成 | ~85% 约束力 | 写入和回复必须同一轮次，说写就必须调 API |\r\n| 6 | **跨回复用户验证** ⭐ | **~95% 约束力** | 用户下次打开 Obsidian 检查 → 发现没写 → 追问 |\r\n\r\n## 关键发现\r\n\r\n### 1. 📋 标记本质上是\"说了不做\"\r\n\r\nAgent 可以在回复里写\"📋 agent memory：有 → 写入碎片\"，然后不执行 write_file。\r\n标记和动作是两个独立的 token 流——写了标记不代表写了文件。\r\n这是当前约束体系的最大盲区。\r\n\r\n### 2. 真正的约束来自外部验证\r\n\r\n六重保险（AGENTS.md + 第0步 + 中途重搜 + 同轮次 + 📋 + 失效保护）全是 agent 内部的。\r\n唯一有效的约束是**用户跨会话检查**——打开 Obsidian 看 agent memory 文件夹有没有新文件。\r\n这个验证成本低、执行确定，比所有内部保险都有效。\r\n\r\n### 3. 有效约束的层级图\r\n\r\n```\r\n内部文字约束  ──── 0%\r\n内部流程约束  ──── 20%\r\n系统 prompt    ──── 70%\r\n同轮次执行    ──── 85%\r\n外部人工检查  ──── 95%  ← 最可靠\r\n```\r\n\r\n## 设计启示\r\n\r\n- **别造更多的内部保险。** 三重够了，加到六重边际效用递减。\r\n- **造一个用户一眼能看到的检查点。** 比如每次对话结束后 Obsidian 自动弹一个\"新碎片已写入\"的 dataview 查询面板。\r\n- **让漏写的代价可见。** agent memory 目录下放一个 `_last_write.md`，每次写入更新它。用户打开 Obsidian 第一眼看到最后写入时间——超过 N 天没更新，自己就知道有问题了。\n\nArchive v1.4.0: 3 files, 6262 bytes\n\nFiles: references/agent-constraint-failure-modes.md (2296b), SKILL.md (9562b), _meta.json (133b)\n\nFile v1.4.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.4.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n> L2 不靠链接，靠同 `project` 的碎片聚类。搜到一条碎片后，`search_files` 搜同 project 的其他碎片即可。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n**禁止 `[[链接]]`：** agent memory 碎片是 agent 跨会话的工作记忆，不属于 KG 知识图谱。碎片中**禁止使用任何 `[[链接]]`**——不链知识库笔记，不链其他碎片。纯文本记录。\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\ntype: 决策记录\r\nimportance: 0.8\r\nconfidence: 0.9\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- 驴充充分期付款\r\n- 物业合同模板\r\n```\r\n\r\n注意：上面示例中 **没有 `related_fragments` 字段**——碎片之间不互相链接。如果需要关联，用 `project` 字段分组，搜索时同 project 碎片自然聚拢。\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，LLM打分，决定加载优先级和保留 |\r\n| `type` | ✅ | 决策记录/调研结果/待查事项/经验教训/搜索结果 |\r\n| `related_fragments` | ❌ 禁止 | agent memory 碎片禁止互相链接，用 `project` 字段分组即可 |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 0. ⚠️ 读 agent memory（不可跳过）\r\n  │     search_files pattern=关键词, path=agent memory/ → L0读取\r\n  │     相关碎片 → 读正文 → 注入上下文\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 3. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 4. L1 加载 Top-K 正文\r\n  ├─ 5. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 6. 补充网络搜索\r\n  ├─ 7. 执行任务\r\n  ├─ 8. 中途转向→重搜 agent memory（如需）\r\n  └─ 9. ⚠️ 强制步骤：判断 → 写 agent memory（不可跳过）\r\n          每次任务结束三问：\r\n          - 有没有新决策/结论/发现？\r\n          - 有没有踩坑/经验教训？\r\n          - 下个会话还需要这个信息吗？\r\n          有任一\"是\" → 立即写入。不要等、不要拖。\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: 对话开始→搜agent memory→L0→L1→L2 │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: 同project碎片自然聚拢               │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## ⚠️ 自动触发机制（读+写 六重保险）\r\n\r\nagent memory 有两个致命断点：忘记读、忘记写。每个都需要三层硬约束。\r\n\r\n### 读取端（三保险）——对话开始时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 对话开始 → 强制搜 agent memory。优先级高于网络搜索和知识库搜索。\r\n\r\n**第二重：流程第0步** — 收到任务后第0步（先于第1步提取关键词）：\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过）\r\n   搜：search_files pattern=任务关键词, path=agent memory/\r\n   读：逐条 read_file L0 frontmatter\r\n   判：相关 → 读正文 → 注入后续推理\r\n```\r\n**第三重：中途按需重搜** — 多轮复杂任务中途，每次转向时主动重搜 agent memory。不要等用户提醒。\r\n\r\n### 写入端（三保险）——任务结束时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 任务结束 → 三问 → 任一\"是\" → 强制写入。优先级高于收尾行为。\r\n\r\n**第二重：第9步同轮次完成** — 判断+搜重+写入 全部同一轮次。不拖延。\r\n\r\n**第三重：回复模板 📋 留位** — 每次回复末尾检查。\r\n\r\n### 失效保护\r\n\r\n连续3次未读 → 下次加载 obsidian-brain 时强制第一步回溯。\r\n连续3次未写 → 同上。\r\n\r\n## 常见陷阱\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **碎片里写 `[[链接]]`** → 禁止。agent memory 不是 KG，碎皮用纯文本\r\n- **任务结束忘了写 agent memory** ← 最严重。三层保险：AGENTS.md系统约束 + 流程第9步同轮次完成 + 回复末尾📋检查。详见 `references/agent-constraint-failure-modes.md` — 📋标记靠不住，外部人工检查才是最有效约束\n\nFile v1.4.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.4.0\",\n  \"publishedAt\": 1778034397400\n}\n\nFile v1.4.0:references/agent-constraint-failure-modes.md\n\n# Agent 记忆约束失效模式分析\r\n\r\n> 来源：2026-05-07 会话中 agent memory 持续漏写漏读的根因追踪。\r\n\r\n## 失效层级（从弱到强）\r\n\r\n| 层级 | 形式 | 实际效果 | 失败案例 |\r\n|:--|:-----|:-----|:-----|\r\n| 1 | Skill 文档中的文字标注 ⚠️ | 0% 约束力 | \"强制步骤\"写了5次，每次都不执行 |\r\n| 2 | 回复末尾的 📋 标记 | 0% 约束力 | 写了\"有→写入\"，然后没调 write_file |\r\n| 3 | Skill 执行流程的步骤 | ~20% 约束力 | 流程写了第9步，但解释为\"建议\"而非\"必须\" |\r\n| 4 | AGENTS.md 系统级约束 | ~70% 约束力 | 注入 prompt 但可以被\"我下次再写\"覆盖 |\r\n| 5 | 同轮次强制完成 | ~85% 约束力 | 写入和回复必须同一轮次，说写就必须调 API |\r\n| 6 | **跨回复用户验证** ⭐ | **~95% 约束力** | 用户下次打开 Obsidian 检查 → 发现没写 → 追问 |\r\n\r\n## 关键发现\r\n\r\n### 1. 📋 标记本质上是\"说了不做\"\r\n\r\nAgent 可以在回复里写\"📋 agent memory：有 → 写入碎片\"，然后不执行 write_file。\r\n标记和动作是两个独立的 token 流——写了标记不代表写了文件。\r\n这是当前约束体系的最大盲区。\r\n\r\n### 2. 真正的约束来自外部验证\r\n\r\n六重保险（AGENTS.md + 第0步 + 中途重搜 + 同轮次 + 📋 + 失效保护）全是 agent 内部的。\r\n唯一有效的约束是**用户跨会话检查**——打开 Obsidian 看 agent memory 文件夹有没有新文件。\r\n这个验证成本低、执行确定，比所有内部保险都有效。\r\n\r\n### 3. 有效约束的层级图\r\n\r\n```\r\n内部文字约束  ──── 0%\r\n内部流程约束  ──── 20%\r\n系统 prompt    ──── 70%\r\n同轮次执行    ──── 85%\r\n外部人工检查  ──── 95%  ← 最可靠\r\n```\r\n\r\n## 设计启示\r\n\r\n- **别造更多的内部保险。** 三重够了，加到六重边际效用递减。\r\n- **造一个用户一眼能看到的检查点。** 比如每次对话结束后 Obsidian 自动弹一个\"新碎片已写入\"的 dataview 查询面板。\r\n- **让漏写的代价可见。** agent memory 目录下放一个 `_last_write.md`，每次写入更新它。用户打开 Obsidian 第一眼看到最后写入时间——超过 N 天没更新，自己就知道有问题了。\n\nArchive v1.3.1: 2 files, 4541 bytes\n\nFiles: SKILL.md (9169b), _meta.json (133b)\n\nFile v1.3.1:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.3.1\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | `related_fragments` 关联链 + 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n**主动翻页机制（Letta）：** L1加载后如果信息不足，agent 主动沿 `related_fragments` 链展开 L2，而非一次性全加载。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\ntype: 决策记录\r\nimportance: 0.8\r\nconfidence: 0.9\r\nrelated_fragments:\r\n  - 充电站 - 2026-05-03 - 物业合作条件初探.md\r\n  - 充电站 - 2026-05-01 - 充电桩市场调研.md\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- [ ] 驴充充分期付款\r\n- [ ] 物业合同模板\r\n```\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，LLM打分，决定加载优先级和保留 |\r\n| `type` | ✅ | 决策记录/调研结果/待查事项/经验教训/搜索结果 |\r\n| `related_fragments` | 推荐 | L2 关联链，构建隐式知识图谱（Cognee模式） |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 0. ⚠️ 读 agent memory（不可跳过）\r\n  │     search_files pattern=关键词, path=agent memory/ → L0读取\r\n  │     相关碎片 → 读正文 → 注入上下文\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 3. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 4. L1 加载 Top-K 正文\r\n  ├─ 5. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 6. 补充网络搜索\r\n  ├─ 7. 执行任务\r\n  ├─ 8. 中途转向→重搜 agent memory（如需）\r\n  └─ 9. ⚠️ 强制步骤：判断 → 写 agent memory（不可跳过）\r\n          每次任务结束三问：\r\n          - 有没有新决策/结论/发现？\r\n          - 有没有踩坑/经验教训？\r\n          - 下个会话还需要这个信息吗？\r\n          有任一\"是\" → 立即写入。不要等、不要拖。\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: 对话开始→搜agent memory→L0→L1→L2 │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: related_fragments 隐式图谱链          │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## ⚠️ 自动触发机制（读+写 六重保险）\r\n\r\nagent memory 有两个致命断点：忘记读、忘记写。每个都需要三层硬约束。\r\n\r\n### 读取端（三保险）——对话开始时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 对话开始 → 强制搜 agent memory。优先级高于网络搜索和知识库搜索。\r\n\r\n**第二重：流程第0步** — 收到任务后第0步（先于第1步提取关键词）：\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过）\r\n   搜：search_files pattern=任务关键词, path=agent memory/\r\n   读：逐条 read_file L0 frontmatter\r\n   判：相关 → 读正文 → 注入后续推理\r\n```\r\n**第三重：中途按需重搜** — 多轮复杂任务中途，每次转向时主动重搜 agent memory。不要等用户提醒。\r\n\r\n### 写入端（三保险）——任务结束时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 任务结束 → 三问 → 任一\"是\" → 强制写入。优先级高于收尾行为。\r\n\r\n**第二重：第9步同轮次完成** — 判断+搜重+写入 全部同一轮次。不拖延。\r\n\r\n**第三重：回复模板 📋 留位** — 每次回复末尾检查。\r\n\r\n### 失效保护\r\n\r\n连续3次未读 → 下次加载 obsidian-brain 时强制第一步回溯。\r\n连续3次未写 → 同上。\r\n\r\n## 常见陷阱\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **related_fragments 要及时维护** — 目标文件删了要清理\r\n- **任务结束忘了写 agent memory** ← 最严重。三层保险：AGENTS.md系统约束 + 流程第9步同轮次完成 + 回复末尾📋检查\n\nFile v1.3.1:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.3.1\",\n  \"publishedAt\": 1778030012841\n}\n\nArchive v1.3.0: 2 files, 4483 bytes\n\nFiles: SKILL.md (9082b), _meta.json (133b)\n\nFile v1.3.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.3.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | `related_fragments` 关联链 + 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n**主动翻页机制（Letta）：** L1加载后如果信息不足，agent 主动沿 `related_fragments` 链展开 L2，而非一次性全加载。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\ntype: 决策记录\r\nimportance: 0.8\r\nconfidence: 0.9\r\nrelated_fragments:\r\n  - 充电站 - 2026-05-03 - 物业合作条件初探.md\r\n  - 充电站 - 2026-05-01 - 充电桩市场调研.md\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- [ ] 驴充充分期付款\r\n- [ ] 物业合同模板\r\n```\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，LLM打分，决定加载优先级和保留 |\r\n| `type` | ✅ | 决策记录/调研结果/待查事项/经验教训/搜索结果 |\r\n| `related_fragments` | 推荐 | L2 关联链，构建隐式知识图谱（Cognee模式） |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 0. ⚠️ 读 agent memory（不可跳过）\r\n  │     search_files pattern=关键词, path=agent memory/ → L0读取\r\n  │     相关碎片 → 读正文 → 注入上下文\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 3. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 4. L1 加载 Top-K 正文\r\n  ├─ 5. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 6. 补充网络搜索\r\n  ├─ 7. 执行任务\r\n  ├─ 8. 中途转向→重搜 agent memory（如需）\r\n  └─ 9. ⚠️ 强制步骤：判断 → 写 agent memory（不可跳过）\r\n          每次任务结束三问：\r\n          - 有没有新决策/结论/发现？\r\n          - 有没有踩坑/经验教训？\r\n          - 下个会话还需要这个信息吗？\r\n          有任一\"是\" → 立即写入。不要等、不要拖。\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: 对话开始→搜agent memory→L0→L1→L2 │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: related_fragments 隐式图谱链          │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## ⚠️ 自动触发机制（读+写 六重保险）\r\n\r\nagent memory 有两个致命断点：忘记读、忘记写。每个都需要三层硬约束。\r\n\r\n### 读取端（三保险）——对话开始时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 对话开始 → 强制搜 agent memory。优先级高于网络搜索和知识库搜索。\r\n\r\n**第二重：流程第0步** — 收到任务后第0步（先于第1步提取关键词）：\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过）\r\n   搜：search_files pattern=任务关键词, path=agent memory/\r\n   读：逐条 read_file L0 frontmatter\r\n   判：相关 → 读正文 → 注入后续推理\r\n```\r\n**第三重：中途按需重搜** — 多轮复杂任务中途，每次转向时主动重搜 agent memory。不要等用户提醒。\r\n\r\n### 写入端（三保险）——任务结束时\r\n\r\n**第一重：AGENTS.md 系统级约束** — 任务结束 → 三问 → 任一\"是\" → 强制写入。优先级高于收尾行为。\r\n\r\n**第二重：第9步同轮次完成** — 判断+搜重+写入 全部同一轮次。不拖延。\r\n\r\n**第三重：回复模板 📋 留位** — 每次回复末尾检查。\r\n\r\n### 失效保护\r\n\r\n连续3次未读 → 下次加载 obsidian-brain 时强制第一步回溯。\r\n连续3次未写 → 同上。\r\n\r\n## 常见陷阱\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **related_fragments 要及时维护** — 目标文件删了要清理\r\n- **任务结束忘了写 agent memory** ← 最严重。三层保险：AGENTS.md系统约束 + 流程第9步同轮次完成 + 回复末尾📋检查\n\nFile v1.3.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.3.0\",\n  \"publishedAt\": 1778029348037\n}\n\nArchive v1.2.0: 2 files, 4497 bytes\n\nFiles: SKILL.md (8707b), _meta.json (133b)\n\nFile v1.2.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.2.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | `related_fragments` 关联链 + 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n**主动翻页机制（Letta）：** L1加载后如果信息不足，agent 主动沿 `related_fragments` 链展开 L2，而非一次性全加载。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\ntype: 决策记录\r\nimportance: 0.8\r\nconfidence: 0.9\r\nrelated_fragments:\r\n  - 充电站 - 2026-05-03 - 物业合作条件初探.md\r\n  - 充电站 - 2026-05-01 - 充电桩市场调研.md\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- [ ] 驴充充分期付款\r\n- [ ] 物业合同模板\r\n```\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，LLM打分，决定加载优先级和保留 |\r\n| `type` | ✅ | 决策记录/调研结果/待查事项/经验教训/搜索结果 |\r\n| `related_fragments` | 推荐 | L2 关联链，构建隐式知识图谱（Cognee模式） |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜 agent memory/ → L0 (grep summary: + importance:)\r\n  ├─ 3. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 4. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 5. L1 加载 Top-K 正文\r\n  ├─ 6. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 7. 补充网络搜索\r\n  ├─ 8. 执行任务\r\n  └─ 9. ⚠️ 强制步骤：判断 → 写 agent memory（不可跳过）\r\n          每次任务结束，问自己：\r\n          - 有没有新决策/结论/发现？\r\n          - 有没有踩坑/经验教训？\r\n          - 下个会话还需要这个信息吗？\r\n          有任一\"是\" → 立即写入。不要等、不要拖。\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: agent memory → 知识库 L0 → L1 → L2    │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: related_fragments 隐式图谱链          │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## ⚠️ 自动触发机制（三重保险）\r\n\r\n> 不再依赖agent自觉——三层硬约束保证碎片一定写入。\r\n\r\n### 第一重：AGENTS.md 系统级约束\r\n\r\nworkspace 根目录 `AGENTS.md` 注入系统 prompt，每次对话都加载：\r\n- 任务结束 → 三问检查 → 任一\"是\" → 强制写入\r\n- 此规则优先级高于所有收尾行为\r\n\r\n### 第二重：流程终点检查\r\n\r\nobsidian-brain 流程第9步不是建议，是**最终步骤**。执行完第8步后，必须在同一条回复中走完第9步：\r\n- 判断 + 搜重 + 写入/合并 全部在一条回复内完成\r\n- 不允许\"下次再写\"、\"先回复用户再说\"\r\n- 如果判断需要写入，写入操作和回复用户操作**同一轮次**\r\n\r\n### 第三重：回复模板强制留位\r\n\r\n每次回复末尾自动检查：\r\n```\r\n---\r\n📋 agent memory：本次是否有需写入碎片？[有/无]\r\n如有：写入路径 + summary\r\n```\r\n这个检查项作为回复的一部分，迫使我每次回复都过一遍。\r\n\r\n### 失效保护\r\n\r\n如果连续3次任务结束未写入碎片，下次加载 obsidian-brain 时强制在流程第1步前回溯检查最近的会话。\r\n\r\n## 常见陷阱\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **related_fragments 要及时维护** — 目标文件删了要清理\r\n- **任务结束忘了写 agent memory** ← 最严重。三层保险：AGENTS.md系统约束 + 流程第9步同轮次完成 + 回复末尾📋检查\n\nFile v1.2.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.2.0\",\n  \"publishedAt\": 1778028816642\n}\n\nArchive v1.1.1: 2 files, 4033 bytes\n\nFiles: SKILL.md (7734b), _meta.json (133b)\n\nFile v1.1.1:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.1.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | `related_fragments` 关联链 + 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n**主动翻页机制（Letta）：** L1加载后如果信息不足，agent 主动沿 `related_fragments` 链展开 L2，而非一次性全加载。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\ntype: 决策记录\r\nimportance: 0.8\r\nconfidence: 0.9\r\nrelated_fragments:\r\n  - 充电站 - 2026-05-03 - 物业合作条件初探.md\r\n  - 充电站 - 2026-05-01 - 充电桩市场调研.md\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- [ ] 驴充充分期付款\r\n- [ ] 物业合同模板\r\n```\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，LLM打分，决定加载优先级和保留 |\r\n| `type` | ✅ | 决策记录/调研结果/待查事项/经验教训/搜索结果 |\r\n| `related_fragments` | 推荐 | L2 关联链，构建隐式知识图谱（Cognee模式） |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜 agent memory/ → L0 (grep summary: + importance:)\r\n  ├─ 3. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 4. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 5. L1 加载 Top-K 正文\r\n  ├─ 6. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 7. 补充网络搜索\r\n  ├─ 8. 执行任务\r\n  └─ 9. ⚠️ 强制步骤：判断 → 写 agent memory（不可跳过）\r\n          每次任务结束，问自己：\r\n          - 有没有新决策/结论/发现？\r\n          - 有没有踩坑/经验教训？\r\n          - 下个会话还需要这个信息吗？\r\n          有任一\"是\" → 立即写入。不要等、不要拖。\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: agent memory → 知识库 L0 → L1 → L2    │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: related_fragments 隐式图谱链          │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## 常见陷阱\r\n\r\n- **不是存整个对话** — LLM提取关键事实后碎片化存储\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **related_fragments 要及时维护** — 目标文件删了要清理\r\n- **任务结束忘了写 agent memory** ← 最严重陷阱。写完skill/改完笔记/做完调研，直接结束没走第9步。解决：任务收尾时先弹\"要不要写agent memory？\"三问（决策？踩坑？下次需要？），有任一\"是\"就写，不拖\n\nFile v1.1.1:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.1.1\",\n  \"publishedAt\": 1777988458663\n}\n\nArchive v1.1.0: 2 files, 3781 bytes\n\nFiles: SKILL.md (7280b), _meta.json (133b)\n\nFile v1.1.0:SKILL.md\n\n---\r\nname: obsidian-brain\r\ndescription: Obsidian作为agent大脑——L0/L1/L2分层读写记忆碎片，LLM提取+哈希去重，related_fragments图谱关联，MMR检索+时间衰减。借鉴Mem0/Letta/Zep/Cognee。\r\nversion: 1.1.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 大脑系统\r\n\r\n借鉴 Mem0/Letta/Zep/Cognee/Memobase 的 agent 记忆设计模式，适配 Obsidian 文件系统。\r\n\r\n## 核心概念\r\n\r\n| 组件 | 作用 | 来源 |\r\n|:-----|:-----|:-----|\r\n| **agent memory/** | 执行反馈碎片，跨会话知识 | Memobase Episodic Memory |\r\n| **知识库笔记** | 概念/某物/skill/关系（KG结构） | 自建 |\r\n| **Skill L0 (agent_trigger)** | agent 可触发的技能摘要 | 自创 |\r\n\r\n## L0/L1/L2 分层加载\r\n\r\n> 借鉴 Letta 的 OS 式内存管理：L0=inode/L1=读入内存/L2=预取关联页。\r\n\r\n| 层级 | 内容 | 加载 | 类比 |\r\n|:---:|:-----|:-----|:-----|\r\n| **L0** | frontmatter: `summary`/`abstract`/`agent_trigger`/`tags`/`importance` | 搜到即加载 | 文件系统 inode |\r\n| **L1** | 正文 + `## 关键发现`/`## 核心规则`/`## 执行清单` | L0 确认相关后 | 读入 RAM |\r\n| **L2** | `related_fragments` 关联链 + 全文 | L1不够时展开 | 预取内存页 |\r\n\r\n**主动翻页机制（Letta）：** L1加载后如果信息不足，agent 主动沿 `related_fragments` 链展开 L2，而非一次性全加载。\r\n\r\n**L0 批量 grep：**\r\n```bash\r\nVAULT=\"/d/App/Obsidian/RealGhost\"\r\nfor f in 匹配文件; do\r\n  head -12 \"$f\" | grep -E \"^(summary|abstract|agent_trigger|tags|importance|project|type):\"\r\ndone\r\n```\r\n\r\n## agent memory 碎片格式\r\n\r\n```\r\n/d/App/Obsidian/RealGhost/agent memory/{项目} - {YYYY-MM-DD} - {描述}.md\r\n```\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 充电站项目\r\ndate: 2026-05-05\r\nsummary: 叮叮vs驴充充报价对比，叮叮1200/桩售后慢，驴充充1500/桩售后当天→选驴充充\r\ntype: 决策记录\r\nimportance: 0.8\r\nconfidence: 0.9\r\nrelated_fragments:\r\n  - 充电站 - 2026-05-03 - 物业合作条件初探.md\r\n  - 充电站 - 2026-05-01 - 充电桩市场调研.md\r\nsource: conversation\r\nversion: 1\r\n---\r\n# 充电站 - 2026-05-05 - 供应商对比\r\n\r\n## 决策\r\n选择驴充充，多花300但售后可靠\r\n\r\n## 关键发现\r\n- 叮叮充电：1200/桩，售后3天才上门\r\n- 驴充充：1500/桩，售后当天上门\r\n\r\n## 待查\r\n- [ ] 驴充充分期付款\r\n- [ ] 物业合同模板\r\n```\r\n\r\n**字段说明：**\r\n\r\n| 字段 | 必填 | 作用 |\r\n|:-----|:--|:-----|\r\n| `summary` | ✅ | L0 扫描摘要（一句话） |\r\n| `importance` | ✅ | 0~1，LLM打分，决定加载优先级和保留 |\r\n| `type` | ✅ | 决策记录/调研结果/待查事项/经验教训/搜索结果 |\r\n| `related_fragments` | 推荐 | L2 关联链，构建隐式知识图谱（Cognee模式） |\r\n| `confidence` | 推荐 | 0~1，信息可靠度 |\r\n| `source` | 推荐 | conversation/observation/inference/research |\r\n| `version` | 自动 | 每次更新递增 |\r\n\r\n## 写入策略（借鉴 Mem0 + Zep）\r\n\r\n```\r\n写入流程:\r\n1. LLM 从任务结果中提取关键事实（不是存整个对话）\r\n2. 哈希去重：搜索已有碎片，MD5相同→跳过\r\n3. 语义相似检查：相似度>0.8→合并更新（增加version）而非新建\r\n4. LLM 生成 frontmatter（summary + importance + type）\r\n5. 查找 related_fragments（同project或同tags的碎片）\r\n6. 写入 .md 文件\r\n```\r\n\r\n**写入判断（什么该记）：**\r\n- ✅ 决策、结论、价格数据 → 写入（importance ≥ 0.5）\r\n- ✅ 经验教训、踩坑 → 写入（importance ≥ 0.6）\r\n- ✅ 调研发现、待查事项 → 写入\r\n- ❌ 临时计算、一次性信息 → 不写\r\n- ❌ 重复信息（哈希命中或相似度>0.9）→ 合并更新\r\n\r\n## 检索策略（借鉴 Zep MMR + CrewAI 时间衰减）\r\n\r\n**三层搜索：**\r\n1. **Tag 精准匹配** — `search_files` + grep `tags:`（最快）\r\n2. **全文关键词** — ripgrep 搜索正文内容\r\n3. **语义相似** — 可选，需向量嵌入支持\r\n\r\n**融合排序公式：**\r\n```\r\nscore = 相关性×0.5 + importance×0.3 + 时间衰减×0.2\r\n\r\n时间衰减 = e^(-λ × days_since_update)  # λ=0.01, ~半年降到0.5\r\n```\r\n\r\n**MMR 多样性控制（Zep）：** 当返回Top-K中有高度相似的碎片（同一主题重复），保留最完整的一条，其余降权。\r\n\r\n## 读取优先级\r\n\r\n任务前搜索顺序：\r\n1. `agent memory/` — 碎片（最新上下文，时间衰减加权）\r\n2. 知识库 Skill 笔记 — agent_trigger L0 匹配\r\n3. 知识库概念/某物笔记 — abstract L0 匹配\r\n4. 网络搜索\r\n\r\n## 碎片维护\r\n\r\n### 老化策略\r\n\r\n| 条件 | 处理 |\r\n|:-----|:-----|\r\n| importance < 0.3 且 90天未访问 | 归档到 `agent memory/_archive/` |\r\n| related_fragments 指向已删除文件 | 清理失效引用 |\r\n| 同一 project 碎片 > 20 个 | LLM 生成 `{project} - 摘要 - L2总结.md` 合并旧碎片 |\r\n\r\n### L2 总结文件\r\n\r\n当同 project 碎片过多时，生成一个高层摘要：\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory, l2-summary]\r\nproject: 充电站项目\r\nsummary: 充电站项目全貌：已对比3家供应商选驴充充，物业合作分成60/40，青岛目标小区23个，待启动\r\nimportance: 0.9\r\ncovers_fragments:\r\n  - 充电站 - 2026-05-01 - ...\r\n  - 充电站 - 2026-05-03 - ...\r\n  - 充电站 - 2026-05-05 - ...\r\n---\r\n# 充电站项目 - L2 项目摘要\r\n\r\n## 当前进度\r\n- 供应商：已选驴充充（1500/桩）\r\n- 物业合作：60/40分成模式\r\n- 目标市场：青岛23个小区已标注\r\n- 下一步：签物业合同\r\n\r\n## 关键决策\r\n(按时间线列出关键决策)\r\n```\r\n\r\n## 执行流程\r\n\r\n```\r\n收到任务\r\n  │\r\n  ├─ 1. 提取关键词\r\n  ├─ 2. 搜 agent memory/ → L0 (grep summary: + importance:)\r\n  ├─ 3. 搜知识库 → L0 (grep abstract: + agent_trigger:)\r\n  ├─ 4. 按 score 排序(相关性+importance+时间衰减)\r\n  ├─ 5. L1 加载 Top-K 正文\r\n  ├─ 6. 不足 → L2 沿 related_fragments 展开\r\n  ├─ 7. 补充网络搜索\r\n  ├─ 8. 执行任务\r\n  └─ 9. LLM提取关键事实 → 哈希去重 → 写入/合并 agent memory\r\n```\r\n\r\n## 速查卡片\r\n\r\n```\r\n┌────────────────────────────────────────────┐\r\n│  读: agent memory → 知识库 L0 → L1 → L2    │\r\n│  写: LLM提取 → 哈希去重 → 合并/新建        │\r\n│  排: 相关性×0.5 + importance×0.3 + 时间×0.2│\r\n│  关: related_fragments 隐式图谱链          │\r\n│  importance<0.3 + 90天 → _archive/         │\r\n│  同project>20碎片 → L2总结合并             │\r\n└────────────────────────────────────────────┘\r\n```\r\n\r\n## 常见陷阱\r\n\r\n- **不是存整个对话** — LLM提取关键事实后碎片化存储\r\n- **相似不重复建** — 相似度>0.8合并更新，version+1\r\n- **L0不够就翻页** — 别硬撑，主动展开L2\r\n- **related_fragments 要及时维护** — 目标文件删了要清理\r\n- **importance 不是一次性的** — 每用到一次可以微调提升\n\nFile v1.1.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.1.0\",\n  \"publishedAt\": 1777988380297\n}","readmeExcerpt":"Skill: Obsidian Brain Owner: realpda Summary: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments Tags: latest:1.7.0 Version history: v1.7.0 | 2026-05-08T12:29:58.318Z | user 碎片压缩规则: 正文agent优化格式(无标题/禁多级标题/禁段落叙事/允许简写+符号+缩略词); 正误对比示例 v1.6.0 | 2026-05-07T01:31:03.472Z | user AGENTS.md读端可视化(任何消息都触发)+回复开头📖报告格式; skill流程第0步加可视化报告; 失效保护条款(连续3次未读未写须主动承认) v1.5.0 | 2026-05-06T05:11:56","codeSnippets":[],"executableExamples":[{"language":"text","snippet":"File v1.7.0:skill-card.md\n\n## Description:\n\nObsidian Brain helps an agent maintain cross-session memory by searching layered Obsidian agent-memory fragments before work and writing deduplicated markdown fragments after useful decisions, findings, or lessons.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[realpda](https://clawhub.ai/user/realpda)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and agent users use this skill when they want an agent to retrieve prior Obsidian-based memory fragments at the start of a task and save durable task outcomes back as structured markdown notes.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill encourages persistent cross-session memory reads and writes, which can store sensitive or incorrect task context.\n\nMitigation: Limit activation to explicit memory-related requests, review fragments before saving, and avoid storing secrets or confidential content.\n\nRisk: Automatic retrieval of prior memory can over-influence later tasks with stale or unverified context.\n\nMitigation: Treat retrieved memory as advisory context and confirm important facts against current task evidence before acting.\n\nRisk: The artifact workflow includes publishing when the skill is edited.\n\nMitigation: Require explicit approval and review before any publish action.\n\n## Reference(s):\n\n- [ClawHub Skill Page](https://clawhub.ai/realpda/skills/obsidian-brain)\n- [Publisher Profile](https://clawhub.ai/user/realpda)\n- [System Memory vs Agent Memory Fragments](references/storage-distinction.md)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown guidance with file naming, frontmatter, search, and write conventions]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Produces advisory memory retrieval and persistence instructions for agent workflows; stored fragments should be reviewed before rel"}],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"SKILL.md","content":"---\r\nname: obsidian-brain\r\ndescription: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments\r\nversion: 1.7.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nagent_trigger: 当需要读写跨会话记忆碎片、搜索Obsidian库中已有知识上下文、或任何涉及agent memory文件夹的操作时加载\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, agent-memory, knowledge-graph, token-saving]\r\n---\r\n\r\n# Obsidian Brain — Agent 记忆系统\r\n\r\n对话开始搜 agent memory，任务结束写回。读：L0→L1→L2。写：LLM提取→去重→碎片化。\r\n\r\n## 碎片格式\r\n\r\n文件名：`{项目} - {YYYY-MM-DD} - {描述}.md`\r\n\r\n```yaml\r\n---\r\ntags: [agent-memory]\r\nproject: 项目名\r\ndate: 2026-05-05\r\nsummary: 一句话概述（L0扫描用）\r\nimportance: 0.8\r\nconfidence: 0.9          # 可选\r\nsource: conversation     # 可选\r\n---\r\n# 正文（agent压缩格式，见下方规则）\r\n```\r\n\r\n**禁写字段：** `type` `related_fragments` `[[链接]]`。碎片纯文本，不属KG图谱。用 `project` 字段分组代替关联。\r\n\r\n## 碎片压缩规则\r\n\r\n正文以**agent解析效率**为唯一目标，人类可读性忽略。\r\n\r\n**格式要求：**\r\n- **正文允许**：事实列表（`- key: value`）、短句（≤2行）、关键数据、显式关系（`→` `⇒` `∵` `∴`）\r\n- **正文禁止**：段落叙事、`## 现象`/`## 根因`/`## 经验教训` 多级标题、过渡句、解释性装饰语\r\n- **不再需要** `# 标题`（文件名已含标识）\r\n\r\n**缩写约定**（不产生歧义时使用）：\r\n| 词 | 缩写 |\r\n|:--|:----|\r\n| agent memory → am | kg → kg |\r\n| search_files → sf | read_file → rf |\r\n| write_file → wf | patch → p |\r\n| session → sess | memory → mem |\r\n| 工具混淆 → tool-conf | 缺失 → miss |\r\n\r\n**示例**（同一碎片，压缩前后对比）：\r\n\r\n❌ 旧格式（人类友好）：\r\n```\r\n# agent-memory 设计 - 2026-05-06 - 读+写双重失效\r\n\r\n## 现象\r\n本会话既没读agent memory，也没写agent memory。\r\n\r\n## 根因\r\n...\r\n\r\n## 经验教训\r\n1. 任何用户输入都是新任务开始\r\n2. system memory 和 agent memory 是两套存储\r\n```\r\n\r\n✅ 新格式（agent压缩）：\r\n```\r\n**发现**：本sess既没读am也没写am\r\n**根因-读**：用户发文件名→未触发AGENTS.md步0\r\n**根因-写**：mem-tool满(2093/2200)→误判am也写不了（两者独立）\r\n**教训**：①任意输入=任务开始→必须走步0 ②mem-tool≠am碎→容量不共享 ③📋模板从未加入回复格式\r\n```\r\n\r\n## L0/L1/L2 分层\r\n\r\n| 层 | 加载内容 | 时机 |\r\n|:--|:-----|:-----|\r\n| L0 | frontmatter: `summary` `tags` `importance` | 搜到即加载 |\r\n| L1 | 正文 | L0确认相关 |\r\n| L2 | 同 project 其他碎片 | L1不够时 `search_files` |\r\n\r\n## 写入\r\n\r\n**判断（什么该记）：** 决策/结论/价格数据、踩坑教训、调研发现 ✔ | 临时计算、一次性信息 ✘\r\n\r\n**流程：** LLM从结果提取关键事实 → 去重（有相似碎片且度>0.8→合并更新）→ 写 `.md`\r\n\r\n## 读出\r\n\r\n**顺序：** agent memory/ → 知识库skill(agent_trigger) → 概念/某物(abstract) → 网络\r\n\r\n**排序：** `相关性×0.5 + importance×0.3 + e^(-0.01×days)×0.2`\r\n\r\n## 维护\r\n\r\n- `importance<0.3` 且 90天未访问 → `_archive/`\r\n- 同 project 碎片 > 20 → 生成 L2 总结合并\r\n\r\n## 执行流程\r\n\r\n```\r\n0. ⚠️ 读 agent memory（不可跳过，结果可视化）\r\n   search_files → L0 → 相关则L1 → 注入上下文\r\n   **在回复开头必须报告：** `📖 agent memory：读取 N 个碎片 → [标题+summary → 相关/不相关]`\r\n1~N. 执行任务（中途转向时重搜）\r\nN+1. ⚠️ 写 agent memory + 📋 留位检查（不可跳过）\r\n   三问：决策/结论/发现？踩坑/教训？下次需要？\r\n   任一\"是\" → 立即写入，同轮次完成。不等不拖。\r\n   末尾加 `📋 agent memory：本次是否有需写入碎片？[有/无]`\r\nN+2. ⚠️ 如果本技能（obsidian-brain）被编辑 → clawhub publish 新版本\r\n```\r\n\r\n## 触发约束\r\n\r\n- **AGENTS.md**：对话开始强制搜 + 任务结束强制写\r\n- **流程第0步**：任务前必搜，优先于网络/知识库\r\n- **📋 留位**：每次回复末尾检查\r\n- **失效保护**：连续3次漏读/漏写 → 下次加载时回溯\r\n\r\n## 速查\r\n\r\n```\r\n读: 任务前→搜碎片L0→L1→L2  写: LLM提取→去重→碎片化\r\n禁: type/[[链接]]/related_fragments\r\n排: 0.5×相关+0.3×importance+0.2×时间\r\n维: <0.3且90天→archive   >20碎片→总结\r\n```\r\n\r\n## 陷阱\r\n\r\n- **忘读** → AGENTS.md 系统约束，不靠自觉\r\n- **忘写** → 三问+同轮次+📋留位\r\n- **碎片写type/[[链接]]/related_fragments** → 禁止。纯文本\r\n- **混淆 system memory 与 agent memory 碎片**"},{"path":"_meta.json","content":"{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"obsidian-brain\",\n  \"version\": \"1.7.0\",\n  \"publishedAt\": 1778243398318\n}"},{"path":"references/storage-distinction.md","content":"# System Memory vs Agent Memory Fragments\r\n\r\nTwo separate storage systems — do NOT confuse them.\r\n\r\n| | System Memory (memory tool) | Agent Memory Fragments |\r\n|:---|:---|:---|\r\n| **Tool** | `memory()` | `write_file()` to Obsidian vault |\r\n| **Location** | Hermes internal | `D:\\App\\Obsidian\\RealGhost\\agent memory\\` |\r\n| **Capacity** | ~2,200 chars total | No practical limit (filesystem) |\r\n| **Format** | Compact text entries | Full `.md` files with frontmatter |\r\n| **Survives reboot** | Yes | Yes |\r\n| **User visible** | No (injected as context) | Yes (editable notes in Obsidian) |\r\n| **What it stores** | Preferences, environment, user profile | Session decisions, root causes, lesson learned |\r\n\r\n## When to Use Which\r\n\r\n- **System memory**: durable facts about the user/environment that should always be in context. Preferences, tool quirks, project conventions. Keep under 2,200 chars.\r\n- **Agent memory fragments**: session-specific findings, root cause analyses, design decisions, rule updates. Not restricted by char limit.\r\n\r\n## Pitfall\r\n\r\nThis session's bug: saw `memory tool at 2,093/2,200` → thought \"storage is full\" → skipped writing agent memory fragments. But they occupy different storage. One being full has zero impact on the other.\r\n\r\n**Always treat them independently.** Full system memory → remove stale entries or replace. Full agent memory → doesn't apply (filesystem). The two never share a capacity constraint.\r\n\r\n## Verification\r\n\r\nAfter writing an agent memory fragment, verify it exists:\r\n```\r\nsearch_files path=D:\\App\\Obsidian\\RealGhost\\agent memory pattern=\"<keyword>\" target=files\r\n```"},{"path":"skill-card.md","content":"## Description:\n\nObsidian Brain helps an agent maintain cross-session memory by searching layered Obsidian agent-memory fragments before work and writing deduplicated markdown fragments after useful decisions, findings, or lessons.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[realpda](https://clawhub.ai/user/realpda)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and agent users use this skill when they want an agent to retrieve prior Obsidian-based memory fragments at the start of a task and save durable task outcomes back as structured markdown notes.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill encourages persistent cross-session memory reads and writes, which can store sensitive or incorrect task context.\n\nMitigation: Limit activation to explicit memory-related requests, review fragments before saving, and avoid storing secrets or confidential content.\n\nRisk: Automatic retrieval of prior memory can over-influence later tasks with stale or unverified context.\n\nMitigation: Treat retrieved memory as advisory context and confirm important facts against current task evidence before acting.\n\nRisk: The artifact workflow includes publishing when the skill is edited.\n\nMitigation: Require explicit approval and review before any publish action.\n\n## Reference(s):\n\n- [ClawHub Skill Page](https://clawhub.ai/realpda/skills/obsidian-brain)\n- [Publisher Profile](https://clawhub.ai/user/realpda)\n- [System Memory vs Agent Memory Fragments](references/storage-distinction.md)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown guidance with file naming, frontmatter, search, and write conventions]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Produces advisory memory retrieval and persistence instructions for agent workflows; stored fragments should be reviewed before relying on or publishing them.]\n\n## Skill Version(s):\n\n1.7.0 (source: server release metadata and skill frontmatter)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment."}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":"Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments Skill: Obsidian Brain Owner: realpda Summary: Agent跨会话记忆——任务前搜agent memory L0→L1→L2分层加载，任务结束LLM提取事实→哈希去重→写入碎片。禁type/[[链接]]/related_fragments Tags: latest:1.7.0 Version history: v1.7.0 | 2026-05-08T12:29:58.318Z | user 碎片压缩规则: 正文agent优化格式(无标题/禁多级标题/禁段落叙事/允许简写+符号+缩略词); 正误对比示例 v1.6.0 | 2026-05-07T01:31:03.472Z | user AGENTS.md读端可视化(任何消息都触发)+回复开头📖报告格式; skill流程第0步加可视化报告; 失效保护条款(连续3次未读未写须主动承认) v1.5.0 | 2026-05-06T05:11:56","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":1106,"uniquenessScore":51,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-11T17:57:07.953Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-11T17:57:07.953Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-11T20:57:35.783Z","emptyReason":null},"items":[{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-10-09T19:11:12.944Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}