{"id":"407d1e36-c186-45bb-9c34-1aa14916d159","entityType":"agent","slug":"clawhub-realpda-kg-note-method-obsidian","name":"Kg Note Method Obsidian","canonicalUrl":"https://www.xpersona.co/agent/clawhub-realpda-kg-note-method-obsidian","canonicalPath":"/agent/clawhub-realpda-kg-note-method-obsidian","generatedAt":"2026-10-10T13:30:20.715Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-10-10T10:19:38.179Z","emptyReason":null},"description":"Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载 Skill: Kg Note Method Obsidian Owner: realpda Summary: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载 Tags: kg-notes:1.5.0, knowledge-graph:1.5.0, latest:3.23.0, note-organization:1.5.0, obsidian:1.5.0 Version history: v3.23.0 | 2026-05-09T11:42:50.060Z | user 回退v3.22.0: 撤销'分支模式'和'直接跳到执行阶段'改动, 回到v3.21.0状态 v3.22.0 | 2026-05-09T11:39:38.178Z | user 手动命令区分支模式(直接执行/分析); 步0有同名可续接清单→直接跳到执行阶段(不重复","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 1.5K downloads reported by the source. Last updated 10/10/2026.","installCommand":"clawhub skill install s17aspeya65fa14fe9v237r5qd863x8n:kg-note-method-obsidian","sourceUrl":"https://clawhub.ai/realpda/kg-note-method-obsidian","homepage":"https://clawhub.ai/realpda/skills/kg-note-method-obsidian","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/realpda/kg-note-method-obsidian","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/realpda/skills/kg-note-method-obsidian","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":64,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载 Skill: Kg Note Method Obsidian Owner: realpda Summary: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接"},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-10T10:19:38.179Z","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-10T10:19:38.179Z","emptyReason":null},"stars":null,"forks":null,"downloads":1500,"packageName":null,"latestVersion":"3.23.0","tractionLabel":"1.5K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-10T10:19:38.179Z","emptyReason":null},"lastUpdatedAt":"2026-10-10T10:19:38.179Z","lastCrawledAt":"2026-10-10T10:19:38.179Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-11T10:19:38.179Z","lastVerifiedAt":null,"highlights":[{"version":"3.23.0","createdAt":"2026-05-09T11:42:50.060Z","changelog":"回退v3.22.0: 撤销'分支模式'和'直接跳到执行阶段'改动, 回到v3.21.0状态","fileCount":8,"zipByteSize":16466},{"version":"3.22.0","createdAt":"2026-05-09T11:39:38.178Z","changelog":"手动命令区分支模式(直接执行/分析); 步0有同名可续接清单→直接跳到执行阶段(不重复分析)","fileCount":7,"zipByteSize":15267},{"version":"3.21.0","createdAt":"2026-05-09T11:30:55.486Z","changelog":"步0改进: 建新清单前先清理同名残留文件(防止笔记名+命令名形式); checklist参数映射示例(3种命令的具体传参); 两阶段模型文档梳理","fileCount":7,"zipByteSize":15101},{"version":"3.19.0","createdAt":"2026-05-09T11:16:10.834Z","changelog":"两阶段模型重构: kg检查=分析(只读)+问确认→执行, 其他命令=直接执行; 步1拆命令分支(检查vs执行); ⑧分析完成后write_file覆盖执行清单为具体步骤+同步更新检查清单bitmask; 新增陷阱-分析阶段动手修改","fileCount":6,"zipByteSize":13638},{"version":"3.17.0","createdAt":"2026-05-09T10:33:06.133Z","changelog":"新增patch操作安全规则(禁跨YAML边界+每步后read_file验证frontmatter); 新陷阱-patch跨YAML边界","fileCount":2,"zipByteSize":6154},{"version":"3.16.0","createdAt":"2026-05-09T09:11:20.352Z","changelog":"执行追加→生成时写入(区分两阶段); 步1加死线(执行中禁止追加/修改清单); ⑥⑦同步; 新陷阱-执行中修改清单","fileCount":2,"zipByteSize":5887},{"version":"3.15.0","createdAt":"2026-05-09T08:55:43.891Z","changelog":"删除⑩收尾(用不上); 完整标识改为检查清单全1+执行清单最后一步为删除本任务; 步0续接逻辑同步更新","fileCount":2,"zipByteSize":5767},{"version":"3.14.0","createdAt":"2026-05-09T08:42:59.814Z","changelog":"每条kg命令硬编码清单强制(第1步即建清单+检查清单到_working/); 删触发条件行(已嵌入命令); 新增陷阱-跳过清单直接动手","fileCount":2,"zipByteSize":5708}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s17aspeya65fa14fe9v237r5qd863x8n:kg-note-method-obsidian","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-kg-note-method-obsidian/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/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-10T13:30:20.712Z"}},"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-kg-note-method-obsidian/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-realpda-kg-note-method-obsidian/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-10T10:19:38.179Z","emptyReason":null},"readme":"Skill: Kg Note Method Obsidian\n\nOwner: realpda\n\nSummary: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\n\nTags: kg-notes:1.5.0, knowledge-graph:1.5.0, latest:3.23.0, note-organization:1.5.0, obsidian:1.5.0\n\nVersion history:\n\nv3.23.0 | 2026-05-09T11:42:50.060Z | user\n\n回退v3.22.0: 撤销'分支模式'和'直接跳到执行阶段'改动, 回到v3.21.0状态\n\nv3.22.0 | 2026-05-09T11:39:38.178Z | user\n\n手动命令区分支模式(直接执行/分析); 步0有同名可续接清单→直接跳到执行阶段(不重复分析)\n\nv3.21.0 | 2026-05-09T11:30:55.486Z | user\n\n步0改进: 建新清单前先清理同名残留文件(防止笔记名+命令名形式); checklist参数映射示例(3种命令的具体传参); 两阶段模型文档梳理\n\nv3.19.0 | 2026-05-09T11:16:10.834Z | user\n\n两阶段模型重构: kg检查=分析(只读)+问确认→执行, 其他命令=直接执行; 步1拆命令分支(检查vs执行); ⑧分析完成后write_file覆盖执行清单为具体步骤+同步更新检查清单bitmask; 新增陷阱-分析阶段动手修改\n\nv3.17.0 | 2026-05-09T10:33:06.133Z | user\n\n新增patch操作安全规则(禁跨YAML边界+每步后read_file验证frontmatter); 新陷阱-patch跨YAML边界\n\nv3.16.0 | 2026-05-09T09:11:20.352Z | user\n\n执行追加→生成时写入(区分两阶段); 步1加死线(执行中禁止追加/修改清单); ⑥⑦同步; 新陷阱-执行中修改清单\n\nv3.15.0 | 2026-05-09T08:55:43.891Z | user\n\n删除⑩收尾(用不上); 完整标识改为检查清单全1+执行清单最后一步为删除本任务; 步0续接逻辑同步更新\n\nv3.14.0 | 2026-05-09T08:42:59.814Z | user\n\n每条kg命令硬编码清单强制(第1步即建清单+检查清单到_working/); 删触发条件行(已嵌入命令); 新增陷阱-跳过清单直接动手\n\nv3.12.0 | 2026-05-09T08:02:26.427Z | user\n\n命令区重构; skill模板修正(YAML含name/version); 触发生成清单条件改无条件; ⑦-⑧自动校验删除; ⑩收尾追加清单标识; 完整符号检测; 流程/完成度自检删除; 速查+桌签同步\n\nv3.11.0 | 2026-05-09T07:05:32.430Z | user\n\n不主动改写笔记; 完成检查清单→检查清单; 删隐私路径; ⑨补完计划(搜网补充); 完整符号检测; 删打开笔记引用\n\nv3.10.0 | 2026-05-09T06:30:48.898Z | user\n\n去隐私(绝对路径→vault); 操作流程标题简化; 移除不主动改写和L0/L1/L2重复说明段\n\nv3.9.0 | 2026-05-09T06:23:35.197Z | user\n\n删除R0-R3(已由①-⑧覆盖)+删除参考段(三份过期引用)\n\nv3.8.0 | 2026-05-09T06:17:55.983Z | user\n\n四种类型表简化+L0/L1/L2分层+模板增加L1正文结构(##核心规则/##基本信息/##步骤)+新增kg查看命令; 攻略归入skill\n\nv3.7.0 | 2026-05-09T06:07:23.556Z | user\n\n补充L0/L1/L2分层加载表；攻略类归入skill笔记\n\nv3.6.0 | 2026-05-09T05:53:30.412Z | user\n\n删⑦两端检查+⑨缺端(⑥已覆盖); ⑦查重重写为反向追踪决策树(同向/双向/语义覆盖); 序号对齐①-⑤检查⑥-⑧执行\n\nv3.5.0 | 2026-05-09T05:30:10.721Z | user\n\n⑥查相关笔记+关联处理重写为完整决策树: 主体笔记搜关联建关系→概念搜关联补建→关系笔记按两端是否存在分流处理; 序号对齐①-⑤检查⑥-⑩执行\n\nv3.4.0 | 2026-05-09T04:58:06.021Z | user\n\n①②合并(内容检查+拆分); 序号刷新①-⑤检查→⑥-⑪执行; 名称匹配加内容判断; 图片不改主动搜; 直链按目标存在分流; 不主动改写笔记+L0/L1/L2分级\n\nv3.3.0 | 2026-05-09T04:25:10.869Z | user\n\n操作流程重构为①-⑥(决策树+只检查不修改+追加执行清单)和⑦-⑫(按清单执行); 编号全量刷新\n\nv3.2.0 | 2026-05-08T13:55:12.713Z | user\n\n3处修复: 1)每条命令恢复kg start前缀 2)模板加粗闭合不可省略 3)ln双反斜杠改为文字描述避免写入笔记\n\nv3.1.0 | 2026-05-08T13:14:50.529Z | user\n\n完成检查清单改为一行动态码+步2强制patch: 退出后从未完成位续接, 极度省token\n\nv3.0.0 | 2026-05-08T13:01:53.197Z | user\n\n总整理: 规则段删除(R0-R5已由①-⑨覆盖); 手调命令去前缀统一声明; 陷阱压缩为7组(按频率排序); 流程A/B合并; 模板移至类型表; 完成度自检去冗余项; 382行→357行(~15%精简)\n\nv2.31.0 | 2026-05-08T12:47:27.103Z | user\n\n清单双倍token问题修复: 生成时走完整①②③分析把所有违规(改名/纠tag等)写进清单; 执行时照做不重复分析; 废弃v2.30.0的重走①-③错误约束\n\nv2.30.0 | 2026-05-08T12:38:53.377Z | user\n\n清单预判致命修复: 每步执行前必须重新走①-③(禁止用预判结果), 执行清单格式增加强制判断标注, 新增陷阱\n\nv2.28.0 | 2026-05-08T12:09:42.317Z | user\n\n步0和步5加粗警示+具体路径: 步0改为搜_working/全部清单(含同名和其他), 步5改为任务完成后强制搜其他清单; 新增2条陷阱\n\nv2.27.0 | 2026-05-08T11:23:15.503Z | user\n\n启动检查移到任务完成后(不干扰当前任务); 未完成清单提示仅在当前任务完成后触发\n\nv2.26.0 | 2026-05-08T11:03:39.840Z | user\n\n恢复kg start加载命令; kg检查改为建清单→显示表格→询问是否执行→是则执行/否则删清单; D流程更新为清单模式\n\nv2.25.0 | 2026-05-08T10:45:48.739Z | user\n\n清单机制新增启动拦截: 每次kg命令先扫_working/全部未完成任务→列给用户→询问是否优先处理; 用户选是处理未完成/选否继续当前命令\n\nv2.24.0 | 2026-05-08T10:26:28.799Z | user\n\n新增批量任务清单机制: >=5文件操作先建执行清单+完成检查清单到_working/目录; 中途中止→清单保留→下次会话从未完成步恢复; 全部完成→删除清单\n\nv2.23.0 | 2026-05-07T11:08:31.213Z | user\n\n⑤新增关系笔记校验(精确2链/A端匹配文件名/复合句拆解/正误对比); 完成度自检+1项; 陷阱+1\n\nv2.22.0 | 2026-05-07T10:48:35.787Z | user\n\n①主动图片嵌入(读内容同步搜图)+已有图保护; ⑥网络完整性扫描(多主体时两两检查关系缺失); R5精简为跨引用; 完成度自检+2项; 陷阱+2\n\nv2.21.0 | 2026-05-07T09:53:46.043Z | user\n\n④⑤改为搜到即关联——搜到的每个有效关联必须建关系笔记(新文件), 不算改旧笔记不违反R2; 新增陷阱'搜到不关联'\n\nv2.20.0 | 2026-05-07T09:49:06.346Z | user\n\n抽象插入规则增加正误对比例子,强调必须在闭合---之前; 已有YAML笔记用patch插入; D流程残留kg start引用清除\n\nv2.18.0 | 2026-05-07T09:38:03.541Z | user\n\nkg start去掉; ③新增抽象插入规则(检查已有YAML再插入); 新增R5图片保护与嵌入(禁止删图+判断有用才嵌+失效图尝试补回); R4标题补回\n\nv2.17.0 | 2026-05-07T08:52:58.414Z | user\n\n模板区重写为YAML代码块+正文分段: abstract仅放frontmatter不重复; 四种类型表内容要求改为YAML→开头\n\nv2.16.0 | 2026-05-07T08:35:58.279Z | user\n\n▸定义从概念模板移除(abstract已在frontmatter); 命令系统重建: kg start(替代kg整理start)+kg笔记名/kg关键词/kg完善/kg拆解/kg扩展/kg检查共7个手调命令\n\nv2.15.0 | 2026-05-07T07:38:05.095Z | user\n\n无链接歧义修正: 3处改为正文禁[[链接]]，可被关系笔记引用\n\nv2.14.0 | 2026-05-07T07:29:53.489Z | user\n\n笔记分类澄清: 某物=描述具体人/物/地点属性(人物归入某物); skill=步骤/技巧/能执行/经验(含可执行流程和技巧)\n\nv2.13.0 | 2026-05-07T07:20:27.799Z | user\n\nagent_trigger全部清除(库内笔记无用); 按速查串重排为9步操作流程(①-⑨); L0统一abstract; 新增7条陷阱; 修复遗留格式错误\n\nv2.9.0 | 2026-05-06T06:24:01.435Z | auto\n\n- Now explicitly prohibits \" - \" in主体 (concept/skill/某物) note names, to avoid confusion with关系 notes.  \n- Clarifies and emphasizes this主体命名规范 across type table,操作流程,和规则说明。  \n- Updates all relevant instructions to enforce stricter separation of主体和关系笔记 by filename.  \n- Minor wording adjustments for clarity and consistency.\n\nv2.8.0 | 2026-05-06T05:04:13.625Z | auto\n\n**Summary: Improved clarity, streamlined rules, merged details for faster reference.**\n\n- 规则/模板/流程全面精简，快速速查核心操作与常见陷阱\n- 所有笔记类型、命名、链接权限与处理流程表格化，一眼判定\n- 明确主体笔记写完后同轮次必须主动搜关联/建关系，防止遗漏\n- 强化旧笔记“用到才改”、补缺端、无关内容分离流程\n- Skill笔记 agent_trigger 的加法规则更简明，判定标准更易懂\n- 去除冗长例子与重复流程，内容更紧凑\n\nv2.7.0 | 2026-05-06T04:46:42.121Z | auto\n\nVersion 2.7.0\n\n- 新增：所有涉及 `D:\\App\\Obsidian\\RealGhost\\` 下 .md 文件操作，必须优先执行 `skill_view(name='kg-note-method-obsidian')`，未加载本 skill 不允许任何读写操作。\n- 明确禁止在笔记和 memory 碎片中使用 `type` 字段，发现即清除，仅允许使用 tags 表达笔记类型。\n- 在各项操作工作流程首步添加 skill 强制加载步骤，强调流程合规性和统一入口。\n- 文档内容细化流程合规和字段约束，增加了对于技能加载及 `type` 字段处理的描述和示例。\n\nv2.6.0 | 2026-05-06T04:36:11.765Z | auto\n\n- 新增“操作前强制步骤”：所有笔记操作前，需先判断 tag/类型，再决定是否处理[[链接]]，防止误操作\n- 明确主体和关系笔记的[[链接]]合法性判断，进一步细化处理流程\n- 速查卡片更新：强调“先看tag再操作”，优化违规处理说明\n- 其余核心规则与结构未变，流程更加清晰可执行\n\nv2.5.0 | 2026-05-06T02:53:02.338Z | auto\n\n**规则5优化：强制建关系后两端检查，避免残留违规链接。**\n\n- 新增规则5第6步：每建一条关系笔记，需立刻“检查两端”——逐个读主体A与B，清除其内容中被关系笔记替换后残留的[[链接]]，操作结果需在回复中明确列出。\n- 明确强调单看“自律”易漏，流程强制两端检查是唯一解。\n- 速查卡片和“常见陷阱”增加：建关系忘检查另一端属于高发隐患，流程中不可略过。\n- 其余内容结构未变，细化流程以保障知识图谱关系一致与规范。\n\nv2.4.0 | 2026-05-06T02:13:59.781Z | auto\n\n**Summary: Adds strict handling for invalid [[links]] in main notes—always determine underlying relationships before removal.**\n\n- 新增规则：主体笔记中出现 `[[链接]]` 时，先判断链接背后的关系是否真实有效，格式错误≠关系无效，必须先核实再处理。\n- 明确禁止见到格式错误链接即直接删除，避免丢失潜在真实关系。\n- “速查卡片”与“常见陷阱”同步强化违规链接的正确处理方法提醒。\n- 对主体笔记拆出违规链接的处理流程做出详细补充，更严格规定操作顺序。\n\nv2.3.0 | 2026-05-06T01:54:42.650Z | auto\n\n**Summary:**  \n加强了“主体笔记必须关联”，新增规则0，明确建关系笔记为必要步骤，优化流程和陷阱提醒。\n\n- 增加规则0：“主体笔记不孤立”，强调新建/编辑主体笔记同轮次必须立刻查找并建立关系笔记，杜绝知识孤岛。\n- 规则5与流程卡片相应修改，要求建主体笔记的同时构建关系笔记，不得滞后或省略。\n- 速查卡片和常见陷阱新增“主体不孤立”、“建完必须搜关联”等提示。\n- 对原有内容结构与警示语句补充注释，加强对关键操作的约束和实际执行细节指引。\n- 版本号由2.2.0提升至2.3.0。\n\nv2.2.0 | 2026-05-06T01:23:09.324Z | auto\n\n**重点加强无关内容分离和关系笔记格式规范**\n\n- 规则2细化“无关内容分离”流程，强调混入内容须移入/新建主体笔记，明文禁止直接删除，并补充三步判断逻辑。\n- 增加关系笔记内容格式约束：仅允许“一句话+两个[[链接]]”，禁止表格、背景介绍、展开段落等，违规内容必须移走。\n- 常见陷阱补充：禁止无关内容直接删、强调关系笔记格式错误处理办法。\n- 各类流程（如流程B）增加对无关内容和关系笔记规范的操作指引。\n- 其余规则与结构不变。\n\nv2.1.0 | 2026-05-06T00:48:21.915Z | auto\n\nVersion 2.1.0\n\n- 增强了关系笔记的校验与修正规则：遇到缺失一端主体笔记时，先尝试自动补建主体笔记，无法补建才删除关系笔记（新增规则6）。\n- 补充了单端/零端关系笔记的具体处理和相关流程说明。\n- 修正常见陷阱、速查卡片和流程B，反映“关系笔记缺端需优先补建”的新规范。\n- 其余结构和模板保持不变，内容条理优化。\n\nv2.0.0 | 2026-05-05T13:54:31.732Z | auto\n\n**重大更新：引入“无关内容分离”和主动关联机制，加强笔记拆分与自动建关系规范。**\n\n- 新增：笔记含与主题无关内容时，必须强制分离到对应主体笔记，并移走内容。\n- 规范：分离/拆分、新建、或读取主体笔记时，立即检查并主动建立关系笔记（规则9）。\n- 流程：整理、修改流程全面要求“无关内容分离”与“即时建关系”。\n- 更新：核心表格和流程卡片，明确内容分离/即时建关系操作要求。\n- 其他：简化分层加载表格，不再包含 agent memory 碎片字段。\n\nv1.11.1 | 2026-05-05T13:41:04.005Z | auto\n\n- Updated SKILL.md to add a new step in “流程A：整理/完善已有笔记”: now requires writing an agent memory 碎片 for decisions, lessons learned, or anticipated future needs.\n- Added detailed instructions and reminders to always record agent memory entries at the end of main editing/refactoring workflows, with a checklist (“三问”).\n- Updated the list of common pitfalls (“常见陷阱”), highlighting forgetting to write agent memory as the most severe mistake, and providing a fix.\n- Version number in version field not yet bumped (still 1.11.0).\n- No code or logic changed; documentation only.\n\nv1.11.0 | 2026-05-05T12:56:13.484Z | auto\n\n**Summary: This update refines the handling of skill notes' agent_trigger fields to ensure only agent-relevant notes include them.**\n\n- 规则8（Skill笔记 agent_trigger 改造）重写，更清晰区分“用得上”与“用不上”两类 skill 笔记，新增判定表格与判定流程。\n- 批量改造流程调整：必须先判断 agent 是否用得上 skill 笔记内容，用得上才添加 agent_trigger，用不上则不加，保留原样。\n- 速查卡片与常见陷阱同步更新，强调 skill 笔记无 agent_trigger 时需先判断，不再强制所有笔记添加。\n- 示例与操作指引同步修订，说明如何判断笔记是否适合被 agent 调用。\n\nArchive index:\n\nArchive v3.23.0: 8 files, 16466 bytes\n\nFiles: references/yaml-parsing-pitfalls.md (2252b), scripts/checklist-generator.py (3064b), scripts/enrichment.py (3601b), scripts/README.md (956b), scripts/yaml-validator.py (5297b), skill-card.md (2412b), SKILL.md (19889b), _meta.json (143b)\n\nFile v3.23.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.23.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"` / `kg 检查 \"关键词\"`\r\n与其他命令相同的清单（清单名=笔记名），区别仅在于：分析完成后**询问是否执行**，等用户确认后才动手。\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n| `_working/` | 当前任务清单目录 |\r\n\r\n**📦 内置脚本和参考（skill_view + file_path 加载）：**\r\n1. `checklist-generator.py` — 自动生成执行清单+检查清单。用法：`python <script> <任务名> <步1> [步2...]`\r\n2. `yaml-validator.py` — 编辑后验证 YAML 结构。用法：`python <script> <文件.md>`\r\n3. `enrichment.py` — 补完计划：将搜索结果格式化为 KG 标准段落追加到笔记。用法：`echo \"内容\" | python <script> <文件.md> --stdout` 或 `--text \"...\"`\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接\r\n   │  （有未完成位 且 最后一步不是\"删除本任务\"）→ 从未完成步开始\r\n   │  否则（全1或最后一步是删除）→ 删除清单文件，重新建\r\n   ├─ 有其他任务的清单（不同名）→ 当前任务执行完后步5再提示\r\n   └─ 无清单 → **清理同名残留：先 `search_files` 搜 `_working/` 下所有包含该笔记名的清单文件并删除**（防止之前建错的 `笔记名+命令名` 形式残留）。\r\n      然后生成执行清单+检查清单。**清单名=笔记名(用户给的参数)，不加任何命令前缀/后缀。**\r\n      **参数映射：** `kg 检查 苏州` → checklist-generator.py 第一个参数传 `苏州`，不传 `苏州检查`\r\n      `kg \"青岛美食.md\"` → 传 `青岛美食`\r\n      `kg 完善 资本收益.md` → 传 `资本收益`\r\n      优先用脚本（需设环境变量）：\r\n      `OBSIDIAN_VAULT=\"<vault绝对路径>\" python scripts/checklist-generator.py <任务名> <步1> [步2...]`\r\n      或用完整路径：`python <script_full_path> <任务名> <步1> [步2...]`（此时仅打印到终端，需手动保存）\r\n      ⚠️ 脚本在终端输出清单不等于文件已保存到 _working/。\r\n      **必须验证：** 脚本执行后立即 `search_files path=_working/ pattern=<任务名>` 确认清单文件存在：\r\n      ├─ 不存在 → 重跑（检查环境变量或手动 copy 内容建文件）\r\n      └─ 存在 → 继续\r\n      无脚本环境 → 手动建（格式见上）\r\n\r\n1. **命令流程分支：**\r\n   ├─ **`kg 检查` → 分析阶段（只读不写）：**\r\n   │   ├─ 逐条跑 ①-⑥ → ⑦ → ⑨，**此阶段禁止任何 patch/write_file/mv**\r\n   │   ├─ **⑧（生成变更清单）两个动作：**\r\n   │   │   ① 在回复中向用户列出所有变更\r\n   │   │   ② **同时用 `write_file` 覆盖执行清单，把具体的操作步骤写进去**（每条操作含：文件、操作类型、具体内容）\r\n   │   │      ⚠️ 清单源自初始脚本，但分析后才产生具体内容。不能只列在回复里，必须写回清单文件。\r\n   │   ├─ **同步更新检查清单 bitmask 步数** — 执行清单步骤数变化后，检查清单的位也要对应\r\n   │   ├─ → **询问用户「是否执行？」**\r\n   │   │     「📋 分析完成，发现以下问题：\\n        · 傻瓜.md: tags为空→[概念], 删除无关行\\n     是否执行这些修改？」\r\n   │   │     等用户回复\"执行/动手/是\" → 进入执行阶段\r\n   │   │     用户说\"不/算了\" → 删除清单，结束\r\n   │   └─ **⚠️ 分析阶段动手修改是最高频错误** — read_file 后会产生\"这里要改\"的冲动，必须克制。只更新执行清单，不动笔记文件。分析阶段的假设是\"没有写操作\"。\r\n   │\r\n   └─ **`kg \"笔记名\"` / `kg 完善` → 直接执行（不询问）：**\r\n        逐条跑 ①-⑥ → ⑦ → ⑨(仅完善)，分析和执行合一。发现一个问题就把操作记入执行清单（write_file 追加或覆盖）→ 立即执行 → 更新 bitmask。不等待用户确认。\r\n        完成后 → ⑧（列出所有变更）\r\n\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n   **patch 操作安全规则（适用所有文件编辑）：**\r\n   - `patch` 的 old_text 必须足够短且唯一，**禁止跨 frontmatter 边界**（`---` 之间 vs `---` 之外分开编辑）\r\n   - 编辑笔记文件后，立即调用 `python scripts/yaml-validator.py <文件>` 验证 frontmatter 闭合\r\n   - 涉及 YAML 字段（tags/abstract/aliases）用单行 patch，不要大段替换\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n> **两阶段模型：** `kg 检查` 的分析阶段只读不写（read_file/search_files 可以，patch/write_file/mv 禁止），分析完写回执行清单→问用户→等确认再执行。\r\n> `kg 完善` / `kg \"笔记名\"` 无分析阶段——分析和执行合一，发现即动手。不询问。\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 生成时写入清单：patch 移入该主体\r\n      ├─ 已有更完整 → 生成时写入清单：patch 删除混入内容\r\n      └─ 无主体 → 生成时写入清单：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 生成时写入清单：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 生成时写入清单：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 生成时写入清单：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 生成时写入清单：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 生成时写入清单：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 生成时写入清单：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 生成时写入清单：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 生成时写入清单：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 生成时写入清单：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型，在清单生成时写入：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 生成时写入清单：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 生成时写入清单：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 生成时写入清单：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 生成时写入清单：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 生成时写入清单：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 生成时写入清单：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 生成时写入清单：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 生成时写入清单：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 生成时写入清单：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 生成时写入清单：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n**分析阶段的⑧不同：** 分析完成后的⑧不仅要列出变更，还必须用 `write_file` 覆盖 `_working/` 下的执行清单，\r\n把具体的操作步骤写入（替换初始模板），同时更新检查清单 bitmask 步数。然后等用户确认后才进入执行。\r\n\r\n### ⑨ 补完计划\r\n优先用脚本：`python scripts/enrichment.py <笔记.md> --stdout` 预览格式化的补充内容，确认后再追加。\r\n无脚本环境 → 手动写：\r\n\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\r\n- **⚠️ 分析阶段动手修改** → `kg 检查` 的分析阶段只读不写。read_file 后产生\"这里要改\"的冲动是正常的，但必须先列变更清单→问用户→等确认→再动手。分析阶段的假设是\"没有写操作\"\r\n- **⚠️ 执行中修改清单** → 清单生成后禁止追加/删除步骤。发现新问题记下来→执行完当前→删清单→建新清单处理\r\n- **⚠️ patch 跨 YAML 边界** → old_text 禁止跨 `---` 编辑。frontmatter 和正文分开 patch。每次 patch 后 read_file 验证 frontmatter 闭合和结构完整\r\n- **⚠️ 字段名写错 `tag:` 而非 `tags:`** → 库里有多个笔记误写 `tag:`（缺 s）。yaml-validator 会报 TAG_VS_TAGS 错误。修 frontmatter 时注意该字段是 `tags:` 不是 `tag:`\r\n- **⚠️ 脚本输出≠文件保存** → 在终端跑 checklist-generator.py 只打印到 stdout，文件未必写入 _working/。必须设 OBSIDIAN_VAULT 环境变量或手动保存。执行后立即 `search_files` 验证文件存在\n\nFile v3.23.0:scripts/README.md\n\nScripts for kg-note-method-obsidian.\r\n\r\n## checklist-generator.py\r\n生成执行清单 + 检查清单文件。\r\n```\r\npython scripts/checklist-generator.py <任务名> <步1> [步2...]\r\n```\r\n自动追加\"删除本任务2个清单文件\"为最后一步，检查清单 bitmask 同步。\r\n\r\n## yaml-validator.py\r\nYAML frontmatter 校验。支持：\r\n- 概念/某物/skill/关系 类型检查\r\n- frontmatter 开闭确认\r\n- 禁止字段检查（type/[[links]/related_fragments）\r\n- agent memory 碎片专用检查（summary必需）\r\n- Git Bash 路径兼容\r\n```\r\npython scripts/yaml-validator.py <文件.md>\r\n```\r\n\r\n## enrichment.py\r\n补完计划 — 将搜索结果格式化为 KG 标准段落，追加到笔记。\r\n```\r\necho \"内容\" | python scripts/enrichment.py <笔记.md> --stdout\r\npython scripts/enrichment.py <笔记.md> --text \"补充内容\"\r\n```\r\n根据笔记类型自动匹配格式（概念→来源, 某物→补充信息, 关系→单句）。\n\nFile v3.23.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.23.0\",\n  \"publishedAt\": 1778326970060\n}\n\nFile v3.23.0:references/yaml-parsing-pitfalls.md\n\n# YAML Frontmatter Parsing Pitfalls\r\n\r\n## The `body_start` Offset Bug (discovered 2026-05-09)\r\n\r\n**Symptom:** YAML validator reports `STRAY_FM_CLOSE: body contains '---'` on a clean file, or body content is shifted/includes the closing `---` delimiter.\r\n\r\n**Root cause:** Using `.lstrip('\\n')` on `raw[3:]` changes the offset, then `close_idx = rest.find('\\n---')` returns an index relative to the stripped string, but `body_start = close_idx + 5` tries to use it on the original `raw` string. The lstrip shifts everything.\r\n\r\n**Bad pattern (DO NOT USE):**\r\n```python\r\nrest = raw[3:].lstrip('\\n')          # offset shifted by stripping\r\nend_idx = rest.find('\\n---')          # index relative to stripped string\r\nyaml_block = rest[:end_idx].strip()   # OK for parsing YAML\r\nbody_start = end_idx + 5              # WRONG: end_idx is in stripped space, not raw\r\nbody_raw = raw[body_start:]           # WRONG: starts too early or in wrong place\r\n```\r\n\r\n**Correct pattern:**\r\n```python\r\nclose_idx = raw.find('\\n---', 3)      # always search in raw, skip first 3 chars (---)\r\nif close_idx == -1:\r\n    return errors\r\nyaml_block = raw[3:close_idx].strip() # YAML content\r\nbody_raw = raw[close_idx + 5:]        # +5 skips \\n---\\n, correct because close_idx is in raw\r\n```\r\n\r\n**Key insight:** Always search for the closing `---` delimiter in the original `raw` string, not in a `lstrip()`-ed copy. The `\\n---` sequence is deterministic (it's `\\n` + `---` + `\\n`), so `close_idx + 5` is correct when operating on the original string.\r\n\r\n## Common `tag:` vs `tags:` Typo\r\n\r\nSeveral notes in the vault use `tag:` (singular, missing 's') instead of `tags:`. The yaml-validator now detects this with `TAG_VS_TAGS` error.\r\n\r\n**Detection logic:**\r\n```python\r\nif 'tag' in fields and 'tags' not in fields:\r\n    errors.append(\"TAG_VS_TAGS: frontmatter has 'tag:' — did you mean 'tags:'?\")\r\n```\r\n\r\n## Agent Memory Frontmatter Rules\r\n\r\nAgent memory fragments (`agent memory/` directory) have special rules:\r\n- No `type:` field (use `tags:` instead)\r\n- No `[[links]]` in frontmatter\r\n- No `related_fragments` field (use `project:` grouping)\r\n- Must have `summary:` field with `importance:` rating\r\n\r\nThese are enforced by `yaml-validator.py` and should not be overridden.\n\nFile v3.23.0:skill-card.md\n\n## Description:\n\nOrganizes Obsidian vault notes with the KG note method by classifying note types, normalizing naming and links, deduplicating relationships, and preparing checklist-driven corrections and enrichments.\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\nObsidian users and agents use this skill to inspect, reorganize, and enrich Markdown vault notes into KG-style concept, object, skill, and relation notes. It is intended for checklist-driven note maintenance, relationship cleanup, YAML validation, and controlled vault edits.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill can directly modify, rename, delete, and enrich Obsidian vault notes.\n\nMitigation: Use the explicit kg 检查 preview flow before applying changes, keep vault backups, and review generated execution checklists before file edits.\n\nRisk: File operations could affect notes outside the intended workspace if the working path is too broad.\n\nMitigation: Restrict the working path to the intended Obsidian vault and verify checklist files are created under that vault's _working directory.\n\nRisk: Enrichment can append externally sourced or unreviewed content to notes.\n\nMitigation: Preview enrichment output with --stdout and review external search results before appending them to vault files.\n\n## Reference(s):\n\n- [YAML Frontmatter Parsing Pitfalls](references/yaml-parsing-pitfalls.md)\n- [ClawHub skill page](https://clawhub.ai/realpda/skills/kg-note-method-obsidian)\n- [Publisher profile](https://clawhub.ai/user/realpda)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, code, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown notes and checklists with inline shell commands and Python helper script guidance]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [May create, modify, rename, delete, validate, or enrich Obsidian Markdown files in the selected vault.]\n\n## Skill Version(s):\n\n3.23.0 (source: evidence.release and artifact 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 v3.22.0: 7 files, 15267 bytes\n\nFiles: references/yaml-parsing-pitfalls.md (2252b), scripts/checklist-generator.py (3064b), scripts/enrichment.py (3601b), scripts/README.md (956b), scripts/yaml-validator.py (5297b), SKILL.md (20172b), _meta.json (143b)\n\nFile v3.22.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.22.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n**直接执行分支（不询问）：**\r\n`skill_view` → 步0(建清单) → ①-⑥ → ⑦ → **按清单逐条执行** → ⑧(变更报告) → 步5(查其他清单)\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n**直接执行分支（不询问，比kg多一步补完）：**\r\n`skill_view` → 步0(建清单) → ①-⑥ → ⑦ → ⑨(补完) → **按清单逐条执行** → ⑧(变更报告) → 步5(查其他清单)\r\n\r\n### `kg 检查 \"笔记名.md\"` / `kg 检查 \"关键词\"`\r\n**分析分支（只读，等确认后执行）：**\r\n与其他命令相同的步0、分析流程。**唯一区别**：分析完成后写覆盖执行清单 → **询问「是否执行？」** → 等用户确认 → 再进入执行阶段。\r\n用户说\"不\" → 删除清单，结束。\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n| `_working/` | 当前任务清单目录 |\r\n\r\n**📦 内置脚本和参考（skill_view + file_path 加载）：**\r\n1. `checklist-generator.py` — 自动生成执行清单+检查清单。用法：`python <script> <任务名> <步1> [步2...]`\r\n2. `yaml-validator.py` — 编辑后验证 YAML 结构。用法：`python <script> <文件.md>`\r\n3. `enrichment.py` — 补完计划：将搜索结果格式化为 KG 标准段落追加到笔记。用法：`echo \"内容\" | python <script> <文件.md> --stdout` 或 `--text \"...\"`\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接\r\n   │  （有未完成位 且 最后一步不是\"删除本任务\"）→ **直接跳到步2的执行阶段（不重复分析）**，按执行清单从未完成步继续\r\n   │  否则（全1或最后一步是删除）→ 删除清单文件，重新建\r\n   ├─ 有其他任务的清单（不同名）→ 当前任务执行完后步5再提示\r\n   └─ 无清单 → **清理同名残留：先 `search_files` 搜 `_working/` 下所有包含该笔记名的清单文件并删除**（防止之前建错的 `笔记名+命令名` 形式残留）。\r\n      然后生成执行清单+检查清单。**清单名=笔记名(用户给的参数)，不加任何命令前缀/后缀。**\r\n      **参数映射：** `kg 检查 苏州` → checklist-generator.py 第一个参数传 `苏州`，不传 `苏州检查`\r\n      `kg \"青岛美食.md\"` → 传 `青岛美食`\r\n      `kg 完善 资本收益.md` → 传 `资本收益`\r\n      优先用脚本（需设环境变量）：\r\n      `OBSIDIAN_VAULT=\"<vault绝对路径>\" python scripts/checklist-generator.py <任务名> <步1> [步2...]`\r\n      或用完整路径：`python <script_full_path> <任务名> <步1> [步2...]`（此时仅打印到终端，需手动保存）\r\n      ⚠️ 脚本在终端输出清单不等于文件已保存到 _working/。\r\n      **必须验证：** 脚本执行后立即 `search_files path=_working/ pattern=<任务名>` 确认清单文件存在：\r\n      ├─ 不存在 → 重跑（检查环境变量或手动 copy 内容建文件）\r\n      └─ 存在 → 继续\r\n      无脚本环境 → 手动建（格式见上）\r\n\r\n1. **命令流程分支：**\r\n   ├─ **`kg 检查` → 分析阶段（只读不写）：**\r\n   │   ├─ 逐条跑 ①-⑥ → ⑦ → ⑨，**此阶段禁止任何 patch/write_file/mv**\r\n   │   ├─ **⑧（生成变更清单）两个动作：**\r\n   │   │   ① 在回复中向用户列出所有变更\r\n   │   │   ② **同时用 `write_file` 覆盖执行清单，把具体的操作步骤写进去**（每条操作含：文件、操作类型、具体内容）\r\n   │   │      ⚠️ 清单源自初始脚本，但分析后才产生具体内容。不能只列在回复里，必须写回清单文件。\r\n   │   ├─ **同步更新检查清单 bitmask 步数** — 执行清单步骤数变化后，检查清单的位也要对应\r\n   │   ├─ → **询问用户「是否执行？」**\r\n   │   │     「📋 分析完成，发现以下问题：\\n        · 傻瓜.md: tags为空→[概念], 删除无关行\\n     是否执行这些修改？」\r\n   │   │     等用户回复\"执行/动手/是\" → 进入执行阶段\r\n   │   │     用户说\"不/算了\" → 删除清单，结束\r\n   │   └─ **⚠️ 分析阶段动手修改是最高频错误** — read_file 后会产生\"这里要改\"的冲动，必须克制。只更新执行清单，不动笔记文件。分析阶段的假设是\"没有写操作\"。\r\n   │\r\n   └─ **`kg \"笔记名\"` / `kg 完善` → 直接执行（不询问）：**\r\n        逐条跑 ①-⑥ → ⑦ → ⑨(仅完善)，分析和执行合一。发现一个问题就把操作记入执行清单（write_file 追加或覆盖）→ 立即执行 → 更新 bitmask。不等待用户确认。\r\n        完成后 → ⑧（列出所有变更）\r\n\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n   **patch 操作安全规则（适用所有文件编辑）：**\r\n   - `patch` 的 old_text 必须足够短且唯一，**禁止跨 frontmatter 边界**（`---` 之间 vs `---` 之外分开编辑）\r\n   - 编辑笔记文件后，立即调用 `python scripts/yaml-validator.py <文件>` 验证 frontmatter 闭合\r\n   - 涉及 YAML 字段（tags/abstract/aliases）用单行 patch，不要大段替换\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n> **两阶段模型：** `kg 检查` 的分析阶段只读不写（read_file/search_files 可以，patch/write_file/mv 禁止），分析完写回执行清单→问用户→等确认再执行。\r\n> `kg 完善` / `kg \"笔记名\"` 无分析阶段——分析和执行合一，发现即动手。不询问。\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 生成时写入清单：patch 移入该主体\r\n      ├─ 已有更完整 → 生成时写入清单：patch 删除混入内容\r\n      └─ 无主体 → 生成时写入清单：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 生成时写入清单：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 生成时写入清单：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 生成时写入清单：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 生成时写入清单：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 生成时写入清单：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 生成时写入清单：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 生成时写入清单：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 生成时写入清单：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 生成时写入清单：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型，在清单生成时写入：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 生成时写入清单：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 生成时写入清单：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 生成时写入清单：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 生成时写入清单：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 生成时写入清单：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 生成时写入清单：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 生成时写入清单：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 生成时写入清单：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 生成时写入清单：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 生成时写入清单：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n**分析阶段的⑧不同：** 分析完成后的⑧不仅要列出变更，还必须用 `write_file` 覆盖 `_working/` 下的执行清单，\r\n把具体的操作步骤写入（替换初始模板），同时更新检查清单 bitmask 步数。然后等用户确认后才进入执行。\r\n\r\n### ⑨ 补完计划\r\n优先用脚本：`python scripts/enrichment.py <笔记.md> --stdout` 预览格式化的补充内容，确认后再追加。\r\n无脚本环境 → 手动写：\r\n\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\r\n- **⚠️ 分析阶段动手修改** → `kg 检查` 的分析阶段只读不写。read_file 后产生\"这里要改\"的冲动是正常的，但必须先列变更清单→问用户→等确认→再动手。分析阶段的假设是\"没有写操作\"\r\n- **⚠️ 执行中修改清单** → 清单生成后禁止追加/删除步骤。发现新问题记下来→执行完当前→删清单→建新清单处理\r\n- **⚠️ patch 跨 YAML 边界** → old_text 禁止跨 `---` 编辑。frontmatter 和正文分开 patch。每次 patch 后 read_file 验证 frontmatter 闭合和结构完整\r\n- **⚠️ 字段名写错 `tag:` 而非 `tags:`** → 库里有多个笔记误写 `tag:`（缺 s）。yaml-validator 会报 TAG_VS_TAGS 错误。修 frontmatter 时注意该字段是 `tags:` 不是 `tag:`\r\n- **⚠️ 脚本输出≠文件保存** → 在终端跑 checklist-generator.py 只打印到 stdout，文件未必写入 _working/。必须设 OBSIDIAN_VAULT 环境变量或手动保存。执行后立即 `search_files` 验证文件存在\n\nFile v3.22.0:scripts/README.md\n\nScripts for kg-note-method-obsidian.\r\n\r\n## checklist-generator.py\r\n生成执行清单 + 检查清单文件。\r\n```\r\npython scripts/checklist-generator.py <任务名> <步1> [步2...]\r\n```\r\n自动追加\"删除本任务2个清单文件\"为最后一步，检查清单 bitmask 同步。\r\n\r\n## yaml-validator.py\r\nYAML frontmatter 校验。支持：\r\n- 概念/某物/skill/关系 类型检查\r\n- frontmatter 开闭确认\r\n- 禁止字段检查（type/[[links]/related_fragments）\r\n- agent memory 碎片专用检查（summary必需）\r\n- Git Bash 路径兼容\r\n```\r\npython scripts/yaml-validator.py <文件.md>\r\n```\r\n\r\n## enrichment.py\r\n补完计划 — 将搜索结果格式化为 KG 标准段落，追加到笔记。\r\n```\r\necho \"内容\" | python scripts/enrichment.py <笔记.md> --stdout\r\npython scripts/enrichment.py <笔记.md> --text \"补充内容\"\r\n```\r\n根据笔记类型自动匹配格式（概念→来源, 某物→补充信息, 关系→单句）。\n\nFile v3.22.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.22.0\",\n  \"publishedAt\": 1778326778178\n}\n\nFile v3.22.0:references/yaml-parsing-pitfalls.md\n\n# YAML Frontmatter Parsing Pitfalls\r\n\r\n## The `body_start` Offset Bug (discovered 2026-05-09)\r\n\r\n**Symptom:** YAML validator reports `STRAY_FM_CLOSE: body contains '---'` on a clean file, or body content is shifted/includes the closing `---` delimiter.\r\n\r\n**Root cause:** Using `.lstrip('\\n')` on `raw[3:]` changes the offset, then `close_idx = rest.find('\\n---')` returns an index relative to the stripped string, but `body_start = close_idx + 5` tries to use it on the original `raw` string. The lstrip shifts everything.\r\n\r\n**Bad pattern (DO NOT USE):**\r\n```python\r\nrest = raw[3:].lstrip('\\n')          # offset shifted by stripping\r\nend_idx = rest.find('\\n---')          # index relative to stripped string\r\nyaml_block = rest[:end_idx].strip()   # OK for parsing YAML\r\nbody_start = end_idx + 5              # WRONG: end_idx is in stripped space, not raw\r\nbody_raw = raw[body_start:]           # WRONG: starts too early or in wrong place\r\n```\r\n\r\n**Correct pattern:**\r\n```python\r\nclose_idx = raw.find('\\n---', 3)      # always search in raw, skip first 3 chars (---)\r\nif close_idx == -1:\r\n    return errors\r\nyaml_block = raw[3:close_idx].strip() # YAML content\r\nbody_raw = raw[close_idx + 5:]        # +5 skips \\n---\\n, correct because close_idx is in raw\r\n```\r\n\r\n**Key insight:** Always search for the closing `---` delimiter in the original `raw` string, not in a `lstrip()`-ed copy. The `\\n---` sequence is deterministic (it's `\\n` + `---` + `\\n`), so `close_idx + 5` is correct when operating on the original string.\r\n\r\n## Common `tag:` vs `tags:` Typo\r\n\r\nSeveral notes in the vault use `tag:` (singular, missing 's') instead of `tags:`. The yaml-validator now detects this with `TAG_VS_TAGS` error.\r\n\r\n**Detection logic:**\r\n```python\r\nif 'tag' in fields and 'tags' not in fields:\r\n    errors.append(\"TAG_VS_TAGS: frontmatter has 'tag:' — did you mean 'tags:'?\")\r\n```\r\n\r\n## Agent Memory Frontmatter Rules\r\n\r\nAgent memory fragments (`agent memory/` directory) have special rules:\r\n- No `type:` field (use `tags:` instead)\r\n- No `[[links]]` in frontmatter\r\n- No `related_fragments` field (use `project:` grouping)\r\n- Must have `summary:` field with `importance:` rating\r\n\r\nThese are enforced by `yaml-validator.py` and should not be overridden.\n\nArchive v3.21.0: 7 files, 15101 bytes\n\nFiles: references/yaml-parsing-pitfalls.md (2252b), scripts/checklist-generator.py (2837b), scripts/enrichment.py (3601b), scripts/README.md (956b), scripts/yaml-validator.py (5297b), SKILL.md (19889b), _meta.json (143b)\n\nFile v3.21.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.21.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"` / `kg 检查 \"关键词\"`\r\n与其他命令相同的清单（清单名=笔记名），区别仅在于：分析完成后**询问是否执行**，等用户确认后才动手。\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n| `_working/` | 当前任务清单目录 |\r\n\r\n**📦 内置脚本和参考（skill_view + file_path 加载）：**\r\n1. `checklist-generator.py` — 自动生成执行清单+检查清单。用法：`python <script> <任务名> <步1> [步2...]`\r\n2. `yaml-validator.py` — 编辑后验证 YAML 结构。用法：`python <script> <文件.md>`\r\n3. `enrichment.py` — 补完计划：将搜索结果格式化为 KG 标准段落追加到笔记。用法：`echo \"内容\" | python <script> <文件.md> --stdout` 或 `--text \"...\"`\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接\r\n   │  （有未完成位 且 最后一步不是\"删除本任务\"）→ 从未完成步开始\r\n   │  否则（全1或最后一步是删除）→ 删除清单文件，重新建\r\n   ├─ 有其他任务的清单（不同名）→ 当前任务执行完后步5再提示\r\n   └─ 无清单 → **清理同名残留：先 `search_files` 搜 `_working/` 下所有包含该笔记名的清单文件并删除**（防止之前建错的 `笔记名+命令名` 形式残留）。\r\n      然后生成执行清单+检查清单。**清单名=笔记名(用户给的参数)，不加任何命令前缀/后缀。**\r\n      **参数映射：** `kg 检查 苏州` → checklist-generator.py 第一个参数传 `苏州`，不传 `苏州检查`\r\n      `kg \"青岛美食.md\"` → 传 `青岛美食`\r\n      `kg 完善 资本收益.md` → 传 `资本收益`\r\n      优先用脚本（需设环境变量）：\r\n      `OBSIDIAN_VAULT=\"<vault绝对路径>\" python scripts/checklist-generator.py <任务名> <步1> [步2...]`\r\n      或用完整路径：`python <script_full_path> <任务名> <步1> [步2...]`（此时仅打印到终端，需手动保存）\r\n      ⚠️ 脚本在终端输出清单不等于文件已保存到 _working/。\r\n      **必须验证：** 脚本执行后立即 `search_files path=_working/ pattern=<任务名>` 确认清单文件存在：\r\n      ├─ 不存在 → 重跑（检查环境变量或手动 copy 内容建文件）\r\n      └─ 存在 → 继续\r\n      无脚本环境 → 手动建（格式见上）\r\n\r\n1. **命令流程分支：**\r\n   ├─ **`kg 检查` → 分析阶段（只读不写）：**\r\n   │   ├─ 逐条跑 ①-⑥ → ⑦ → ⑨，**此阶段禁止任何 patch/write_file/mv**\r\n   │   ├─ **⑧（生成变更清单）两个动作：**\r\n   │   │   ① 在回复中向用户列出所有变更\r\n   │   │   ② **同时用 `write_file` 覆盖执行清单，把具体的操作步骤写进去**（每条操作含：文件、操作类型、具体内容）\r\n   │   │      ⚠️ 清单源自初始脚本，但分析后才产生具体内容。不能只列在回复里，必须写回清单文件。\r\n   │   ├─ **同步更新检查清单 bitmask 步数** — 执行清单步骤数变化后，检查清单的位也要对应\r\n   │   ├─ → **询问用户「是否执行？」**\r\n   │   │     「📋 分析完成，发现以下问题：\\n        · 傻瓜.md: tags为空→[概念], 删除无关行\\n     是否执行这些修改？」\r\n   │   │     等用户回复\"执行/动手/是\" → 进入执行阶段\r\n   │   │     用户说\"不/算了\" → 删除清单，结束\r\n   │   └─ **⚠️ 分析阶段动手修改是最高频错误** — read_file 后会产生\"这里要改\"的冲动，必须克制。只更新执行清单，不动笔记文件。分析阶段的假设是\"没有写操作\"。\r\n   │\r\n   └─ **`kg \"笔记名\"` / `kg 完善` → 直接执行（不询问）：**\r\n        逐条跑 ①-⑥ → ⑦ → ⑨(仅完善)，分析和执行合一。发现一个问题就把操作记入执行清单（write_file 追加或覆盖）→ 立即执行 → 更新 bitmask。不等待用户确认。\r\n        完成后 → ⑧（列出所有变更）\r\n\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n   **patch 操作安全规则（适用所有文件编辑）：**\r\n   - `patch` 的 old_text 必须足够短且唯一，**禁止跨 frontmatter 边界**（`---` 之间 vs `---` 之外分开编辑）\r\n   - 编辑笔记文件后，立即调用 `python scripts/yaml-validator.py <文件>` 验证 frontmatter 闭合\r\n   - 涉及 YAML 字段（tags/abstract/aliases）用单行 patch，不要大段替换\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n> **两阶段模型：** `kg 检查` 的分析阶段只读不写（read_file/search_files 可以，patch/write_file/mv 禁止），分析完写回执行清单→问用户→等确认再执行。\r\n> `kg 完善` / `kg \"笔记名\"` 无分析阶段——分析和执行合一，发现即动手。不询问。\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 生成时写入清单：patch 移入该主体\r\n      ├─ 已有更完整 → 生成时写入清单：patch 删除混入内容\r\n      └─ 无主体 → 生成时写入清单：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 生成时写入清单：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 生成时写入清单：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 生成时写入清单：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 生成时写入清单：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 生成时写入清单：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 生成时写入清单：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 生成时写入清单：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 生成时写入清单：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 生成时写入清单：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型，在清单生成时写入：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 生成时写入清单：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 生成时写入清单：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 生成时写入清单：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 生成时写入清单：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 生成时写入清单：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 生成时写入清单：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 生成时写入清单：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 生成时写入清单：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 生成时写入清单：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 生成时写入清单：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n**分析阶段的⑧不同：** 分析完成后的⑧不仅要列出变更，还必须用 `write_file` 覆盖 `_working/` 下的执行清单，\r\n把具体的操作步骤写入（替换初始模板），同时更新检查清单 bitmask 步数。然后等用户确认后才进入执行。\r\n\r\n### ⑨ 补完计划\r\n优先用脚本：`python scripts/enrichment.py <笔记.md> --stdout` 预览格式化的补充内容，确认后再追加。\r\n无脚本环境 → 手动写：\r\n\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\r\n- **⚠️ 分析阶段动手修改** → `kg 检查` 的分析阶段只读不写。read_file 后产生\"这里要改\"的冲动是正常的，但必须先列变更清单→问用户→等确认→再动手。分析阶段的假设是\"没有写操作\"\r\n- **⚠️ 执行中修改清单** → 清单生成后禁止追加/删除步骤。发现新问题记下来→执行完当前→删清单→建新清单处理\r\n- **⚠️ patch 跨 YAML 边界** → old_text 禁止跨 `---` 编辑。frontmatter 和正文分开 patch。每次 patch 后 read_file 验证 frontmatter 闭合和结构完整\r\n- **⚠️ 字段名写错 `tag:` 而非 `tags:`** → 库里有多个笔记误写 `tag:`（缺 s）。yaml-validator 会报 TAG_VS_TAGS 错误。修 frontmatter 时注意该字段是 `tags:` 不是 `tag:`\r\n- **⚠️ 脚本输出≠文件保存** → 在终端跑 checklist-generator.py 只打印到 stdout，文件未必写入 _working/。必须设 OBSIDIAN_VAULT 环境变量或手动保存。执行后立即 `search_files` 验证文件存在\n\nFile v3.21.0:scripts/README.md\n\nScripts for kg-note-method-obsidian.\r\n\r\n## checklist-generator.py\r\n生成执行清单 + 检查清单文件。\r\n```\r\npython scripts/checklist-generator.py <任务名> <步1> [步2...]\r\n```\r\n自动追加\"删除本任务2个清单文件\"为最后一步，检查清单 bitmask 同步。\r\n\r\n## yaml-validator.py\r\nYAML frontmatter 校验。支持：\r\n- 概念/某物/skill/关系 类型检查\r\n- frontmatter 开闭确认\r\n- 禁止字段检查（type/[[links]/related_fragments）\r\n- agent memory 碎片专用检查（summary必需）\r\n- Git Bash 路径兼容\r\n```\r\npython scripts/yaml-validator.py <文件.md>\r\n```\r\n\r\n## enrichment.py\r\n补完计划 — 将搜索结果格式化为 KG 标准段落，追加到笔记。\r\n```\r\necho \"内容\" | python scripts/enrichment.py <笔记.md> --stdout\r\npython scripts/enrichment.py <笔记.md> --text \"补充内容\"\r\n```\r\n根据笔记类型自动匹配格式（概念→来源, 某物→补充信息, 关系→单句）。\n\nFile v3.21.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.21.0\",\n  \"publishedAt\": 1778326255486\n}\n\nFile v3.21.0:references/yaml-parsing-pitfalls.md\n\n# YAML Frontmatter Parsing Pitfalls\r\n\r\n## The `body_start` Offset Bug (discovered 2026-05-09)\r\n\r\n**Symptom:** YAML validator reports `STRAY_FM_CLOSE: body contains '---'` on a clean file, or body content is shifted/includes the closing `---` delimiter.\r\n\r\n**Root cause:** Using `.lstrip('\\n')` on `raw[3:]` changes the offset, then `close_idx = rest.find('\\n---')` returns an index relative to the stripped string, but `body_start = close_idx + 5` tries to use it on the original `raw` string. The lstrip shifts everything.\r\n\r\n**Bad pattern (DO NOT USE):**\r\n```python\r\nrest = raw[3:].lstrip('\\n')          # offset shifted by stripping\r\nend_idx = rest.find('\\n---')          # index relative to stripped string\r\nyaml_block = rest[:end_idx].strip()   # OK for parsing YAML\r\nbody_start = end_idx + 5              # WRONG: end_idx is in stripped space, not raw\r\nbody_raw = raw[body_start:]           # WRONG: starts too early or in wrong place\r\n```\r\n\r\n**Correct pattern:**\r\n```python\r\nclose_idx = raw.find('\\n---', 3)      # always search in raw, skip first 3 chars (---)\r\nif close_idx == -1:\r\n    return errors\r\nyaml_block = raw[3:close_idx].strip() # YAML content\r\nbody_raw = raw[close_idx + 5:]        # +5 skips \\n---\\n, correct because close_idx is in raw\r\n```\r\n\r\n**Key insight:** Always search for the closing `---` delimiter in the original `raw` string, not in a `lstrip()`-ed copy. The `\\n---` sequence is deterministic (it's `\\n` + `---` + `\\n`), so `close_idx + 5` is correct when operating on the original string.\r\n\r\n## Common `tag:` vs `tags:` Typo\r\n\r\nSeveral notes in the vault use `tag:` (singular, missing 's') instead of `tags:`. The yaml-validator now detects this with `TAG_VS_TAGS` error.\r\n\r\n**Detection logic:**\r\n```python\r\nif 'tag' in fields and 'tags' not in fields:\r\n    errors.append(\"TAG_VS_TAGS: frontmatter has 'tag:' — did you mean 'tags:'?\")\r\n```\r\n\r\n## Agent Memory Frontmatter Rules\r\n\r\nAgent memory fragments (`agent memory/` directory) have special rules:\r\n- No `type:` field (use `tags:` instead)\r\n- No `[[links]]` in frontmatter\r\n- No `related_fragments` field (use `project:` grouping)\r\n- Must have `summary:` field with `importance:` rating\r\n\r\nThese are enforced by `yaml-validator.py` and should not be overridden.\n\nArchive v3.19.0: 6 files, 13638 bytes\n\nFiles: scripts/checklist-generator.py (2837b), scripts/enrichment.py (3601b), scripts/README.md (956b), scripts/yaml-validator.py (5297b), SKILL.md (19506b), _meta.json (143b)\n\nFile v3.19.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.19.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ **分析阶段**（只读不写：逐条跑 ①-⑥ → ⑦ → ⑨ → ⑧生成变更清单）→ **询问是否执行** → 用户确认后 → **执行阶段**（按清单执行 patch/mv/write → ⑧）\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**📦 内置脚本（skill_view + file_path 加载后读源码或直接 python 调用）：**\r\n1. `checklist-generator.py` — 自动生成执行清单+检查清单。用法：`python <script> <任务名> <步1> [步2...]`\r\n2. `yaml-validator.py` — 编辑后验证 YAML 结构。用法：`python <script> <文件.md>`\r\n3. `enrichment.py` — 补完计划：将搜索结果格式化为 KG 标准段落追加到笔记。用法：`echo \"内容\" | python <script> <文件.md> --stdout` 或 `--text \"...\"`\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接\r\n   │  （有未完成位 且 最后一步不是\"删除本任务\"）→ 从未完成步开始\r\n   │  否则（全1或最后一步是删除）→ 删除清单文件，重新建\r\n   ├─ 有其他任务的清单（不同名）→ 当前任务执行完后步5再提示\r\n   └─ 无清单 → 生成执行清单+检查清单。优先用脚本（需设环境变量）：\r\n      `OBSIDIAN_VAULT=\"<vault绝对路径>\" python scripts/checklist-generator.py <任务名> <步1> [步2...]`\r\n      或用完整路径：`python <script_full_path> <任务名> <步1> [步2...]`（此时仅打印到终端，需手动保存）\r\n      ⚠️ 脚本在终端输出清单不等于文件已保存到 _working/。\r\n      **必须验证：** 脚本执行后立即 `search_files path=_working/ pattern=<任务名>` 确认清单文件存在：\r\n      ├─ 不存在 → 重跑（检查环境变量或手动 copy 内容建文件）\r\n      └─ 存在 → 继续\r\n      无脚本环境 → 手动建（格式见上）\r\n\r\n1. **命令流程分支：**\r\n   ├─ **`kg 检查` → 分析阶段（只读不写）：**\r\n   │   ├─ 逐条跑 ①-⑥ → ⑦ → ⑨，**此阶段禁止任何 patch/write_file/mv**\r\n   │   ├─ **⑧（生成变更清单）两个动作：**\r\n   │   │   ① 在回复中向用户列出所有变更\r\n   │   │   ② **同时用 `write_file` 覆盖执行清单，把具体的操作步骤写进去**（每条操作含：文件、操作类型、具体内容）\r\n   │   │      ⚠️ 清单源自初始脚本，但分析后才产生具体内容。不能只列在回复里，必须写回清单文件。\r\n   │   ├─ **同步更新检查清单 bitmask 步数** — 执行清单步骤数变化后，检查清单的位也要对应\r\n   │   ├─ → **询问用户「是否执行？」**\r\n   │   │     「📋 分析完成，发现以下问题：\\n        · 傻瓜.md: tags为空→[概念], 删除无关行\\n     是否执行这些修改？」\r\n   │   │     等用户回复\"执行/动手/是\" → 进入执行阶段\r\n   │   │     用户说\"不/算了\" → 删除清单，结束\r\n   │   └─ **⚠️ 分析阶段动手修改是最高频错误** — read_file 后会产生\"这里要改\"的冲动，必须克制。只更新执行清单，不动笔记文件。分析阶段的假设是\"没有写操作\"。\r\n   │\r\n   └─ **`kg \"笔记名\"` / `kg 完善` → 直接执行（不询问）：**\r\n        逐条跑 ①-⑥ → ⑦ → ⑨(仅完善)，分析和执行合一。发现一个问题就把操作记入执行清单（write_file 追加或覆盖）→ 立即执行 → 更新 bitmask。不等待用户确认。\r\n        完成后 → ⑧（列出所有变更）\r\n\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n   **patch 操作安全规则（适用所有文件编辑）：**\r\n   - `patch` 的 old_text 必须足够短且唯一，**禁止跨 frontmatter 边界**（`---` 之间 vs `---` 之外分开编辑）\r\n   - 编辑笔记文件后，立即调用 `python scripts/yaml-validator.py <文件>` 验证 frontmatter 闭合\r\n   - 涉及 YAML 字段（tags/abstract/aliases）用单行 patch，不要大段替换\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n> **两阶段模型：** `kg 检查` 的分析阶段只读不写（read_file/search_files 可以，patch/write_file/mv 禁止），分析完写回执行清单→问用户→等确认再执行。\r\n> `kg 完善` / `kg \"笔记名\"` 无分析阶段——分析和执行合一，发现即动手。不询问。\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 生成时写入清单：patch 移入该主体\r\n      ├─ 已有更完整 → 生成时写入清单：patch 删除混入内容\r\n      └─ 无主体 → 生成时写入清单：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 生成时写入清单：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 生成时写入清单：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 生成时写入清单：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 生成时写入清单：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 生成时写入清单：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 生成时写入清单：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 生成时写入清单：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 生成时写入清单：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 生成时写入清单：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型，在清单生成时写入：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 生成时写入清单：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 生成时写入清单：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 生成时写入清单：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 生成时写入清单：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 生成时写入清单：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 生成时写入清单：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 生成时写入清单：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 生成时写入清单：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 生成时写入清单：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 生成时写入清单：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n**分析阶段的⑧不同：** 分析完成后的⑧不仅要列出变更，还必须用 `write_file` 覆盖 `_working/` 下的执行清单，\r\n把具体的操作步骤写入（替换初始模板），同时更新检查清单 bitmask 步数。然后等用户确认后才进入执行。\r\n\r\n### ⑨ 补完计划\r\n优先用脚本：`python scripts/enrichment.py <笔记.md> --stdout` 预览格式化的补充内容，确认后再追加。\r\n无脚本环境 → 手动写：\r\n\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\r\n- **⚠️ 分析阶段动手修改** → `kg 检查` 的分析阶段只读不写。read_file 后产生\"这里要改\"的冲动是正常的，但必须先列变更清单→问用户→等确认→再动手。分析阶段的假设是\"没有写操作\"\r\n- **⚠️ 执行中修改清单** → 清单生成后禁止追加/删除步骤。发现新问题记下来→执行完当前→删清单→建新清单处理\r\n- **⚠️ patch 跨 YAML 边界** → old_text 禁止跨 `---` 编辑。frontmatter 和正文分开 patch。每次 patch 后 read_file 验证 frontmatter 闭合和结构完整\r\n- **⚠️ 字段名写错 `tag:` 而非 `tags:`** → 库里有多个笔记误写 `tag:`（缺 s）。yaml-validator 会报 TAG_VS_TAGS 错误。修 frontmatter 时注意该字段是 `tags:` 不是 `tag:`\r\n- **⚠️ 脚本输出≠文件保存** → 在终端跑 checklist-generator.py 只打印到 stdout，文件未必写入 _working/。必须设 OBSIDIAN_VAULT 环境变量或手动保存。执行后立即 `search_files` 验证文件存在\n\nFile v3.19.0:scripts/README.md\n\nScripts for kg-note-method-obsidian.\r\n\r\n## checklist-generator.py\r\n生成执行清单 + 检查清单文件。\r\n```\r\npython scripts/checklist-generator.py <任务名> <步1> [步2...]\r\n```\r\n自动追加\"删除本任务2个清单文件\"为最后一步，检查清单 bitmask 同步。\r\n\r\n## yaml-validator.py\r\nYAML frontmatter 校验。支持：\r\n- 概念/某物/skill/关系 类型检查\r\n- frontmatter 开闭确认\r\n- 禁止字段检查（type/[[links]/related_fragments）\r\n- agent memory 碎片专用检查（summary必需）\r\n- Git Bash 路径兼容\r\n```\r\npython scripts/yaml-validator.py <文件.md>\r\n```\r\n\r\n## enrichment.py\r\n补完计划 — 将搜索结果格式化为 KG 标准段落，追加到笔记。\r\n```\r\necho \"内容\" | python scripts/enrichment.py <笔记.md> --stdout\r\npython scripts/enrichment.py <笔记.md> --text \"补充内容\"\r\n```\r\n根据笔记类型自动匹配格式（概念→来源, 某物→补充信息, 关系→单句）。\n\nFile v3.19.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.19.0\",\n  \"publishedAt\": 1778325370834\n}\n\nArchive v3.17.0: 2 files, 6154 bytes\n\nFiles: SKILL.md (15367b), _meta.json (143b)\n\nFile v3.17.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.17.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → ⑧ → 询问是否执行 → 按清单执行 → ⑧\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接（检查清单有未完成位 且 执行清单最后一步不是\"删除本任务\"）。可续接→从未完成步开始；不可续接（全1或最后一步是删除）→删除清单文件\r\n   ├─ 有其他任务的清单（不同名）→ 先完成当前任务，末尾步5再提示\r\n   └─ 无 → 生成执行清单+检查清单\r\n\r\n1. 按执行清单步骤逐条执行。清单已含所有修正步骤（改名/纠tag/去abstract等），照做即可。**⚠️ 执行中禁止修改清单内容或追加新步骤**。发现的新问题记下来，等当前清单执行完并删除后，再建新清单处理。\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n   **patch 操作安全规则（适用所有文件编辑）：**\r\n   - `patch` 的 old_text 必须足够短且唯一，**禁止跨 frontmatter 边界**（`---` 之间 vs `---` 之外分开编辑）\r\n   - 编辑笔记文件时，每次 `patch` 后立即 `read_file` 确认 frontmatter 闭合 `---` 存在、YAML 结构完整、正文未丢失\r\n   - 涉及 YAML 字段（tags/abstract/aliases）用单行 patch，不要大段替换\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 生成时写入清单：patch 移入该主体\r\n      ├─ 已有更完整 → 生成时写入清单：patch 删除混入内容\r\n      └─ 无主体 → 生成时写入清单：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 生成时写入清单：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 生成时写入清单：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 生成时写入清单：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 生成时写入清单：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 生成时写入清单：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 生成时写入清单：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 生成时写入清单：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 生成时写入清单：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 生成时写入清单：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型，在清单生成时写入：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 生成时写入清单：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 生成时写入清单：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 生成时写入清单：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 生成时写入清单：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 生成时写入清单：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 生成时写入清单：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 生成时写入清单：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 生成时写入清单：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 生成时写入清单：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 生成时写入清单：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n\r\n### ⑨ 补完计划\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\r\n- **⚠️ 执行中修改清单** → 清单生成后禁止追加/删除步骤。发现新问题记下来→执行完当前→删清单→建新清单处理\r\n- **⚠️ patch 跨 YAML 边界** → old_text 禁止跨 `---` 编辑。frontmatter 和正文分开 patch。每次 patch 后 read_file 验证 frontmatter 闭合和结构完整\n\nFile v3.17.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.17.0\",\n  \"publishedAt\": 1778322786133\n}\n\nArchive v3.16.0: 2 files, 5887 bytes\n\nFiles: SKILL.md (14758b), _meta.json (143b)\n\nFile v3.16.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.16.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → ⑧ → 询问是否执行 → 按清单执行 → ⑧\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接（检查清单有未完成位 且 执行清单最后一步不是\"删除本任务\"）。可续接→从未完成步开始；不可续接（全1或最后一步是删除）→删除清单文件\r\n   ├─ 有其他任务的清单（不同名）→ 先完成当前任务，末尾步5再提示\r\n   └─ 无 → 生成执行清单+检查清单\r\n\r\n1. 按执行清单步骤逐条执行。清单已含所有修正步骤（改名/纠tag/去abstract等），照做即可。**⚠️ 执行中禁止修改清单内容或追加新步骤**。发现的新问题记下来，等当前清单执行完并删除后，再建新清单处理。\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 生成时写入清单：patch 移入该主体\r\n      ├─ 已有更完整 → 生成时写入清单：patch 删除混入内容\r\n      └─ 无主体 → 生成时写入清单：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 生成时写入清单：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 生成时写入清单：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 生成时写入清单：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 生成时写入清单：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 生成时写入清单：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 生成时写入清单：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 生成时写入清单：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 生成时写入清单：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 生成时写入清单：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型，在清单生成时写入：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 生成时写入清单：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 生成时写入清单：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 生成时写入清单：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 生成时写入清单：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 生成时写入清单：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 生成时写入清单：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 生成时写入清单：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 生成时写入清单：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 生成时写入清单：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 生成时写入清单：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 生成时写入清单：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n\r\n### ⑨ 补完计划\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\r\n- **⚠️ 执行中修改清单** → 清单生成后禁止追加/删除步骤。发现新问题记下来→执行完当前→删清单→建新清单处理\n\nFile v3.16.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.16.0\",\n  \"publishedAt\": 1778317880352\n}\n\nArchive v3.15.0: 2 files, 5767 bytes\n\nFiles: SKILL.md (14366b), _meta.json (143b)\n\nFile v3.15.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.15.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → ⑧ → 询问是否执行 → 按清单执行 → ⑧\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接（检查清单有未完成位 且 执行清单最后一步不是\"删除本任务\"）。可续接→从未完成步开始；不可续接（全1或最后一步是删除）→删除清单文件\r\n   ├─ 有其他任务的清单（不同名）→ 先完成当前任务，末尾步5再提示\r\n   └─ 无 → 生成执行清单+检查清单\r\n\r\n1. 按执行清单步骤逐条执行。清单已含所有修正步骤（改名/纠tag/去abstract等），照做即可。\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n3. 全部完成 → read_file 检查清单+执行清单，确认检查清单所有位均为 `1` 且执行清单最后一步为\"删除本任务2个清单文件\"。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 执行清单追加：patch 移入该主体\r\n      ├─ 已有更完整 → 执行清单追加：patch 删除混入内容\r\n      └─ 无主体 → 执行清单追加：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 执行清单追加：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 执行清单追加：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 执行清单追加：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 执行清单追加：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 执行清单追加：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 执行清单追加：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 执行清单追加：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 执行清单追加：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 执行清单追加：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型并追加到执行清单：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 执行清单追加：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 执行清单追加：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 执行清单追加：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 执行清单追加：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 执行清单追加：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 执行清单追加：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 执行清单追加：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 执行清单追加：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 执行清单追加：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 执行清单追加：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n\r\n### ⑨ 补完计划\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\n\nFile v3.15.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.15.0\",\n  \"publishedAt\": 1778316943891\n}\n\nArchive v3.14.0: 2 files, 5708 bytes\n\nFiles: SKILL.md (14167b), _meta.json (143b)\n\nFile v3.14.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.14.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → ⑩ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → ⑩ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → ⑧ → 询问是否执行 → ⑩ → 按清单执行 → ⑧\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单 → 检查清单完整标识 → 从未完成步开始续接。没有标识，删除相应清单文件。\r\n   ├─ 有其他任务的清单（不同名）→ 先完成当前任务，末尾步5再提示\r\n   └─ 无 → 生成执行清单+检查清单\r\n\r\n1. 按执行清单步骤逐条执行。清单已含所有修正步骤（改名/纠tag/去abstract等），照做即可。\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n3. 全部完成 → read_file 检查清单，确认所有位均为 `1`。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n逐条跑 ①-⑥ → ⑦ → ⑩ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 执行清单追加：patch 移入该主体\r\n      ├─ 已有更完整 → 执行清单追加：patch 删除混入内容\r\n      └─ 无主体 → 执行清单追加：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 执行清单追加：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 执行清单追加：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 执行清单追加：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 执行清单追加：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 执行清单追加：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 执行清单追加：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 执行清单追加：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 执行清单追加：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 执行清单追加：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型并追加到执行清单：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 执行清单追加：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 执行清单追加：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 执行清单追加：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 执行清单追加：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 执行清单追加：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 执行清单追加：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 执行清单追加：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 执行清单追加：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 执行清单追加：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 执行清单追加：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n\r\n### ⑨ 补完计划\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n### ⑩ 收尾\r\n在执行清单追加清单完整标识，记录任务完成状态。\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\r\n- **⚠️ 未加载skill直接操作** → 用户消息以 `kg` 开头必须先加载本 skill，再走清单强制建单。跳过会丢失格式校验和流程控制\r\n- **⚠️ 跳过清单直接动手** → 每条命令第一动作就是建清单。不建清单不允许任何文件操作\n\nFile v3.14.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.14.0\",\n  \"publishedAt\": 1778316179814\n}\n\nArchive v3.12.0: 5 files, 11223 bytes\n\nFiles: references/agent-common-errors.md (7754b), references/checklist-format.md (1371b), references/note-template.md (2260b), SKILL.md (13715b), _meta.json (143b)\n\nFile v3.12.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.12.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n### `kg start`\r\n`skill_view(name='kg-note-method-obsidian')` — 加载本 skill\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 查找相应笔记逐条跑 ①-⑥ → ⑦ → ⑩ → 按清单执行 → ⑧ ，没有新建笔记再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 把相应笔记逐条跑 ①-⑥ → ⑦ → ⑨ → ⑩ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 把相应笔记逐条跑 ①-⑥ → ⑦ → ⑨ → ⑧ → 询问是否执行 → ⑩ → 按清单执行 → ⑧\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 路径含 vault 或任务涉及笔记整理 → 自动触发本 skill，用上述命令显式调用更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**触发条件：** 任务开始时，必须先建清单再动手。\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单 → 检查清单完整标识 → 从未完成步开始续接。没有标识，删除相应清单文件。\r\n   ├─ 有其他任务的清单（不同名）→ 先完成当前任务，末尾步5再提示\r\n   └─ 无 → 生成执行清单+检查清单\r\n\r\n1. 按执行清单步骤逐条执行。清单已含所有修正步骤（改名/纠tag/去abstract等），照做即可。\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n3. 全部完成 → read_file 检查清单，确认所有位均为 `1`。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n## 操作流程\r\n\r\n逐条跑 ①-⑥ → ⑦ → ⑩ → 按清单执行 → ⑧\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 执行清单追加：patch 移入该主体\r\n      ├─ 已有更完整 → 执行清单追加：patch 删除混入内容\r\n      └─ 无主体 → 执行清单追加：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 执行清单追加：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 执行清单追加：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 执行清单追加：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 执行清单追加：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 执行清单追加：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 执行清单追加：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 执行清单追加：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 执行清单追加：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 执行清单追加：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型并追加到执行清单：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 执行清单追加：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 执行清单追加：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 执行清单追加：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 执行清单追加：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 执行清单追加：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 执行清单追加：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 执行清单追加：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 执行清单追加：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 执行清单追加：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 执行清单追加：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n\r\n### ⑨ 补完计划\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n### ⑩ 收尾\r\n在执行清单追加清单完整标识，记录任务完成状态。\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nname: 技能名\r\nabstract: 一句话描述\r\nversion: x.x.x\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 速查\r\n\r\n```\r\n内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → 任务开始必须建清单；步0必搜同名清单检查完整标识；步5必查其他清单\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\n\nFile v3.12.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.12.0\",\n  \"publishedAt\": 1778313746427\n}\n\nFile v3.12.0:references/agent-common-errors.md\n\n# Agent常见错误诊断参考\r\n\r\n> 当小龙虾或其他 agent 执行 KG 笔记操作后出现错误，先按此文件排查。\r\n>\r\n> ①-⑤ = 只检查不修改，结果追加到执行清单。⑥-⑩ = 按清单执行。详见 SKILL.md 操作流程。\r\n\r\n---\r\n\r\n## E1：见 `[[链接]]` 就动手\r\n\r\n**现象：** 关系笔记的 `[[链接]]` 当成违规直接修。\r\n**根因：** 没走 ① 检查——没先看 tag 就判断\"链接违规\"。\r\n**对应：** ① 内容检查 + ⑤ 直链检查。\r\n**修正：** `[[链接]]` 在关系笔记中合法。先走 tag 判类型再动手。\r\n\r\n## E2：混入内容直接删\r\n\r\n**现象：** 笔记里有表格/段落不属于这里，直接删掉。\r\n**根因：** 走了\"删\"捷径。信息应在正确主体中保留。\r\n**对应：** ① 内容检查 → 搜库→移入→不直接删。\r\n**修正：** 搜库看混入内容属于谁→移入。分离后立即建关系。\r\n\r\n## E3：建主体不建关系（主体孤立）\r\n\r\n**现象：** 只建了主体笔记，没搜关联笔记→没建关系线。\r\n**根因：** 把\"建关系\"当可选项。\r\n**对应：** ⑥ 查相关笔记+关联处理（主体笔记分支）。\r\n**修正：** 关系笔记是主体创建的一部分，不是附加物。找不到关联→留 `<!-- 待关联 -->`。\r\n\r\n## E4：建关系只扫一端\r\n\r\n**现象：** 建完 `A - 关系 - B`，A 清了但 B 还有残留 `[[链接]]`。\r\n**根因：** 注意力聚焦于\"被操作的文件\"，另一端没进意识。\r\n**对应：** ⑦ 两端检查。\r\n**修正：** 建完关系后 `read_file` A 和 B。检查结果必须在回复中列出。不列=未完成。\r\n\r\n## E5：建议新关系前不查已有\r\n\r\n**现象：** 建议建 `老门东-位于-南京`，已有 `南京-景点-老门东`。\r\n**根因：** 提建议前没查目标节点的现有关系网。\r\n**对应：** ⑧ 查重（R7）→ 语义覆盖检验。\r\n**修正：** 建关系前先 search_files 查 A-B 间已有关系。标志景点=已含归属+类型→不另建位于线。\r\n\r\n## E6：格式错=直接删\r\n\r\n**现象：** 看到 `[[邹城市 - 人物]]` 这种错格式链接直接删。\r\n**根因：** 没判断链接背后的关系是否有效（匡衡/孟子都是邹城人）。\r\n**对应：** ⑤ 直链检查 → 检查目标是否存在。\r\n**修正：** 格式错误 ≠ 关系无效。目标主体存在→建关系笔记；不存在→转纯文本。\r\n\r\n## E7：关系笔记正文为空\r\n\r\n**现象：** 只有 frontmatter 没有正文。\r\n**根因：** 建完不校验完整性。\r\n**对应：** ⑥ 关联处理（自动校验关系笔记格式）。\r\n**修正：** 关系笔记必须有一句话+两个 `[[链接]]`，不可为空。\r\n\r\n## E8：先起概念名再填内容\r\n\r\n**现象：** 先预设名再往里套内容（命名流程反了）。\r\n**根因：** 内容决定名称的顺序弄反了。\r\n**对应：** ② 分类匹配 → 概念名从内容出。\r\n**修正：** 先读内容理解含义→再从内容提炼概念名。\r\n\r\n## E9/E10：abstract 问题\r\n\r\n**现象：** abstract 在正文重复（E9）或插到 YAML 外面（E10）。\r\n**根因：** 写前没验证 YAML 结构。\r\n**对应：** ② 分类匹配 + 写后 verify。\r\n**修正：** abstract 只放 YAML frontmatter，正文不重复。写后 verify 前 3 行含完整 `---...---`。\r\n\r\n## E11：误删图片链接\r\n\r\n**现象：** 笔记中 `![]()` 图片链接被删除。\r\n**根因：** 没把图片视为笔记有效内容。\r\n**对应：** ④ 图片保护。\r\n**修正：** `![]()` 受保护禁止删除。失效图（404/403）→ 搜替代链接。\r\n\r\n## E12：关系笔记多链/混入第三方\r\n\r\n**现象：** 正文出现 3+ `[[链接]]`，或第一个链不等于文件名 A 部分。\r\n**根因：** 建关系笔记时不校验链接数/文件名匹配。\r\n**对应：** ⑥ 关联处理（自动校验关系笔记格式）。\r\n**修正：** 正文只允许 2 链。文件名 `X - 关系 - Y` → 正文第一个链必须是 `[[X]]`。\r\n\r\n## E13：复合句未拆解\r\n\r\n**现象：** \"甲做了A导致乙做了B\"放入同一条关系笔记。\r\n**根因：** 原文含两个因果链，没识别出是两条独立关系。\r\n**对应：** ⑥ 关联处理（自动校验→复合句拆解）。\r\n**修正：** 复合因果必须拆成多条独立关系笔记。\r\n\r\n## E14：多主体间关系缺失\r\n\r\n**现象：** 一轮生成多个主体，只建了到中心节点的线。\r\n**根因：** 不检查同批次主体之间有没有未建的关系。\r\n**对应：** ⑦ 网络完整性扫描 → 跨主体扫描。\r\n**修正：** 多新主体时两两检查是否有真实关联。\r\n\r\n## E15：关系笔记正文含无关第三方\r\n\r\n**现象：** `[[小鱼山]]俯瞰[[八大关]]和圣弥厄尔大教堂` — 圣弥厄尔大教堂是第三方实体。\r\n**根因：** 关系正文提了 A-B 之外的实体。\r\n**对应：** ⑥ 关联处理（识别实体→补建关系→删文本）。\r\n**修正：** 识别正文中所有实体名，有实质关系→建新关系笔记，从原正文删除该实体提及。\r\n\r\n## E16/E17/E18：清单机制问题\r\n\r\n**现象：** ≥5文件操作靠脑子记（E16）、开始不搜同名清单（E17）、完成不搜其他清单（E18）。\r\n**根因：** 清单三步（步0/流程/步5）没嵌入操作习惯。\r\n**对应：** 📋 批量任务清单机制 步0/步5。\r\n**修正：** ≥5文件操作先建清单；开始前搜同名→续接；完成后搜其他→提示。\r\n\r\n## E19：清单漏写改名步骤\r\n\r\n**现象：** 生成清单发现名称违规（如 `美食-青岛` 含 ` - `），没写进清单步骤。\r\n**根因：** ③名称匹配的检测结果没有追加到执行清单。\r\n**对应：** ③ 名称匹配 → 追加执行清单步骤。\r\n**修正：** 生成的每条违规必须追加具体步骤（\"第一步：重命名 mv\"），不靠执行时发现。\r\n\r\n## E20：某物笔记 YAML 未闭合\r\n\r\n**现象：** 闭合 `---` 漏写，正文混入 YAML 段。\r\n**根因：** 写后未 verify 文件前 30 字符。\r\n**对应：** ② 分类匹配 → 写后 verify。\r\n**修正：** 写完后 verify 前 3 行含完整 `---` 三段模式。修复用 patch。\r\n\r\n## E21：关系笔记前部冗余\r\n\r\n**现象：** frontmatter 含 `created`/`source`/`# 标题` 等多余内容。\r\n**根因：** 关系模板没有 YAML 代码块示例，agent 抄了概念模板的字段。\r\n**对应：** ⑥ 关联处理（自动校验 → frontmatter 检查）。\r\n**修正：** frontmatter 只能有 `tags: [关系]`。正文是含动词的完整句子+句号。\r\n\r\n---\r\n\r\n## 快速诊断表\r\n\r\n| 错误 | 对应步骤 | 一句口诀 |\r\n|:----|:--------|:---------|\r\n| E1 见链接就删 | ①⑤ | 先看tag再动手 |\r\n| E2 混入直接删 | ① | 搜库移入不删除 |\r\n| E3 主体孤立 | ⑥ | 建主体必建关系 |\r\n| E4 只扫一端 | ⑦ | 两端都要查 |\r\n| E5 关系重复 | ⑧ | 先查已有再新建 |\r\n| E6 格式错删 | ⑤ | 目标存在→建关系 |\r\n| E7 正文为空 | ⑥校验 | 关系笔记不可空 |\r\n| E8 命名反了 | ② | 内容出概念名 |\r\n| E9/E10 abstract问题 | ②+verify | 只YAML+verify三段式 |\r\n| E11 误删图片 | ④ | 图片受保护不删 |\r\n| E12 关系多链 | ⑥校验 | 正文2链 A端=文件名 |\r\n| E13 复合句不拆 | ⑥校验 | 拆多条独立关系 |\r\n| E14 多主体缺关系 | ⑦扫描 | 新主体两两检查 |\r\n| E15 正文含第三方 | ⑥校验 | 识别→补关系→删文本 |\r\n| E16/E17/E18 清单 | 📋步0/步5 | 建清单→搜同名→搜其他 |\r\n| E19 清单漏改名 | ③→执行清单 | 生成时违规写进步骤 |\r\n| E20 YAML未闭合 | ② verify | verify前3行含三段--- |\r\n| E21 关系冗余 | ⑥校验 | frontmatter仅tags |\n\nFile v3.12.0:references/checklist-format.md\n\n# 检查清单格式参考\r\n\r\n> `kg 检查 \"笔记名.md\"` 的输出格式参考。\r\n\r\n## 两份清单文件\r\n\r\n存放位置：`_working/`\r\n\r\n| 文件 | 命名格式 | 内容 |\r\n|:----|:--------|:-----|\r\n| 执行清单 | `{任务名}_执行清单.md` | 每步编号、操作类型、具体内容 |\r\n| 检查清单 | `{任务名}_检查清单.md` | 一行状态码，每步1位 |\r\n\r\n## 检查清单格式\r\n\r\n一行状态码，极简省 token：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n每一位 = 1步：`0`=未做，`1`=完成。冒号分隔。\r\n更新用 `patch` 改单字符 `0`→`1`。失败追加 `| 失败:N`。\r\n\r\n示例（17步，步1/3完成，步7失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n## 表格输出格式（给用户看）\r\n\r\n```\r\n| 阶段 | 步骤 | 操作 | 对象 |\r\n|:----|:-----|:-----|:-----|\r\n| 🔧 修tag | 1 | patch tags | 笔记A.md |\r\n| ➕ 新建关系 | 2 | 新建文件 | A-B关系.md |\r\n| ✅ 收尾 | 3-4 | 查重+删清单 | — |\r\n```\r\n\r\n## 交互约定\r\n\r\n1. `kg 检查`：分析→建清单→显示表格→询问是否执行。执行则逐条执行，否则删清单。\r\n2. 任务完成后扫 `_working/` 其他清单，询问是否继续。\r\n3. 清单最后一步 = 删除自身清单文件。\r\n4. 中途中止→清单保留，续接。\r\n5. 清单不在 KG 图谱，禁止 `[[链接]]`。\n\nFile v3.12.0:references/note-template.md\n\n# 概念笔记模板（仅适用于概念笔记）\r\n\r\n> 此模板只适用于概念笔记。某物笔记和skill笔记不按此结构。\r\n\r\n## 要求\r\n\r\n每篇主体笔记（概念/某物/skill）frontmatter 必须加 `abstract:` 字段（L0 字段），作为分层查询入口。\r\n**abstract 只放在 YAML，正文不重复。**\r\n\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话定义：什么情况做什么，效果是什么。\r\n---\r\n```\r\n\r\n## 完整模板\r\n\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话定义：什么情况做什么，效果是什么。\r\n---\r\n\r\n# 标题\r\n\r\n## 核心规则\r\n\r\n执行要点，只写怎么做，不写为什么。\r\n\r\n## 来源\r\n\r\n出处。\r\n```\r\n\r\n## 分层原则\r\n\r\n| 层级 | 内容 | 加载策略 |\r\n|:---:|:----|:--------|\r\n| **L0** | `abstract:` 字段（frontmatter） | 永远加载 |\r\n| **L1** | 核心规则 | 按需展开 |\r\n| **L2** | 全文 | 点开才读 |\r\n\r\n回看笔记时，只读取 frontmatter 的 `abstract`（L0），不加载全文。\r\n\r\n## 示例：一回合四原则.md\r\n\r\n```markdown\r\n---\r\ntags: [概念, 沟通, 人际关系, 内耗, 龙飞律师]\r\nabstract: 当产生分歧，不涉及善恶/不伤害他人/不威胁健康/不造成重大财产损失时，建议或提醒只表达一次。\r\n---\r\n\r\n# 一回合四原则\r\n\r\n## 四原则（判断是否适用）\r\n\r\n不涉及善恶、不伤害他人、不威胁健康、不造成重大财产损失。\r\n\r\n## 一回合\r\n\r\n任何分歧、建议或提醒，只表达一次。对方同意或反对后，对话就结束，不重复、不争辩、不翻旧账。\r\n\r\n## 来源\r\n\r\n龙飞律师（抖音/B站/微信公众号）。\r\n```\r\n\r\n> 注意：正文不再有 `▸ 一句话定义` 的重复行。abstract 只在 YAML 中写一次。\r\n\r\n## 常见错误\r\n\r\n❌ **正文重复 abstract：**\r\n```markdown\r\n---\r\nabstract: 当产生分歧...建议只表达一次\r\n---\r\n▸ 当产生分歧...建议只表达一次\r\n```\r\n→ abstract 写了两次，正文那个纯冗余。\r\n\r\n❌ **abstract 插到 YAML 外面：**\r\n```markdown\r\n---\r\ntags: [概念]\r\n---\r\nabstract: ...\r\n---\r\n```\r\n→ 文件顶部出现两个 `---` 段，第二个在正文。必须插到第一个 `---` 内部。\r\n\r\n✅ **正确：** abstract 只在 YAML，正文直接写内容。\n\nArchive v3.11.0: 5 files, 12173 bytes\n\nFiles: references/agent-common-errors.md (7754b), references/checklist-format.md (1590b), references/note-template.md (2260b), SKILL.md (15702b), _meta.json (143b)\n\nFile v3.11.0:SKILL.md\n\n---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.11.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, note-organization]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 先看内容→笔记分类→新笔记→查相关笔记→建关系→扫两端→查重→去直链→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n其他 agent 执行命令前必须先 `kg start` 加载本 skill。\r\n\r\n### `kg start`\r\n加载本 skill。所有命令执行前的第一步，不可跳过。\r\n\r\n### `kg \"笔记名.md\"`\r\n`kg start` → 读取该笔记，按（①-⑥检查→⑦-⑫执行）整理。\r\n\r\n### `kg \"关键词\"`\r\n`kg start` → `search_files` 搜索含该关键词的笔记，按（①-⑥检查→⑦-⑫执行）整理。搜索不到→搜网后新建。\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 读取笔记 → 搜网补充更新 → 标注来源 → 按（①-⑥检查→⑦-⑫执行）。\r\n\r\n### `kg 拆解 \"笔记名.md\"`\r\n`kg start` → 判断为概念笔记时，以第一性原理拆解（找本质概念和相关概念）→ 建笔记+建关系。\r\n\r\n### `kg 扩展 \"笔记名.md\"`\r\n`kg start` → 推断相关主体笔记 → 查已有或新建 → 建关系。\r\n\r\n### `kg 检查 \"笔记名.md\"`\r\n`kg start` → 走 D 流程：分析→建清单→显示表格→询问是否执行。执行则按清单执行，否则删清单。\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 路径含 vault 或任务涉及笔记整理 → 自动触发本 skill，用上述命令显式调用更可靠。\r\n\r\n## 📋 批量任务清单机制\r\n\r\n**触发条件：** 任务预期产生 ≥5 个文件操作（新建/修改/删除）时，必须先建清单再动手。\r\n\r\n**清单目录：** vault 根目录下的 `_working\\\\`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**生成时走完整①②③分析，所有违规当场写进清单。执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单 → 从未完成步开始续接\r\n   ├─ 有其他任务的清单（不同名）→ 先完成当前任务，末尾步5再提示\r\n   └─ 无 → 判断任务规模 ≥5 文件操作 → 生成执行清单+检查清单\r\n\r\n1. 按执行清单步骤逐条执行。清单已含所有修正步骤（改名/纠tag/去abstract等），照做即可。\r\n2. 每步完成后 → 立即 `patch` 检查清单，将该步对应的 `0` 改为 `1`（单字符替换，不得用 `write_file` 重写全文）。失败则追加 `| 失败:N`。\r\n3. 全部完成 → read_file 检查清单，确认所有位均为 `1`（完整符号）。是则删除两个清单文件；否则说明执行不完整，删除清单并通知用户。\r\n4. 中途中止 → 清单文件保留，下次会话恢复\r\n\r\n**5. 任务完成后（不可跳过）：**\r\n   search_files target=files, pattern=*检查清单*, path=_working/\r\n   ├─ 有 OTHER 清单文件 → 逐条 read_file 读取 → 列给用户：\r\n   │     「📋 还有未完成任务：\r\n   │       · 小村庄 — 完成度 0/14（14步未完成）\r\n   │       · 美食-青岛 — 完成度 0/17」\r\n   │     → clarify 询问：「是否继续完成某个？」\r\n   │     → 用户选是 / 指定某个 → 开始执行\r\n   │     → 用户选否 → 结束\r\n   └─ 无 → 结束\r\n```\r\n\r\n> 清单文件不在 KG 图谱内，禁止用 `[[链接]]`。纯文本跟踪用。\r\n\r\n## 四种类型\r\n\r\n所有主体笔记（概念/某物/skill）**统一 L0 为 `abstract`**，一句让人看明白的核心简介。\r\n\r\n| 类型 | tag | `[[链接]]`? | 文件名含`-`? | 内容 |\r\n|:---|:---|:---:|:---:|:-----|\r\n| **概念笔记** | `概念` | ❌ | ❌ | 抽象概念 |\r\n| **某物笔记** | `某物` | ❌ | ❌ | 具体人/物/地点 |\r\n| **Skill笔记** | `skill` | ❌ | ❌ | 技能块/技巧/经验/攻略/操作步骤/执行清单 |\r\n| **关系笔记** | `关系` | ✅唯一 | ✅ 格式：`A - 关系 - B` | 一句话+两个`[[链接]]`，禁表格/段落/标题 |\r\n\r\n> 主体笔记=概念+某物+skill。关系笔记=线。攻略类文件→归入 **skill 笔记**。\r\n\r\n## L0/L1/L2 分层加载\r\n\r\nL0 搜索时自动加载（匹配到即读 frontmatter）。L1/L2 需要时手动加载。\r\n\r\n| 层级 | 概念笔记 | 某物笔记 | Skill笔记 | 何时加载 |\r\n|:---:|:--------|:--------|:----------|:--------|\r\n| **L0** | `abstract:` YAML | `abstract:` YAML | `abstract:` YAML | 搜到即加载 |\r\n| **L1** | `## 核心规则` 段落 | `## 基本信息` 段落 | `## 步骤` / 技能块 | L0相关后加载 |\r\n| **L2** | 全文+来源 | 全文+来源 | 全文+来源 | 需要细节时 |\r\n\r\n**手动加载命令：**\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。如果 L0 相关 → 加载 L1（对应段落）。仍需要 → 加载 L2（全文）。\r\n\r\n## 操作流程\r\n\r\n`read_file` 先读 → 逐条跑 ①-⑥ 检查 → 每条发现违规 → **追加具体操作到执行清单** → 所有检查跑完 → 按清单执行。\r\n\r\n---\r\n\r\n### ① 内容检查 + 拆分\r\n```\r\nread_file 先读。内容 > tag > 名称。\r\n└─ 内容有混入/分属多主题（表格/段落/无关信息混在主体或关系里）\r\n   └─ 搜库判断：\r\n      ├─ 已有主体且缺此信息 → 执行清单追加：patch 移入该主体\r\n      ├─ 已有更完整 → 执行清单追加：patch 删除混入内容\r\n      └─ 无主体 → 执行清单追加：新建文件（保留原笔记，只拆分不改写）\r\n```\r\n\r\n### ② 分类匹配\r\n```\r\n└─ 内容与当前 tag 不匹配：\r\n   └─ 抽象定义+规则 → 执行清单追加：patch tags 为 [概念]\r\n   └─ 描述具体人/物/地点属性 → 执行清单追加：patch tags 为 [某物]\r\n   └─ 步骤清单/技巧/能执行/经验 → 执行清单追加：patch tags 为 [skill]\r\n   └─ 一句话+俩 [[链接]] → 执行清单追加：patch tags 为 [关系]\r\n```\r\n\r\n### ③ 名称匹配\r\n```\r\n└─ 主体笔记名含 ` - `（误认为关系笔记）→ 执行清单追加：重命名 mv\r\n└─ 文件名 与 核心内容 不匹配 → 执行清单追加：重命名 mv（以核心内容为准）\r\n```\r\n\r\n### ④ 图片保护\r\n```\r\n└─ 已有 ![]() 图片：\r\n   ├─ 有效（HTTP 200）→ 不动\r\n   └─ 失效（404/403）→ 执行清单追加：搜有效替代链接\r\n└─ 没有图片 → 跳过\r\n```\r\n\r\n### ⑤ 直链检查\r\n```\r\nread_file 检查正文 [[链接]]：\r\n└─ tag 是 概念/某物/skill（主体笔记）且有 [[链接]]：\r\n   └─ 检查 [[链接]] 目标是否存在：\r\n      ├─ 存在 → 执行清单追加：新建关系笔记（A - 关系 - B）+ 删原直链（先补关系再删链）\r\n      └─ 不存在 → 执行清单追加：[[链接]] 转为纯文本（删除 [[ ]] 保留字词）\r\n└─ tag 是 关系 → [[链接]] 合法，不动\r\n```\r\n\r\n### ⑥ 查相关笔记 + 关联处理\r\n\r\n按以下顺序检查 tag 类型并追加到执行清单：\r\n\r\n```──────────────────────────────────────\r\n└─ tag 是 概念/某物/skill（主体笔记）：\r\n   └─ search_files 搜库中有关联的其他主体笔记\r\n   └─ 每找到一条有效关联 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n──────────────────────────────────────\r\n└─ tag 是 概念（特殊处理——概念之间常需连线成网）：\r\n   └─ 列出本概念相关的其他概念\r\n   └─ 搜库查找：\r\n      ├─ 已有 → 执行清单追加：新建关系笔记（A - 关系 - B）\r\n      └─ 没有 → 执行清单追加：新建概念笔记 + 建关系\r\n──────────────────────────────────────\r\n└─ tag 是 关系（检查两端主体是否存在）：\r\n   └─ search_files 查 A 端和 B 端是否已有主体笔记\r\n      ├─ 一端有、一端没有：\r\n      │  └─ 判断缺失端：\r\n      │     ├─ 缺失端是概念 → 执行清单追加：新建概念笔记 + 两端建关系\r\n      │     └─ 缺失端不是概念 → 执行清单追加：把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      ├─ 两端都没有：\r\n      │  └─ 判断两端：\r\n      │     ├─ 两端都是概念 → 执行清单追加：新建两端概念笔记 + 两端建关系\r\n      │     ├─ 一端是概念 → 执行清单追加：新建概念笔记 + 把关系笔记内容移入已有主体（转纯文本）+ 删除关系笔记\r\n      │     └─ 两端都不是概念 → 不改动\r\n      └─ 两端都有 → 执行清单追加：跳过（已有主体，关系笔记正常即可）\r\n```\r\n\r\n> ⑦-⑧ 按执行清单执行时自动校验关系笔记格式（frontmatter/2链/A端匹配/B端唯一/复合句拆解）。\r\n\r\n### ⑦ 查重（R7）\r\n\r\n```\r\n└─ search_files 通过关系笔记连接的目标主体笔记（反向追踪）：\r\n   └─ 检查两个主体之间是否有多条关系笔记：\r\n      ├─ 多条同向（A→B 多条）→ 执行清单追加：选最佳名称保留，其余删除\r\n      ├─ 双向（A→B + B→A）→ 执行清单追加：保留不冲突\r\n      └─ 同语义覆盖（一条含归属+类型+位置等，另一条只是子集）→ 执行清单追加：保留语义更全的一条，删子集\r\n   └─ 每条被保留的关系笔记 → 执行清单追加：校验文件名最佳匹配\r\n```\r\n\r\n### ⑧ 更改清单\r\n操作完成后在回复中列出所有更改：新建/修改/删除的文件清单。\r\n\r\n### ⑨ 补完计划\r\n```\r\n└─ tag 是 概念/skill 笔记：\r\n   └─ 网络搜索 What、Why、Who、When、Where、How、How much、Effectiveness\r\n   └─ 搜到有用信息 → 写入笔记对应段落并标明出处\r\n   └─ 需改写原文 → clarify 询问用户确认后再改\r\n└─ tag 是 某物笔记：\r\n   └─ 查询具体属性信息（位置/参数/数据等）并填写\r\n```\r\n\r\n## 规则\r\n\r\n### R4：Skill 结构\r\nSkill笔记=步骤清单/技巧/能执行/经验/攻略的集合，必须有完整的可执行技能块（步骤+陷阱+验证），信息密度够大才能让 agent 直接用。任何可执行的流程、经验、技巧、攻略都归入 skill。\r\n\r\n标准结构（L1）：\r\n```\r\n---\r\nname: 技能名\r\ndescription: 一句话描述\r\nversion: x.x.x\r\n---\r\n\r\n# 标题\r\n\r\n## 步骤\r\n1. ...\r\n2. ...\r\n\r\n## 陷阱\r\n- ...\r\n```\r\n\r\n### R5：图片保护\r\n笔记中已有图片禁止删除。图片嵌入见①步（同步图片嵌入）。\r\n\r\n## 模板\r\n\r\nabstract 只放 YAML frontmatter。正文在闭合 `---` 之后，闭合不可省略。\r\n\r\n**概念：**\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话核心定义\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 核心规则\r\n...\r\n## 来源\r\n...\r\n```\r\n\r\n**某物：**\r\n```yaml\r\n---\r\ntags: [某物]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 基本信息\r\n...\r\n```\r\n\r\n**Skill：**\r\n```yaml\r\n---\r\ntags: [skill]\r\nabstract: 一句话简介\r\n---\r\n```\r\n正文结构（L1）：\r\n```\r\n## 步骤（技能块/技巧/经验/攻略/执行清单）\r\n...\r\n## 陷阱\r\n...\r\n```\r\n\r\n**关系：**\r\n```yaml\r\n---\r\ntags: [关系]\r\n---\r\n```\r\n正文：`[[A]]关系描述[[B]]。` 一句完整句子（含动词+句号），禁止 `created`/`source`/标题行。\r\n\r\n## 流程\r\n\r\n**A/B 整理与修改：** `kg start` → `read_file` → 跑①-⑤追加到执行清单 → ⑥查相关笔记+关联处理 → ⑦查重 → ⑧更改清单 → ⑨补完计划。完善模式加搜网补充（⑨前）。\r\n\r\n**C Skill改造：** `kg start` → 搜 `tags:.*skill` → 逐条读→缺abstract补abstract→缺技能块补技能块→收尾(⑧)\r\n\r\n**D 分析与建议（受用户委托分析笔记库时使用）：**\r\n1. `kg start` → 搜目标网络 → 读内容\r\n2. 走①②③分析 → 所有违规直接写进执行清单\r\n3. 生成清单到 `_working/` → 显示表格 → 询问\r\n4. 执行/不执行（同清单机制步6-8）\r\n\r\n□ 完成度自检（所有流程通用）：\r\n□ 关系笔记正文非空 + frontmatter 合规（仅有 tags）\r\n□ 已查重（同向/双向/语义覆盖）\r\n□ 概念名来自内容（非预设）\r\n□ 无混入内容残留\r\n□ 图片已检查（有效不动/失效搜替）\r\n\r\n## 速查\r\n\r\n```\r\n先看内容再操作 内容>tag>名称 主体名禁 ` - `  禁type字段 无关必须移走 读写拆分即关联 查相关笔记 相关笔记关联 关系链接合法  关系 `A - 关系 - B` 关系两端检查  缺端先补不先删  两点一线不重复 直链去前补关系 更改清单\r\n```\r\n\r\n## 陷阱（按频率排序）\r\n\r\n- **不看内容就动手** → 涉文件操作必须先 `read_file`\r\n- **见链接就动手/多链/复合句** → 先看tag→关系链接合法；正文只允许2链；复合因果拆多条(⑥关联处理自动校验)\r\n- **建完主体停手/忘查另一端/直链先删后补** → 同轮次搜关联建关系(⑥)；直链先补关系再删\r\n- **多主体不扫/缺端直接删/关系重复** → ⑥已覆盖缺端处理；⑦查重覆盖关系冗余和语义覆盖\r\n- **清单相关** → ≥5文件操作必须建清单；步0必搜同名清单；步5必查其他清单；生成时违规直接写进步骤\r\n- **全图空白/skill写一半** → ①-⑤检查阶段图片保护；skill缺abstract或缺技能块\r\n- **关系笔记前部冗余** → frontmatter 只能 `tags: [关系]`，禁止 `created`/`source`/标题行(⑥关联处理校验)\n\nFile v3.11.0:_meta.json\n\n{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.11.0\",\n  \"publishedAt\": 1778310332430\n}\n\nFile v3.11.0:references/agent-common-errors.md\n\n# Agent常见错误诊断参考\r\n\r\n> 当小龙虾或其他 agent 执行 KG 笔记操作后出现错误，先按此文件排查。\r\n>\r\n> ①-⑤ = 只检查不修改，结果追加到执行清单。⑥-⑩ = 按清单执行。详见 SKILL.md 操作流程。\r\n\r\n---\r\n\r\n## E1：见 `[[链接]]` 就动手\r\n\r\n**现象：** 关系笔记的 `[[链接]]` 当成违规直接修。\r\n**根因：** 没走 ① 检查——没先看 tag 就判断\"链接违规\"。\r\n**对应：** ① 内容检查 + ⑤ 直链检查。\r\n**修正：** `[[链接]]` 在关系笔记中合法。先走 tag 判类型再动手。\r\n\r\n## E2：混入内容直接删\r\n\r\n**现象：** 笔记里有表格/段落不属于这里，直接删掉。\r\n**根因：** 走了\"删\"捷径。信息应在正确主体中保留。\r\n**对应：** ① 内容检查 → 搜库→移入→不直接删。\r\n**修正：** 搜库看混入内容属于谁→移入。分离后立即建关系。\r\n\r\n## E3：建主体不建关系（主体孤立）\r\n\r\n**现象：** 只建了主体笔记，没搜关联笔记→没建关系线。\r\n**根因：** 把\"建关系\"当可选项。\r\n**对应：** ⑥ 查相关笔记+关联处理（主体笔记分支）。\r\n**修正：** 关系笔记是主体创建的一部分，不是附加物。找不到关联→留 `<!-- 待关联 -->`。\r\n\r\n## E4：建关系只扫一端\r\n\r\n**现象：** 建完 `A - 关系 - B`，A 清了但 B 还有残留 `[[链接]]`。\r\n**根因：** 注意力聚焦于\"被操作的文件\"，另一端没进意识。\r\n**对应：** ⑦ 两端检查。\r\n**修正：** 建完关系后 `read_file` A 和 B。检查结果必须在回复中列出。不列=未完成。\r\n\r\n## E5：建议新关系前不查已有\r\n\r\n**现象：** 建议建 `老门东-位于-南京`，已有 `南京-景点-老门东`。\r\n**根因：** 提建议前没查目标节点的现有关系网。\r\n**对应：** ⑧ 查重（R7）→ 语义覆盖检验。\r\n**修正：** 建关系前先 search_files 查 A-B 间已有关系。标志景点=已含归属+类型→不另建位于线。\r\n\r\n## E6：格式错=直接删\r\n\r\n**现象：** 看到 `[[邹城市 - 人物]]` 这种错格式链接直接删。\r\n**根因：** 没判断链接背后的关系是否有效（匡衡/孟子都是邹城人）。\r\n**对应：** ⑤ 直链检查 → 检查目标是否存在。\r\n**修正：** 格式错误 ≠ 关系无效。目标主体存在→建关系笔记；不存在→转纯文本。\r\n\r\n## E7：关系笔记正文为空\r\n\r\n**现象：** 只有 frontmatter 没有正文。\r\n**根因：** 建完不校验完整性。\r\n**对应：** ⑥ 关联处理（自动校验关系笔记格式）。\r\n**修正：** 关系笔记必须有一句话+两个 `[[链接]]`，不可为空。\r\n\r\n## E8：先起概念名再填内容\r\n\r\n**现象：** 先预设名再往里套内容（命名流程反了）。\r\n**根因：** 内容决定名称的顺序弄反了。\r\n**对应：** ② 分类匹配 → 概念名从内容出。\r\n**修正：** 先读内容理解含义→再从内容提炼概念名。\r\n\r\n## E9/E10：abstract 问题\r\n\r\n**现象：** abstract 在正文重复（E9）或插到 YAML 外面（E10）。\r\n**根因：** 写前没验证 YAML 结构。\r\n**对应：** ② 分类匹配 + 写后 verify。\r\n**修正：** abstract 只放 YAML frontmatter，正文不重复。写后 verify 前 3 行含完整 `---...---`。\r\n\r\n## E11：误删图片链接\r\n\r\n**现象：** 笔记中 `![]()` 图片链接被删除。\r\n**根因：** 没把图片视为笔记有效内容。\r\n**对应：** ④ 图片保护。\r\n**修正：** `![]()` 受保护禁止删除。失效图（404/403）→ 搜替代链接。\r\n\r\n## E12：关系笔记多链/混入第三方\r\n\r\n**现象：** 正文出现 3+ `[[链接]]`，或第一个链不等于文件名 A 部分。\r\n**根因：** 建关系笔记时不校验链接数/文件名匹配。\r\n**对应：** ⑥ 关联处理（自动校验关系笔记格式）。\r\n**修正：** 正文只允许 2 链。文件名 `X - 关系 - Y` → 正文第一个链必须是 `[[X]]`。\r\n\r\n## E13：复合句未拆解\r\n\r\n**现象：** \"甲做了A导致乙做了B\"放入同一条关系笔记。\r\n**根因：** 原文含两个因果链，没识别出是两条独立关系。\r\n**对应：** ⑥ 关联处理（自动校验→复合句拆解）。\r\n**修正：** 复合因果必须拆成多条独立关系笔记。\r\n\r\n## E14：多主体间关系缺失\r\n\r\n**现象：** 一轮生成多个主体，只建了到中心节点的线。\r\n**根因：** 不检查同批次主体之间有没有未建的关系。\r\n**对应：** ⑦ 网络完整性扫描 → 跨主体扫描。\r\n**修正：** 多新主体时两两检查是否有真实关联。\r\n\r\n## E15：关系笔记正文含无关第三方\r\n\r\n**现象：** `[[小鱼山]]俯瞰[[八大关]]和圣弥厄尔大教堂` — 圣弥厄尔大教堂是第三方实体。\r\n**根因：** 关系正文提了 A-B 之外的实体。\r\n**对应：** ⑥ 关联处理（识别实体→补建关系→删文本）。\r\n**修正：** 识别正文中所有实体名，有实质关系→建新关系笔记，从原正文删除该实体提及。\r\n\r\n## E16/E17/E18：清单机制问题\r\n\r\n**现象：** ≥5文件操作靠脑子记（E16）、开始不搜同名清单（E17）、完成不搜其他清单（E18）。\r\n**根因：** 清单三步（步0/流程/步5）没嵌入操作习惯。\r\n**对应：** 📋 批量任务清单机制 步0/步5。\r\n**修正：** ≥5文件操作先建清单；开始前搜同名→续接；完成后搜其他→提示。\r\n\r\n## E19：清单漏写改名步骤\r\n\r\n**现象：** 生成清单发现名称违规（如 `美食-青岛` 含 ` - `），没写进清单步骤。\r\n**根因：** ③名称匹配的检测结果没有追加到执行清单。\r\n**对应：** ③ 名称匹配 → 追加执行清单步骤。\r\n**修正：** 生成的每条违规必须追加具体步骤（\"第一步：重命名 mv\"），不靠执行时发现。\r\n\r\n## E20：某物笔记 YAML 未闭合\r\n\r\n**现象：** 闭合 `---` 漏写，正文混入 YAML 段。\r\n**根因：** 写后未 verify 文件前 30 字符。\r\n**对应：** ② 分类匹配 → 写后 verify。\r\n**修正：** 写完后 verify 前 3 行含完整 `---` 三段模式。修复用 patch。\r\n\r\n## E21：关系笔记前部冗余\r\n\r\n**现象：** frontmatter 含 `created`/`source`/`# 标题` 等多余内容。\r\n**根因：** 关系模板没有 YAML 代码块示例，agent 抄了概念模板的字段。\r\n**对应：** ⑥ 关联处理（自动校验 → frontmatter 检查）。\r\n**修正：** frontmatter 只能有 `tags: [关系]`。正文是含动词的完整句子+句号。\r\n\r\n---\r\n\r\n## 快速诊断表\r\n\r\n| 错误 | 对应步骤 | 一句口诀 |\r\n|:----|:--------|:---------|\r\n| E1 见链接就删 | ①⑤ | 先看tag再动手 |\r\n| E2 混入直接删 | ① | 搜库移入不删除 |\r\n| E3 主体孤立 | ⑥ | 建主体必建关系 |\r\n| E4 只扫一端 | ⑦ | 两端都要查 |\r\n| E5 关系重复 | ⑧ | 先查已有再新建 |\r\n| E6 格式错删 | ⑤ | 目标存在→建关系 |\r\n| E7 正文为空 | ⑥校验 | 关系笔记不可空 |\r\n| E8 命名反了 | ② | 内容出概念名 |\r\n| E9/E10 abstract问题 | ②+verify | 只YAML+verify三段式 |\r\n| E11 误删图片 | ④ | 图片受保护不删 |\r\n| E12 关系多链 | ⑥校验 | 正文2链 A端=文件名 |\r\n| E13 复合句不拆 | ⑥校验 | 拆多条独立关系 |\r\n| E14 多主体缺关系 | ⑦扫描 | 新主体两两检查 |\r\n| E15 正文含第三方 | ⑥校验 | 识别→补关系→删文本 |\r\n| E16/E17/E18 清单 | 📋步0/步5 | 建清单→搜同名→搜其他 |\r\n| E19 清单漏改名 | ③→执行清单 | 生成时违规写进步骤 |\r\n| E20 YAML未闭合 | ② verify | verify前3行含三段--- |\r\n| E21 关系冗余 | ⑥校验 | frontmatter仅tags |\n\nFile v3.11.0:references/checklist-format.md\n\n# 检查清单生成格式参考\r\n\r\n> `kg 检查 \"笔记名.md\"` 命令的输出格式参考文件。\r\n\r\n## 两份清单文件\r\n\r\n存放位置：`D:\\App\\Obsidian\\RealGhost\\_working\\`\r\n\r\n| 文件 | 命名格式 | 内容 |\r\n|:----|:--------|:-----|\r\n| 执行清单 | `{任务名}_执行清单.md` | 每步编号、操作类型（新建/修改/读取/patch/检查/删除/重命名）、具体内容 |\r\n| 完成检查清单 | `{任务名}_完成检查清单.md` | 一行状态码 `0:0:0:0:...`，每步1位 0=未做 1=完成。更新用 patch |\r\n\r\n## 完成检查清单格式\r\n\r\n```\r\n# {任务名} — 完成检查清单\r\n## 状态\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n## 失败记录\r\n3. 失败：reason here\r\n```\r\n\r\n步长 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`。\r\n\r\n执行清单建立后不再修改，只读。完成检查清单才动态更新。\r\n\r\n## 表格输出格式（回复用户用）\r\n\r\n```\r\n| 阶段 | 步骤 | 操作 | 对象 |\r\n|:----|:-----|:-----|:-----|\r\n| 🔧 去abstract | 1~3 | 关系笔记违规abstract+标题清除 | 3条关系笔记 |\r\n| ➕ 新建关系 | 6 | 笔记A↔笔记B | 1条新关系 |\r\n| ✅ 收尾 | 7~8 | 两端检查+查重+删清单 | — |\r\n```\r\n\r\n## 用户交互约定\r\n\r\n1. `kg 检查`：分析→建清单→显示表格→**询问是否执行**。用户选是→逐条执行，选否→删清单。\r\n2. 当前任务完成后检查 `_working/` 下其他清单，询问是否继续。\r\n3. 清单最后一步 = 删除自身。\r\n4. 中途中止→清单保留，续接。\r\n5. 清单不在 KG 图谱，禁止 `[[链接]]`。\n\nFile v3.11.0:references/note-template.md\n\n# 概念笔记模板（仅适用于概念笔记）\r\n\r\n> 此模板只适用于概念笔记。某物笔记和skill笔记不按此结构。\r\n\r\n## 要求\r\n\r\n每篇主体笔记（概念/某物/skill）frontmatter 必须加 `abstract:` 字段（L0 字段），作为分层查询入口。\r\n**abstract 只放在 YAML，正文不重复。**\r\n\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话定义：什么情况做什么，效果是什么。\r\n---\r\n```\r\n\r\n## 完整模板\r\n\r\n```yaml\r\n---\r\ntags: [概念]\r\nabstract: 一句话定义：什么情况做什么，效果是什么。\r\n---\r\n\r\n# 标题\r\n\r\n## 核心规则\r\n\r\n执行要点，只写怎么做，不写为什么。\r\n\r\n## 来源\r\n\r\n出处。\r\n```\r\n\r\n## 分层原则\r\n\r\n| 层级 | 内容 | 加载策略 |\r\n|:---:|:----|:--------|\r\n| **L0** | `abstract:` 字段（frontmatter） | 永远加载 |\r\n| **L1** | 核心规则 | 按需展开 |\r\n| **L2** | 全文 | 点开才读 |\r\n\r\n回看笔记时，只读取 frontmatter 的 `abstract`（L0），不加载全文。\r\n\r\n## 示例：一回合四原则.md\r\n\r\n```markdown\r\n---\r\ntags: [概念, 沟通, 人际关系, 内耗, 龙飞律师]\r\nabstract: 当产生分歧，不涉及善恶/不伤害他人/不威胁健康/不造成重大财产损失时，建议或提醒只表达一次。\r\n---\r\n\r\n# 一回合四原则\r\n\r\n## 四原则（判断是否适用）\r\n\r\n不涉及善恶、不伤害他人、不威胁健康、不造成重大财产损失。\r\n\r\n## 一回合\r\n\r\n任何分歧、建议或提醒，只表达一次。对方同意或反对后，对话就结束，不重复、不争辩、不翻旧账。\r\n\r\n## 来源\r\n\r\n龙飞律师（抖音/B站/微信公众号）。\r\n```\r\n\r\n> 注意：正文不再有 `▸ 一句话定义` 的重复行。abstract 只在 YAML 中写一次。\r\n\r\n## 常见错误\r\n\r\n❌ **正文重复 abstract：**\r\n```markdown\r\n---\r\nabstract: 当产生分歧...建议只表达一次\r\n---\r\n▸ 当产生分歧...建议只表达一次\r\n```\r\n→ abstract 写了两次，正文那个纯冗余。\r\n\r\n❌ **abstract 插到 YAML 外面：**\r\n```markdown\r\n---\r\ntags: [概念]\r\n---\r\nabstract: ...\r\n---\r\n```\r\n→ 文件顶部出现两个 `---` 段，第二个在正文。必须插到第一个 `---` 内部。\r\n\r\n✅ **正确：** abstract 只在 YAML，正文直接写内容。","readmeExcerpt":"Skill: Kg Note Method Obsidian Owner: realpda Summary: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载 Tags: kg-notes:1.5.0, knowledge-graph:1.5.0, latest:3.23.0, note-organization:1.5.0, obsidian:1.5.0 Version history: v3.23.0 | 2026-05-09T11:42:50.060Z | user 回退v3.22.0: 撤销'分支模式'和'直接跳到执行阶段'改动, 回到v3.21.0状态 v3.22.0 | 2026-05-09T11:39:38.178Z | user 手动命令区分支模式(直接执行/分析); 步0有同名可续接清单→直接跳到执行阶段(不重复","codeSnippets":[],"executableExamples":[],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"SKILL.md","content":"---\r\nname: kg-note-method-obsidian\r\ndescription: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载\r\nversion: 3.23.0\r\nauthor: Hermes Agent\r\nlicense: MIT\r\nmetadata:\r\n  hermes:\r\n    tags: [obsidian, kg-notes, knowledge-graph, token-saving]\r\n---\r\n\r\n# KG笔记法 — Obsidian 笔记整理\r\n\r\n<!-- 速查: 内容检查+拆分→分类匹配→名称匹配→图片保护→直链检查→查相关笔记→查重→更改清单→补完计划→收尾 -->\r\n\r\n> ⚠️ **不主动改写笔记**：所有命令（除 `kg 完善`），尽量保留原文原貌。\r\n\r\n## ⚡ 手动调用命令\r\n\r\n> 所有命令第一步：`skill_view(name='kg-note-method-obsidian')` 加载本 skill。不可跳过。\r\n\r\n### `kg start`\r\n加载本 skill。\r\n\r\n### `kg \"笔记名.md\"/\"关键词\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 查找笔记逐条跑 ①-⑥ → ⑦ → 按清单执行 → ⑧，无笔记则新建再跑\r\n\r\n### `kg 完善 \"笔记名.md\"`\r\n`kg start` → 建执行清单+检查清单到 `_working/`（清单强制）→ 逐条跑 ①-⑥ → ⑦ → ⑨ → 按清单执行 → ⑧\r\n\r\n### `kg 检查 \"笔记名.md\"` / `kg 检查 \"关键词\"`\r\n与其他命令相同的清单（清单名=笔记名），区别仅在于：分析完成后**询问是否执行**，等用户确认后才动手。\r\n\r\n### `kg 查看 \"笔记名.md\"`\r\n加载 L0（frontmatter）。相关则加载 L1（对应段落）。仍不足加载 L2（全文）。\r\n\r\n> 用户消息以 `kg` 开头 → 必须先加载本 skill。路径含 vault → 自动触发，用上述命令更可靠。\r\n\r\n| `_working/` | 当前任务清单目录 |\r\n\r\n**📦 内置脚本和参考（skill_view + file_path 加载）：**\r\n1. `checklist-generator.py` — 自动生成执行清单+检查清单。用法：`python <script> <任务名> <步1> [步2...]`\r\n2. `yaml-validator.py` — 编辑后验证 YAML 结构。用法：`python <script> <文件.md>`\r\n3. `enrichment.py` — 补完计划：将搜索结果格式化为 KG 标准段落追加到笔记。用法：`echo \"内容\" | python <script> <文件.md> --stdout` 或 `--text \"...\"`\r\n\r\n**清单目录：** vault 根目录下的 `_working/`\r\n\r\n### 两个清单文件\r\n\r\n| 文件 | 用途 | 更新时机 |\r\n|:----|:-----|:--------|\r\n| `{任务名}_执行清单.md` | 预判所有步骤的详细操作 | 任务开始前一次性生成 |\r\n| `{任务名}_检查清单.md` | 追踪每步完成/失败状态 | 每步完成后立即更新 |\r\n\r\n### 执行清单格式\r\n\r\n**执行时照做，不重复分析。**\r\n\r\n```markdown\r\n# {任务名} — 执行清单\r\n## 步骤\r\n### 1. 重命名「美食-青岛.md」→「青岛美食.md」（②名称检查：主体名禁` - `）\r\n- 操作类型：mv\r\n### 2. 修改「笔记A.md」tag\r\n- 操作类型：patch\r\n- tags: [旧tag] → tags: [某物]\r\n### 3. 新建「笔记A - 关系 - 笔记B.md」\r\n- 操作类型：新建文件\r\n- 内容：[[笔记A]]关系描述[[笔记B]]。\r\n### 4. 检查两端残留链接 + 查重\r\n- 操作类型：检查验证\r\n### N. 删除本任务的2个清单文件\r\n- 操作类型：删除文件\r\n```\r\n\r\n### 检查清单格式\r\n\r\n**极度精简一行状态码。执行清单已含完整描述，这里只记进度。每步一个位：`0`=未做，`1`=完成。** 文件内容仅一行：\r\n\r\n```\r\n0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0\r\n```\r\n\r\n步数 = 冒号分隔的位数。更新时 `patch` 单字符 `0`→`1`（只改对应位，不改全文）。失败步记步号到末尾：` | 失败:3,7`。**完整标识**：检查清单全 `1` + 执行清单最后一步≥\"删除本任务2个清单文件\"。\r\n\r\n格式示例（17步，第1、3步已完成，第7步失败）：\r\n```\r\n1:0:1:0:0:0:0:0:0:0:0:0:0:0:0:0:0 | 失败:7\r\n```\r\n\r\n### 执行流程\r\n\r\n**步0 和步5 不可跳过。跳过步0 → 同名任务已有清单却被覆盖。跳过步5 → 用户不知道还有其他任务。**\r\n\r\n```\r\n0. 任务开始前（不可跳过）：\r\n   search_files target=content, pattern='检查清单', path=_working/\r\n   ├─ 有同名任务的清单 → read_file 检查清单+执行清单 → 检查是否可续接\r\n   │  （有未完成位 且 最后一步不是\"删除本任务\"）→ 从未完成步开始\r\n   │  否则（全1或最后一步是删除）→ 删除清单文件，重新建\r\n   ├─ 有其他任务的清单（不同名）→ 当前任务执行完后步5再提示\r\n   └─ 无清单 → **清理同名残留：先 `search_files` 搜 `_working/` 下所有包含该笔记名的清单文件并删除**（防止之前建错的 `笔记名+命令名` 形式残留）。\r\n      然后生成执行清单+检查清单。**清单名=笔记名(用户给的参数)，不加任何命令前缀/后缀。**\r\n      **参数映射：** `kg 检查 苏州` → checklist-generator.py 第一个参数传 `苏州`，不传 `苏州检查`\r\n      `kg \"青岛美食.md\"` → 传 `青岛美食`\r\n      `kg 完善 资本收益.md` → 传 `资本收益`\r\n      优先用脚本（需设环境变量）：\r\n      `OBSIDIAN_VAULT=\"<vault绝对路径>\" python scripts/checklist-generator.py <任务名> <步1> [步2...]`\r\n      或用完整路径：`python <script_full_path> <任务名> <步1> [步2...]`（此时仅打印到终端，需手动保存）\r\n      ⚠️ 脚本在终端输出清单不等于文件已保存到 "},{"path":"scripts/README.md","content":"Scripts for kg-note-method-obsidian.\r\n\r\n## checklist-generator.py\r\n生成执行清单 + 检查清单文件。\r\n```\r\npython scripts/checklist-generator.py <任务名> <步1> [步2...]\r\n```\r\n自动追加\"删除本任务2个清单文件\"为最后一步，检查清单 bitmask 同步。\r\n\r\n## yaml-validator.py\r\nYAML frontmatter 校验。支持：\r\n- 概念/某物/skill/关系 类型检查\r\n- frontmatter 开闭确认\r\n- 禁止字段检查（type/[[links]/related_fragments）\r\n- agent memory 碎片专用检查（summary必需）\r\n- Git Bash 路径兼容\r\n```\r\npython scripts/yaml-validator.py <文件.md>\r\n```\r\n\r\n## enrichment.py\r\n补完计划 — 将搜索结果格式化为 KG 标准段落，追加到笔记。\r\n```\r\necho \"内容\" | python scripts/enrichment.py <笔记.md> --stdout\r\npython scripts/enrichment.py <笔记.md> --text \"补充内容\"\r\n```\r\n根据笔记类型自动匹配格式（概念→来源, 某物→补充信息, 关系→单句）。"},{"path":"_meta.json","content":"{\n  \"ownerId\": \"kn7fqb3c2xfkrkayjpw1sceew1863n0d\",\n  \"slug\": \"kg-note-method-obsidian\",\n  \"version\": \"3.23.0\",\n  \"publishedAt\": 1778326970060\n}"},{"path":"references/yaml-parsing-pitfalls.md","content":"# YAML Frontmatter Parsing Pitfalls\r\n\r\n## The `body_start` Offset Bug (discovered 2026-05-09)\r\n\r\n**Symptom:** YAML validator reports `STRAY_FM_CLOSE: body contains '---'` on a clean file, or body content is shifted/includes the closing `---` delimiter.\r\n\r\n**Root cause:** Using `.lstrip('\\n')` on `raw[3:]` changes the offset, then `close_idx = rest.find('\\n---')` returns an index relative to the stripped string, but `body_start = close_idx + 5` tries to use it on the original `raw` string. The lstrip shifts everything.\r\n\r\n**Bad pattern (DO NOT USE):**\r\n```python\r\nrest = raw[3:].lstrip('\\n')          # offset shifted by stripping\r\nend_idx = rest.find('\\n---')          # index relative to stripped string\r\nyaml_block = rest[:end_idx].strip()   # OK for parsing YAML\r\nbody_start = end_idx + 5              # WRONG: end_idx is in stripped space, not raw\r\nbody_raw = raw[body_start:]           # WRONG: starts too early or in wrong place\r\n```\r\n\r\n**Correct pattern:**\r\n```python\r\nclose_idx = raw.find('\\n---', 3)      # always search in raw, skip first 3 chars (---)\r\nif close_idx == -1:\r\n    return errors\r\nyaml_block = raw[3:close_idx].strip() # YAML content\r\nbody_raw = raw[close_idx + 5:]        # +5 skips \\n---\\n, correct because close_idx is in raw\r\n```\r\n\r\n**Key insight:** Always search for the closing `---` delimiter in the original `raw` string, not in a `lstrip()`-ed copy. The `\\n---` sequence is deterministic (it's `\\n` + `---` + `\\n`), so `close_idx + 5` is correct when operating on the original string.\r\n\r\n## Common `tag:` vs `tags:` Typo\r\n\r\nSeveral notes in the vault use `tag:` (singular, missing 's') instead of `tags:`. The yaml-validator now detects this with `TAG_VS_TAGS` error.\r\n\r\n**Detection logic:**\r\n```python\r\nif 'tag' in fields and 'tags' not in fields:\r\n    errors.append(\"TAG_VS_TAGS: frontmatter has 'tag:' — did you mean 'tags:'?\")\r\n```\r\n\r\n## Agent Memory Frontmatter Rules\r\n\r\nAgent memory fragments (`agent memory/` directory) have special rules:\r\n- No `type:` field (use `tags:` instead)\r\n- No `[[links]]` in frontmatter\r\n- No `related_fragments` field (use `project:` grouping)\r\n- Must have `summary:` field with `importance:` rating\r\n\r\nThese are enforced by `yaml-validator.py` and should not be overridden."},{"path":"skill-card.md","content":"## Description:\n\nOrganizes Obsidian vault notes with the KG note method by classifying note types, normalizing naming and links, deduplicating relationships, and preparing checklist-driven corrections and enrichments.\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\nObsidian users and agents use this skill to inspect, reorganize, and enrich Markdown vault notes into KG-style concept, object, skill, and relation notes. It is intended for checklist-driven note maintenance, relationship cleanup, YAML validation, and controlled vault edits.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The skill can directly modify, rename, delete, and enrich Obsidian vault notes.\n\nMitigation: Use the explicit kg 检查 preview flow before applying changes, keep vault backups, and review generated execution checklists before file edits.\n\nRisk: File operations could affect notes outside the intended workspace if the working path is too broad.\n\nMitigation: Restrict the working path to the intended Obsidian vault and verify checklist files are created under that vault's _working directory.\n\nRisk: Enrichment can append externally sourced or unreviewed content to notes.\n\nMitigation: Preview enrichment output with --stdout and review external search results before appending them to vault files.\n\n## Reference(s):\n\n- [YAML Frontmatter Parsing Pitfalls](references/yaml-parsing-pitfalls.md)\n- [ClawHub skill page](https://clawhub.ai/realpda/skills/kg-note-method-obsidian)\n- [Publisher profile](https://clawhub.ai/user/realpda)\n\n## Skill Output:\n\n**Output Type(s):** [text, markdown, code, shell commands, configuration, guidance]\n\n**Output Format:** [Markdown notes and checklists with inline shell commands and Python helper script guidance]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [May create, modify, rename, delete, validate, or enrich Obsidian Markdown files in the selected vault.]\n\n## Skill Version(s):\n\n3.23.0 (source: evidence.release and artifact 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":"Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载 Skill: Kg Note Method Obsidian Owner: realpda Summary: Obsidian笔记库按KG笔记法整理——四种笔记类型、链接权限、关系中转、命名规范、新旧分离。自动纠错+建关系+去重+补缺+无关内容分离+分层加载 Tags: kg-notes:1.5.0, knowledge-graph:1.5.0, latest:3.23.0, note-organization:1.5.0, obsidian:1.5.0 Version history: v3.23.0 | 2026-05-09T11:42:50.060Z | user 回退v3.22.0: 撤销'分支模式'和'直接跳到执行阶段'改动, 回到v3.21.0状态 v3.22.0 | 2026-05-09T11:39:38.178Z | user 手动命令区分支模式(直接执行/分析); 步0有同名可续接清单→直接跳到执行阶段(不重复","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":982,"uniquenessScore":50,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-10T10:19:38.179Z","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-10T10:19:38.179Z","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-10T13:30:20.715Z","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"}]}}}